From 0cddb08e608ffa99c1c70147679967a549a30dc2 Mon Sep 17 00:00:00 2001 From: Scratchcat1 Date: Thu, 18 Jan 2018 18:53:34 +0000 Subject: [PATCH] Add files via upload -General bug fixes and improvements -NoFlyZoneGrapher now correctly converts NoFlyZones to the costs on the graphs, cleaning up removed NoFlyZones. Additionally the memory usage of the program has decreased, see AATC_Config NoFlyZoneGrapher for more. --- AATC_AStar.py | 3 + AATC_Config.py | 4 + AATC_DB.py | 2 +- AATC_Drone_Logic.py | 4 +- AATC_GPIO.py | 4 +- AATC_NoFlyZoneGrapher.py | 33 +- AATC_Server_002.py | 8 +- AATC_Server_Starter.py | 2 +- CAStar/AATC_Monitor_Viewer.c | 18037 ++++++++++++++++ CAStar/AATC_Monitor_Viewer.html | 10392 +++++++++ CAStar/AATC_Monitor_Viewer.pyx | 375 + CAStar/AATC_Monitor_Viewer.so | Bin 0 -> 354848 bytes CAStar/CAStar.c | 2274 +- CAStar/CAStar.html | 2058 +- CAStar/CAStar.pyd | Bin 0 -> 151577 bytes CAStar/CAStar.pyx | 16 +- CAStar/CAStar.so | Bin 119216 -> 122796 bytes CAStar/__init__.py | 2 +- CAStar/__pycache__/__init__.cpython-34.pyc | Bin 0 -> 134 bytes CAStar/__pycache__/__init__.cpython-36.pyc | Bin 0 -> 153 bytes PriorityQueue/CAStar.so | Bin 0 -> 58300 bytes PriorityQueue/COMPILE WINDOWS.txt | 4 + PriorityQueue/PriorityQueue.py | 14 +- PriorityQueue/PriorityQueueC.c | 328 +- PriorityQueue/PriorityQueueC.html | 232 +- PriorityQueue/PriorityQueueC.pyd | Bin 0 -> 83565 bytes PriorityQueue/PriorityQueueC.pyx | 14 +- PriorityQueue/__init__.py | 2 +- .../__pycache__/PriorityQueue.cpython-33.pyc | Bin 0 -> 2075 bytes .../__pycache__/PriorityQueue.cpython-34.pyc | Bin 0 -> 1434 bytes .../__pycache__/PriorityQueue.cpython-35.pyc | Bin 0 -> 1418 bytes .../__pycache__/PriorityQueue.cpython-36.pyc | Bin 0 -> 1313 bytes .../__pycache__/__init__.cpython-33.pyc | Bin 0 -> 141 bytes .../__pycache__/__init__.cpython-34.pyc | Bin 0 -> 141 bytes .../__pycache__/__init__.cpython-35.pyc | Bin 0 -> 129 bytes .../__pycache__/__init__.cpython-36.pyc | Bin 0 -> 174 bytes 36 files changed, 31673 insertions(+), 2135 deletions(-) create mode 100644 CAStar/AATC_Monitor_Viewer.c create mode 100644 CAStar/AATC_Monitor_Viewer.html create mode 100644 CAStar/AATC_Monitor_Viewer.pyx create mode 100644 CAStar/AATC_Monitor_Viewer.so create mode 100644 CAStar/CAStar.pyd create mode 100644 CAStar/__pycache__/__init__.cpython-34.pyc create mode 100644 CAStar/__pycache__/__init__.cpython-36.pyc create mode 100644 PriorityQueue/CAStar.so create mode 100644 PriorityQueue/COMPILE WINDOWS.txt create mode 100644 PriorityQueue/PriorityQueueC.pyd create mode 100644 PriorityQueue/__pycache__/PriorityQueue.cpython-33.pyc create mode 100644 PriorityQueue/__pycache__/PriorityQueue.cpython-34.pyc create mode 100644 PriorityQueue/__pycache__/PriorityQueue.cpython-35.pyc create mode 100644 PriorityQueue/__pycache__/PriorityQueue.cpython-36.pyc create mode 100644 PriorityQueue/__pycache__/__init__.cpython-33.pyc create mode 100644 PriorityQueue/__pycache__/__init__.cpython-34.pyc create mode 100644 PriorityQueue/__pycache__/__init__.cpython-35.pyc create mode 100644 PriorityQueue/__pycache__/__init__.cpython-36.pyc diff --git a/AATC_AStar.py b/AATC_AStar.py index 617d242..5a5b1e0 100644 --- a/AATC_AStar.py +++ b/AATC_AStar.py @@ -50,6 +50,9 @@ def Size(self,xSize,ySize,zSize): def Get_Size(self): return self._xSize, self._ySize, self._zSize + + def Get_Count(self): + return self._xCount, self._yCount, self._zCount def add_node(self,node): self._Nodes[node.Get_NodeID()] = node diff --git a/AATC_Config.py b/AATC_Config.py index 798567d..6404266 100644 --- a/AATC_Config.py +++ b/AATC_Config.py @@ -39,6 +39,10 @@ #Control at which setting the server will raise an error if the cost for entering that node sector exceeds value. To prevent selecting a blocked node as a target node to bypass search algorithm. NOFLYZONE_THRESHOLD_COST = 50 +#NoFlyZoneGrapher +NOFLYZONEGRAPHER_FLUSH_GRAPH_NUMBER = 50000 # This controls how frequently while generating the new node costs the no fly zone grapher should flush the graph to reduce memoryu usage. + #OWM Controls ENABLE_FINE_SPEED_ESTIMATION = False #Allows fine grained estimation of drone speed due to wind. Noticable slowdown when creating flight due to many requests which may be limited by OWM depending on contract OWM_SLEEP_TIME = 1/60*60*4 # How long the add flight program should sleep between requests to reduce the chance of overusing requests. 1/REQUESTS_PER_MINUTE*60*NUMBER_OF_CONCURRENT_SEARCHES should ensure that the program never hits the limit of OWM. +OWM_API_KEY = '5b943c4857a45d75ef7ee9b301666fa8' #Contains the API key for the OWM diff --git a/AATC_DB.py b/AATC_DB.py index eb27682..c1c6da9 100644 --- a/AATC_DB.py +++ b/AATC_DB.py @@ -50,7 +50,7 @@ def __init__(self): def Exit(self): self._db_con.close() def Table_Headers(self,TableName): - self._cur_header.execute("SHOW COLUMNS FROM %s",( TableName)) + self._cur_header.execute("SHOW COLUMNS FROM "+ TableName) # Cannot use placeholders when referencing the table name , syntax error result = self._cur_header.fetchall() Headers = [] for item in result: diff --git a/AATC_Drone_Logic.py b/AATC_Drone_Logic.py index a5d994c..b0d2b31 100644 --- a/AATC_Drone_Logic.py +++ b/AATC_Drone_Logic.py @@ -65,7 +65,7 @@ def CheckForFlight(self): FlightID = FlightID[0][0] print("Obtaining flight and drone information. FlightID :",FlightID) - DroneInfo, Flight, Waypoints = GetAllFlightInfo(self._D,self._DroneID,FlightID) + DroneInfo, Flight, Waypoints = GetAllFlightInfo(self._D,FlightID) self._FlightQueue.put((False,(DroneInfo,Flight,Waypoints))) @@ -91,7 +91,7 @@ def RunFlight(self): -def GetAllFlightInfo(D,DRONEID,FlightID): #Gets all drone flight information and packages the information into objects +def GetAllFlightInfo(D,FlightID): #Gets all drone flight information and packages the information into objects DSucess,DroneMessage,DroneData = D.DroneGetDroneInfo() FSucess,FlightMessage,FlightData = D.GetFlight(FlightID) WSucess,WaypointsMessage,FlightWaypointsData = D.GetFlightWaypoints(FlightID) diff --git a/AATC_GPIO.py b/AATC_GPIO.py index 9b5da9a..baafe12 100644 --- a/AATC_GPIO.py +++ b/AATC_GPIO.py @@ -42,7 +42,7 @@ def GPIO_Thread(Thread_Name,GPIO_Queue): if not Repeat: Function,FuncArgs = BlankFunction,() #Resets commands. Allows function to exit itself. - if not GPIO_Queue.empty(): + while not GPIO_Queue.empty(): #While loop implemented so that if many commands are send per loop they will all be processed. Data = GPIO_Queue.get() #GPIO_Queue.task_done() Command,Arguments = Data[0],Data[1] @@ -133,7 +133,7 @@ def Main(self): self.Reset(*Args) else: - self.PassData(Request[0],(Request[1],Request[2])) + self.PassData(Request[0],Request[1:]) except Exception as e: diff --git a/AATC_NoFlyZoneGrapher.py b/AATC_NoFlyZoneGrapher.py index f84ac13..155a60a 100644 --- a/AATC_NoFlyZoneGrapher.py +++ b/AATC_NoFlyZoneGrapher.py @@ -1,5 +1,8 @@ -import AATC_DB,AATC_AStar,ast,time -from AATC_Coordinate import * +import AATC_DB,AATC_AStar,ast,time,AATC_Config,AATC_Coordinate + +def NoFlyZoneGrapher_Launch(Thread_Name,Thread_Queue,Interval = 36000): + NFZG = NoFlyZoneGrapher(Thread_Name,Thread_Queue,Interval) + NFZG.Main_Loop() class NoFlyZoneGrapher: """ Selects all NoFlyZones, calculates the nodes which they correspond to and modifies the cost of those nodes @@ -8,7 +11,7 @@ class NoFlyZoneGrapher: Then for all nodes, the node is loaded, cost modified Then graph is saved Repeats every interval seconds. - Must load entire graph and all NoFlyZones at once as if a NoFlyZone is removed there may be other smaller NoFlyZones which affect the cost of the node. + Must load entire graph and all NoFlyZones at once as if a NoFlyZone is removed there may be other smaller NoFlyZones which affect the cost of the node. #DEALT WITH , DONE IN GROUPS Very RAM intensive. Could be run on a different device and update via a network share. Could use an A/B method to update if file locking occurs where the Updating takes place on one set of data while the other set of data is read from by eg A* pathfinding @@ -24,7 +27,7 @@ def __init__(self,Thread_Name,Thread_Queue,Interval = 36000): self._xSize,self._ySize,self._zSize = graph.Get_Size() del graph - self.Main_Loop() + def Main_Loop(self): self._Exit = False @@ -69,8 +72,8 @@ def GetNoFlyZones(self): for line in Data: #Converts each line into a dict with the column name as a key lineDict = { "ZoneID":line[ZoneIDIndex], - "StartCoord":Coordinate(*ast.literal_eval(line[StartCoordIndex])), - "EndCoord":Coordinate(*ast.literal_eval(line[EndCoordIndex])), + "StartCoord":AATC_Coordinate.Coordinate(*ast.literal_eval(line[StartCoordIndex])), + "EndCoord":AATC_Coordinate.Coordinate(*ast.literal_eval(line[EndCoordIndex])), "Level":line[LevelIndex], "OwnerUserID":line[OwnerUserIDIndex]} ProcessedData.append(lineDict) #Also turns sthe coords into objects rather than strings @@ -99,20 +102,28 @@ def Make_Values(self,NoFlyZoneData,ABSlot = 1): Values[NodeID] = v #This gets the maximum cost for that node - ######MODIFY TO BE OK - graph.Node_Cache = {} #Reduces memory usage. +## ######MODIFY TO BE OK +## graph.Node_Cache = {} #Reduces memory usage. + graph.FlushGraph() #Reduces memory usage by removing the Node_Caches - print("[NoFlyZoneGrapher] Length of Values:",len(Values)) - for NodeID in list(Values.keys()): #CHECK THIS. Only using those involved with a new no fly zone may cause issues if a no fly zone was removed. Maybe should be set to all node IDs. + for NodeID in graph.All_NodeIDs(): #CHECK THIS. Only using those involved with a new no fly zone may cause issues if a no fly zone was removed. Maybe should be set to all node IDs. node = graph.GetNode(NodeID) if node.Get_NodeID() in Values: node.Set_Cost( Values[node.Get_NodeID()]) Values.pop(node.Get_NodeID())# Reduce memory usage by evicting Node values which have been added already else: node.Set_Cost(1) + if NodeID % AATC_Config.NOFLYZONEGRAPHER_FLUSH_GRAPH_NUMBER == 0: #Every N nodes the program will save the current nodes and remove them from memory + try: + graph.SaveNodes([graph.CurrentFolderName()]) #Ensures any loaded nodes are saved. As all nodes in a block are loaded , entire blocks are saved thus no nodes are lost. + except Exception as e: + print("Error saving nodes",e," Most likely no NoFlyZoneData yet") + graph.FlushGraph() #The graph nodes are then emptied to reduce memory usage. + #print("Processede block to ",NodeID) + try: - graph.SaveNodes([graph.CurrentFolderName()]) + graph.SaveNodes([graph.CurrentFolderName()]) #Saves any last nodes. except Exception as e: print("Error saving nodes",e," Most likely no NoFlyZoneData yet") diff --git a/AATC_Server_002.py b/AATC_Server_002.py index f6835e0..aac6c27 100644 --- a/AATC_Server_002.py +++ b/AATC_Server_002.py @@ -368,7 +368,7 @@ def AddFlight(self,Arguments): DroneSpeed,DroneRange = DroneData[SpeedIndex],DroneData[RangeIndex] Weather_Estimator = AATC_Weather.OWM_Control() - Estimated_Drone_Speed = Weather_Estimator.Get_Ajusted_Speed(CoordList[0]["Coords"],CoordList[-1]["Coords"],DroneSpeed,Time) + Estimated_Drone_Speed = Weather_Estimator.Get_Adjusted_Speed(CoordList[0]["Coords"],CoordList[-1]["Coords"],DroneSpeed,Time) TotalDistance = 0 for x in range(len(CoordList)): if x != 0: #If not first Coord add the difference in distance to time etc @@ -376,7 +376,7 @@ def AddFlight(self,Arguments): TotalDistance += Distance if AATC_Config.ENABLE_FINE_SPEED_ESTIMATION: - Estimated_Drone_Speed = Weather_Estimator.Get_Ajusted_Speed(CoordList[x]["Coords"],CoordList[x-1]["Coords"],DroneSpeed,Time) + Estimated_Drone_Speed = Weather_Estimator.Get_Adjusted_Speed(CoordList[x]["Coords"],CoordList[x-1]["Coords"],DroneSpeed,Time) time.sleep(AATC_Config.OWM_SLEEP_TIME) DeltaTime = Distance/Estimated_Drone_Speed Time = Time + DeltaTime @@ -498,12 +498,12 @@ def Main(self,Command,Arguments): except Exception as e: Sucess,Message,Data = False,"An Error occured"+str(e),[] - print("Error occured with UserID:",str(self._ClientID),". Error :",str(e),". Sending failure message") + print("Error occured with ",self._Thread_Name,". Error :",str(e),". Sending failure message") try: self.Send((Sucess,Message,Data)) except Exception as e: - print("Error sending message back to chat",e) + print(self._Thread_Name,"Error sending message back to chat",e) self._DB.Exit() diff --git a/AATC_Server_Starter.py b/AATC_Server_Starter.py index a8d4fd1..392b557 100644 --- a/AATC_Server_Starter.py +++ b/AATC_Server_Starter.py @@ -175,7 +175,7 @@ def StartProcesses(Control_Queue): Control_Queue.put(("Controller","Create_Process",("DSpawner",ProcessSpawner,(8002,"Drone",MakeDroneConnection)))) - Control_Queue.put(("Controller","Create_Process",("Grapher",AATC_NoFlyZoneGrapher.NoFlyZoneGrapher))) + Control_Queue.put(("Controller","Create_Process",("Grapher",AATC_NoFlyZoneGrapher.NoFlyZoneGrapher_Launch))) Control_Queue.put(("Controller","Create_Process",("Cleaner",AATC_Server.Cleaner))) Control_Queue.put(("Controller","Create_Process",("Hedabot",HedaBot.TelebotLaunch,()))) diff --git a/CAStar/AATC_Monitor_Viewer.c b/CAStar/AATC_Monitor_Viewer.c new file mode 100644 index 0000000..33c7188 --- /dev/null +++ b/CAStar/AATC_Monitor_Viewer.c @@ -0,0 +1,18037 @@ +/* Generated by Cython 0.26 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_26" +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && PY_VERSION_HEX >= 0x02070000) + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#if PY_VERSION_HEX < 0x030700A0 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject **args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#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_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #ifdef __cplusplus + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) || (defined(__GNUC__) && defined(__attribute__)) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + + +#define __PYX_ERR(f_index, lineno, Ln_error) \ +{ \ + __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ +} + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__CAStar__AATC_Monitor_Viewer +#define __PYX_HAVE_API__CAStar__AATC_Monitor_Viewer +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 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))) ) +#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) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "AATC_Monitor_Viewer.pyx", +}; + +/*--- Type declarations ---*/ +struct __pyx_ctuple_long__and_long__and_long; +typedef struct __pyx_ctuple_long__and_long__and_long __pyx_ctuple_long__and_long__and_long; + +/* "CAStar/AATC_Monitor_Viewer.pyx":82 + * self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom) + * + * def CameraWipe(self,Colour = (0,0,0)): # <<<<<<<<<<<<<< + * self.gameDisplay.fill(Colour) + * def ResetDrawObject(self): + */ +struct __pyx_ctuple_long__and_long__and_long { + long f0; + long f1; + long f2; +}; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* GetModuleGlobalName.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectCallNoArg.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static CYTHON_INLINE 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); + +/* 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) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_setattro)) + return tp->tp_setattro(obj, attr_name, value); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_setattr)) + return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); +#endif + return PyObject_SetAttr(obj, attr_name, value); +} +#else +#define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + Py_SIZE(list) = len+1; + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* PyObjectCallMethod1.proto */ +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +/* append.proto */ +static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x); + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); + +/* CythonFunction.proto */ +#define __Pyx_CyFunction_USED 1 +#include +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_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 { + PyCFunctionObject func; +#if PY_VERSION_HEX < 0x030500A0 + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; + PyObject *func_classobj; + void *defaults; + int defaults_pyobjects; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; +} __pyx_CyFunctionObject; +static PyTypeObject *__pyx_CyFunctionType = 0; +#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\ + __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code) +static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *self, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(void); + +/* CalculateMetaclass.proto */ +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); + +/* Py3ClassCreate.proto */ +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, + PyObject *mkw, PyObject *modname, PyObject *doc); +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, + PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* StrEquals.proto */ +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals +#else +#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = PyThreadState_GET(); +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#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 + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* 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 + +/* CLineInTraceback.proto */ +static int __Pyx_CLineForTraceback(int c_line); + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* Print.proto */ +static int __Pyx_Print(PyObject*, PyObject *, int); +#if CYTHON_COMPILING_IN_PYPY || PY_MAJOR_VERSION >= 3 +static PyObject* __pyx_print = 0; +static PyObject* __pyx_print_kwargs = 0; +#endif + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* ToPyCTupleUtility.proto */ +static PyObject* __pyx_convert__to_py___pyx_ctuple_long__and_long__and_long(__pyx_ctuple_long__and_long__and_long); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* PrintOne.proto */ +static int __Pyx_PrintOne(PyObject* stream, PyObject *o); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + + +/* Module declarations from 'CAStar.AATC_Monitor_Viewer' */ +static int __pyx_f_6CAStar_19AATC_Monitor_Viewer_MaxLimit(int, int); /*proto*/ +#define __Pyx_MODULE_NAME "CAStar.AATC_Monitor_Viewer" +int __pyx_module_is_main_CAStar__AATC_Monitor_Viewer = 0; + +/* Implementation of 'CAStar.AATC_Monitor_Viewer' */ +static PyObject *__pyx_builtin_input; +static const char __pyx_k_B[] = " B:"; +static const char __pyx_k_D[] = "D:"; +static const char __pyx_k_F[] = "F:"; +static const char __pyx_k_L[] = " L:"; +static const char __pyx_k_M[] = "M"; +static const char __pyx_k_N[] = " N:"; +static const char __pyx_k_U[] = " U:"; +static const char __pyx_k_W[] = " W:"; +static const char __pyx_k_Y[] = "Y"; +static const char __pyx_k_Z[] = "Z:"; +static const char __pyx_k_e[] = "e"; +static const char __pyx_k_x[] = "x"; +static const char __pyx_k_y[] = "y"; +static const char __pyx_k_AA[] = "AA"; +static const char __pyx_k_IP[] = "IP"; +static const char __pyx_k_ST[] = "ST:"; +static const char __pyx_k__2[] = ""; +static const char __pyx_k__6[] = " "; +static const char __pyx_k_D_2[] = " D:"; +static const char __pyx_k_ETA[] = "ETA"; +static const char __pyx_k_FPS[] = "FPS:"; +static const char __pyx_k_K_a[] = "K_a"; +static const char __pyx_k_K_d[] = "K_d"; +static const char __pyx_k_K_e[] = "K_e"; +static const char __pyx_k_K_q[] = "K_q"; +static const char __pyx_k_K_s[] = "K_s"; +static const char __pyx_k_K_w[] = "K_w"; +static const char __pyx_k_N_2[] = "N"; +static const char __pyx_k_ast[] = "ast"; +static const char __pyx_k_doc[] = "__doc__"; +static const char __pyx_k_end[] = "end"; +static const char __pyx_k_get[] = "get"; +static const char __pyx_k_key[] = "key"; +static const char __pyx_k_pop[] = "pop"; +static const char __pyx_k_sys[] = "sys"; +static const char __pyx_k_Draw[] = "Draw"; +static const char __pyx_k_Exit[] = "Exit"; +static const char __pyx_k_Font[] = "Font"; +static const char __pyx_k_Port[] = "Port"; +static const char __pyx_k_PosX[] = "PosX"; +static const char __pyx_k_PosY[] = "PosY"; +static const char __pyx_k_QUIT[] = "QUIT"; +static const char __pyx_k_Size[] = "Size"; +static const char __pyx_k_Text[] = "Text"; +static const char __pyx_k_Type[] = "Type"; +static const char __pyx_k_Zini[] = "Zini"; +static const char __pyx_k_Zone[] = "Zone"; +static const char __pyx_k_Zoom[] = "Zoom"; +static const char __pyx_k_blit[] = "blit"; +static const char __pyx_k_copy[] = "copy"; +static const char __pyx_k_exit[] = "exit"; +static const char __pyx_k_file[] = "file"; +static const char __pyx_k_fill[] = "fill"; +static const char __pyx_k_flip[] = "flip"; +static const char __pyx_k_font[] = "font"; +static const char __pyx_k_init[] = "init"; +static const char __pyx_k_keys[] = "keys"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_quit[] = "quit"; +static const char __pyx_k_self[] = "self"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_text[] = "text"; +static const char __pyx_k_tick[] = "tick"; +static const char __pyx_k_time[] = "time"; +static const char __pyx_k_type[] = "type"; +static const char __pyx_k_Clock[] = "Clock"; +static const char __pyx_k_Coord[] = "Coord"; +static const char __pyx_k_Drone[] = "Drone"; +static const char __pyx_k_ETA_2[] = "ETA:"; +static const char __pyx_k_Get_X[] = "Get_X"; +static const char __pyx_k_Get_Y[] = "Get_Y"; +static const char __pyx_k_Get_Z[] = "Get_Z"; +static const char __pyx_k_Level[] = "Level"; +static const char __pyx_k_Login[] = "Login"; +static const char __pyx_k_Set_X[] = "Set_X"; +static const char __pyx_k_Set_Y[] = "Set_Y"; +static const char __pyx_k_clock[] = "clock"; +static const char __pyx_k_event[] = "event"; +static const char __pyx_k_fonts[] = "_fonts"; +static const char __pyx_k_image[] = "image"; +static const char __pyx_k_index[] = "index"; +static const char __pyx_k_input[] = "input"; +static const char __pyx_k_print[] = "print"; +static const char __pyx_k_texts[] = "_texts"; +static const char __pyx_k_upper[] = "upper"; +static const char __pyx_k_width[] = "width"; +static const char __pyx_k_xSize[] = "xSize"; +static const char __pyx_k_ySize[] = "ySize"; +static const char __pyx_k_Amount[] = "Amount"; +static const char __pyx_k_Camera[] = "Camera"; +static const char __pyx_k_Colour[] = "Colour"; +static const char __pyx_k_Coords[] = "Coords"; +static const char __pyx_k_Flight[] = "Flight"; +static const char __pyx_k_Object[] = "Object"; +static const char __pyx_k_Sprite[] = "Sprite"; +static const char __pyx_k_Sucess[] = "Sucess"; +static const char __pyx_k_UserID[] = "UserID"; +static const char __pyx_k_ZoneID[] = "ZoneID"; +static const char __pyx_k_append[] = "append"; +static const char __pyx_k_height[] = "height"; +static const char __pyx_k_images[] = "_images"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_init_2[] = "__init__"; +static const char __pyx_k_module[] = "__module__"; +static const char __pyx_k_pygame[] = "pygame"; +static const char __pyx_k_random[] = "random"; +static const char __pyx_k_render[] = "render"; +static const char __pyx_k_result[] = "result"; +static const char __pyx_k_sample[] = "sample"; +static const char __pyx_k_sprite[] = "sprite"; +static const char __pyx_k_xpixel[] = "xpixel"; +static const char __pyx_k_ypixel[] = "ypixel"; +static const char __pyx_k_CameraX[] = "CameraX"; +static const char __pyx_k_CameraY[] = "CameraY"; +static const char __pyx_k_Columns[] = "Columns"; +static const char __pyx_k_DroneID[] = "DroneID"; +static const char __pyx_k_EndTime[] = "EndTime"; +static const char __pyx_k_GetFont[] = "GetFont"; +static const char __pyx_k_GetText[] = "GetText"; +static const char __pyx_k_GetZoom[] = "GetZoom"; +static const char __pyx_k_KEYDOWN[] = "KEYDOWN"; +static const char __pyx_k_K_SPACE[] = "K_SPACE"; +static const char __pyx_k_Message[] = "Message"; +static const char __pyx_k_SetZoom[] = "SetZoom"; +static const char __pyx_k_Sprites[] = "Sprites"; +static const char __pyx_k_Surface[] = "Surface"; +static const char __pyx_k_convert[] = "convert"; +static const char __pyx_k_display[] = "display"; +static const char __pyx_k_get_fps[] = "get_fps"; +static const char __pyx_k_prepare[] = "__prepare__"; +static const char __pyx_k_pressed[] = "pressed"; +static const char __pyx_k_refresh[] = "refresh"; +static const char __pyx_k_Distance[] = "Distance"; +static const char __pyx_k_ETAIndex[] = "ETAIndex"; +static const char __pyx_k_EndCoord[] = "EndCoord"; +static const char __pyx_k_EndPoint[] = "EndPoint"; +static const char __pyx_k_Exit_Y_N[] = "Exit? Y/N"; +static const char __pyx_k_FlightID[] = "FlightID"; +static const char __pyx_k_GetImage[] = "GetImage"; +static const char __pyx_k_Waypoint[] = "Waypoint"; +static const char __pyx_k_ZoneList[] = "ZoneList"; +static const char __pyx_k_get_size[] = "get_size"; +static const char __pyx_k_qualname[] = "__qualname__"; +static const char __pyx_k_set_mode[] = "set_mode"; +static const char __pyx_k_127_0_0_1[] = "127.0.0.1"; +static const char __pyx_k_DroneList[] = "DroneList"; +static const char __pyx_k_DroneName[] = "DroneName"; +static const char __pyx_k_DronesAll[] = "DronesAll"; +static const char __pyx_k_EndCoords[] = "EndCoords"; +static const char __pyx_k_ForceDraw[] = "ForceDraw"; +static const char __pyx_k_Get_Coord[] = "Get_Coord"; +static const char __pyx_k_Get_XSize[] = "Get_XSize"; +static const char __pyx_k_Get_YSize[] = "Get_YSize"; +static const char __pyx_k_Make_Text[] = "Make_Text"; +static const char __pyx_k_MaxCoords[] = "MaxCoords"; +static const char __pyx_k_MinCoords[] = "MinCoords"; +static const char __pyx_k_MonCamera[] = "MonCamera"; +static const char __pyx_k_NoFlyZone[] = "NoFlyZone"; +static const char __pyx_k_Set_XSize[] = "Set_XSize"; +static const char __pyx_k_Set_YSize[] = "Set_YSize"; +static const char __pyx_k_StartTime[] = "StartTime"; +static const char __pyx_k_font_size[] = "font_size"; +static const char __pyx_k_metaclass[] = "__metaclass__"; +static const char __pyx_k_CameraEndX[] = "CameraEndX"; +static const char __pyx_k_CameraEndY[] = "CameraEndY"; +static const char __pyx_k_CameraWipe[] = "CameraWipe"; +static const char __pyx_k_CameraZoom[] = "CameraZoom"; +static const char __pyx_k_CoordIndex[] = "CoordIndex"; +static const char __pyx_k_Coordinate[] = "Coordinate"; +static const char __pyx_k_DrawObject[] = "DrawObject"; +static const char __pyx_k_FlightList[] = "FlightList"; +static const char __pyx_k_FlightsAll[] = "FlightsAll"; +static const char __pyx_k_Get_Coords[] = "Get_Coords"; +static const char __pyx_k_LastCoords[] = "LastCoords"; +static const char __pyx_k_LevelIndex[] = "LevelIndex"; +static const char __pyx_k_Make_Image[] = "Make_Image"; +static const char __pyx_k_NoFlyZones[] = "NoFlyZones"; +static const char __pyx_k_SpriteList[] = "SpriteList"; +static const char __pyx_k_StartCoord[] = "StartCoord"; +static const char __pyx_k_StartPoint[] = "StartPoint"; +static const char __pyx_k_CameraCoord[] = "CameraCoord"; +static const char __pyx_k_CameraXSize[] = "CameraXSize"; +static const char __pyx_k_CameraYSize[] = "CameraYSize"; +static const char __pyx_k_Camera_Draw[] = "Camera.Draw"; +static const char __pyx_k_CoordObject[] = "CoordObject"; +static const char __pyx_k_DrawObjects[] = "DrawObjects"; +static const char __pyx_k_LastBattery[] = "LastBattery"; +static const char __pyx_k_MakeSprites[] = "MakeSprites"; +static const char __pyx_k_RawZoneList[] = "RawZoneList"; +static const char __pyx_k_StartCoords[] = "StartCoords"; +static const char __pyx_k_UserIDIndex[] = "UserIDIndex"; +static const char __pyx_k_ZoneIDIndex[] = "ZoneIDIndex"; +static const char __pyx_k_gameDisplay[] = "gameDisplay"; +static const char __pyx_k_get_pressed[] = "get_pressed"; +static const char __pyx_k_AATC_Monitor[] = "AATC_Monitor"; +static const char __pyx_k_BatteryIndex[] = "BatteryIndex"; +static const char __pyx_k_DroneIDIndex[] = "DroneIDIndex"; +static const char __pyx_k_EndTimeIndex[] = "EndTimeIndex"; +static const char __pyx_k_GetDronesAll[] = "GetDronesAll"; +static const char __pyx_k_RawDroneList[] = "RawDroneList"; +static const char __pyx_k_WaypointList[] = "WaypointList"; +static const char __pyx_k_WaypointsAll[] = "WaypointsAll"; +static const char __pyx_k_literal_eval[] = "literal_eval"; +static const char __pyx_k_AddDrawObject[] = "AddDrawObject"; +static const char __pyx_k_Camera___init[] = "Camera.__init__"; +static const char __pyx_k_DistanceIndex[] = "DistanceIndex"; +static const char __pyx_k_DronesMonitor[] = "DronesMonitor"; +static const char __pyx_k_EndCoordIndex[] = "EndCoordIndex"; +static const char __pyx_k_FlightIDIndex[] = "FlightIDIndex"; +static const char __pyx_k_GetFlightsAll[] = "GetFlightsAll"; +static const char __pyx_k_GetNoFlyZones[] = "GetNoFlyZones"; +static const char __pyx_k_Object_Coords[] = "Object_Coords"; +static const char __pyx_k_RawFlightList[] = "RawFlightList"; +static const char __pyx_k_Refresh_Delay[] = "Refresh_Delay"; +static const char __pyx_k_Camera_GetZoom[] = "Camera.GetZoom"; +static const char __pyx_k_Camera_SetZoom[] = "Camera.SetZoom"; +static const char __pyx_k_Camera_details[] = "Camera details"; +static const char __pyx_k_DroneNameIndex[] = "DroneNameIndex"; +static const char __pyx_k_EndCoordsIndex[] = "EndCoordsIndex"; +static const char __pyx_k_FlightsMonitor[] = "FlightsMonitor"; +static const char __pyx_k_Monitor_Sprite[] = "Monitor_Sprite"; +static const char __pyx_k_Refreshed_data[] = "Refreshed data"; +static const char __pyx_k_StartTimeIndex[] = "StartTimeIndex"; +static const char __pyx_k_WaypointNumber[] = "WaypointNumber"; +static const char __pyx_k_fontParameters[] = "fontParameters"; +static const char __pyx_k_AATC_Coordinate[] = "AATC_Coordinate"; +static const char __pyx_k_GetCameraCoords[] = "GetCameraCoords"; +static const char __pyx_k_MOUSEBUTTONDOWN[] = "MOUSEBUTTONDOWN"; +static const char __pyx_k_MakeZoneSprites[] = "MakeZoneSprites"; +static const char __pyx_k_RawWaypointList[] = "RawWaypointList"; +static const char __pyx_k_Refreshing_data[] = "Refreshing data"; +static const char __pyx_k_ResetDrawObject[] = "ResetDrawObject"; +static const char __pyx_k_SetCameraCoords[] = "SetCameraCoords"; +static const char __pyx_k_StartCoordIndex[] = "StartCoordIndex"; +static const char __pyx_k_Camera_Get_Coord[] = "Camera.Get_Coord"; +static const char __pyx_k_GetMonitorDrones[] = "GetMonitorDrones"; +static const char __pyx_k_MakeDroneSprites[] = "MakeDroneSprites"; +static const char __pyx_k_StartCoordsIndex[] = "StartCoordsIndex"; +static const char __pyx_k_UpdateCameraSize[] = "UpdateCameraSize"; +static const char __pyx_k_WaypointsMonitor[] = "WaypointsMonitor"; +static const char __pyx_k_Camera_CameraWipe[] = "Camera.CameraWipe"; +static const char __pyx_k_GetMonitorFlights[] = "GetMonitorFlights"; +static const char __pyx_k_Last_Refresh_Time[] = "Last_Refresh_Time"; +static const char __pyx_k_MakeFlightSprites[] = "MakeFlightSprites"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_MakeWaypointSprites[] = "MakeWaypointSprites"; +static const char __pyx_k_WaypointNumberIndex[] = "WaypointNumberIndex"; +static const char __pyx_k_Camera_AddDrawObject[] = "Camera.AddDrawObject"; +static const char __pyx_k_GetFlightWaypointsAll[] = "GetFlightWaypointsAll"; +static const char __pyx_k_IncrementCameraCoordX[] = "IncrementCameraCoordX"; +static const char __pyx_k_IncrementCameraCoordY[] = "IncrementCameraCoordY"; +static const char __pyx_k_Monitor_Sprite___init[] = "Monitor_Sprite.__init__"; +static const char __pyx_k_Camera_GetCameraCoords[] = "Camera.GetCameraCoords"; +static const char __pyx_k_Camera_ResetDrawObject[] = "Camera.ResetDrawObject"; +static const char __pyx_k_Camera_SetCameraCoords[] = "Camera.SetCameraCoords"; +static const char __pyx_k_CreateMonitorInterface[] = "CreateMonitorInterface"; +static const char __pyx_k_AATC_Monitor_Viewer_pyx[] = "AATC_Monitor_Viewer.pyx"; +static const char __pyx_k_Camera_UpdateCameraSize[] = "Camera.UpdateCameraSize"; +static const char __pyx_k_Monitor_exit_was_called[] = "Monitor exit was called"; +static const char __pyx_k_Monitor_Sprite_Make_Text[] = "Monitor_Sprite.Make_Text"; +static const char __pyx_k_GetMonitorFlightWaypoints[] = "GetMonitorFlightWaypoints"; +static const char __pyx_k_Monitor_Sprite_Get_Coords[] = "Monitor_Sprite.Get_Coords"; +static const char __pyx_k_Monitor_Sprite_Make_Image[] = "Monitor_Sprite.Make_Image"; +static const char __pyx_k_CAStar_AATC_Monitor_Viewer[] = "CAStar.AATC_Monitor_Viewer"; +static const char __pyx_k_Camera_IncrementCameraCoordX[] = "Camera.IncrementCameraCoordX"; +static const char __pyx_k_Camera_IncrementCameraCoordY[] = "Camera.IncrementCameraCoordY"; +static const char __pyx_k_An_error_occured_restarting_main[] = "An error occured, restarting main loop"; +static PyObject *__pyx_kp_s_127_0_0_1; +static PyObject *__pyx_n_s_AA; +static PyObject *__pyx_n_s_AATC_Coordinate; +static PyObject *__pyx_n_s_AATC_Monitor; +static PyObject *__pyx_kp_s_AATC_Monitor_Viewer_pyx; +static PyObject *__pyx_n_s_AddDrawObject; +static PyObject *__pyx_n_s_Amount; +static PyObject *__pyx_kp_s_An_error_occured_restarting_main; +static PyObject *__pyx_kp_s_B; +static PyObject *__pyx_n_s_BatteryIndex; +static PyObject *__pyx_n_s_CAStar_AATC_Monitor_Viewer; +static PyObject *__pyx_n_s_Camera; +static PyObject *__pyx_n_s_CameraCoord; +static PyObject *__pyx_n_s_CameraEndX; +static PyObject *__pyx_n_s_CameraEndY; +static PyObject *__pyx_n_s_CameraWipe; +static PyObject *__pyx_n_s_CameraX; +static PyObject *__pyx_n_s_CameraXSize; +static PyObject *__pyx_n_s_CameraY; +static PyObject *__pyx_n_s_CameraYSize; +static PyObject *__pyx_n_s_CameraZoom; +static PyObject *__pyx_n_s_Camera_AddDrawObject; +static PyObject *__pyx_n_s_Camera_CameraWipe; +static PyObject *__pyx_n_s_Camera_Draw; +static PyObject *__pyx_n_s_Camera_GetCameraCoords; +static PyObject *__pyx_n_s_Camera_GetZoom; +static PyObject *__pyx_n_s_Camera_Get_Coord; +static PyObject *__pyx_n_s_Camera_IncrementCameraCoordX; +static PyObject *__pyx_n_s_Camera_IncrementCameraCoordY; +static PyObject *__pyx_n_s_Camera_ResetDrawObject; +static PyObject *__pyx_n_s_Camera_SetCameraCoords; +static PyObject *__pyx_n_s_Camera_SetZoom; +static PyObject *__pyx_n_s_Camera_UpdateCameraSize; +static PyObject *__pyx_n_s_Camera___init; +static PyObject *__pyx_kp_s_Camera_details; +static PyObject *__pyx_n_s_Clock; +static PyObject *__pyx_n_s_Colour; +static PyObject *__pyx_n_s_Columns; +static PyObject *__pyx_n_s_Coord; +static PyObject *__pyx_n_s_CoordIndex; +static PyObject *__pyx_n_s_CoordObject; +static PyObject *__pyx_n_s_Coordinate; +static PyObject *__pyx_n_s_Coords; +static PyObject *__pyx_n_s_CreateMonitorInterface; +static PyObject *__pyx_kp_s_D; +static PyObject *__pyx_kp_s_D_2; +static PyObject *__pyx_n_s_Distance; +static PyObject *__pyx_n_s_DistanceIndex; +static PyObject *__pyx_n_s_Draw; +static PyObject *__pyx_n_s_DrawObject; +static PyObject *__pyx_n_s_DrawObjects; +static PyObject *__pyx_n_s_Drone; +static PyObject *__pyx_n_s_DroneID; +static PyObject *__pyx_n_s_DroneIDIndex; +static PyObject *__pyx_n_s_DroneList; +static PyObject *__pyx_n_s_DroneName; +static PyObject *__pyx_n_s_DroneNameIndex; +static PyObject *__pyx_n_s_DronesAll; +static PyObject *__pyx_n_s_DronesMonitor; +static PyObject *__pyx_n_s_ETA; +static PyObject *__pyx_n_s_ETAIndex; +static PyObject *__pyx_kp_s_ETA_2; +static PyObject *__pyx_n_s_EndCoord; +static PyObject *__pyx_n_s_EndCoordIndex; +static PyObject *__pyx_n_s_EndCoords; +static PyObject *__pyx_n_s_EndCoordsIndex; +static PyObject *__pyx_n_s_EndPoint; +static PyObject *__pyx_n_s_EndTime; +static PyObject *__pyx_n_s_EndTimeIndex; +static PyObject *__pyx_n_s_Exit; +static PyObject *__pyx_kp_s_Exit_Y_N; +static PyObject *__pyx_kp_s_F; +static PyObject *__pyx_kp_s_FPS; +static PyObject *__pyx_n_s_Flight; +static PyObject *__pyx_n_s_FlightID; +static PyObject *__pyx_n_s_FlightIDIndex; +static PyObject *__pyx_n_s_FlightList; +static PyObject *__pyx_n_s_FlightsAll; +static PyObject *__pyx_n_s_FlightsMonitor; +static PyObject *__pyx_n_s_Font; +static PyObject *__pyx_n_s_ForceDraw; +static PyObject *__pyx_n_s_GetCameraCoords; +static PyObject *__pyx_n_s_GetDronesAll; +static PyObject *__pyx_n_s_GetFlightWaypointsAll; +static PyObject *__pyx_n_s_GetFlightsAll; +static PyObject *__pyx_n_s_GetFont; +static PyObject *__pyx_n_s_GetImage; +static PyObject *__pyx_n_s_GetMonitorDrones; +static PyObject *__pyx_n_s_GetMonitorFlightWaypoints; +static PyObject *__pyx_n_s_GetMonitorFlights; +static PyObject *__pyx_n_s_GetNoFlyZones; +static PyObject *__pyx_n_s_GetText; +static PyObject *__pyx_n_s_GetZoom; +static PyObject *__pyx_n_s_Get_Coord; +static PyObject *__pyx_n_s_Get_Coords; +static PyObject *__pyx_n_s_Get_X; +static PyObject *__pyx_n_s_Get_XSize; +static PyObject *__pyx_n_s_Get_Y; +static PyObject *__pyx_n_s_Get_YSize; +static PyObject *__pyx_n_s_Get_Z; +static PyObject *__pyx_n_s_IP; +static PyObject *__pyx_n_s_IncrementCameraCoordX; +static PyObject *__pyx_n_s_IncrementCameraCoordY; +static PyObject *__pyx_n_s_KEYDOWN; +static PyObject *__pyx_n_s_K_SPACE; +static PyObject *__pyx_n_s_K_a; +static PyObject *__pyx_n_s_K_d; +static PyObject *__pyx_n_s_K_e; +static PyObject *__pyx_n_s_K_q; +static PyObject *__pyx_n_s_K_s; +static PyObject *__pyx_n_s_K_w; +static PyObject *__pyx_kp_s_L; +static PyObject *__pyx_n_s_LastBattery; +static PyObject *__pyx_n_s_LastCoords; +static PyObject *__pyx_n_s_Last_Refresh_Time; +static PyObject *__pyx_n_s_Level; +static PyObject *__pyx_n_s_LevelIndex; +static PyObject *__pyx_n_s_Login; +static PyObject *__pyx_n_s_M; +static PyObject *__pyx_n_s_MOUSEBUTTONDOWN; +static PyObject *__pyx_n_s_MakeDroneSprites; +static PyObject *__pyx_n_s_MakeFlightSprites; +static PyObject *__pyx_n_s_MakeSprites; +static PyObject *__pyx_n_s_MakeWaypointSprites; +static PyObject *__pyx_n_s_MakeZoneSprites; +static PyObject *__pyx_n_s_Make_Image; +static PyObject *__pyx_n_s_Make_Text; +static PyObject *__pyx_n_s_MaxCoords; +static PyObject *__pyx_n_s_Message; +static PyObject *__pyx_n_s_MinCoords; +static PyObject *__pyx_n_s_MonCamera; +static PyObject *__pyx_n_s_Monitor_Sprite; +static PyObject *__pyx_n_s_Monitor_Sprite_Get_Coords; +static PyObject *__pyx_n_s_Monitor_Sprite_Make_Image; +static PyObject *__pyx_n_s_Monitor_Sprite_Make_Text; +static PyObject *__pyx_n_s_Monitor_Sprite___init; +static PyObject *__pyx_kp_s_Monitor_exit_was_called; +static PyObject *__pyx_kp_s_N; +static PyObject *__pyx_n_s_N_2; +static PyObject *__pyx_n_s_NoFlyZone; +static PyObject *__pyx_n_s_NoFlyZones; +static PyObject *__pyx_n_s_Object; +static PyObject *__pyx_n_s_Object_Coords; +static PyObject *__pyx_n_s_Port; +static PyObject *__pyx_n_s_PosX; +static PyObject *__pyx_n_s_PosY; +static PyObject *__pyx_n_s_QUIT; +static PyObject *__pyx_n_s_RawDroneList; +static PyObject *__pyx_n_s_RawFlightList; +static PyObject *__pyx_n_s_RawWaypointList; +static PyObject *__pyx_n_s_RawZoneList; +static PyObject *__pyx_n_s_Refresh_Delay; +static PyObject *__pyx_kp_s_Refreshed_data; +static PyObject *__pyx_kp_s_Refreshing_data; +static PyObject *__pyx_n_s_ResetDrawObject; +static PyObject *__pyx_kp_s_ST; +static PyObject *__pyx_n_s_SetCameraCoords; +static PyObject *__pyx_n_s_SetZoom; +static PyObject *__pyx_n_s_Set_X; +static PyObject *__pyx_n_s_Set_XSize; +static PyObject *__pyx_n_s_Set_Y; +static PyObject *__pyx_n_s_Set_YSize; +static PyObject *__pyx_n_s_Size; +static PyObject *__pyx_n_s_Sprite; +static PyObject *__pyx_n_s_SpriteList; +static PyObject *__pyx_n_s_Sprites; +static PyObject *__pyx_n_s_StartCoord; +static PyObject *__pyx_n_s_StartCoordIndex; +static PyObject *__pyx_n_s_StartCoords; +static PyObject *__pyx_n_s_StartCoordsIndex; +static PyObject *__pyx_n_s_StartPoint; +static PyObject *__pyx_n_s_StartTime; +static PyObject *__pyx_n_s_StartTimeIndex; +static PyObject *__pyx_n_s_Sucess; +static PyObject *__pyx_n_s_Surface; +static PyObject *__pyx_n_s_Text; +static PyObject *__pyx_n_s_Type; +static PyObject *__pyx_kp_s_U; +static PyObject *__pyx_n_s_UpdateCameraSize; +static PyObject *__pyx_n_s_UserID; +static PyObject *__pyx_n_s_UserIDIndex; +static PyObject *__pyx_kp_s_W; +static PyObject *__pyx_n_s_Waypoint; +static PyObject *__pyx_n_s_WaypointList; +static PyObject *__pyx_n_s_WaypointNumber; +static PyObject *__pyx_n_s_WaypointNumberIndex; +static PyObject *__pyx_n_s_WaypointsAll; +static PyObject *__pyx_n_s_WaypointsMonitor; +static PyObject *__pyx_n_s_Y; +static PyObject *__pyx_kp_s_Z; +static PyObject *__pyx_n_s_Zini; +static PyObject *__pyx_n_s_Zone; +static PyObject *__pyx_n_s_ZoneID; +static PyObject *__pyx_n_s_ZoneIDIndex; +static PyObject *__pyx_n_s_ZoneList; +static PyObject *__pyx_n_s_Zoom; +static PyObject *__pyx_kp_s__2; +static PyObject *__pyx_kp_s__6; +static PyObject *__pyx_n_s_append; +static PyObject *__pyx_n_s_ast; +static PyObject *__pyx_n_s_blit; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_n_s_clock; +static PyObject *__pyx_n_s_convert; +static PyObject *__pyx_n_s_copy; +static PyObject *__pyx_n_s_display; +static PyObject *__pyx_n_s_doc; +static PyObject *__pyx_n_s_e; +static PyObject *__pyx_n_s_end; +static PyObject *__pyx_n_s_event; +static PyObject *__pyx_n_s_exit; +static PyObject *__pyx_n_s_file; +static PyObject *__pyx_n_s_fill; +static PyObject *__pyx_n_s_flip; +static PyObject *__pyx_n_s_font; +static PyObject *__pyx_n_s_fontParameters; +static PyObject *__pyx_n_s_font_size; +static PyObject *__pyx_n_s_fonts; +static PyObject *__pyx_n_s_gameDisplay; +static PyObject *__pyx_n_s_get; +static PyObject *__pyx_n_s_get_fps; +static PyObject *__pyx_n_s_get_pressed; +static PyObject *__pyx_n_s_get_size; +static PyObject *__pyx_n_s_height; +static PyObject *__pyx_n_s_image; +static PyObject *__pyx_n_s_images; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_index; +static PyObject *__pyx_n_s_init; +static PyObject *__pyx_n_s_init_2; +static PyObject *__pyx_n_s_input; +static PyObject *__pyx_n_s_key; +static PyObject *__pyx_n_s_keys; +static PyObject *__pyx_n_s_literal_eval; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_metaclass; +static PyObject *__pyx_n_s_module; +static PyObject *__pyx_n_s_pop; +static PyObject *__pyx_n_s_prepare; +static PyObject *__pyx_n_s_pressed; +static PyObject *__pyx_n_s_print; +static PyObject *__pyx_n_s_pygame; +static PyObject *__pyx_n_s_qualname; +static PyObject *__pyx_n_s_quit; +static PyObject *__pyx_n_s_random; +static PyObject *__pyx_n_s_refresh; +static PyObject *__pyx_n_s_render; +static PyObject *__pyx_n_s_result; +static PyObject *__pyx_n_s_sample; +static PyObject *__pyx_n_s_self; +static PyObject *__pyx_n_s_set_mode; +static PyObject *__pyx_n_s_sprite; +static PyObject *__pyx_n_s_sys; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_text; +static PyObject *__pyx_n_s_texts; +static PyObject *__pyx_n_s_tick; +static PyObject *__pyx_n_s_time; +static PyObject *__pyx_n_s_type; +static PyObject *__pyx_n_s_upper; +static PyObject *__pyx_n_s_width; +static PyObject *__pyx_n_s_x; +static PyObject *__pyx_n_s_xSize; +static PyObject *__pyx_n_s_xpixel; +static PyObject *__pyx_n_s_y; +static PyObject *__pyx_n_s_ySize; +static PyObject *__pyx_n_s_ypixel; +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_GetImage(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_xSize, PyObject *__pyx_v_ySize, PyObject *__pyx_v_Colour); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_2GetText(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Text, PyObject *__pyx_v_fontParameters, PyObject *__pyx_v_AA, PyObject *__pyx_v_Colour); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_4GetFont(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Font, PyObject *__pyx_v_Size); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_xpixel, PyObject *__pyx_v_ypixel, PyObject *__pyx_v_MinCoords, PyObject *__pyx_v_MaxCoords); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_2GetZoom(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_4SetZoom(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Zoom); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_6GetCameraCoords(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_8IncrementCameraCoordX(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Amount); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_10IncrementCameraCoordY(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Amount); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_12SetCameraCoords(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_CameraX, PyObject *__pyx_v_CameraY); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_14UpdateCameraSize(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_16CameraWipe(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Colour); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_18ResetDrawObject(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_20AddDrawObject(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Object, PyObject *__pyx_v_ForceDraw); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_22Get_Coord(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_24Draw(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_CoordObject, PyObject *__pyx_v_Type, PyObject *__pyx_v_Text, PyObject *__pyx_v_Colour); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_2Make_Image(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, int __pyx_v_width, int __pyx_v_height); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_4Make_Text(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_font); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_6Get_Coords(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6MakeDroneSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Message, PyObject *__pyx_v_RawDroneList); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_8MakeFlightSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Message, PyObject *__pyx_v_RawFlightList); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_10MakeWaypointSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Message, PyObject *__pyx_v_RawWaypointList); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_12MakeZoneSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Message, PyObject *__pyx_v_RawZoneList); /* proto */ +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14MakeSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_M); /* proto */ +static PyObject *__pyx_float_0_01; +static PyObject *__pyx_float_0_99; +static PyObject *__pyx_float_1_01; +static PyObject *__pyx_float_0_001; +static PyObject *__pyx_float_0_0001; +static PyObject *__pyx_float_0_00001; +static PyObject *__pyx_float_neg_0_01; +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_50; +static PyObject *__pyx_int_60; +static PyObject *__pyx_int_255; +static PyObject *__pyx_int_700; +static PyObject *__pyx_int_1200; +static PyObject *__pyx_int_8001; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_tuple__14; +static PyObject *__pyx_tuple__15; +static PyObject *__pyx_tuple__16; +static PyObject *__pyx_tuple__17; +static PyObject *__pyx_tuple__18; +static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__20; +static PyObject *__pyx_tuple__21; +static PyObject *__pyx_tuple__22; +static PyObject *__pyx_tuple__23; +static PyObject *__pyx_tuple__24; +static PyObject *__pyx_tuple__25; +static PyObject *__pyx_tuple__26; +static PyObject *__pyx_tuple__27; +static PyObject *__pyx_tuple__29; +static PyObject *__pyx_tuple__31; +static PyObject *__pyx_tuple__33; +static PyObject *__pyx_tuple__35; +static PyObject *__pyx_tuple__37; +static PyObject *__pyx_tuple__39; +static PyObject *__pyx_tuple__41; +static PyObject *__pyx_tuple__43; +static PyObject *__pyx_tuple__45; +static PyObject *__pyx_tuple__47; +static PyObject *__pyx_tuple__49; +static PyObject *__pyx_tuple__51; +static PyObject *__pyx_tuple__52; +static PyObject *__pyx_tuple__54; +static PyObject *__pyx_tuple__56; +static PyObject *__pyx_tuple__58; +static PyObject *__pyx_tuple__60; +static PyObject *__pyx_tuple__62; +static PyObject *__pyx_tuple__63; +static PyObject *__pyx_tuple__65; +static PyObject *__pyx_tuple__67; +static PyObject *__pyx_tuple__69; +static PyObject *__pyx_tuple__71; +static PyObject *__pyx_tuple__73; +static PyObject *__pyx_tuple__75; +static PyObject *__pyx_tuple__77; +static PyObject *__pyx_tuple__79; +static PyObject *__pyx_tuple__80; +static PyObject *__pyx_tuple__81; +static PyObject *__pyx_tuple__82; +static PyObject *__pyx_tuple__83; +static PyObject *__pyx_codeobj__28; +static PyObject *__pyx_codeobj__30; +static PyObject *__pyx_codeobj__32; +static PyObject *__pyx_codeobj__34; +static PyObject *__pyx_codeobj__36; +static PyObject *__pyx_codeobj__38; +static PyObject *__pyx_codeobj__40; +static PyObject *__pyx_codeobj__42; +static PyObject *__pyx_codeobj__44; +static PyObject *__pyx_codeobj__46; +static PyObject *__pyx_codeobj__48; +static PyObject *__pyx_codeobj__50; +static PyObject *__pyx_codeobj__53; +static PyObject *__pyx_codeobj__55; +static PyObject *__pyx_codeobj__57; +static PyObject *__pyx_codeobj__59; +static PyObject *__pyx_codeobj__61; +static PyObject *__pyx_codeobj__64; +static PyObject *__pyx_codeobj__66; +static PyObject *__pyx_codeobj__68; +static PyObject *__pyx_codeobj__70; +static PyObject *__pyx_codeobj__72; +static PyObject *__pyx_codeobj__74; +static PyObject *__pyx_codeobj__76; +static PyObject *__pyx_codeobj__78; + +/* "CAStar/AATC_Monitor_Viewer.pyx":9 + * + * _images= {} + * def GetImage(xSize,ySize,Colour): #Efficiently get images # <<<<<<<<<<<<<< + * result = _images.get((xSize,ySize,Colour)) + * if result == None: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_1GetImage(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_1GetImage = {"GetImage", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_1GetImage, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_1GetImage(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_xSize = 0; + PyObject *__pyx_v_ySize = 0; + PyObject *__pyx_v_Colour = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("GetImage (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_xSize,&__pyx_n_s_ySize,&__pyx_n_s_Colour,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_xSize)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ySize)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("GetImage", 1, 3, 3, 1); __PYX_ERR(0, 9, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Colour)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("GetImage", 1, 3, 3, 2); __PYX_ERR(0, 9, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "GetImage") < 0)) __PYX_ERR(0, 9, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_xSize = values[0]; + __pyx_v_ySize = values[1]; + __pyx_v_Colour = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("GetImage", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 9, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.GetImage", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_GetImage(__pyx_self, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_Colour); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_GetImage(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_xSize, PyObject *__pyx_v_ySize, PyObject *__pyx_v_Colour) { + 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; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + __Pyx_RefNannySetupContext("GetImage", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":10 + * _images= {} + * def GetImage(xSize,ySize,Colour): #Efficiently get images + * result = _images.get((xSize,ySize,Colour)) # <<<<<<<<<<<<<< + * if result == None: + * result = pygame.Surface((xSize,ySize)).convert() + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_images); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_xSize); + __Pyx_GIVEREF(__pyx_v_xSize); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_xSize); + __Pyx_INCREF(__pyx_v_ySize); + __Pyx_GIVEREF(__pyx_v_ySize); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_ySize); + __Pyx_INCREF(__pyx_v_Colour); + __Pyx_GIVEREF(__pyx_v_Colour); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_Colour); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":11 + * def GetImage(xSize,ySize,Colour): #Efficiently get images + * result = _images.get((xSize,ySize,Colour)) + * if result == None: # <<<<<<<<<<<<<< + * result = pygame.Surface((xSize,ySize)).convert() + * result.fill(Colour) + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_result, Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_6) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":12 + * result = _images.get((xSize,ySize,Colour)) + * if result == None: + * result = pygame.Surface((xSize,ySize)).convert() # <<<<<<<<<<<<<< + * result.fill(Colour) + * _images[(xSize,ySize,Colour)]=result + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Surface); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_xSize); + __Pyx_GIVEREF(__pyx_v_xSize); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_xSize); + __Pyx_INCREF(__pyx_v_ySize); + __Pyx_GIVEREF(__pyx_v_ySize); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_ySize); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_convert); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":13 + * if result == None: + * result = pygame.Surface((xSize,ySize)).convert() + * result.fill(Colour) # <<<<<<<<<<<<<< + * _images[(xSize,ySize,Colour)]=result + * while len(_images) > 1500: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result, __pyx_n_s_fill); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_Colour); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_Colour}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_Colour}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_Colour); + __Pyx_GIVEREF(__pyx_v_Colour); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_Colour); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":14 + * result = pygame.Surface((xSize,ySize)).convert() + * result.fill(Colour) + * _images[(xSize,ySize,Colour)]=result # <<<<<<<<<<<<<< + * while len(_images) > 1500: + * _images.pop(random.sample(_images.keys(),1)[0]) #If cache is full evict old versions + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_images); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_xSize); + __Pyx_GIVEREF(__pyx_v_xSize); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_xSize); + __Pyx_INCREF(__pyx_v_ySize); + __Pyx_GIVEREF(__pyx_v_ySize); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_ySize); + __Pyx_INCREF(__pyx_v_Colour); + __Pyx_GIVEREF(__pyx_v_Colour); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_Colour); + if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_t_2, __pyx_v_result) < 0)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":11 + * def GetImage(xSize,ySize,Colour): #Efficiently get images + * result = _images.get((xSize,ySize,Colour)) + * if result == None: # <<<<<<<<<<<<<< + * result = pygame.Surface((xSize,ySize)).convert() + * result.fill(Colour) + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":15 + * result.fill(Colour) + * _images[(xSize,ySize,Colour)]=result + * while len(_images) > 1500: # <<<<<<<<<<<<<< + * _images.pop(random.sample(_images.keys(),1)[0]) #If cache is full evict old versions + * return result#_copy + */ + while (1) { + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_images); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = ((__pyx_t_8 > 0x5DC) != 0); + if (!__pyx_t_6) break; + + /* "CAStar/AATC_Monitor_Viewer.pyx":16 + * _images[(xSize,ySize,Colour)]=result + * while len(_images) > 1500: + * _images.pop(random.sample(_images.keys(),1)[0]) #If cache is full evict old versions # <<<<<<<<<<<<<< + * return result#_copy + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_images); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_pop); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_sample); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_images); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_keys); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + if (__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_3, __pyx_int_1}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_3, __pyx_int_1}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_9) { + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_9); __pyx_t_9 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_10, __pyx_t_3); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_10, __pyx_int_1); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (!__pyx_t_1) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":17 + * while len(_images) > 1500: + * _images.pop(random.sample(_images.keys(),1)[0]) #If cache is full evict old versions + * return result#_copy # <<<<<<<<<<<<<< + * + * _texts= {} + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":9 + * + * _images= {} + * def GetImage(xSize,ySize,Colour): #Efficiently get images # <<<<<<<<<<<<<< + * result = _images.get((xSize,ySize,Colour)) + * if result == None: + */ + + /* 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_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.GetImage", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":20 + * + * _texts= {} + * def GetText(Text,fontParameters,AA,Colour): #Efficiently get text # <<<<<<<<<<<<<< + * result = _texts.get((Text,fontParameters,AA,Colour)) + * if result == None: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_3GetText(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_3GetText = {"GetText", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_3GetText, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_3GetText(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_Text = 0; + PyObject *__pyx_v_fontParameters = 0; + PyObject *__pyx_v_AA = 0; + PyObject *__pyx_v_Colour = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("GetText (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Text,&__pyx_n_s_fontParameters,&__pyx_n_s_AA,&__pyx_n_s_Colour,0}; + PyObject* values[4] = {0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Text)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fontParameters)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("GetText", 1, 4, 4, 1); __PYX_ERR(0, 20, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_AA)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("GetText", 1, 4, 4, 2); __PYX_ERR(0, 20, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Colour)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("GetText", 1, 4, 4, 3); __PYX_ERR(0, 20, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "GetText") < 0)) __PYX_ERR(0, 20, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + } + __pyx_v_Text = values[0]; + __pyx_v_fontParameters = values[1]; + __pyx_v_AA = values[2]; + __pyx_v_Colour = values[3]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("GetText", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 20, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.GetText", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_2GetText(__pyx_self, __pyx_v_Text, __pyx_v_fontParameters, __pyx_v_AA, __pyx_v_Colour); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_2GetText(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Text, PyObject *__pyx_v_fontParameters, PyObject *__pyx_v_AA, PyObject *__pyx_v_Colour) { + 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; + int __pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("GetText", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":21 + * _texts= {} + * def GetText(Text,fontParameters,AA,Colour): #Efficiently get text + * result = _texts.get((Text,fontParameters,AA,Colour)) # <<<<<<<<<<<<<< + * if result == None: + * result = GetFont(*fontParameters).render(Text,AA,Colour) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_texts); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_Text); + __Pyx_GIVEREF(__pyx_v_Text); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_Text); + __Pyx_INCREF(__pyx_v_fontParameters); + __Pyx_GIVEREF(__pyx_v_fontParameters); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_fontParameters); + __Pyx_INCREF(__pyx_v_AA); + __Pyx_GIVEREF(__pyx_v_AA); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_AA); + __Pyx_INCREF(__pyx_v_Colour); + __Pyx_GIVEREF(__pyx_v_Colour); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_v_Colour); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":22 + * def GetText(Text,fontParameters,AA,Colour): #Efficiently get text + * result = _texts.get((Text,fontParameters,AA,Colour)) + * if result == None: # <<<<<<<<<<<<<< + * result = GetFont(*fontParameters).render(Text,AA,Colour) + * _texts[(Text,fontParameters,AA,Colour)]=result + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_result, Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_6) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":23 + * result = _texts.get((Text,fontParameters,AA,Colour)) + * if result == None: + * result = GetFont(*fontParameters).render(Text,AA,Colour) # <<<<<<<<<<<<<< + * _texts[(Text,fontParameters,AA,Colour)]=result + * while len(_texts) > 1500: + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_GetFont); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PySequence_Tuple(__pyx_v_fontParameters); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_render); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_v_Text, __pyx_v_AA, __pyx_v_Colour}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_v_Text, __pyx_v_AA, __pyx_v_Colour}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_3 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(__pyx_v_Text); + __Pyx_GIVEREF(__pyx_v_Text); + PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_7, __pyx_v_Text); + __Pyx_INCREF(__pyx_v_AA); + __Pyx_GIVEREF(__pyx_v_AA); + PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_7, __pyx_v_AA); + __Pyx_INCREF(__pyx_v_Colour); + __Pyx_GIVEREF(__pyx_v_Colour); + PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_7, __pyx_v_Colour); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":24 + * if result == None: + * result = GetFont(*fontParameters).render(Text,AA,Colour) + * _texts[(Text,fontParameters,AA,Colour)]=result # <<<<<<<<<<<<<< + * while len(_texts) > 1500: + * _texts.pop(random.sample(_texts.keys(),1)[0]) #If cache is full evict old versions + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_texts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_Text); + __Pyx_GIVEREF(__pyx_v_Text); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_Text); + __Pyx_INCREF(__pyx_v_fontParameters); + __Pyx_GIVEREF(__pyx_v_fontParameters); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_fontParameters); + __Pyx_INCREF(__pyx_v_AA); + __Pyx_GIVEREF(__pyx_v_AA); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_AA); + __Pyx_INCREF(__pyx_v_Colour); + __Pyx_GIVEREF(__pyx_v_Colour); + PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_v_Colour); + if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_t_5, __pyx_v_result) < 0)) __PYX_ERR(0, 24, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":22 + * def GetText(Text,fontParameters,AA,Colour): #Efficiently get text + * result = _texts.get((Text,fontParameters,AA,Colour)) + * if result == None: # <<<<<<<<<<<<<< + * result = GetFont(*fontParameters).render(Text,AA,Colour) + * _texts[(Text,fontParameters,AA,Colour)]=result + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":25 + * result = GetFont(*fontParameters).render(Text,AA,Colour) + * _texts[(Text,fontParameters,AA,Colour)]=result + * while len(_texts) > 1500: # <<<<<<<<<<<<<< + * _texts.pop(random.sample(_texts.keys(),1)[0]) #If cache is full evict old versions + * return result + */ + while (1) { + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_texts); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = ((__pyx_t_8 > 0x5DC) != 0); + if (!__pyx_t_6) break; + + /* "CAStar/AATC_Monitor_Viewer.pyx":26 + * _texts[(Text,fontParameters,AA,Colour)]=result + * while len(_texts) > 1500: + * _texts.pop(random.sample(_texts.keys(),1)[0]) #If cache is full evict old versions # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_texts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_pop); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_random); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_sample); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_texts); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_keys); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + } + } + if (__pyx_t_9) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_2, __pyx_int_1}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_2, __pyx_int_1}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_10) { + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); __pyx_t_10 = NULL; + } + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_7, __pyx_t_2); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_7, __pyx_int_1); + __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_1) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_5); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_4}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_4}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_1); __pyx_t_1 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":27 + * while len(_texts) > 1500: + * _texts.pop(random.sample(_texts.keys(),1)[0]) #If cache is full evict old versions + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":20 + * + * _texts= {} + * def GetText(Text,fontParameters,AA,Colour): #Efficiently get text # <<<<<<<<<<<<<< + * result = _texts.get((Text,fontParameters,AA,Colour)) + * if result == None: + */ + + /* 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_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.GetText", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":31 + * + * _fonts = {} + * def GetFont(Font,Size): # <<<<<<<<<<<<<< + * result = _fonts.get((Font,Size)) + * if result == None: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_5GetFont(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_5GetFont = {"GetFont", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_5GetFont, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_5GetFont(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_Font = 0; + PyObject *__pyx_v_Size = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("GetFont (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Font,&__pyx_n_s_Size,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Font)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Size)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("GetFont", 1, 2, 2, 1); __PYX_ERR(0, 31, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "GetFont") < 0)) __PYX_ERR(0, 31, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_Font = values[0]; + __pyx_v_Size = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("GetFont", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 31, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.GetFont", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_4GetFont(__pyx_self, __pyx_v_Font, __pyx_v_Size); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_4GetFont(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Font, PyObject *__pyx_v_Size) { + 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; + int __pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + __Pyx_RefNannySetupContext("GetFont", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":32 + * _fonts = {} + * def GetFont(Font,Size): + * result = _fonts.get((Font,Size)) # <<<<<<<<<<<<<< + * if result == None: + * result = pygame.font.Font(Font,Size) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_fonts); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_Font); + __Pyx_GIVEREF(__pyx_v_Font); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_Font); + __Pyx_INCREF(__pyx_v_Size); + __Pyx_GIVEREF(__pyx_v_Size); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_Size); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":33 + * def GetFont(Font,Size): + * result = _fonts.get((Font,Size)) + * if result == None: # <<<<<<<<<<<<<< + * result = pygame.font.Font(Font,Size) + * _fonts[(Font,Size)]=result + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_result, Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_6) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":34 + * result = _fonts.get((Font,Size)) + * if result == None: + * result = pygame.font.Font(Font,Size) # <<<<<<<<<<<<<< + * _fonts[(Font,Size)]=result + * while len(_fonts) > 1500: + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_font); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Font); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_Font, __pyx_v_Size}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_Font, __pyx_v_Size}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_2 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_INCREF(__pyx_v_Font); + __Pyx_GIVEREF(__pyx_v_Font); + PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_7, __pyx_v_Font); + __Pyx_INCREF(__pyx_v_Size); + __Pyx_GIVEREF(__pyx_v_Size); + PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_7, __pyx_v_Size); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __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_DECREF_SET(__pyx_v_result, __pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":35 + * if result == None: + * result = pygame.font.Font(Font,Size) + * _fonts[(Font,Size)]=result # <<<<<<<<<<<<<< + * while len(_fonts) > 1500: + * _fonts.pop(random.sample(_fonts.keys(),1)[0]) #If cache is full evict old versions + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_fonts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_Font); + __Pyx_GIVEREF(__pyx_v_Font); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_Font); + __Pyx_INCREF(__pyx_v_Size); + __Pyx_GIVEREF(__pyx_v_Size); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_Size); + if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_t_3, __pyx_v_result) < 0)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":33 + * def GetFont(Font,Size): + * result = _fonts.get((Font,Size)) + * if result == None: # <<<<<<<<<<<<<< + * result = pygame.font.Font(Font,Size) + * _fonts[(Font,Size)]=result + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":36 + * result = pygame.font.Font(Font,Size) + * _fonts[(Font,Size)]=result + * while len(_fonts) > 1500: # <<<<<<<<<<<<<< + * _fonts.pop(random.sample(_fonts.keys(),1)[0]) #If cache is full evict old versions + * return result + */ + while (1) { + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_fonts); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((__pyx_t_8 > 0x5DC) != 0); + if (!__pyx_t_6) break; + + /* "CAStar/AATC_Monitor_Viewer.pyx":37 + * _fonts[(Font,Size)]=result + * while len(_fonts) > 1500: + * _fonts.pop(random.sample(_fonts.keys(),1)[0]) #If cache is full evict old versions # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_fonts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_pop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_random); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_sample); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_fonts); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_keys); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + } + } + if (__pyx_t_9) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 37, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_5, __pyx_int_1}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_5, __pyx_int_1}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_10) { + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); __pyx_t_10 = NULL; + } + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_7, __pyx_t_5); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_7, __pyx_int_1); + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_1) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_1); __pyx_t_1 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":38 + * while len(_fonts) > 1500: + * _fonts.pop(random.sample(_fonts.keys(),1)[0]) #If cache is full evict old versions + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":31 + * + * _fonts = {} + * def GetFont(Font,Size): # <<<<<<<<<<<<<< + * result = _fonts.get((Font,Size)) + * if result == None: + */ + + /* 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_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.GetFont", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":41 + * + * + * cdef int MaxLimit( int value, int Max): # <<<<<<<<<<<<<< + * if value > Max: + * value = Max + */ + +static int __pyx_f_6CAStar_19AATC_Monitor_Viewer_MaxLimit(int __pyx_v_value, int __pyx_v_Max) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("MaxLimit", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":42 + * + * cdef int MaxLimit( int value, int Max): + * if value > Max: # <<<<<<<<<<<<<< + * value = Max + * return value + */ + __pyx_t_1 = ((__pyx_v_value > __pyx_v_Max) != 0); + if (__pyx_t_1) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":43 + * cdef int MaxLimit( int value, int Max): + * if value > Max: + * value = Max # <<<<<<<<<<<<<< + * return value + * + */ + __pyx_v_value = __pyx_v_Max; + + /* "CAStar/AATC_Monitor_Viewer.pyx":42 + * + * cdef int MaxLimit( int value, int Max): + * if value > Max: # <<<<<<<<<<<<<< + * value = Max + * return value + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":44 + * if value > Max: + * value = Max + * return value # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_value; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":41 + * + * + * cdef int MaxLimit( int value, int Max): # <<<<<<<<<<<<<< + * if value > Max: + * value = Max + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":49 + * + * class Camera: + * def __init__(self,xpixel,ypixel,MinCoords,MaxCoords): #COORDS (X,Y,Z) # <<<<<<<<<<<<<< + * self.xpixel = xpixel + * self.ypixel = ypixel + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_1__init__ = {"__init__", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_1__init__, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_xpixel = 0; + PyObject *__pyx_v_ypixel = 0; + PyObject *__pyx_v_MinCoords = 0; + PyObject *__pyx_v_MaxCoords = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_xpixel,&__pyx_n_s_ypixel,&__pyx_n_s_MinCoords,&__pyx_n_s_MaxCoords,0}; + PyObject* values[5] = {0,0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_xpixel)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 1); __PYX_ERR(0, 49, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ypixel)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 2); __PYX_ERR(0, 49, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_MinCoords)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 3); __PYX_ERR(0, 49, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_MaxCoords)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 4); __PYX_ERR(0, 49, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 49, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + } + __pyx_v_self = values[0]; + __pyx_v_xpixel = values[1]; + __pyx_v_ypixel = values[2]; + __pyx_v_MinCoords = values[3]; + __pyx_v_MaxCoords = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 49, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera___init__(__pyx_self, __pyx_v_self, __pyx_v_xpixel, __pyx_v_ypixel, __pyx_v_MinCoords, __pyx_v_MaxCoords); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_xpixel, PyObject *__pyx_v_ypixel, PyObject *__pyx_v_MinCoords, PyObject *__pyx_v_MaxCoords) { + 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; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":50 + * class Camera: + * def __init__(self,xpixel,ypixel,MinCoords,MaxCoords): #COORDS (X,Y,Z) + * self.xpixel = xpixel # <<<<<<<<<<<<<< + * self.ypixel = ypixel + * self.gameDisplay = pygame.display.set_mode((self.xpixel,self.ypixel)) + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_xpixel, __pyx_v_xpixel) < 0) __PYX_ERR(0, 50, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":51 + * def __init__(self,xpixel,ypixel,MinCoords,MaxCoords): #COORDS (X,Y,Z) + * self.xpixel = xpixel + * self.ypixel = ypixel # <<<<<<<<<<<<<< + * self.gameDisplay = pygame.display.set_mode((self.xpixel,self.ypixel)) + * self.MinCoords = MinCoords + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_ypixel, __pyx_v_ypixel) < 0) __PYX_ERR(0, 51, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":52 + * self.xpixel = xpixel + * self.ypixel = ypixel + * self.gameDisplay = pygame.display.set_mode((self.xpixel,self.ypixel)) # <<<<<<<<<<<<<< + * self.MinCoords = MinCoords + * self.MaxCoords = MaxCoords + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_display); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_set_mode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_xpixel); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ypixel); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_gameDisplay, __pyx_t_1) < 0) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":53 + * self.ypixel = ypixel + * self.gameDisplay = pygame.display.set_mode((self.xpixel,self.ypixel)) + * self.MinCoords = MinCoords # <<<<<<<<<<<<<< + * self.MaxCoords = MaxCoords + * self.CameraCoord = self.MinCoords.copy() + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_MinCoords, __pyx_v_MinCoords) < 0) __PYX_ERR(0, 53, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":54 + * self.gameDisplay = pygame.display.set_mode((self.xpixel,self.ypixel)) + * self.MinCoords = MinCoords + * self.MaxCoords = MaxCoords # <<<<<<<<<<<<<< + * self.CameraCoord = self.MinCoords.copy() + * self.CameraCoord.Set_XSize( self.MaxCoords.Get_X() - self.MinCoords.Get_X()) + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_MaxCoords, __pyx_v_MaxCoords) < 0) __PYX_ERR(0, 54, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":55 + * self.MinCoords = MinCoords + * self.MaxCoords = MaxCoords + * self.CameraCoord = self.MinCoords.copy() # <<<<<<<<<<<<<< + * self.CameraCoord.Set_XSize( self.MaxCoords.Get_X() - self.MinCoords.Get_X()) + * self.CameraCoord.Set_YSize( self.MaxCoords.Get_Y() - self.MinCoords.Get_Y()) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MinCoords); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord, __pyx_t_1) < 0) __PYX_ERR(0, 55, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":56 + * self.MaxCoords = MaxCoords + * self.CameraCoord = self.MinCoords.copy() + * self.CameraCoord.Set_XSize( self.MaxCoords.Get_X() - self.MinCoords.Get_X()) # <<<<<<<<<<<<<< + * self.CameraCoord.Set_YSize( self.MaxCoords.Get_Y() - self.MinCoords.Get_Y()) + * self.CameraZoom = 1 + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Set_XSize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MaxCoords); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MinCoords); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (__pyx_t_5) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyNumber_Subtract(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":57 + * self.CameraCoord = self.MinCoords.copy() + * self.CameraCoord.Set_XSize( self.MaxCoords.Get_X() - self.MinCoords.Get_X()) + * self.CameraCoord.Set_YSize( self.MaxCoords.Get_Y() - self.MinCoords.Get_Y()) # <<<<<<<<<<<<<< + * self.CameraZoom = 1 + * self.DrawObjects = [] + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Set_YSize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MaxCoords); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_6) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MinCoords); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Subtract(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __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_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":58 + * self.CameraCoord.Set_XSize( self.MaxCoords.Get_X() - self.MinCoords.Get_X()) + * self.CameraCoord.Set_YSize( self.MaxCoords.Get_Y() - self.MinCoords.Get_Y()) + * self.CameraZoom = 1 # <<<<<<<<<<<<<< + * self.DrawObjects = [] + * + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_CameraZoom, __pyx_int_1) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":59 + * self.CameraCoord.Set_YSize( self.MaxCoords.Get_Y() - self.MinCoords.Get_Y()) + * self.CameraZoom = 1 + * self.DrawObjects = [] # <<<<<<<<<<<<<< + * + * def GetZoom(self): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_DrawObjects, __pyx_t_1) < 0) __PYX_ERR(0, 59, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":49 + * + * class Camera: + * def __init__(self,xpixel,ypixel,MinCoords,MaxCoords): #COORDS (X,Y,Z) # <<<<<<<<<<<<<< + * self.xpixel = xpixel + * self.ypixel = ypixel + */ + + /* 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_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":61 + * self.DrawObjects = [] + * + * def GetZoom(self): # <<<<<<<<<<<<<< + * return self.CameraZoom + * def SetZoom(self,Zoom): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_3GetZoom(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_3GetZoom = {"GetZoom", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_3GetZoom, METH_O, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_3GetZoom(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("GetZoom (wrapper)", 0); + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_2GetZoom(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_2GetZoom(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("GetZoom", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":62 + * + * def GetZoom(self): + * return self.CameraZoom # <<<<<<<<<<<<<< + * def SetZoom(self,Zoom): + * self.CameraZoom = Zoom + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraZoom); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":61 + * self.DrawObjects = [] + * + * def GetZoom(self): # <<<<<<<<<<<<<< + * return self.CameraZoom + * def SetZoom(self,Zoom): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.GetZoom", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":63 + * def GetZoom(self): + * return self.CameraZoom + * def SetZoom(self,Zoom): # <<<<<<<<<<<<<< + * self.CameraZoom = Zoom + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_5SetZoom(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_5SetZoom = {"SetZoom", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_5SetZoom, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_5SetZoom(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_Zoom = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("SetZoom (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_Zoom,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Zoom)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("SetZoom", 1, 2, 2, 1); __PYX_ERR(0, 63, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "SetZoom") < 0)) __PYX_ERR(0, 63, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_self = values[0]; + __pyx_v_Zoom = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("SetZoom", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 63, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.SetZoom", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_4SetZoom(__pyx_self, __pyx_v_self, __pyx_v_Zoom); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_4SetZoom(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Zoom) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("SetZoom", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":64 + * return self.CameraZoom + * def SetZoom(self,Zoom): + * self.CameraZoom = Zoom # <<<<<<<<<<<<<< + * + * def GetCameraCoords(self): + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_CameraZoom, __pyx_v_Zoom) < 0) __PYX_ERR(0, 64, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":63 + * def GetZoom(self): + * return self.CameraZoom + * def SetZoom(self,Zoom): # <<<<<<<<<<<<<< + * self.CameraZoom = Zoom + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.SetZoom", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":66 + * self.CameraZoom = Zoom + * + * def GetCameraCoords(self): # <<<<<<<<<<<<<< + * return self.CameraCoord + * def IncrementCameraCoordX(self,Amount): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_7GetCameraCoords(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_7GetCameraCoords = {"GetCameraCoords", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_7GetCameraCoords, METH_O, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_7GetCameraCoords(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("GetCameraCoords (wrapper)", 0); + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_6GetCameraCoords(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_6GetCameraCoords(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("GetCameraCoords", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":67 + * + * def GetCameraCoords(self): + * return self.CameraCoord # <<<<<<<<<<<<<< + * def IncrementCameraCoordX(self,Amount): + * self.CameraCoord.Set_X( Amount+self.CameraCoord.Get_X()) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":66 + * self.CameraZoom = Zoom + * + * def GetCameraCoords(self): # <<<<<<<<<<<<<< + * return self.CameraCoord + * def IncrementCameraCoordX(self,Amount): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.GetCameraCoords", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":68 + * def GetCameraCoords(self): + * return self.CameraCoord + * def IncrementCameraCoordX(self,Amount): # <<<<<<<<<<<<<< + * self.CameraCoord.Set_X( Amount+self.CameraCoord.Get_X()) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_9IncrementCameraCoordX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_9IncrementCameraCoordX = {"IncrementCameraCoordX", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_9IncrementCameraCoordX, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_9IncrementCameraCoordX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_Amount = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("IncrementCameraCoordX (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_Amount,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Amount)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("IncrementCameraCoordX", 1, 2, 2, 1); __PYX_ERR(0, 68, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "IncrementCameraCoordX") < 0)) __PYX_ERR(0, 68, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_self = values[0]; + __pyx_v_Amount = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("IncrementCameraCoordX", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 68, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.IncrementCameraCoordX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_8IncrementCameraCoordX(__pyx_self, __pyx_v_self, __pyx_v_Amount); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_8IncrementCameraCoordX(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Amount) { + 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; + __Pyx_RefNannySetupContext("IncrementCameraCoordX", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":69 + * return self.CameraCoord + * def IncrementCameraCoordX(self,Amount): + * self.CameraCoord.Set_X( Amount+self.CameraCoord.Get_X()) # <<<<<<<<<<<<<< + * + * def IncrementCameraCoordY(self,Amount): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Set_X); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Add(__pyx_v_Amount, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":68 + * def GetCameraCoords(self): + * return self.CameraCoord + * def IncrementCameraCoordX(self,Amount): # <<<<<<<<<<<<<< + * self.CameraCoord.Set_X( Amount+self.CameraCoord.Get_X()) + * + */ + + /* 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_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.IncrementCameraCoordX", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":71 + * self.CameraCoord.Set_X( Amount+self.CameraCoord.Get_X()) + * + * def IncrementCameraCoordY(self,Amount): # <<<<<<<<<<<<<< + * self.CameraCoord.Set_Y( Amount+self.CameraCoord.Get_Y()) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_11IncrementCameraCoordY(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_11IncrementCameraCoordY = {"IncrementCameraCoordY", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_11IncrementCameraCoordY, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_11IncrementCameraCoordY(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_Amount = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("IncrementCameraCoordY (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_Amount,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Amount)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("IncrementCameraCoordY", 1, 2, 2, 1); __PYX_ERR(0, 71, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "IncrementCameraCoordY") < 0)) __PYX_ERR(0, 71, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_self = values[0]; + __pyx_v_Amount = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("IncrementCameraCoordY", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 71, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.IncrementCameraCoordY", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_10IncrementCameraCoordY(__pyx_self, __pyx_v_self, __pyx_v_Amount); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_10IncrementCameraCoordY(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Amount) { + 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; + __Pyx_RefNannySetupContext("IncrementCameraCoordY", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":72 + * + * def IncrementCameraCoordY(self,Amount): + * self.CameraCoord.Set_Y( Amount+self.CameraCoord.Get_Y()) # <<<<<<<<<<<<<< + * + * def SetCameraCoords(self,CameraX,CameraY): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Set_Y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Add(__pyx_v_Amount, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":71 + * self.CameraCoord.Set_X( Amount+self.CameraCoord.Get_X()) + * + * def IncrementCameraCoordY(self,Amount): # <<<<<<<<<<<<<< + * self.CameraCoord.Set_Y( Amount+self.CameraCoord.Get_Y()) + * + */ + + /* 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_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.IncrementCameraCoordY", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":74 + * self.CameraCoord.Set_Y( Amount+self.CameraCoord.Get_Y()) + * + * def SetCameraCoords(self,CameraX,CameraY): # <<<<<<<<<<<<<< + * self.CameraCoord.Set_X( CameraX) + * self.CameraCoord.Set_Y(CameraY) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_13SetCameraCoords(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_13SetCameraCoords = {"SetCameraCoords", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_13SetCameraCoords, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_13SetCameraCoords(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_CameraX = 0; + PyObject *__pyx_v_CameraY = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("SetCameraCoords (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_CameraX,&__pyx_n_s_CameraY,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_CameraX)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("SetCameraCoords", 1, 3, 3, 1); __PYX_ERR(0, 74, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_CameraY)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("SetCameraCoords", 1, 3, 3, 2); __PYX_ERR(0, 74, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "SetCameraCoords") < 0)) __PYX_ERR(0, 74, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_self = values[0]; + __pyx_v_CameraX = values[1]; + __pyx_v_CameraY = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("SetCameraCoords", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 74, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.SetCameraCoords", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_12SetCameraCoords(__pyx_self, __pyx_v_self, __pyx_v_CameraX, __pyx_v_CameraY); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_12SetCameraCoords(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_CameraX, PyObject *__pyx_v_CameraY) { + 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; + __Pyx_RefNannySetupContext("SetCameraCoords", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":75 + * + * def SetCameraCoords(self,CameraX,CameraY): + * self.CameraCoord.Set_X( CameraX) # <<<<<<<<<<<<<< + * self.CameraCoord.Set_Y(CameraY) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Set_X); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_CameraX); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_CameraX}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_CameraX}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_v_CameraX); + __Pyx_GIVEREF(__pyx_v_CameraX); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_CameraX); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":76 + * def SetCameraCoords(self,CameraX,CameraY): + * self.CameraCoord.Set_X( CameraX) + * self.CameraCoord.Set_Y(CameraY) # <<<<<<<<<<<<<< + * + * def UpdateCameraSize(self): #Gets width of map divided by zoom level eg at zoom 1x it has whole map + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Set_Y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_CameraY); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_CameraY}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_CameraY}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_CameraY); + __Pyx_GIVEREF(__pyx_v_CameraY); + PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_CameraY); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":74 + * self.CameraCoord.Set_Y( Amount+self.CameraCoord.Get_Y()) + * + * def SetCameraCoords(self,CameraX,CameraY): # <<<<<<<<<<<<<< + * self.CameraCoord.Set_X( CameraX) + * self.CameraCoord.Set_Y(CameraY) + */ + + /* 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_4); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.SetCameraCoords", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":78 + * self.CameraCoord.Set_Y(CameraY) + * + * def UpdateCameraSize(self): #Gets width of map divided by zoom level eg at zoom 1x it has whole map # <<<<<<<<<<<<<< + * self.CameraCoord.Set_XSize ((self.MaxCoords.Get_X() - self.MinCoords.Get_X())/self.CameraZoom) + * self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_15UpdateCameraSize(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_15UpdateCameraSize = {"UpdateCameraSize", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_15UpdateCameraSize, METH_O, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_15UpdateCameraSize(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("UpdateCameraSize (wrapper)", 0); + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_14UpdateCameraSize(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_14UpdateCameraSize(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__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 = NULL; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("UpdateCameraSize", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":79 + * + * def UpdateCameraSize(self): #Gets width of map divided by zoom level eg at zoom 1x it has whole map + * self.CameraCoord.Set_XSize ((self.MaxCoords.Get_X() - self.MinCoords.Get_X())/self.CameraZoom) # <<<<<<<<<<<<<< + * self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Set_XSize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MaxCoords); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MinCoords); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (__pyx_t_4) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyNumber_Subtract(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraZoom); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_PyNumber_Divide(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":80 + * def UpdateCameraSize(self): #Gets width of map divided by zoom level eg at zoom 1x it has whole map + * self.CameraCoord.Set_XSize ((self.MaxCoords.Get_X() - self.MinCoords.Get_X())/self.CameraZoom) + * self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom) # <<<<<<<<<<<<<< + * + * def CameraWipe(self,Colour = (0,0,0)): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Set_YSize); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MaxCoords); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_2) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MinCoords); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_2) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Subtract(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraZoom); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (!__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":78 + * self.CameraCoord.Set_Y(CameraY) + * + * def UpdateCameraSize(self): #Gets width of map divided by zoom level eg at zoom 1x it has whole map # <<<<<<<<<<<<<< + * self.CameraCoord.Set_XSize ((self.MaxCoords.Get_X() - self.MinCoords.Get_X())/self.CameraZoom) + * self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom) + */ + + /* 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_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.UpdateCameraSize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":82 + * self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom) + * + * def CameraWipe(self,Colour = (0,0,0)): # <<<<<<<<<<<<<< + * self.gameDisplay.fill(Colour) + * def ResetDrawObject(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_17CameraWipe(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_17CameraWipe = {"CameraWipe", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_17CameraWipe, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_17CameraWipe(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_Colour = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("CameraWipe (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_Colour,0}; + PyObject* values[2] = {0,0}; + values[1] = ((PyObject *)((PyObject*)__pyx_tuple_)); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Colour); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CameraWipe") < 0)) __PYX_ERR(0, 82, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_self = values[0]; + __pyx_v_Colour = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("CameraWipe", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 82, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.CameraWipe", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_16CameraWipe(__pyx_self, __pyx_v_self, __pyx_v_Colour); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_16CameraWipe(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Colour) { + 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; + __Pyx_RefNannySetupContext("CameraWipe", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":83 + * + * def CameraWipe(self,Colour = (0,0,0)): + * self.gameDisplay.fill(Colour) # <<<<<<<<<<<<<< + * def ResetDrawObject(self): + * self.DrawObjects = [] + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_gameDisplay); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_fill); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_Colour); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Colour}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Colour}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_v_Colour); + __Pyx_GIVEREF(__pyx_v_Colour); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_Colour); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":82 + * self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom) + * + * def CameraWipe(self,Colour = (0,0,0)): # <<<<<<<<<<<<<< + * self.gameDisplay.fill(Colour) + * def ResetDrawObject(self): + */ + + /* 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_4); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.CameraWipe", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":84 + * def CameraWipe(self,Colour = (0,0,0)): + * self.gameDisplay.fill(Colour) + * def ResetDrawObject(self): # <<<<<<<<<<<<<< + * self.DrawObjects = [] + * def AddDrawObject(self,Object,ForceDraw): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_19ResetDrawObject(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_19ResetDrawObject = {"ResetDrawObject", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_19ResetDrawObject, METH_O, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_19ResetDrawObject(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ResetDrawObject (wrapper)", 0); + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_18ResetDrawObject(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_18ResetDrawObject(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("ResetDrawObject", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":85 + * self.gameDisplay.fill(Colour) + * def ResetDrawObject(self): + * self.DrawObjects = [] # <<<<<<<<<<<<<< + * def AddDrawObject(self,Object,ForceDraw): + * self.DrawObjects.append({"Object":Object,"ForceDraw":ForceDraw}) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_DrawObjects, __pyx_t_1) < 0) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":84 + * def CameraWipe(self,Colour = (0,0,0)): + * self.gameDisplay.fill(Colour) + * def ResetDrawObject(self): # <<<<<<<<<<<<<< + * self.DrawObjects = [] + * def AddDrawObject(self,Object,ForceDraw): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.ResetDrawObject", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":86 + * def ResetDrawObject(self): + * self.DrawObjects = [] + * def AddDrawObject(self,Object,ForceDraw): # <<<<<<<<<<<<<< + * self.DrawObjects.append({"Object":Object,"ForceDraw":ForceDraw}) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_21AddDrawObject(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_21AddDrawObject = {"AddDrawObject", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_21AddDrawObject, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_21AddDrawObject(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_Object = 0; + PyObject *__pyx_v_ForceDraw = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("AddDrawObject (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_Object,&__pyx_n_s_ForceDraw,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Object)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("AddDrawObject", 1, 3, 3, 1); __PYX_ERR(0, 86, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ForceDraw)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("AddDrawObject", 1, 3, 3, 2); __PYX_ERR(0, 86, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "AddDrawObject") < 0)) __PYX_ERR(0, 86, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_self = values[0]; + __pyx_v_Object = values[1]; + __pyx_v_ForceDraw = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("AddDrawObject", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 86, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.AddDrawObject", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_20AddDrawObject(__pyx_self, __pyx_v_self, __pyx_v_Object, __pyx_v_ForceDraw); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_20AddDrawObject(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Object, PyObject *__pyx_v_ForceDraw) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + __Pyx_RefNannySetupContext("AddDrawObject", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":87 + * self.DrawObjects = [] + * def AddDrawObject(self,Object,ForceDraw): + * self.DrawObjects.append({"Object":Object,"ForceDraw":ForceDraw}) # <<<<<<<<<<<<<< + * + * def Get_Coord(self): + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_DrawObjects); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_Object, __pyx_v_Object) < 0) __PYX_ERR(0, 87, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_ForceDraw, __pyx_v_ForceDraw) < 0) __PYX_ERR(0, 87, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_t_2); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":86 + * def ResetDrawObject(self): + * self.DrawObjects = [] + * def AddDrawObject(self,Object,ForceDraw): # <<<<<<<<<<<<<< + * self.DrawObjects.append({"Object":Object,"ForceDraw":ForceDraw}) + * + */ + + /* 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("CAStar.AATC_Monitor_Viewer.Camera.AddDrawObject", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":89 + * self.DrawObjects.append({"Object":Object,"ForceDraw":ForceDraw}) + * + * def Get_Coord(self): # <<<<<<<<<<<<<< + * return self.CameraCoord + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_23Get_Coord(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_23Get_Coord = {"Get_Coord", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_23Get_Coord, METH_O, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_23Get_Coord(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("Get_Coord (wrapper)", 0); + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_22Get_Coord(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_22Get_Coord(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("Get_Coord", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":90 + * + * def Get_Coord(self): + * return self.CameraCoord # <<<<<<<<<<<<<< + * + * def Draw(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":89 + * self.DrawObjects.append({"Object":Object,"ForceDraw":ForceDraw}) + * + * def Get_Coord(self): # <<<<<<<<<<<<<< + * return self.CameraCoord + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.Get_Coord", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":92 + * return self.CameraCoord + * + * def Draw(self): # <<<<<<<<<<<<<< + * cdef float CameraEndX,CameraEndY,CameraX,CameraY,CameraXSize,CameraYSize,x,y,xSize,ySize,PosX,PosY + * cdef int width,height,xpixel,ypixel,font_size + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_25Draw(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_25Draw = {"Draw", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_25Draw, METH_O, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_25Draw(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("Draw (wrapper)", 0); + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_24Draw(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_24Draw(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + float __pyx_v_CameraEndX; + float __pyx_v_CameraEndY; + float __pyx_v_CameraX; + float __pyx_v_CameraY; + float __pyx_v_CameraXSize; + float __pyx_v_CameraYSize; + float __pyx_v_x; + float __pyx_v_y; + float __pyx_v_xSize; + float __pyx_v_ySize; + float __pyx_v_PosX; + float __pyx_v_PosY; + int __pyx_v_width; + int __pyx_v_height; + int __pyx_v_xpixel; + int __pyx_v_ypixel; + int __pyx_v_font_size; + PyObject *__pyx_v_DrawObject = NULL; + PyObject *__pyx_v_Object = NULL; + PyObject *__pyx_v_Object_Coords = NULL; + PyObject *__pyx_v_image = NULL; + PyObject *__pyx_v_font = 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; + float __pyx_t_5; + int __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; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + __Pyx_RefNannySetupContext("Draw", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":96 + * cdef int width,height,xpixel,ypixel,font_size + * + * CameraEndX= self.CameraCoord.Get_X() + self.CameraCoord.Get_XSize() #Moved to new variablt to reduce recalculation # <<<<<<<<<<<<<< + * CameraEndY = self.CameraCoord.Get_Y() + self.CameraCoord.Get_YSize() + * CameraX = self.CameraCoord.Get_X() + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 96, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_2) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_CameraEndX = __pyx_t_5; + + /* "CAStar/AATC_Monitor_Viewer.pyx":97 + * + * CameraEndX= self.CameraCoord.Get_X() + self.CameraCoord.Get_XSize() #Moved to new variablt to reduce recalculation + * CameraEndY = self.CameraCoord.Get_Y() + self.CameraCoord.Get_YSize() # <<<<<<<<<<<<<< + * CameraX = self.CameraCoord.Get_X() + * CameraY = self.CameraCoord.Get_Y() + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (__pyx_t_3) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Get_YSize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_CameraEndY = __pyx_t_5; + + /* "CAStar/AATC_Monitor_Viewer.pyx":98 + * CameraEndX= self.CameraCoord.Get_X() + self.CameraCoord.Get_XSize() #Moved to new variablt to reduce recalculation + * CameraEndY = self.CameraCoord.Get_Y() + self.CameraCoord.Get_YSize() + * CameraX = self.CameraCoord.Get_X() # <<<<<<<<<<<<<< + * CameraY = self.CameraCoord.Get_Y() + * CameraXSize = self.CameraCoord.Get_XSize() + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_1) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_CameraX = __pyx_t_5; + + /* "CAStar/AATC_Monitor_Viewer.pyx":99 + * CameraEndY = self.CameraCoord.Get_Y() + self.CameraCoord.Get_YSize() + * CameraX = self.CameraCoord.Get_X() + * CameraY = self.CameraCoord.Get_Y() # <<<<<<<<<<<<<< + * CameraXSize = self.CameraCoord.Get_XSize() + * CameraYSize = self.CameraCoord.Get_YSize() + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_CameraY = __pyx_t_5; + + /* "CAStar/AATC_Monitor_Viewer.pyx":100 + * CameraX = self.CameraCoord.Get_X() + * CameraY = self.CameraCoord.Get_Y() + * CameraXSize = self.CameraCoord.Get_XSize() # <<<<<<<<<<<<<< + * CameraYSize = self.CameraCoord.Get_YSize() + * xpixel,ypixel = self.xpixel,self.ypixel + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_1) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_CameraXSize = __pyx_t_5; + + /* "CAStar/AATC_Monitor_Viewer.pyx":101 + * CameraY = self.CameraCoord.Get_Y() + * CameraXSize = self.CameraCoord.Get_XSize() + * CameraYSize = self.CameraCoord.Get_YSize() # <<<<<<<<<<<<<< + * xpixel,ypixel = self.xpixel,self.ypixel + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Get_YSize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_CameraYSize = __pyx_t_5; + + /* "CAStar/AATC_Monitor_Viewer.pyx":102 + * CameraXSize = self.CameraCoord.Get_XSize() + * CameraYSize = self.CameraCoord.Get_YSize() + * xpixel,ypixel = self.xpixel,self.ypixel # <<<<<<<<<<<<<< + * + * for DrawObject in self.DrawObjects: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_xpixel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ypixel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_xpixel = __pyx_t_6; + __pyx_v_ypixel = __pyx_t_7; + + /* "CAStar/AATC_Monitor_Viewer.pyx":104 + * xpixel,ypixel = self.xpixel,self.ypixel + * + * for DrawObject in self.DrawObjects: # <<<<<<<<<<<<<< + * Object = DrawObject["Object"] + * Object_Coords = Object.Get_Coords() + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_DrawObjects); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_8 = 0; + __pyx_t_9 = NULL; + } else { + __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 104, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_9)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_2); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 104, __pyx_L1_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_2); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 104, __pyx_L1_error) + #else + __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_9(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 104, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_DrawObject, __pyx_t_2); + __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":105 + * + * for DrawObject in self.DrawObjects: + * Object = DrawObject["Object"] # <<<<<<<<<<<<<< + * Object_Coords = Object.Get_Coords() + * x = Object_Coords.Get_X() + */ + __pyx_t_2 = PyObject_GetItem(__pyx_v_DrawObject, __pyx_n_s_Object); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_Object, __pyx_t_2); + __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":106 + * for DrawObject in self.DrawObjects: + * Object = DrawObject["Object"] + * Object_Coords = Object.Get_Coords() # <<<<<<<<<<<<<< + * x = Object_Coords.Get_X() + * y = Object_Coords.Get_Y() + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object, __pyx_n_s_Get_Coords); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_3) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_Object_Coords, __pyx_t_2); + __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":107 + * Object = DrawObject["Object"] + * Object_Coords = Object.Get_Coords() + * x = Object_Coords.Get_X() # <<<<<<<<<<<<<< + * y = Object_Coords.Get_Y() + * xSize = Object_Coords.Get_XSize() + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object_Coords, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_3) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_x = __pyx_t_5; + + /* "CAStar/AATC_Monitor_Viewer.pyx":108 + * Object_Coords = Object.Get_Coords() + * x = Object_Coords.Get_X() + * y = Object_Coords.Get_Y() # <<<<<<<<<<<<<< + * xSize = Object_Coords.Get_XSize() + * ySize = Object_Coords.Get_YSize() + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object_Coords, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_3) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_y = __pyx_t_5; + + /* "CAStar/AATC_Monitor_Viewer.pyx":109 + * x = Object_Coords.Get_X() + * y = Object_Coords.Get_Y() + * xSize = Object_Coords.Get_XSize() # <<<<<<<<<<<<<< + * ySize = Object_Coords.Get_YSize() + * if ((x < CameraEndX) and ((x+xSize) > CameraX)) and \ + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object_Coords, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_3) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_xSize = __pyx_t_5; + + /* "CAStar/AATC_Monitor_Viewer.pyx":110 + * y = Object_Coords.Get_Y() + * xSize = Object_Coords.Get_XSize() + * ySize = Object_Coords.Get_YSize() # <<<<<<<<<<<<<< + * if ((x < CameraEndX) and ((x+xSize) > CameraX)) and \ + * ((y < CameraEndY) and ((y+ySize) > CameraY )) : #If DrawObject intersects with Camera , Render, otherwise ignore + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object_Coords, __pyx_n_s_Get_YSize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_3) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_ySize = __pyx_t_5; + + /* "CAStar/AATC_Monitor_Viewer.pyx":111 + * xSize = Object_Coords.Get_XSize() + * ySize = Object_Coords.Get_YSize() + * if ((x < CameraEndX) and ((x+xSize) > CameraX)) and \ # <<<<<<<<<<<<<< + * ((y < CameraEndY) and ((y+ySize) > CameraY )) : #If DrawObject intersects with Camera , Render, otherwise ignore + * + */ + __pyx_t_11 = ((__pyx_v_x < __pyx_v_CameraEndX) != 0); + if (__pyx_t_11) { + } else { + __pyx_t_10 = __pyx_t_11; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_11 = (((__pyx_v_x + __pyx_v_xSize) > __pyx_v_CameraX) != 0); + if (__pyx_t_11) { + } else { + __pyx_t_10 = __pyx_t_11; + goto __pyx_L6_bool_binop_done; + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":112 + * ySize = Object_Coords.Get_YSize() + * if ((x < CameraEndX) and ((x+xSize) > CameraX)) and \ + * ((y < CameraEndY) and ((y+ySize) > CameraY )) : #If DrawObject intersects with Camera , Render, otherwise ignore # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_11 = ((__pyx_v_y < __pyx_v_CameraEndY) != 0); + if (__pyx_t_11) { + } else { + __pyx_t_10 = __pyx_t_11; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_11 = (((__pyx_v_y + __pyx_v_ySize) > __pyx_v_CameraY) != 0); + __pyx_t_10 = __pyx_t_11; + __pyx_L6_bool_binop_done:; + + /* "CAStar/AATC_Monitor_Viewer.pyx":111 + * xSize = Object_Coords.Get_XSize() + * ySize = Object_Coords.Get_YSize() + * if ((x < CameraEndX) and ((x+xSize) > CameraX)) and \ # <<<<<<<<<<<<<< + * ((y < CameraEndY) and ((y+ySize) > CameraY )) : #If DrawObject intersects with Camera , Render, otherwise ignore + * + */ + if (__pyx_t_10) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":115 + * + * + * width,height = int(xSize/CameraXSize*xpixel) ,int(ySize/CameraYSize*ypixel) # Would benifit from being cythonised # <<<<<<<<<<<<<< + * if width > 0 and height > 0: + * PosX = ((x- CameraX)/CameraXSize)* xpixel # Would benifit from being cythonised + */ + __pyx_v_width = ((int)((__pyx_v_xSize / __pyx_v_CameraXSize) * __pyx_v_xpixel)); + __pyx_v_height = ((int)((__pyx_v_ySize / __pyx_v_CameraYSize) * __pyx_v_ypixel)); + + /* "CAStar/AATC_Monitor_Viewer.pyx":116 + * + * width,height = int(xSize/CameraXSize*xpixel) ,int(ySize/CameraYSize*ypixel) # Would benifit from being cythonised + * if width > 0 and height > 0: # <<<<<<<<<<<<<< + * PosX = ((x- CameraX)/CameraXSize)* xpixel # Would benifit from being cythonised + * PosY = ((y- CameraY)/CameraYSize)* ypixel + */ + __pyx_t_11 = ((__pyx_v_width > 0) != 0); + if (__pyx_t_11) { + } else { + __pyx_t_10 = __pyx_t_11; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_11 = ((__pyx_v_height > 0) != 0); + __pyx_t_10 = __pyx_t_11; + __pyx_L11_bool_binop_done:; + if (__pyx_t_10) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":117 + * width,height = int(xSize/CameraXSize*xpixel) ,int(ySize/CameraYSize*ypixel) # Would benifit from being cythonised + * if width > 0 and height > 0: + * PosX = ((x- CameraX)/CameraXSize)* xpixel # Would benifit from being cythonised # <<<<<<<<<<<<<< + * PosY = ((y- CameraY)/CameraYSize)* ypixel + * width = MaxLimit(width,xpixel) + */ + __pyx_v_PosX = (((__pyx_v_x - __pyx_v_CameraX) / __pyx_v_CameraXSize) * __pyx_v_xpixel); + + /* "CAStar/AATC_Monitor_Viewer.pyx":118 + * if width > 0 and height > 0: + * PosX = ((x- CameraX)/CameraXSize)* xpixel # Would benifit from being cythonised + * PosY = ((y- CameraY)/CameraYSize)* ypixel # <<<<<<<<<<<<<< + * width = MaxLimit(width,xpixel) + * height = MaxLimit(height,ypixel) + */ + __pyx_v_PosY = (((__pyx_v_y - __pyx_v_CameraY) / __pyx_v_CameraYSize) * __pyx_v_ypixel); + + /* "CAStar/AATC_Monitor_Viewer.pyx":119 + * PosX = ((x- CameraX)/CameraXSize)* xpixel # Would benifit from being cythonised + * PosY = ((y- CameraY)/CameraYSize)* ypixel + * width = MaxLimit(width,xpixel) # <<<<<<<<<<<<<< + * height = MaxLimit(height,ypixel) + * font_size = int(100*width/xpixel) # Would benifit from being cythonised + */ + __pyx_v_width = __pyx_f_6CAStar_19AATC_Monitor_Viewer_MaxLimit(__pyx_v_width, __pyx_v_xpixel); + + /* "CAStar/AATC_Monitor_Viewer.pyx":120 + * PosY = ((y- CameraY)/CameraYSize)* ypixel + * width = MaxLimit(width,xpixel) + * height = MaxLimit(height,ypixel) # <<<<<<<<<<<<<< + * font_size = int(100*width/xpixel) # Would benifit from being cythonised + * image = Object.Make_Image(width,height) + */ + __pyx_v_height = __pyx_f_6CAStar_19AATC_Monitor_Viewer_MaxLimit(__pyx_v_height, __pyx_v_ypixel); + + /* "CAStar/AATC_Monitor_Viewer.pyx":121 + * width = MaxLimit(width,xpixel) + * height = MaxLimit(height,ypixel) + * font_size = int(100*width/xpixel) # Would benifit from being cythonised # <<<<<<<<<<<<<< + * image = Object.Make_Image(width,height) + * self.gameDisplay.blit(image,(PosX,PosY)) + */ + __pyx_v_font_size = ((int)((0x64 * __pyx_v_width) / __pyx_v_xpixel)); + + /* "CAStar/AATC_Monitor_Viewer.pyx":122 + * height = MaxLimit(height,ypixel) + * font_size = int(100*width/xpixel) # Would benifit from being cythonised + * image = Object.Make_Image(width,height) # <<<<<<<<<<<<<< + * self.gameDisplay.blit(image,(PosX,PosY)) + * if font_size > 5: + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object, __pyx_n_s_Make_Image); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_width); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_12 = __Pyx_PyInt_From_int(__pyx_v_height); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_13, __pyx_t_3, __pyx_t_12}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_13, __pyx_t_3, __pyx_t_12}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else + #endif + { + __pyx_t_14 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + if (__pyx_t_13) { + __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_13); __pyx_t_13 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_7, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_7, __pyx_t_12); + __pyx_t_3 = 0; + __pyx_t_12 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_14, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_image, __pyx_t_2); + __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":123 + * font_size = int(100*width/xpixel) # Would benifit from being cythonised + * image = Object.Make_Image(width,height) + * self.gameDisplay.blit(image,(PosX,PosY)) # <<<<<<<<<<<<<< + * if font_size > 5: + * font = (None, font_size) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_gameDisplay); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_blit); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_PosX); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_PosY); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_12); + __pyx_t_4 = 0; + __pyx_t_12 = 0; + __pyx_t_12 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_14))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_14); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_14, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_14)) { + PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_v_image, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_14)) { + PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_v_image, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_12) { + __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_12); __pyx_t_12 = NULL; + } + __Pyx_INCREF(__pyx_v_image); + __Pyx_GIVEREF(__pyx_v_image); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_7, __pyx_v_image); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_7, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":124 + * image = Object.Make_Image(width,height) + * self.gameDisplay.blit(image,(PosX,PosY)) + * if font_size > 5: # <<<<<<<<<<<<<< + * font = (None, font_size) + * self.gameDisplay.blit(Object.Make_Text(font) ,(PosX+width,PosY)) + */ + __pyx_t_10 = ((__pyx_v_font_size > 5) != 0); + if (__pyx_t_10) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":125 + * self.gameDisplay.blit(image,(PosX,PosY)) + * if font_size > 5: + * font = (None, font_size) # <<<<<<<<<<<<<< + * self.gameDisplay.blit(Object.Make_Text(font) ,(PosX+width,PosY)) + * + */ + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_font_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_14 = PyTuple_New(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_14, 0, Py_None); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_font, ((PyObject*)__pyx_t_14)); + __pyx_t_14 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":126 + * if font_size > 5: + * font = (None, font_size) + * self.gameDisplay.blit(Object.Make_Text(font) ,(PosX+width,PosY)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_gameDisplay); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_blit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object, __pyx_n_s_Make_Text); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_12 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_12) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_font); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_v_font}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_v_font}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __pyx_t_12 = NULL; + __Pyx_INCREF(__pyx_v_font); + __Pyx_GIVEREF(__pyx_v_font); + PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_v_font); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_PosX + __pyx_v_width)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = PyFloat_FromDouble(__pyx_v_PosY); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_13); + PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_13); + __pyx_t_3 = 0; + __pyx_t_13 = 0; + __pyx_t_13 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_13, __pyx_t_2, __pyx_t_12}; + __pyx_t_14 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_13, __pyx_t_2, __pyx_t_12}; + __pyx_t_14 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } else + #endif + { + __pyx_t_3 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__pyx_t_13) { + __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_13); __pyx_t_13 = NULL; + } + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_7, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_7, __pyx_t_12); + __pyx_t_2 = 0; + __pyx_t_12 = 0; + __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, NULL); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":124 + * image = Object.Make_Image(width,height) + * self.gameDisplay.blit(image,(PosX,PosY)) + * if font_size > 5: # <<<<<<<<<<<<<< + * font = (None, font_size) + * self.gameDisplay.blit(Object.Make_Text(font) ,(PosX+width,PosY)) + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":116 + * + * width,height = int(xSize/CameraXSize*xpixel) ,int(ySize/CameraYSize*ypixel) # Would benifit from being cythonised + * if width > 0 and height > 0: # <<<<<<<<<<<<<< + * PosX = ((x- CameraX)/CameraXSize)* xpixel # Would benifit from being cythonised + * PosY = ((y- CameraY)/CameraYSize)* ypixel + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":111 + * xSize = Object_Coords.Get_XSize() + * ySize = Object_Coords.Get_YSize() + * if ((x < CameraEndX) and ((x+xSize) > CameraX)) and \ # <<<<<<<<<<<<<< + * ((y < CameraEndY) and ((y+ySize) > CameraY )) : #If DrawObject intersects with Camera , Render, otherwise ignore + * + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":104 + * xpixel,ypixel = self.xpixel,self.ypixel + * + * for DrawObject in self.DrawObjects: # <<<<<<<<<<<<<< + * Object = DrawObject["Object"] + * Object_Coords = Object.Get_Coords() + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":92 + * return self.CameraCoord + * + * def Draw(self): # <<<<<<<<<<<<<< + * cdef float CameraEndX,CameraEndY,CameraX,CameraY,CameraXSize,CameraYSize,x,y,xSize,ySize,PosX,PosY + * cdef int width,height,xpixel,ypixel,font_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_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.Draw", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_DrawObject); + __Pyx_XDECREF(__pyx_v_Object); + __Pyx_XDECREF(__pyx_v_Object_Coords); + __Pyx_XDECREF(__pyx_v_image); + __Pyx_XDECREF(__pyx_v_font); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":134 + * + * class Monitor_Sprite(pygame.sprite.Sprite): + * def __init__(self,CoordObject,Type = "",Text = "",Colour = (255,255,255)): # <<<<<<<<<<<<<< + * self.Coords = CoordObject + * self.Type = Type + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_1__init__ = {"__init__", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_1__init__, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_CoordObject = 0; + PyObject *__pyx_v_Type = 0; + PyObject *__pyx_v_Text = 0; + PyObject *__pyx_v_Colour = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_CoordObject,&__pyx_n_s_Type,&__pyx_n_s_Text,&__pyx_n_s_Colour,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[2] = ((PyObject *)((PyObject*)__pyx_kp_s__2)); + values[3] = ((PyObject *)((PyObject*)__pyx_kp_s__2)); + values[4] = ((PyObject *)((PyObject*)__pyx_tuple__3)); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_CoordObject)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, 1); __PYX_ERR(0, 134, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Type); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Text); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Colour); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 134, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_self = values[0]; + __pyx_v_CoordObject = values[1]; + __pyx_v_Type = values[2]; + __pyx_v_Text = values[3]; + __pyx_v_Colour = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 134, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite___init__(__pyx_self, __pyx_v_self, __pyx_v_CoordObject, __pyx_v_Type, __pyx_v_Text, __pyx_v_Colour); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_CoordObject, PyObject *__pyx_v_Type, PyObject *__pyx_v_Text, PyObject *__pyx_v_Colour) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":135 + * class Monitor_Sprite(pygame.sprite.Sprite): + * def __init__(self,CoordObject,Type = "",Text = "",Colour = (255,255,255)): + * self.Coords = CoordObject # <<<<<<<<<<<<<< + * self.Type = Type + * self.Text = Text + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Coords, __pyx_v_CoordObject) < 0) __PYX_ERR(0, 135, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":136 + * def __init__(self,CoordObject,Type = "",Text = "",Colour = (255,255,255)): + * self.Coords = CoordObject + * self.Type = Type # <<<<<<<<<<<<<< + * self.Text = Text + * self.Colour = Colour + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Type, __pyx_v_Type) < 0) __PYX_ERR(0, 136, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":137 + * self.Coords = CoordObject + * self.Type = Type + * self.Text = Text # <<<<<<<<<<<<<< + * self.Colour = Colour + * self.image = pygame.Surface((1,1)) + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Text, __pyx_v_Text) < 0) __PYX_ERR(0, 137, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":138 + * self.Type = Type + * self.Text = Text + * self.Colour = Colour # <<<<<<<<<<<<<< + * self.image = pygame.Surface((1,1)) + * #self.Make_Image(2,2) # No longer needed, is similar to that above. + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Colour, __pyx_v_Colour) < 0) __PYX_ERR(0, 138, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":139 + * self.Text = Text + * self.Colour = Colour + * self.image = pygame.Surface((1,1)) # <<<<<<<<<<<<<< + * #self.Make_Image(2,2) # No longer needed, is similar to that above. + * + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Surface); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_image, __pyx_t_1) < 0) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":134 + * + * class Monitor_Sprite(pygame.sprite.Sprite): + * def __init__(self,CoordObject,Type = "",Text = "",Colour = (255,255,255)): # <<<<<<<<<<<<<< + * self.Coords = CoordObject + * self.Type = 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_2); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":142 + * #self.Make_Image(2,2) # No longer needed, is similar to that above. + * + * def Make_Image(self, int width, int height): # <<<<<<<<<<<<<< + * if self.image.get_size() != (width,height): #If new image does not match with previous + * self.image = GetImage(width,height,self.Colour) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_3Make_Image(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_3Make_Image = {"Make_Image", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_3Make_Image, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_3Make_Image(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + int __pyx_v_width; + int __pyx_v_height; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("Make_Image (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_width,&__pyx_n_s_height,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_width)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("Make_Image", 1, 3, 3, 1); __PYX_ERR(0, 142, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_height)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("Make_Image", 1, 3, 3, 2); __PYX_ERR(0, 142, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "Make_Image") < 0)) __PYX_ERR(0, 142, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_self = values[0]; + __pyx_v_width = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_width == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 142, __pyx_L3_error) + __pyx_v_height = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_height == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 142, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("Make_Image", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 142, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.Make_Image", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_2Make_Image(__pyx_self, __pyx_v_self, __pyx_v_width, __pyx_v_height); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_2Make_Image(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, int __pyx_v_width, int __pyx_v_height) { + 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; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("Make_Image", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":143 + * + * def Make_Image(self, int width, int height): + * if self.image.get_size() != (width,height): #If new image does not match with previous # <<<<<<<<<<<<<< + * self.image = GetImage(width,height,self.Colour) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_image); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_width); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_height); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); + __pyx_t_3 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":144 + * def Make_Image(self, int width, int height): + * if self.image.get_size() != (width,height): #If new image does not match with previous + * self.image = GetImage(width,height,self.Colour) # <<<<<<<<<<<<<< + * + * return self.image + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_GetImage); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_width); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_height); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Colour); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_1, __pyx_t_3, __pyx_t_6}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_1, __pyx_t_3, __pyx_t_6}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_6); + __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_t_6 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_image, __pyx_t_2) < 0) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":143 + * + * def Make_Image(self, int width, int height): + * if self.image.get_size() != (width,height): #If new image does not match with previous # <<<<<<<<<<<<<< + * self.image = GetImage(width,height,self.Colour) + * + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":146 + * self.image = GetImage(width,height,self.Colour) + * + * return self.image # <<<<<<<<<<<<<< + * ## self.image = pygame.Surface((width,height)).convert() + * ## self.image.fill(self.Colour) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_image); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":142 + * #self.Make_Image(2,2) # No longer needed, is similar to that above. + * + * def Make_Image(self, int width, int height): # <<<<<<<<<<<<<< + * if self.image.get_size() != (width,height): #If new image does not match with previous + * self.image = GetImage(width,height,self.Colour) + */ + + /* 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_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.Make_Image", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":150 + * ## self.image.fill(self.Colour) + * + * def Make_Text(self,font): # <<<<<<<<<<<<<< + * text = str((self.Coords.Get_X(),self.Coords.Get_Y(),self.Coords.Get_Z())) +" " +self.Text + " "+ self.Type + * return GetText(text,font,False,self.Colour) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_5Make_Text(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_5Make_Text = {"Make_Text", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_5Make_Text, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_5Make_Text(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_font = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("Make_Text (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_font,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_font)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("Make_Text", 1, 2, 2, 1); __PYX_ERR(0, 150, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "Make_Text") < 0)) __PYX_ERR(0, 150, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_self = values[0]; + __pyx_v_font = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("Make_Text", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 150, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.Make_Text", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_4Make_Text(__pyx_self, __pyx_v_self, __pyx_v_font); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_4Make_Text(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_font) { + PyObject *__pyx_v_text = 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; + int __pyx_t_6; + __Pyx_RefNannySetupContext("Make_Text", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":151 + * + * def Make_Text(self,font): + * text = str((self.Coords.Get_X(),self.Coords.Get_Y(),self.Coords.Get_Z())) +" " +self.Text + " "+ self.Type # <<<<<<<<<<<<<< + * return GetText(text,font,False,self.Colour) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Coords); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Coords); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_2) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Coords); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_Z); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4); + __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_kp_s__6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Text); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Add(__pyx_t_3, __pyx_kp_s__6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_text = __pyx_t_4; + __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":152 + * def Make_Text(self,font): + * text = str((self.Coords.Get_X(),self.Coords.Get_Y(),self.Coords.Get_Z())) +" " +self.Text + " "+ self.Type + * return GetText(text,font,False,self.Colour) # <<<<<<<<<<<<<< + * + * def Get_Coords(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_GetText); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Colour); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = NULL; + __pyx_t_6 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[5] = {__pyx_t_1, __pyx_v_text, __pyx_v_font, Py_False, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[5] = {__pyx_t_1, __pyx_v_text, __pyx_v_font, Py_False, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_2 = PyTuple_New(4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_1) { + __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); __pyx_t_1 = NULL; + } + __Pyx_INCREF(__pyx_v_text); + __Pyx_GIVEREF(__pyx_v_text); + PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_6, __pyx_v_text); + __Pyx_INCREF(__pyx_v_font); + __Pyx_GIVEREF(__pyx_v_font); + PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_6, __pyx_v_font); + __Pyx_INCREF(Py_False); + __Pyx_GIVEREF(Py_False); + PyTuple_SET_ITEM(__pyx_t_2, 2+__pyx_t_6, Py_False); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_2, 3+__pyx_t_6, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":150 + * ## self.image.fill(self.Colour) + * + * def Make_Text(self,font): # <<<<<<<<<<<<<< + * text = str((self.Coords.Get_X(),self.Coords.Get_Y(),self.Coords.Get_Z())) +" " +self.Text + " "+ self.Type + * return GetText(text,font,False,self.Colour) + */ + + /* 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("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.Make_Text", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_text); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":154 + * return GetText(text,font,False,self.Colour) + * + * def Get_Coords(self): # <<<<<<<<<<<<<< + * return self.Coords + * ## + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_7Get_Coords(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_7Get_Coords = {"Get_Coords", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_7Get_Coords, METH_O, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_7Get_Coords(PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("Get_Coords (wrapper)", 0); + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_6Get_Coords(__pyx_self, ((PyObject *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_6Get_Coords(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("Get_Coords", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":155 + * + * def Get_Coords(self): + * return self.Coords # <<<<<<<<<<<<<< + * ## + * ## def Make_CoordsText(self,font): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Coords); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":154 + * return GetText(text,font,False,self.Colour) + * + * def Get_Coords(self): # <<<<<<<<<<<<<< + * return self.Coords + * ## + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.Get_Coords", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":170 + * + * + * def MakeDroneSprites(Message,RawDroneList): # <<<<<<<<<<<<<< + * DroneList = [] + * Columns = ast.literal_eval(Message) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_7MakeDroneSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_7MakeDroneSprites = {"MakeDroneSprites", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_7MakeDroneSprites, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_7MakeDroneSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_Message = 0; + PyObject *__pyx_v_RawDroneList = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("MakeDroneSprites (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Message,&__pyx_n_s_RawDroneList,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Message)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_RawDroneList)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("MakeDroneSprites", 1, 2, 2, 1); __PYX_ERR(0, 170, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MakeDroneSprites") < 0)) __PYX_ERR(0, 170, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_Message = values[0]; + __pyx_v_RawDroneList = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("MakeDroneSprites", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 170, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeDroneSprites", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6MakeDroneSprites(__pyx_self, __pyx_v_Message, __pyx_v_RawDroneList); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6MakeDroneSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Message, PyObject *__pyx_v_RawDroneList) { + PyObject *__pyx_v_DroneList = NULL; + PyObject *__pyx_v_Columns = NULL; + PyObject *__pyx_v_CoordIndex = NULL; + PyObject *__pyx_v_DroneIDIndex = NULL; + PyObject *__pyx_v_UserIDIndex = NULL; + PyObject *__pyx_v_DroneNameIndex = NULL; + PyObject *__pyx_v_BatteryIndex = NULL; + PyObject *__pyx_v_Drone = NULL; + PyObject *__pyx_v_LastCoords = NULL; + PyObject *__pyx_v_Coord = NULL; + PyObject *__pyx_v_Text = NULL; + __pyx_ctuple_long__and_long__and_long __pyx_v_Colour; + PyObject *__pyx_v_Sprite = 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; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + __pyx_ctuple_long__and_long__and_long __pyx_t_12; + int __pyx_t_13; + __Pyx_RefNannySetupContext("MakeDroneSprites", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":171 + * + * def MakeDroneSprites(Message,RawDroneList): + * DroneList = [] # <<<<<<<<<<<<<< + * Columns = ast.literal_eval(Message) + * CoordIndex = Columns.index("LastCoords") + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_DroneList = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":172 + * def MakeDroneSprites(Message,RawDroneList): + * DroneList = [] + * Columns = ast.literal_eval(Message) # <<<<<<<<<<<<<< + * CoordIndex = Columns.index("LastCoords") + * DroneIDIndex = Columns.index("DroneID") + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_Message); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_v_Message); + __Pyx_GIVEREF(__pyx_v_Message); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_Message); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_Columns = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":173 + * DroneList = [] + * Columns = ast.literal_eval(Message) + * CoordIndex = Columns.index("LastCoords") # <<<<<<<<<<<<<< + * DroneIDIndex = Columns.index("DroneID") + * UserIDIndex = Columns.index("UserID") + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_CoordIndex = __pyx_t_3; + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":174 + * Columns = ast.literal_eval(Message) + * CoordIndex = Columns.index("LastCoords") + * DroneIDIndex = Columns.index("DroneID") # <<<<<<<<<<<<<< + * UserIDIndex = Columns.index("UserID") + * DroneNameIndex = Columns.index("DroneName") + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_DroneIDIndex = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":175 + * CoordIndex = Columns.index("LastCoords") + * DroneIDIndex = Columns.index("DroneID") + * UserIDIndex = Columns.index("UserID") # <<<<<<<<<<<<<< + * DroneNameIndex = Columns.index("DroneName") + * BatteryIndex = Columns.index("LastBattery") + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_UserIDIndex = __pyx_t_3; + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":176 + * DroneIDIndex = Columns.index("DroneID") + * UserIDIndex = Columns.index("UserID") + * DroneNameIndex = Columns.index("DroneName") # <<<<<<<<<<<<<< + * BatteryIndex = Columns.index("LastBattery") + * for Drone in RawDroneList: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_DroneNameIndex = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":177 + * UserIDIndex = Columns.index("UserID") + * DroneNameIndex = Columns.index("DroneName") + * BatteryIndex = Columns.index("LastBattery") # <<<<<<<<<<<<<< + * for Drone in RawDroneList: + * LastCoords = ast.literal_eval(Drone[CoordIndex]) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_BatteryIndex = __pyx_t_3; + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":178 + * DroneNameIndex = Columns.index("DroneName") + * BatteryIndex = Columns.index("LastBattery") + * for Drone in RawDroneList: # <<<<<<<<<<<<<< + * LastCoords = ast.literal_eval(Drone[CoordIndex]) + * Coord = AATC_Coordinate.Coordinate(LastCoords[0],LastCoords[1],LastCoords[2],0.001,0.001,0.00001) + */ + if (likely(PyList_CheckExact(__pyx_v_RawDroneList)) || PyTuple_CheckExact(__pyx_v_RawDroneList)) { + __pyx_t_3 = __pyx_v_RawDroneList; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_RawDroneList); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 178, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 178, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 178, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_6(__pyx_t_3); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 178, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_Drone, __pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":179 + * BatteryIndex = Columns.index("LastBattery") + * for Drone in RawDroneList: + * LastCoords = ast.literal_eval(Drone[CoordIndex]) # <<<<<<<<<<<<<< + * Coord = AATC_Coordinate.Coordinate(LastCoords[0],LastCoords[1],LastCoords[2],0.001,0.001,0.00001) + * Text = "D:"+str(Drone[DroneIDIndex]) +" U:"+str(Drone[UserIDIndex]) +" N:"+str(Drone[DroneNameIndex])+" B:"+str(Drone[BatteryIndex]) + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyObject_GetItem(__pyx_v_Drone, __pyx_v_CoordIndex); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_7) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_LastCoords, __pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":180 + * for Drone in RawDroneList: + * LastCoords = ast.literal_eval(Drone[CoordIndex]) + * Coord = AATC_Coordinate.Coordinate(LastCoords[0],LastCoords[1],LastCoords[2],0.001,0.001,0.00001) # <<<<<<<<<<<<<< + * Text = "D:"+str(Drone[DroneIDIndex]) +" U:"+str(Drone[UserIDIndex]) +" N:"+str(Drone[DroneNameIndex])+" B:"+str(Drone[BatteryIndex]) + * Colour = (255,255,255) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_LastCoords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_LastCoords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_LastCoords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[7] = {__pyx_t_9, __pyx_t_2, __pyx_t_4, __pyx_t_7, __pyx_float_0_001, __pyx_float_0_001, __pyx_float_0_00001}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[7] = {__pyx_t_9, __pyx_t_2, __pyx_t_4, __pyx_t_7, __pyx_float_0_001, __pyx_float_0_001, __pyx_float_0_00001}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(6+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (__pyx_t_9) { + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; + } + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_t_7); + __Pyx_INCREF(__pyx_float_0_001); + __Pyx_GIVEREF(__pyx_float_0_001); + PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_10, __pyx_float_0_001); + __Pyx_INCREF(__pyx_float_0_001); + __Pyx_GIVEREF(__pyx_float_0_001); + PyTuple_SET_ITEM(__pyx_t_11, 4+__pyx_t_10, __pyx_float_0_001); + __Pyx_INCREF(__pyx_float_0_00001); + __Pyx_GIVEREF(__pyx_float_0_00001); + PyTuple_SET_ITEM(__pyx_t_11, 5+__pyx_t_10, __pyx_float_0_00001); + __pyx_t_2 = 0; + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF_SET(__pyx_v_Coord, __pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":181 + * LastCoords = ast.literal_eval(Drone[CoordIndex]) + * Coord = AATC_Coordinate.Coordinate(LastCoords[0],LastCoords[1],LastCoords[2],0.001,0.001,0.00001) + * Text = "D:"+str(Drone[DroneIDIndex]) +" U:"+str(Drone[UserIDIndex]) +" N:"+str(Drone[DroneNameIndex])+" B:"+str(Drone[BatteryIndex]) # <<<<<<<<<<<<<< + * Colour = (255,255,255) + * Sprite = Monitor_Sprite(Coord,"Drone",Text,Colour) + */ + __pyx_t_1 = PyObject_GetItem(__pyx_v_Drone, __pyx_v_DroneIDIndex); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_kp_s_D, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_kp_s_U); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyObject_GetItem(__pyx_v_Drone, __pyx_v_UserIDIndex); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyNumber_Add(__pyx_t_1, __pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_t_11, __pyx_kp_s_N); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyObject_GetItem(__pyx_v_Drone, __pyx_v_DroneNameIndex); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_11); + __pyx_t_11 = 0; + __pyx_t_11 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyNumber_Add(__pyx_t_1, __pyx_kp_s_B); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_GetItem(__pyx_v_Drone, __pyx_v_BatteryIndex); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_t_11, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_Text, __pyx_t_8); + __pyx_t_8 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":182 + * Coord = AATC_Coordinate.Coordinate(LastCoords[0],LastCoords[1],LastCoords[2],0.001,0.001,0.00001) + * Text = "D:"+str(Drone[DroneIDIndex]) +" U:"+str(Drone[UserIDIndex]) +" N:"+str(Drone[DroneNameIndex])+" B:"+str(Drone[BatteryIndex]) + * Colour = (255,255,255) # <<<<<<<<<<<<<< + * Sprite = Monitor_Sprite(Coord,"Drone",Text,Colour) + * DroneList.append(Sprite) + */ + __pyx_t_12.f0 = 0xFF; + __pyx_t_12.f1 = 0xFF; + __pyx_t_12.f2 = 0xFF; + __pyx_v_Colour = __pyx_t_12; + + /* "CAStar/AATC_Monitor_Viewer.pyx":183 + * Text = "D:"+str(Drone[DroneIDIndex]) +" U:"+str(Drone[UserIDIndex]) +" N:"+str(Drone[DroneNameIndex])+" B:"+str(Drone[BatteryIndex]) + * Colour = (255,255,255) + * Sprite = Monitor_Sprite(Coord,"Drone",Text,Colour) # <<<<<<<<<<<<<< + * DroneList.append(Sprite) + * return DroneList + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_Monitor_Sprite); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = __pyx_convert__to_py___pyx_ctuple_long__and_long__and_long(__pyx_v_Colour); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_7 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_Coord, __pyx_n_s_Drone, __pyx_v_Text, __pyx_t_11}; + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_Coord, __pyx_n_s_Drone, __pyx_v_Text, __pyx_t_11}; + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(4+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_INCREF(__pyx_v_Coord); + __Pyx_GIVEREF(__pyx_v_Coord); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_10, __pyx_v_Coord); + __Pyx_INCREF(__pyx_n_s_Drone); + __Pyx_GIVEREF(__pyx_n_s_Drone); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_10, __pyx_n_s_Drone); + __Pyx_INCREF(__pyx_v_Text); + __Pyx_GIVEREF(__pyx_v_Text); + PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_10, __pyx_v_Text); + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_4, 3+__pyx_t_10, __pyx_t_11); + __pyx_t_11 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_Sprite, __pyx_t_8); + __pyx_t_8 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":184 + * Colour = (255,255,255) + * Sprite = Monitor_Sprite(Coord,"Drone",Text,Colour) + * DroneList.append(Sprite) # <<<<<<<<<<<<<< + * return DroneList + * + */ + __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_DroneList, __pyx_v_Sprite); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 184, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":178 + * DroneNameIndex = Columns.index("DroneName") + * BatteryIndex = Columns.index("LastBattery") + * for Drone in RawDroneList: # <<<<<<<<<<<<<< + * LastCoords = ast.literal_eval(Drone[CoordIndex]) + * Coord = AATC_Coordinate.Coordinate(LastCoords[0],LastCoords[1],LastCoords[2],0.001,0.001,0.00001) + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":185 + * Sprite = Monitor_Sprite(Coord,"Drone",Text,Colour) + * DroneList.append(Sprite) + * return DroneList # <<<<<<<<<<<<<< + * + * def MakeFlightSprites(Message,RawFlightList): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_DroneList); + __pyx_r = __pyx_v_DroneList; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":170 + * + * + * def MakeDroneSprites(Message,RawDroneList): # <<<<<<<<<<<<<< + * DroneList = [] + * Columns = ast.literal_eval(Message) + */ + + /* 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_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeDroneSprites", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_DroneList); + __Pyx_XDECREF(__pyx_v_Columns); + __Pyx_XDECREF(__pyx_v_CoordIndex); + __Pyx_XDECREF(__pyx_v_DroneIDIndex); + __Pyx_XDECREF(__pyx_v_UserIDIndex); + __Pyx_XDECREF(__pyx_v_DroneNameIndex); + __Pyx_XDECREF(__pyx_v_BatteryIndex); + __Pyx_XDECREF(__pyx_v_Drone); + __Pyx_XDECREF(__pyx_v_LastCoords); + __Pyx_XDECREF(__pyx_v_Coord); + __Pyx_XDECREF(__pyx_v_Text); + __Pyx_XDECREF(__pyx_v_Sprite); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":187 + * return DroneList + * + * def MakeFlightSprites(Message,RawFlightList): # <<<<<<<<<<<<<< + * FlightList = [] + * Columns = ast.literal_eval(Message) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_9MakeFlightSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_9MakeFlightSprites = {"MakeFlightSprites", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_9MakeFlightSprites, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_9MakeFlightSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_Message = 0; + PyObject *__pyx_v_RawFlightList = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("MakeFlightSprites (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Message,&__pyx_n_s_RawFlightList,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Message)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_RawFlightList)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("MakeFlightSprites", 1, 2, 2, 1); __PYX_ERR(0, 187, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MakeFlightSprites") < 0)) __PYX_ERR(0, 187, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_Message = values[0]; + __pyx_v_RawFlightList = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("MakeFlightSprites", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 187, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeFlightSprites", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_8MakeFlightSprites(__pyx_self, __pyx_v_Message, __pyx_v_RawFlightList); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_8MakeFlightSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Message, PyObject *__pyx_v_RawFlightList) { + PyObject *__pyx_v_FlightList = NULL; + PyObject *__pyx_v_Columns = NULL; + PyObject *__pyx_v_FlightIDIndex = NULL; + PyObject *__pyx_v_DroneIDIndex = NULL; + PyObject *__pyx_v_StartCoordsIndex = NULL; + PyObject *__pyx_v_EndCoordsIndex = NULL; + PyObject *__pyx_v_StartTimeIndex = NULL; + PyObject *__pyx_v_ETAIndex = NULL; + CYTHON_UNUSED PyObject *__pyx_v_EndTimeIndex = NULL; + CYTHON_UNUSED PyObject *__pyx_v_DistanceIndex = NULL; + PyObject *__pyx_v_Flight = NULL; + PyObject *__pyx_v_Coords = NULL; + PyObject *__pyx_v_Coord = NULL; + PyObject *__pyx_v_Text = NULL; + __pyx_ctuple_long__and_long__and_long __pyx_v_Colour; + 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; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + __pyx_ctuple_long__and_long__and_long __pyx_t_12; + int __pyx_t_13; + __Pyx_RefNannySetupContext("MakeFlightSprites", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":188 + * + * def MakeFlightSprites(Message,RawFlightList): + * FlightList = [] # <<<<<<<<<<<<<< + * Columns = ast.literal_eval(Message) + * FlightIDIndex = Columns.index("FlightID") + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_FlightList = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":189 + * def MakeFlightSprites(Message,RawFlightList): + * FlightList = [] + * Columns = ast.literal_eval(Message) # <<<<<<<<<<<<<< + * FlightIDIndex = Columns.index("FlightID") + * DroneIDIndex = Columns.index("DroneID") + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_Message); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_v_Message); + __Pyx_GIVEREF(__pyx_v_Message); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_Message); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_Columns = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":190 + * FlightList = [] + * Columns = ast.literal_eval(Message) + * FlightIDIndex = Columns.index("FlightID") # <<<<<<<<<<<<<< + * DroneIDIndex = Columns.index("DroneID") + * StartCoordsIndex = Columns.index("StartCoords") + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_FlightIDIndex = __pyx_t_3; + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":191 + * Columns = ast.literal_eval(Message) + * FlightIDIndex = Columns.index("FlightID") + * DroneIDIndex = Columns.index("DroneID") # <<<<<<<<<<<<<< + * StartCoordsIndex = Columns.index("StartCoords") + * EndCoordsIndex = Columns.index("EndCoords") + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_DroneIDIndex = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":192 + * FlightIDIndex = Columns.index("FlightID") + * DroneIDIndex = Columns.index("DroneID") + * StartCoordsIndex = Columns.index("StartCoords") # <<<<<<<<<<<<<< + * EndCoordsIndex = Columns.index("EndCoords") + * StartTimeIndex = Columns.index("StartTime") + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_StartCoordsIndex = __pyx_t_3; + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":193 + * DroneIDIndex = Columns.index("DroneID") + * StartCoordsIndex = Columns.index("StartCoords") + * EndCoordsIndex = Columns.index("EndCoords") # <<<<<<<<<<<<<< + * StartTimeIndex = Columns.index("StartTime") + * ETAIndex = Columns.index("ETA") + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_EndCoordsIndex = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":194 + * StartCoordsIndex = Columns.index("StartCoords") + * EndCoordsIndex = Columns.index("EndCoords") + * StartTimeIndex = Columns.index("StartTime") # <<<<<<<<<<<<<< + * ETAIndex = Columns.index("ETA") + * EndTimeIndex = Columns.index("EndTime") + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_StartTimeIndex = __pyx_t_3; + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":195 + * EndCoordsIndex = Columns.index("EndCoords") + * StartTimeIndex = Columns.index("StartTime") + * ETAIndex = Columns.index("ETA") # <<<<<<<<<<<<<< + * EndTimeIndex = Columns.index("EndTime") + * DistanceIndex = Columns.index("Distance") + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_ETAIndex = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":196 + * StartTimeIndex = Columns.index("StartTime") + * ETAIndex = Columns.index("ETA") + * EndTimeIndex = Columns.index("EndTime") # <<<<<<<<<<<<<< + * DistanceIndex = Columns.index("Distance") + * for Flight in RawFlightList: + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_EndTimeIndex = __pyx_t_3; + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":197 + * ETAIndex = Columns.index("ETA") + * EndTimeIndex = Columns.index("EndTime") + * DistanceIndex = Columns.index("Distance") # <<<<<<<<<<<<<< + * for Flight in RawFlightList: + * #Start Sprite + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_DistanceIndex = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":198 + * EndTimeIndex = Columns.index("EndTime") + * DistanceIndex = Columns.index("Distance") + * for Flight in RawFlightList: # <<<<<<<<<<<<<< + * #Start Sprite + * Coords = ast.literal_eval(Flight[StartCoordsIndex]) + */ + if (likely(PyList_CheckExact(__pyx_v_RawFlightList)) || PyTuple_CheckExact(__pyx_v_RawFlightList)) { + __pyx_t_1 = __pyx_v_RawFlightList; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_RawFlightList); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 198, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 198, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 198, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_6(__pyx_t_1); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 198, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_Flight, __pyx_t_3); + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":200 + * for Flight in RawFlightList: + * #Start Sprite + * Coords = ast.literal_eval(Flight[StartCoordsIndex]) # <<<<<<<<<<<<<< + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.0001,0.0001,0.00001) + * Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ST:"+str(Flight[StartTimeIndex]) + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_StartCoordsIndex); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_7) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_Coords, __pyx_t_3); + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":201 + * #Start Sprite + * Coords = ast.literal_eval(Flight[StartCoordsIndex]) + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.0001,0.0001,0.00001) # <<<<<<<<<<<<<< + * Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ST:"+str(Flight[StartTimeIndex]) + * Colour = (0,0,255) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_Coords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_Coords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_Coords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[7] = {__pyx_t_9, __pyx_t_2, __pyx_t_4, __pyx_t_7, __pyx_float_0_0001, __pyx_float_0_0001, __pyx_float_0_00001}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[7] = {__pyx_t_9, __pyx_t_2, __pyx_t_4, __pyx_t_7, __pyx_float_0_0001, __pyx_float_0_0001, __pyx_float_0_00001}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(6+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (__pyx_t_9) { + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; + } + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_t_7); + __Pyx_INCREF(__pyx_float_0_0001); + __Pyx_GIVEREF(__pyx_float_0_0001); + PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_10, __pyx_float_0_0001); + __Pyx_INCREF(__pyx_float_0_0001); + __Pyx_GIVEREF(__pyx_float_0_0001); + PyTuple_SET_ITEM(__pyx_t_11, 4+__pyx_t_10, __pyx_float_0_0001); + __Pyx_INCREF(__pyx_float_0_00001); + __Pyx_GIVEREF(__pyx_float_0_00001); + PyTuple_SET_ITEM(__pyx_t_11, 5+__pyx_t_10, __pyx_float_0_00001); + __pyx_t_2 = 0; + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF_SET(__pyx_v_Coord, __pyx_t_3); + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":202 + * Coords = ast.literal_eval(Flight[StartCoordsIndex]) + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.0001,0.0001,0.00001) + * Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ST:"+str(Flight[StartTimeIndex]) # <<<<<<<<<<<<<< + * Colour = (0,0,255) + * FlightList.append(Monitor_Sprite(Coord,"StartPoint",Text,Colour)) + */ + __pyx_t_3 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_FlightIDIndex); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_kp_s_F, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Add(__pyx_t_8, __pyx_kp_s_D_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_DroneIDIndex); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyNumber_Add(__pyx_t_3, __pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_t_11, __pyx_kp_s_ST); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_StartTimeIndex); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_11); + __pyx_t_11 = 0; + __pyx_t_11 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Add(__pyx_t_8, __pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF_SET(__pyx_v_Text, __pyx_t_3); + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":203 + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.0001,0.0001,0.00001) + * Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ST:"+str(Flight[StartTimeIndex]) + * Colour = (0,0,255) # <<<<<<<<<<<<<< + * FlightList.append(Monitor_Sprite(Coord,"StartPoint",Text,Colour)) + * + */ + __pyx_t_12.f0 = 0; + __pyx_t_12.f1 = 0; + __pyx_t_12.f2 = 0xFF; + __pyx_v_Colour = __pyx_t_12; + + /* "CAStar/AATC_Monitor_Viewer.pyx":204 + * Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ST:"+str(Flight[StartTimeIndex]) + * Colour = (0,0,255) + * FlightList.append(Monitor_Sprite(Coord,"StartPoint",Text,Colour)) # <<<<<<<<<<<<<< + * + * #End Sprite + */ + __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_Monitor_Sprite); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_8 = __pyx_convert__to_py___pyx_ctuple_long__and_long__and_long(__pyx_v_Colour); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_11); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_11, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_11)) { + PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_Coord, __pyx_n_s_StartPoint, __pyx_v_Text, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_11, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_11)) { + PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_Coord, __pyx_n_s_StartPoint, __pyx_v_Text, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_11, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(4+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_INCREF(__pyx_v_Coord); + __Pyx_GIVEREF(__pyx_v_Coord); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_10, __pyx_v_Coord); + __Pyx_INCREF(__pyx_n_s_StartPoint); + __Pyx_GIVEREF(__pyx_n_s_StartPoint); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_10, __pyx_n_s_StartPoint); + __Pyx_INCREF(__pyx_v_Text); + __Pyx_GIVEREF(__pyx_v_Text); + PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_10, __pyx_v_Text); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_4, 3+__pyx_t_10, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_FlightList, __pyx_t_3); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":207 + * + * #End Sprite + * Coords = ast.literal_eval(Flight[EndCoordsIndex]) # <<<<<<<<<<<<<< + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.0001,0.0001,0.00001) + * Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ETA:"+str(Flight[ETAIndex]) + */ + __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_EndCoordsIndex); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_8) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_11}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_11}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_11); + __pyx_t_11 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_Coords, __pyx_t_3); + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":208 + * #End Sprite + * Coords = ast.literal_eval(Flight[EndCoordsIndex]) + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.0001,0.0001,0.00001) # <<<<<<<<<<<<<< + * Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ETA:"+str(Flight[ETAIndex]) + * Colour = (255,0,0) + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_Coords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_Coords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_Coords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[7] = {__pyx_t_2, __pyx_t_4, __pyx_t_11, __pyx_t_8, __pyx_float_0_0001, __pyx_float_0_0001, __pyx_float_0_00001}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[7] = {__pyx_t_2, __pyx_t_4, __pyx_t_11, __pyx_t_8, __pyx_float_0_0001, __pyx_float_0_0001, __pyx_float_0_00001}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(6+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_10, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_10, __pyx_t_11); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_10, __pyx_t_8); + __Pyx_INCREF(__pyx_float_0_0001); + __Pyx_GIVEREF(__pyx_float_0_0001); + PyTuple_SET_ITEM(__pyx_t_9, 3+__pyx_t_10, __pyx_float_0_0001); + __Pyx_INCREF(__pyx_float_0_0001); + __Pyx_GIVEREF(__pyx_float_0_0001); + PyTuple_SET_ITEM(__pyx_t_9, 4+__pyx_t_10, __pyx_float_0_0001); + __Pyx_INCREF(__pyx_float_0_00001); + __Pyx_GIVEREF(__pyx_float_0_00001); + PyTuple_SET_ITEM(__pyx_t_9, 5+__pyx_t_10, __pyx_float_0_00001); + __pyx_t_4 = 0; + __pyx_t_11 = 0; + __pyx_t_8 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF_SET(__pyx_v_Coord, __pyx_t_3); + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":209 + * Coords = ast.literal_eval(Flight[EndCoordsIndex]) + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.0001,0.0001,0.00001) + * Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ETA:"+str(Flight[ETAIndex]) # <<<<<<<<<<<<<< + * Colour = (255,0,0) + * FlightList.append(Monitor_Sprite(Coord,"EndPoint",Text,Colour)) + */ + __pyx_t_3 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_FlightIDIndex); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyNumber_Add(__pyx_kp_s_F, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Add(__pyx_t_7, __pyx_kp_s_D_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_DroneIDIndex); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_9, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyNumber_Add(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyNumber_Add(__pyx_t_9, __pyx_kp_s_ETA_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_ETAIndex); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Add(__pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF_SET(__pyx_v_Text, __pyx_t_3); + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":210 + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.0001,0.0001,0.00001) + * Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ETA:"+str(Flight[ETAIndex]) + * Colour = (255,0,0) # <<<<<<<<<<<<<< + * FlightList.append(Monitor_Sprite(Coord,"EndPoint",Text,Colour)) + * return FlightList + */ + __pyx_t_12.f0 = 0xFF; + __pyx_t_12.f1 = 0; + __pyx_t_12.f2 = 0; + __pyx_v_Colour = __pyx_t_12; + + /* "CAStar/AATC_Monitor_Viewer.pyx":211 + * Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ETA:"+str(Flight[ETAIndex]) + * Colour = (255,0,0) + * FlightList.append(Monitor_Sprite(Coord,"EndPoint",Text,Colour)) # <<<<<<<<<<<<<< + * return FlightList + * + */ + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_Monitor_Sprite); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_7 = __pyx_convert__to_py___pyx_ctuple_long__and_long__and_long(__pyx_v_Colour); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_v_Coord, __pyx_n_s_EndPoint, __pyx_v_Text, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_v_Coord, __pyx_n_s_EndPoint, __pyx_v_Text, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(4+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_INCREF(__pyx_v_Coord); + __Pyx_GIVEREF(__pyx_v_Coord); + PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_v_Coord); + __Pyx_INCREF(__pyx_n_s_EndPoint); + __Pyx_GIVEREF(__pyx_n_s_EndPoint); + PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_n_s_EndPoint); + __Pyx_INCREF(__pyx_v_Text); + __Pyx_GIVEREF(__pyx_v_Text); + PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_v_Text); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_10, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_FlightList, __pyx_t_3); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":198 + * EndTimeIndex = Columns.index("EndTime") + * DistanceIndex = Columns.index("Distance") + * for Flight in RawFlightList: # <<<<<<<<<<<<<< + * #Start Sprite + * Coords = ast.literal_eval(Flight[StartCoordsIndex]) + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":212 + * Colour = (255,0,0) + * FlightList.append(Monitor_Sprite(Coord,"EndPoint",Text,Colour)) + * return FlightList # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_FlightList); + __pyx_r = __pyx_v_FlightList; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":187 + * return DroneList + * + * def MakeFlightSprites(Message,RawFlightList): # <<<<<<<<<<<<<< + * FlightList = [] + * Columns = ast.literal_eval(Message) + */ + + /* 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_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeFlightSprites", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_FlightList); + __Pyx_XDECREF(__pyx_v_Columns); + __Pyx_XDECREF(__pyx_v_FlightIDIndex); + __Pyx_XDECREF(__pyx_v_DroneIDIndex); + __Pyx_XDECREF(__pyx_v_StartCoordsIndex); + __Pyx_XDECREF(__pyx_v_EndCoordsIndex); + __Pyx_XDECREF(__pyx_v_StartTimeIndex); + __Pyx_XDECREF(__pyx_v_ETAIndex); + __Pyx_XDECREF(__pyx_v_EndTimeIndex); + __Pyx_XDECREF(__pyx_v_DistanceIndex); + __Pyx_XDECREF(__pyx_v_Flight); + __Pyx_XDECREF(__pyx_v_Coords); + __Pyx_XDECREF(__pyx_v_Coord); + __Pyx_XDECREF(__pyx_v_Text); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":215 + * + * + * def MakeWaypointSprites(Message,RawWaypointList): # <<<<<<<<<<<<<< + * WaypointList = [] + * Columns = ast.literal_eval(Message) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_11MakeWaypointSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_11MakeWaypointSprites = {"MakeWaypointSprites", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_11MakeWaypointSprites, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_11MakeWaypointSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_Message = 0; + PyObject *__pyx_v_RawWaypointList = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("MakeWaypointSprites (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Message,&__pyx_n_s_RawWaypointList,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Message)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_RawWaypointList)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("MakeWaypointSprites", 1, 2, 2, 1); __PYX_ERR(0, 215, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MakeWaypointSprites") < 0)) __PYX_ERR(0, 215, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_Message = values[0]; + __pyx_v_RawWaypointList = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("MakeWaypointSprites", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 215, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeWaypointSprites", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_10MakeWaypointSprites(__pyx_self, __pyx_v_Message, __pyx_v_RawWaypointList); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_10MakeWaypointSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Message, PyObject *__pyx_v_RawWaypointList) { + PyObject *__pyx_v_WaypointList = NULL; + PyObject *__pyx_v_Columns = NULL; + PyObject *__pyx_v_CoordIndex = NULL; + PyObject *__pyx_v_WaypointNumberIndex = NULL; + PyObject *__pyx_v_FlightIDIndex = NULL; + PyObject *__pyx_v_Waypoint = NULL; + PyObject *__pyx_v_Coords = NULL; + PyObject *__pyx_v_Coord = NULL; + PyObject *__pyx_v_Text = NULL; + __pyx_ctuple_long__and_long__and_long __pyx_v_Colour; + 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; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + __pyx_ctuple_long__and_long__and_long __pyx_t_12; + int __pyx_t_13; + __Pyx_RefNannySetupContext("MakeWaypointSprites", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":216 + * + * def MakeWaypointSprites(Message,RawWaypointList): + * WaypointList = [] # <<<<<<<<<<<<<< + * Columns = ast.literal_eval(Message) + * CoordIndex = Columns.index("Coords") + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_WaypointList = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":217 + * def MakeWaypointSprites(Message,RawWaypointList): + * WaypointList = [] + * Columns = ast.literal_eval(Message) # <<<<<<<<<<<<<< + * CoordIndex = Columns.index("Coords") + * WaypointNumberIndex = Columns.index("WaypointNumber") + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_Message); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_v_Message); + __Pyx_GIVEREF(__pyx_v_Message); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_Message); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_Columns = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":218 + * WaypointList = [] + * Columns = ast.literal_eval(Message) + * CoordIndex = Columns.index("Coords") # <<<<<<<<<<<<<< + * WaypointNumberIndex = Columns.index("WaypointNumber") + * FlightIDIndex = Columns.index("FlightID") + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_CoordIndex = __pyx_t_3; + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":219 + * Columns = ast.literal_eval(Message) + * CoordIndex = Columns.index("Coords") + * WaypointNumberIndex = Columns.index("WaypointNumber") # <<<<<<<<<<<<<< + * FlightIDIndex = Columns.index("FlightID") + * for Waypoint in RawWaypointList: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_WaypointNumberIndex = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":220 + * CoordIndex = Columns.index("Coords") + * WaypointNumberIndex = Columns.index("WaypointNumber") + * FlightIDIndex = Columns.index("FlightID") # <<<<<<<<<<<<<< + * for Waypoint in RawWaypointList: + * Coords = ast.literal_eval(Waypoint[CoordIndex]) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_FlightIDIndex = __pyx_t_3; + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":221 + * WaypointNumberIndex = Columns.index("WaypointNumber") + * FlightIDIndex = Columns.index("FlightID") + * for Waypoint in RawWaypointList: # <<<<<<<<<<<<<< + * Coords = ast.literal_eval(Waypoint[CoordIndex]) + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.001,0.001,0.00001) + */ + if (likely(PyList_CheckExact(__pyx_v_RawWaypointList)) || PyTuple_CheckExact(__pyx_v_RawWaypointList)) { + __pyx_t_3 = __pyx_v_RawWaypointList; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_RawWaypointList); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 221, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 221, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 221, __pyx_L1_error) + #else + __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_6(__pyx_t_3); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 221, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_Waypoint, __pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":222 + * FlightIDIndex = Columns.index("FlightID") + * for Waypoint in RawWaypointList: + * Coords = ast.literal_eval(Waypoint[CoordIndex]) # <<<<<<<<<<<<<< + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.001,0.001,0.00001) + * Text = "F:"+ str(Waypoint[FlightIDIndex]) +" W:"+ str(Waypoint[WaypointNumberIndex]) + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyObject_GetItem(__pyx_v_Waypoint, __pyx_v_CoordIndex); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_7) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_Coords, __pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":223 + * for Waypoint in RawWaypointList: + * Coords = ast.literal_eval(Waypoint[CoordIndex]) + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.001,0.001,0.00001) # <<<<<<<<<<<<<< + * Text = "F:"+ str(Waypoint[FlightIDIndex]) +" W:"+ str(Waypoint[WaypointNumberIndex]) + * Colour = (0,255,0) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_Coords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_Coords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_Coords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[7] = {__pyx_t_9, __pyx_t_2, __pyx_t_4, __pyx_t_7, __pyx_float_0_001, __pyx_float_0_001, __pyx_float_0_00001}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[7] = {__pyx_t_9, __pyx_t_2, __pyx_t_4, __pyx_t_7, __pyx_float_0_001, __pyx_float_0_001, __pyx_float_0_00001}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(6+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (__pyx_t_9) { + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; + } + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_t_7); + __Pyx_INCREF(__pyx_float_0_001); + __Pyx_GIVEREF(__pyx_float_0_001); + PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_10, __pyx_float_0_001); + __Pyx_INCREF(__pyx_float_0_001); + __Pyx_GIVEREF(__pyx_float_0_001); + PyTuple_SET_ITEM(__pyx_t_11, 4+__pyx_t_10, __pyx_float_0_001); + __Pyx_INCREF(__pyx_float_0_00001); + __Pyx_GIVEREF(__pyx_float_0_00001); + PyTuple_SET_ITEM(__pyx_t_11, 5+__pyx_t_10, __pyx_float_0_00001); + __pyx_t_2 = 0; + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF_SET(__pyx_v_Coord, __pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":224 + * Coords = ast.literal_eval(Waypoint[CoordIndex]) + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.001,0.001,0.00001) + * Text = "F:"+ str(Waypoint[FlightIDIndex]) +" W:"+ str(Waypoint[WaypointNumberIndex]) # <<<<<<<<<<<<<< + * Colour = (0,255,0) + * WaypointList.append(Monitor_Sprite(Coord,"Waypoint",Text,Colour)) + */ + __pyx_t_1 = PyObject_GetItem(__pyx_v_Waypoint, __pyx_v_FlightIDIndex); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_kp_s_F, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_kp_s_W); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyObject_GetItem(__pyx_v_Waypoint, __pyx_v_WaypointNumberIndex); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyNumber_Add(__pyx_t_1, __pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF_SET(__pyx_v_Text, __pyx_t_11); + __pyx_t_11 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":225 + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.001,0.001,0.00001) + * Text = "F:"+ str(Waypoint[FlightIDIndex]) +" W:"+ str(Waypoint[WaypointNumberIndex]) + * Colour = (0,255,0) # <<<<<<<<<<<<<< + * WaypointList.append(Monitor_Sprite(Coord,"Waypoint",Text,Colour)) + * return WaypointList + */ + __pyx_t_12.f0 = 0; + __pyx_t_12.f1 = 0xFF; + __pyx_t_12.f2 = 0; + __pyx_v_Colour = __pyx_t_12; + + /* "CAStar/AATC_Monitor_Viewer.pyx":226 + * Text = "F:"+ str(Waypoint[FlightIDIndex]) +" W:"+ str(Waypoint[WaypointNumberIndex]) + * Colour = (0,255,0) + * WaypointList.append(Monitor_Sprite(Coord,"Waypoint",Text,Colour)) # <<<<<<<<<<<<<< + * return WaypointList + * + */ + __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_Monitor_Sprite); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = __pyx_convert__to_py___pyx_ctuple_long__and_long__and_long(__pyx_v_Colour); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_Coord, __pyx_n_s_Waypoint, __pyx_v_Text, __pyx_t_1}; + __pyx_t_11 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_Coord, __pyx_n_s_Waypoint, __pyx_v_Text, __pyx_t_1}; + __pyx_t_11 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(4+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_INCREF(__pyx_v_Coord); + __Pyx_GIVEREF(__pyx_v_Coord); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_10, __pyx_v_Coord); + __Pyx_INCREF(__pyx_n_s_Waypoint); + __Pyx_GIVEREF(__pyx_n_s_Waypoint); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_10, __pyx_n_s_Waypoint); + __Pyx_INCREF(__pyx_v_Text); + __Pyx_GIVEREF(__pyx_v_Text); + PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_10, __pyx_v_Text); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 3+__pyx_t_10, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_4, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_WaypointList, __pyx_t_11); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":221 + * WaypointNumberIndex = Columns.index("WaypointNumber") + * FlightIDIndex = Columns.index("FlightID") + * for Waypoint in RawWaypointList: # <<<<<<<<<<<<<< + * Coords = ast.literal_eval(Waypoint[CoordIndex]) + * Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.001,0.001,0.00001) + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":227 + * Colour = (0,255,0) + * WaypointList.append(Monitor_Sprite(Coord,"Waypoint",Text,Colour)) + * return WaypointList # <<<<<<<<<<<<<< + * + * def MakeZoneSprites(Message,RawZoneList): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_WaypointList); + __pyx_r = __pyx_v_WaypointList; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":215 + * + * + * def MakeWaypointSprites(Message,RawWaypointList): # <<<<<<<<<<<<<< + * WaypointList = [] + * Columns = ast.literal_eval(Message) + */ + + /* 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_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeWaypointSprites", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_WaypointList); + __Pyx_XDECREF(__pyx_v_Columns); + __Pyx_XDECREF(__pyx_v_CoordIndex); + __Pyx_XDECREF(__pyx_v_WaypointNumberIndex); + __Pyx_XDECREF(__pyx_v_FlightIDIndex); + __Pyx_XDECREF(__pyx_v_Waypoint); + __Pyx_XDECREF(__pyx_v_Coords); + __Pyx_XDECREF(__pyx_v_Coord); + __Pyx_XDECREF(__pyx_v_Text); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":229 + * return WaypointList + * + * def MakeZoneSprites(Message,RawZoneList): # <<<<<<<<<<<<<< + * ZoneList = [] + * Columns = ast.literal_eval(Message) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_13MakeZoneSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_13MakeZoneSprites = {"MakeZoneSprites", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_13MakeZoneSprites, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_13MakeZoneSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_Message = 0; + PyObject *__pyx_v_RawZoneList = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("MakeZoneSprites (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Message,&__pyx_n_s_RawZoneList,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Message)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_RawZoneList)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("MakeZoneSprites", 1, 2, 2, 1); __PYX_ERR(0, 229, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MakeZoneSprites") < 0)) __PYX_ERR(0, 229, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_Message = values[0]; + __pyx_v_RawZoneList = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("MakeZoneSprites", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 229, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeZoneSprites", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_12MakeZoneSprites(__pyx_self, __pyx_v_Message, __pyx_v_RawZoneList); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_12MakeZoneSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Message, PyObject *__pyx_v_RawZoneList) { + PyObject *__pyx_v_ZoneList = NULL; + PyObject *__pyx_v_Columns = NULL; + PyObject *__pyx_v_StartCoordIndex = NULL; + PyObject *__pyx_v_EndCoordIndex = NULL; + PyObject *__pyx_v_LevelIndex = NULL; + PyObject *__pyx_v_ZoneIDIndex = NULL; + PyObject *__pyx_v_Zone = NULL; + PyObject *__pyx_v_StartCoords = NULL; + PyObject *__pyx_v_EndCoords = NULL; + PyObject *__pyx_v_Coord = NULL; + PyObject *__pyx_v_Text = NULL; + __pyx_ctuple_long__and_long__and_long __pyx_v_Colour; + 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; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + 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; + PyObject *__pyx_t_13 = NULL; + int __pyx_t_14; + __pyx_ctuple_long__and_long__and_long __pyx_t_15; + int __pyx_t_16; + __Pyx_RefNannySetupContext("MakeZoneSprites", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":230 + * + * def MakeZoneSprites(Message,RawZoneList): + * ZoneList = [] # <<<<<<<<<<<<<< + * Columns = ast.literal_eval(Message) + * StartCoordIndex = Columns.index("StartCoord") + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_ZoneList = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":231 + * def MakeZoneSprites(Message,RawZoneList): + * ZoneList = [] + * Columns = ast.literal_eval(Message) # <<<<<<<<<<<<<< + * StartCoordIndex = Columns.index("StartCoord") + * EndCoordIndex = Columns.index("EndCoord") + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_Message); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_INCREF(__pyx_v_Message); + __Pyx_GIVEREF(__pyx_v_Message); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_Message); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_Columns = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":232 + * ZoneList = [] + * Columns = ast.literal_eval(Message) + * StartCoordIndex = Columns.index("StartCoord") # <<<<<<<<<<<<<< + * EndCoordIndex = Columns.index("EndCoord") + * LevelIndex = Columns.index("Level") + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_StartCoordIndex = __pyx_t_3; + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":233 + * Columns = ast.literal_eval(Message) + * StartCoordIndex = Columns.index("StartCoord") + * EndCoordIndex = Columns.index("EndCoord") # <<<<<<<<<<<<<< + * LevelIndex = Columns.index("Level") + * ZoneIDIndex = Columns.index("ZoneID") + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_EndCoordIndex = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":234 + * StartCoordIndex = Columns.index("StartCoord") + * EndCoordIndex = Columns.index("EndCoord") + * LevelIndex = Columns.index("Level") # <<<<<<<<<<<<<< + * ZoneIDIndex = Columns.index("ZoneID") + * for Zone in RawZoneList: + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_LevelIndex = __pyx_t_3; + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":235 + * EndCoordIndex = Columns.index("EndCoord") + * LevelIndex = Columns.index("Level") + * ZoneIDIndex = Columns.index("ZoneID") # <<<<<<<<<<<<<< + * for Zone in RawZoneList: + * StartCoords = ast.literal_eval(Zone[StartCoordIndex]) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_ZoneIDIndex = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":236 + * LevelIndex = Columns.index("Level") + * ZoneIDIndex = Columns.index("ZoneID") + * for Zone in RawZoneList: # <<<<<<<<<<<<<< + * StartCoords = ast.literal_eval(Zone[StartCoordIndex]) + * EndCoords = ast.literal_eval(Zone[EndCoordIndex]) + */ + if (likely(PyList_CheckExact(__pyx_v_RawZoneList)) || PyTuple_CheckExact(__pyx_v_RawZoneList)) { + __pyx_t_1 = __pyx_v_RawZoneList; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_RawZoneList); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 236, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 236, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 236, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_6(__pyx_t_1); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 236, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_Zone, __pyx_t_3); + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":237 + * ZoneIDIndex = Columns.index("ZoneID") + * for Zone in RawZoneList: + * StartCoords = ast.literal_eval(Zone[StartCoordIndex]) # <<<<<<<<<<<<<< + * EndCoords = ast.literal_eval(Zone[EndCoordIndex]) + * Coord = AATC_Coordinate.Coordinate(StartCoords[0],StartCoords[1],StartCoords[2],EndCoords[0]-StartCoords[0],EndCoords[1]-StartCoords[1],EndCoords[2]-StartCoords[2]) + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyObject_GetItem(__pyx_v_Zone, __pyx_v_StartCoordIndex); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_7) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_StartCoords, __pyx_t_3); + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":238 + * for Zone in RawZoneList: + * StartCoords = ast.literal_eval(Zone[StartCoordIndex]) + * EndCoords = ast.literal_eval(Zone[EndCoordIndex]) # <<<<<<<<<<<<<< + * Coord = AATC_Coordinate.Coordinate(StartCoords[0],StartCoords[1],StartCoords[2],EndCoords[0]-StartCoords[0],EndCoords[1]-StartCoords[1],EndCoords[2]-StartCoords[2]) + * Text = "Z:"+ str(Zone[ZoneIDIndex]) +" L:"+ str(Zone[LevelIndex]) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_GetItem(__pyx_v_Zone, __pyx_v_EndCoordIndex); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + if (!__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF_SET(__pyx_v_EndCoords, __pyx_t_3); + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":239 + * StartCoords = ast.literal_eval(Zone[StartCoordIndex]) + * EndCoords = ast.literal_eval(Zone[EndCoordIndex]) + * Coord = AATC_Coordinate.Coordinate(StartCoords[0],StartCoords[1],StartCoords[2],EndCoords[0]-StartCoords[0],EndCoords[1]-StartCoords[1],EndCoords[2]-StartCoords[2]) # <<<<<<<<<<<<<< + * Text = "Z:"+ str(Zone[ZoneIDIndex]) +" L:"+ str(Zone[LevelIndex]) + * Colour = (100,100,100) + */ + __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_StartCoords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_StartCoords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_StartCoords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_EndCoords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_StartCoords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = PyNumber_Subtract(__pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_EndCoords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_StartCoords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_12 = PyNumber_Subtract(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_EndCoords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_StartCoords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_13 = PyNumber_Subtract(__pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = NULL; + __pyx_t_14 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_14 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[7] = {__pyx_t_10, __pyx_t_8, __pyx_t_2, __pyx_t_4, __pyx_t_11, __pyx_t_12, __pyx_t_13}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_14, 6+__pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[7] = {__pyx_t_10, __pyx_t_8, __pyx_t_2, __pyx_t_4, __pyx_t_11, __pyx_t_12, __pyx_t_13}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_14, 6+__pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(6+__pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_10) { + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); __pyx_t_10 = NULL; + } + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_14, __pyx_t_8); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_14, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_14, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_9, 3+__pyx_t_14, __pyx_t_11); + __Pyx_GIVEREF(__pyx_t_12); + PyTuple_SET_ITEM(__pyx_t_9, 4+__pyx_t_14, __pyx_t_12); + __Pyx_GIVEREF(__pyx_t_13); + PyTuple_SET_ITEM(__pyx_t_9, 5+__pyx_t_14, __pyx_t_13); + __pyx_t_8 = 0; + __pyx_t_2 = 0; + __pyx_t_4 = 0; + __pyx_t_11 = 0; + __pyx_t_12 = 0; + __pyx_t_13 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF_SET(__pyx_v_Coord, __pyx_t_3); + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":240 + * EndCoords = ast.literal_eval(Zone[EndCoordIndex]) + * Coord = AATC_Coordinate.Coordinate(StartCoords[0],StartCoords[1],StartCoords[2],EndCoords[0]-StartCoords[0],EndCoords[1]-StartCoords[1],EndCoords[2]-StartCoords[2]) + * Text = "Z:"+ str(Zone[ZoneIDIndex]) +" L:"+ str(Zone[LevelIndex]) # <<<<<<<<<<<<<< + * Colour = (100,100,100) + * ZoneList.append(Monitor_Sprite(Coord,"NoFlyZone",Text,Colour)) + */ + __pyx_t_3 = PyObject_GetItem(__pyx_v_Zone, __pyx_v_ZoneIDIndex); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyNumber_Add(__pyx_kp_s_Z, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Add(__pyx_t_7, __pyx_kp_s_L); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyObject_GetItem(__pyx_v_Zone, __pyx_v_LevelIndex); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_9, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyNumber_Add(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF_SET(__pyx_v_Text, __pyx_t_9); + __pyx_t_9 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":241 + * Coord = AATC_Coordinate.Coordinate(StartCoords[0],StartCoords[1],StartCoords[2],EndCoords[0]-StartCoords[0],EndCoords[1]-StartCoords[1],EndCoords[2]-StartCoords[2]) + * Text = "Z:"+ str(Zone[ZoneIDIndex]) +" L:"+ str(Zone[LevelIndex]) + * Colour = (100,100,100) # <<<<<<<<<<<<<< + * ZoneList.append(Monitor_Sprite(Coord,"NoFlyZone",Text,Colour)) + * return ZoneList + */ + __pyx_t_15.f0 = 0x64; + __pyx_t_15.f1 = 0x64; + __pyx_t_15.f2 = 0x64; + __pyx_v_Colour = __pyx_t_15; + + /* "CAStar/AATC_Monitor_Viewer.pyx":242 + * Text = "Z:"+ str(Zone[ZoneIDIndex]) +" L:"+ str(Zone[LevelIndex]) + * Colour = (100,100,100) + * ZoneList.append(Monitor_Sprite(Coord,"NoFlyZone",Text,Colour)) # <<<<<<<<<<<<<< + * return ZoneList + * + */ + __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_Monitor_Sprite); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __pyx_convert__to_py___pyx_ctuple_long__and_long__and_long(__pyx_v_Colour); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = NULL; + __pyx_t_14 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_14 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[5] = {__pyx_t_13, __pyx_v_Coord, __pyx_n_s_NoFlyZone, __pyx_v_Text, __pyx_t_3}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_14, 4+__pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[5] = {__pyx_t_13, __pyx_v_Coord, __pyx_n_s_NoFlyZone, __pyx_v_Text, __pyx_t_3}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_14, 4+__pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_12 = PyTuple_New(4+__pyx_t_14); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (__pyx_t_13) { + __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_13); __pyx_t_13 = NULL; + } + __Pyx_INCREF(__pyx_v_Coord); + __Pyx_GIVEREF(__pyx_v_Coord); + PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_14, __pyx_v_Coord); + __Pyx_INCREF(__pyx_n_s_NoFlyZone); + __Pyx_GIVEREF(__pyx_n_s_NoFlyZone); + PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_14, __pyx_n_s_NoFlyZone); + __Pyx_INCREF(__pyx_v_Text); + __Pyx_GIVEREF(__pyx_v_Text); + PyTuple_SET_ITEM(__pyx_t_12, 2+__pyx_t_14, __pyx_v_Text); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_12, 3+__pyx_t_14, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_12, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_16 = __Pyx_PyList_Append(__pyx_v_ZoneList, __pyx_t_9); if (unlikely(__pyx_t_16 == -1)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":236 + * LevelIndex = Columns.index("Level") + * ZoneIDIndex = Columns.index("ZoneID") + * for Zone in RawZoneList: # <<<<<<<<<<<<<< + * StartCoords = ast.literal_eval(Zone[StartCoordIndex]) + * EndCoords = ast.literal_eval(Zone[EndCoordIndex]) + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":243 + * Colour = (100,100,100) + * ZoneList.append(Monitor_Sprite(Coord,"NoFlyZone",Text,Colour)) + * return ZoneList # <<<<<<<<<<<<<< + * + * def MakeSprites(M): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_ZoneList); + __pyx_r = __pyx_v_ZoneList; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":229 + * return WaypointList + * + * def MakeZoneSprites(Message,RawZoneList): # <<<<<<<<<<<<<< + * ZoneList = [] + * Columns = ast.literal_eval(Message) + */ + + /* 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_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeZoneSprites", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ZoneList); + __Pyx_XDECREF(__pyx_v_Columns); + __Pyx_XDECREF(__pyx_v_StartCoordIndex); + __Pyx_XDECREF(__pyx_v_EndCoordIndex); + __Pyx_XDECREF(__pyx_v_LevelIndex); + __Pyx_XDECREF(__pyx_v_ZoneIDIndex); + __Pyx_XDECREF(__pyx_v_Zone); + __Pyx_XDECREF(__pyx_v_StartCoords); + __Pyx_XDECREF(__pyx_v_EndCoords); + __Pyx_XDECREF(__pyx_v_Coord); + __Pyx_XDECREF(__pyx_v_Text); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "CAStar/AATC_Monitor_Viewer.pyx":245 + * return ZoneList + * + * def MakeSprites(M): # <<<<<<<<<<<<<< + * print("Refreshing data") + * SpriteList = [] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_15MakeSprites(PyObject *__pyx_self, PyObject *__pyx_v_M); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_15MakeSprites = {"MakeSprites", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_15MakeSprites, METH_O, 0}; +static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_15MakeSprites(PyObject *__pyx_self, PyObject *__pyx_v_M) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("MakeSprites (wrapper)", 0); + __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_14MakeSprites(__pyx_self, ((PyObject *)__pyx_v_M)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14MakeSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_M) { + PyObject *__pyx_v_SpriteList = NULL; + PyObject *__pyx_v_Sucess = NULL; + PyObject *__pyx_v_Message = NULL; + PyObject *__pyx_v_DronesAll = NULL; + PyObject *__pyx_v_DronesMonitor = NULL; + PyObject *__pyx_v_FlightsAll = NULL; + PyObject *__pyx_v_FlightsMonitor = NULL; + PyObject *__pyx_v_WaypointsAll = NULL; + PyObject *__pyx_v_WaypointsMonitor = NULL; + PyObject *__pyx_v_NoFlyZones = 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)(PyObject *); + int __pyx_t_7; + int __pyx_t_8; + __Pyx_RefNannySetupContext("MakeSprites", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":246 + * + * def MakeSprites(M): + * print("Refreshing data") # <<<<<<<<<<<<<< + * SpriteList = [] + * Sucess,Message,DronesAll = M.GetDronesAll() + */ + if (__Pyx_PrintOne(0, __pyx_kp_s_Refreshing_data) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":247 + * def MakeSprites(M): + * print("Refreshing data") + * SpriteList = [] # <<<<<<<<<<<<<< + * Sucess,Message,DronesAll = M.GetDronesAll() + * if Sucess: + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_SpriteList = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":248 + * print("Refreshing data") + * SpriteList = [] + * Sucess,Message,DronesAll = M.GetDronesAll() # <<<<<<<<<<<<<< + * if Sucess: + * SpriteList += MakeDroneSprites(Message,DronesAll) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetDronesAll); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 3)) { + if (size > 3) __Pyx_RaiseTooManyValuesError(3); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 248, __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_t_3 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_3 = PyList_GET_ITEM(sequence, 1); + __pyx_t_4 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; + index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 248, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L4_unpacking_done; + __pyx_L3_unpacking_failed:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 248, __pyx_L1_error) + __pyx_L4_unpacking_done:; + } + __pyx_v_Sucess = __pyx_t_2; + __pyx_t_2 = 0; + __pyx_v_Message = __pyx_t_3; + __pyx_t_3 = 0; + __pyx_v_DronesAll = __pyx_t_4; + __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":249 + * SpriteList = [] + * Sucess,Message,DronesAll = M.GetDronesAll() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeDroneSprites(Message,DronesAll) + * + */ + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 249, __pyx_L1_error) + if (__pyx_t_7) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":250 + * Sucess,Message,DronesAll = M.GetDronesAll() + * if Sucess: + * SpriteList += MakeDroneSprites(Message,DronesAll) # <<<<<<<<<<<<<< + * + * Sucess,Message,DronesMonitor = M.GetMonitorDrones() + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeDroneSprites); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_Message, __pyx_v_DronesAll}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_Message, __pyx_v_DronesAll}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_2 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_INCREF(__pyx_v_Message); + __Pyx_GIVEREF(__pyx_v_Message); + PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_8, __pyx_v_Message); + __Pyx_INCREF(__pyx_v_DronesAll); + __Pyx_GIVEREF(__pyx_v_DronesAll); + PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_8, __pyx_v_DronesAll); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_4); + __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":249 + * SpriteList = [] + * Sucess,Message,DronesAll = M.GetDronesAll() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeDroneSprites(Message,DronesAll) + * + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":252 + * SpriteList += MakeDroneSprites(Message,DronesAll) + * + * Sucess,Message,DronesMonitor = M.GetMonitorDrones() # <<<<<<<<<<<<<< + * if Sucess: + * SpriteList += MakeDroneSprites(Message,DronesMonitor) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetMonitorDrones); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 252, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { + PyObject* sequence = __pyx_t_4; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 3)) { + if (size > 3) __Pyx_RaiseTooManyValuesError(3); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 252, __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_t_2 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_1 = PyList_GET_ITEM(sequence, 0); + __pyx_t_2 = PyList_GET_ITEM(sequence, 1); + __pyx_t_3 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + #else + __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; + index = 0; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + index = 1; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 2; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 252, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 252, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v_Sucess, __pyx_t_1); + __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_Message, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_v_DronesMonitor = __pyx_t_3; + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":253 + * + * Sucess,Message,DronesMonitor = M.GetMonitorDrones() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeDroneSprites(Message,DronesMonitor) + * + */ + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 253, __pyx_L1_error) + if (__pyx_t_7) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":254 + * Sucess,Message,DronesMonitor = M.GetMonitorDrones() + * if Sucess: + * SpriteList += MakeDroneSprites(Message,DronesMonitor) # <<<<<<<<<<<<<< + * + * Sucess,Message,FlightsAll = M.GetFlightsAll() + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeDroneSprites); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_Message, __pyx_v_DronesMonitor}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_Message, __pyx_v_DronesMonitor}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + { + __pyx_t_1 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(__pyx_v_Message); + __Pyx_GIVEREF(__pyx_v_Message); + PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_8, __pyx_v_Message); + __Pyx_INCREF(__pyx_v_DronesMonitor); + __Pyx_GIVEREF(__pyx_v_DronesMonitor); + PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_8, __pyx_v_DronesMonitor); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_3); + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":253 + * + * Sucess,Message,DronesMonitor = M.GetMonitorDrones() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeDroneSprites(Message,DronesMonitor) + * + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":256 + * SpriteList += MakeDroneSprites(Message,DronesMonitor) + * + * Sucess,Message,FlightsAll = M.GetFlightsAll() # <<<<<<<<<<<<<< + * if Sucess: + * SpriteList += MakeFlightSprites(Message,FlightsAll) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetFlightsAll); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_1) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 256, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 256, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 3)) { + if (size > 3) __Pyx_RaiseTooManyValuesError(3); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 256, __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_t_1 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_4 = PyList_GET_ITEM(sequence, 0); + __pyx_t_1 = PyList_GET_ITEM(sequence, 1); + __pyx_t_2 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + #else + __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 256, __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, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; + index = 0; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L9_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L9_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + index = 2; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L9_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 256, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L10_unpacking_done; + __pyx_L9_unpacking_failed:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 256, __pyx_L1_error) + __pyx_L10_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v_Sucess, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_Message, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_v_FlightsAll = __pyx_t_2; + __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":257 + * + * Sucess,Message,FlightsAll = M.GetFlightsAll() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeFlightSprites(Message,FlightsAll) + * + */ + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 257, __pyx_L1_error) + if (__pyx_t_7) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":258 + * Sucess,Message,FlightsAll = M.GetFlightsAll() + * if Sucess: + * SpriteList += MakeFlightSprites(Message,FlightsAll) # <<<<<<<<<<<<<< + * + * Sucess,Message,FlightsMonitor = M.GetMonitorFlights() + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeFlightSprites); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_Message, __pyx_v_FlightsAll}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_Message, __pyx_v_FlightsAll}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_4 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_1) { + __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = NULL; + } + __Pyx_INCREF(__pyx_v_Message); + __Pyx_GIVEREF(__pyx_v_Message); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_8, __pyx_v_Message); + __Pyx_INCREF(__pyx_v_FlightsAll); + __Pyx_GIVEREF(__pyx_v_FlightsAll); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_8, __pyx_v_FlightsAll); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_2); + __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":257 + * + * Sucess,Message,FlightsAll = M.GetFlightsAll() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeFlightSprites(Message,FlightsAll) + * + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":260 + * SpriteList += MakeFlightSprites(Message,FlightsAll) + * + * Sucess,Message,FlightsMonitor = M.GetMonitorFlights() # <<<<<<<<<<<<<< + * if Sucess: + * SpriteList += MakeFlightSprites(Message,FlightsMonitor) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetMonitorFlights); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 260, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) { + PyObject* sequence = __pyx_t_2; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 3)) { + if (size > 3) __Pyx_RaiseTooManyValuesError(3); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 260, __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_t_4 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_3 = PyList_GET_ITEM(sequence, 0); + __pyx_t_4 = PyList_GET_ITEM(sequence, 1); + __pyx_t_1 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_5 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; + index = 0; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L12_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + index = 1; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L12_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 2; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L12_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 260, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L13_unpacking_done; + __pyx_L12_unpacking_failed:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 260, __pyx_L1_error) + __pyx_L13_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v_Sucess, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_Message, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_v_FlightsMonitor = __pyx_t_1; + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":261 + * + * Sucess,Message,FlightsMonitor = M.GetMonitorFlights() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeFlightSprites(Message,FlightsMonitor) + * + */ + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 261, __pyx_L1_error) + if (__pyx_t_7) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":262 + * Sucess,Message,FlightsMonitor = M.GetMonitorFlights() + * if Sucess: + * SpriteList += MakeFlightSprites(Message,FlightsMonitor) # <<<<<<<<<<<<<< + * + * Sucess,Message,WaypointsAll = M.GetFlightWaypointsAll() + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeFlightSprites); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 262, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_Message, __pyx_v_FlightsMonitor}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_Message, __pyx_v_FlightsMonitor}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else + #endif + { + __pyx_t_3 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 262, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(__pyx_v_Message); + __Pyx_GIVEREF(__pyx_v_Message); + PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_8, __pyx_v_Message); + __Pyx_INCREF(__pyx_v_FlightsMonitor); + __Pyx_GIVEREF(__pyx_v_FlightsMonitor); + PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_8, __pyx_v_FlightsMonitor); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 262, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_1); + __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":261 + * + * Sucess,Message,FlightsMonitor = M.GetMonitorFlights() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeFlightSprites(Message,FlightsMonitor) + * + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":264 + * SpriteList += MakeFlightSprites(Message,FlightsMonitor) + * + * Sucess,Message,WaypointsAll = M.GetFlightWaypointsAll() # <<<<<<<<<<<<<< + * if Sucess: + * SpriteList += MakeWaypointSprites(Message,WaypointsAll) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetFlightWaypointsAll); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 264, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 3)) { + if (size > 3) __Pyx_RaiseTooManyValuesError(3); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 264, __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_t_3 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_3 = PyList_GET_ITEM(sequence, 1); + __pyx_t_4 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; + index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L15_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L15_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L15_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 264, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L16_unpacking_done; + __pyx_L15_unpacking_failed:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 264, __pyx_L1_error) + __pyx_L16_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v_Sucess, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_Message, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_v_WaypointsAll = __pyx_t_4; + __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":265 + * + * Sucess,Message,WaypointsAll = M.GetFlightWaypointsAll() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeWaypointSprites(Message,WaypointsAll) + * + */ + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 265, __pyx_L1_error) + if (__pyx_t_7) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":266 + * Sucess,Message,WaypointsAll = M.GetFlightWaypointsAll() + * if Sucess: + * SpriteList += MakeWaypointSprites(Message,WaypointsAll) # <<<<<<<<<<<<<< + * + * Sucess,Message,WaypointsMonitor = M.GetMonitorFlightWaypoints() + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeWaypointSprites); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_Message, __pyx_v_WaypointsAll}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_Message, __pyx_v_WaypointsAll}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_2 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__pyx_t_3) { + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL; + } + __Pyx_INCREF(__pyx_v_Message); + __Pyx_GIVEREF(__pyx_v_Message); + PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_8, __pyx_v_Message); + __Pyx_INCREF(__pyx_v_WaypointsAll); + __Pyx_GIVEREF(__pyx_v_WaypointsAll); + PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_8, __pyx_v_WaypointsAll); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_4); + __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":265 + * + * Sucess,Message,WaypointsAll = M.GetFlightWaypointsAll() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeWaypointSprites(Message,WaypointsAll) + * + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":268 + * SpriteList += MakeWaypointSprites(Message,WaypointsAll) + * + * Sucess,Message,WaypointsMonitor = M.GetMonitorFlightWaypoints() # <<<<<<<<<<<<<< + * if Sucess: + * SpriteList += MakeWaypointSprites(Message,WaypointsMonitor) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetMonitorFlightWaypoints); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 268, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { + PyObject* sequence = __pyx_t_4; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 3)) { + if (size > 3) __Pyx_RaiseTooManyValuesError(3); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 268, __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_t_2 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_1 = PyList_GET_ITEM(sequence, 0); + __pyx_t_2 = PyList_GET_ITEM(sequence, 1); + __pyx_t_3 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + #else + __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; + index = 0; __pyx_t_1 = __pyx_t_6(__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_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L18_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 2; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L18_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 268, __pyx_L1_error) + __pyx_t_6 = 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_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 268, __pyx_L1_error) + __pyx_L19_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v_Sucess, __pyx_t_1); + __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_Message, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_v_WaypointsMonitor = __pyx_t_3; + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":269 + * + * Sucess,Message,WaypointsMonitor = M.GetMonitorFlightWaypoints() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeWaypointSprites(Message,WaypointsMonitor) + * + */ + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 269, __pyx_L1_error) + if (__pyx_t_7) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":270 + * Sucess,Message,WaypointsMonitor = M.GetMonitorFlightWaypoints() + * if Sucess: + * SpriteList += MakeWaypointSprites(Message,WaypointsMonitor) # <<<<<<<<<<<<<< + * + * Sucess,Message,NoFlyZones = M.GetNoFlyZones() + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeWaypointSprites); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_Message, __pyx_v_WaypointsMonitor}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_Message, __pyx_v_WaypointsMonitor}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else + #endif + { + __pyx_t_1 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_INCREF(__pyx_v_Message); + __Pyx_GIVEREF(__pyx_v_Message); + PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_8, __pyx_v_Message); + __Pyx_INCREF(__pyx_v_WaypointsMonitor); + __Pyx_GIVEREF(__pyx_v_WaypointsMonitor); + PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_8, __pyx_v_WaypointsMonitor); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_3); + __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":269 + * + * Sucess,Message,WaypointsMonitor = M.GetMonitorFlightWaypoints() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeWaypointSprites(Message,WaypointsMonitor) + * + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":272 + * SpriteList += MakeWaypointSprites(Message,WaypointsMonitor) + * + * Sucess,Message,NoFlyZones = M.GetNoFlyZones() # <<<<<<<<<<<<<< + * if Sucess: + * SpriteList += MakeZoneSprites(Message,NoFlyZones) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetNoFlyZones); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_1) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 272, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 272, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 3)) { + if (size > 3) __Pyx_RaiseTooManyValuesError(3); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 272, __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_t_1 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_4 = PyList_GET_ITEM(sequence, 0); + __pyx_t_1 = PyList_GET_ITEM(sequence, 1); + __pyx_t_2 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + #else + __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 272, __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, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; + index = 0; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L21_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L21_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + index = 2; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L21_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 272, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L22_unpacking_done; + __pyx_L21_unpacking_failed:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 272, __pyx_L1_error) + __pyx_L22_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v_Sucess, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_DECREF_SET(__pyx_v_Message, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_v_NoFlyZones = __pyx_t_2; + __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":273 + * + * Sucess,Message,NoFlyZones = M.GetNoFlyZones() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeZoneSprites(Message,NoFlyZones) + * + */ + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 273, __pyx_L1_error) + if (__pyx_t_7) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":274 + * Sucess,Message,NoFlyZones = M.GetNoFlyZones() + * if Sucess: + * SpriteList += MakeZoneSprites(Message,NoFlyZones) # <<<<<<<<<<<<<< + * + * #Sprites are created in this function to simplify code in case of an error(False) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeZoneSprites); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_Message, __pyx_v_NoFlyZones}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_Message, __pyx_v_NoFlyZones}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_4 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_1) { + __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = NULL; + } + __Pyx_INCREF(__pyx_v_Message); + __Pyx_GIVEREF(__pyx_v_Message); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_8, __pyx_v_Message); + __Pyx_INCREF(__pyx_v_NoFlyZones); + __Pyx_GIVEREF(__pyx_v_NoFlyZones); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_8, __pyx_v_NoFlyZones); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_2); + __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":273 + * + * Sucess,Message,NoFlyZones = M.GetNoFlyZones() + * if Sucess: # <<<<<<<<<<<<<< + * SpriteList += MakeZoneSprites(Message,NoFlyZones) + * + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":277 + * + * #Sprites are created in this function to simplify code in case of an error(False) + * print("Refreshed data") # <<<<<<<<<<<<<< + * return SpriteList #All sprites which were sucessfully created + * + */ + if (__Pyx_PrintOne(0, __pyx_kp_s_Refreshed_data) < 0) __PYX_ERR(0, 277, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":278 + * #Sprites are created in this function to simplify code in case of an error(False) + * print("Refreshed data") + * return SpriteList #All sprites which were sucessfully created # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_SpriteList); + __pyx_r = __pyx_v_SpriteList; + goto __pyx_L0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":245 + * return ZoneList + * + * def MakeSprites(M): # <<<<<<<<<<<<<< + * print("Refreshing data") + * SpriteList = [] + */ + + /* 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("CAStar.AATC_Monitor_Viewer.MakeSprites", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_SpriteList); + __Pyx_XDECREF(__pyx_v_Sucess); + __Pyx_XDECREF(__pyx_v_Message); + __Pyx_XDECREF(__pyx_v_DronesAll); + __Pyx_XDECREF(__pyx_v_DronesMonitor); + __Pyx_XDECREF(__pyx_v_FlightsAll); + __Pyx_XDECREF(__pyx_v_FlightsMonitor); + __Pyx_XDECREF(__pyx_v_WaypointsAll); + __Pyx_XDECREF(__pyx_v_WaypointsMonitor); + __Pyx_XDECREF(__pyx_v_NoFlyZones); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "AATC_Monitor_Viewer", + 0, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_s_127_0_0_1, __pyx_k_127_0_0_1, sizeof(__pyx_k_127_0_0_1), 0, 0, 1, 0}, + {&__pyx_n_s_AA, __pyx_k_AA, sizeof(__pyx_k_AA), 0, 0, 1, 1}, + {&__pyx_n_s_AATC_Coordinate, __pyx_k_AATC_Coordinate, sizeof(__pyx_k_AATC_Coordinate), 0, 0, 1, 1}, + {&__pyx_n_s_AATC_Monitor, __pyx_k_AATC_Monitor, sizeof(__pyx_k_AATC_Monitor), 0, 0, 1, 1}, + {&__pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_k_AATC_Monitor_Viewer_pyx, sizeof(__pyx_k_AATC_Monitor_Viewer_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_AddDrawObject, __pyx_k_AddDrawObject, sizeof(__pyx_k_AddDrawObject), 0, 0, 1, 1}, + {&__pyx_n_s_Amount, __pyx_k_Amount, sizeof(__pyx_k_Amount), 0, 0, 1, 1}, + {&__pyx_kp_s_An_error_occured_restarting_main, __pyx_k_An_error_occured_restarting_main, sizeof(__pyx_k_An_error_occured_restarting_main), 0, 0, 1, 0}, + {&__pyx_kp_s_B, __pyx_k_B, sizeof(__pyx_k_B), 0, 0, 1, 0}, + {&__pyx_n_s_BatteryIndex, __pyx_k_BatteryIndex, sizeof(__pyx_k_BatteryIndex), 0, 0, 1, 1}, + {&__pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_k_CAStar_AATC_Monitor_Viewer, sizeof(__pyx_k_CAStar_AATC_Monitor_Viewer), 0, 0, 1, 1}, + {&__pyx_n_s_Camera, __pyx_k_Camera, sizeof(__pyx_k_Camera), 0, 0, 1, 1}, + {&__pyx_n_s_CameraCoord, __pyx_k_CameraCoord, sizeof(__pyx_k_CameraCoord), 0, 0, 1, 1}, + {&__pyx_n_s_CameraEndX, __pyx_k_CameraEndX, sizeof(__pyx_k_CameraEndX), 0, 0, 1, 1}, + {&__pyx_n_s_CameraEndY, __pyx_k_CameraEndY, sizeof(__pyx_k_CameraEndY), 0, 0, 1, 1}, + {&__pyx_n_s_CameraWipe, __pyx_k_CameraWipe, sizeof(__pyx_k_CameraWipe), 0, 0, 1, 1}, + {&__pyx_n_s_CameraX, __pyx_k_CameraX, sizeof(__pyx_k_CameraX), 0, 0, 1, 1}, + {&__pyx_n_s_CameraXSize, __pyx_k_CameraXSize, sizeof(__pyx_k_CameraXSize), 0, 0, 1, 1}, + {&__pyx_n_s_CameraY, __pyx_k_CameraY, sizeof(__pyx_k_CameraY), 0, 0, 1, 1}, + {&__pyx_n_s_CameraYSize, __pyx_k_CameraYSize, sizeof(__pyx_k_CameraYSize), 0, 0, 1, 1}, + {&__pyx_n_s_CameraZoom, __pyx_k_CameraZoom, sizeof(__pyx_k_CameraZoom), 0, 0, 1, 1}, + {&__pyx_n_s_Camera_AddDrawObject, __pyx_k_Camera_AddDrawObject, sizeof(__pyx_k_Camera_AddDrawObject), 0, 0, 1, 1}, + {&__pyx_n_s_Camera_CameraWipe, __pyx_k_Camera_CameraWipe, sizeof(__pyx_k_Camera_CameraWipe), 0, 0, 1, 1}, + {&__pyx_n_s_Camera_Draw, __pyx_k_Camera_Draw, sizeof(__pyx_k_Camera_Draw), 0, 0, 1, 1}, + {&__pyx_n_s_Camera_GetCameraCoords, __pyx_k_Camera_GetCameraCoords, sizeof(__pyx_k_Camera_GetCameraCoords), 0, 0, 1, 1}, + {&__pyx_n_s_Camera_GetZoom, __pyx_k_Camera_GetZoom, sizeof(__pyx_k_Camera_GetZoom), 0, 0, 1, 1}, + {&__pyx_n_s_Camera_Get_Coord, __pyx_k_Camera_Get_Coord, sizeof(__pyx_k_Camera_Get_Coord), 0, 0, 1, 1}, + {&__pyx_n_s_Camera_IncrementCameraCoordX, __pyx_k_Camera_IncrementCameraCoordX, sizeof(__pyx_k_Camera_IncrementCameraCoordX), 0, 0, 1, 1}, + {&__pyx_n_s_Camera_IncrementCameraCoordY, __pyx_k_Camera_IncrementCameraCoordY, sizeof(__pyx_k_Camera_IncrementCameraCoordY), 0, 0, 1, 1}, + {&__pyx_n_s_Camera_ResetDrawObject, __pyx_k_Camera_ResetDrawObject, sizeof(__pyx_k_Camera_ResetDrawObject), 0, 0, 1, 1}, + {&__pyx_n_s_Camera_SetCameraCoords, __pyx_k_Camera_SetCameraCoords, sizeof(__pyx_k_Camera_SetCameraCoords), 0, 0, 1, 1}, + {&__pyx_n_s_Camera_SetZoom, __pyx_k_Camera_SetZoom, sizeof(__pyx_k_Camera_SetZoom), 0, 0, 1, 1}, + {&__pyx_n_s_Camera_UpdateCameraSize, __pyx_k_Camera_UpdateCameraSize, sizeof(__pyx_k_Camera_UpdateCameraSize), 0, 0, 1, 1}, + {&__pyx_n_s_Camera___init, __pyx_k_Camera___init, sizeof(__pyx_k_Camera___init), 0, 0, 1, 1}, + {&__pyx_kp_s_Camera_details, __pyx_k_Camera_details, sizeof(__pyx_k_Camera_details), 0, 0, 1, 0}, + {&__pyx_n_s_Clock, __pyx_k_Clock, sizeof(__pyx_k_Clock), 0, 0, 1, 1}, + {&__pyx_n_s_Colour, __pyx_k_Colour, sizeof(__pyx_k_Colour), 0, 0, 1, 1}, + {&__pyx_n_s_Columns, __pyx_k_Columns, sizeof(__pyx_k_Columns), 0, 0, 1, 1}, + {&__pyx_n_s_Coord, __pyx_k_Coord, sizeof(__pyx_k_Coord), 0, 0, 1, 1}, + {&__pyx_n_s_CoordIndex, __pyx_k_CoordIndex, sizeof(__pyx_k_CoordIndex), 0, 0, 1, 1}, + {&__pyx_n_s_CoordObject, __pyx_k_CoordObject, sizeof(__pyx_k_CoordObject), 0, 0, 1, 1}, + {&__pyx_n_s_Coordinate, __pyx_k_Coordinate, sizeof(__pyx_k_Coordinate), 0, 0, 1, 1}, + {&__pyx_n_s_Coords, __pyx_k_Coords, sizeof(__pyx_k_Coords), 0, 0, 1, 1}, + {&__pyx_n_s_CreateMonitorInterface, __pyx_k_CreateMonitorInterface, sizeof(__pyx_k_CreateMonitorInterface), 0, 0, 1, 1}, + {&__pyx_kp_s_D, __pyx_k_D, sizeof(__pyx_k_D), 0, 0, 1, 0}, + {&__pyx_kp_s_D_2, __pyx_k_D_2, sizeof(__pyx_k_D_2), 0, 0, 1, 0}, + {&__pyx_n_s_Distance, __pyx_k_Distance, sizeof(__pyx_k_Distance), 0, 0, 1, 1}, + {&__pyx_n_s_DistanceIndex, __pyx_k_DistanceIndex, sizeof(__pyx_k_DistanceIndex), 0, 0, 1, 1}, + {&__pyx_n_s_Draw, __pyx_k_Draw, sizeof(__pyx_k_Draw), 0, 0, 1, 1}, + {&__pyx_n_s_DrawObject, __pyx_k_DrawObject, sizeof(__pyx_k_DrawObject), 0, 0, 1, 1}, + {&__pyx_n_s_DrawObjects, __pyx_k_DrawObjects, sizeof(__pyx_k_DrawObjects), 0, 0, 1, 1}, + {&__pyx_n_s_Drone, __pyx_k_Drone, sizeof(__pyx_k_Drone), 0, 0, 1, 1}, + {&__pyx_n_s_DroneID, __pyx_k_DroneID, sizeof(__pyx_k_DroneID), 0, 0, 1, 1}, + {&__pyx_n_s_DroneIDIndex, __pyx_k_DroneIDIndex, sizeof(__pyx_k_DroneIDIndex), 0, 0, 1, 1}, + {&__pyx_n_s_DroneList, __pyx_k_DroneList, sizeof(__pyx_k_DroneList), 0, 0, 1, 1}, + {&__pyx_n_s_DroneName, __pyx_k_DroneName, sizeof(__pyx_k_DroneName), 0, 0, 1, 1}, + {&__pyx_n_s_DroneNameIndex, __pyx_k_DroneNameIndex, sizeof(__pyx_k_DroneNameIndex), 0, 0, 1, 1}, + {&__pyx_n_s_DronesAll, __pyx_k_DronesAll, sizeof(__pyx_k_DronesAll), 0, 0, 1, 1}, + {&__pyx_n_s_DronesMonitor, __pyx_k_DronesMonitor, sizeof(__pyx_k_DronesMonitor), 0, 0, 1, 1}, + {&__pyx_n_s_ETA, __pyx_k_ETA, sizeof(__pyx_k_ETA), 0, 0, 1, 1}, + {&__pyx_n_s_ETAIndex, __pyx_k_ETAIndex, sizeof(__pyx_k_ETAIndex), 0, 0, 1, 1}, + {&__pyx_kp_s_ETA_2, __pyx_k_ETA_2, sizeof(__pyx_k_ETA_2), 0, 0, 1, 0}, + {&__pyx_n_s_EndCoord, __pyx_k_EndCoord, sizeof(__pyx_k_EndCoord), 0, 0, 1, 1}, + {&__pyx_n_s_EndCoordIndex, __pyx_k_EndCoordIndex, sizeof(__pyx_k_EndCoordIndex), 0, 0, 1, 1}, + {&__pyx_n_s_EndCoords, __pyx_k_EndCoords, sizeof(__pyx_k_EndCoords), 0, 0, 1, 1}, + {&__pyx_n_s_EndCoordsIndex, __pyx_k_EndCoordsIndex, sizeof(__pyx_k_EndCoordsIndex), 0, 0, 1, 1}, + {&__pyx_n_s_EndPoint, __pyx_k_EndPoint, sizeof(__pyx_k_EndPoint), 0, 0, 1, 1}, + {&__pyx_n_s_EndTime, __pyx_k_EndTime, sizeof(__pyx_k_EndTime), 0, 0, 1, 1}, + {&__pyx_n_s_EndTimeIndex, __pyx_k_EndTimeIndex, sizeof(__pyx_k_EndTimeIndex), 0, 0, 1, 1}, + {&__pyx_n_s_Exit, __pyx_k_Exit, sizeof(__pyx_k_Exit), 0, 0, 1, 1}, + {&__pyx_kp_s_Exit_Y_N, __pyx_k_Exit_Y_N, sizeof(__pyx_k_Exit_Y_N), 0, 0, 1, 0}, + {&__pyx_kp_s_F, __pyx_k_F, sizeof(__pyx_k_F), 0, 0, 1, 0}, + {&__pyx_kp_s_FPS, __pyx_k_FPS, sizeof(__pyx_k_FPS), 0, 0, 1, 0}, + {&__pyx_n_s_Flight, __pyx_k_Flight, sizeof(__pyx_k_Flight), 0, 0, 1, 1}, + {&__pyx_n_s_FlightID, __pyx_k_FlightID, sizeof(__pyx_k_FlightID), 0, 0, 1, 1}, + {&__pyx_n_s_FlightIDIndex, __pyx_k_FlightIDIndex, sizeof(__pyx_k_FlightIDIndex), 0, 0, 1, 1}, + {&__pyx_n_s_FlightList, __pyx_k_FlightList, sizeof(__pyx_k_FlightList), 0, 0, 1, 1}, + {&__pyx_n_s_FlightsAll, __pyx_k_FlightsAll, sizeof(__pyx_k_FlightsAll), 0, 0, 1, 1}, + {&__pyx_n_s_FlightsMonitor, __pyx_k_FlightsMonitor, sizeof(__pyx_k_FlightsMonitor), 0, 0, 1, 1}, + {&__pyx_n_s_Font, __pyx_k_Font, sizeof(__pyx_k_Font), 0, 0, 1, 1}, + {&__pyx_n_s_ForceDraw, __pyx_k_ForceDraw, sizeof(__pyx_k_ForceDraw), 0, 0, 1, 1}, + {&__pyx_n_s_GetCameraCoords, __pyx_k_GetCameraCoords, sizeof(__pyx_k_GetCameraCoords), 0, 0, 1, 1}, + {&__pyx_n_s_GetDronesAll, __pyx_k_GetDronesAll, sizeof(__pyx_k_GetDronesAll), 0, 0, 1, 1}, + {&__pyx_n_s_GetFlightWaypointsAll, __pyx_k_GetFlightWaypointsAll, sizeof(__pyx_k_GetFlightWaypointsAll), 0, 0, 1, 1}, + {&__pyx_n_s_GetFlightsAll, __pyx_k_GetFlightsAll, sizeof(__pyx_k_GetFlightsAll), 0, 0, 1, 1}, + {&__pyx_n_s_GetFont, __pyx_k_GetFont, sizeof(__pyx_k_GetFont), 0, 0, 1, 1}, + {&__pyx_n_s_GetImage, __pyx_k_GetImage, sizeof(__pyx_k_GetImage), 0, 0, 1, 1}, + {&__pyx_n_s_GetMonitorDrones, __pyx_k_GetMonitorDrones, sizeof(__pyx_k_GetMonitorDrones), 0, 0, 1, 1}, + {&__pyx_n_s_GetMonitorFlightWaypoints, __pyx_k_GetMonitorFlightWaypoints, sizeof(__pyx_k_GetMonitorFlightWaypoints), 0, 0, 1, 1}, + {&__pyx_n_s_GetMonitorFlights, __pyx_k_GetMonitorFlights, sizeof(__pyx_k_GetMonitorFlights), 0, 0, 1, 1}, + {&__pyx_n_s_GetNoFlyZones, __pyx_k_GetNoFlyZones, sizeof(__pyx_k_GetNoFlyZones), 0, 0, 1, 1}, + {&__pyx_n_s_GetText, __pyx_k_GetText, sizeof(__pyx_k_GetText), 0, 0, 1, 1}, + {&__pyx_n_s_GetZoom, __pyx_k_GetZoom, sizeof(__pyx_k_GetZoom), 0, 0, 1, 1}, + {&__pyx_n_s_Get_Coord, __pyx_k_Get_Coord, sizeof(__pyx_k_Get_Coord), 0, 0, 1, 1}, + {&__pyx_n_s_Get_Coords, __pyx_k_Get_Coords, sizeof(__pyx_k_Get_Coords), 0, 0, 1, 1}, + {&__pyx_n_s_Get_X, __pyx_k_Get_X, sizeof(__pyx_k_Get_X), 0, 0, 1, 1}, + {&__pyx_n_s_Get_XSize, __pyx_k_Get_XSize, sizeof(__pyx_k_Get_XSize), 0, 0, 1, 1}, + {&__pyx_n_s_Get_Y, __pyx_k_Get_Y, sizeof(__pyx_k_Get_Y), 0, 0, 1, 1}, + {&__pyx_n_s_Get_YSize, __pyx_k_Get_YSize, sizeof(__pyx_k_Get_YSize), 0, 0, 1, 1}, + {&__pyx_n_s_Get_Z, __pyx_k_Get_Z, sizeof(__pyx_k_Get_Z), 0, 0, 1, 1}, + {&__pyx_n_s_IP, __pyx_k_IP, sizeof(__pyx_k_IP), 0, 0, 1, 1}, + {&__pyx_n_s_IncrementCameraCoordX, __pyx_k_IncrementCameraCoordX, sizeof(__pyx_k_IncrementCameraCoordX), 0, 0, 1, 1}, + {&__pyx_n_s_IncrementCameraCoordY, __pyx_k_IncrementCameraCoordY, sizeof(__pyx_k_IncrementCameraCoordY), 0, 0, 1, 1}, + {&__pyx_n_s_KEYDOWN, __pyx_k_KEYDOWN, sizeof(__pyx_k_KEYDOWN), 0, 0, 1, 1}, + {&__pyx_n_s_K_SPACE, __pyx_k_K_SPACE, sizeof(__pyx_k_K_SPACE), 0, 0, 1, 1}, + {&__pyx_n_s_K_a, __pyx_k_K_a, sizeof(__pyx_k_K_a), 0, 0, 1, 1}, + {&__pyx_n_s_K_d, __pyx_k_K_d, sizeof(__pyx_k_K_d), 0, 0, 1, 1}, + {&__pyx_n_s_K_e, __pyx_k_K_e, sizeof(__pyx_k_K_e), 0, 0, 1, 1}, + {&__pyx_n_s_K_q, __pyx_k_K_q, sizeof(__pyx_k_K_q), 0, 0, 1, 1}, + {&__pyx_n_s_K_s, __pyx_k_K_s, sizeof(__pyx_k_K_s), 0, 0, 1, 1}, + {&__pyx_n_s_K_w, __pyx_k_K_w, sizeof(__pyx_k_K_w), 0, 0, 1, 1}, + {&__pyx_kp_s_L, __pyx_k_L, sizeof(__pyx_k_L), 0, 0, 1, 0}, + {&__pyx_n_s_LastBattery, __pyx_k_LastBattery, sizeof(__pyx_k_LastBattery), 0, 0, 1, 1}, + {&__pyx_n_s_LastCoords, __pyx_k_LastCoords, sizeof(__pyx_k_LastCoords), 0, 0, 1, 1}, + {&__pyx_n_s_Last_Refresh_Time, __pyx_k_Last_Refresh_Time, sizeof(__pyx_k_Last_Refresh_Time), 0, 0, 1, 1}, + {&__pyx_n_s_Level, __pyx_k_Level, sizeof(__pyx_k_Level), 0, 0, 1, 1}, + {&__pyx_n_s_LevelIndex, __pyx_k_LevelIndex, sizeof(__pyx_k_LevelIndex), 0, 0, 1, 1}, + {&__pyx_n_s_Login, __pyx_k_Login, sizeof(__pyx_k_Login), 0, 0, 1, 1}, + {&__pyx_n_s_M, __pyx_k_M, sizeof(__pyx_k_M), 0, 0, 1, 1}, + {&__pyx_n_s_MOUSEBUTTONDOWN, __pyx_k_MOUSEBUTTONDOWN, sizeof(__pyx_k_MOUSEBUTTONDOWN), 0, 0, 1, 1}, + {&__pyx_n_s_MakeDroneSprites, __pyx_k_MakeDroneSprites, sizeof(__pyx_k_MakeDroneSprites), 0, 0, 1, 1}, + {&__pyx_n_s_MakeFlightSprites, __pyx_k_MakeFlightSprites, sizeof(__pyx_k_MakeFlightSprites), 0, 0, 1, 1}, + {&__pyx_n_s_MakeSprites, __pyx_k_MakeSprites, sizeof(__pyx_k_MakeSprites), 0, 0, 1, 1}, + {&__pyx_n_s_MakeWaypointSprites, __pyx_k_MakeWaypointSprites, sizeof(__pyx_k_MakeWaypointSprites), 0, 0, 1, 1}, + {&__pyx_n_s_MakeZoneSprites, __pyx_k_MakeZoneSprites, sizeof(__pyx_k_MakeZoneSprites), 0, 0, 1, 1}, + {&__pyx_n_s_Make_Image, __pyx_k_Make_Image, sizeof(__pyx_k_Make_Image), 0, 0, 1, 1}, + {&__pyx_n_s_Make_Text, __pyx_k_Make_Text, sizeof(__pyx_k_Make_Text), 0, 0, 1, 1}, + {&__pyx_n_s_MaxCoords, __pyx_k_MaxCoords, sizeof(__pyx_k_MaxCoords), 0, 0, 1, 1}, + {&__pyx_n_s_Message, __pyx_k_Message, sizeof(__pyx_k_Message), 0, 0, 1, 1}, + {&__pyx_n_s_MinCoords, __pyx_k_MinCoords, sizeof(__pyx_k_MinCoords), 0, 0, 1, 1}, + {&__pyx_n_s_MonCamera, __pyx_k_MonCamera, sizeof(__pyx_k_MonCamera), 0, 0, 1, 1}, + {&__pyx_n_s_Monitor_Sprite, __pyx_k_Monitor_Sprite, sizeof(__pyx_k_Monitor_Sprite), 0, 0, 1, 1}, + {&__pyx_n_s_Monitor_Sprite_Get_Coords, __pyx_k_Monitor_Sprite_Get_Coords, sizeof(__pyx_k_Monitor_Sprite_Get_Coords), 0, 0, 1, 1}, + {&__pyx_n_s_Monitor_Sprite_Make_Image, __pyx_k_Monitor_Sprite_Make_Image, sizeof(__pyx_k_Monitor_Sprite_Make_Image), 0, 0, 1, 1}, + {&__pyx_n_s_Monitor_Sprite_Make_Text, __pyx_k_Monitor_Sprite_Make_Text, sizeof(__pyx_k_Monitor_Sprite_Make_Text), 0, 0, 1, 1}, + {&__pyx_n_s_Monitor_Sprite___init, __pyx_k_Monitor_Sprite___init, sizeof(__pyx_k_Monitor_Sprite___init), 0, 0, 1, 1}, + {&__pyx_kp_s_Monitor_exit_was_called, __pyx_k_Monitor_exit_was_called, sizeof(__pyx_k_Monitor_exit_was_called), 0, 0, 1, 0}, + {&__pyx_kp_s_N, __pyx_k_N, sizeof(__pyx_k_N), 0, 0, 1, 0}, + {&__pyx_n_s_N_2, __pyx_k_N_2, sizeof(__pyx_k_N_2), 0, 0, 1, 1}, + {&__pyx_n_s_NoFlyZone, __pyx_k_NoFlyZone, sizeof(__pyx_k_NoFlyZone), 0, 0, 1, 1}, + {&__pyx_n_s_NoFlyZones, __pyx_k_NoFlyZones, sizeof(__pyx_k_NoFlyZones), 0, 0, 1, 1}, + {&__pyx_n_s_Object, __pyx_k_Object, sizeof(__pyx_k_Object), 0, 0, 1, 1}, + {&__pyx_n_s_Object_Coords, __pyx_k_Object_Coords, sizeof(__pyx_k_Object_Coords), 0, 0, 1, 1}, + {&__pyx_n_s_Port, __pyx_k_Port, sizeof(__pyx_k_Port), 0, 0, 1, 1}, + {&__pyx_n_s_PosX, __pyx_k_PosX, sizeof(__pyx_k_PosX), 0, 0, 1, 1}, + {&__pyx_n_s_PosY, __pyx_k_PosY, sizeof(__pyx_k_PosY), 0, 0, 1, 1}, + {&__pyx_n_s_QUIT, __pyx_k_QUIT, sizeof(__pyx_k_QUIT), 0, 0, 1, 1}, + {&__pyx_n_s_RawDroneList, __pyx_k_RawDroneList, sizeof(__pyx_k_RawDroneList), 0, 0, 1, 1}, + {&__pyx_n_s_RawFlightList, __pyx_k_RawFlightList, sizeof(__pyx_k_RawFlightList), 0, 0, 1, 1}, + {&__pyx_n_s_RawWaypointList, __pyx_k_RawWaypointList, sizeof(__pyx_k_RawWaypointList), 0, 0, 1, 1}, + {&__pyx_n_s_RawZoneList, __pyx_k_RawZoneList, sizeof(__pyx_k_RawZoneList), 0, 0, 1, 1}, + {&__pyx_n_s_Refresh_Delay, __pyx_k_Refresh_Delay, sizeof(__pyx_k_Refresh_Delay), 0, 0, 1, 1}, + {&__pyx_kp_s_Refreshed_data, __pyx_k_Refreshed_data, sizeof(__pyx_k_Refreshed_data), 0, 0, 1, 0}, + {&__pyx_kp_s_Refreshing_data, __pyx_k_Refreshing_data, sizeof(__pyx_k_Refreshing_data), 0, 0, 1, 0}, + {&__pyx_n_s_ResetDrawObject, __pyx_k_ResetDrawObject, sizeof(__pyx_k_ResetDrawObject), 0, 0, 1, 1}, + {&__pyx_kp_s_ST, __pyx_k_ST, sizeof(__pyx_k_ST), 0, 0, 1, 0}, + {&__pyx_n_s_SetCameraCoords, __pyx_k_SetCameraCoords, sizeof(__pyx_k_SetCameraCoords), 0, 0, 1, 1}, + {&__pyx_n_s_SetZoom, __pyx_k_SetZoom, sizeof(__pyx_k_SetZoom), 0, 0, 1, 1}, + {&__pyx_n_s_Set_X, __pyx_k_Set_X, sizeof(__pyx_k_Set_X), 0, 0, 1, 1}, + {&__pyx_n_s_Set_XSize, __pyx_k_Set_XSize, sizeof(__pyx_k_Set_XSize), 0, 0, 1, 1}, + {&__pyx_n_s_Set_Y, __pyx_k_Set_Y, sizeof(__pyx_k_Set_Y), 0, 0, 1, 1}, + {&__pyx_n_s_Set_YSize, __pyx_k_Set_YSize, sizeof(__pyx_k_Set_YSize), 0, 0, 1, 1}, + {&__pyx_n_s_Size, __pyx_k_Size, sizeof(__pyx_k_Size), 0, 0, 1, 1}, + {&__pyx_n_s_Sprite, __pyx_k_Sprite, sizeof(__pyx_k_Sprite), 0, 0, 1, 1}, + {&__pyx_n_s_SpriteList, __pyx_k_SpriteList, sizeof(__pyx_k_SpriteList), 0, 0, 1, 1}, + {&__pyx_n_s_Sprites, __pyx_k_Sprites, sizeof(__pyx_k_Sprites), 0, 0, 1, 1}, + {&__pyx_n_s_StartCoord, __pyx_k_StartCoord, sizeof(__pyx_k_StartCoord), 0, 0, 1, 1}, + {&__pyx_n_s_StartCoordIndex, __pyx_k_StartCoordIndex, sizeof(__pyx_k_StartCoordIndex), 0, 0, 1, 1}, + {&__pyx_n_s_StartCoords, __pyx_k_StartCoords, sizeof(__pyx_k_StartCoords), 0, 0, 1, 1}, + {&__pyx_n_s_StartCoordsIndex, __pyx_k_StartCoordsIndex, sizeof(__pyx_k_StartCoordsIndex), 0, 0, 1, 1}, + {&__pyx_n_s_StartPoint, __pyx_k_StartPoint, sizeof(__pyx_k_StartPoint), 0, 0, 1, 1}, + {&__pyx_n_s_StartTime, __pyx_k_StartTime, sizeof(__pyx_k_StartTime), 0, 0, 1, 1}, + {&__pyx_n_s_StartTimeIndex, __pyx_k_StartTimeIndex, sizeof(__pyx_k_StartTimeIndex), 0, 0, 1, 1}, + {&__pyx_n_s_Sucess, __pyx_k_Sucess, sizeof(__pyx_k_Sucess), 0, 0, 1, 1}, + {&__pyx_n_s_Surface, __pyx_k_Surface, sizeof(__pyx_k_Surface), 0, 0, 1, 1}, + {&__pyx_n_s_Text, __pyx_k_Text, sizeof(__pyx_k_Text), 0, 0, 1, 1}, + {&__pyx_n_s_Type, __pyx_k_Type, sizeof(__pyx_k_Type), 0, 0, 1, 1}, + {&__pyx_kp_s_U, __pyx_k_U, sizeof(__pyx_k_U), 0, 0, 1, 0}, + {&__pyx_n_s_UpdateCameraSize, __pyx_k_UpdateCameraSize, sizeof(__pyx_k_UpdateCameraSize), 0, 0, 1, 1}, + {&__pyx_n_s_UserID, __pyx_k_UserID, sizeof(__pyx_k_UserID), 0, 0, 1, 1}, + {&__pyx_n_s_UserIDIndex, __pyx_k_UserIDIndex, sizeof(__pyx_k_UserIDIndex), 0, 0, 1, 1}, + {&__pyx_kp_s_W, __pyx_k_W, sizeof(__pyx_k_W), 0, 0, 1, 0}, + {&__pyx_n_s_Waypoint, __pyx_k_Waypoint, sizeof(__pyx_k_Waypoint), 0, 0, 1, 1}, + {&__pyx_n_s_WaypointList, __pyx_k_WaypointList, sizeof(__pyx_k_WaypointList), 0, 0, 1, 1}, + {&__pyx_n_s_WaypointNumber, __pyx_k_WaypointNumber, sizeof(__pyx_k_WaypointNumber), 0, 0, 1, 1}, + {&__pyx_n_s_WaypointNumberIndex, __pyx_k_WaypointNumberIndex, sizeof(__pyx_k_WaypointNumberIndex), 0, 0, 1, 1}, + {&__pyx_n_s_WaypointsAll, __pyx_k_WaypointsAll, sizeof(__pyx_k_WaypointsAll), 0, 0, 1, 1}, + {&__pyx_n_s_WaypointsMonitor, __pyx_k_WaypointsMonitor, sizeof(__pyx_k_WaypointsMonitor), 0, 0, 1, 1}, + {&__pyx_n_s_Y, __pyx_k_Y, sizeof(__pyx_k_Y), 0, 0, 1, 1}, + {&__pyx_kp_s_Z, __pyx_k_Z, sizeof(__pyx_k_Z), 0, 0, 1, 0}, + {&__pyx_n_s_Zini, __pyx_k_Zini, sizeof(__pyx_k_Zini), 0, 0, 1, 1}, + {&__pyx_n_s_Zone, __pyx_k_Zone, sizeof(__pyx_k_Zone), 0, 0, 1, 1}, + {&__pyx_n_s_ZoneID, __pyx_k_ZoneID, sizeof(__pyx_k_ZoneID), 0, 0, 1, 1}, + {&__pyx_n_s_ZoneIDIndex, __pyx_k_ZoneIDIndex, sizeof(__pyx_k_ZoneIDIndex), 0, 0, 1, 1}, + {&__pyx_n_s_ZoneList, __pyx_k_ZoneList, sizeof(__pyx_k_ZoneList), 0, 0, 1, 1}, + {&__pyx_n_s_Zoom, __pyx_k_Zoom, sizeof(__pyx_k_Zoom), 0, 0, 1, 1}, + {&__pyx_kp_s__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 1, 0}, + {&__pyx_kp_s__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 0, 1, 0}, + {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1}, + {&__pyx_n_s_ast, __pyx_k_ast, sizeof(__pyx_k_ast), 0, 0, 1, 1}, + {&__pyx_n_s_blit, __pyx_k_blit, sizeof(__pyx_k_blit), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_clock, __pyx_k_clock, sizeof(__pyx_k_clock), 0, 0, 1, 1}, + {&__pyx_n_s_convert, __pyx_k_convert, sizeof(__pyx_k_convert), 0, 0, 1, 1}, + {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, + {&__pyx_n_s_display, __pyx_k_display, sizeof(__pyx_k_display), 0, 0, 1, 1}, + {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, + {&__pyx_n_s_e, __pyx_k_e, sizeof(__pyx_k_e), 0, 0, 1, 1}, + {&__pyx_n_s_end, __pyx_k_end, sizeof(__pyx_k_end), 0, 0, 1, 1}, + {&__pyx_n_s_event, __pyx_k_event, sizeof(__pyx_k_event), 0, 0, 1, 1}, + {&__pyx_n_s_exit, __pyx_k_exit, sizeof(__pyx_k_exit), 0, 0, 1, 1}, + {&__pyx_n_s_file, __pyx_k_file, sizeof(__pyx_k_file), 0, 0, 1, 1}, + {&__pyx_n_s_fill, __pyx_k_fill, sizeof(__pyx_k_fill), 0, 0, 1, 1}, + {&__pyx_n_s_flip, __pyx_k_flip, sizeof(__pyx_k_flip), 0, 0, 1, 1}, + {&__pyx_n_s_font, __pyx_k_font, sizeof(__pyx_k_font), 0, 0, 1, 1}, + {&__pyx_n_s_fontParameters, __pyx_k_fontParameters, sizeof(__pyx_k_fontParameters), 0, 0, 1, 1}, + {&__pyx_n_s_font_size, __pyx_k_font_size, sizeof(__pyx_k_font_size), 0, 0, 1, 1}, + {&__pyx_n_s_fonts, __pyx_k_fonts, sizeof(__pyx_k_fonts), 0, 0, 1, 1}, + {&__pyx_n_s_gameDisplay, __pyx_k_gameDisplay, sizeof(__pyx_k_gameDisplay), 0, 0, 1, 1}, + {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, + {&__pyx_n_s_get_fps, __pyx_k_get_fps, sizeof(__pyx_k_get_fps), 0, 0, 1, 1}, + {&__pyx_n_s_get_pressed, __pyx_k_get_pressed, sizeof(__pyx_k_get_pressed), 0, 0, 1, 1}, + {&__pyx_n_s_get_size, __pyx_k_get_size, sizeof(__pyx_k_get_size), 0, 0, 1, 1}, + {&__pyx_n_s_height, __pyx_k_height, sizeof(__pyx_k_height), 0, 0, 1, 1}, + {&__pyx_n_s_image, __pyx_k_image, sizeof(__pyx_k_image), 0, 0, 1, 1}, + {&__pyx_n_s_images, __pyx_k_images, sizeof(__pyx_k_images), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1}, + {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, + {&__pyx_n_s_init_2, __pyx_k_init_2, sizeof(__pyx_k_init_2), 0, 0, 1, 1}, + {&__pyx_n_s_input, __pyx_k_input, sizeof(__pyx_k_input), 0, 0, 1, 1}, + {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1}, + {&__pyx_n_s_keys, __pyx_k_keys, sizeof(__pyx_k_keys), 0, 0, 1, 1}, + {&__pyx_n_s_literal_eval, __pyx_k_literal_eval, sizeof(__pyx_k_literal_eval), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, + {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, + {&__pyx_n_s_pop, __pyx_k_pop, sizeof(__pyx_k_pop), 0, 0, 1, 1}, + {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, + {&__pyx_n_s_pressed, __pyx_k_pressed, sizeof(__pyx_k_pressed), 0, 0, 1, 1}, + {&__pyx_n_s_print, __pyx_k_print, sizeof(__pyx_k_print), 0, 0, 1, 1}, + {&__pyx_n_s_pygame, __pyx_k_pygame, sizeof(__pyx_k_pygame), 0, 0, 1, 1}, + {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, + {&__pyx_n_s_quit, __pyx_k_quit, sizeof(__pyx_k_quit), 0, 0, 1, 1}, + {&__pyx_n_s_random, __pyx_k_random, sizeof(__pyx_k_random), 0, 0, 1, 1}, + {&__pyx_n_s_refresh, __pyx_k_refresh, sizeof(__pyx_k_refresh), 0, 0, 1, 1}, + {&__pyx_n_s_render, __pyx_k_render, sizeof(__pyx_k_render), 0, 0, 1, 1}, + {&__pyx_n_s_result, __pyx_k_result, sizeof(__pyx_k_result), 0, 0, 1, 1}, + {&__pyx_n_s_sample, __pyx_k_sample, sizeof(__pyx_k_sample), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_set_mode, __pyx_k_set_mode, sizeof(__pyx_k_set_mode), 0, 0, 1, 1}, + {&__pyx_n_s_sprite, __pyx_k_sprite, sizeof(__pyx_k_sprite), 0, 0, 1, 1}, + {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_text, __pyx_k_text, sizeof(__pyx_k_text), 0, 0, 1, 1}, + {&__pyx_n_s_texts, __pyx_k_texts, sizeof(__pyx_k_texts), 0, 0, 1, 1}, + {&__pyx_n_s_tick, __pyx_k_tick, sizeof(__pyx_k_tick), 0, 0, 1, 1}, + {&__pyx_n_s_time, __pyx_k_time, sizeof(__pyx_k_time), 0, 0, 1, 1}, + {&__pyx_n_s_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 0, 1, 1}, + {&__pyx_n_s_upper, __pyx_k_upper, sizeof(__pyx_k_upper), 0, 0, 1, 1}, + {&__pyx_n_s_width, __pyx_k_width, sizeof(__pyx_k_width), 0, 0, 1, 1}, + {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, + {&__pyx_n_s_xSize, __pyx_k_xSize, sizeof(__pyx_k_xSize), 0, 0, 1, 1}, + {&__pyx_n_s_xpixel, __pyx_k_xpixel, sizeof(__pyx_k_xpixel), 0, 0, 1, 1}, + {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, + {&__pyx_n_s_ySize, __pyx_k_ySize, sizeof(__pyx_k_ySize), 0, 0, 1, 1}, + {&__pyx_n_s_ypixel, __pyx_k_ypixel, sizeof(__pyx_k_ypixel), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_input = __Pyx_GetBuiltinName(__pyx_n_s_input); if (!__pyx_builtin_input) __PYX_ERR(0, 357, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "CAStar/AATC_Monitor_Viewer.pyx":82 + * self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom) + * + * def CameraWipe(self,Colour = (0,0,0)): # <<<<<<<<<<<<<< + * self.gameDisplay.fill(Colour) + * def ResetDrawObject(self): + */ + __pyx_tuple_ = PyTuple_Pack(3, __pyx_int_0, __pyx_int_0, __pyx_int_0); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "CAStar/AATC_Monitor_Viewer.pyx":134 + * + * class Monitor_Sprite(pygame.sprite.Sprite): + * def __init__(self,CoordObject,Type = "",Text = "",Colour = (255,255,255)): # <<<<<<<<<<<<<< + * self.Coords = CoordObject + * self.Type = Type + */ + __pyx_tuple__3 = PyTuple_Pack(3, __pyx_int_255, __pyx_int_255, __pyx_int_255); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "CAStar/AATC_Monitor_Viewer.pyx":139 + * self.Text = Text + * self.Colour = Colour + * self.image = pygame.Surface((1,1)) # <<<<<<<<<<<<<< + * #self.Make_Image(2,2) # No longer needed, is similar to that above. + * + */ + __pyx_tuple__4 = PyTuple_Pack(2, __pyx_int_1, __pyx_int_1); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_tuple__4); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "CAStar/AATC_Monitor_Viewer.pyx":173 + * DroneList = [] + * Columns = ast.literal_eval(Message) + * CoordIndex = Columns.index("LastCoords") # <<<<<<<<<<<<<< + * DroneIDIndex = Columns.index("DroneID") + * UserIDIndex = Columns.index("UserID") + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_n_s_LastCoords); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "CAStar/AATC_Monitor_Viewer.pyx":174 + * Columns = ast.literal_eval(Message) + * CoordIndex = Columns.index("LastCoords") + * DroneIDIndex = Columns.index("DroneID") # <<<<<<<<<<<<<< + * UserIDIndex = Columns.index("UserID") + * DroneNameIndex = Columns.index("DroneName") + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_n_s_DroneID); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "CAStar/AATC_Monitor_Viewer.pyx":175 + * CoordIndex = Columns.index("LastCoords") + * DroneIDIndex = Columns.index("DroneID") + * UserIDIndex = Columns.index("UserID") # <<<<<<<<<<<<<< + * DroneNameIndex = Columns.index("DroneName") + * BatteryIndex = Columns.index("LastBattery") + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_n_s_UserID); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "CAStar/AATC_Monitor_Viewer.pyx":176 + * DroneIDIndex = Columns.index("DroneID") + * UserIDIndex = Columns.index("UserID") + * DroneNameIndex = Columns.index("DroneName") # <<<<<<<<<<<<<< + * BatteryIndex = Columns.index("LastBattery") + * for Drone in RawDroneList: + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_n_s_DroneName); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "CAStar/AATC_Monitor_Viewer.pyx":177 + * UserIDIndex = Columns.index("UserID") + * DroneNameIndex = Columns.index("DroneName") + * BatteryIndex = Columns.index("LastBattery") # <<<<<<<<<<<<<< + * for Drone in RawDroneList: + * LastCoords = ast.literal_eval(Drone[CoordIndex]) + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_n_s_LastBattery); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "CAStar/AATC_Monitor_Viewer.pyx":190 + * FlightList = [] + * Columns = ast.literal_eval(Message) + * FlightIDIndex = Columns.index("FlightID") # <<<<<<<<<<<<<< + * DroneIDIndex = Columns.index("DroneID") + * StartCoordsIndex = Columns.index("StartCoords") + */ + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_n_s_FlightID); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "CAStar/AATC_Monitor_Viewer.pyx":191 + * Columns = ast.literal_eval(Message) + * FlightIDIndex = Columns.index("FlightID") + * DroneIDIndex = Columns.index("DroneID") # <<<<<<<<<<<<<< + * StartCoordsIndex = Columns.index("StartCoords") + * EndCoordsIndex = Columns.index("EndCoords") + */ + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_DroneID); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "CAStar/AATC_Monitor_Viewer.pyx":192 + * FlightIDIndex = Columns.index("FlightID") + * DroneIDIndex = Columns.index("DroneID") + * StartCoordsIndex = Columns.index("StartCoords") # <<<<<<<<<<<<<< + * EndCoordsIndex = Columns.index("EndCoords") + * StartTimeIndex = Columns.index("StartTime") + */ + __pyx_tuple__14 = PyTuple_Pack(1, __pyx_n_s_StartCoords); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + /* "CAStar/AATC_Monitor_Viewer.pyx":193 + * DroneIDIndex = Columns.index("DroneID") + * StartCoordsIndex = Columns.index("StartCoords") + * EndCoordsIndex = Columns.index("EndCoords") # <<<<<<<<<<<<<< + * StartTimeIndex = Columns.index("StartTime") + * ETAIndex = Columns.index("ETA") + */ + __pyx_tuple__15 = PyTuple_Pack(1, __pyx_n_s_EndCoords); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + + /* "CAStar/AATC_Monitor_Viewer.pyx":194 + * StartCoordsIndex = Columns.index("StartCoords") + * EndCoordsIndex = Columns.index("EndCoords") + * StartTimeIndex = Columns.index("StartTime") # <<<<<<<<<<<<<< + * ETAIndex = Columns.index("ETA") + * EndTimeIndex = Columns.index("EndTime") + */ + __pyx_tuple__16 = PyTuple_Pack(1, __pyx_n_s_StartTime); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + + /* "CAStar/AATC_Monitor_Viewer.pyx":195 + * EndCoordsIndex = Columns.index("EndCoords") + * StartTimeIndex = Columns.index("StartTime") + * ETAIndex = Columns.index("ETA") # <<<<<<<<<<<<<< + * EndTimeIndex = Columns.index("EndTime") + * DistanceIndex = Columns.index("Distance") + */ + __pyx_tuple__17 = PyTuple_Pack(1, __pyx_n_s_ETA); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + + /* "CAStar/AATC_Monitor_Viewer.pyx":196 + * StartTimeIndex = Columns.index("StartTime") + * ETAIndex = Columns.index("ETA") + * EndTimeIndex = Columns.index("EndTime") # <<<<<<<<<<<<<< + * DistanceIndex = Columns.index("Distance") + * for Flight in RawFlightList: + */ + __pyx_tuple__18 = PyTuple_Pack(1, __pyx_n_s_EndTime); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); + + /* "CAStar/AATC_Monitor_Viewer.pyx":197 + * ETAIndex = Columns.index("ETA") + * EndTimeIndex = Columns.index("EndTime") + * DistanceIndex = Columns.index("Distance") # <<<<<<<<<<<<<< + * for Flight in RawFlightList: + * #Start Sprite + */ + __pyx_tuple__19 = PyTuple_Pack(1, __pyx_n_s_Distance); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + + /* "CAStar/AATC_Monitor_Viewer.pyx":218 + * WaypointList = [] + * Columns = ast.literal_eval(Message) + * CoordIndex = Columns.index("Coords") # <<<<<<<<<<<<<< + * WaypointNumberIndex = Columns.index("WaypointNumber") + * FlightIDIndex = Columns.index("FlightID") + */ + __pyx_tuple__20 = PyTuple_Pack(1, __pyx_n_s_Coords); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); + + /* "CAStar/AATC_Monitor_Viewer.pyx":219 + * Columns = ast.literal_eval(Message) + * CoordIndex = Columns.index("Coords") + * WaypointNumberIndex = Columns.index("WaypointNumber") # <<<<<<<<<<<<<< + * FlightIDIndex = Columns.index("FlightID") + * for Waypoint in RawWaypointList: + */ + __pyx_tuple__21 = PyTuple_Pack(1, __pyx_n_s_WaypointNumber); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + + /* "CAStar/AATC_Monitor_Viewer.pyx":220 + * CoordIndex = Columns.index("Coords") + * WaypointNumberIndex = Columns.index("WaypointNumber") + * FlightIDIndex = Columns.index("FlightID") # <<<<<<<<<<<<<< + * for Waypoint in RawWaypointList: + * Coords = ast.literal_eval(Waypoint[CoordIndex]) + */ + __pyx_tuple__22 = PyTuple_Pack(1, __pyx_n_s_FlightID); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + + /* "CAStar/AATC_Monitor_Viewer.pyx":232 + * ZoneList = [] + * Columns = ast.literal_eval(Message) + * StartCoordIndex = Columns.index("StartCoord") # <<<<<<<<<<<<<< + * EndCoordIndex = Columns.index("EndCoord") + * LevelIndex = Columns.index("Level") + */ + __pyx_tuple__23 = PyTuple_Pack(1, __pyx_n_s_StartCoord); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + + /* "CAStar/AATC_Monitor_Viewer.pyx":233 + * Columns = ast.literal_eval(Message) + * StartCoordIndex = Columns.index("StartCoord") + * EndCoordIndex = Columns.index("EndCoord") # <<<<<<<<<<<<<< + * LevelIndex = Columns.index("Level") + * ZoneIDIndex = Columns.index("ZoneID") + */ + __pyx_tuple__24 = PyTuple_Pack(1, __pyx_n_s_EndCoord); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); + + /* "CAStar/AATC_Monitor_Viewer.pyx":234 + * StartCoordIndex = Columns.index("StartCoord") + * EndCoordIndex = Columns.index("EndCoord") + * LevelIndex = Columns.index("Level") # <<<<<<<<<<<<<< + * ZoneIDIndex = Columns.index("ZoneID") + * for Zone in RawZoneList: + */ + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_n_s_Level); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + + /* "CAStar/AATC_Monitor_Viewer.pyx":235 + * EndCoordIndex = Columns.index("EndCoord") + * LevelIndex = Columns.index("Level") + * ZoneIDIndex = Columns.index("ZoneID") # <<<<<<<<<<<<<< + * for Zone in RawZoneList: + * StartCoords = ast.literal_eval(Zone[StartCoordIndex]) + */ + __pyx_tuple__26 = PyTuple_Pack(1, __pyx_n_s_ZoneID); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); + + /* "CAStar/AATC_Monitor_Viewer.pyx":9 + * + * _images= {} + * def GetImage(xSize,ySize,Colour): #Efficiently get images # <<<<<<<<<<<<<< + * result = _images.get((xSize,ySize,Colour)) + * if result == None: + */ + __pyx_tuple__27 = PyTuple_Pack(4, __pyx_n_s_xSize, __pyx_n_s_ySize, __pyx_n_s_Colour, __pyx_n_s_result); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__27); + __Pyx_GIVEREF(__pyx_tuple__27); + __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_GetImage, 9, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 9, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":20 + * + * _texts= {} + * def GetText(Text,fontParameters,AA,Colour): #Efficiently get text # <<<<<<<<<<<<<< + * result = _texts.get((Text,fontParameters,AA,Colour)) + * if result == None: + */ + __pyx_tuple__29 = PyTuple_Pack(5, __pyx_n_s_Text, __pyx_n_s_fontParameters, __pyx_n_s_AA, __pyx_n_s_Colour, __pyx_n_s_result); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__29); + __Pyx_GIVEREF(__pyx_tuple__29); + __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(4, 0, 5, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_GetText, 20, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(0, 20, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":31 + * + * _fonts = {} + * def GetFont(Font,Size): # <<<<<<<<<<<<<< + * result = _fonts.get((Font,Size)) + * if result == None: + */ + __pyx_tuple__31 = PyTuple_Pack(3, __pyx_n_s_Font, __pyx_n_s_Size, __pyx_n_s_result); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__31); + __Pyx_GIVEREF(__pyx_tuple__31); + __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_GetFont, 31, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 31, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":49 + * + * class Camera: + * def __init__(self,xpixel,ypixel,MinCoords,MaxCoords): #COORDS (X,Y,Z) # <<<<<<<<<<<<<< + * self.xpixel = xpixel + * self.ypixel = ypixel + */ + __pyx_tuple__33 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_xpixel, __pyx_n_s_ypixel, __pyx_n_s_MinCoords, __pyx_n_s_MaxCoords); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__33); + __Pyx_GIVEREF(__pyx_tuple__33); + __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(5, 0, 5, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__33, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_init_2, 49, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(0, 49, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":61 + * self.DrawObjects = [] + * + * def GetZoom(self): # <<<<<<<<<<<<<< + * return self.CameraZoom + * def SetZoom(self,Zoom): + */ + __pyx_tuple__35 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__35); + __Pyx_GIVEREF(__pyx_tuple__35); + __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__35, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_GetZoom, 61, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(0, 61, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":63 + * def GetZoom(self): + * return self.CameraZoom + * def SetZoom(self,Zoom): # <<<<<<<<<<<<<< + * self.CameraZoom = Zoom + * + */ + __pyx_tuple__37 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_Zoom); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__37); + __Pyx_GIVEREF(__pyx_tuple__37); + __pyx_codeobj__38 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__37, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_SetZoom, 63, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__38)) __PYX_ERR(0, 63, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":66 + * self.CameraZoom = Zoom + * + * def GetCameraCoords(self): # <<<<<<<<<<<<<< + * return self.CameraCoord + * def IncrementCameraCoordX(self,Amount): + */ + __pyx_tuple__39 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__39); + __Pyx_GIVEREF(__pyx_tuple__39); + __pyx_codeobj__40 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__39, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_GetCameraCoords, 66, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__40)) __PYX_ERR(0, 66, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":68 + * def GetCameraCoords(self): + * return self.CameraCoord + * def IncrementCameraCoordX(self,Amount): # <<<<<<<<<<<<<< + * self.CameraCoord.Set_X( Amount+self.CameraCoord.Get_X()) + * + */ + __pyx_tuple__41 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_Amount); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__41); + __Pyx_GIVEREF(__pyx_tuple__41); + __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__41, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_IncrementCameraCoordX, 68, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) __PYX_ERR(0, 68, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":71 + * self.CameraCoord.Set_X( Amount+self.CameraCoord.Get_X()) + * + * def IncrementCameraCoordY(self,Amount): # <<<<<<<<<<<<<< + * self.CameraCoord.Set_Y( Amount+self.CameraCoord.Get_Y()) + * + */ + __pyx_tuple__43 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_Amount); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__43); + __Pyx_GIVEREF(__pyx_tuple__43); + __pyx_codeobj__44 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__43, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_IncrementCameraCoordY, 71, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__44)) __PYX_ERR(0, 71, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":74 + * self.CameraCoord.Set_Y( Amount+self.CameraCoord.Get_Y()) + * + * def SetCameraCoords(self,CameraX,CameraY): # <<<<<<<<<<<<<< + * self.CameraCoord.Set_X( CameraX) + * self.CameraCoord.Set_Y(CameraY) + */ + __pyx_tuple__45 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_CameraX, __pyx_n_s_CameraY); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__45); + __Pyx_GIVEREF(__pyx_tuple__45); + __pyx_codeobj__46 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_SetCameraCoords, 74, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__46)) __PYX_ERR(0, 74, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":78 + * self.CameraCoord.Set_Y(CameraY) + * + * def UpdateCameraSize(self): #Gets width of map divided by zoom level eg at zoom 1x it has whole map # <<<<<<<<<<<<<< + * self.CameraCoord.Set_XSize ((self.MaxCoords.Get_X() - self.MinCoords.Get_X())/self.CameraZoom) + * self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom) + */ + __pyx_tuple__47 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__47); + __Pyx_GIVEREF(__pyx_tuple__47); + __pyx_codeobj__48 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_UpdateCameraSize, 78, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__48)) __PYX_ERR(0, 78, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":82 + * self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom) + * + * def CameraWipe(self,Colour = (0,0,0)): # <<<<<<<<<<<<<< + * self.gameDisplay.fill(Colour) + * def ResetDrawObject(self): + */ + __pyx_tuple__49 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_Colour); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__49); + __Pyx_GIVEREF(__pyx_tuple__49); + __pyx_codeobj__50 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__49, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_CameraWipe, 82, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__50)) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_tuple__51 = PyTuple_Pack(1, ((PyObject*)__pyx_tuple_)); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__51); + __Pyx_GIVEREF(__pyx_tuple__51); + + /* "CAStar/AATC_Monitor_Viewer.pyx":84 + * def CameraWipe(self,Colour = (0,0,0)): + * self.gameDisplay.fill(Colour) + * def ResetDrawObject(self): # <<<<<<<<<<<<<< + * self.DrawObjects = [] + * def AddDrawObject(self,Object,ForceDraw): + */ + __pyx_tuple__52 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__52); + __Pyx_GIVEREF(__pyx_tuple__52); + __pyx_codeobj__53 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_ResetDrawObject, 84, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__53)) __PYX_ERR(0, 84, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":86 + * def ResetDrawObject(self): + * self.DrawObjects = [] + * def AddDrawObject(self,Object,ForceDraw): # <<<<<<<<<<<<<< + * self.DrawObjects.append({"Object":Object,"ForceDraw":ForceDraw}) + * + */ + __pyx_tuple__54 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_Object, __pyx_n_s_ForceDraw); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__54); + __Pyx_GIVEREF(__pyx_tuple__54); + __pyx_codeobj__55 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__54, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_AddDrawObject, 86, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__55)) __PYX_ERR(0, 86, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":89 + * self.DrawObjects.append({"Object":Object,"ForceDraw":ForceDraw}) + * + * def Get_Coord(self): # <<<<<<<<<<<<<< + * return self.CameraCoord + * + */ + __pyx_tuple__56 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__56); + __Pyx_GIVEREF(__pyx_tuple__56); + __pyx_codeobj__57 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__56, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_Get_Coord, 89, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__57)) __PYX_ERR(0, 89, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":92 + * return self.CameraCoord + * + * def Draw(self): # <<<<<<<<<<<<<< + * cdef float CameraEndX,CameraEndY,CameraX,CameraY,CameraXSize,CameraYSize,x,y,xSize,ySize,PosX,PosY + * cdef int width,height,xpixel,ypixel,font_size + */ + __pyx_tuple__58 = PyTuple_Pack(23, __pyx_n_s_self, __pyx_n_s_CameraEndX, __pyx_n_s_CameraEndY, __pyx_n_s_CameraX, __pyx_n_s_CameraY, __pyx_n_s_CameraXSize, __pyx_n_s_CameraYSize, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_xSize, __pyx_n_s_ySize, __pyx_n_s_PosX, __pyx_n_s_PosY, __pyx_n_s_width, __pyx_n_s_height, __pyx_n_s_xpixel, __pyx_n_s_ypixel, __pyx_n_s_font_size, __pyx_n_s_DrawObject, __pyx_n_s_Object, __pyx_n_s_Object_Coords, __pyx_n_s_image, __pyx_n_s_font); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__58); + __Pyx_GIVEREF(__pyx_tuple__58); + __pyx_codeobj__59 = (PyObject*)__Pyx_PyCode_New(1, 0, 23, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__58, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_Draw, 92, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__59)) __PYX_ERR(0, 92, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":134 + * + * class Monitor_Sprite(pygame.sprite.Sprite): + * def __init__(self,CoordObject,Type = "",Text = "",Colour = (255,255,255)): # <<<<<<<<<<<<<< + * self.Coords = CoordObject + * self.Type = Type + */ + __pyx_tuple__60 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_CoordObject, __pyx_n_s_Type, __pyx_n_s_Text, __pyx_n_s_Colour); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__60); + __Pyx_GIVEREF(__pyx_tuple__60); + __pyx_codeobj__61 = (PyObject*)__Pyx_PyCode_New(5, 0, 5, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__60, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_init_2, 134, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__61)) __PYX_ERR(0, 134, __pyx_L1_error) + __pyx_tuple__62 = PyTuple_Pack(3, ((PyObject*)__pyx_kp_s__2), ((PyObject*)__pyx_kp_s__2), ((PyObject*)__pyx_tuple__3)); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__62); + __Pyx_GIVEREF(__pyx_tuple__62); + + /* "CAStar/AATC_Monitor_Viewer.pyx":142 + * #self.Make_Image(2,2) # No longer needed, is similar to that above. + * + * def Make_Image(self, int width, int height): # <<<<<<<<<<<<<< + * if self.image.get_size() != (width,height): #If new image does not match with previous + * self.image = GetImage(width,height,self.Colour) + */ + __pyx_tuple__63 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_width, __pyx_n_s_height); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__63); + __Pyx_GIVEREF(__pyx_tuple__63); + __pyx_codeobj__64 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__63, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_Make_Image, 142, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__64)) __PYX_ERR(0, 142, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":150 + * ## self.image.fill(self.Colour) + * + * def Make_Text(self,font): # <<<<<<<<<<<<<< + * text = str((self.Coords.Get_X(),self.Coords.Get_Y(),self.Coords.Get_Z())) +" " +self.Text + " "+ self.Type + * return GetText(text,font,False,self.Colour) + */ + __pyx_tuple__65 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_font, __pyx_n_s_text); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__65); + __Pyx_GIVEREF(__pyx_tuple__65); + __pyx_codeobj__66 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__65, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_Make_Text, 150, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__66)) __PYX_ERR(0, 150, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":154 + * return GetText(text,font,False,self.Colour) + * + * def Get_Coords(self): # <<<<<<<<<<<<<< + * return self.Coords + * ## + */ + __pyx_tuple__67 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__67); + __Pyx_GIVEREF(__pyx_tuple__67); + __pyx_codeobj__68 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__67, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_Get_Coords, 154, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__68)) __PYX_ERR(0, 154, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":170 + * + * + * def MakeDroneSprites(Message,RawDroneList): # <<<<<<<<<<<<<< + * DroneList = [] + * Columns = ast.literal_eval(Message) + */ + __pyx_tuple__69 = PyTuple_Pack(15, __pyx_n_s_Message, __pyx_n_s_RawDroneList, __pyx_n_s_DroneList, __pyx_n_s_Columns, __pyx_n_s_CoordIndex, __pyx_n_s_DroneIDIndex, __pyx_n_s_UserIDIndex, __pyx_n_s_DroneNameIndex, __pyx_n_s_BatteryIndex, __pyx_n_s_Drone, __pyx_n_s_LastCoords, __pyx_n_s_Coord, __pyx_n_s_Text, __pyx_n_s_Colour, __pyx_n_s_Sprite); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__69); + __Pyx_GIVEREF(__pyx_tuple__69); + __pyx_codeobj__70 = (PyObject*)__Pyx_PyCode_New(2, 0, 15, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__69, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_MakeDroneSprites, 170, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__70)) __PYX_ERR(0, 170, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":187 + * return DroneList + * + * def MakeFlightSprites(Message,RawFlightList): # <<<<<<<<<<<<<< + * FlightList = [] + * Columns = ast.literal_eval(Message) + */ + __pyx_tuple__71 = PyTuple_Pack(17, __pyx_n_s_Message, __pyx_n_s_RawFlightList, __pyx_n_s_FlightList, __pyx_n_s_Columns, __pyx_n_s_FlightIDIndex, __pyx_n_s_DroneIDIndex, __pyx_n_s_StartCoordsIndex, __pyx_n_s_EndCoordsIndex, __pyx_n_s_StartTimeIndex, __pyx_n_s_ETAIndex, __pyx_n_s_EndTimeIndex, __pyx_n_s_DistanceIndex, __pyx_n_s_Flight, __pyx_n_s_Coords, __pyx_n_s_Coord, __pyx_n_s_Text, __pyx_n_s_Colour); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__71); + __Pyx_GIVEREF(__pyx_tuple__71); + __pyx_codeobj__72 = (PyObject*)__Pyx_PyCode_New(2, 0, 17, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__71, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_MakeFlightSprites, 187, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__72)) __PYX_ERR(0, 187, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":215 + * + * + * def MakeWaypointSprites(Message,RawWaypointList): # <<<<<<<<<<<<<< + * WaypointList = [] + * Columns = ast.literal_eval(Message) + */ + __pyx_tuple__73 = PyTuple_Pack(12, __pyx_n_s_Message, __pyx_n_s_RawWaypointList, __pyx_n_s_WaypointList, __pyx_n_s_Columns, __pyx_n_s_CoordIndex, __pyx_n_s_WaypointNumberIndex, __pyx_n_s_FlightIDIndex, __pyx_n_s_Waypoint, __pyx_n_s_Coords, __pyx_n_s_Coord, __pyx_n_s_Text, __pyx_n_s_Colour); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__73); + __Pyx_GIVEREF(__pyx_tuple__73); + __pyx_codeobj__74 = (PyObject*)__Pyx_PyCode_New(2, 0, 12, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__73, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_MakeWaypointSprites, 215, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__74)) __PYX_ERR(0, 215, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":229 + * return WaypointList + * + * def MakeZoneSprites(Message,RawZoneList): # <<<<<<<<<<<<<< + * ZoneList = [] + * Columns = ast.literal_eval(Message) + */ + __pyx_tuple__75 = PyTuple_Pack(14, __pyx_n_s_Message, __pyx_n_s_RawZoneList, __pyx_n_s_ZoneList, __pyx_n_s_Columns, __pyx_n_s_StartCoordIndex, __pyx_n_s_EndCoordIndex, __pyx_n_s_LevelIndex, __pyx_n_s_ZoneIDIndex, __pyx_n_s_Zone, __pyx_n_s_StartCoords, __pyx_n_s_EndCoords, __pyx_n_s_Coord, __pyx_n_s_Text, __pyx_n_s_Colour); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__75); + __Pyx_GIVEREF(__pyx_tuple__75); + __pyx_codeobj__76 = (PyObject*)__Pyx_PyCode_New(2, 0, 14, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__75, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_MakeZoneSprites, 229, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__76)) __PYX_ERR(0, 229, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":245 + * return ZoneList + * + * def MakeSprites(M): # <<<<<<<<<<<<<< + * print("Refreshing data") + * SpriteList = [] + */ + __pyx_tuple__77 = PyTuple_Pack(11, __pyx_n_s_M, __pyx_n_s_SpriteList, __pyx_n_s_Sucess, __pyx_n_s_Message, __pyx_n_s_DronesAll, __pyx_n_s_DronesMonitor, __pyx_n_s_FlightsAll, __pyx_n_s_FlightsMonitor, __pyx_n_s_WaypointsAll, __pyx_n_s_WaypointsMonitor, __pyx_n_s_NoFlyZones); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__77); + __Pyx_GIVEREF(__pyx_tuple__77); + __pyx_codeobj__78 = (PyObject*)__Pyx_PyCode_New(1, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__77, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_MakeSprites, 245, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__78)) __PYX_ERR(0, 245, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":291 + * try: + * M = AATC_Monitor.CreateMonitorInterface(IP = "127.0.0.1",Port = 8001) + * M.Login("Zini","") # <<<<<<<<<<<<<< + * #Sucess,Message,Data = M.GetCoordDetails() + * #MinCoords,MaxCoords,StepCoords = Data[0],Data[1],Data[2] + */ + __pyx_tuple__79 = PyTuple_Pack(2, __pyx_n_s_Zini, __pyx_kp_s__2); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(0, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__79); + __Pyx_GIVEREF(__pyx_tuple__79); + + /* "CAStar/AATC_Monitor_Viewer.pyx":294 + * #Sucess,Message,Data = M.GetCoordDetails() + * #MinCoords,MaxCoords,StepCoords = Data[0],Data[1],Data[2] + * MinCoords,MaxCoords = AATC_Coordinate.Coordinate(0,0,0),AATC_Coordinate.Coordinate(1,1,50) # <<<<<<<<<<<<<< + * MonCamera = Camera(xpixel,ypixel,MinCoords,MaxCoords) + * while True: + */ + __pyx_tuple__80 = PyTuple_Pack(3, __pyx_int_0, __pyx_int_0, __pyx_int_0); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__80); + __Pyx_GIVEREF(__pyx_tuple__80); + __pyx_tuple__81 = PyTuple_Pack(3, __pyx_int_1, __pyx_int_1, __pyx_int_50); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__81); + __Pyx_GIVEREF(__pyx_tuple__81); + + /* "CAStar/AATC_Monitor_Viewer.pyx":350 + * MonCamera.Draw() + * pygame.display.flip() + * clock.tick(60) # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__82 = PyTuple_Pack(1, __pyx_int_60); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(0, 350, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__82); + __Pyx_GIVEREF(__pyx_tuple__82); + + /* "CAStar/AATC_Monitor_Viewer.pyx":357 + * print(e) + * print("An error occured, restarting main loop") + * Exit = input("Exit? Y/N").upper() # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__83 = PyTuple_Pack(1, __pyx_kp_s_Exit_Y_N); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(0, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__83); + __Pyx_GIVEREF(__pyx_tuple__83); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_float_0_01 = PyFloat_FromDouble(0.01); if (unlikely(!__pyx_float_0_01)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_0_99 = PyFloat_FromDouble(0.99); if (unlikely(!__pyx_float_0_99)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_1_01 = PyFloat_FromDouble(1.01); if (unlikely(!__pyx_float_1_01)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_0_001 = PyFloat_FromDouble(0.001); if (unlikely(!__pyx_float_0_001)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_0_0001 = PyFloat_FromDouble(0.0001); if (unlikely(!__pyx_float_0_0001)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_0_00001 = PyFloat_FromDouble(0.00001); if (unlikely(!__pyx_float_0_00001)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_neg_0_01 = PyFloat_FromDouble(-0.01); if (unlikely(!__pyx_float_neg_0_01)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_50 = PyInt_FromLong(50); if (unlikely(!__pyx_int_50)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_60 = PyInt_FromLong(60); if (unlikely(!__pyx_int_60)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_255 = PyInt_FromLong(255); if (unlikely(!__pyx_int_255)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_700 = PyInt_FromLong(700); if (unlikely(!__pyx_int_700)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1200 = PyInt_FromLong(1200); if (unlikely(!__pyx_int_1200)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_8001 = PyInt_FromLong(8001); if (unlikely(!__pyx_int_8001)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initAATC_Monitor_Viewer(void); /*proto*/ +PyMODINIT_FUNC initAATC_Monitor_Viewer(void) +#else +PyMODINIT_FUNC PyInit_AATC_Monitor_Viewer(void); /*proto*/ +PyMODINIT_FUNC PyInit_AATC_Monitor_Viewer(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + 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; + int __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + Py_ssize_t __pyx_t_14; + PyObject *(*__pyx_t_15)(PyObject *); + int __pyx_t_16; + Py_ssize_t __pyx_t_17; + __Pyx_RefNannyDeclarations + #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("PyMODINIT_FUNC PyInit_AATC_Monitor_Viewer(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("AATC_Monitor_Viewer", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_CAStar__AATC_Monitor_Viewer) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "CAStar.AATC_Monitor_Viewer")) { + if (unlikely(PyDict_SetItemString(modules, "CAStar.AATC_Monitor_Viewer", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + /*--- Type init code ---*/ + /*--- Type import code ---*/ + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "CAStar/AATC_Monitor_Viewer.pyx":4 + * #cython: boundscheck=False, wraparound=False, infer_types=True,cdivision = True + * + * import pygame,AATC_Monitor,time,ast,sys,random,AATC_Coordinate # <<<<<<<<<<<<<< + * + * pygame.init() + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_pygame, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pygame, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_Import(__pyx_n_s_AATC_Monitor, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_AATC_Monitor, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_Import(__pyx_n_s_time, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_time, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_Import(__pyx_n_s_ast, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ast, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_Import(__pyx_n_s_random, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_random, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_Import(__pyx_n_s_AATC_Coordinate, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_AATC_Coordinate, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":6 + * import pygame,AATC_Monitor,time,ast,sys,random,AATC_Coordinate + * + * pygame.init() # <<<<<<<<<<<<<< + * + * _images= {} + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_init); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __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; + + /* "CAStar/AATC_Monitor_Viewer.pyx":8 + * pygame.init() + * + * _images= {} # <<<<<<<<<<<<<< + * def GetImage(xSize,ySize,Colour): #Efficiently get images + * result = _images.get((xSize,ySize,Colour)) + */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_images, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":9 + * + * _images= {} + * def GetImage(xSize,ySize,Colour): #Efficiently get images # <<<<<<<<<<<<<< + * result = _images.get((xSize,ySize,Colour)) + * if result == None: + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_1GetImage, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_GetImage, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":19 + * return result#_copy + * + * _texts= {} # <<<<<<<<<<<<<< + * def GetText(Text,fontParameters,AA,Colour): #Efficiently get text + * result = _texts.get((Text,fontParameters,AA,Colour)) + */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_texts, __pyx_t_1) < 0) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":20 + * + * _texts= {} + * def GetText(Text,fontParameters,AA,Colour): #Efficiently get text # <<<<<<<<<<<<<< + * result = _texts.get((Text,fontParameters,AA,Colour)) + * if result == None: + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_3GetText, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_GetText, __pyx_t_1) < 0) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":30 + * + * + * _fonts = {} # <<<<<<<<<<<<<< + * def GetFont(Font,Size): + * result = _fonts.get((Font,Size)) + */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_fonts, __pyx_t_1) < 0) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":31 + * + * _fonts = {} + * def GetFont(Font,Size): # <<<<<<<<<<<<<< + * result = _fonts.get((Font,Size)) + * if result == None: + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_5GetFont, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_GetFont, __pyx_t_1) < 0) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":48 + * + * + * class Camera: # <<<<<<<<<<<<<< + * def __init__(self,xpixel,ypixel,MinCoords,MaxCoords): #COORDS (X,Y,Z) + * self.xpixel = xpixel + */ + __pyx_t_1 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_Camera, __pyx_n_s_Camera, (PyObject *) NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "CAStar/AATC_Monitor_Viewer.pyx":49 + * + * class Camera: + * def __init__(self,xpixel,ypixel,MinCoords,MaxCoords): #COORDS (X,Y,Z) # <<<<<<<<<<<<<< + * self.xpixel = xpixel + * self.ypixel = ypixel + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_1__init__, 0, __pyx_n_s_Camera___init, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_init_2, __pyx_t_3) < 0) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":61 + * self.DrawObjects = [] + * + * def GetZoom(self): # <<<<<<<<<<<<<< + * return self.CameraZoom + * def SetZoom(self,Zoom): + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_3GetZoom, 0, __pyx_n_s_Camera_GetZoom, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__36)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_GetZoom, __pyx_t_3) < 0) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":63 + * def GetZoom(self): + * return self.CameraZoom + * def SetZoom(self,Zoom): # <<<<<<<<<<<<<< + * self.CameraZoom = Zoom + * + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_5SetZoom, 0, __pyx_n_s_Camera_SetZoom, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__38)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_SetZoom, __pyx_t_3) < 0) __PYX_ERR(0, 63, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":66 + * self.CameraZoom = Zoom + * + * def GetCameraCoords(self): # <<<<<<<<<<<<<< + * return self.CameraCoord + * def IncrementCameraCoordX(self,Amount): + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_7GetCameraCoords, 0, __pyx_n_s_Camera_GetCameraCoords, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__40)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_GetCameraCoords, __pyx_t_3) < 0) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":68 + * def GetCameraCoords(self): + * return self.CameraCoord + * def IncrementCameraCoordX(self,Amount): # <<<<<<<<<<<<<< + * self.CameraCoord.Set_X( Amount+self.CameraCoord.Get_X()) + * + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_9IncrementCameraCoordX, 0, __pyx_n_s_Camera_IncrementCameraCoordX, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__42)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_IncrementCameraCoordX, __pyx_t_3) < 0) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":71 + * self.CameraCoord.Set_X( Amount+self.CameraCoord.Get_X()) + * + * def IncrementCameraCoordY(self,Amount): # <<<<<<<<<<<<<< + * self.CameraCoord.Set_Y( Amount+self.CameraCoord.Get_Y()) + * + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_11IncrementCameraCoordY, 0, __pyx_n_s_Camera_IncrementCameraCoordY, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__44)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_IncrementCameraCoordY, __pyx_t_3) < 0) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":74 + * self.CameraCoord.Set_Y( Amount+self.CameraCoord.Get_Y()) + * + * def SetCameraCoords(self,CameraX,CameraY): # <<<<<<<<<<<<<< + * self.CameraCoord.Set_X( CameraX) + * self.CameraCoord.Set_Y(CameraY) + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_13SetCameraCoords, 0, __pyx_n_s_Camera_SetCameraCoords, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__46)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_SetCameraCoords, __pyx_t_3) < 0) __PYX_ERR(0, 74, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":78 + * self.CameraCoord.Set_Y(CameraY) + * + * def UpdateCameraSize(self): #Gets width of map divided by zoom level eg at zoom 1x it has whole map # <<<<<<<<<<<<<< + * self.CameraCoord.Set_XSize ((self.MaxCoords.Get_X() - self.MinCoords.Get_X())/self.CameraZoom) + * self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom) + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_15UpdateCameraSize, 0, __pyx_n_s_Camera_UpdateCameraSize, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__48)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_UpdateCameraSize, __pyx_t_3) < 0) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":82 + * self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom) + * + * def CameraWipe(self,Colour = (0,0,0)): # <<<<<<<<<<<<<< + * self.gameDisplay.fill(Colour) + * def ResetDrawObject(self): + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_17CameraWipe, 0, __pyx_n_s_Camera_CameraWipe, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__50)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__51); + if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_CameraWipe, __pyx_t_3) < 0) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":84 + * def CameraWipe(self,Colour = (0,0,0)): + * self.gameDisplay.fill(Colour) + * def ResetDrawObject(self): # <<<<<<<<<<<<<< + * self.DrawObjects = [] + * def AddDrawObject(self,Object,ForceDraw): + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_19ResetDrawObject, 0, __pyx_n_s_Camera_ResetDrawObject, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__53)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_ResetDrawObject, __pyx_t_3) < 0) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":86 + * def ResetDrawObject(self): + * self.DrawObjects = [] + * def AddDrawObject(self,Object,ForceDraw): # <<<<<<<<<<<<<< + * self.DrawObjects.append({"Object":Object,"ForceDraw":ForceDraw}) + * + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_21AddDrawObject, 0, __pyx_n_s_Camera_AddDrawObject, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__55)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_AddDrawObject, __pyx_t_3) < 0) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":89 + * self.DrawObjects.append({"Object":Object,"ForceDraw":ForceDraw}) + * + * def Get_Coord(self): # <<<<<<<<<<<<<< + * return self.CameraCoord + * + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_23Get_Coord, 0, __pyx_n_s_Camera_Get_Coord, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__57)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_Get_Coord, __pyx_t_3) < 0) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":92 + * return self.CameraCoord + * + * def Draw(self): # <<<<<<<<<<<<<< + * cdef float CameraEndX,CameraEndY,CameraX,CameraY,CameraXSize,CameraYSize,x,y,xSize,ySize,PosX,PosY + * cdef int width,height,xpixel,ypixel,font_size + */ + __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_25Draw, 0, __pyx_n_s_Camera_Draw, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__59)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_Draw, __pyx_t_3) < 0) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":48 + * + * + * class Camera: # <<<<<<<<<<<<<< + * def __init__(self,xpixel,ypixel,MinCoords,MaxCoords): #COORDS (X,Y,Z) + * self.xpixel = xpixel + */ + __pyx_t_3 = __Pyx_Py3ClassCreate(((PyObject*)&__Pyx_DefaultClassType), __pyx_n_s_Camera, __pyx_empty_tuple, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Camera, __pyx_t_3) < 0) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":133 + * + * + * class Monitor_Sprite(pygame.sprite.Sprite): # <<<<<<<<<<<<<< + * def __init__(self,CoordObject,Type = "",Text = "",Colour = (255,255,255)): + * self.Coords = CoordObject + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sprite); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Sprite); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_3, __pyx_n_s_Monitor_Sprite, __pyx_n_s_Monitor_Sprite, (PyObject *) NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "CAStar/AATC_Monitor_Viewer.pyx":134 + * + * class Monitor_Sprite(pygame.sprite.Sprite): + * def __init__(self,CoordObject,Type = "",Text = "",Colour = (255,255,255)): # <<<<<<<<<<<<<< + * self.Coords = CoordObject + * self.Type = Type + */ + __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_1__init__, 0, __pyx_n_s_Monitor_Sprite___init, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__61)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__62); + if (PyObject_SetItem(__pyx_t_2, __pyx_n_s_init_2, __pyx_t_4) < 0) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":142 + * #self.Make_Image(2,2) # No longer needed, is similar to that above. + * + * def Make_Image(self, int width, int height): # <<<<<<<<<<<<<< + * if self.image.get_size() != (width,height): #If new image does not match with previous + * self.image = GetImage(width,height,self.Colour) + */ + __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_3Make_Image, 0, __pyx_n_s_Monitor_Sprite_Make_Image, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__64)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyObject_SetItem(__pyx_t_2, __pyx_n_s_Make_Image, __pyx_t_4) < 0) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":150 + * ## self.image.fill(self.Colour) + * + * def Make_Text(self,font): # <<<<<<<<<<<<<< + * text = str((self.Coords.Get_X(),self.Coords.Get_Y(),self.Coords.Get_Z())) +" " +self.Text + " "+ self.Type + * return GetText(text,font,False,self.Colour) + */ + __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_5Make_Text, 0, __pyx_n_s_Monitor_Sprite_Make_Text, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__66)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyObject_SetItem(__pyx_t_2, __pyx_n_s_Make_Text, __pyx_t_4) < 0) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":154 + * return GetText(text,font,False,self.Colour) + * + * def Get_Coords(self): # <<<<<<<<<<<<<< + * return self.Coords + * ## + */ + __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_7Get_Coords, 0, __pyx_n_s_Monitor_Sprite_Get_Coords, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__68)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyObject_SetItem(__pyx_t_2, __pyx_n_s_Get_Coords, __pyx_t_4) < 0) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":133 + * + * + * class Monitor_Sprite(pygame.sprite.Sprite): # <<<<<<<<<<<<<< + * def __init__(self,CoordObject,Type = "",Text = "",Colour = (255,255,255)): + * self.Coords = CoordObject + */ + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_Monitor_Sprite, __pyx_t_3, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Monitor_Sprite, __pyx_t_4) < 0) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":170 + * + * + * def MakeDroneSprites(Message,RawDroneList): # <<<<<<<<<<<<<< + * DroneList = [] + * Columns = ast.literal_eval(Message) + */ + __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_7MakeDroneSprites, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MakeDroneSprites, __pyx_t_3) < 0) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":187 + * return DroneList + * + * def MakeFlightSprites(Message,RawFlightList): # <<<<<<<<<<<<<< + * FlightList = [] + * Columns = ast.literal_eval(Message) + */ + __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_9MakeFlightSprites, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MakeFlightSprites, __pyx_t_3) < 0) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":215 + * + * + * def MakeWaypointSprites(Message,RawWaypointList): # <<<<<<<<<<<<<< + * WaypointList = [] + * Columns = ast.literal_eval(Message) + */ + __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_11MakeWaypointSprites, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MakeWaypointSprites, __pyx_t_3) < 0) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":229 + * return WaypointList + * + * def MakeZoneSprites(Message,RawZoneList): # <<<<<<<<<<<<<< + * ZoneList = [] + * Columns = ast.literal_eval(Message) + */ + __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_13MakeZoneSprites, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MakeZoneSprites, __pyx_t_3) < 0) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":245 + * return ZoneList + * + * def MakeSprites(M): # <<<<<<<<<<<<<< + * print("Refreshing data") + * SpriteList = [] + */ + __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_15MakeSprites, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MakeSprites, __pyx_t_3) < 0) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":282 + * + * + * xpixel = 1200 # <<<<<<<<<<<<<< + * ypixel = 700 + * Refresh_Delay = 60 + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_xpixel, __pyx_int_1200) < 0) __PYX_ERR(0, 282, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":283 + * + * xpixel = 1200 + * ypixel = 700 # <<<<<<<<<<<<<< + * Refresh_Delay = 60 + * clock = pygame.time.Clock() + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ypixel, __pyx_int_700) < 0) __PYX_ERR(0, 283, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":284 + * xpixel = 1200 + * ypixel = 700 + * Refresh_Delay = 60 # <<<<<<<<<<<<<< + * clock = pygame.time.Clock() + * pressed = pygame.key.get_pressed + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Refresh_Delay, __pyx_int_60) < 0) __PYX_ERR(0, 284, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":285 + * ypixel = 700 + * Refresh_Delay = 60 + * clock = pygame.time.Clock() # <<<<<<<<<<<<<< + * pressed = pygame.key.get_pressed + * Exit = "N" + */ + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Clock); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (__pyx_t_2) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 285, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_clock, __pyx_t_3) < 0) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":286 + * Refresh_Delay = 60 + * clock = pygame.time.Clock() + * pressed = pygame.key.get_pressed # <<<<<<<<<<<<<< + * Exit = "N" + * while Exit != "Y": + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_get_pressed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pressed, __pyx_t_3) < 0) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":287 + * clock = pygame.time.Clock() + * pressed = pygame.key.get_pressed + * Exit = "N" # <<<<<<<<<<<<<< + * while Exit != "Y": + * try: + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Exit, __pyx_n_s_N_2) < 0) __PYX_ERR(0, 287, __pyx_L1_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":288 + * pressed = pygame.key.get_pressed + * Exit = "N" + * while Exit != "Y": # <<<<<<<<<<<<<< + * try: + * M = AATC_Monitor.CreateMonitorInterface(IP = "127.0.0.1",Port = 8001) + */ + while (1) { + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_Exit); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_Y, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!__pyx_t_5) break; + + /* "CAStar/AATC_Monitor_Viewer.pyx":289 + * Exit = "N" + * while Exit != "Y": + * try: # <<<<<<<<<<<<<< + * M = AATC_Monitor.CreateMonitorInterface(IP = "127.0.0.1",Port = 8001) + * M.Login("Zini","") + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + /*try:*/ { + + /* "CAStar/AATC_Monitor_Viewer.pyx":290 + * while Exit != "Y": + * try: + * M = AATC_Monitor.CreateMonitorInterface(IP = "127.0.0.1",Port = 8001) # <<<<<<<<<<<<<< + * M.Login("Zini","") + * #Sucess,Message,Data = M.GetCoordDetails() + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Monitor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 290, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_CreateMonitorInterface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 290, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 290, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_IP, __pyx_kp_s_127_0_0_1) < 0) __PYX_ERR(0, 290, __pyx_L4_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_Port, __pyx_int_8001) < 0) __PYX_ERR(0, 290, __pyx_L4_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 290, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_M, __pyx_t_2) < 0) __PYX_ERR(0, 290, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":291 + * try: + * M = AATC_Monitor.CreateMonitorInterface(IP = "127.0.0.1",Port = 8001) + * M.Login("Zini","") # <<<<<<<<<<<<<< + * #Sucess,Message,Data = M.GetCoordDetails() + * #MinCoords,MaxCoords,StepCoords = Data[0],Data[1],Data[2] + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_M); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 291, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Login); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 291, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 291, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":294 + * #Sucess,Message,Data = M.GetCoordDetails() + * #MinCoords,MaxCoords,StepCoords = Data[0],Data[1],Data[2] + * MinCoords,MaxCoords = AATC_Coordinate.Coordinate(0,0,0),AATC_Coordinate.Coordinate(1,1,50) # <<<<<<<<<<<<<< + * MonCamera = Camera(xpixel,ypixel,MinCoords,MaxCoords) + * while True: + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 294, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MinCoords, __pyx_t_2) < 0) __PYX_ERR(0, 294, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MaxCoords, __pyx_t_3) < 0) __PYX_ERR(0, 294, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":295 + * #MinCoords,MaxCoords,StepCoords = Data[0],Data[1],Data[2] + * MinCoords,MaxCoords = AATC_Coordinate.Coordinate(0,0,0),AATC_Coordinate.Coordinate(1,1,50) + * MonCamera = Camera(xpixel,ypixel,MinCoords,MaxCoords) # <<<<<<<<<<<<<< + * while True: + * MonCamera.ResetDrawObject() + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_Camera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 295, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_xpixel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ypixel); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 295, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_MinCoords); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 295, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_MaxCoords); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 295, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = NULL; + __pyx_t_12 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_12 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_t_1, __pyx_t_4, __pyx_t_9, __pyx_t_10}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 295, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_t_1, __pyx_t_4, __pyx_t_9, __pyx_t_10}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 295, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } else + #endif + { + __pyx_t_13 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 295, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + if (__pyx_t_11) { + __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_11); __pyx_t_11 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_13, 2+__pyx_t_12, __pyx_t_9); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_13, 3+__pyx_t_12, __pyx_t_10); + __pyx_t_1 = 0; + __pyx_t_4 = 0; + __pyx_t_9 = 0; + __pyx_t_10 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 295, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MonCamera, __pyx_t_3) < 0) __PYX_ERR(0, 295, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":296 + * MinCoords,MaxCoords = AATC_Coordinate.Coordinate(0,0,0),AATC_Coordinate.Coordinate(1,1,50) + * MonCamera = Camera(xpixel,ypixel,MinCoords,MaxCoords) + * while True: # <<<<<<<<<<<<<< + * MonCamera.ResetDrawObject() + * Sprites = MakeSprites(M) + */ + while (1) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":297 + * MonCamera = Camera(xpixel,ypixel,MinCoords,MaxCoords) + * while True: + * MonCamera.ResetDrawObject() # <<<<<<<<<<<<<< + * Sprites = MakeSprites(M) + * #font = (None, 30) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 297, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ResetDrawObject); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 297, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + if (__pyx_t_2) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 297, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 297, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":298 + * while True: + * MonCamera.ResetDrawObject() + * Sprites = MakeSprites(M) # <<<<<<<<<<<<<< + * #font = (None, 30) + * for sprite in Sprites: + */ + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeSprites); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 298, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_M); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 298, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + if (!__pyx_t_10) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_13)) { + PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_t_2}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_13, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_13)) { + PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_t_2}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_13, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 298, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); __pyx_t_10 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Sprites, __pyx_t_3) < 0) __PYX_ERR(0, 298, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":300 + * Sprites = MakeSprites(M) + * #font = (None, 30) + * for sprite in Sprites: # <<<<<<<<<<<<<< + * MonCamera.AddDrawObject(sprite,False) + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_Sprites); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 300, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_13 = __pyx_t_3; __Pyx_INCREF(__pyx_t_13); __pyx_t_14 = 0; + __pyx_t_15 = NULL; + } else { + __pyx_t_14 = -1; __pyx_t_13 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 300, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_15 = Py_TYPE(__pyx_t_13)->tp_iternext; if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 300, __pyx_L4_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_15)) { + if (likely(PyList_CheckExact(__pyx_t_13))) { + if (__pyx_t_14 >= PyList_GET_SIZE(__pyx_t_13)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_13, __pyx_t_14); __Pyx_INCREF(__pyx_t_3); __pyx_t_14++; if (unlikely(0 < 0)) __PYX_ERR(0, 300, __pyx_L4_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_13, __pyx_t_14); __pyx_t_14++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 300, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + if (__pyx_t_14 >= PyTuple_GET_SIZE(__pyx_t_13)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_13, __pyx_t_14); __Pyx_INCREF(__pyx_t_3); __pyx_t_14++; if (unlikely(0 < 0)) __PYX_ERR(0, 300, __pyx_L4_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_13, __pyx_t_14); __pyx_t_14++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 300, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_15(__pyx_t_13); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 300, __pyx_L4_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + if (PyDict_SetItem(__pyx_d, __pyx_n_s_sprite, __pyx_t_3) < 0) __PYX_ERR(0, 300, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":301 + * #font = (None, 30) + * for sprite in Sprites: + * MonCamera.AddDrawObject(sprite,False) # <<<<<<<<<<<<<< + * + * Last_Refresh_Time = time.time() + */ + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 301, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_AddDrawObject); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 301, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_sprite); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 301, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_12 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_12 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_9, Py_False}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_9, Py_False}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + { + __pyx_t_4 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 301, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + if (__pyx_t_10) { + __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_10); __pyx_t_10 = NULL; + } + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_12, __pyx_t_9); + __Pyx_INCREF(Py_False); + __Pyx_GIVEREF(Py_False); + PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_12, Py_False); + __pyx_t_9 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":300 + * Sprites = MakeSprites(M) + * #font = (None, 30) + * for sprite in Sprites: # <<<<<<<<<<<<<< + * MonCamera.AddDrawObject(sprite,False) + * + */ + } + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":303 + * MonCamera.AddDrawObject(sprite,False) + * + * Last_Refresh_Time = time.time() # <<<<<<<<<<<<<< + * refresh = False + * while not refresh: + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 303, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 303, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 303, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_13 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 303, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Last_Refresh_Time, __pyx_t_13) < 0) __PYX_ERR(0, 303, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":304 + * + * Last_Refresh_Time = time.time() + * refresh = False # <<<<<<<<<<<<<< + * while not refresh: + * MonCamera.CameraWipe() + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_refresh, Py_False) < 0) __PYX_ERR(0, 304, __pyx_L4_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":305 + * Last_Refresh_Time = time.time() + * refresh = False + * while not refresh: # <<<<<<<<<<<<<< + * MonCamera.CameraWipe() + * if time.time() >= (Last_Refresh_Time + Refresh_Delay): + */ + while (1) { + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_refresh); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 305, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 305, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_16 = ((!__pyx_t_5) != 0); + if (!__pyx_t_16) break; + + /* "CAStar/AATC_Monitor_Viewer.pyx":306 + * refresh = False + * while not refresh: + * MonCamera.CameraWipe() # <<<<<<<<<<<<<< + * if time.time() >= (Last_Refresh_Time + Refresh_Delay): + * refresh = True + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 306, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_CameraWipe); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 306, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 306, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_13 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 306, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":307 + * while not refresh: + * MonCamera.CameraWipe() + * if time.time() >= (Last_Refresh_Time + Refresh_Delay): # <<<<<<<<<<<<<< + * refresh = True + * for event in pygame.event.get(): + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 307, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 307, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 307, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_13 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 307, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_Last_Refresh_Time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 307, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_Refresh_Delay); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 307, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyNumber_Add(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 307, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyObject_RichCompare(__pyx_t_13, __pyx_t_4, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 307, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 307, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_16) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":308 + * MonCamera.CameraWipe() + * if time.time() >= (Last_Refresh_Time + Refresh_Delay): + * refresh = True # <<<<<<<<<<<<<< + * for event in pygame.event.get(): + * if event.type == pygame.QUIT: + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_refresh, Py_True) < 0) __PYX_ERR(0, 308, __pyx_L4_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":307 + * while not refresh: + * MonCamera.CameraWipe() + * if time.time() >= (Last_Refresh_Time + Refresh_Delay): # <<<<<<<<<<<<<< + * refresh = True + * for event in pygame.event.get(): + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":309 + * if time.time() >= (Last_Refresh_Time + Refresh_Delay): + * refresh = True + * for event in pygame.event.get(): # <<<<<<<<<<<<<< + * if event.type == pygame.QUIT: + * print("Monitor exit was called") + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 309, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_event); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 309, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_get); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 309, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_13) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 309, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 309, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_4 = __pyx_t_3; __Pyx_INCREF(__pyx_t_4); __pyx_t_14 = 0; + __pyx_t_15 = NULL; + } else { + __pyx_t_14 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 309, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_15 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 309, __pyx_L4_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_15)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + if (__pyx_t_14 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_14); __Pyx_INCREF(__pyx_t_3); __pyx_t_14++; if (unlikely(0 < 0)) __PYX_ERR(0, 309, __pyx_L4_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_14); __pyx_t_14++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 309, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + if (__pyx_t_14 >= PyTuple_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_14); __Pyx_INCREF(__pyx_t_3); __pyx_t_14++; if (unlikely(0 < 0)) __PYX_ERR(0, 309, __pyx_L4_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_14); __pyx_t_14++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 309, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_15(__pyx_t_4); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 309, __pyx_L4_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + if (PyDict_SetItem(__pyx_d, __pyx_n_s_event, __pyx_t_3) < 0) __PYX_ERR(0, 309, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":310 + * refresh = True + * for event in pygame.event.get(): + * if event.type == pygame.QUIT: # <<<<<<<<<<<<<< + * print("Monitor exit was called") + * pygame.quit() + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 310, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_type); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 310, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 310, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_QUIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 310, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyObject_RichCompare(__pyx_t_13, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 310, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 310, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_16) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":311 + * for event in pygame.event.get(): + * if event.type == pygame.QUIT: + * print("Monitor exit was called") # <<<<<<<<<<<<<< + * pygame.quit() + * sys.exit() + */ + if (__Pyx_PrintOne(0, __pyx_kp_s_Monitor_exit_was_called) < 0) __PYX_ERR(0, 311, __pyx_L4_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":312 + * if event.type == pygame.QUIT: + * print("Monitor exit was called") + * pygame.quit() # <<<<<<<<<<<<<< + * sys.exit() + * + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 312, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_quit); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 312, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + if (__pyx_t_2) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 312, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 312, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":313 + * print("Monitor exit was called") + * pygame.quit() + * sys.exit() # <<<<<<<<<<<<<< + * + * elif event.type == pygame.MOUSEBUTTONDOWN: + */ + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 313, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_exit); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 313, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_13) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 313, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 313, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":310 + * refresh = True + * for event in pygame.event.get(): + * if event.type == pygame.QUIT: # <<<<<<<<<<<<<< + * print("Monitor exit was called") + * pygame.quit() + */ + goto __pyx_L21; + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":315 + * sys.exit() + * + * elif event.type == pygame.MOUSEBUTTONDOWN: # <<<<<<<<<<<<<< + * print("Camera details") #Mainly for debugging + * print(MonCamera.GetZoom()) + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 315, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 315, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 315, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_MOUSEBUTTONDOWN); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 315, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_t_13, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 315, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 315, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_16) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":316 + * + * elif event.type == pygame.MOUSEBUTTONDOWN: + * print("Camera details") #Mainly for debugging # <<<<<<<<<<<<<< + * print(MonCamera.GetZoom()) + * print(MonCamera.CameraCoord.Get_X()) + */ + if (__Pyx_PrintOne(0, __pyx_kp_s_Camera_details) < 0) __PYX_ERR(0, 316, __pyx_L4_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":317 + * elif event.type == pygame.MOUSEBUTTONDOWN: + * print("Camera details") #Mainly for debugging + * print(MonCamera.GetZoom()) # <<<<<<<<<<<<<< + * print(MonCamera.CameraCoord.Get_X()) + * print(MonCamera.CameraCoord.Get_Y()) + */ + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 317, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_GetZoom); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 317, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_13) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 317, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 317, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 317, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":318 + * print("Camera details") #Mainly for debugging + * print(MonCamera.GetZoom()) + * print(MonCamera.CameraCoord.Get_X()) # <<<<<<<<<<<<<< + * print(MonCamera.CameraCoord.Get_Y()) + * print(MonCamera.CameraCoord.Get_XSize()) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 318, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 318, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 318, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_13) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 318, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 318, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 318, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":319 + * print(MonCamera.GetZoom()) + * print(MonCamera.CameraCoord.Get_X()) + * print(MonCamera.CameraCoord.Get_Y()) # <<<<<<<<<<<<<< + * print(MonCamera.CameraCoord.Get_XSize()) + * print(MonCamera.CameraCoord.Get_YSize()) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 319, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 319, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 319, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_13) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 319, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 319, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 319, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":320 + * print(MonCamera.CameraCoord.Get_X()) + * print(MonCamera.CameraCoord.Get_Y()) + * print(MonCamera.CameraCoord.Get_XSize()) # <<<<<<<<<<<<<< + * print(MonCamera.CameraCoord.Get_YSize()) + * print(len(MonCamera.DrawObjects)) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 320, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 320, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 320, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_13) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 320, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 320, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 320, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":321 + * print(MonCamera.CameraCoord.Get_Y()) + * print(MonCamera.CameraCoord.Get_XSize()) + * print(MonCamera.CameraCoord.Get_YSize()) # <<<<<<<<<<<<<< + * print(len(MonCamera.DrawObjects)) + * print("FPS:"+str(clock.get_fps())) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 321, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_Get_YSize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_13) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 321, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 321, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 321, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":322 + * print(MonCamera.CameraCoord.Get_XSize()) + * print(MonCamera.CameraCoord.Get_YSize()) + * print(len(MonCamera.DrawObjects)) # <<<<<<<<<<<<<< + * print("FPS:"+str(clock.get_fps())) + * elif event.type == pygame.KEYDOWN: + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 322, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_DrawObjects); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 322, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_17 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_17 == -1)) __PYX_ERR(0, 322, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_17); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 322, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(0, 322, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":323 + * print(MonCamera.CameraCoord.Get_YSize()) + * print(len(MonCamera.DrawObjects)) + * print("FPS:"+str(clock.get_fps())) # <<<<<<<<<<<<<< + * elif event.type == pygame.KEYDOWN: + * pass + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_clock); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_get_fps); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 323, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + if (__pyx_t_3) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 323, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 323, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = PyTuple_New(1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 323, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 323, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = PyNumber_Add(__pyx_kp_s_FPS, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 323, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_PrintOne(0, __pyx_t_13) < 0) __PYX_ERR(0, 323, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":315 + * sys.exit() + * + * elif event.type == pygame.MOUSEBUTTONDOWN: # <<<<<<<<<<<<<< + * print("Camera details") #Mainly for debugging + * print(MonCamera.GetZoom()) + */ + goto __pyx_L21; + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":324 + * print(len(MonCamera.DrawObjects)) + * print("FPS:"+str(clock.get_fps())) + * elif event.type == pygame.KEYDOWN: # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_event); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 324, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 324, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 324, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_KEYDOWN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 324, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 324, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 324, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + if (__pyx_t_16) { + } + __pyx_L21:; + + /* "CAStar/AATC_Monitor_Viewer.pyx":309 + * if time.time() >= (Last_Refresh_Time + Refresh_Delay): + * refresh = True + * for event in pygame.event.get(): # <<<<<<<<<<<<<< + * if event.type == pygame.QUIT: + * print("Monitor exit was called") + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":328 + * + * + * CameraCoord = MonCamera.Get_Coord() # <<<<<<<<<<<<<< + * if pressed()[pygame.K_w]: #Shift camera + * MonCamera.IncrementCameraCoordY(-0.01*CameraCoord.Get_XSize()) #/ as Greater zoom means need more fidelety + */ + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 328, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_Get_Coord); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 328, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_13) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 328, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 328, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CameraCoord, __pyx_t_4) < 0) __PYX_ERR(0, 328, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":329 + * + * CameraCoord = MonCamera.Get_Coord() + * if pressed()[pygame.K_w]: #Shift camera # <<<<<<<<<<<<<< + * MonCamera.IncrementCameraCoordY(-0.01*CameraCoord.Get_XSize()) #/ as Greater zoom means need more fidelety + * if pressed()[pygame.K_s]: + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 329, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_13) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 329, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 329, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 329, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_K_w); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 329, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyObject_GetItem(__pyx_t_4, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 329, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 329, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_16) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":330 + * CameraCoord = MonCamera.Get_Coord() + * if pressed()[pygame.K_w]: #Shift camera + * MonCamera.IncrementCameraCoordY(-0.01*CameraCoord.Get_XSize()) #/ as Greater zoom means need more fidelety # <<<<<<<<<<<<<< + * if pressed()[pygame.K_s]: + * MonCamera.IncrementCameraCoordY(0.01*CameraCoord.Get_XSize()) + */ + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 330, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_IncrementCameraCoordY); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 330, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 330, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 330, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + if (__pyx_t_2) { + __pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 330, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_13 = __Pyx_PyObject_CallNoArg(__pyx_t_9); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 330, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyNumber_Multiply(__pyx_float_neg_0_01, __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 330, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_13) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_13, __pyx_t_9}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_13, __pyx_t_9}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + { + __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 330, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_13); __pyx_t_13 = NULL; + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__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; + + /* "CAStar/AATC_Monitor_Viewer.pyx":329 + * + * CameraCoord = MonCamera.Get_Coord() + * if pressed()[pygame.K_w]: #Shift camera # <<<<<<<<<<<<<< + * MonCamera.IncrementCameraCoordY(-0.01*CameraCoord.Get_XSize()) #/ as Greater zoom means need more fidelety + * if pressed()[pygame.K_s]: + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":331 + * if pressed()[pygame.K_w]: #Shift camera + * MonCamera.IncrementCameraCoordY(-0.01*CameraCoord.Get_XSize()) #/ as Greater zoom means need more fidelety + * if pressed()[pygame.K_s]: # <<<<<<<<<<<<<< + * MonCamera.IncrementCameraCoordY(0.01*CameraCoord.Get_XSize()) + * if pressed()[pygame.K_a]: + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 331, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_2) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 331, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 331, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 331, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_K_s); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 331, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyObject_GetItem(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 331, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 331, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_16) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":332 + * MonCamera.IncrementCameraCoordY(-0.01*CameraCoord.Get_XSize()) #/ as Greater zoom means need more fidelety + * if pressed()[pygame.K_s]: + * MonCamera.IncrementCameraCoordY(0.01*CameraCoord.Get_XSize()) # <<<<<<<<<<<<<< + * if pressed()[pygame.K_a]: + * MonCamera.IncrementCameraCoordX(-0.01*CameraCoord.Get_XSize()) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 332, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_IncrementCameraCoordY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 332, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 332, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 332, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + if (__pyx_t_9) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 332, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 332, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = PyNumber_Multiply(__pyx_float_0_01, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 332, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 332, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_13}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 332, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_13}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 332, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 332, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_GIVEREF(__pyx_t_13); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_13); + __pyx_t_13 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 332, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":331 + * if pressed()[pygame.K_w]: #Shift camera + * MonCamera.IncrementCameraCoordY(-0.01*CameraCoord.Get_XSize()) #/ as Greater zoom means need more fidelety + * if pressed()[pygame.K_s]: # <<<<<<<<<<<<<< + * MonCamera.IncrementCameraCoordY(0.01*CameraCoord.Get_XSize()) + * if pressed()[pygame.K_a]: + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":333 + * if pressed()[pygame.K_s]: + * MonCamera.IncrementCameraCoordY(0.01*CameraCoord.Get_XSize()) + * if pressed()[pygame.K_a]: # <<<<<<<<<<<<<< + * MonCamera.IncrementCameraCoordX(-0.01*CameraCoord.Get_XSize()) + * if pressed()[pygame.K_d]: + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_9) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 333, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 333, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_K_a); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 333, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyObject_GetItem(__pyx_t_4, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 333, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_16) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":334 + * MonCamera.IncrementCameraCoordY(0.01*CameraCoord.Get_XSize()) + * if pressed()[pygame.K_a]: + * MonCamera.IncrementCameraCoordX(-0.01*CameraCoord.Get_XSize()) # <<<<<<<<<<<<<< + * if pressed()[pygame.K_d]: + * MonCamera.IncrementCameraCoordX(0.01*CameraCoord.Get_XSize()) + */ + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 334, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_IncrementCameraCoordX); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 334, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 334, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 334, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_13) { + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 334, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 334, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Multiply(__pyx_float_neg_0_01, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 334, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_9) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_2}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_2}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 334, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_9); __pyx_t_9 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":333 + * if pressed()[pygame.K_s]: + * MonCamera.IncrementCameraCoordY(0.01*CameraCoord.Get_XSize()) + * if pressed()[pygame.K_a]: # <<<<<<<<<<<<<< + * MonCamera.IncrementCameraCoordX(-0.01*CameraCoord.Get_XSize()) + * if pressed()[pygame.K_d]: + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":335 + * if pressed()[pygame.K_a]: + * MonCamera.IncrementCameraCoordX(-0.01*CameraCoord.Get_XSize()) + * if pressed()[pygame.K_d]: # <<<<<<<<<<<<<< + * MonCamera.IncrementCameraCoordX(0.01*CameraCoord.Get_XSize()) + * + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 335, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_13) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 335, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 335, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 335, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_K_d); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 335, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyObject_GetItem(__pyx_t_3, __pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 335, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 335, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_16) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":336 + * MonCamera.IncrementCameraCoordX(-0.01*CameraCoord.Get_XSize()) + * if pressed()[pygame.K_d]: + * MonCamera.IncrementCameraCoordX(0.01*CameraCoord.Get_XSize()) # <<<<<<<<<<<<<< + * + * if pressed()[pygame.K_q]:#Zoom out + */ + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 336, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_IncrementCameraCoordX); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 336, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 336, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 336, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + if (__pyx_t_2) { + __pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 336, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_13 = __Pyx_PyObject_CallNoArg(__pyx_t_9); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 336, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyNumber_Multiply(__pyx_float_0_01, __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 336, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_13) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 336, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_13, __pyx_t_9}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 336, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_13, __pyx_t_9}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 336, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + { + __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 336, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_13); __pyx_t_13 = NULL; + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 336, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":335 + * if pressed()[pygame.K_a]: + * MonCamera.IncrementCameraCoordX(-0.01*CameraCoord.Get_XSize()) + * if pressed()[pygame.K_d]: # <<<<<<<<<<<<<< + * MonCamera.IncrementCameraCoordX(0.01*CameraCoord.Get_XSize()) + * + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":338 + * MonCamera.IncrementCameraCoordX(0.01*CameraCoord.Get_XSize()) + * + * if pressed()[pygame.K_q]:#Zoom out # <<<<<<<<<<<<<< + * MonCamera.SetZoom(0.99*MonCamera.GetZoom()) + * if pressed()[pygame.K_e]:#Zoom in + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 338, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 338, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 338, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 338, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_K_q); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 338, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyObject_GetItem(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 338, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 338, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_16) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":339 + * + * if pressed()[pygame.K_q]:#Zoom out + * MonCamera.SetZoom(0.99*MonCamera.GetZoom()) # <<<<<<<<<<<<<< + * if pressed()[pygame.K_e]:#Zoom in + * MonCamera.SetZoom(1.01*MonCamera.GetZoom()) + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 339, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_SetZoom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 339, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 339, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_GetZoom); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 339, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + if (__pyx_t_9) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 339, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 339, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = PyNumber_Multiply(__pyx_float_0_99, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 339, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_2) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 339, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_13}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 339, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_13}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 339, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 339, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_GIVEREF(__pyx_t_13); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_13); + __pyx_t_13 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 339, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":338 + * MonCamera.IncrementCameraCoordX(0.01*CameraCoord.Get_XSize()) + * + * if pressed()[pygame.K_q]:#Zoom out # <<<<<<<<<<<<<< + * MonCamera.SetZoom(0.99*MonCamera.GetZoom()) + * if pressed()[pygame.K_e]:#Zoom in + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":340 + * if pressed()[pygame.K_q]:#Zoom out + * MonCamera.SetZoom(0.99*MonCamera.GetZoom()) + * if pressed()[pygame.K_e]:#Zoom in # <<<<<<<<<<<<<< + * MonCamera.SetZoom(1.01*MonCamera.GetZoom()) + * + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 340, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_9) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 340, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 340, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 340, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_K_e); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 340, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyObject_GetItem(__pyx_t_3, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 340, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 340, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_16) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":341 + * MonCamera.SetZoom(0.99*MonCamera.GetZoom()) + * if pressed()[pygame.K_e]:#Zoom in + * MonCamera.SetZoom(1.01*MonCamera.GetZoom()) # <<<<<<<<<<<<<< + * + * if pressed()[pygame.K_SPACE]:#Zoom in + */ + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 341, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_SetZoom); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 341, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 341, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_GetZoom); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 341, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_13) { + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 341, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 341, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Multiply(__pyx_float_1_01, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 341, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_9) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_4); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_2}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_2}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L4_error) + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else + #endif + { + __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 341, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_9); __pyx_t_9 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_13, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":340 + * if pressed()[pygame.K_q]:#Zoom out + * MonCamera.SetZoom(0.99*MonCamera.GetZoom()) + * if pressed()[pygame.K_e]:#Zoom in # <<<<<<<<<<<<<< + * MonCamera.SetZoom(1.01*MonCamera.GetZoom()) + * + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":343 + * MonCamera.SetZoom(1.01*MonCamera.GetZoom()) + * + * if pressed()[pygame.K_SPACE]:#Zoom in # <<<<<<<<<<<<<< + * refresh = True + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 343, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_13) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 343, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 343, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 343, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_K_SPACE); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 343, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyObject_GetItem(__pyx_t_4, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 343, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 343, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_16) { + + /* "CAStar/AATC_Monitor_Viewer.pyx":344 + * + * if pressed()[pygame.K_SPACE]:#Zoom in + * refresh = True # <<<<<<<<<<<<<< + * + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_refresh, Py_True) < 0) __PYX_ERR(0, 344, __pyx_L4_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":343 + * MonCamera.SetZoom(1.01*MonCamera.GetZoom()) + * + * if pressed()[pygame.K_SPACE]:#Zoom in # <<<<<<<<<<<<<< + * refresh = True + * + */ + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":347 + * + * + * MonCamera.UpdateCameraSize() # <<<<<<<<<<<<<< + * MonCamera.Draw() + * pygame.display.flip() + */ + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 347, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_UpdateCameraSize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 347, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_13) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 347, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 347, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":348 + * + * MonCamera.UpdateCameraSize() + * MonCamera.Draw() # <<<<<<<<<<<<<< + * pygame.display.flip() + * clock.tick(60) + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 348, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Draw); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 348, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + if (__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 348, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 348, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":349 + * MonCamera.UpdateCameraSize() + * MonCamera.Draw() + * pygame.display.flip() # <<<<<<<<<<<<<< + * clock.tick(60) + * + */ + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 349, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_display); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 349, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_flip); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 349, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + if (__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 349, __pyx_L4_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 349, __pyx_L4_error) + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":350 + * MonCamera.Draw() + * pygame.display.flip() + * clock.tick(60) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_clock); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 350, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_tick); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 350, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 350, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":289 + * Exit = "N" + * while Exit != "Y": + * try: # <<<<<<<<<<<<<< + * M = AATC_Monitor.CreateMonitorInterface(IP = "127.0.0.1",Port = 8001) + * M.Login("Zini","") + */ + } + __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; + goto __pyx_L11_try_end; + __pyx_L4_error:; + __Pyx_PyThreadState_assign + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":354 + * + * + * except Exception as e: # <<<<<<<<<<<<<< + * print(e) + * print("An error occured, restarting main loop") + */ + __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_12) { + __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_13, &__pyx_t_4) < 0) __PYX_ERR(0, 354, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_13); + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_e, __pyx_t_13) < 0) __PYX_ERR(0, 354, __pyx_L6_except_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":355 + * + * except Exception as e: + * print(e) # <<<<<<<<<<<<<< + * print("An error occured, restarting main loop") + * Exit = input("Exit? Y/N").upper() + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_e); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 355, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(0, 355, __pyx_L6_except_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "CAStar/AATC_Monitor_Viewer.pyx":356 + * except Exception as e: + * print(e) + * print("An error occured, restarting main loop") # <<<<<<<<<<<<<< + * Exit = input("Exit? Y/N").upper() + * + */ + if (__Pyx_PrintOne(0, __pyx_kp_s_An_error_occured_restarting_main) < 0) __PYX_ERR(0, 356, __pyx_L6_except_error) + + /* "CAStar/AATC_Monitor_Viewer.pyx":357 + * print(e) + * print("An error occured, restarting main loop") + * Exit = input("Exit? Y/N").upper() # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_input, __pyx_tuple__83, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 357, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_upper); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 357, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_10, function); + } + } + if (__pyx_t_9) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 357, __pyx_L6_except_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 357, __pyx_L6_except_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Exit, __pyx_t_2) < 0) __PYX_ERR(0, 357, __pyx_L6_except_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L5_exception_handled; + } + goto __pyx_L6_except_error; + __pyx_L6_except_error:; + + /* "CAStar/AATC_Monitor_Viewer.pyx":289 + * Exit = "N" + * while Exit != "Y": + * try: # <<<<<<<<<<<<<< + * M = AATC_Monitor.CreateMonitorInterface(IP = "127.0.0.1",Port = 8001) + * M.Login("Zini","") + */ + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + goto __pyx_L1_error; + __pyx_L5_exception_handled:; + __Pyx_PyThreadState_assign + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); + __pyx_L11_try_end:; + } + } + + /* "CAStar/AATC_Monitor_Viewer.pyx":1 + * #!python # <<<<<<<<<<<<<< + * #cython: boundscheck=False, wraparound=False, infer_types=True,cdivision = True + * + */ + __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_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_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_13); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init CAStar.AATC_Monitor_Viewer", 0, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init CAStar.AATC_Monitor_Viewer"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* GetModuleGlobalName */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS + result = PyDict_GetItem(__pyx_d, name); + if (likely(result)) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +/* PyCFunctionFastCall */ + #if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs); + } +} +#endif + +/* PyFunctionFastCall */ + #if CYTHON_FAST_PYCALL +#include "frameobject.h" +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = PyThreadState_GET(); + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = f->f_localsplus; + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCall */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + 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 */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* PyObjectCallNoArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, NULL, 0); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +/* GetItemInt */ + static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely((0 <= wrapped_i) & (wrapped_i < PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely((0 <= wrapped_i) & (wrapped_i < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* PyObjectCallMethod1 */ + static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { + PyObject *method, *result = NULL; + method = __Pyx_PyObject_GetAttrStr(obj, method_name); + if (unlikely(!method)) goto done; +#if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(method))) { + PyObject *self = PyMethod_GET_SELF(method); + if (likely(self)) { + PyObject *args; + PyObject *function = PyMethod_GET_FUNCTION(method); + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {self, arg}; + result = __Pyx_PyFunction_FastCall(function, args, 2); + goto done; + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {self, arg}; + result = __Pyx_PyCFunction_FastCall(function, args, 2); + goto done; + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(self); + PyTuple_SET_ITEM(args, 0, self); + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 1, arg); + Py_INCREF(function); + Py_DECREF(method); method = NULL; + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); + return result; + } + } +#endif + result = __Pyx_PyObject_CallOneArg(method, arg); +done: + Py_XDECREF(method); + return result; +} + +/* append */ + static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) { + if (likely(PyList_CheckExact(L))) { + if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1; + } else { + PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_n_s_append, x); + if (unlikely(!retval)) + return -1; + Py_DECREF(retval); + } + return 0; +} + +/* 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"); +} + +/* IterFinish */ + static CYTHON_INLINE int __Pyx_IterFinish(void) { +#if CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = PyThreadState_GET(); + PyObject* exc_type = tstate->curexc_type; + if (unlikely(exc_type)) { + if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) { + PyObject *exc_value, *exc_tb; + exc_value = tstate->curexc_value; + exc_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + Py_DECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_tb); + return 0; + } else { + return -1; + } + } + return 0; +#else + if (unlikely(PyErr_Occurred())) { + if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { + PyErr_Clear(); + return 0; + } else { + return -1; + } + } + return 0; +#endif +} + +/* UnpackItemEndCheck */ + static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } else { + return __Pyx_IterFinish(); + } + return 0; +} + +/* Import */ + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* FetchCommonType */ + static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* fake_module; + PyTypeObject* cached_type = NULL; + fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); + if (!fake_module) return NULL; + Py_INCREF(fake_module); + cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); + if (cached_type) { + if (!PyType_Check((PyObject*)cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", + type->tp_name); + goto bad; + } + if (cached_type->tp_basicsize != type->tp_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + type->tp_name); + goto bad; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; + } +done: + Py_DECREF(fake_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +/* CythonFunction */ + static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) +{ + if (unlikely(op->func_doc == NULL)) { + if (op->func.m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp = op->func_doc; + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + op->func_doc = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = op->func_name; + Py_INCREF(value); + op->func_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = op->func_qualname; + Py_INCREF(value); + op->func_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) +{ + PyObject *self; + self = m->func_closure; + if (self == NULL) + self = Py_None; + Py_INCREF(self); + return self; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + tmp = op->func_dict; + Py_INCREF(value); + op->func_dict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op) +{ + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + 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 = PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = 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) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyTuple_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_tuple; + op->defaults_tuple = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_kwdict; + op->defaults_kwdict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value || value == Py_None) { + value = NULL; + } else if (!PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + tmp = op->func_annotations; + op->func_annotations = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__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 PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { + {(char *) "__module__", T_OBJECT, offsetof(__pyx_CyFunctionObject, func.m_module), PY_WRITE_RESTRICTED, 0}, + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromString(m->func.m_ml->ml_name); +#else + return PyString_FromString(m->func.m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type); + if (op == NULL) + return NULL; + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; + op->func.m_ml = ml; + op->func.m_self = (PyObject *) op; + Py_XINCREF(closure); + op->func_closure = closure; + Py_XINCREF(module); + op->func.m_module = module; + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; + op->func_classobj = NULL; + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + PyObject_GC_Track(op); + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); + Py_CLEAR(m->func.m_module); + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); + Py_CLEAR(m->func_classobj); + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + PyObject_GC_Del(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); + Py_VISIT(m->func.m_module); + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); + Py_VISIT(m->func_classobj); + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) +{ + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { + Py_INCREF(func); + return func; + } + if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { + if (type == NULL) + type = (PyObject *)(Py_TYPE(obj)); + return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); + } + if (obj == Py_None) + obj = NULL; + return __Pyx_PyMethod_New(func, obj, type); +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + Py_ssize_t size; + switch (f->m_ml->ml_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)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 0)) + return (*meth)(self, NULL); + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 1)) { + PyObject *result, *arg0 = PySequence_ITEM(arg, 0); + if (unlikely(!arg0)) return NULL; + result = (*meth)(self, arg0); + Py_DECREF(arg0); + return result; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags in " + "__Pyx_CyFunction_Call. METH_OLDARGS is no " + "longer supported!"); + return NULL; + } + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw); +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; + argc = PyTuple_GET_SIZE(args); + 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); + 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; +} +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, + 0, + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_CyFunction_descr_get, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +}; +static int __pyx_CyFunction_init(void) { + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); + if (__pyx_CyFunctionType == NULL) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (!m->defaults) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + 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); +} + +/* CalculateMetaclass */ + static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { + Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases); + for (i=0; i < nbases; i++) { + PyTypeObject *tmptype; + PyObject *tmp = PyTuple_GET_ITEM(bases, i); + tmptype = Py_TYPE(tmp); +#if PY_MAJOR_VERSION < 3 + if (tmptype == &PyClass_Type) + continue; +#endif + if (!metaclass) { + metaclass = tmptype; + continue; + } + if (PyType_IsSubtype(metaclass, tmptype)) + continue; + if (PyType_IsSubtype(tmptype, metaclass)) { + metaclass = tmptype; + continue; + } + PyErr_SetString(PyExc_TypeError, + "metaclass conflict: " + "the metaclass of a derived class " + "must be a (non-strict) subclass " + "of the metaclasses of all its bases"); + return NULL; + } + if (!metaclass) { +#if PY_MAJOR_VERSION < 3 + metaclass = &PyClass_Type; +#else + metaclass = &PyType_Type; +#endif + } + Py_INCREF((PyObject*) metaclass); + return (PyObject*) metaclass; +} + +/* Py3ClassCreate */ + static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, + PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { + PyObject *ns; + if (metaclass) { + PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare); + if (prep) { + PyObject *pargs = PyTuple_Pack(2, name, bases); + if (unlikely(!pargs)) { + Py_DECREF(prep); + return NULL; + } + ns = PyObject_Call(prep, pargs, mkw); + Py_DECREF(prep); + Py_DECREF(pargs); + } else { + if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + PyErr_Clear(); + ns = PyDict_New(); + } + } else { + ns = PyDict_New(); + } + if (unlikely(!ns)) + return NULL; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; + if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; + return ns; +bad: + Py_DECREF(ns); + return NULL; +} +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, + PyObject *dict, PyObject *mkw, + int calculate_metaclass, int allow_py2_metaclass) { + PyObject *result, *margs; + PyObject *owned_metaclass = NULL; + if (allow_py2_metaclass) { + owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass); + if (owned_metaclass) { + metaclass = owned_metaclass; + } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { + PyErr_Clear(); + } else { + return NULL; + } + } + if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { + metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); + Py_XDECREF(owned_metaclass); + if (unlikely(!metaclass)) + return NULL; + owned_metaclass = metaclass; + } + margs = PyTuple_Pack(3, name, bases, dict); + if (unlikely(!margs)) { + result = NULL; + } else { + result = PyObject_Call(metaclass, margs, mkw); + Py_DECREF(margs); + } + Py_XDECREF(owned_metaclass); + return result; +} + +/* BytesEquals */ + static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ + static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + 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; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) { + PyObject *exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + return PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { +#endif + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + 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; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* CLineInTraceback */ + static int __Pyx_CLineForTraceback(int c_line) { +#ifdef CYTHON_CLINE_IN_TRACEBACK + return ((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0; +#else + PyObject **cython_runtime_dict; + PyObject *use_cline; + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (unlikely(!cython_runtime_dict)) { + PyObject *ptype, *pvalue, *ptraceback; + PyObject *use_cline_obj; + PyErr_Fetch(&ptype, &pvalue, &ptraceback); + use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + use_cline = NULL; + } + PyErr_Restore(ptype, pvalue, ptraceback); + } else { + use_cline = PyDict_GetItem(*_PyObject_GetDictPtr(__pyx_cython_runtime), __pyx_n_s_cline_in_traceback); + } + if (!use_cline) { + c_line = 0; + PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (PyObject_Not(use_cline) != 0) { + c_line = 0; + } + return c_line; +#endif +} + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + if (c_line) { + c_line = __Pyx_CLineForTraceback(c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +/* 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;\ + } + +/* Print */ + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION < 3 +static PyObject *__Pyx_GetStdout(void) { + PyObject *f = PySys_GetObject((char *)"stdout"); + if (!f) { + PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout"); + } + return f; +} +static int __Pyx_Print(PyObject* f, PyObject *arg_tuple, int newline) { + int i; + if (!f) { + if (!(f = __Pyx_GetStdout())) + return -1; + } + Py_INCREF(f); + for (i=0; i < PyTuple_GET_SIZE(arg_tuple); i++) { + PyObject* v; + if (PyFile_SoftSpace(f, 1)) { + if (PyFile_WriteString(" ", f) < 0) + goto error; + } + v = PyTuple_GET_ITEM(arg_tuple, i); + if (PyFile_WriteObject(v, f, Py_PRINT_RAW) < 0) + goto error; + if (PyString_Check(v)) { + char *s = PyString_AsString(v); + Py_ssize_t len = PyString_Size(v); + if (len > 0) { + switch (s[len-1]) { + case ' ': break; + case '\f': case '\r': case '\n': case '\t': case '\v': + PyFile_SoftSpace(f, 0); + break; + default: break; + } + } + } + } + if (newline) { + if (PyFile_WriteString("\n", f) < 0) + goto error; + PyFile_SoftSpace(f, 0); + } + Py_DECREF(f); + return 0; +error: + Py_DECREF(f); + return -1; +} +#else +static int __Pyx_Print(PyObject* stream, PyObject *arg_tuple, int newline) { + PyObject* kwargs = 0; + PyObject* result = 0; + PyObject* end_string; + if (unlikely(!__pyx_print)) { + __pyx_print = PyObject_GetAttr(__pyx_b, __pyx_n_s_print); + if (!__pyx_print) + return -1; + } + if (stream) { + kwargs = PyDict_New(); + if (unlikely(!kwargs)) + return -1; + if (unlikely(PyDict_SetItem(kwargs, __pyx_n_s_file, stream) < 0)) + goto bad; + if (!newline) { + end_string = PyUnicode_FromStringAndSize(" ", 1); + if (unlikely(!end_string)) + goto bad; + if (PyDict_SetItem(kwargs, __pyx_n_s_end, end_string) < 0) { + Py_DECREF(end_string); + goto bad; + } + Py_DECREF(end_string); + } + } else if (!newline) { + if (unlikely(!__pyx_print_kwargs)) { + __pyx_print_kwargs = PyDict_New(); + if (unlikely(!__pyx_print_kwargs)) + return -1; + end_string = PyUnicode_FromStringAndSize(" ", 1); + if (unlikely(!end_string)) + return -1; + if (PyDict_SetItem(__pyx_print_kwargs, __pyx_n_s_end, end_string) < 0) { + Py_DECREF(end_string); + return -1; + } + Py_DECREF(end_string); + } + kwargs = __pyx_print_kwargs; + } + result = PyObject_Call(__pyx_print, arg_tuple, kwargs); + if (unlikely(kwargs) && (kwargs != __pyx_print_kwargs)) + Py_DECREF(kwargs); + if (!result) + return -1; + Py_DECREF(result); + return 0; +bad: + if (kwargs != __pyx_print_kwargs) + Py_XDECREF(kwargs); + return -1; +} +#endif + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* ToPyCTupleUtility */ + static PyObject* __pyx_convert__to_py___pyx_ctuple_long__and_long__and_long(__pyx_ctuple_long__and_long__and_long value) { + PyObject* item = NULL; + PyObject* result = PyTuple_New(3); + if (!result) goto bad; + item = __Pyx_PyInt_From_long(value.f0); + if (!item) goto bad; + PyTuple_SET_ITEM(result, 0, item); + item = __Pyx_PyInt_From_long(value.f1); + if (!item) goto bad; + PyTuple_SET_ITEM(result, 1, item); + item = __Pyx_PyInt_From_long(value.f2); + if (!item) goto bad; + PyTuple_SET_ITEM(result, 2, item); + return result; +bad: + Py_XDECREF(item); + Py_XDECREF(result); + return NULL; +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* PrintOne */ + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION < 3 +static int __Pyx_PrintOne(PyObject* f, PyObject *o) { + if (!f) { + if (!(f = __Pyx_GetStdout())) + return -1; + } + Py_INCREF(f); + if (PyFile_SoftSpace(f, 0)) { + if (PyFile_WriteString(" ", f) < 0) + goto error; + } + if (PyFile_WriteObject(o, f, Py_PRINT_RAW) < 0) + goto error; + if (PyFile_WriteString("\n", f) < 0) + goto error; + Py_DECREF(f); + return 0; +error: + Py_DECREF(f); + return -1; + /* the line below is just to avoid C compiler + * warnings about unused functions */ + return __Pyx_Print(f, NULL, 0); +} +#else +static int __Pyx_PrintOne(PyObject* stream, PyObject *o) { + int res; + PyObject* arg_tuple = PyTuple_Pack(1, o); + if (unlikely(!arg_tuple)) + return -1; + res = __Pyx_Print(stream, arg_tuple, 1); + Py_DECREF(arg_tuple); + return res; +} +#endif + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + PyErr_Clear(); + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (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 + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } + #else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } + #endif +#else + res = PyNumber_Int(x); +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/CAStar/AATC_Monitor_Viewer.html b/CAStar/AATC_Monitor_Viewer.html new file mode 100644 index 0000000..80b5134 --- /dev/null +++ b/CAStar/AATC_Monitor_Viewer.html @@ -0,0 +1,10392 @@ + + + + + + Cython: AATC_Monitor_Viewer.pyx + + + + +

Generated by Cython 0.26

+

+ Yellow lines hint at Python interaction.
+ Click on a line that starts with a "+" to see the C code that Cython generated for it. +

+

Raw output: AATC_Monitor_Viewer.c

+
 001: #!python
+
 002: #cython: boundscheck=False, wraparound=False, infer_types=True,cdivision = True
+
 003:
+
+004: import pygame,AATC_Monitor,time,ast,sys,random,AATC_Coordinate
+
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_pygame, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pygame, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_AATC_Monitor, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AATC_Monitor, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_time, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_time, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_ast, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ast, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_random, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_random, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_AATC_Coordinate, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AATC_Coordinate, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
 005:
+
+006: pygame.init()
+
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_init); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __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;
+
 007:
+
+008: _images= {}
+
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_images, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+009: def GetImage(xSize,ySize,Colour):  #Efficiently get images
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_1GetImage(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_1GetImage = {"GetImage", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_1GetImage, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_1GetImage(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_xSize = 0;
+  PyObject *__pyx_v_ySize = 0;
+  PyObject *__pyx_v_Colour = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("GetImage (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_xSize,&__pyx_n_s_ySize,&__pyx_n_s_Colour,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_xSize)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ySize)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("GetImage", 1, 3, 3, 1); __PYX_ERR(0, 9, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Colour)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("GetImage", 1, 3, 3, 2); __PYX_ERR(0, 9, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "GetImage") < 0)) __PYX_ERR(0, 9, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_xSize = values[0];
+    __pyx_v_ySize = values[1];
+    __pyx_v_Colour = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("GetImage", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 9, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.GetImage", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_GetImage(__pyx_self, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_Colour);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_GetImage(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_xSize, PyObject *__pyx_v_ySize, PyObject *__pyx_v_Colour) {
+  PyObject *__pyx_v_result = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("GetImage", 0);
+/* … */
+  /* 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_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.GetImage", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__27 = PyTuple_Pack(4, __pyx_n_s_xSize, __pyx_n_s_ySize, __pyx_n_s_Colour, __pyx_n_s_result); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 9, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__27);
+  __Pyx_GIVEREF(__pyx_tuple__27);
+/* … */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_1GetImage, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_GetImage, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_GetImage, 9, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 9, __pyx_L1_error)
+
+010:     result = _images.get((xSize,ySize,Colour))
+
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_images); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 10, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_xSize);
+  __Pyx_GIVEREF(__pyx_v_xSize);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_xSize);
+  __Pyx_INCREF(__pyx_v_ySize);
+  __Pyx_GIVEREF(__pyx_v_ySize);
+  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_ySize);
+  __Pyx_INCREF(__pyx_v_Colour);
+  __Pyx_GIVEREF(__pyx_v_Colour);
+  PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_Colour);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 10, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_2);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2);
+      __pyx_t_2 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_result = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+011:     if result == None:
+
  __pyx_t_1 = PyObject_RichCompare(__pyx_v_result, Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 11, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_6) {
+/* … */
+  }
+
+012:         result = pygame.Surface((xSize,ySize)).convert()
+
    __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 12, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Surface); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 12, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_v_xSize);
+    __Pyx_GIVEREF(__pyx_v_xSize);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_xSize);
+    __Pyx_INCREF(__pyx_v_ySize);
+    __Pyx_GIVEREF(__pyx_v_ySize);
+    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_ySize);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    if (!__pyx_t_4) {
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 12, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5};
+        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 12, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5};
+        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 12, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 12, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
+        __Pyx_GIVEREF(__pyx_t_5);
+        PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5);
+        __pyx_t_5 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 12, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_convert); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    if (__pyx_t_3) {
+      __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else {
+      __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error)
+    }
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+013:         result.fill(Colour)
+
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result, __pyx_n_s_fill); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    if (!__pyx_t_3) {
+      __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_Colour); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_Colour};
+        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_Colour};
+        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+      } else
+      #endif
+      {
+        __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 13, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
+        __Pyx_INCREF(__pyx_v_Colour);
+        __Pyx_GIVEREF(__pyx_v_Colour);
+        PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_Colour);
+        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+014:         _images[(xSize,ySize,Colour)]=result
+
    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_images); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_v_xSize);
+    __Pyx_GIVEREF(__pyx_v_xSize);
+    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_xSize);
+    __Pyx_INCREF(__pyx_v_ySize);
+    __Pyx_GIVEREF(__pyx_v_ySize);
+    PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_ySize);
+    __Pyx_INCREF(__pyx_v_Colour);
+    __Pyx_GIVEREF(__pyx_v_Colour);
+    PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_Colour);
+    if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_t_2, __pyx_v_result) < 0)) __PYX_ERR(0, 14, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+015:     while len(_images) > 1500:
+
  while (1) {
+    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_images); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_8 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 15, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_6 = ((__pyx_t_8 > 0x5DC) != 0);
+    if (!__pyx_t_6) break;
+
+016:         _images.pop(random.sample(_images.keys(),1)[0])   #If cache is full evict old versions
+
    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_images); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_pop); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 16, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_sample); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 16, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_images); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 16, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_keys); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 16, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_9, function);
+      }
+    }
+    if (__pyx_t_4) {
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else {
+      __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 16, __pyx_L1_error)
+    }
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_t_9 = NULL;
+    __pyx_t_10 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+        __pyx_t_10 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_5)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_3, __pyx_int_1};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_3, __pyx_int_1};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 16, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (__pyx_t_9) {
+        __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_9); __pyx_t_9 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_10, __pyx_t_3);
+      __Pyx_INCREF(__pyx_int_1);
+      __Pyx_GIVEREF(__pyx_int_1);
+      PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_10, __pyx_int_1);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 16, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_7);
+      if (likely(__pyx_t_1)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_7, function);
+      }
+    }
+    if (!__pyx_t_1) {
+      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_7)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_5};
+        __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_5};
+        __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 16, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = NULL;
+        __Pyx_GIVEREF(__pyx_t_5);
+        PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_5);
+        __pyx_t_5 = 0;
+        __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+
+017:     return result#_copy
+
  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_result);
+  __pyx_r = __pyx_v_result;
+  goto __pyx_L0;
+
 018:
+
+019: _texts= {}
+
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_texts, __pyx_t_1) < 0) __PYX_ERR(0, 19, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+020: def GetText(Text,fontParameters,AA,Colour):  #Efficiently get text
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_3GetText(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_3GetText = {"GetText", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_3GetText, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_3GetText(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_Text = 0;
+  PyObject *__pyx_v_fontParameters = 0;
+  PyObject *__pyx_v_AA = 0;
+  PyObject *__pyx_v_Colour = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("GetText (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Text,&__pyx_n_s_fontParameters,&__pyx_n_s_AA,&__pyx_n_s_Colour,0};
+    PyObject* values[4] = {0,0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        CYTHON_FALLTHROUGH;
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Text)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fontParameters)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("GetText", 1, 4, 4, 1); __PYX_ERR(0, 20, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_AA)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("GetText", 1, 4, 4, 2); __PYX_ERR(0, 20, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Colour)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("GetText", 1, 4, 4, 3); __PYX_ERR(0, 20, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "GetText") < 0)) __PYX_ERR(0, 20, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    }
+    __pyx_v_Text = values[0];
+    __pyx_v_fontParameters = values[1];
+    __pyx_v_AA = values[2];
+    __pyx_v_Colour = values[3];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("GetText", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 20, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.GetText", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_2GetText(__pyx_self, __pyx_v_Text, __pyx_v_fontParameters, __pyx_v_AA, __pyx_v_Colour);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_2GetText(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Text, PyObject *__pyx_v_fontParameters, PyObject *__pyx_v_AA, PyObject *__pyx_v_Colour) {
+  PyObject *__pyx_v_result = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("GetText", 0);
+/* … */
+  /* 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_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.GetText", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__29 = PyTuple_Pack(5, __pyx_n_s_Text, __pyx_n_s_fontParameters, __pyx_n_s_AA, __pyx_n_s_Colour, __pyx_n_s_result); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__29);
+  __Pyx_GIVEREF(__pyx_tuple__29);
+/* … */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_3GetText, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_GetText, __pyx_t_1) < 0) __PYX_ERR(0, 20, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(4, 0, 5, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_GetText, 20, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(0, 20, __pyx_L1_error)
+
+021:     result = _texts.get((Text,fontParameters,AA,Colour))
+
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_texts); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 21, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_Text);
+  __Pyx_GIVEREF(__pyx_v_Text);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_Text);
+  __Pyx_INCREF(__pyx_v_fontParameters);
+  __Pyx_GIVEREF(__pyx_v_fontParameters);
+  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_fontParameters);
+  __Pyx_INCREF(__pyx_v_AA);
+  __Pyx_GIVEREF(__pyx_v_AA);
+  PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_AA);
+  __Pyx_INCREF(__pyx_v_Colour);
+  __Pyx_GIVEREF(__pyx_v_Colour);
+  PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_v_Colour);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 21, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_2);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2);
+      __pyx_t_2 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_result = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+022:     if result == None:
+
  __pyx_t_1 = PyObject_RichCompare(__pyx_v_result, Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_6) {
+/* … */
+  }
+
+023:         result = GetFont(*fontParameters).render(Text,AA,Colour)
+
    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_GetFont); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 23, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = PySequence_Tuple(__pyx_v_fontParameters); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 23, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_render); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 23, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = NULL;
+    __pyx_t_7 = 0;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_2)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_2);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+        __pyx_t_7 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_5)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_v_Text, __pyx_v_AA, __pyx_v_Colour};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_2, __pyx_v_Text, __pyx_v_AA, __pyx_v_Colour};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_3 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 23, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      if (__pyx_t_2) {
+        __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Text);
+      __Pyx_GIVEREF(__pyx_v_Text);
+      PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_7, __pyx_v_Text);
+      __Pyx_INCREF(__pyx_v_AA);
+      __Pyx_GIVEREF(__pyx_v_AA);
+      PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_7, __pyx_v_AA);
+      __Pyx_INCREF(__pyx_v_Colour);
+      __Pyx_GIVEREF(__pyx_v_Colour);
+      PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_7, __pyx_v_Colour);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+024:         _texts[(Text,fontParameters,AA,Colour)]=result
+
    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_texts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 24, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_v_Text);
+    __Pyx_GIVEREF(__pyx_v_Text);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_Text);
+    __Pyx_INCREF(__pyx_v_fontParameters);
+    __Pyx_GIVEREF(__pyx_v_fontParameters);
+    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_fontParameters);
+    __Pyx_INCREF(__pyx_v_AA);
+    __Pyx_GIVEREF(__pyx_v_AA);
+    PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_AA);
+    __Pyx_INCREF(__pyx_v_Colour);
+    __Pyx_GIVEREF(__pyx_v_Colour);
+    PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_v_Colour);
+    if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_t_5, __pyx_v_result) < 0)) __PYX_ERR(0, 24, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+025:     while len(_texts) > 1500:
+
  while (1) {
+    __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_texts); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 25, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_8 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 25, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_6 = ((__pyx_t_8 > 0x5DC) != 0);
+    if (!__pyx_t_6) break;
+
+026:         _texts.pop(random.sample(_texts.keys(),1)[0])   #If cache is full evict old versions
+
    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_texts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_pop); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_random); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_sample); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_texts); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 26, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_keys); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 26, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_10);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_t_9 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_10, function);
+      }
+    }
+    if (__pyx_t_9) {
+      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    } else {
+      __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error)
+    }
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __pyx_t_10 = NULL;
+    __pyx_t_7 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_10)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_10);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+        __pyx_t_7 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_2, __pyx_int_1};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_2, __pyx_int_1};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_9 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 26, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      if (__pyx_t_10) {
+        __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); __pyx_t_10 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_2);
+      PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_7, __pyx_t_2);
+      __Pyx_INCREF(__pyx_int_1);
+      __Pyx_GIVEREF(__pyx_int_1);
+      PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_7, __pyx_int_1);
+      __pyx_t_2 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 26, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_1)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+      }
+    }
+    if (!__pyx_t_1) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_3)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_4};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_4};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 26, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_1); __pyx_t_1 = NULL;
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_4);
+        __pyx_t_4 = 0;
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+
+027:     return result
+
  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_result);
+  __pyx_r = __pyx_v_result;
+  goto __pyx_L0;
+
 028:
+
 029:
+
+030: _fonts = {}
+
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_fonts, __pyx_t_1) < 0) __PYX_ERR(0, 30, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+031: def GetFont(Font,Size):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_5GetFont(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_5GetFont = {"GetFont", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_5GetFont, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_5GetFont(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_Font = 0;
+  PyObject *__pyx_v_Size = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("GetFont (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Font,&__pyx_n_s_Size,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Font)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Size)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("GetFont", 1, 2, 2, 1); __PYX_ERR(0, 31, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "GetFont") < 0)) __PYX_ERR(0, 31, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_Font = values[0];
+    __pyx_v_Size = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("GetFont", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 31, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.GetFont", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_4GetFont(__pyx_self, __pyx_v_Font, __pyx_v_Size);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_4GetFont(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Font, PyObject *__pyx_v_Size) {
+  PyObject *__pyx_v_result = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("GetFont", 0);
+/* … */
+  /* 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_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.GetFont", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__31 = PyTuple_Pack(3, __pyx_n_s_Font, __pyx_n_s_Size, __pyx_n_s_result); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__31);
+  __Pyx_GIVEREF(__pyx_tuple__31);
+/* … */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_5GetFont, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_GetFont, __pyx_t_1) < 0) __PYX_ERR(0, 31, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_GetFont, 31, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 31, __pyx_L1_error)
+
+032:     result = _fonts.get((Font,Size))
+
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_fonts); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_Font);
+  __Pyx_GIVEREF(__pyx_v_Font);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_Font);
+  __Pyx_INCREF(__pyx_v_Size);
+  __Pyx_GIVEREF(__pyx_v_Size);
+  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_Size);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 32, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_2);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2);
+      __pyx_t_2 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_result = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+033:     if result == None:
+
  __pyx_t_1 = PyObject_RichCompare(__pyx_v_result, Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 33, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_6) {
+/* … */
+  }
+
+034:         result = pygame.font.Font(Font,Size)
+
    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_font); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 34, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Font); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_5 = NULL;
+    __pyx_t_7 = 0;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_5)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_7 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_Font, __pyx_v_Size};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_Font, __pyx_v_Size};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_2 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      if (__pyx_t_5) {
+        __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5); __pyx_t_5 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Font);
+      __Pyx_GIVEREF(__pyx_v_Font);
+      PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_7, __pyx_v_Font);
+      __Pyx_INCREF(__pyx_v_Size);
+      __Pyx_GIVEREF(__pyx_v_Size);
+      PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_7, __pyx_v_Size);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __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_DECREF_SET(__pyx_v_result, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+035:         _fonts[(Font,Size)]=result
+
    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_fonts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 35, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 35, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_v_Font);
+    __Pyx_GIVEREF(__pyx_v_Font);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_Font);
+    __Pyx_INCREF(__pyx_v_Size);
+    __Pyx_GIVEREF(__pyx_v_Size);
+    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_Size);
+    if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_t_3, __pyx_v_result) < 0)) __PYX_ERR(0, 35, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+036:     while len(_fonts) > 1500:
+
  while (1) {
+    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_fonts); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 36, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_8 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 36, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_6 = ((__pyx_t_8 > 0x5DC) != 0);
+    if (!__pyx_t_6) break;
+
+037:         _fonts.pop(random.sample(_fonts.keys(),1)[0])   #If cache is full evict old versions
+
    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_fonts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_pop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_random); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 37, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_sample); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_fonts); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 37, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_keys); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 37, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_10);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_t_9 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_10, function);
+      }
+    }
+    if (__pyx_t_9) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 37, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    } else {
+      __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 37, __pyx_L1_error)
+    }
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __pyx_t_10 = NULL;
+    __pyx_t_7 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_10)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_10);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+        __pyx_t_7 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_5, __pyx_int_1};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_5, __pyx_int_1};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_9 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 37, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      if (__pyx_t_10) {
+        __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); __pyx_t_10 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_7, __pyx_t_5);
+      __Pyx_INCREF(__pyx_int_1);
+      __Pyx_GIVEREF(__pyx_int_1);
+      PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_7, __pyx_int_1);
+      __pyx_t_5 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_1)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    if (!__pyx_t_1) {
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_4};
+        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_4};
+        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 37, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_1); __pyx_t_1 = NULL;
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_4);
+        __pyx_t_4 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+
+038:     return result
+
  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_result);
+  __pyx_r = __pyx_v_result;
+  goto __pyx_L0;
+
 039:
+
 040:
+
+041: cdef int MaxLimit( int value, int Max):
+
static int __pyx_f_6CAStar_19AATC_Monitor_Viewer_MaxLimit(int __pyx_v_value, int __pyx_v_Max) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("MaxLimit", 0);
+/* … */
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+042:     if value > Max:
+
  __pyx_t_1 = ((__pyx_v_value > __pyx_v_Max) != 0);
+  if (__pyx_t_1) {
+/* … */
+  }
+
+043:         value = Max
+
    __pyx_v_value = __pyx_v_Max;
+
+044:     return value
+
  __pyx_r = __pyx_v_value;
+  goto __pyx_L0;
+
 045:
+
 046:
+
 047:
+
+048: class Camera:
+
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_Camera, __pyx_n_s_Camera, (PyObject *) NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+/* … */
+  __pyx_t_3 = __Pyx_Py3ClassCreate(((PyObject*)&__Pyx_DefaultClassType), __pyx_n_s_Camera, __pyx_empty_tuple, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_Camera, __pyx_t_3) < 0) __PYX_ERR(0, 48, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+049:     def __init__(self,xpixel,ypixel,MinCoords,MaxCoords):  #COORDS (X,Y,Z)
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_1__init__ = {"__init__", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_1__init__, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_xpixel = 0;
+  PyObject *__pyx_v_ypixel = 0;
+  PyObject *__pyx_v_MinCoords = 0;
+  PyObject *__pyx_v_MaxCoords = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_xpixel,&__pyx_n_s_ypixel,&__pyx_n_s_MinCoords,&__pyx_n_s_MaxCoords,0};
+    PyObject* values[5] = {0,0,0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        CYTHON_FALLTHROUGH;
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        CYTHON_FALLTHROUGH;
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_xpixel)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 1); __PYX_ERR(0, 49, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ypixel)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 2); __PYX_ERR(0, 49, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_MinCoords)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 3); __PYX_ERR(0, 49, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  4:
+        if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_MaxCoords)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 4); __PYX_ERR(0, 49, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 49, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_xpixel = values[1];
+    __pyx_v_ypixel = values[2];
+    __pyx_v_MinCoords = values[3];
+    __pyx_v_MaxCoords = values[4];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 49, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera___init__(__pyx_self, __pyx_v_self, __pyx_v_xpixel, __pyx_v_ypixel, __pyx_v_MinCoords, __pyx_v_MaxCoords);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_xpixel, PyObject *__pyx_v_ypixel, PyObject *__pyx_v_MinCoords, PyObject *__pyx_v_MaxCoords) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__", 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_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__33 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_xpixel, __pyx_n_s_ypixel, __pyx_n_s_MinCoords, __pyx_n_s_MaxCoords); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__33);
+  __Pyx_GIVEREF(__pyx_tuple__33);
+/* … */
+  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_1__init__, 0, __pyx_n_s_Camera___init, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_init_2, __pyx_t_3) < 0) __PYX_ERR(0, 49, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(5, 0, 5, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__33, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_init_2, 49, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(0, 49, __pyx_L1_error)
+
+050:         self.xpixel = xpixel
+
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_xpixel, __pyx_v_xpixel) < 0) __PYX_ERR(0, 50, __pyx_L1_error)
+
+051:         self.ypixel = ypixel
+
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_ypixel, __pyx_v_ypixel) < 0) __PYX_ERR(0, 51, __pyx_L1_error)
+
+052:         self.gameDisplay = pygame.display.set_mode((self.xpixel,self.ypixel))
+
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_display); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_set_mode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_xpixel); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ypixel); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_5);
+      __pyx_t_5 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_gameDisplay, __pyx_t_1) < 0) __PYX_ERR(0, 52, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+053:         self.MinCoords = MinCoords
+
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_MinCoords, __pyx_v_MinCoords) < 0) __PYX_ERR(0, 53, __pyx_L1_error)
+
+054:         self.MaxCoords = MaxCoords
+
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_MaxCoords, __pyx_v_MaxCoords) < 0) __PYX_ERR(0, 54, __pyx_L1_error)
+
+055:         self.CameraCoord = self.MinCoords.copy()
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MinCoords); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord, __pyx_t_1) < 0) __PYX_ERR(0, 55, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+056:         self.CameraCoord.Set_XSize( self.MaxCoords.Get_X() - self.MinCoords.Get_X())
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Set_XSize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MaxCoords); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (__pyx_t_5) {
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else {
+    __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MinCoords); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  if (__pyx_t_5) {
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else {
+    __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = PyNumber_Subtract(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_6};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_6};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_6);
+      __pyx_t_6 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+057:         self.CameraCoord.Set_YSize( self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Set_YSize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MaxCoords); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_6)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (__pyx_t_6) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MinCoords); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_6)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  if (__pyx_t_6) {
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  } else {
+    __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyNumber_Subtract(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_5);
+      __pyx_t_5 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __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_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+058:         self.CameraZoom = 1
+
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_CameraZoom, __pyx_int_1) < 0) __PYX_ERR(0, 58, __pyx_L1_error)
+
+059:         self.DrawObjects = []
+
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_DrawObjects, __pyx_t_1) < 0) __PYX_ERR(0, 59, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
 060:
+
+061:     def GetZoom(self):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_3GetZoom(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_3GetZoom = {"GetZoom", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_3GetZoom, METH_O, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_3GetZoom(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("GetZoom (wrapper)", 0);
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_2GetZoom(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_2GetZoom(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("GetZoom", 0);
+/* … */
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.GetZoom", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__35 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__35);
+  __Pyx_GIVEREF(__pyx_tuple__35);
+/* … */
+  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_3GetZoom, 0, __pyx_n_s_Camera_GetZoom, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__36)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_GetZoom, __pyx_t_3) < 0) __PYX_ERR(0, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__35, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_GetZoom, 61, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(0, 61, __pyx_L1_error)
+
+062:         return self.CameraZoom
+
  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraZoom); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+063:     def SetZoom(self,Zoom):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_5SetZoom(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_5SetZoom = {"SetZoom", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_5SetZoom, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_5SetZoom(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_Zoom = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("SetZoom (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_Zoom,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Zoom)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("SetZoom", 1, 2, 2, 1); __PYX_ERR(0, 63, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "SetZoom") < 0)) __PYX_ERR(0, 63, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_Zoom = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("SetZoom", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 63, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.SetZoom", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_4SetZoom(__pyx_self, __pyx_v_self, __pyx_v_Zoom);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_4SetZoom(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Zoom) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("SetZoom", 0);
+/* … */
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.SetZoom", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__37 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_Zoom); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__37);
+  __Pyx_GIVEREF(__pyx_tuple__37);
+/* … */
+  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_5SetZoom, 0, __pyx_n_s_Camera_SetZoom, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__38)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_SetZoom, __pyx_t_3) < 0) __PYX_ERR(0, 63, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__38 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__37, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_SetZoom, 63, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__38)) __PYX_ERR(0, 63, __pyx_L1_error)
+
+064:         self.CameraZoom = Zoom
+
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_CameraZoom, __pyx_v_Zoom) < 0) __PYX_ERR(0, 64, __pyx_L1_error)
+
 065:
+
+066:     def GetCameraCoords(self):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_7GetCameraCoords(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_7GetCameraCoords = {"GetCameraCoords", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_7GetCameraCoords, METH_O, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_7GetCameraCoords(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("GetCameraCoords (wrapper)", 0);
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_6GetCameraCoords(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_6GetCameraCoords(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("GetCameraCoords", 0);
+/* … */
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.GetCameraCoords", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__39 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__39);
+  __Pyx_GIVEREF(__pyx_tuple__39);
+/* … */
+  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_7GetCameraCoords, 0, __pyx_n_s_Camera_GetCameraCoords, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__40)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_GetCameraCoords, __pyx_t_3) < 0) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__40 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__39, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_GetCameraCoords, 66, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__40)) __PYX_ERR(0, 66, __pyx_L1_error)
+
+067:         return self.CameraCoord
+
  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+068:     def IncrementCameraCoordX(self,Amount):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_9IncrementCameraCoordX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_9IncrementCameraCoordX = {"IncrementCameraCoordX", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_9IncrementCameraCoordX, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_9IncrementCameraCoordX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_Amount = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("IncrementCameraCoordX (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_Amount,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Amount)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("IncrementCameraCoordX", 1, 2, 2, 1); __PYX_ERR(0, 68, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "IncrementCameraCoordX") < 0)) __PYX_ERR(0, 68, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_Amount = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("IncrementCameraCoordX", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 68, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.IncrementCameraCoordX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_8IncrementCameraCoordX(__pyx_self, __pyx_v_self, __pyx_v_Amount);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_8IncrementCameraCoordX(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Amount) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("IncrementCameraCoordX", 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_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.IncrementCameraCoordX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__41 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_Amount); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__41);
+  __Pyx_GIVEREF(__pyx_tuple__41);
+/* … */
+  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_9IncrementCameraCoordX, 0, __pyx_n_s_Camera_IncrementCameraCoordX, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__42)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_IncrementCameraCoordX, __pyx_t_3) < 0) __PYX_ERR(0, 68, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__41, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_IncrementCameraCoordX, 68, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) __PYX_ERR(0, 68, __pyx_L1_error)
+
+069:         self.CameraCoord.Set_X( Amount+self.CameraCoord.Get_X())
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Set_X); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyNumber_Add(__pyx_v_Amount, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_5};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_5};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_5);
+      __pyx_t_5 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
 070:
+
+071:     def IncrementCameraCoordY(self,Amount):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_11IncrementCameraCoordY(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_11IncrementCameraCoordY = {"IncrementCameraCoordY", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_11IncrementCameraCoordY, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_11IncrementCameraCoordY(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_Amount = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("IncrementCameraCoordY (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_Amount,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Amount)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("IncrementCameraCoordY", 1, 2, 2, 1); __PYX_ERR(0, 71, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "IncrementCameraCoordY") < 0)) __PYX_ERR(0, 71, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_Amount = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("IncrementCameraCoordY", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 71, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.IncrementCameraCoordY", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_10IncrementCameraCoordY(__pyx_self, __pyx_v_self, __pyx_v_Amount);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_10IncrementCameraCoordY(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Amount) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("IncrementCameraCoordY", 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_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.IncrementCameraCoordY", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__43 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_Amount); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__43);
+  __Pyx_GIVEREF(__pyx_tuple__43);
+/* … */
+  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_11IncrementCameraCoordY, 0, __pyx_n_s_Camera_IncrementCameraCoordY, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__44)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_IncrementCameraCoordY, __pyx_t_3) < 0) __PYX_ERR(0, 71, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__44 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__43, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_IncrementCameraCoordY, 71, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__44)) __PYX_ERR(0, 71, __pyx_L1_error)
+
+072:         self.CameraCoord.Set_Y( Amount+self.CameraCoord.Get_Y())
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Set_Y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyNumber_Add(__pyx_v_Amount, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_5};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_5};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 72, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_5);
+      __pyx_t_5 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
 073:
+
+074:     def SetCameraCoords(self,CameraX,CameraY):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_13SetCameraCoords(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_13SetCameraCoords = {"SetCameraCoords", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_13SetCameraCoords, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_13SetCameraCoords(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_CameraX = 0;
+  PyObject *__pyx_v_CameraY = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("SetCameraCoords (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_CameraX,&__pyx_n_s_CameraY,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_CameraX)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("SetCameraCoords", 1, 3, 3, 1); __PYX_ERR(0, 74, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_CameraY)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("SetCameraCoords", 1, 3, 3, 2); __PYX_ERR(0, 74, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "SetCameraCoords") < 0)) __PYX_ERR(0, 74, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_CameraX = values[1];
+    __pyx_v_CameraY = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("SetCameraCoords", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 74, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.SetCameraCoords", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_12SetCameraCoords(__pyx_self, __pyx_v_self, __pyx_v_CameraX, __pyx_v_CameraY);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_12SetCameraCoords(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_CameraX, PyObject *__pyx_v_CameraY) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("SetCameraCoords", 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_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.SetCameraCoords", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__45 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_CameraX, __pyx_n_s_CameraY); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__45);
+  __Pyx_GIVEREF(__pyx_tuple__45);
+/* … */
+  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_13SetCameraCoords, 0, __pyx_n_s_Camera_SetCameraCoords, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__46)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_SetCameraCoords, __pyx_t_3) < 0) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__46 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_SetCameraCoords, 74, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__46)) __PYX_ERR(0, 74, __pyx_L1_error)
+
+075:         self.CameraCoord.Set_X( CameraX)
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 75, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Set_X); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 75, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_CameraX); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_CameraX};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_CameraX};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 75, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      __Pyx_INCREF(__pyx_v_CameraX);
+      __Pyx_GIVEREF(__pyx_v_CameraX);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_CameraX);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+076:         self.CameraCoord.Set_Y(CameraY)
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Set_Y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (!__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_CameraY); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_CameraY};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_CameraY};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      __Pyx_INCREF(__pyx_v_CameraY);
+      __Pyx_GIVEREF(__pyx_v_CameraY);
+      PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_CameraY);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
 077:
+
+078:     def UpdateCameraSize(self):  #Gets width of map divided by zoom level eg at zoom 1x it has whole map
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_15UpdateCameraSize(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_15UpdateCameraSize = {"UpdateCameraSize", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_15UpdateCameraSize, METH_O, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_15UpdateCameraSize(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("UpdateCameraSize (wrapper)", 0);
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_14UpdateCameraSize(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_14UpdateCameraSize(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("UpdateCameraSize", 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_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.UpdateCameraSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__47 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__47);
+  __Pyx_GIVEREF(__pyx_tuple__47);
+/* … */
+  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_15UpdateCameraSize, 0, __pyx_n_s_Camera_UpdateCameraSize, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__48)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_UpdateCameraSize, __pyx_t_3) < 0) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__48 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_UpdateCameraSize, 78, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__48)) __PYX_ERR(0, 78, __pyx_L1_error)
+
+079:         self.CameraCoord.Set_XSize ((self.MaxCoords.Get_X() - self.MinCoords.Get_X())/self.CameraZoom)
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Set_XSize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MaxCoords); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MinCoords); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = PyNumber_Subtract(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraZoom); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_PyNumber_Divide(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_5) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_2};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_2};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+      __Pyx_GIVEREF(__pyx_t_2);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_2);
+      __pyx_t_2 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+080:         self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom)
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Set_YSize); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MaxCoords); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MinCoords); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyNumber_Subtract(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraZoom); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  if (!__pyx_t_5) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_6)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 80, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __pyx_t_5 = NULL;
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
 081:
+
+082:     def CameraWipe(self,Colour = (0,0,0)):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_17CameraWipe(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_17CameraWipe = {"CameraWipe", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_17CameraWipe, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_17CameraWipe(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_Colour = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("CameraWipe (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_Colour,0};
+    PyObject* values[2] = {0,0};
+    values[1] = ((PyObject *)((PyObject*)__pyx_tuple_));
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Colour);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CameraWipe") < 0)) __PYX_ERR(0, 82, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_Colour = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("CameraWipe", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 82, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.CameraWipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_16CameraWipe(__pyx_self, __pyx_v_self, __pyx_v_Colour);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_16CameraWipe(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Colour) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("CameraWipe", 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_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.CameraWipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple_ = PyTuple_Pack(3, __pyx_int_0, __pyx_int_0, __pyx_int_0); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple_);
+  __Pyx_GIVEREF(__pyx_tuple_);
+/* … */
+  __pyx_tuple__49 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_Colour); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__49);
+  __Pyx_GIVEREF(__pyx_tuple__49);
+  __pyx_codeobj__50 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__49, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_CameraWipe, 82, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__50)) __PYX_ERR(0, 82, __pyx_L1_error)
+/* … */
+  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_17CameraWipe, 0, __pyx_n_s_Camera_CameraWipe, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__50)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__51);
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_CameraWipe, __pyx_t_3) < 0) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_tuple__51 = PyTuple_Pack(1, ((PyObject*)__pyx_tuple_)); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__51);
+  __Pyx_GIVEREF(__pyx_tuple__51);
+
+083:         self.gameDisplay.fill(Colour)
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_gameDisplay); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_fill); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 83, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_Colour); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Colour};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Colour};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 83, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      __Pyx_INCREF(__pyx_v_Colour);
+      __Pyx_GIVEREF(__pyx_v_Colour);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_Colour);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+084:     def ResetDrawObject(self):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_19ResetDrawObject(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_19ResetDrawObject = {"ResetDrawObject", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_19ResetDrawObject, METH_O, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_19ResetDrawObject(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("ResetDrawObject (wrapper)", 0);
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_18ResetDrawObject(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_18ResetDrawObject(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("ResetDrawObject", 0);
+/* … */
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.ResetDrawObject", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__52 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__52);
+  __Pyx_GIVEREF(__pyx_tuple__52);
+/* … */
+  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_19ResetDrawObject, 0, __pyx_n_s_Camera_ResetDrawObject, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__53)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_ResetDrawObject, __pyx_t_3) < 0) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__53 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_ResetDrawObject, 84, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__53)) __PYX_ERR(0, 84, __pyx_L1_error)
+
+085:         self.DrawObjects = []
+
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_DrawObjects, __pyx_t_1) < 0) __PYX_ERR(0, 85, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+086:     def AddDrawObject(self,Object,ForceDraw):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_21AddDrawObject(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_21AddDrawObject = {"AddDrawObject", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_21AddDrawObject, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_21AddDrawObject(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_Object = 0;
+  PyObject *__pyx_v_ForceDraw = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("AddDrawObject (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_Object,&__pyx_n_s_ForceDraw,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Object)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("AddDrawObject", 1, 3, 3, 1); __PYX_ERR(0, 86, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ForceDraw)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("AddDrawObject", 1, 3, 3, 2); __PYX_ERR(0, 86, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "AddDrawObject") < 0)) __PYX_ERR(0, 86, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_Object = values[1];
+    __pyx_v_ForceDraw = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("AddDrawObject", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 86, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.AddDrawObject", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_20AddDrawObject(__pyx_self, __pyx_v_self, __pyx_v_Object, __pyx_v_ForceDraw);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_20AddDrawObject(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_Object, PyObject *__pyx_v_ForceDraw) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("AddDrawObject", 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_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.AddDrawObject", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__54 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_Object, __pyx_n_s_ForceDraw); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(0, 86, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__54);
+  __Pyx_GIVEREF(__pyx_tuple__54);
+/* … */
+  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_21AddDrawObject, 0, __pyx_n_s_Camera_AddDrawObject, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__55)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_AddDrawObject, __pyx_t_3) < 0) __PYX_ERR(0, 86, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__55 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__54, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_AddDrawObject, 86, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__55)) __PYX_ERR(0, 86, __pyx_L1_error)
+
+087:         self.DrawObjects.append({"Object":Object,"ForceDraw":ForceDraw})
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_DrawObjects); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_Object, __pyx_v_Object) < 0) __PYX_ERR(0, 87, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_ForceDraw, __pyx_v_ForceDraw) < 0) __PYX_ERR(0, 87, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_Append(__pyx_t_1, __pyx_t_2); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(0, 87, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
 088:
+
+089:     def Get_Coord(self):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_23Get_Coord(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_23Get_Coord = {"Get_Coord", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_23Get_Coord, METH_O, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_23Get_Coord(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("Get_Coord (wrapper)", 0);
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_22Get_Coord(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_22Get_Coord(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("Get_Coord", 0);
+/* … */
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.Get_Coord", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__56 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(0, 89, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__56);
+  __Pyx_GIVEREF(__pyx_tuple__56);
+/* … */
+  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_23Get_Coord, 0, __pyx_n_s_Camera_Get_Coord, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__57)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_Get_Coord, __pyx_t_3) < 0) __PYX_ERR(0, 89, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__57 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__56, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_Get_Coord, 89, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__57)) __PYX_ERR(0, 89, __pyx_L1_error)
+
+090:         return self.CameraCoord
+
  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
 091:
+
+092:     def Draw(self):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_25Draw(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_25Draw = {"Draw", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_25Draw, METH_O, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_6Camera_25Draw(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("Draw (wrapper)", 0);
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_24Draw(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6Camera_24Draw(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  float __pyx_v_CameraEndX;
+  float __pyx_v_CameraEndY;
+  float __pyx_v_CameraX;
+  float __pyx_v_CameraY;
+  float __pyx_v_CameraXSize;
+  float __pyx_v_CameraYSize;
+  float __pyx_v_x;
+  float __pyx_v_y;
+  float __pyx_v_xSize;
+  float __pyx_v_ySize;
+  float __pyx_v_PosX;
+  float __pyx_v_PosY;
+  int __pyx_v_width;
+  int __pyx_v_height;
+  int __pyx_v_xpixel;
+  int __pyx_v_ypixel;
+  int __pyx_v_font_size;
+  PyObject *__pyx_v_DrawObject = NULL;
+  PyObject *__pyx_v_Object = NULL;
+  PyObject *__pyx_v_Object_Coords = NULL;
+  PyObject *__pyx_v_image = NULL;
+  PyObject *__pyx_v_font = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("Draw", 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_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Camera.Draw", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_DrawObject);
+  __Pyx_XDECREF(__pyx_v_Object);
+  __Pyx_XDECREF(__pyx_v_Object_Coords);
+  __Pyx_XDECREF(__pyx_v_image);
+  __Pyx_XDECREF(__pyx_v_font);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__58 = PyTuple_Pack(23, __pyx_n_s_self, __pyx_n_s_CameraEndX, __pyx_n_s_CameraEndY, __pyx_n_s_CameraX, __pyx_n_s_CameraY, __pyx_n_s_CameraXSize, __pyx_n_s_CameraYSize, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_xSize, __pyx_n_s_ySize, __pyx_n_s_PosX, __pyx_n_s_PosY, __pyx_n_s_width, __pyx_n_s_height, __pyx_n_s_xpixel, __pyx_n_s_ypixel, __pyx_n_s_font_size, __pyx_n_s_DrawObject, __pyx_n_s_Object, __pyx_n_s_Object_Coords, __pyx_n_s_image, __pyx_n_s_font); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(0, 92, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__58);
+  __Pyx_GIVEREF(__pyx_tuple__58);
+/* … */
+  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_6Camera_25Draw, 0, __pyx_n_s_Camera_Draw, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__59)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 92, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_Draw, __pyx_t_3) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__59 = (PyObject*)__Pyx_PyCode_New(1, 0, 23, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__58, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_Draw, 92, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__59)) __PYX_ERR(0, 92, __pyx_L1_error)
+
 093:         cdef float CameraEndX,CameraEndY,CameraX,CameraY,CameraXSize,CameraYSize,x,y,xSize,ySize,PosX,PosY
+
 094:         cdef int width,height,xpixel,ypixel,font_size
+
 095:
+
+096:         CameraEndX= self.CameraCoord.Get_X() + self.CameraCoord.Get_XSize()    #Moved to new variablt to reduce recalculation
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 96, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 96, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 96, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_CameraEndX = __pyx_t_5;
+
+097:         CameraEndY = self.CameraCoord.Get_Y() + self.CameraCoord.Get_YSize()
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  if (__pyx_t_3) {
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Get_YSize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 97, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_CameraEndY = __pyx_t_5;
+
+098:         CameraX = self.CameraCoord.Get_X()
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (__pyx_t_1) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 98, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_CameraX = __pyx_t_5;
+
+099:         CameraY = self.CameraCoord.Get_Y()
+
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 99, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 99, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_CameraY = __pyx_t_5;
+
+100:         CameraXSize = self.CameraCoord.Get_XSize()
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 100, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 100, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (__pyx_t_1) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 100, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_CameraXSize = __pyx_t_5;
+
+101:         CameraYSize = self.CameraCoord.Get_YSize()
+
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Get_YSize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 101, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_CameraYSize = __pyx_t_5;
+
+102:         xpixel,ypixel = self.xpixel,self.ypixel
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_xpixel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 102, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ypixel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 102, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_xpixel = __pyx_t_6;
+  __pyx_v_ypixel = __pyx_t_7;
+
 103:
+
+104:         for DrawObject in self.DrawObjects:
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_DrawObjects); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
+    __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_8 = 0;
+    __pyx_t_9 = NULL;
+  } else {
+    __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 104, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_9 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 104, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  for (;;) {
+    if (likely(!__pyx_t_9)) {
+      if (likely(PyList_CheckExact(__pyx_t_1))) {
+        if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_1)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_2); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 104, __pyx_L1_error)
+        #else
+        __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        #endif
+      } else {
+        if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_2); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 104, __pyx_L1_error)
+        #else
+        __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        #endif
+      }
+    } else {
+      __pyx_t_2 = __pyx_t_9(__pyx_t_1);
+      if (unlikely(!__pyx_t_2)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 104, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_DrawObject, __pyx_t_2);
+    __pyx_t_2 = 0;
+/* … */
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+105:             Object = DrawObject["Object"]
+
    __pyx_t_2 = PyObject_GetItem(__pyx_v_DrawObject, __pyx_n_s_Object); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_Object, __pyx_t_2);
+    __pyx_t_2 = 0;
+
+106:             Object_Coords = Object.Get_Coords()
+
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object, __pyx_n_s_Get_Coords); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 106, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    if (__pyx_t_3) {
+      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else {
+      __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
+    }
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_Object_Coords, __pyx_t_2);
+    __pyx_t_2 = 0;
+
+107:             x = Object_Coords.Get_X()
+
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object_Coords, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 107, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    if (__pyx_t_3) {
+      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else {
+      __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error)
+    }
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 107, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_v_x = __pyx_t_5;
+
+108:             y = Object_Coords.Get_Y()
+
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object_Coords, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 108, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    if (__pyx_t_3) {
+      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else {
+      __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error)
+    }
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 108, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_v_y = __pyx_t_5;
+
+109:             xSize = Object_Coords.Get_XSize()
+
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object_Coords, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 109, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    if (__pyx_t_3) {
+      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else {
+      __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error)
+    }
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 109, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_v_xSize = __pyx_t_5;
+
+110:             ySize = Object_Coords.Get_YSize()
+
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object_Coords, __pyx_n_s_Get_YSize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 110, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    if (__pyx_t_3) {
+      __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else {
+      __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error)
+    }
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_5 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 110, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_v_ySize = __pyx_t_5;
+
+111:             if ((x < CameraEndX) and ((x+xSize) > CameraX)) and \
+
    __pyx_t_11 = ((__pyx_v_x < __pyx_v_CameraEndX) != 0);
+    if (__pyx_t_11) {
+    } else {
+      __pyx_t_10 = __pyx_t_11;
+      goto __pyx_L6_bool_binop_done;
+    }
+    __pyx_t_11 = (((__pyx_v_x + __pyx_v_xSize) > __pyx_v_CameraX) != 0);
+    if (__pyx_t_11) {
+    } else {
+      __pyx_t_10 = __pyx_t_11;
+      goto __pyx_L6_bool_binop_done;
+    }
+/* … */
+    if (__pyx_t_10) {
+/* … */
+    }
+
+112:                ((y < CameraEndY) and ((y+ySize) > CameraY )) :  #If DrawObject intersects with Camera , Render, otherwise ignore
+
    __pyx_t_11 = ((__pyx_v_y < __pyx_v_CameraEndY) != 0);
+    if (__pyx_t_11) {
+    } else {
+      __pyx_t_10 = __pyx_t_11;
+      goto __pyx_L6_bool_binop_done;
+    }
+    __pyx_t_11 = (((__pyx_v_y + __pyx_v_ySize) > __pyx_v_CameraY) != 0);
+    __pyx_t_10 = __pyx_t_11;
+    __pyx_L6_bool_binop_done:;
+
 113:
+
 114:
+
+115:                 width,height = int(xSize/CameraXSize*xpixel) ,int(ySize/CameraYSize*ypixel)  # Would benifit from being cythonised
+
      __pyx_v_width = ((int)((__pyx_v_xSize / __pyx_v_CameraXSize) * __pyx_v_xpixel));
+      __pyx_v_height = ((int)((__pyx_v_ySize / __pyx_v_CameraYSize) * __pyx_v_ypixel));
+
+116:                 if width > 0 and height > 0:
+
      __pyx_t_11 = ((__pyx_v_width > 0) != 0);
+      if (__pyx_t_11) {
+      } else {
+        __pyx_t_10 = __pyx_t_11;
+        goto __pyx_L11_bool_binop_done;
+      }
+      __pyx_t_11 = ((__pyx_v_height > 0) != 0);
+      __pyx_t_10 = __pyx_t_11;
+      __pyx_L11_bool_binop_done:;
+      if (__pyx_t_10) {
+/* … */
+      }
+
+117:                     PosX = ((x- CameraX)/CameraXSize)* xpixel  # Would benifit from being cythonised
+
        __pyx_v_PosX = (((__pyx_v_x - __pyx_v_CameraX) / __pyx_v_CameraXSize) * __pyx_v_xpixel);
+
+118:                     PosY = ((y- CameraY)/CameraYSize)* ypixel
+
        __pyx_v_PosY = (((__pyx_v_y - __pyx_v_CameraY) / __pyx_v_CameraYSize) * __pyx_v_ypixel);
+
+119:                     width = MaxLimit(width,xpixel)
+
        __pyx_v_width = __pyx_f_6CAStar_19AATC_Monitor_Viewer_MaxLimit(__pyx_v_width, __pyx_v_xpixel);
+
+120:                     height = MaxLimit(height,ypixel)
+
        __pyx_v_height = __pyx_f_6CAStar_19AATC_Monitor_Viewer_MaxLimit(__pyx_v_height, __pyx_v_ypixel);
+
+121:                     font_size = int(100*width/xpixel)          # Would benifit from being cythonised
+
        __pyx_v_font_size = ((int)((0x64 * __pyx_v_width) / __pyx_v_xpixel));
+
+122:                     image = Object.Make_Image(width,height)
+
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object, __pyx_n_s_Make_Image); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 122, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_width); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_12 = __Pyx_PyInt_From_int(__pyx_v_height); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 122, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __pyx_t_13 = NULL;
+        __pyx_t_7 = 0;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+          __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4);
+          if (likely(__pyx_t_13)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+            __Pyx_INCREF(__pyx_t_13);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_4, function);
+            __pyx_t_7 = 1;
+          }
+        }
+        #if CYTHON_FAST_PYCALL
+        if (PyFunction_Check(__pyx_t_4)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_13, __pyx_t_3, __pyx_t_12};
+          __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_13, __pyx_t_3, __pyx_t_12};
+          __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+        } else
+        #endif
+        {
+          __pyx_t_14 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 122, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_14);
+          if (__pyx_t_13) {
+            __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_13); __pyx_t_13 = NULL;
+          }
+          __Pyx_GIVEREF(__pyx_t_3);
+          PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_7, __pyx_t_3);
+          __Pyx_GIVEREF(__pyx_t_12);
+          PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_7, __pyx_t_12);
+          __pyx_t_3 = 0;
+          __pyx_t_12 = 0;
+          __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_14, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+        }
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_XDECREF_SET(__pyx_v_image, __pyx_t_2);
+        __pyx_t_2 = 0;
+
+123:                     self.gameDisplay.blit(image,(PosX,PosY))
+
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_gameDisplay); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_blit); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 123, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_14);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __pyx_t_4 = PyFloat_FromDouble(__pyx_v_PosX); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_12 = PyFloat_FromDouble(__pyx_v_PosY); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 123, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_12);
+        __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 123, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_12);
+        PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_12);
+        __pyx_t_4 = 0;
+        __pyx_t_12 = 0;
+        __pyx_t_12 = NULL;
+        __pyx_t_7 = 0;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_14))) {
+          __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_14);
+          if (likely(__pyx_t_12)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14);
+            __Pyx_INCREF(__pyx_t_12);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_14, function);
+            __pyx_t_7 = 1;
+          }
+        }
+        #if CYTHON_FAST_PYCALL
+        if (PyFunction_Check(__pyx_t_14)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_v_image, __pyx_t_3};
+          __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_14)) {
+          PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_v_image, __pyx_t_3};
+          __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        } else
+        #endif
+        {
+          __pyx_t_4 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          if (__pyx_t_12) {
+            __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_12); __pyx_t_12 = NULL;
+          }
+          __Pyx_INCREF(__pyx_v_image);
+          __Pyx_GIVEREF(__pyx_v_image);
+          PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_7, __pyx_v_image);
+          __Pyx_GIVEREF(__pyx_t_3);
+          PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_7, __pyx_t_3);
+          __pyx_t_3 = 0;
+          __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        }
+        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+124:                     if font_size > 5:
+
        __pyx_t_10 = ((__pyx_v_font_size > 5) != 0);
+        if (__pyx_t_10) {
+/* … */
+        }
+
+125:                         font = (None, font_size)
+
          __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_font_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __pyx_t_14 = PyTuple_New(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 125, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_14);
+          __Pyx_INCREF(Py_None);
+          __Pyx_GIVEREF(Py_None);
+          PyTuple_SET_ITEM(__pyx_t_14, 0, Py_None);
+          __Pyx_GIVEREF(__pyx_t_2);
+          PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_2);
+          __pyx_t_2 = 0;
+          __Pyx_XDECREF_SET(__pyx_v_font, ((PyObject*)__pyx_t_14));
+          __pyx_t_14 = 0;
+
+126:                         self.gameDisplay.blit(Object.Make_Text(font) ,(PosX+width,PosY))
+
          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_gameDisplay); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_blit); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 126, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Object, __pyx_n_s_Make_Text); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __pyx_t_12 = NULL;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+            __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_3);
+            if (likely(__pyx_t_12)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+              __Pyx_INCREF(__pyx_t_12);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_3, function);
+            }
+          }
+          if (!__pyx_t_12) {
+            __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_font); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_2);
+          } else {
+            #if CYTHON_FAST_PYCALL
+            if (PyFunction_Check(__pyx_t_3)) {
+              PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_v_font};
+              __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
+              __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+              __Pyx_GOTREF(__pyx_t_2);
+            } else
+            #endif
+            #if CYTHON_FAST_PYCCALL
+            if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+              PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_v_font};
+              __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
+              __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+              __Pyx_GOTREF(__pyx_t_2);
+            } else
+            #endif
+            {
+              __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 126, __pyx_L1_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __pyx_t_12 = NULL;
+              __Pyx_INCREF(__pyx_v_font);
+              __Pyx_GIVEREF(__pyx_v_font);
+              PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_v_font);
+              __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
+              __Pyx_GOTREF(__pyx_t_2);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            }
+          }
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          __pyx_t_3 = PyFloat_FromDouble((__pyx_v_PosX + __pyx_v_width)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __pyx_t_13 = PyFloat_FromDouble(__pyx_v_PosY); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 126, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_13);
+          __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 126, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_12);
+          __Pyx_GIVEREF(__pyx_t_3);
+          PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_3);
+          __Pyx_GIVEREF(__pyx_t_13);
+          PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_13);
+          __pyx_t_3 = 0;
+          __pyx_t_13 = 0;
+          __pyx_t_13 = NULL;
+          __pyx_t_7 = 0;
+          if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+            __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4);
+            if (likely(__pyx_t_13)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+              __Pyx_INCREF(__pyx_t_13);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_4, function);
+              __pyx_t_7 = 1;
+            }
+          }
+          #if CYTHON_FAST_PYCALL
+          if (PyFunction_Check(__pyx_t_4)) {
+            PyObject *__pyx_temp[3] = {__pyx_t_13, __pyx_t_2, __pyx_t_12};
+            __pyx_t_14 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 126, __pyx_L1_error)
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_GOTREF(__pyx_t_14);
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+          } else
+          #endif
+          #if CYTHON_FAST_PYCCALL
+          if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+            PyObject *__pyx_temp[3] = {__pyx_t_13, __pyx_t_2, __pyx_t_12};
+            __pyx_t_14 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 126, __pyx_L1_error)
+            __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_GOTREF(__pyx_t_14);
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+          } else
+          #endif
+          {
+            __pyx_t_3 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 126, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            if (__pyx_t_13) {
+              __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_13); __pyx_t_13 = NULL;
+            }
+            __Pyx_GIVEREF(__pyx_t_2);
+            PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_7, __pyx_t_2);
+            __Pyx_GIVEREF(__pyx_t_12);
+            PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_7, __pyx_t_12);
+            __pyx_t_2 = 0;
+            __pyx_t_12 = 0;
+            __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, NULL); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 126, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_14);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          }
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+
 127:
+
 128:
+
 129:
+
 130:
+
 131:
+
 132:
+
+133: class Monitor_Sprite(pygame.sprite.Sprite):
+
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sprite); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Sprite); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_3, __pyx_n_s_Monitor_Sprite, __pyx_n_s_Monitor_Sprite, (PyObject *) NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+/* … */
+  __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_Monitor_Sprite, __pyx_t_3, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_Monitor_Sprite, __pyx_t_4) < 0) __PYX_ERR(0, 133, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+134:     def __init__(self,CoordObject,Type = "",Text = "",Colour = (255,255,255)):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_1__init__ = {"__init__", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_1__init__, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_CoordObject = 0;
+  PyObject *__pyx_v_Type = 0;
+  PyObject *__pyx_v_Text = 0;
+  PyObject *__pyx_v_Colour = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_CoordObject,&__pyx_n_s_Type,&__pyx_n_s_Text,&__pyx_n_s_Colour,0};
+    PyObject* values[5] = {0,0,0,0,0};
+    values[2] = ((PyObject *)((PyObject*)__pyx_kp_s__2));
+    values[3] = ((PyObject *)((PyObject*)__pyx_kp_s__2));
+    values[4] = ((PyObject *)((PyObject*)__pyx_tuple__3));
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        CYTHON_FALLTHROUGH;
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        CYTHON_FALLTHROUGH;
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_CoordObject)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, 1); __PYX_ERR(0, 134, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Type);
+          if (value) { values[2] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Text);
+          if (value) { values[3] = value; kw_args--; }
+        }
+        CYTHON_FALLTHROUGH;
+        case  4:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Colour);
+          if (value) { values[4] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 134, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        CYTHON_FALLTHROUGH;
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        CYTHON_FALLTHROUGH;
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_CoordObject = values[1];
+    __pyx_v_Type = values[2];
+    __pyx_v_Text = values[3];
+    __pyx_v_Colour = values[4];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 134, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite___init__(__pyx_self, __pyx_v_self, __pyx_v_CoordObject, __pyx_v_Type, __pyx_v_Text, __pyx_v_Colour);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_CoordObject, PyObject *__pyx_v_Type, PyObject *__pyx_v_Text, PyObject *__pyx_v_Colour) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__init__", 0);
+/* … */
+  __pyx_tuple__3 = PyTuple_Pack(3, __pyx_int_255, __pyx_int_255, __pyx_int_255); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+/* … */
+  /* 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("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__60 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_CoordObject, __pyx_n_s_Type, __pyx_n_s_Text, __pyx_n_s_Colour); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__60);
+  __Pyx_GIVEREF(__pyx_tuple__60);
+  __pyx_codeobj__61 = (PyObject*)__Pyx_PyCode_New(5, 0, 5, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__60, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_init_2, 134, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__61)) __PYX_ERR(0, 134, __pyx_L1_error)
+/* … */
+  __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_1__init__, 0, __pyx_n_s_Monitor_Sprite___init, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__61)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__62);
+  if (PyObject_SetItem(__pyx_t_2, __pyx_n_s_init_2, __pyx_t_4) < 0) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_tuple__62 = PyTuple_Pack(3, ((PyObject*)__pyx_kp_s__2), ((PyObject*)__pyx_kp_s__2), ((PyObject*)__pyx_tuple__3)); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(0, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__62);
+  __Pyx_GIVEREF(__pyx_tuple__62);
+
+135:         self.Coords = CoordObject
+
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Coords, __pyx_v_CoordObject) < 0) __PYX_ERR(0, 135, __pyx_L1_error)
+
+136:         self.Type = Type
+
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Type, __pyx_v_Type) < 0) __PYX_ERR(0, 136, __pyx_L1_error)
+
+137:         self.Text = Text
+
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Text, __pyx_v_Text) < 0) __PYX_ERR(0, 137, __pyx_L1_error)
+
+138:         self.Colour = Colour
+
  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Colour, __pyx_v_Colour) < 0) __PYX_ERR(0, 138, __pyx_L1_error)
+
+139:         self.image = pygame.Surface((1,1))
+
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Surface); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+/* … */
+  __pyx_tuple__4 = PyTuple_Pack(2, __pyx_int_1, __pyx_int_1); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_image, __pyx_t_1) < 0) __PYX_ERR(0, 139, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_tuple__4); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+
 140:         #self.Make_Image(2,2)     # No longer needed, is similar to that above.
+
 141:
+
+142:     def Make_Image(self, int width, int height):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_3Make_Image(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_3Make_Image = {"Make_Image", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_3Make_Image, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_3Make_Image(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  int __pyx_v_width;
+  int __pyx_v_height;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("Make_Image (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_width,&__pyx_n_s_height,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_width)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("Make_Image", 1, 3, 3, 1); __PYX_ERR(0, 142, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_height)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("Make_Image", 1, 3, 3, 2); __PYX_ERR(0, 142, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "Make_Image") < 0)) __PYX_ERR(0, 142, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_width = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_width == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 142, __pyx_L3_error)
+    __pyx_v_height = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_height == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 142, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("Make_Image", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 142, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.Make_Image", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_2Make_Image(__pyx_self, __pyx_v_self, __pyx_v_width, __pyx_v_height);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_2Make_Image(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, int __pyx_v_width, int __pyx_v_height) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("Make_Image", 0);
+/* … */
+  /* 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_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.Make_Image", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__63 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_width, __pyx_n_s_height); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__63);
+  __Pyx_GIVEREF(__pyx_tuple__63);
+/* … */
+  __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_3Make_Image, 0, __pyx_n_s_Monitor_Sprite_Make_Image, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__64)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyObject_SetItem(__pyx_t_2, __pyx_n_s_Make_Image, __pyx_t_4) < 0) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_codeobj__64 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__63, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_Make_Image, 142, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__64)) __PYX_ERR(0, 142, __pyx_L1_error)
+
+143:         if self.image.get_size() != (width,height):  #If new image does not match with previous
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_image); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_width); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_height); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
+  __pyx_t_3 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__pyx_t_5) {
+/* … */
+  }
+
+144:             self.image = GetImage(width,height,self.Colour)
+
    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_GetImage); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 144, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_width); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_height); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 144, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Colour); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 144, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = NULL;
+    __pyx_t_8 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+        __pyx_t_8 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_1, __pyx_t_3, __pyx_t_6};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_1, __pyx_t_3, __pyx_t_6};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 144, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      if (__pyx_t_7) {
+        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_1);
+      PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_1);
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_t_6);
+      __pyx_t_1 = 0;
+      __pyx_t_3 = 0;
+      __pyx_t_6 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_image, __pyx_t_2) < 0) __PYX_ERR(0, 144, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
 145:
+
+146:         return self.image
+
  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_image); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
 147: ##            self.image = pygame.Surface((width,height)).convert()
+
 148: ##            self.image.fill(self.Colour)
+
 149:
+
+150:     def Make_Text(self,font):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_5Make_Text(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_5Make_Text = {"Make_Text", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_5Make_Text, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_5Make_Text(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_font = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("Make_Text (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_font,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_font)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("Make_Text", 1, 2, 2, 1); __PYX_ERR(0, 150, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "Make_Text") < 0)) __PYX_ERR(0, 150, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_font = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("Make_Text", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 150, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.Make_Text", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_4Make_Text(__pyx_self, __pyx_v_self, __pyx_v_font);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_4Make_Text(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_font) {
+  PyObject *__pyx_v_text = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("Make_Text", 0);
+/* … */
+  /* 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("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.Make_Text", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_text);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__65 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_font, __pyx_n_s_text); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__65);
+  __Pyx_GIVEREF(__pyx_tuple__65);
+/* … */
+  __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_5Make_Text, 0, __pyx_n_s_Monitor_Sprite_Make_Text, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__66)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyObject_SetItem(__pyx_t_2, __pyx_n_s_Make_Text, __pyx_t_4) < 0) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_codeobj__66 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__65, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_Make_Text, 150, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__66)) __PYX_ERR(0, 150, __pyx_L1_error)
+
+151:         text = str((self.Coords.Get_X(),self.Coords.Get_Y(),self.Coords.Get_Z())) +" " +self.Text + " "+ self.Type
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Coords); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Coords); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Coords); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_Z); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_kp_s__6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Text); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyNumber_Add(__pyx_t_3, __pyx_kp_s__6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyNumber_Add(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_text = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+152:         return GetText(text,font,False,self.Colour)
+
  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_GetText); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Colour); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[5] = {__pyx_t_1, __pyx_v_text, __pyx_v_font, Py_False, __pyx_t_5};
+    __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+    PyObject *__pyx_temp[5] = {__pyx_t_1, __pyx_v_text, __pyx_v_font, Py_False, __pyx_t_5};
+    __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_6, 4+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_2 = PyTuple_New(4+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    if (__pyx_t_1) {
+      __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); __pyx_t_1 = NULL;
+    }
+    __Pyx_INCREF(__pyx_v_text);
+    __Pyx_GIVEREF(__pyx_v_text);
+    PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_6, __pyx_v_text);
+    __Pyx_INCREF(__pyx_v_font);
+    __Pyx_GIVEREF(__pyx_v_font);
+    PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_6, __pyx_v_font);
+    __Pyx_INCREF(Py_False);
+    __Pyx_GIVEREF(Py_False);
+    PyTuple_SET_ITEM(__pyx_t_2, 2+__pyx_t_6, Py_False);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_2, 3+__pyx_t_6, __pyx_t_5);
+    __pyx_t_5 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
 153:
+
+154:     def Get_Coords(self):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_7Get_Coords(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_7Get_Coords = {"Get_Coords", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_7Get_Coords, METH_O, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_7Get_Coords(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("Get_Coords (wrapper)", 0);
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_6Get_Coords(__pyx_self, ((PyObject *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_6Get_Coords(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("Get_Coords", 0);
+/* … */
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.Monitor_Sprite.Get_Coords", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__67 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__67);
+  __Pyx_GIVEREF(__pyx_tuple__67);
+/* … */
+  __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_14Monitor_Sprite_7Get_Coords, 0, __pyx_n_s_Monitor_Sprite_Get_Coords, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer, __pyx_d, ((PyObject *)__pyx_codeobj__68)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyObject_SetItem(__pyx_t_2, __pyx_n_s_Get_Coords, __pyx_t_4) < 0) __PYX_ERR(0, 154, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_codeobj__68 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__67, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_Get_Coords, 154, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__68)) __PYX_ERR(0, 154, __pyx_L1_error)
+
+155:         return self.Coords
+
  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Coords); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
 156: ##
+
 157: ##    def Make_CoordsText(self,font):
+
 158: ##        self.CoordsText = GetText(str((self.Coords.x,self.Coords.y,self.Coords.z)),font,False,self.Colour)
+
 159: ##        #self.CoordsText = font.render(str((self.Coords.x,self.Coords.y,self.Coords.z)),False,self.Colour)
+
 160: ##
+
 161: ##    def Make_Text(self,font):
+
 162: ##        self.DrawnText = GetText(self.Text,font,False,self.Colour)
+
 163: ##        #self.DrawnText = font.render(self.Text,False,self.Colour)
+
 164: ##
+
 165: ##    def Make_Type(self,font):
+
 166: ##        self.DrawnType = GetText(self.Type,font,False,self.Colour)
+
 167: ##        #self.DrawnType = font.render(self.Type,False,self.Colour)
+
 168:
+
 169:
+
+170: def MakeDroneSprites(Message,RawDroneList):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_7MakeDroneSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_7MakeDroneSprites = {"MakeDroneSprites", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_7MakeDroneSprites, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_7MakeDroneSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_Message = 0;
+  PyObject *__pyx_v_RawDroneList = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("MakeDroneSprites (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Message,&__pyx_n_s_RawDroneList,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Message)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_RawDroneList)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("MakeDroneSprites", 1, 2, 2, 1); __PYX_ERR(0, 170, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MakeDroneSprites") < 0)) __PYX_ERR(0, 170, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_Message = values[0];
+    __pyx_v_RawDroneList = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("MakeDroneSprites", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 170, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeDroneSprites", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_6MakeDroneSprites(__pyx_self, __pyx_v_Message, __pyx_v_RawDroneList);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_6MakeDroneSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Message, PyObject *__pyx_v_RawDroneList) {
+  PyObject *__pyx_v_DroneList = NULL;
+  PyObject *__pyx_v_Columns = NULL;
+  PyObject *__pyx_v_CoordIndex = NULL;
+  PyObject *__pyx_v_DroneIDIndex = NULL;
+  PyObject *__pyx_v_UserIDIndex = NULL;
+  PyObject *__pyx_v_DroneNameIndex = NULL;
+  PyObject *__pyx_v_BatteryIndex = NULL;
+  PyObject *__pyx_v_Drone = NULL;
+  PyObject *__pyx_v_LastCoords = NULL;
+  PyObject *__pyx_v_Coord = NULL;
+  PyObject *__pyx_v_Text = NULL;
+  __pyx_ctuple_long__and_long__and_long __pyx_v_Colour;
+  PyObject *__pyx_v_Sprite = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("MakeDroneSprites", 0);
+/* … */
+  /* 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_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeDroneSprites", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_DroneList);
+  __Pyx_XDECREF(__pyx_v_Columns);
+  __Pyx_XDECREF(__pyx_v_CoordIndex);
+  __Pyx_XDECREF(__pyx_v_DroneIDIndex);
+  __Pyx_XDECREF(__pyx_v_UserIDIndex);
+  __Pyx_XDECREF(__pyx_v_DroneNameIndex);
+  __Pyx_XDECREF(__pyx_v_BatteryIndex);
+  __Pyx_XDECREF(__pyx_v_Drone);
+  __Pyx_XDECREF(__pyx_v_LastCoords);
+  __Pyx_XDECREF(__pyx_v_Coord);
+  __Pyx_XDECREF(__pyx_v_Text);
+  __Pyx_XDECREF(__pyx_v_Sprite);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__69 = PyTuple_Pack(15, __pyx_n_s_Message, __pyx_n_s_RawDroneList, __pyx_n_s_DroneList, __pyx_n_s_Columns, __pyx_n_s_CoordIndex, __pyx_n_s_DroneIDIndex, __pyx_n_s_UserIDIndex, __pyx_n_s_DroneNameIndex, __pyx_n_s_BatteryIndex, __pyx_n_s_Drone, __pyx_n_s_LastCoords, __pyx_n_s_Coord, __pyx_n_s_Text, __pyx_n_s_Colour, __pyx_n_s_Sprite); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__69);
+  __Pyx_GIVEREF(__pyx_tuple__69);
+/* … */
+  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_7MakeDroneSprites, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MakeDroneSprites, __pyx_t_3) < 0) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__70 = (PyObject*)__Pyx_PyCode_New(2, 0, 15, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__69, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_MakeDroneSprites, 170, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__70)) __PYX_ERR(0, 170, __pyx_L1_error)
+
+171:     DroneList = []
+
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 171, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_DroneList = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+172:     Columns = ast.literal_eval(Message)
+
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_Message); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 172, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      __Pyx_INCREF(__pyx_v_Message);
+      __Pyx_GIVEREF(__pyx_v_Message);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_Message);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_Columns = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+173:     CoordIndex = Columns.index("LastCoords")
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_CoordIndex = __pyx_t_3;
+  __pyx_t_3 = 0;
+/* … */
+  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_n_s_LastCoords); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
+
+174:     DroneIDIndex = Columns.index("DroneID")
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_DroneIDIndex = __pyx_t_1;
+  __pyx_t_1 = 0;
+/* … */
+  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_n_s_DroneID); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__8);
+  __Pyx_GIVEREF(__pyx_tuple__8);
+
+175:     UserIDIndex = Columns.index("UserID")
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_UserIDIndex = __pyx_t_3;
+  __pyx_t_3 = 0;
+/* … */
+  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_n_s_UserID); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__9);
+  __Pyx_GIVEREF(__pyx_tuple__9);
+
+176:     DroneNameIndex = Columns.index("DroneName")
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_DroneNameIndex = __pyx_t_1;
+  __pyx_t_1 = 0;
+/* … */
+  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_n_s_DroneName); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__10);
+  __Pyx_GIVEREF(__pyx_tuple__10);
+
+177:     BatteryIndex = Columns.index("LastBattery")
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_BatteryIndex = __pyx_t_3;
+  __pyx_t_3 = 0;
+/* … */
+  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_n_s_LastBattery); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__11);
+  __Pyx_GIVEREF(__pyx_tuple__11);
+
+178:     for Drone in RawDroneList:
+
  if (likely(PyList_CheckExact(__pyx_v_RawDroneList)) || PyTuple_CheckExact(__pyx_v_RawDroneList)) {
+    __pyx_t_3 = __pyx_v_RawDroneList; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
+  } else {
+    __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_RawDroneList); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 178, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_6)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 178, __pyx_L1_error)
+        #else
+        __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        #endif
+      } else {
+        if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 178, __pyx_L1_error)
+        #else
+        __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        #endif
+      }
+    } else {
+      __pyx_t_1 = __pyx_t_6(__pyx_t_3);
+      if (unlikely(!__pyx_t_1)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 178, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_Drone, __pyx_t_1);
+    __pyx_t_1 = 0;
+/* … */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+179:         LastCoords = ast.literal_eval(Drone[CoordIndex])
+
    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 179, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = PyObject_GetItem(__pyx_v_Drone, __pyx_v_CoordIndex); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    if (!__pyx_t_7) {
+      __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4};
+        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4};
+        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 179, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4);
+        __pyx_t_4 = 0;
+        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 179, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_LastCoords, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+180:         Coord = AATC_Coordinate.Coordinate(LastCoords[0],LastCoords[1],LastCoords[2],0.001,0.001,0.00001)
+
    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 180, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 180, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_LastCoords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 180, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_LastCoords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 180, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_LastCoords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 180, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_9 = NULL;
+    __pyx_t_10 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_8, function);
+        __pyx_t_10 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_8)) {
+      PyObject *__pyx_temp[7] = {__pyx_t_9, __pyx_t_2, __pyx_t_4, __pyx_t_7, __pyx_float_0_001, __pyx_float_0_001, __pyx_float_0_00001};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) {
+      PyObject *__pyx_temp[7] = {__pyx_t_9, __pyx_t_2, __pyx_t_4, __pyx_t_7, __pyx_float_0_001, __pyx_float_0_001, __pyx_float_0_00001};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_11 = PyTuple_New(6+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 180, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      if (__pyx_t_9) {
+        __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_2);
+      PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_2);
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_7);
+      PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_t_7);
+      __Pyx_INCREF(__pyx_float_0_001);
+      __Pyx_GIVEREF(__pyx_float_0_001);
+      PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_10, __pyx_float_0_001);
+      __Pyx_INCREF(__pyx_float_0_001);
+      __Pyx_GIVEREF(__pyx_float_0_001);
+      PyTuple_SET_ITEM(__pyx_t_11, 4+__pyx_t_10, __pyx_float_0_001);
+      __Pyx_INCREF(__pyx_float_0_00001);
+      __Pyx_GIVEREF(__pyx_float_0_00001);
+      PyTuple_SET_ITEM(__pyx_t_11, 5+__pyx_t_10, __pyx_float_0_00001);
+      __pyx_t_2 = 0;
+      __pyx_t_4 = 0;
+      __pyx_t_7 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_Coord, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+181:         Text = "D:"+str(Drone[DroneIDIndex]) +" U:"+str(Drone[UserIDIndex]) +" N:"+str(Drone[DroneNameIndex])+" B:"+str(Drone[BatteryIndex])
+
    __pyx_t_1 = PyObject_GetItem(__pyx_v_Drone, __pyx_v_DroneIDIndex); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1);
+    __pyx_t_1 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_8 = PyNumber_Add(__pyx_kp_s_D, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_kp_s_U); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_8 = PyObject_GetItem(__pyx_v_Drone, __pyx_v_UserIDIndex); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __Pyx_GIVEREF(__pyx_t_8);
+    PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8);
+    __pyx_t_8 = 0;
+    __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __pyx_t_11 = PyNumber_Add(__pyx_t_1, __pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_8 = PyNumber_Add(__pyx_t_11, __pyx_kp_s_N); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __pyx_t_11 = PyObject_GetItem(__pyx_v_Drone, __pyx_v_DroneNameIndex); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_11);
+    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_11);
+    __pyx_t_11 = 0;
+    __pyx_t_11 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __pyx_t_11 = PyNumber_Add(__pyx_t_1, __pyx_kp_s_B); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = PyObject_GetItem(__pyx_v_Drone, __pyx_v_BatteryIndex); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1);
+    __pyx_t_1 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_8 = PyNumber_Add(__pyx_t_11, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_Text, __pyx_t_8);
+    __pyx_t_8 = 0;
+
+182:         Colour = (255,255,255)
+
    __pyx_t_12.f0 = 0xFF;
+    __pyx_t_12.f1 = 0xFF;
+    __pyx_t_12.f2 = 0xFF;
+    __pyx_v_Colour = __pyx_t_12;
+
+183:         Sprite = Monitor_Sprite(Coord,"Drone",Text,Colour)
+
    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_Monitor_Sprite); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 183, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_11 = __pyx_convert__to_py___pyx_ctuple_long__and_long__and_long(__pyx_v_Colour); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 183, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __pyx_t_7 = NULL;
+    __pyx_t_10 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_1, function);
+        __pyx_t_10 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_Coord, __pyx_n_s_Drone, __pyx_v_Text, __pyx_t_11};
+      __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 183, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_Coord, __pyx_n_s_Drone, __pyx_v_Text, __pyx_t_11};
+      __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 183, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(4+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (__pyx_t_7) {
+        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7); __pyx_t_7 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Coord);
+      __Pyx_GIVEREF(__pyx_v_Coord);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_10, __pyx_v_Coord);
+      __Pyx_INCREF(__pyx_n_s_Drone);
+      __Pyx_GIVEREF(__pyx_n_s_Drone);
+      PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_10, __pyx_n_s_Drone);
+      __Pyx_INCREF(__pyx_v_Text);
+      __Pyx_GIVEREF(__pyx_v_Text);
+      PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_10, __pyx_v_Text);
+      __Pyx_GIVEREF(__pyx_t_11);
+      PyTuple_SET_ITEM(__pyx_t_4, 3+__pyx_t_10, __pyx_t_11);
+      __pyx_t_11 = 0;
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 183, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_Sprite, __pyx_t_8);
+    __pyx_t_8 = 0;
+
+184:         DroneList.append(Sprite)
+
    __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_DroneList, __pyx_v_Sprite); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 184, __pyx_L1_error)
+
+185:     return DroneList
+
  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_DroneList);
+  __pyx_r = __pyx_v_DroneList;
+  goto __pyx_L0;
+
 186:
+
+187: def MakeFlightSprites(Message,RawFlightList):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_9MakeFlightSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_9MakeFlightSprites = {"MakeFlightSprites", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_9MakeFlightSprites, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_9MakeFlightSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_Message = 0;
+  PyObject *__pyx_v_RawFlightList = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("MakeFlightSprites (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Message,&__pyx_n_s_RawFlightList,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Message)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_RawFlightList)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("MakeFlightSprites", 1, 2, 2, 1); __PYX_ERR(0, 187, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MakeFlightSprites") < 0)) __PYX_ERR(0, 187, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_Message = values[0];
+    __pyx_v_RawFlightList = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("MakeFlightSprites", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 187, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeFlightSprites", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_8MakeFlightSprites(__pyx_self, __pyx_v_Message, __pyx_v_RawFlightList);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_8MakeFlightSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Message, PyObject *__pyx_v_RawFlightList) {
+  PyObject *__pyx_v_FlightList = NULL;
+  PyObject *__pyx_v_Columns = NULL;
+  PyObject *__pyx_v_FlightIDIndex = NULL;
+  PyObject *__pyx_v_DroneIDIndex = NULL;
+  PyObject *__pyx_v_StartCoordsIndex = NULL;
+  PyObject *__pyx_v_EndCoordsIndex = NULL;
+  PyObject *__pyx_v_StartTimeIndex = NULL;
+  PyObject *__pyx_v_ETAIndex = NULL;
+  CYTHON_UNUSED PyObject *__pyx_v_EndTimeIndex = NULL;
+  CYTHON_UNUSED PyObject *__pyx_v_DistanceIndex = NULL;
+  PyObject *__pyx_v_Flight = NULL;
+  PyObject *__pyx_v_Coords = NULL;
+  PyObject *__pyx_v_Coord = NULL;
+  PyObject *__pyx_v_Text = NULL;
+  __pyx_ctuple_long__and_long__and_long __pyx_v_Colour;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("MakeFlightSprites", 0);
+/* … */
+  /* 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_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeFlightSprites", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_FlightList);
+  __Pyx_XDECREF(__pyx_v_Columns);
+  __Pyx_XDECREF(__pyx_v_FlightIDIndex);
+  __Pyx_XDECREF(__pyx_v_DroneIDIndex);
+  __Pyx_XDECREF(__pyx_v_StartCoordsIndex);
+  __Pyx_XDECREF(__pyx_v_EndCoordsIndex);
+  __Pyx_XDECREF(__pyx_v_StartTimeIndex);
+  __Pyx_XDECREF(__pyx_v_ETAIndex);
+  __Pyx_XDECREF(__pyx_v_EndTimeIndex);
+  __Pyx_XDECREF(__pyx_v_DistanceIndex);
+  __Pyx_XDECREF(__pyx_v_Flight);
+  __Pyx_XDECREF(__pyx_v_Coords);
+  __Pyx_XDECREF(__pyx_v_Coord);
+  __Pyx_XDECREF(__pyx_v_Text);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__71 = PyTuple_Pack(17, __pyx_n_s_Message, __pyx_n_s_RawFlightList, __pyx_n_s_FlightList, __pyx_n_s_Columns, __pyx_n_s_FlightIDIndex, __pyx_n_s_DroneIDIndex, __pyx_n_s_StartCoordsIndex, __pyx_n_s_EndCoordsIndex, __pyx_n_s_StartTimeIndex, __pyx_n_s_ETAIndex, __pyx_n_s_EndTimeIndex, __pyx_n_s_DistanceIndex, __pyx_n_s_Flight, __pyx_n_s_Coords, __pyx_n_s_Coord, __pyx_n_s_Text, __pyx_n_s_Colour); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__71);
+  __Pyx_GIVEREF(__pyx_tuple__71);
+/* … */
+  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_9MakeFlightSprites, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MakeFlightSprites, __pyx_t_3) < 0) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__72 = (PyObject*)__Pyx_PyCode_New(2, 0, 17, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__71, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_MakeFlightSprites, 187, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__72)) __PYX_ERR(0, 187, __pyx_L1_error)
+
+188:     FlightList = []
+
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_FlightList = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+189:     Columns = ast.literal_eval(Message)
+
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_Message); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 189, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      __Pyx_INCREF(__pyx_v_Message);
+      __Pyx_GIVEREF(__pyx_v_Message);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_Message);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 189, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_Columns = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+190:     FlightIDIndex = Columns.index("FlightID")
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_FlightIDIndex = __pyx_t_3;
+  __pyx_t_3 = 0;
+/* … */
+  __pyx_tuple__12 = PyTuple_Pack(1, __pyx_n_s_FlightID); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__12);
+  __Pyx_GIVEREF(__pyx_tuple__12);
+
+191:     DroneIDIndex = Columns.index("DroneID")
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_DroneIDIndex = __pyx_t_1;
+  __pyx_t_1 = 0;
+/* … */
+  __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_DroneID); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__13);
+  __Pyx_GIVEREF(__pyx_tuple__13);
+
+192:     StartCoordsIndex = Columns.index("StartCoords")
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_StartCoordsIndex = __pyx_t_3;
+  __pyx_t_3 = 0;
+/* … */
+  __pyx_tuple__14 = PyTuple_Pack(1, __pyx_n_s_StartCoords); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__14);
+  __Pyx_GIVEREF(__pyx_tuple__14);
+
+193:     EndCoordsIndex = Columns.index("EndCoords")
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_EndCoordsIndex = __pyx_t_1;
+  __pyx_t_1 = 0;
+/* … */
+  __pyx_tuple__15 = PyTuple_Pack(1, __pyx_n_s_EndCoords); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__15);
+  __Pyx_GIVEREF(__pyx_tuple__15);
+
+194:     StartTimeIndex = Columns.index("StartTime")
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_StartTimeIndex = __pyx_t_3;
+  __pyx_t_3 = 0;
+/* … */
+  __pyx_tuple__16 = PyTuple_Pack(1, __pyx_n_s_StartTime); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__16);
+  __Pyx_GIVEREF(__pyx_tuple__16);
+
+195:     ETAIndex = Columns.index("ETA")
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 195, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 195, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_ETAIndex = __pyx_t_1;
+  __pyx_t_1 = 0;
+/* … */
+  __pyx_tuple__17 = PyTuple_Pack(1, __pyx_n_s_ETA); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 195, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__17);
+  __Pyx_GIVEREF(__pyx_tuple__17);
+
+196:     EndTimeIndex = Columns.index("EndTime")
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 196, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 196, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_EndTimeIndex = __pyx_t_3;
+  __pyx_t_3 = 0;
+/* … */
+  __pyx_tuple__18 = PyTuple_Pack(1, __pyx_n_s_EndTime); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 196, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__18);
+  __Pyx_GIVEREF(__pyx_tuple__18);
+
+197:     DistanceIndex = Columns.index("Distance")
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_DistanceIndex = __pyx_t_1;
+  __pyx_t_1 = 0;
+/* … */
+  __pyx_tuple__19 = PyTuple_Pack(1, __pyx_n_s_Distance); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__19);
+  __Pyx_GIVEREF(__pyx_tuple__19);
+
+198:     for Flight in RawFlightList:
+
  if (likely(PyList_CheckExact(__pyx_v_RawFlightList)) || PyTuple_CheckExact(__pyx_v_RawFlightList)) {
+    __pyx_t_1 = __pyx_v_RawFlightList; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
+  } else {
+    __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_RawFlightList); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 198, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 198, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_6)) {
+      if (likely(PyList_CheckExact(__pyx_t_1))) {
+        if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 198, __pyx_L1_error)
+        #else
+        __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        #endif
+      } else {
+        if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 198, __pyx_L1_error)
+        #else
+        __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        #endif
+      }
+    } else {
+      __pyx_t_3 = __pyx_t_6(__pyx_t_1);
+      if (unlikely(!__pyx_t_3)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 198, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_3);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_Flight, __pyx_t_3);
+    __pyx_t_3 = 0;
+/* … */
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
 199:         #Start Sprite
+
+200:         Coords = ast.literal_eval(Flight[StartCoordsIndex])
+
    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 200, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_StartCoordsIndex); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    if (!__pyx_t_7) {
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4};
+        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4};
+        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 200, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4);
+        __pyx_t_4 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_Coords, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+201:         Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.0001,0.0001,0.00001)
+
    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 201, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_Coords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_Coords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 201, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_Coords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 201, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_9 = NULL;
+    __pyx_t_10 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_8, function);
+        __pyx_t_10 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_8)) {
+      PyObject *__pyx_temp[7] = {__pyx_t_9, __pyx_t_2, __pyx_t_4, __pyx_t_7, __pyx_float_0_0001, __pyx_float_0_0001, __pyx_float_0_00001};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) {
+      PyObject *__pyx_temp[7] = {__pyx_t_9, __pyx_t_2, __pyx_t_4, __pyx_t_7, __pyx_float_0_0001, __pyx_float_0_0001, __pyx_float_0_00001};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_11 = PyTuple_New(6+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 201, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      if (__pyx_t_9) {
+        __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_2);
+      PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_2);
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_7);
+      PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_t_7);
+      __Pyx_INCREF(__pyx_float_0_0001);
+      __Pyx_GIVEREF(__pyx_float_0_0001);
+      PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_10, __pyx_float_0_0001);
+      __Pyx_INCREF(__pyx_float_0_0001);
+      __Pyx_GIVEREF(__pyx_float_0_0001);
+      PyTuple_SET_ITEM(__pyx_t_11, 4+__pyx_t_10, __pyx_float_0_0001);
+      __Pyx_INCREF(__pyx_float_0_00001);
+      __Pyx_GIVEREF(__pyx_float_0_00001);
+      PyTuple_SET_ITEM(__pyx_t_11, 5+__pyx_t_10, __pyx_float_0_00001);
+      __pyx_t_2 = 0;
+      __pyx_t_4 = 0;
+      __pyx_t_7 = 0;
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_Coord, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+202:         Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ST:"+str(Flight[StartTimeIndex])
+
    __pyx_t_3 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_FlightIDIndex); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_8 = PyNumber_Add(__pyx_kp_s_F, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = PyNumber_Add(__pyx_t_8, __pyx_kp_s_D_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_8 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_DroneIDIndex); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __Pyx_GIVEREF(__pyx_t_8);
+    PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8);
+    __pyx_t_8 = 0;
+    __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __pyx_t_11 = PyNumber_Add(__pyx_t_3, __pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_8 = PyNumber_Add(__pyx_t_11, __pyx_kp_s_ST); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __pyx_t_11 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_StartTimeIndex); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_11);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_11);
+    __pyx_t_11 = 0;
+    __pyx_t_11 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = PyNumber_Add(__pyx_t_8, __pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_Text, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+203:         Colour = (0,0,255)
+
    __pyx_t_12.f0 = 0;
+    __pyx_t_12.f1 = 0;
+    __pyx_t_12.f2 = 0xFF;
+    __pyx_v_Colour = __pyx_t_12;
+
+204:         FlightList.append(Monitor_Sprite(Coord,"StartPoint",Text,Colour))
+
    __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_Monitor_Sprite); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 204, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __pyx_t_8 = __pyx_convert__to_py___pyx_ctuple_long__and_long__and_long(__pyx_v_Colour); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 204, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_7 = NULL;
+    __pyx_t_10 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_11))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_11);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_11, function);
+        __pyx_t_10 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_11)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_Coord, __pyx_n_s_StartPoint, __pyx_v_Text, __pyx_t_8};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_11, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_11)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_Coord, __pyx_n_s_StartPoint, __pyx_v_Text, __pyx_t_8};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_11, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(4+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 204, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (__pyx_t_7) {
+        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7); __pyx_t_7 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Coord);
+      __Pyx_GIVEREF(__pyx_v_Coord);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_10, __pyx_v_Coord);
+      __Pyx_INCREF(__pyx_n_s_StartPoint);
+      __Pyx_GIVEREF(__pyx_n_s_StartPoint);
+      PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_10, __pyx_n_s_StartPoint);
+      __Pyx_INCREF(__pyx_v_Text);
+      __Pyx_GIVEREF(__pyx_v_Text);
+      PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_10, __pyx_v_Text);
+      __Pyx_GIVEREF(__pyx_t_8);
+      PyTuple_SET_ITEM(__pyx_t_4, 3+__pyx_t_10, __pyx_t_8);
+      __pyx_t_8 = 0;
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_FlightList, __pyx_t_3); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 204, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
 205:
+
 206:         #End Sprite
+
+207:         Coords = ast.literal_eval(Flight[EndCoordsIndex])
+
    __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __pyx_t_11 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_EndCoordsIndex); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 207, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __pyx_t_8 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+      }
+    }
+    if (!__pyx_t_8) {
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_4)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_11};
+        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_11};
+        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 207, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __pyx_t_8 = NULL;
+        __Pyx_GIVEREF(__pyx_t_11);
+        PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_11);
+        __pyx_t_11 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF_SET(__pyx_v_Coords, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+208:         Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.0001,0.0001,0.00001)
+
    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 208, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_Coords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_Coords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 208, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_Coords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 208, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_2 = NULL;
+    __pyx_t_10 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7);
+      if (likely(__pyx_t_2)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_2);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_7, function);
+        __pyx_t_10 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_7)) {
+      PyObject *__pyx_temp[7] = {__pyx_t_2, __pyx_t_4, __pyx_t_11, __pyx_t_8, __pyx_float_0_0001, __pyx_float_0_0001, __pyx_float_0_00001};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+      PyObject *__pyx_temp[7] = {__pyx_t_2, __pyx_t_4, __pyx_t_11, __pyx_t_8, __pyx_float_0_0001, __pyx_float_0_0001, __pyx_float_0_00001};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_9 = PyTuple_New(6+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 208, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      if (__pyx_t_2) {
+        __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_10, __pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_11);
+      PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_10, __pyx_t_11);
+      __Pyx_GIVEREF(__pyx_t_8);
+      PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_10, __pyx_t_8);
+      __Pyx_INCREF(__pyx_float_0_0001);
+      __Pyx_GIVEREF(__pyx_float_0_0001);
+      PyTuple_SET_ITEM(__pyx_t_9, 3+__pyx_t_10, __pyx_float_0_0001);
+      __Pyx_INCREF(__pyx_float_0_0001);
+      __Pyx_GIVEREF(__pyx_float_0_0001);
+      PyTuple_SET_ITEM(__pyx_t_9, 4+__pyx_t_10, __pyx_float_0_0001);
+      __Pyx_INCREF(__pyx_float_0_00001);
+      __Pyx_GIVEREF(__pyx_float_0_00001);
+      PyTuple_SET_ITEM(__pyx_t_9, 5+__pyx_t_10, __pyx_float_0_00001);
+      __pyx_t_4 = 0;
+      __pyx_t_11 = 0;
+      __pyx_t_8 = 0;
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF_SET(__pyx_v_Coord, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+209:         Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ETA:"+str(Flight[ETAIndex])
+
    __pyx_t_3 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_FlightIDIndex); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = PyNumber_Add(__pyx_kp_s_F, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = PyNumber_Add(__pyx_t_7, __pyx_kp_s_D_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_DroneIDIndex); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_GIVEREF(__pyx_t_7);
+    PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7);
+    __pyx_t_7 = 0;
+    __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_9, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_t_9 = PyNumber_Add(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = PyNumber_Add(__pyx_t_9, __pyx_kp_s_ETA_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_t_9 = PyObject_GetItem(__pyx_v_Flight, __pyx_v_ETAIndex); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_9);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_9);
+    __pyx_t_9 = 0;
+    __pyx_t_9 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = PyNumber_Add(__pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_DECREF_SET(__pyx_v_Text, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+210:         Colour = (255,0,0)
+
    __pyx_t_12.f0 = 0xFF;
+    __pyx_t_12.f1 = 0;
+    __pyx_t_12.f2 = 0;
+    __pyx_v_Colour = __pyx_t_12;
+
+211:         FlightList.append(Monitor_Sprite(Coord,"EndPoint",Text,Colour))
+
    __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_Monitor_Sprite); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 211, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_t_7 = __pyx_convert__to_py___pyx_ctuple_long__and_long__and_long(__pyx_v_Colour); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 211, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_8 = NULL;
+    __pyx_t_10 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_9, function);
+        __pyx_t_10 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_9)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_v_Coord, __pyx_n_s_EndPoint, __pyx_v_Text, __pyx_t_7};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 211, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_v_Coord, __pyx_n_s_EndPoint, __pyx_v_Text, __pyx_t_7};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 211, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_11 = PyTuple_New(4+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 211, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      if (__pyx_t_8) {
+        __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __pyx_t_8 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Coord);
+      __Pyx_GIVEREF(__pyx_v_Coord);
+      PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_v_Coord);
+      __Pyx_INCREF(__pyx_n_s_EndPoint);
+      __Pyx_GIVEREF(__pyx_n_s_EndPoint);
+      PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_n_s_EndPoint);
+      __Pyx_INCREF(__pyx_v_Text);
+      __Pyx_GIVEREF(__pyx_v_Text);
+      PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_v_Text);
+      __Pyx_GIVEREF(__pyx_t_7);
+      PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_10, __pyx_t_7);
+      __pyx_t_7 = 0;
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 211, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_FlightList, __pyx_t_3); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 211, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+212:     return FlightList
+
  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_FlightList);
+  __pyx_r = __pyx_v_FlightList;
+  goto __pyx_L0;
+
 213:
+
 214:
+
+215: def MakeWaypointSprites(Message,RawWaypointList):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_11MakeWaypointSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_11MakeWaypointSprites = {"MakeWaypointSprites", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_11MakeWaypointSprites, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_11MakeWaypointSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_Message = 0;
+  PyObject *__pyx_v_RawWaypointList = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("MakeWaypointSprites (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Message,&__pyx_n_s_RawWaypointList,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Message)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_RawWaypointList)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("MakeWaypointSprites", 1, 2, 2, 1); __PYX_ERR(0, 215, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MakeWaypointSprites") < 0)) __PYX_ERR(0, 215, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_Message = values[0];
+    __pyx_v_RawWaypointList = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("MakeWaypointSprites", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 215, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeWaypointSprites", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_10MakeWaypointSprites(__pyx_self, __pyx_v_Message, __pyx_v_RawWaypointList);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_10MakeWaypointSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Message, PyObject *__pyx_v_RawWaypointList) {
+  PyObject *__pyx_v_WaypointList = NULL;
+  PyObject *__pyx_v_Columns = NULL;
+  PyObject *__pyx_v_CoordIndex = NULL;
+  PyObject *__pyx_v_WaypointNumberIndex = NULL;
+  PyObject *__pyx_v_FlightIDIndex = NULL;
+  PyObject *__pyx_v_Waypoint = NULL;
+  PyObject *__pyx_v_Coords = NULL;
+  PyObject *__pyx_v_Coord = NULL;
+  PyObject *__pyx_v_Text = NULL;
+  __pyx_ctuple_long__and_long__and_long __pyx_v_Colour;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("MakeWaypointSprites", 0);
+/* … */
+  /* 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_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeWaypointSprites", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_WaypointList);
+  __Pyx_XDECREF(__pyx_v_Columns);
+  __Pyx_XDECREF(__pyx_v_CoordIndex);
+  __Pyx_XDECREF(__pyx_v_WaypointNumberIndex);
+  __Pyx_XDECREF(__pyx_v_FlightIDIndex);
+  __Pyx_XDECREF(__pyx_v_Waypoint);
+  __Pyx_XDECREF(__pyx_v_Coords);
+  __Pyx_XDECREF(__pyx_v_Coord);
+  __Pyx_XDECREF(__pyx_v_Text);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__73 = PyTuple_Pack(12, __pyx_n_s_Message, __pyx_n_s_RawWaypointList, __pyx_n_s_WaypointList, __pyx_n_s_Columns, __pyx_n_s_CoordIndex, __pyx_n_s_WaypointNumberIndex, __pyx_n_s_FlightIDIndex, __pyx_n_s_Waypoint, __pyx_n_s_Coords, __pyx_n_s_Coord, __pyx_n_s_Text, __pyx_n_s_Colour); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(0, 215, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__73);
+  __Pyx_GIVEREF(__pyx_tuple__73);
+/* … */
+  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_11MakeWaypointSprites, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 215, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MakeWaypointSprites, __pyx_t_3) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__74 = (PyObject*)__Pyx_PyCode_New(2, 0, 12, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__73, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_MakeWaypointSprites, 215, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__74)) __PYX_ERR(0, 215, __pyx_L1_error)
+
+216:     WaypointList = []
+
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_WaypointList = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+217:     Columns = ast.literal_eval(Message)
+
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 217, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 217, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_Message); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 217, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 217, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 217, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 217, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      __Pyx_INCREF(__pyx_v_Message);
+      __Pyx_GIVEREF(__pyx_v_Message);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_Message);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 217, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_Columns = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+218:     CoordIndex = Columns.index("Coords")
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_CoordIndex = __pyx_t_3;
+  __pyx_t_3 = 0;
+/* … */
+  __pyx_tuple__20 = PyTuple_Pack(1, __pyx_n_s_Coords); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__20);
+  __Pyx_GIVEREF(__pyx_tuple__20);
+
+219:     WaypointNumberIndex = Columns.index("WaypointNumber")
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_WaypointNumberIndex = __pyx_t_1;
+  __pyx_t_1 = 0;
+/* … */
+  __pyx_tuple__21 = PyTuple_Pack(1, __pyx_n_s_WaypointNumber); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__21);
+  __Pyx_GIVEREF(__pyx_tuple__21);
+
+220:     FlightIDIndex = Columns.index("FlightID")
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_FlightIDIndex = __pyx_t_3;
+  __pyx_t_3 = 0;
+/* … */
+  __pyx_tuple__22 = PyTuple_Pack(1, __pyx_n_s_FlightID); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__22);
+  __Pyx_GIVEREF(__pyx_tuple__22);
+
+221:     for Waypoint in RawWaypointList:
+
  if (likely(PyList_CheckExact(__pyx_v_RawWaypointList)) || PyTuple_CheckExact(__pyx_v_RawWaypointList)) {
+    __pyx_t_3 = __pyx_v_RawWaypointList; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
+  } else {
+    __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_RawWaypointList); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 221, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 221, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_6)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 221, __pyx_L1_error)
+        #else
+        __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 221, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        #endif
+      } else {
+        if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 221, __pyx_L1_error)
+        #else
+        __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 221, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        #endif
+      }
+    } else {
+      __pyx_t_1 = __pyx_t_6(__pyx_t_3);
+      if (unlikely(!__pyx_t_1)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 221, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_Waypoint, __pyx_t_1);
+    __pyx_t_1 = 0;
+/* … */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+222:         Coords = ast.literal_eval(Waypoint[CoordIndex])
+
    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = PyObject_GetItem(__pyx_v_Waypoint, __pyx_v_CoordIndex); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    if (!__pyx_t_7) {
+      __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4};
+        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4};
+        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 222, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4);
+        __pyx_t_4 = 0;
+        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_Coords, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+223:         Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.001,0.001,0.00001)
+
    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 223, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 223, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_Coords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 223, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_Coords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 223, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_Coords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 223, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_9 = NULL;
+    __pyx_t_10 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+      if (likely(__pyx_t_9)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_8, function);
+        __pyx_t_10 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_8)) {
+      PyObject *__pyx_temp[7] = {__pyx_t_9, __pyx_t_2, __pyx_t_4, __pyx_t_7, __pyx_float_0_001, __pyx_float_0_001, __pyx_float_0_00001};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 223, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) {
+      PyObject *__pyx_temp[7] = {__pyx_t_9, __pyx_t_2, __pyx_t_4, __pyx_t_7, __pyx_float_0_001, __pyx_float_0_001, __pyx_float_0_00001};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 6+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 223, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_11 = PyTuple_New(6+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 223, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      if (__pyx_t_9) {
+        __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_2);
+      PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_2);
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_7);
+      PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_t_7);
+      __Pyx_INCREF(__pyx_float_0_001);
+      __Pyx_GIVEREF(__pyx_float_0_001);
+      PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_10, __pyx_float_0_001);
+      __Pyx_INCREF(__pyx_float_0_001);
+      __Pyx_GIVEREF(__pyx_float_0_001);
+      PyTuple_SET_ITEM(__pyx_t_11, 4+__pyx_t_10, __pyx_float_0_001);
+      __Pyx_INCREF(__pyx_float_0_00001);
+      __Pyx_GIVEREF(__pyx_float_0_00001);
+      PyTuple_SET_ITEM(__pyx_t_11, 5+__pyx_t_10, __pyx_float_0_00001);
+      __pyx_t_2 = 0;
+      __pyx_t_4 = 0;
+      __pyx_t_7 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 223, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_Coord, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+224:         Text = "F:"+ str(Waypoint[FlightIDIndex]) +" W:"+ str(Waypoint[WaypointNumberIndex])
+
    __pyx_t_1 = PyObject_GetItem(__pyx_v_Waypoint, __pyx_v_FlightIDIndex); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 224, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 224, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1);
+    __pyx_t_1 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 224, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_8 = PyNumber_Add(__pyx_kp_s_F, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 224, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = PyNumber_Add(__pyx_t_8, __pyx_kp_s_W); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 224, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_8 = PyObject_GetItem(__pyx_v_Waypoint, __pyx_v_WaypointNumberIndex); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 224, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 224, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __Pyx_GIVEREF(__pyx_t_8);
+    PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8);
+    __pyx_t_8 = 0;
+    __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 224, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __pyx_t_11 = PyNumber_Add(__pyx_t_1, __pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 224, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_Text, __pyx_t_11);
+    __pyx_t_11 = 0;
+
+225:         Colour = (0,255,0)
+
    __pyx_t_12.f0 = 0;
+    __pyx_t_12.f1 = 0xFF;
+    __pyx_t_12.f2 = 0;
+    __pyx_v_Colour = __pyx_t_12;
+
+226:         WaypointList.append(Monitor_Sprite(Coord,"Waypoint",Text,Colour))
+
    __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_Monitor_Sprite); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 226, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_1 = __pyx_convert__to_py___pyx_ctuple_long__and_long__and_long(__pyx_v_Colour); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_7 = NULL;
+    __pyx_t_10 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_8, function);
+        __pyx_t_10 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_8)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_Coord, __pyx_n_s_Waypoint, __pyx_v_Text, __pyx_t_1};
+      __pyx_t_11 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 226, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_11);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_v_Coord, __pyx_n_s_Waypoint, __pyx_v_Text, __pyx_t_1};
+      __pyx_t_11 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_10, 4+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 226, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_11);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(4+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 226, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (__pyx_t_7) {
+        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7); __pyx_t_7 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Coord);
+      __Pyx_GIVEREF(__pyx_v_Coord);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_10, __pyx_v_Coord);
+      __Pyx_INCREF(__pyx_n_s_Waypoint);
+      __Pyx_GIVEREF(__pyx_n_s_Waypoint);
+      PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_10, __pyx_n_s_Waypoint);
+      __Pyx_INCREF(__pyx_v_Text);
+      __Pyx_GIVEREF(__pyx_v_Text);
+      PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_10, __pyx_v_Text);
+      __Pyx_GIVEREF(__pyx_t_1);
+      PyTuple_SET_ITEM(__pyx_t_4, 3+__pyx_t_10, __pyx_t_1);
+      __pyx_t_1 = 0;
+      __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_4, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 226, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_WaypointList, __pyx_t_11); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 226, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+
+227:     return WaypointList
+
  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_WaypointList);
+  __pyx_r = __pyx_v_WaypointList;
+  goto __pyx_L0;
+
 228:
+
+229: def MakeZoneSprites(Message,RawZoneList):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_13MakeZoneSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_13MakeZoneSprites = {"MakeZoneSprites", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_13MakeZoneSprites, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_13MakeZoneSprites(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_Message = 0;
+  PyObject *__pyx_v_RawZoneList = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("MakeZoneSprites (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_Message,&__pyx_n_s_RawZoneList,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_Message)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_RawZoneList)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("MakeZoneSprites", 1, 2, 2, 1); __PYX_ERR(0, 229, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MakeZoneSprites") < 0)) __PYX_ERR(0, 229, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_Message = values[0];
+    __pyx_v_RawZoneList = values[1];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("MakeZoneSprites", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 229, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeZoneSprites", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_12MakeZoneSprites(__pyx_self, __pyx_v_Message, __pyx_v_RawZoneList);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_12MakeZoneSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_Message, PyObject *__pyx_v_RawZoneList) {
+  PyObject *__pyx_v_ZoneList = NULL;
+  PyObject *__pyx_v_Columns = NULL;
+  PyObject *__pyx_v_StartCoordIndex = NULL;
+  PyObject *__pyx_v_EndCoordIndex = NULL;
+  PyObject *__pyx_v_LevelIndex = NULL;
+  PyObject *__pyx_v_ZoneIDIndex = NULL;
+  PyObject *__pyx_v_Zone = NULL;
+  PyObject *__pyx_v_StartCoords = NULL;
+  PyObject *__pyx_v_EndCoords = NULL;
+  PyObject *__pyx_v_Coord = NULL;
+  PyObject *__pyx_v_Text = NULL;
+  __pyx_ctuple_long__and_long__and_long __pyx_v_Colour;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("MakeZoneSprites", 0);
+/* … */
+  /* 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_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer.MakeZoneSprites", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ZoneList);
+  __Pyx_XDECREF(__pyx_v_Columns);
+  __Pyx_XDECREF(__pyx_v_StartCoordIndex);
+  __Pyx_XDECREF(__pyx_v_EndCoordIndex);
+  __Pyx_XDECREF(__pyx_v_LevelIndex);
+  __Pyx_XDECREF(__pyx_v_ZoneIDIndex);
+  __Pyx_XDECREF(__pyx_v_Zone);
+  __Pyx_XDECREF(__pyx_v_StartCoords);
+  __Pyx_XDECREF(__pyx_v_EndCoords);
+  __Pyx_XDECREF(__pyx_v_Coord);
+  __Pyx_XDECREF(__pyx_v_Text);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__75 = PyTuple_Pack(14, __pyx_n_s_Message, __pyx_n_s_RawZoneList, __pyx_n_s_ZoneList, __pyx_n_s_Columns, __pyx_n_s_StartCoordIndex, __pyx_n_s_EndCoordIndex, __pyx_n_s_LevelIndex, __pyx_n_s_ZoneIDIndex, __pyx_n_s_Zone, __pyx_n_s_StartCoords, __pyx_n_s_EndCoords, __pyx_n_s_Coord, __pyx_n_s_Text, __pyx_n_s_Colour); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__75);
+  __Pyx_GIVEREF(__pyx_tuple__75);
+/* … */
+  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_13MakeZoneSprites, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MakeZoneSprites, __pyx_t_3) < 0) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__76 = (PyObject*)__Pyx_PyCode_New(2, 0, 14, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__75, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_MakeZoneSprites, 229, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__76)) __PYX_ERR(0, 229, __pyx_L1_error)
+
+230:     ZoneList = []
+
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_ZoneList = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+231:     Columns = ast.literal_eval(Message)
+
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 231, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 231, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_Message); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_v_Message};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 231, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      __Pyx_INCREF(__pyx_v_Message);
+      __Pyx_GIVEREF(__pyx_v_Message);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_Message);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_Columns = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+232:     StartCoordIndex = Columns.index("StartCoord")
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_StartCoordIndex = __pyx_t_3;
+  __pyx_t_3 = 0;
+/* … */
+  __pyx_tuple__23 = PyTuple_Pack(1, __pyx_n_s_StartCoord); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__23);
+  __Pyx_GIVEREF(__pyx_tuple__23);
+
+233:     EndCoordIndex = Columns.index("EndCoord")
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 233, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 233, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_EndCoordIndex = __pyx_t_1;
+  __pyx_t_1 = 0;
+/* … */
+  __pyx_tuple__24 = PyTuple_Pack(1, __pyx_n_s_EndCoord); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 233, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__24);
+  __Pyx_GIVEREF(__pyx_tuple__24);
+
+234:     LevelIndex = Columns.index("Level")
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_LevelIndex = __pyx_t_3;
+  __pyx_t_3 = 0;
+/* … */
+  __pyx_tuple__25 = PyTuple_Pack(1, __pyx_n_s_Level); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__25);
+  __Pyx_GIVEREF(__pyx_tuple__25);
+
+235:     ZoneIDIndex = Columns.index("ZoneID")
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_Columns, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_ZoneIDIndex = __pyx_t_1;
+  __pyx_t_1 = 0;
+/* … */
+  __pyx_tuple__26 = PyTuple_Pack(1, __pyx_n_s_ZoneID); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__26);
+  __Pyx_GIVEREF(__pyx_tuple__26);
+
+236:     for Zone in RawZoneList:
+
  if (likely(PyList_CheckExact(__pyx_v_RawZoneList)) || PyTuple_CheckExact(__pyx_v_RawZoneList)) {
+    __pyx_t_1 = __pyx_v_RawZoneList; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
+  } else {
+    __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_RawZoneList); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 236, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_6)) {
+      if (likely(PyList_CheckExact(__pyx_t_1))) {
+        if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 236, __pyx_L1_error)
+        #else
+        __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 236, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        #endif
+      } else {
+        if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 236, __pyx_L1_error)
+        #else
+        __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 236, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        #endif
+      }
+    } else {
+      __pyx_t_3 = __pyx_t_6(__pyx_t_1);
+      if (unlikely(!__pyx_t_3)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 236, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_3);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_Zone, __pyx_t_3);
+    __pyx_t_3 = 0;
+/* … */
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+237:         StartCoords = ast.literal_eval(Zone[StartCoordIndex])
+
    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 237, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 237, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = PyObject_GetItem(__pyx_v_Zone, __pyx_v_StartCoordIndex); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 237, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    if (!__pyx_t_7) {
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4};
+        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_4};
+        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 237, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+        __Pyx_GIVEREF(__pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4);
+        __pyx_t_4 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_StartCoords, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+238:         EndCoords = ast.literal_eval(Zone[EndCoordIndex])
+
    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ast); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_literal_eval); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 238, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = PyObject_GetItem(__pyx_v_Zone, __pyx_v_EndCoordIndex); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_8, function);
+      }
+    }
+    if (!__pyx_t_4) {
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_8)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
+        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
+        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 238, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
+        __Pyx_GIVEREF(__pyx_t_2);
+        PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_2);
+        __pyx_t_2 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_EndCoords, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+239:         Coord = AATC_Coordinate.Coordinate(StartCoords[0],StartCoords[1],StartCoords[2],EndCoords[0]-StartCoords[0],EndCoords[1]-StartCoords[1],EndCoords[2]-StartCoords[2])
+
    __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_StartCoords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_StartCoords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_StartCoords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_EndCoords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_StartCoords, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_10);
+    __pyx_t_11 = PyNumber_Subtract(__pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_11);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_EndCoords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_10);
+    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_StartCoords, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_t_12 = PyNumber_Subtract(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_12);
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_EndCoords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_StartCoords, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_10);
+    __pyx_t_13 = PyNumber_Subtract(__pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 239, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_13);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __pyx_t_10 = NULL;
+    __pyx_t_14 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_7);
+      if (likely(__pyx_t_10)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_10);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_7, function);
+        __pyx_t_14 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_7)) {
+      PyObject *__pyx_temp[7] = {__pyx_t_10, __pyx_t_8, __pyx_t_2, __pyx_t_4, __pyx_t_11, __pyx_t_12, __pyx_t_13};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_14, 6+__pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+      PyObject *__pyx_temp[7] = {__pyx_t_10, __pyx_t_8, __pyx_t_2, __pyx_t_4, __pyx_t_11, __pyx_t_12, __pyx_t_13};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_14, 6+__pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_9 = PyTuple_New(6+__pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      if (__pyx_t_10) {
+        __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); __pyx_t_10 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_8);
+      PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_14, __pyx_t_8);
+      __Pyx_GIVEREF(__pyx_t_2);
+      PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_14, __pyx_t_2);
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_14, __pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_11);
+      PyTuple_SET_ITEM(__pyx_t_9, 3+__pyx_t_14, __pyx_t_11);
+      __Pyx_GIVEREF(__pyx_t_12);
+      PyTuple_SET_ITEM(__pyx_t_9, 4+__pyx_t_14, __pyx_t_12);
+      __Pyx_GIVEREF(__pyx_t_13);
+      PyTuple_SET_ITEM(__pyx_t_9, 5+__pyx_t_14, __pyx_t_13);
+      __pyx_t_8 = 0;
+      __pyx_t_2 = 0;
+      __pyx_t_4 = 0;
+      __pyx_t_11 = 0;
+      __pyx_t_12 = 0;
+      __pyx_t_13 = 0;
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_Coord, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+240:         Text = "Z:"+ str(Zone[ZoneIDIndex]) +" L:"+ str(Zone[LevelIndex])
+
    __pyx_t_3 = PyObject_GetItem(__pyx_v_Zone, __pyx_v_ZoneIDIndex); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = PyNumber_Add(__pyx_kp_s_Z, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = PyNumber_Add(__pyx_t_7, __pyx_kp_s_L); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = PyObject_GetItem(__pyx_v_Zone, __pyx_v_LevelIndex); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_GIVEREF(__pyx_t_7);
+    PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7);
+    __pyx_t_7 = 0;
+    __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_9, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_t_9 = PyNumber_Add(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_Text, __pyx_t_9);
+    __pyx_t_9 = 0;
+
+241:         Colour = (100,100,100)
+
    __pyx_t_15.f0 = 0x64;
+    __pyx_t_15.f1 = 0x64;
+    __pyx_t_15.f2 = 0x64;
+    __pyx_v_Colour = __pyx_t_15;
+
+242:         ZoneList.append(Monitor_Sprite(Coord,"NoFlyZone",Text,Colour))
+
    __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_Monitor_Sprite); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 242, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_3 = __pyx_convert__to_py___pyx_ctuple_long__and_long__and_long(__pyx_v_Colour); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_13 = NULL;
+    __pyx_t_14 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+      __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_7);
+      if (likely(__pyx_t_13)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+        __Pyx_INCREF(__pyx_t_13);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_7, function);
+        __pyx_t_14 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_7)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_13, __pyx_v_Coord, __pyx_n_s_NoFlyZone, __pyx_v_Text, __pyx_t_3};
+      __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_14, 4+__pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_13, __pyx_v_Coord, __pyx_n_s_NoFlyZone, __pyx_v_Text, __pyx_t_3};
+      __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_14, 4+__pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_12 = PyTuple_New(4+__pyx_t_14); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 242, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      if (__pyx_t_13) {
+        __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_13); __pyx_t_13 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Coord);
+      __Pyx_GIVEREF(__pyx_v_Coord);
+      PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_14, __pyx_v_Coord);
+      __Pyx_INCREF(__pyx_n_s_NoFlyZone);
+      __Pyx_GIVEREF(__pyx_n_s_NoFlyZone);
+      PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_14, __pyx_n_s_NoFlyZone);
+      __Pyx_INCREF(__pyx_v_Text);
+      __Pyx_GIVEREF(__pyx_v_Text);
+      PyTuple_SET_ITEM(__pyx_t_12, 2+__pyx_t_14, __pyx_v_Text);
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_12, 3+__pyx_t_14, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_12, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 242, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_16 = __Pyx_PyList_Append(__pyx_v_ZoneList, __pyx_t_9); if (unlikely(__pyx_t_16 == -1)) __PYX_ERR(0, 242, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+243:     return ZoneList
+
  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_ZoneList);
+  __pyx_r = __pyx_v_ZoneList;
+  goto __pyx_L0;
+
 244:
+
+245: def MakeSprites(M):
+
/* Python wrapper */
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_15MakeSprites(PyObject *__pyx_self, PyObject *__pyx_v_M); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_19AATC_Monitor_Viewer_15MakeSprites = {"MakeSprites", (PyCFunction)__pyx_pw_6CAStar_19AATC_Monitor_Viewer_15MakeSprites, METH_O, 0};
+static PyObject *__pyx_pw_6CAStar_19AATC_Monitor_Viewer_15MakeSprites(PyObject *__pyx_self, PyObject *__pyx_v_M) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("MakeSprites (wrapper)", 0);
+  __pyx_r = __pyx_pf_6CAStar_19AATC_Monitor_Viewer_14MakeSprites(__pyx_self, ((PyObject *)__pyx_v_M));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_6CAStar_19AATC_Monitor_Viewer_14MakeSprites(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_M) {
+  PyObject *__pyx_v_SpriteList = NULL;
+  PyObject *__pyx_v_Sucess = NULL;
+  PyObject *__pyx_v_Message = NULL;
+  PyObject *__pyx_v_DronesAll = NULL;
+  PyObject *__pyx_v_DronesMonitor = NULL;
+  PyObject *__pyx_v_FlightsAll = NULL;
+  PyObject *__pyx_v_FlightsMonitor = NULL;
+  PyObject *__pyx_v_WaypointsAll = NULL;
+  PyObject *__pyx_v_WaypointsMonitor = NULL;
+  PyObject *__pyx_v_NoFlyZones = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("MakeSprites", 0);
+/* … */
+  /* 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("CAStar.AATC_Monitor_Viewer.MakeSprites", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_SpriteList);
+  __Pyx_XDECREF(__pyx_v_Sucess);
+  __Pyx_XDECREF(__pyx_v_Message);
+  __Pyx_XDECREF(__pyx_v_DronesAll);
+  __Pyx_XDECREF(__pyx_v_DronesMonitor);
+  __Pyx_XDECREF(__pyx_v_FlightsAll);
+  __Pyx_XDECREF(__pyx_v_FlightsMonitor);
+  __Pyx_XDECREF(__pyx_v_WaypointsAll);
+  __Pyx_XDECREF(__pyx_v_WaypointsMonitor);
+  __Pyx_XDECREF(__pyx_v_NoFlyZones);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__77 = PyTuple_Pack(11, __pyx_n_s_M, __pyx_n_s_SpriteList, __pyx_n_s_Sucess, __pyx_n_s_Message, __pyx_n_s_DronesAll, __pyx_n_s_DronesMonitor, __pyx_n_s_FlightsAll, __pyx_n_s_FlightsMonitor, __pyx_n_s_WaypointsAll, __pyx_n_s_WaypointsMonitor, __pyx_n_s_NoFlyZones); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(0, 245, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__77);
+  __Pyx_GIVEREF(__pyx_tuple__77);
+/* … */
+  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_19AATC_Monitor_Viewer_15MakeSprites, NULL, __pyx_n_s_CAStar_AATC_Monitor_Viewer); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 245, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MakeSprites, __pyx_t_3) < 0) __PYX_ERR(0, 245, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__78 = (PyObject*)__Pyx_PyCode_New(1, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__77, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_AATC_Monitor_Viewer_pyx, __pyx_n_s_MakeSprites, 245, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__78)) __PYX_ERR(0, 245, __pyx_L1_error)
+
+246:     print("Refreshing data")
+
  if (__Pyx_PrintOne(0, __pyx_kp_s_Refreshing_data) < 0) __PYX_ERR(0, 246, __pyx_L1_error)
+
+247:     SpriteList = []
+
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_SpriteList = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+248:     Sucess,Message,DronesAll = M.GetDronesAll()
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetDronesAll); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
+    PyObject* sequence = __pyx_t_1;
+    #if !CYTHON_COMPILING_IN_PYPY
+    Py_ssize_t size = Py_SIZE(sequence);
+    #else
+    Py_ssize_t size = PySequence_Size(sequence);
+    #endif
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 248, __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_t_3 = PyTuple_GET_ITEM(sequence, 1); 
+      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); 
+    } else {
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
+      __pyx_t_4 = PyList_GET_ITEM(sequence, 2); 
+    }
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_t_4);
+    #else
+    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 248, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    #endif
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
+    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_2);
+    index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_3);
+    index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_4);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 248, __pyx_L1_error)
+    __pyx_t_6 = NULL;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    goto __pyx_L4_unpacking_done;
+    __pyx_L3_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 248, __pyx_L1_error)
+    __pyx_L4_unpacking_done:;
+  }
+  __pyx_v_Sucess = __pyx_t_2;
+  __pyx_t_2 = 0;
+  __pyx_v_Message = __pyx_t_3;
+  __pyx_t_3 = 0;
+  __pyx_v_DronesAll = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+249:     if Sucess:
+
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 249, __pyx_L1_error)
+  if (__pyx_t_7) {
+/* … */
+  }
+
+250:         SpriteList += MakeDroneSprites(Message,DronesAll)
+
    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeDroneSprites); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = NULL;
+    __pyx_t_8 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+        __pyx_t_8 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_Message, __pyx_v_DronesAll};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_Message, __pyx_v_DronesAll};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_2 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 250, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      if (__pyx_t_3) {
+        __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Message);
+      __Pyx_GIVEREF(__pyx_v_Message);
+      PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_8, __pyx_v_Message);
+      __Pyx_INCREF(__pyx_v_DronesAll);
+      __Pyx_GIVEREF(__pyx_v_DronesAll);
+      PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_8, __pyx_v_DronesAll);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_4);
+    __pyx_t_4 = 0;
+
 251:
+
+252:     Sucess,Message,DronesMonitor = M.GetMonitorDrones()
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetMonitorDrones); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 252, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 252, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) {
+    PyObject* sequence = __pyx_t_4;
+    #if !CYTHON_COMPILING_IN_PYPY
+    Py_ssize_t size = Py_SIZE(sequence);
+    #else
+    Py_ssize_t size = PySequence_Size(sequence);
+    #endif
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 252, __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_t_2 = PyTuple_GET_ITEM(sequence, 1); 
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 2); 
+    } else {
+      __pyx_t_1 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 1); 
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 2); 
+    }
+    __Pyx_INCREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_3);
+    #else
+    __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 252, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 252, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
+    index = 0; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L6_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_1);
+    index = 1; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L6_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_2);
+    index = 2; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L6_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 252, __pyx_L1_error)
+    __pyx_t_6 = NULL;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    goto __pyx_L7_unpacking_done;
+    __pyx_L6_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 252, __pyx_L1_error)
+    __pyx_L7_unpacking_done:;
+  }
+  __Pyx_DECREF_SET(__pyx_v_Sucess, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_Message, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_v_DronesMonitor = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+253:     if Sucess:
+
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 253, __pyx_L1_error)
+  if (__pyx_t_7) {
+/* … */
+  }
+
+254:         SpriteList += MakeDroneSprites(Message,DronesMonitor)
+
    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeDroneSprites); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_2 = NULL;
+    __pyx_t_8 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_2)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_2);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_8 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_Message, __pyx_v_DronesMonitor};
+      __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 254, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_Message, __pyx_v_DronesMonitor};
+      __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 254, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+    } else
+    #endif
+    {
+      __pyx_t_1 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 254, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      if (__pyx_t_2) {
+        __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Message);
+      __Pyx_GIVEREF(__pyx_v_Message);
+      PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_8, __pyx_v_Message);
+      __Pyx_INCREF(__pyx_v_DronesMonitor);
+      __Pyx_GIVEREF(__pyx_v_DronesMonitor);
+      PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_8, __pyx_v_DronesMonitor);
+      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 254, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_3);
+    __pyx_t_3 = 0;
+
 255:
+
+256:     Sucess,Message,FlightsAll = M.GetFlightsAll()
+
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetFlightsAll); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 256, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (__pyx_t_1) {
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 256, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else {
+    __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 256, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
+    PyObject* sequence = __pyx_t_3;
+    #if !CYTHON_COMPILING_IN_PYPY
+    Py_ssize_t size = Py_SIZE(sequence);
+    #else
+    Py_ssize_t size = PySequence_Size(sequence);
+    #endif
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 256, __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_t_1 = PyTuple_GET_ITEM(sequence, 1); 
+      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 2); 
+    } else {
+      __pyx_t_4 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_1 = PyList_GET_ITEM(sequence, 1); 
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 2); 
+    }
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_t_2);
+    #else
+    __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 256, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 256, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 256, __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, 256, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
+    index = 0; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L9_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_4);
+    index = 1; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L9_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_1);
+    index = 2; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L9_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_2);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 256, __pyx_L1_error)
+    __pyx_t_6 = NULL;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    goto __pyx_L10_unpacking_done;
+    __pyx_L9_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 256, __pyx_L1_error)
+    __pyx_L10_unpacking_done:;
+  }
+  __Pyx_DECREF_SET(__pyx_v_Sucess, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __Pyx_DECREF_SET(__pyx_v_Message, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_v_FlightsAll = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+257:     if Sucess:
+
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 257, __pyx_L1_error)
+  if (__pyx_t_7) {
+/* … */
+  }
+
+258:         SpriteList += MakeFlightSprites(Message,FlightsAll)
+
    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeFlightSprites); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 258, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_1 = NULL;
+    __pyx_t_8 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_1)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+        __pyx_t_8 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_Message, __pyx_v_FlightsAll};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_Message, __pyx_v_FlightsAll};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 258, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (__pyx_t_1) {
+        __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Message);
+      __Pyx_GIVEREF(__pyx_v_Message);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_8, __pyx_v_Message);
+      __Pyx_INCREF(__pyx_v_FlightsAll);
+      __Pyx_GIVEREF(__pyx_v_FlightsAll);
+      PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_8, __pyx_v_FlightsAll);
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 258, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_2);
+    __pyx_t_2 = 0;
+
 259:
+
+260:     Sucess,Message,FlightsMonitor = M.GetMonitorFlights()
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetMonitorFlights); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 260, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 260, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
+    PyObject* sequence = __pyx_t_2;
+    #if !CYTHON_COMPILING_IN_PYPY
+    Py_ssize_t size = Py_SIZE(sequence);
+    #else
+    Py_ssize_t size = PySequence_Size(sequence);
+    #endif
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 260, __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_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+      __pyx_t_1 = PyTuple_GET_ITEM(sequence, 2); 
+    } else {
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_4 = PyList_GET_ITEM(sequence, 1); 
+      __pyx_t_1 = PyList_GET_ITEM(sequence, 2); 
+    }
+    __Pyx_INCREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx_t_1);
+    #else
+    __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 260, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 260, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_1 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    #endif
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_5 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 260, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
+    index = 0; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L12_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_3);
+    index = 1; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L12_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_4);
+    index = 2; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L12_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_1);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 260, __pyx_L1_error)
+    __pyx_t_6 = NULL;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    goto __pyx_L13_unpacking_done;
+    __pyx_L12_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 260, __pyx_L1_error)
+    __pyx_L13_unpacking_done:;
+  }
+  __Pyx_DECREF_SET(__pyx_v_Sucess, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __Pyx_DECREF_SET(__pyx_v_Message, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __pyx_v_FlightsMonitor = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+261:     if Sucess:
+
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 261, __pyx_L1_error)
+  if (__pyx_t_7) {
+/* … */
+  }
+
+262:         SpriteList += MakeFlightSprites(Message,FlightsMonitor)
+
    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeFlightSprites); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 262, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_4 = NULL;
+    __pyx_t_8 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_1, function);
+        __pyx_t_8 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_Message, __pyx_v_FlightsMonitor};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_Message, __pyx_v_FlightsMonitor};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+    } else
+    #endif
+    {
+      __pyx_t_3 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 262, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      if (__pyx_t_4) {
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Message);
+      __Pyx_GIVEREF(__pyx_v_Message);
+      PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_8, __pyx_v_Message);
+      __Pyx_INCREF(__pyx_v_FlightsMonitor);
+      __Pyx_GIVEREF(__pyx_v_FlightsMonitor);
+      PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_8, __pyx_v_FlightsMonitor);
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 262, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_1);
+    __pyx_t_1 = 0;
+
 263:
+
+264:     Sucess,Message,WaypointsAll = M.GetFlightWaypointsAll()
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetFlightWaypointsAll); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 264, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 264, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 264, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
+    PyObject* sequence = __pyx_t_1;
+    #if !CYTHON_COMPILING_IN_PYPY
+    Py_ssize_t size = Py_SIZE(sequence);
+    #else
+    Py_ssize_t size = PySequence_Size(sequence);
+    #endif
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 264, __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_t_3 = PyTuple_GET_ITEM(sequence, 1); 
+      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); 
+    } else {
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 1); 
+      __pyx_t_4 = PyList_GET_ITEM(sequence, 2); 
+    }
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_t_4);
+    #else
+    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 264, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 264, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 264, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    #endif
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 264, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
+    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L15_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_2);
+    index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L15_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_3);
+    index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L15_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_4);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 264, __pyx_L1_error)
+    __pyx_t_6 = NULL;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    goto __pyx_L16_unpacking_done;
+    __pyx_L15_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 264, __pyx_L1_error)
+    __pyx_L16_unpacking_done:;
+  }
+  __Pyx_DECREF_SET(__pyx_v_Sucess, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __Pyx_DECREF_SET(__pyx_v_Message, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_v_WaypointsAll = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+265:     if Sucess:
+
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 265, __pyx_L1_error)
+  if (__pyx_t_7) {
+/* … */
+  }
+
+266:         SpriteList += MakeWaypointSprites(Message,WaypointsAll)
+
    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeWaypointSprites); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 266, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = NULL;
+    __pyx_t_8 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_4, function);
+        __pyx_t_8 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_Message, __pyx_v_WaypointsAll};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 266, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_Message, __pyx_v_WaypointsAll};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 266, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_2 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 266, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      if (__pyx_t_3) {
+        __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Message);
+      __Pyx_GIVEREF(__pyx_v_Message);
+      PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_8, __pyx_v_Message);
+      __Pyx_INCREF(__pyx_v_WaypointsAll);
+      __Pyx_GIVEREF(__pyx_v_WaypointsAll);
+      PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_8, __pyx_v_WaypointsAll);
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 266, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 266, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_4);
+    __pyx_t_4 = 0;
+
 267:
+
+268:     Sucess,Message,WaypointsMonitor = M.GetMonitorFlightWaypoints()
+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetMonitorFlightWaypoints); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 268, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 268, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 268, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) {
+    PyObject* sequence = __pyx_t_4;
+    #if !CYTHON_COMPILING_IN_PYPY
+    Py_ssize_t size = Py_SIZE(sequence);
+    #else
+    Py_ssize_t size = PySequence_Size(sequence);
+    #endif
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 268, __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_t_2 = PyTuple_GET_ITEM(sequence, 1); 
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 2); 
+    } else {
+      __pyx_t_1 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 1); 
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 2); 
+    }
+    __Pyx_INCREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_3);
+    #else
+    __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 268, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 268, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 268, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 268, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
+    index = 0; __pyx_t_1 = __pyx_t_6(__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_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L18_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_2);
+    index = 2; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L18_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 268, __pyx_L1_error)
+    __pyx_t_6 = 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_6 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 268, __pyx_L1_error)
+    __pyx_L19_unpacking_done:;
+  }
+  __Pyx_DECREF_SET(__pyx_v_Sucess, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_Message, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_v_WaypointsMonitor = __pyx_t_3;
+  __pyx_t_3 = 0;
+
+269:     if Sucess:
+
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 269, __pyx_L1_error)
+  if (__pyx_t_7) {
+/* … */
+  }
+
+270:         SpriteList += MakeWaypointSprites(Message,WaypointsMonitor)
+
    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeWaypointSprites); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_2 = NULL;
+    __pyx_t_8 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_2)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_2);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_8 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_Message, __pyx_v_WaypointsMonitor};
+      __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 270, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_Message, __pyx_v_WaypointsMonitor};
+      __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 270, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_4);
+    } else
+    #endif
+    {
+      __pyx_t_1 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      if (__pyx_t_2) {
+        __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Message);
+      __Pyx_GIVEREF(__pyx_v_Message);
+      PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_8, __pyx_v_Message);
+      __Pyx_INCREF(__pyx_v_WaypointsMonitor);
+      __Pyx_GIVEREF(__pyx_v_WaypointsMonitor);
+      PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_8, __pyx_v_WaypointsMonitor);
+      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 270, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 270, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_3);
+    __pyx_t_3 = 0;
+
 271:
+
+272:     Sucess,Message,NoFlyZones = M.GetNoFlyZones()
+
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_M, __pyx_n_s_GetNoFlyZones); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 272, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_1)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_1);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (__pyx_t_1) {
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 272, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else {
+    __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 272, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
+    PyObject* sequence = __pyx_t_3;
+    #if !CYTHON_COMPILING_IN_PYPY
+    Py_ssize_t size = Py_SIZE(sequence);
+    #else
+    Py_ssize_t size = PySequence_Size(sequence);
+    #endif
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 272, __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_t_1 = PyTuple_GET_ITEM(sequence, 1); 
+      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 2); 
+    } else {
+      __pyx_t_4 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_1 = PyList_GET_ITEM(sequence, 1); 
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 2); 
+    }
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_t_2);
+    #else
+    __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 272, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 272, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 272, __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, 272, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
+    index = 0; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L21_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_4);
+    index = 1; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L21_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_1);
+    index = 2; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L21_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_2);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 272, __pyx_L1_error)
+    __pyx_t_6 = NULL;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    goto __pyx_L22_unpacking_done;
+    __pyx_L21_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 272, __pyx_L1_error)
+    __pyx_L22_unpacking_done:;
+  }
+  __Pyx_DECREF_SET(__pyx_v_Sucess, __pyx_t_4);
+  __pyx_t_4 = 0;
+  __Pyx_DECREF_SET(__pyx_v_Message, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_v_NoFlyZones = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+273:     if Sucess:
+
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_Sucess); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 273, __pyx_L1_error)
+  if (__pyx_t_7) {
+/* … */
+  }
+
+274:         SpriteList += MakeZoneSprites(Message,NoFlyZones)
+
    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeZoneSprites); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 274, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_1 = NULL;
+    __pyx_t_8 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_1)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+        __pyx_t_8 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_Message, __pyx_v_NoFlyZones};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_Message, __pyx_v_NoFlyZones};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 274, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (__pyx_t_1) {
+        __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = NULL;
+      }
+      __Pyx_INCREF(__pyx_v_Message);
+      __Pyx_GIVEREF(__pyx_v_Message);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_8, __pyx_v_Message);
+      __Pyx_INCREF(__pyx_v_NoFlyZones);
+      __Pyx_GIVEREF(__pyx_v_NoFlyZones);
+      PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_8, __pyx_v_NoFlyZones);
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_SpriteList, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 274, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF_SET(__pyx_v_SpriteList, __pyx_t_2);
+    __pyx_t_2 = 0;
+
 275:
+
 276:     #Sprites are created in this function to simplify code in case of an error(False)
+
+277:     print("Refreshed data")
+
  if (__Pyx_PrintOne(0, __pyx_kp_s_Refreshed_data) < 0) __PYX_ERR(0, 277, __pyx_L1_error)
+
+278:     return SpriteList #All sprites which were sucessfully created
+
  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_SpriteList);
+  __pyx_r = __pyx_v_SpriteList;
+  goto __pyx_L0;
+
 279:
+
 280:
+
 281:
+
+282: xpixel = 1200
+
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_xpixel, __pyx_int_1200) < 0) __PYX_ERR(0, 282, __pyx_L1_error)
+
+283: ypixel = 700
+
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ypixel, __pyx_int_700) < 0) __PYX_ERR(0, 283, __pyx_L1_error)
+
+284: Refresh_Delay = 60
+
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_Refresh_Delay, __pyx_int_60) < 0) __PYX_ERR(0, 284, __pyx_L1_error)
+
+285: clock = pygame.time.Clock()
+
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 285, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 285, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Clock); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 285, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 285, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 285, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_clock, __pyx_t_3) < 0) __PYX_ERR(0, 285, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+286: pressed = pygame.key.get_pressed
+
  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_get_pressed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pressed, __pyx_t_3) < 0) __PYX_ERR(0, 286, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+287: Exit = "N"
+
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_Exit, __pyx_n_s_N_2) < 0) __PYX_ERR(0, 287, __pyx_L1_error)
+
+288: while Exit != "Y":
+
  while (1) {
+    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_Exit); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 288, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_Y, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 288, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!__pyx_t_5) break;
+
+289:     try:
+
    {
+      /*try:*/ {
+/* … */
+      }
+      __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;
+      goto __pyx_L11_try_end;
+      __pyx_L4_error:;
+      __Pyx_PyThreadState_assign
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* … */
+      __Pyx_PyThreadState_assign
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+      goto __pyx_L1_error;
+      __pyx_L5_exception_handled:;
+      __Pyx_PyThreadState_assign
+      __Pyx_XGIVEREF(__pyx_t_6);
+      __Pyx_XGIVEREF(__pyx_t_7);
+      __Pyx_XGIVEREF(__pyx_t_8);
+      __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
+      __pyx_L11_try_end:;
+    }
+  }
+
+290:         M = AATC_Monitor.CreateMonitorInterface(IP = "127.0.0.1",Port = 8001)
+
        __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Monitor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 290, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_CreateMonitorInterface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 290, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 290, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_IP, __pyx_kp_s_127_0_0_1) < 0) __PYX_ERR(0, 290, __pyx_L4_error)
+        if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_Port, __pyx_int_8001) < 0) __PYX_ERR(0, 290, __pyx_L4_error)
+        __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 290, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        if (PyDict_SetItem(__pyx_d, __pyx_n_s_M, __pyx_t_2) < 0) __PYX_ERR(0, 290, __pyx_L4_error)
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+291:         M.Login("Zini","")
+
        __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_M); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 291, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Login); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 291, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 291, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+/* … */
+  __pyx_tuple__79 = PyTuple_Pack(2, __pyx_n_s_Zini, __pyx_kp_s__2); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(0, 291, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__79);
+  __Pyx_GIVEREF(__pyx_tuple__79);
+
 292:         #Sucess,Message,Data =  M.GetCoordDetails()
+
 293:         #MinCoords,MaxCoords,StepCoords = Data[0],Data[1],Data[2]
+
+294:         MinCoords,MaxCoords = AATC_Coordinate.Coordinate(0,0,0),AATC_Coordinate.Coordinate(1,1,50)
+
        __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_AATC_Coordinate); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Coordinate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 294, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* … */
+  __pyx_tuple__80 = PyTuple_Pack(3, __pyx_int_0, __pyx_int_0, __pyx_int_0); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(0, 294, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__80);
+  __Pyx_GIVEREF(__pyx_tuple__80);
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        if (PyDict_SetItem(__pyx_d, __pyx_n_s_MinCoords, __pyx_t_2) < 0) __PYX_ERR(0, 294, __pyx_L4_error)
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        if (PyDict_SetItem(__pyx_d, __pyx_n_s_MaxCoords, __pyx_t_3) < 0) __PYX_ERR(0, 294, __pyx_L4_error)
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_tuple__81 = PyTuple_Pack(3, __pyx_int_1, __pyx_int_1, __pyx_int_50); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(0, 294, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__81);
+  __Pyx_GIVEREF(__pyx_tuple__81);
+
+295:         MonCamera = Camera(xpixel,ypixel,MinCoords,MaxCoords)
+
        __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_Camera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 295, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_xpixel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_ypixel); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 295, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_MinCoords); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 295, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_MaxCoords); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 295, __pyx_L4_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __pyx_t_11 = NULL;
+        __pyx_t_12 = 0;
+        if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+          __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_2);
+          if (likely(__pyx_t_11)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+            __Pyx_INCREF(__pyx_t_11);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_2, function);
+            __pyx_t_12 = 1;
+          }
+        }
+        #if CYTHON_FAST_PYCALL
+        if (PyFunction_Check(__pyx_t_2)) {
+          PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_t_1, __pyx_t_4, __pyx_t_9, __pyx_t_10};
+          __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 295, __pyx_L4_error)
+          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        } else
+        #endif
+        #if CYTHON_FAST_PYCCALL
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+          PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_t_1, __pyx_t_4, __pyx_t_9, __pyx_t_10};
+          __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 295, __pyx_L4_error)
+          __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+          __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        } else
+        #endif
+        {
+          __pyx_t_13 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 295, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_13);
+          if (__pyx_t_11) {
+            __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_11); __pyx_t_11 = NULL;
+          }
+          __Pyx_GIVEREF(__pyx_t_1);
+          PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_1);
+          __Pyx_GIVEREF(__pyx_t_4);
+          PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_4);
+          __Pyx_GIVEREF(__pyx_t_9);
+          PyTuple_SET_ITEM(__pyx_t_13, 2+__pyx_t_12, __pyx_t_9);
+          __Pyx_GIVEREF(__pyx_t_10);
+          PyTuple_SET_ITEM(__pyx_t_13, 3+__pyx_t_12, __pyx_t_10);
+          __pyx_t_1 = 0;
+          __pyx_t_4 = 0;
+          __pyx_t_9 = 0;
+          __pyx_t_10 = 0;
+          __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 295, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+        }
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        if (PyDict_SetItem(__pyx_d, __pyx_n_s_MonCamera, __pyx_t_3) < 0) __PYX_ERR(0, 295, __pyx_L4_error)
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+296:         while True:
+
        while (1) {
+
+297:             MonCamera.ResetDrawObject()
+
          __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 297, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ResetDrawObject); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 297, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_13);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __pyx_t_2 = NULL;
+          if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) {
+            __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_13);
+            if (likely(__pyx_t_2)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+              __Pyx_INCREF(__pyx_t_2);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_13, function);
+            }
+          }
+          if (__pyx_t_2) {
+            __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 297, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          } else {
+            __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 297, __pyx_L4_error)
+          }
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+298:             Sprites = MakeSprites(M)
+
          __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MakeSprites); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 298, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_13);
+          __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_M); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 298, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __pyx_t_10 = NULL;
+          if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) {
+            __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_13);
+            if (likely(__pyx_t_10)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+              __Pyx_INCREF(__pyx_t_10);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_13, function);
+            }
+          }
+          if (!__pyx_t_10) {
+            __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            __Pyx_GOTREF(__pyx_t_3);
+          } else {
+            #if CYTHON_FAST_PYCALL
+            if (PyFunction_Check(__pyx_t_13)) {
+              PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_t_2};
+              __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_13, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L4_error)
+              __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+              __Pyx_GOTREF(__pyx_t_3);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            } else
+            #endif
+            #if CYTHON_FAST_PYCCALL
+            if (__Pyx_PyFastCFunction_Check(__pyx_t_13)) {
+              PyObject *__pyx_temp[2] = {__pyx_t_10, __pyx_t_2};
+              __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_13, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L4_error)
+              __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+              __Pyx_GOTREF(__pyx_t_3);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            } else
+            #endif
+            {
+              __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 298, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_9);
+              __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); __pyx_t_10 = NULL;
+              __Pyx_GIVEREF(__pyx_t_2);
+              PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_2);
+              __pyx_t_2 = 0;
+              __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_3);
+              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+            }
+          }
+          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+          if (PyDict_SetItem(__pyx_d, __pyx_n_s_Sprites, __pyx_t_3) < 0) __PYX_ERR(0, 298, __pyx_L4_error)
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
 299:             #font = (None, 30)
+
+300:             for sprite in Sprites:
+
          __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_Sprites); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 300, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
+            __pyx_t_13 = __pyx_t_3; __Pyx_INCREF(__pyx_t_13); __pyx_t_14 = 0;
+            __pyx_t_15 = NULL;
+          } else {
+            __pyx_t_14 = -1; __pyx_t_13 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 300, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __pyx_t_15 = Py_TYPE(__pyx_t_13)->tp_iternext; if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 300, __pyx_L4_error)
+          }
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          for (;;) {
+            if (likely(!__pyx_t_15)) {
+              if (likely(PyList_CheckExact(__pyx_t_13))) {
+                if (__pyx_t_14 >= PyList_GET_SIZE(__pyx_t_13)) break;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                __pyx_t_3 = PyList_GET_ITEM(__pyx_t_13, __pyx_t_14); __Pyx_INCREF(__pyx_t_3); __pyx_t_14++; if (unlikely(0 < 0)) __PYX_ERR(0, 300, __pyx_L4_error)
+                #else
+                __pyx_t_3 = PySequence_ITEM(__pyx_t_13, __pyx_t_14); __pyx_t_14++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 300, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_3);
+                #endif
+              } else {
+                if (__pyx_t_14 >= PyTuple_GET_SIZE(__pyx_t_13)) break;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_13, __pyx_t_14); __Pyx_INCREF(__pyx_t_3); __pyx_t_14++; if (unlikely(0 < 0)) __PYX_ERR(0, 300, __pyx_L4_error)
+                #else
+                __pyx_t_3 = PySequence_ITEM(__pyx_t_13, __pyx_t_14); __pyx_t_14++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 300, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_3);
+                #endif
+              }
+            } else {
+              __pyx_t_3 = __pyx_t_15(__pyx_t_13);
+              if (unlikely(!__pyx_t_3)) {
+                PyObject* exc_type = PyErr_Occurred();
+                if (exc_type) {
+                  if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+                  else __PYX_ERR(0, 300, __pyx_L4_error)
+                }
+                break;
+              }
+              __Pyx_GOTREF(__pyx_t_3);
+            }
+            if (PyDict_SetItem(__pyx_d, __pyx_n_s_sprite, __pyx_t_3) < 0) __PYX_ERR(0, 300, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* … */
+          }
+          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
+301:                 MonCamera.AddDrawObject(sprite,False)
+
            __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 301, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_9);
+            __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_AddDrawObject); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 301, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_2);
+            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+            __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_sprite); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 301, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_9);
+            __pyx_t_10 = NULL;
+            __pyx_t_12 = 0;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+              __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_2);
+              if (likely(__pyx_t_10)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+                __Pyx_INCREF(__pyx_t_10);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_2, function);
+                __pyx_t_12 = 1;
+              }
+            }
+            #if CYTHON_FAST_PYCALL
+            if (PyFunction_Check(__pyx_t_2)) {
+              PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_9, Py_False};
+              __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L4_error)
+              __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+              __Pyx_GOTREF(__pyx_t_3);
+              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+            } else
+            #endif
+            #if CYTHON_FAST_PYCCALL
+            if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+              PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_9, Py_False};
+              __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L4_error)
+              __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+              __Pyx_GOTREF(__pyx_t_3);
+              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+            } else
+            #endif
+            {
+              __pyx_t_4 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 301, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_4);
+              if (__pyx_t_10) {
+                __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_10); __pyx_t_10 = NULL;
+              }
+              __Pyx_GIVEREF(__pyx_t_9);
+              PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_12, __pyx_t_9);
+              __Pyx_INCREF(Py_False);
+              __Pyx_GIVEREF(Py_False);
+              PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_12, Py_False);
+              __pyx_t_9 = 0;
+              __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_3);
+              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            }
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
 302:
+
+303:             Last_Refresh_Time = time.time()
+
          __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 303, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 303, __pyx_L4_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          __pyx_t_3 = NULL;
+          if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+            __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+            if (likely(__pyx_t_3)) {
+              PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+              __Pyx_INCREF(__pyx_t_3);
+              __Pyx_INCREF(function);
+              __Pyx_DECREF_SET(__pyx_t_2, function);
+            }
+          }
+          if (__pyx_t_3) {
+            __pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 303, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          } else {
+            __pyx_t_13 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 303, __pyx_L4_error)
+          }
+          __Pyx_GOTREF(__pyx_t_13);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          if (PyDict_SetItem(__pyx_d, __pyx_n_s_Last_Refresh_Time, __pyx_t_13) < 0) __PYX_ERR(0, 303, __pyx_L4_error)
+          __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
+304:             refresh = False
+
          if (PyDict_SetItem(__pyx_d, __pyx_n_s_refresh, Py_False) < 0) __PYX_ERR(0, 304, __pyx_L4_error)
+
+305:             while not refresh:
+
          while (1) {
+            __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_refresh); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 305, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 305, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __pyx_t_16 = ((!__pyx_t_5) != 0);
+            if (!__pyx_t_16) break;
+
+306:                 MonCamera.CameraWipe()
+
            __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 306, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_2);
+            __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_CameraWipe); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 306, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            __pyx_t_2 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+              __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+              if (likely(__pyx_t_2)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+                __Pyx_INCREF(__pyx_t_2);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_3, function);
+              }
+            }
+            if (__pyx_t_2) {
+              __pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 306, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            } else {
+              __pyx_t_13 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 306, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_13);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
+307:                 if time.time() >= (Last_Refresh_Time + Refresh_Delay):
+
            __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 307, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 307, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_2);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __pyx_t_3 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+              __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+              if (likely(__pyx_t_3)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+                __Pyx_INCREF(__pyx_t_3);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_2, function);
+              }
+            }
+            if (__pyx_t_3) {
+              __pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 307, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            } else {
+              __pyx_t_13 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 307, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_13);
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_Last_Refresh_Time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 307, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_2);
+            __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_Refresh_Delay); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 307, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_4 = PyNumber_Add(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 307, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __pyx_t_3 = PyObject_RichCompare(__pyx_t_13, __pyx_t_4, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 307, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 307, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            if (__pyx_t_16) {
+/* … */
+            }
+
+308:                     refresh = True
+
              if (PyDict_SetItem(__pyx_d, __pyx_n_s_refresh, Py_True) < 0) __PYX_ERR(0, 308, __pyx_L4_error)
+
+309:                 for event in pygame.event.get():
+
            __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 309, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_event); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 309, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_get); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 309, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __pyx_t_13 = NULL;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+              __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4);
+              if (likely(__pyx_t_13)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+                __Pyx_INCREF(__pyx_t_13);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_4, function);
+              }
+            }
+            if (__pyx_t_13) {
+              __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 309, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            } else {
+              __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 309, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
+              __pyx_t_4 = __pyx_t_3; __Pyx_INCREF(__pyx_t_4); __pyx_t_14 = 0;
+              __pyx_t_15 = NULL;
+            } else {
+              __pyx_t_14 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 309, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_4);
+              __pyx_t_15 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 309, __pyx_L4_error)
+            }
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            for (;;) {
+              if (likely(!__pyx_t_15)) {
+                if (likely(PyList_CheckExact(__pyx_t_4))) {
+                  if (__pyx_t_14 >= PyList_GET_SIZE(__pyx_t_4)) break;
+                  #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                  __pyx_t_3 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_14); __Pyx_INCREF(__pyx_t_3); __pyx_t_14++; if (unlikely(0 < 0)) __PYX_ERR(0, 309, __pyx_L4_error)
+                  #else
+                  __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_14); __pyx_t_14++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 309, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_3);
+                  #endif
+                } else {
+                  if (__pyx_t_14 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
+                  #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                  __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_14); __Pyx_INCREF(__pyx_t_3); __pyx_t_14++; if (unlikely(0 < 0)) __PYX_ERR(0, 309, __pyx_L4_error)
+                  #else
+                  __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_14); __pyx_t_14++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 309, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_3);
+                  #endif
+                }
+              } else {
+                __pyx_t_3 = __pyx_t_15(__pyx_t_4);
+                if (unlikely(!__pyx_t_3)) {
+                  PyObject* exc_type = PyErr_Occurred();
+                  if (exc_type) {
+                    if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+                    else __PYX_ERR(0, 309, __pyx_L4_error)
+                  }
+                  break;
+                }
+                __Pyx_GOTREF(__pyx_t_3);
+              }
+              if (PyDict_SetItem(__pyx_d, __pyx_n_s_event, __pyx_t_3) < 0) __PYX_ERR(0, 309, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* … */
+            }
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+310:                     if event.type == pygame.QUIT:
+
              __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 310, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_3);
+              __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_type); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 310, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+              __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 310, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_3);
+              __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_QUIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 310, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_2);
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+              __pyx_t_3 = PyObject_RichCompare(__pyx_t_13, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 310, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 310, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+              if (__pyx_t_16) {
+/* … */
+                goto __pyx_L21;
+              }
+
+311:                         print("Monitor exit was called")
+
                if (__Pyx_PrintOne(0, __pyx_kp_s_Monitor_exit_was_called) < 0) __PYX_ERR(0, 311, __pyx_L4_error)
+
+312:                         pygame.quit()
+
                __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 312, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_quit); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 312, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_13);
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                __pyx_t_2 = NULL;
+                if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) {
+                  __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_13);
+                  if (likely(__pyx_t_2)) {
+                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+                    __Pyx_INCREF(__pyx_t_2);
+                    __Pyx_INCREF(function);
+                    __Pyx_DECREF_SET(__pyx_t_13, function);
+                  }
+                }
+                if (__pyx_t_2) {
+                  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 312, __pyx_L4_error)
+                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                } else {
+                  __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 312, __pyx_L4_error)
+                }
+                __Pyx_GOTREF(__pyx_t_3);
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+313:                         sys.exit()
+
                __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 313, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_13);
+                __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_exit); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 313, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                __pyx_t_13 = NULL;
+                if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+                  __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2);
+                  if (likely(__pyx_t_13)) {
+                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+                    __Pyx_INCREF(__pyx_t_13);
+                    __Pyx_INCREF(function);
+                    __Pyx_DECREF_SET(__pyx_t_2, function);
+                  }
+                }
+                if (__pyx_t_13) {
+                  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 313, __pyx_L4_error)
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                } else {
+                  __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 313, __pyx_L4_error)
+                }
+                __Pyx_GOTREF(__pyx_t_3);
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
 314:
+
+315:                     elif event.type == pygame.MOUSEBUTTONDOWN:
+
              __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_event); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 315, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_3);
+              __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 315, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_2);
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+              __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 315, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_3);
+              __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_MOUSEBUTTONDOWN); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 315, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+              __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_t_13, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 315, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 315, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+              if (__pyx_t_16) {
+/* … */
+                goto __pyx_L21;
+              }
+
+316:                         print("Camera details")                  #Mainly for debugging
+
                if (__Pyx_PrintOne(0, __pyx_kp_s_Camera_details) < 0) __PYX_ERR(0, 316, __pyx_L4_error)
+
+317:                         print(MonCamera.GetZoom())
+
                __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 317, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_13);
+                __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_GetZoom); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 317, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                __pyx_t_13 = NULL;
+                if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+                  __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2);
+                  if (likely(__pyx_t_13)) {
+                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+                    __Pyx_INCREF(__pyx_t_13);
+                    __Pyx_INCREF(function);
+                    __Pyx_DECREF_SET(__pyx_t_2, function);
+                  }
+                }
+                if (__pyx_t_13) {
+                  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 317, __pyx_L4_error)
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                } else {
+                  __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 317, __pyx_L4_error)
+                }
+                __Pyx_GOTREF(__pyx_t_3);
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 317, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+318:                         print(MonCamera.CameraCoord.Get_X())
+
                __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 318, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 318, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_13);
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_Get_X); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 318, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                __pyx_t_13 = NULL;
+                if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+                  __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2);
+                  if (likely(__pyx_t_13)) {
+                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+                    __Pyx_INCREF(__pyx_t_13);
+                    __Pyx_INCREF(function);
+                    __Pyx_DECREF_SET(__pyx_t_2, function);
+                  }
+                }
+                if (__pyx_t_13) {
+                  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 318, __pyx_L4_error)
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                } else {
+                  __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 318, __pyx_L4_error)
+                }
+                __Pyx_GOTREF(__pyx_t_3);
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 318, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+319:                         print(MonCamera.CameraCoord.Get_Y())
+
                __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 319, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 319, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_13);
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_Get_Y); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 319, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                __pyx_t_13 = NULL;
+                if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+                  __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2);
+                  if (likely(__pyx_t_13)) {
+                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+                    __Pyx_INCREF(__pyx_t_13);
+                    __Pyx_INCREF(function);
+                    __Pyx_DECREF_SET(__pyx_t_2, function);
+                  }
+                }
+                if (__pyx_t_13) {
+                  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 319, __pyx_L4_error)
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                } else {
+                  __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 319, __pyx_L4_error)
+                }
+                __Pyx_GOTREF(__pyx_t_3);
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 319, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+320:                         print(MonCamera.CameraCoord.Get_XSize())
+
                __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 320, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 320, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_13);
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 320, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                __pyx_t_13 = NULL;
+                if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+                  __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2);
+                  if (likely(__pyx_t_13)) {
+                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+                    __Pyx_INCREF(__pyx_t_13);
+                    __Pyx_INCREF(function);
+                    __Pyx_DECREF_SET(__pyx_t_2, function);
+                  }
+                }
+                if (__pyx_t_13) {
+                  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 320, __pyx_L4_error)
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                } else {
+                  __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 320, __pyx_L4_error)
+                }
+                __Pyx_GOTREF(__pyx_t_3);
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 320, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+321:                         print(MonCamera.CameraCoord.Get_YSize())
+
                __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 321, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_13);
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_Get_YSize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                __pyx_t_13 = NULL;
+                if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+                  __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2);
+                  if (likely(__pyx_t_13)) {
+                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+                    __Pyx_INCREF(__pyx_t_13);
+                    __Pyx_INCREF(function);
+                    __Pyx_DECREF_SET(__pyx_t_2, function);
+                  }
+                }
+                if (__pyx_t_13) {
+                  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 321, __pyx_L4_error)
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                } else {
+                  __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 321, __pyx_L4_error)
+                }
+                __Pyx_GOTREF(__pyx_t_3);
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 321, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+322:                         print(len(MonCamera.DrawObjects))
+
                __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 322, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_3);
+                __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_DrawObjects); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 322, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+                __pyx_t_17 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_17 == -1)) __PYX_ERR(0, 322, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_17); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 322, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(0, 322, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+323:                         print("FPS:"+str(clock.get_fps()))
+
                __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_clock); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_3);
+                __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_get_fps); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 323, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_13);
+                __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+                __pyx_t_3 = NULL;
+                if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) {
+                  __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_13);
+                  if (likely(__pyx_t_3)) {
+                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+                    __Pyx_INCREF(__pyx_t_3);
+                    __Pyx_INCREF(function);
+                    __Pyx_DECREF_SET(__pyx_t_13, function);
+                  }
+                }
+                if (__pyx_t_3) {
+                  __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 323, __pyx_L4_error)
+                  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+                } else {
+                  __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 323, __pyx_L4_error)
+                }
+                __Pyx_GOTREF(__pyx_t_2);
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                __pyx_t_13 = PyTuple_New(1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 323, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_13);
+                __Pyx_GIVEREF(__pyx_t_2);
+                PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_2);
+                __pyx_t_2 = 0;
+                __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 323, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_2);
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                __pyx_t_13 = PyNumber_Add(__pyx_kp_s_FPS, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 323, __pyx_L4_error)
+                __Pyx_GOTREF(__pyx_t_13);
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                if (__Pyx_PrintOne(0, __pyx_t_13) < 0) __PYX_ERR(0, 323, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
+324:                     elif event.type == pygame.KEYDOWN:
+
              __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_event); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 324, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 324, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_2);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 324, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_KEYDOWN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 324, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_3);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __pyx_t_13 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 324, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+              __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 324, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              if (__pyx_t_16) {
+              }
+              __pyx_L21:;
+
 325:                         pass
+
 326:
+
 327:
+
+328:                 CameraCoord = MonCamera.Get_Coord()
+
            __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 328, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_Get_Coord); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 328, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __pyx_t_13 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+              __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_3);
+              if (likely(__pyx_t_13)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+                __Pyx_INCREF(__pyx_t_13);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_3, function);
+              }
+            }
+            if (__pyx_t_13) {
+              __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 328, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            } else {
+              __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 328, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            if (PyDict_SetItem(__pyx_d, __pyx_n_s_CameraCoord, __pyx_t_4) < 0) __PYX_ERR(0, 328, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+329:                 if pressed()[pygame.K_w]:   #Shift camera
+
            __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 329, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_13 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+              __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_3);
+              if (likely(__pyx_t_13)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+                __Pyx_INCREF(__pyx_t_13);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_3, function);
+              }
+            }
+            if (__pyx_t_13) {
+              __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 329, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            } else {
+              __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 329, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 329, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_K_w); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 329, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __pyx_t_3 = PyObject_GetItem(__pyx_t_4, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 329, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 329, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            if (__pyx_t_16) {
+/* … */
+            }
+
+330:                     MonCamera.IncrementCameraCoordY(-0.01*CameraCoord.Get_XSize())  #/ as Greater zoom means need more fidelety
+
              __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 330, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_IncrementCameraCoordY); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 330, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_4);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 330, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_2);
+              __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 330, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_9);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              __pyx_t_2 = NULL;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) {
+                __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9);
+                if (likely(__pyx_t_2)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+                  __Pyx_INCREF(__pyx_t_2);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_9, function);
+                }
+              }
+              if (__pyx_t_2) {
+                __pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 330, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              } else {
+                __pyx_t_13 = __Pyx_PyObject_CallNoArg(__pyx_t_9); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 330, __pyx_L4_error)
+              }
+              __Pyx_GOTREF(__pyx_t_13);
+              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+              __pyx_t_9 = PyNumber_Multiply(__pyx_float_neg_0_01, __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 330, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_9);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __pyx_t_13 = NULL;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+                __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4);
+                if (likely(__pyx_t_13)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+                  __Pyx_INCREF(__pyx_t_13);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_4, function);
+                }
+              }
+              if (!__pyx_t_13) {
+                __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+                __Pyx_GOTREF(__pyx_t_3);
+              } else {
+                #if CYTHON_FAST_PYCALL
+                if (PyFunction_Check(__pyx_t_4)) {
+                  PyObject *__pyx_temp[2] = {__pyx_t_13, __pyx_t_9};
+                  __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L4_error)
+                  __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+                  __Pyx_GOTREF(__pyx_t_3);
+                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+                } else
+                #endif
+                #if CYTHON_FAST_PYCCALL
+                if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+                  PyObject *__pyx_temp[2] = {__pyx_t_13, __pyx_t_9};
+                  __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L4_error)
+                  __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+                  __Pyx_GOTREF(__pyx_t_3);
+                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+                } else
+                #endif
+                {
+                  __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 330, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_2);
+                  __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_13); __pyx_t_13 = NULL;
+                  __Pyx_GIVEREF(__pyx_t_9);
+                  PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_9);
+                  __pyx_t_9 = 0;
+                  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_3);
+                  __Pyx_DECREF(__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;
+
+331:                 if pressed()[pygame.K_s]:
+
            __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 331, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __pyx_t_2 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+              __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
+              if (likely(__pyx_t_2)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+                __Pyx_INCREF(__pyx_t_2);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_4, function);
+              }
+            }
+            if (__pyx_t_2) {
+              __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 331, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            } else {
+              __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 331, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 331, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_K_s); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 331, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_2);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __pyx_t_4 = PyObject_GetItem(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 331, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 331, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            if (__pyx_t_16) {
+/* … */
+            }
+
+332:                     MonCamera.IncrementCameraCoordY(0.01*CameraCoord.Get_XSize())
+
              __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 332, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_2);
+              __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_IncrementCameraCoordY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 332, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_3);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 332, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_9);
+              __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 332, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+              __pyx_t_9 = NULL;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) {
+                __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_13);
+                if (likely(__pyx_t_9)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+                  __Pyx_INCREF(__pyx_t_9);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_13, function);
+                }
+              }
+              if (__pyx_t_9) {
+                __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 332, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+              } else {
+                __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 332, __pyx_L4_error)
+              }
+              __Pyx_GOTREF(__pyx_t_2);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __pyx_t_13 = PyNumber_Multiply(__pyx_float_0_01, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 332, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              __pyx_t_2 = NULL;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+                __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+                if (likely(__pyx_t_2)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+                  __Pyx_INCREF(__pyx_t_2);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_3, function);
+                }
+              }
+              if (!__pyx_t_2) {
+                __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 332, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                __Pyx_GOTREF(__pyx_t_4);
+              } else {
+                #if CYTHON_FAST_PYCALL
+                if (PyFunction_Check(__pyx_t_3)) {
+                  PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_13};
+                  __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 332, __pyx_L4_error)
+                  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+                  __Pyx_GOTREF(__pyx_t_4);
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                } else
+                #endif
+                #if CYTHON_FAST_PYCCALL
+                if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+                  PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_13};
+                  __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 332, __pyx_L4_error)
+                  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+                  __Pyx_GOTREF(__pyx_t_4);
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                } else
+                #endif
+                {
+                  __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 332, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_9);
+                  __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); __pyx_t_2 = NULL;
+                  __Pyx_GIVEREF(__pyx_t_13);
+                  PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_13);
+                  __pyx_t_13 = 0;
+                  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 332, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_4);
+                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+                }
+              }
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+333:                 if pressed()[pygame.K_a]:
+
            __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_9 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+              __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3);
+              if (likely(__pyx_t_9)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+                __Pyx_INCREF(__pyx_t_9);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_3, function);
+              }
+            }
+            if (__pyx_t_9) {
+              __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 333, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+            } else {
+              __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 333, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_K_a); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 333, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_9);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __pyx_t_3 = PyObject_GetItem(__pyx_t_4, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+            __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 333, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            if (__pyx_t_16) {
+/* … */
+            }
+
+334:                     MonCamera.IncrementCameraCoordX(-0.01*CameraCoord.Get_XSize())
+
              __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 334, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_9);
+              __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_IncrementCameraCoordX); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 334, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_4);
+              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+              __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 334, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 334, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_2);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __pyx_t_13 = NULL;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+                __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2);
+                if (likely(__pyx_t_13)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+                  __Pyx_INCREF(__pyx_t_13);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_2, function);
+                }
+              }
+              if (__pyx_t_13) {
+                __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 334, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              } else {
+                __pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 334, __pyx_L4_error)
+              }
+              __Pyx_GOTREF(__pyx_t_9);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              __pyx_t_2 = PyNumber_Multiply(__pyx_float_neg_0_01, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 334, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_2);
+              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+              __pyx_t_9 = NULL;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+                __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4);
+                if (likely(__pyx_t_9)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+                  __Pyx_INCREF(__pyx_t_9);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_4, function);
+                }
+              }
+              if (!__pyx_t_9) {
+                __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                __Pyx_GOTREF(__pyx_t_3);
+              } else {
+                #if CYTHON_FAST_PYCALL
+                if (PyFunction_Check(__pyx_t_4)) {
+                  PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_2};
+                  __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L4_error)
+                  __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+                  __Pyx_GOTREF(__pyx_t_3);
+                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                } else
+                #endif
+                #if CYTHON_FAST_PYCCALL
+                if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+                  PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_2};
+                  __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L4_error)
+                  __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+                  __Pyx_GOTREF(__pyx_t_3);
+                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                } else
+                #endif
+                {
+                  __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 334, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_13);
+                  __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_9); __pyx_t_9 = NULL;
+                  __Pyx_GIVEREF(__pyx_t_2);
+                  PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_2);
+                  __pyx_t_2 = 0;
+                  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_3);
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                }
+              }
+              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+335:                 if pressed()[pygame.K_d]:
+
            __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 335, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __pyx_t_13 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+              __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4);
+              if (likely(__pyx_t_13)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+                __Pyx_INCREF(__pyx_t_13);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_4, function);
+              }
+            }
+            if (__pyx_t_13) {
+              __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 335, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            } else {
+              __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 335, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 335, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_K_d); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 335, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __pyx_t_4 = PyObject_GetItem(__pyx_t_3, __pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 335, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 335, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            if (__pyx_t_16) {
+/* … */
+            }
+
+336:                     MonCamera.IncrementCameraCoordX(0.01*CameraCoord.Get_XSize())
+
              __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 336, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_IncrementCameraCoordX); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 336, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_3);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CameraCoord); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 336, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_2);
+              __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Get_XSize); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 336, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_9);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              __pyx_t_2 = NULL;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) {
+                __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9);
+                if (likely(__pyx_t_2)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
+                  __Pyx_INCREF(__pyx_t_2);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_9, function);
+                }
+              }
+              if (__pyx_t_2) {
+                __pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 336, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              } else {
+                __pyx_t_13 = __Pyx_PyObject_CallNoArg(__pyx_t_9); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 336, __pyx_L4_error)
+              }
+              __Pyx_GOTREF(__pyx_t_13);
+              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+              __pyx_t_9 = PyNumber_Multiply(__pyx_float_0_01, __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 336, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_9);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __pyx_t_13 = NULL;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+                __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_3);
+                if (likely(__pyx_t_13)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+                  __Pyx_INCREF(__pyx_t_13);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_3, function);
+                }
+              }
+              if (!__pyx_t_13) {
+                __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 336, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+                __Pyx_GOTREF(__pyx_t_4);
+              } else {
+                #if CYTHON_FAST_PYCALL
+                if (PyFunction_Check(__pyx_t_3)) {
+                  PyObject *__pyx_temp[2] = {__pyx_t_13, __pyx_t_9};
+                  __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 336, __pyx_L4_error)
+                  __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+                  __Pyx_GOTREF(__pyx_t_4);
+                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+                } else
+                #endif
+                #if CYTHON_FAST_PYCCALL
+                if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+                  PyObject *__pyx_temp[2] = {__pyx_t_13, __pyx_t_9};
+                  __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 336, __pyx_L4_error)
+                  __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+                  __Pyx_GOTREF(__pyx_t_4);
+                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+                } else
+                #endif
+                {
+                  __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 336, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_2);
+                  __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_13); __pyx_t_13 = NULL;
+                  __Pyx_GIVEREF(__pyx_t_9);
+                  PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_9);
+                  __pyx_t_9 = 0;
+                  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 336, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_4);
+                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                }
+              }
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
 337:
+
+338:                 if pressed()[pygame.K_q]:#Zoom out
+
            __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 338, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_2 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+              __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+              if (likely(__pyx_t_2)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+                __Pyx_INCREF(__pyx_t_2);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_3, function);
+              }
+            }
+            if (__pyx_t_2) {
+              __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 338, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            } else {
+              __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 338, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 338, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_K_q); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 338, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_2);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __pyx_t_3 = PyObject_GetItem(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 338, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 338, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            if (__pyx_t_16) {
+/* … */
+            }
+
+339:                     MonCamera.SetZoom(0.99*MonCamera.GetZoom())
+
              __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 339, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_2);
+              __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_SetZoom); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 339, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_4);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 339, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_9);
+              __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_GetZoom); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 339, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+              __pyx_t_9 = NULL;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) {
+                __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_13);
+                if (likely(__pyx_t_9)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+                  __Pyx_INCREF(__pyx_t_9);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_13, function);
+                }
+              }
+              if (__pyx_t_9) {
+                __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 339, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+              } else {
+                __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 339, __pyx_L4_error)
+              }
+              __Pyx_GOTREF(__pyx_t_2);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __pyx_t_13 = PyNumber_Multiply(__pyx_float_0_99, __pyx_t_2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 339, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              __pyx_t_2 = NULL;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+                __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
+                if (likely(__pyx_t_2)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+                  __Pyx_INCREF(__pyx_t_2);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_4, function);
+                }
+              }
+              if (!__pyx_t_2) {
+                __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 339, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                __Pyx_GOTREF(__pyx_t_3);
+              } else {
+                #if CYTHON_FAST_PYCALL
+                if (PyFunction_Check(__pyx_t_4)) {
+                  PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_13};
+                  __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 339, __pyx_L4_error)
+                  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+                  __Pyx_GOTREF(__pyx_t_3);
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                } else
+                #endif
+                #if CYTHON_FAST_PYCCALL
+                if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+                  PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_13};
+                  __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 339, __pyx_L4_error)
+                  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+                  __Pyx_GOTREF(__pyx_t_3);
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                } else
+                #endif
+                {
+                  __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 339, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_9);
+                  __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2); __pyx_t_2 = NULL;
+                  __Pyx_GIVEREF(__pyx_t_13);
+                  PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_13);
+                  __pyx_t_13 = 0;
+                  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 339, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_3);
+                  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+                }
+              }
+              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+340:                 if pressed()[pygame.K_e]:#Zoom in
+
            __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 340, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __pyx_t_9 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+              __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4);
+              if (likely(__pyx_t_9)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+                __Pyx_INCREF(__pyx_t_9);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_4, function);
+              }
+            }
+            if (__pyx_t_9) {
+              __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 340, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+            } else {
+              __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 340, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 340, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_K_e); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 340, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_9);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __pyx_t_4 = PyObject_GetItem(__pyx_t_3, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 340, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+            __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 340, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            if (__pyx_t_16) {
+/* … */
+            }
+
+341:                     MonCamera.SetZoom(1.01*MonCamera.GetZoom())
+
              __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 341, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_9);
+              __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_SetZoom); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 341, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_3);
+              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+              __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 341, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_13);
+              __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_GetZoom); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 341, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_2);
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              __pyx_t_13 = NULL;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+                __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2);
+                if (likely(__pyx_t_13)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+                  __Pyx_INCREF(__pyx_t_13);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_2, function);
+                }
+              }
+              if (__pyx_t_13) {
+                __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 341, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+              } else {
+                __pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 341, __pyx_L4_error)
+              }
+              __Pyx_GOTREF(__pyx_t_9);
+              __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+              __pyx_t_2 = PyNumber_Multiply(__pyx_float_1_01, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 341, __pyx_L4_error)
+              __Pyx_GOTREF(__pyx_t_2);
+              __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+              __pyx_t_9 = NULL;
+              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+                __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3);
+                if (likely(__pyx_t_9)) {
+                  PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+                  __Pyx_INCREF(__pyx_t_9);
+                  __Pyx_INCREF(function);
+                  __Pyx_DECREF_SET(__pyx_t_3, function);
+                }
+              }
+              if (!__pyx_t_9) {
+                __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L4_error)
+                __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                __Pyx_GOTREF(__pyx_t_4);
+              } else {
+                #if CYTHON_FAST_PYCALL
+                if (PyFunction_Check(__pyx_t_3)) {
+                  PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_2};
+                  __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L4_error)
+                  __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+                  __Pyx_GOTREF(__pyx_t_4);
+                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                } else
+                #endif
+                #if CYTHON_FAST_PYCCALL
+                if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+                  PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_2};
+                  __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L4_error)
+                  __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+                  __Pyx_GOTREF(__pyx_t_4);
+                  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+                } else
+                #endif
+                {
+                  __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 341, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_13);
+                  __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_9); __pyx_t_9 = NULL;
+                  __Pyx_GIVEREF(__pyx_t_2);
+                  PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_2);
+                  __pyx_t_2 = 0;
+                  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_13, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L4_error)
+                  __Pyx_GOTREF(__pyx_t_4);
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                }
+              }
+              __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
 342:
+
+343:                 if pressed()[pygame.K_SPACE]:#Zoom in
+
            __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pressed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 343, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_13 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+              __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_3);
+              if (likely(__pyx_t_13)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+                __Pyx_INCREF(__pyx_t_13);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_3, function);
+              }
+            }
+            if (__pyx_t_13) {
+              __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 343, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            } else {
+              __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 343, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 343, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_K_SPACE); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 343, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __pyx_t_3 = PyObject_GetItem(__pyx_t_4, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 343, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 343, __pyx_L4_error)
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            if (__pyx_t_16) {
+/* … */
+            }
+
+344:                     refresh = True
+
              if (PyDict_SetItem(__pyx_d, __pyx_n_s_refresh, Py_True) < 0) __PYX_ERR(0, 344, __pyx_L4_error)
+
 345:
+
 346:
+
+347:                 MonCamera.UpdateCameraSize()
+
            __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 347, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_UpdateCameraSize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 347, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __pyx_t_13 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+              __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4);
+              if (likely(__pyx_t_13)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+                __Pyx_INCREF(__pyx_t_13);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_4, function);
+              }
+            }
+            if (__pyx_t_13) {
+              __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 347, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            } else {
+              __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 347, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+348:                 MonCamera.Draw()
+
            __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_MonCamera); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 348, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Draw); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 348, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __pyx_t_4 = NULL;
+            if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) {
+              __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_13);
+              if (likely(__pyx_t_4)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+                __Pyx_INCREF(__pyx_t_4);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_13, function);
+              }
+            }
+            if (__pyx_t_4) {
+              __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 348, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            } else {
+              __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 348, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+349:                 pygame.display.flip()
+
            __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_pygame); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 349, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_display); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 349, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_4);
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_flip); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 349, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            __pyx_t_4 = NULL;
+            if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) {
+              __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_13);
+              if (likely(__pyx_t_4)) {
+                PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+                __Pyx_INCREF(__pyx_t_4);
+                __Pyx_INCREF(function);
+                __Pyx_DECREF_SET(__pyx_t_13, function);
+              }
+            }
+            if (__pyx_t_4) {
+              __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 349, __pyx_L4_error)
+              __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+            } else {
+              __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 349, __pyx_L4_error)
+            }
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+350:                 clock.tick(60)
+
            __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_clock); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 350, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_tick); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 350, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_13);
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+            __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 350, __pyx_L4_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+          }
+        }
+/* … */
+  __pyx_tuple__82 = PyTuple_Pack(1, __pyx_int_60); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(0, 350, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__82);
+  __Pyx_GIVEREF(__pyx_tuple__82);
+
 351:
+
 352:
+
 353:
+
+354:     except Exception as e:
+
      __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+      if (__pyx_t_12) {
+        __Pyx_AddTraceback("CAStar.AATC_Monitor_Viewer", __pyx_clineno, __pyx_lineno, __pyx_filename);
+        if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_13, &__pyx_t_4) < 0) __PYX_ERR(0, 354, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_t_13);
+        __Pyx_GOTREF(__pyx_t_4);
+        if (PyDict_SetItem(__pyx_d, __pyx_n_s_e, __pyx_t_13) < 0) __PYX_ERR(0, 354, __pyx_L6_except_error)
+
+355:         print(e)
+
        __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_e); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 355, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(0, 355, __pyx_L6_except_error)
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+356:         print("An error occured, restarting main loop")
+
        if (__Pyx_PrintOne(0, __pyx_kp_s_An_error_occured_restarting_main) < 0) __PYX_ERR(0, 356, __pyx_L6_except_error)
+
+357:         Exit = input("Exit? Y/N").upper()
+
        __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_input, __pyx_tuple__83, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 357, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_upper); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 357, __pyx_L6_except_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __pyx_t_9 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
+          __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10);
+          if (likely(__pyx_t_9)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
+            __Pyx_INCREF(__pyx_t_9);
+            __Pyx_INCREF(function);
+            __Pyx_DECREF_SET(__pyx_t_10, function);
+          }
+        }
+        if (__pyx_t_9) {
+          __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 357, __pyx_L6_except_error)
+          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        } else {
+          __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 357, __pyx_L6_except_error)
+        }
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        if (PyDict_SetItem(__pyx_d, __pyx_n_s_Exit, __pyx_t_2) < 0) __PYX_ERR(0, 357, __pyx_L6_except_error)
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        goto __pyx_L5_exception_handled;
+      }
+      goto __pyx_L6_except_error;
+      __pyx_L6_except_error:;
+
 358:
+
 359:
+
 360:
+
 361:
+
 362:
+
 363:
+
 364:
+
 365:
+
 366:
+
 367:
+
 368:
+
 369:
+
 370:
+
 371:
+
 372:
+
 373:
+
 374:
+
 375:
+
diff --git a/CAStar/AATC_Monitor_Viewer.pyx b/CAStar/AATC_Monitor_Viewer.pyx new file mode 100644 index 0000000..ec1f3e3 --- /dev/null +++ b/CAStar/AATC_Monitor_Viewer.pyx @@ -0,0 +1,375 @@ +#!python +#cython: boundscheck=False, wraparound=False, infer_types=True,cdivision = True + +import pygame,AATC_Monitor,time,ast,sys,random,AATC_Coordinate + +pygame.init() + +_images= {} +def GetImage(xSize,ySize,Colour): #Efficiently get images + result = _images.get((xSize,ySize,Colour)) + if result == None: + result = pygame.Surface((xSize,ySize)).convert() + result.fill(Colour) + _images[(xSize,ySize,Colour)]=result + while len(_images) > 1500: + _images.pop(random.sample(_images.keys(),1)[0]) #If cache is full evict old versions + return result#_copy + +_texts= {} +def GetText(Text,fontParameters,AA,Colour): #Efficiently get text + result = _texts.get((Text,fontParameters,AA,Colour)) + if result == None: + result = GetFont(*fontParameters).render(Text,AA,Colour) + _texts[(Text,fontParameters,AA,Colour)]=result + while len(_texts) > 1500: + _texts.pop(random.sample(_texts.keys(),1)[0]) #If cache is full evict old versions + return result + + +_fonts = {} +def GetFont(Font,Size): + result = _fonts.get((Font,Size)) + if result == None: + result = pygame.font.Font(Font,Size) + _fonts[(Font,Size)]=result + while len(_fonts) > 1500: + _fonts.pop(random.sample(_fonts.keys(),1)[0]) #If cache is full evict old versions + return result + + +cdef int MaxLimit( int value, int Max): + if value > Max: + value = Max + return value + + + +class Camera: + def __init__(self,xpixel,ypixel,MinCoords,MaxCoords): #COORDS (X,Y,Z) + self.xpixel = xpixel + self.ypixel = ypixel + self.gameDisplay = pygame.display.set_mode((self.xpixel,self.ypixel)) + self.MinCoords = MinCoords + self.MaxCoords = MaxCoords + self.CameraCoord = self.MinCoords.copy() + self.CameraCoord.Set_XSize( self.MaxCoords.Get_X() - self.MinCoords.Get_X()) + self.CameraCoord.Set_YSize( self.MaxCoords.Get_Y() - self.MinCoords.Get_Y()) + self.CameraZoom = 1 + self.DrawObjects = [] + + def GetZoom(self): + return self.CameraZoom + def SetZoom(self,Zoom): + self.CameraZoom = Zoom + + def GetCameraCoords(self): + return self.CameraCoord + def IncrementCameraCoordX(self,Amount): + self.CameraCoord.Set_X( Amount+self.CameraCoord.Get_X()) + + def IncrementCameraCoordY(self,Amount): + self.CameraCoord.Set_Y( Amount+self.CameraCoord.Get_Y()) + + def SetCameraCoords(self,CameraX,CameraY): + self.CameraCoord.Set_X( CameraX) + self.CameraCoord.Set_Y(CameraY) + + def UpdateCameraSize(self): #Gets width of map divided by zoom level eg at zoom 1x it has whole map + self.CameraCoord.Set_XSize ((self.MaxCoords.Get_X() - self.MinCoords.Get_X())/self.CameraZoom) + self.CameraCoord.Set_YSize ((self.MaxCoords.Get_Y() - self.MinCoords.Get_Y())/self.CameraZoom) + + def CameraWipe(self,Colour = (0,0,0)): + self.gameDisplay.fill(Colour) + def ResetDrawObject(self): + self.DrawObjects = [] + def AddDrawObject(self,Object,ForceDraw): + self.DrawObjects.append({"Object":Object,"ForceDraw":ForceDraw}) + + def Get_Coord(self): + return self.CameraCoord + + def Draw(self): + cdef float CameraEndX,CameraEndY,CameraX,CameraY,CameraXSize,CameraYSize,x,y,xSize,ySize,PosX,PosY + cdef int width,height,xpixel,ypixel,font_size + + CameraEndX= self.CameraCoord.Get_X() + self.CameraCoord.Get_XSize() #Moved to new variablt to reduce recalculation + CameraEndY = self.CameraCoord.Get_Y() + self.CameraCoord.Get_YSize() + CameraX = self.CameraCoord.Get_X() + CameraY = self.CameraCoord.Get_Y() + CameraXSize = self.CameraCoord.Get_XSize() + CameraYSize = self.CameraCoord.Get_YSize() + xpixel,ypixel = self.xpixel,self.ypixel + + for DrawObject in self.DrawObjects: + Object = DrawObject["Object"] + Object_Coords = Object.Get_Coords() + x = Object_Coords.Get_X() + y = Object_Coords.Get_Y() + xSize = Object_Coords.Get_XSize() + ySize = Object_Coords.Get_YSize() + if ((x < CameraEndX) and ((x+xSize) > CameraX)) and \ + ((y < CameraEndY) and ((y+ySize) > CameraY )) : #If DrawObject intersects with Camera , Render, otherwise ignore + + + width,height = int(xSize/CameraXSize*xpixel) ,int(ySize/CameraYSize*ypixel) # Would benifit from being cythonised + if width > 0 and height > 0: + PosX = ((x- CameraX)/CameraXSize)* xpixel # Would benifit from being cythonised + PosY = ((y- CameraY)/CameraYSize)* ypixel + width = MaxLimit(width,xpixel) + height = MaxLimit(height,ypixel) + font_size = int(100*width/xpixel) # Would benifit from being cythonised + image = Object.Make_Image(width,height) + self.gameDisplay.blit(image,(PosX,PosY)) + if font_size > 5: + font = (None, font_size) + self.gameDisplay.blit(Object.Make_Text(font) ,(PosX+width,PosY)) + + + + + + +class Monitor_Sprite(pygame.sprite.Sprite): + def __init__(self,CoordObject,Type = "",Text = "",Colour = (255,255,255)): + self.Coords = CoordObject + self.Type = Type + self.Text = Text + self.Colour = Colour + self.image = pygame.Surface((1,1)) + #self.Make_Image(2,2) # No longer needed, is similar to that above. + + def Make_Image(self, int width, int height): + if self.image.get_size() != (width,height): #If new image does not match with previous + self.image = GetImage(width,height,self.Colour) + + return self.image +## self.image = pygame.Surface((width,height)).convert() +## self.image.fill(self.Colour) + + def Make_Text(self,font): + text = str((self.Coords.Get_X(),self.Coords.Get_Y(),self.Coords.Get_Z())) +" " +self.Text + " "+ self.Type + return GetText(text,font,False,self.Colour) + + def Get_Coords(self): + return self.Coords +## +## def Make_CoordsText(self,font): +## self.CoordsText = GetText(str((self.Coords.x,self.Coords.y,self.Coords.z)),font,False,self.Colour) +## #self.CoordsText = font.render(str((self.Coords.x,self.Coords.y,self.Coords.z)),False,self.Colour) +## +## def Make_Text(self,font): +## self.DrawnText = GetText(self.Text,font,False,self.Colour) +## #self.DrawnText = font.render(self.Text,False,self.Colour) +## +## def Make_Type(self,font): +## self.DrawnType = GetText(self.Type,font,False,self.Colour) +## #self.DrawnType = font.render(self.Type,False,self.Colour) + + +def MakeDroneSprites(Message,RawDroneList): + DroneList = [] + Columns = ast.literal_eval(Message) + CoordIndex = Columns.index("LastCoords") + DroneIDIndex = Columns.index("DroneID") + UserIDIndex = Columns.index("UserID") + DroneNameIndex = Columns.index("DroneName") + BatteryIndex = Columns.index("LastBattery") + for Drone in RawDroneList: + LastCoords = ast.literal_eval(Drone[CoordIndex]) + Coord = AATC_Coordinate.Coordinate(LastCoords[0],LastCoords[1],LastCoords[2],0.001,0.001,0.00001) + Text = "D:"+str(Drone[DroneIDIndex]) +" U:"+str(Drone[UserIDIndex]) +" N:"+str(Drone[DroneNameIndex])+" B:"+str(Drone[BatteryIndex]) + Colour = (255,255,255) + Sprite = Monitor_Sprite(Coord,"Drone",Text,Colour) + DroneList.append(Sprite) + return DroneList + +def MakeFlightSprites(Message,RawFlightList): + FlightList = [] + Columns = ast.literal_eval(Message) + FlightIDIndex = Columns.index("FlightID") + DroneIDIndex = Columns.index("DroneID") + StartCoordsIndex = Columns.index("StartCoords") + EndCoordsIndex = Columns.index("EndCoords") + StartTimeIndex = Columns.index("StartTime") + ETAIndex = Columns.index("ETA") + EndTimeIndex = Columns.index("EndTime") + DistanceIndex = Columns.index("Distance") + for Flight in RawFlightList: + #Start Sprite + Coords = ast.literal_eval(Flight[StartCoordsIndex]) + Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.0001,0.0001,0.00001) + Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ST:"+str(Flight[StartTimeIndex]) + Colour = (0,0,255) + FlightList.append(Monitor_Sprite(Coord,"StartPoint",Text,Colour)) + + #End Sprite + Coords = ast.literal_eval(Flight[EndCoordsIndex]) + Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.0001,0.0001,0.00001) + Text = "F:"+ str(Flight[FlightIDIndex])+" D:"+ str(Flight[DroneIDIndex])+ "ETA:"+str(Flight[ETAIndex]) + Colour = (255,0,0) + FlightList.append(Monitor_Sprite(Coord,"EndPoint",Text,Colour)) + return FlightList + + +def MakeWaypointSprites(Message,RawWaypointList): + WaypointList = [] + Columns = ast.literal_eval(Message) + CoordIndex = Columns.index("Coords") + WaypointNumberIndex = Columns.index("WaypointNumber") + FlightIDIndex = Columns.index("FlightID") + for Waypoint in RawWaypointList: + Coords = ast.literal_eval(Waypoint[CoordIndex]) + Coord = AATC_Coordinate.Coordinate(Coords[0],Coords[1],Coords[2],0.001,0.001,0.00001) + Text = "F:"+ str(Waypoint[FlightIDIndex]) +" W:"+ str(Waypoint[WaypointNumberIndex]) + Colour = (0,255,0) + WaypointList.append(Monitor_Sprite(Coord,"Waypoint",Text,Colour)) + return WaypointList + +def MakeZoneSprites(Message,RawZoneList): + ZoneList = [] + Columns = ast.literal_eval(Message) + StartCoordIndex = Columns.index("StartCoord") + EndCoordIndex = Columns.index("EndCoord") + LevelIndex = Columns.index("Level") + ZoneIDIndex = Columns.index("ZoneID") + for Zone in RawZoneList: + StartCoords = ast.literal_eval(Zone[StartCoordIndex]) + EndCoords = ast.literal_eval(Zone[EndCoordIndex]) + Coord = AATC_Coordinate.Coordinate(StartCoords[0],StartCoords[1],StartCoords[2],EndCoords[0]-StartCoords[0],EndCoords[1]-StartCoords[1],EndCoords[2]-StartCoords[2]) + Text = "Z:"+ str(Zone[ZoneIDIndex]) +" L:"+ str(Zone[LevelIndex]) + Colour = (100,100,100) + ZoneList.append(Monitor_Sprite(Coord,"NoFlyZone",Text,Colour)) + return ZoneList + +def MakeSprites(M): + print("Refreshing data") + SpriteList = [] + Sucess,Message,DronesAll = M.GetDronesAll() + if Sucess: + SpriteList += MakeDroneSprites(Message,DronesAll) + + Sucess,Message,DronesMonitor = M.GetMonitorDrones() + if Sucess: + SpriteList += MakeDroneSprites(Message,DronesMonitor) + + Sucess,Message,FlightsAll = M.GetFlightsAll() + if Sucess: + SpriteList += MakeFlightSprites(Message,FlightsAll) + + Sucess,Message,FlightsMonitor = M.GetMonitorFlights() + if Sucess: + SpriteList += MakeFlightSprites(Message,FlightsMonitor) + + Sucess,Message,WaypointsAll = M.GetFlightWaypointsAll() + if Sucess: + SpriteList += MakeWaypointSprites(Message,WaypointsAll) + + Sucess,Message,WaypointsMonitor = M.GetMonitorFlightWaypoints() + if Sucess: + SpriteList += MakeWaypointSprites(Message,WaypointsMonitor) + + Sucess,Message,NoFlyZones = M.GetNoFlyZones() + if Sucess: + SpriteList += MakeZoneSprites(Message,NoFlyZones) + + #Sprites are created in this function to simplify code in case of an error(False) + print("Refreshed data") + return SpriteList #All sprites which were sucessfully created + + + +xpixel = 1200 +ypixel = 700 +Refresh_Delay = 60 +clock = pygame.time.Clock() +pressed = pygame.key.get_pressed +Exit = "N" +while Exit != "Y": + try: + M = AATC_Monitor.CreateMonitorInterface(IP = "127.0.0.1",Port = 8001) + M.Login("Zini","") + #Sucess,Message,Data = M.GetCoordDetails() + #MinCoords,MaxCoords,StepCoords = Data[0],Data[1],Data[2] + MinCoords,MaxCoords = AATC_Coordinate.Coordinate(0,0,0),AATC_Coordinate.Coordinate(1,1,50) + MonCamera = Camera(xpixel,ypixel,MinCoords,MaxCoords) + while True: + MonCamera.ResetDrawObject() + Sprites = MakeSprites(M) + #font = (None, 30) + for sprite in Sprites: + MonCamera.AddDrawObject(sprite,False) + + Last_Refresh_Time = time.time() + refresh = False + while not refresh: + MonCamera.CameraWipe() + if time.time() >= (Last_Refresh_Time + Refresh_Delay): + refresh = True + for event in pygame.event.get(): + if event.type == pygame.QUIT: + print("Monitor exit was called") + pygame.quit() + sys.exit() + + elif event.type == pygame.MOUSEBUTTONDOWN: + print("Camera details") #Mainly for debugging + print(MonCamera.GetZoom()) + print(MonCamera.CameraCoord.Get_X()) + print(MonCamera.CameraCoord.Get_Y()) + print(MonCamera.CameraCoord.Get_XSize()) + print(MonCamera.CameraCoord.Get_YSize()) + print(len(MonCamera.DrawObjects)) + print("FPS:"+str(clock.get_fps())) + elif event.type == pygame.KEYDOWN: + pass + + + CameraCoord = MonCamera.Get_Coord() + if pressed()[pygame.K_w]: #Shift camera + MonCamera.IncrementCameraCoordY(-0.01*CameraCoord.Get_XSize()) #/ as Greater zoom means need more fidelety + if pressed()[pygame.K_s]: + MonCamera.IncrementCameraCoordY(0.01*CameraCoord.Get_XSize()) + if pressed()[pygame.K_a]: + MonCamera.IncrementCameraCoordX(-0.01*CameraCoord.Get_XSize()) + if pressed()[pygame.K_d]: + MonCamera.IncrementCameraCoordX(0.01*CameraCoord.Get_XSize()) + + if pressed()[pygame.K_q]:#Zoom out + MonCamera.SetZoom(0.99*MonCamera.GetZoom()) + if pressed()[pygame.K_e]:#Zoom in + MonCamera.SetZoom(1.01*MonCamera.GetZoom()) + + if pressed()[pygame.K_SPACE]:#Zoom in + refresh = True + + + MonCamera.UpdateCameraSize() + MonCamera.Draw() + pygame.display.flip() + clock.tick(60) + + + + except Exception as e: + print(e) + print("An error occured, restarting main loop") + Exit = input("Exit? Y/N").upper() + + + + + + + + + + + + + + + + + + diff --git a/CAStar/AATC_Monitor_Viewer.so b/CAStar/AATC_Monitor_Viewer.so new file mode 100644 index 0000000000000000000000000000000000000000..45b6fac7be3b6a59c46bec5fcd31979691bd9075 GIT binary patch literal 354848 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 #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) @@ -47,6 +47,8 @@ #define CYTHON_COMPILING_IN_CPYTHON 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS @@ -74,6 +76,8 @@ #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS @@ -105,6 +109,12 @@ #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 @@ -467,8 +477,8 @@ static CYTHON_INLINE float __PYX_NAN() { #endif #endif -#define __PYX_HAVE__CAStar -#define __PYX_HAVE_API__CAStar +#define __PYX_HAVE__CAStar__CAStar +#define __PYX_HAVE_API__CAStar__CAStar #ifdef _OPENMP #include #endif /* _OPENMP */ @@ -673,16 +683,16 @@ static const char *__pyx_f[] = { }; /*--- Type declarations ---*/ -struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2; +struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2; -/* "CAStar.pyx":121 +/* "CAStar/CAStar.pyx":121 * return None * * def AStar2(graph, int start, int target): # Set all g to node_count + 1 # <<<<<<<<<<<<<< * StartTime = time.time() * */ -struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 { +struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 { PyObject_HEAD PyObject *__pyx_v_f; }; @@ -826,6 +836,18 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + /* PyObjectCallMethod0.proto */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); @@ -1101,24 +1123,23 @@ static int __Pyx_check_binary_version(void); static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); -/* Module declarations from 'CAStar' */ -static PyTypeObject *__pyx_ptype_6CAStar___pyx_scope_struct__AStar2 = 0; -static float __pyx_f_6CAStar_EstimateDistance(int, int, int, int, int, float, float, float); /*proto*/ -static float __pyx_f_6CAStar_GetxCoord(int, int, int, int, float, float, float); /*proto*/ -static float __pyx_f_6CAStar_GetyCoord(int, int, int, int, float, float, float); /*proto*/ -static float __pyx_f_6CAStar_GetzCoord(int, int, int, int, float, float, float); /*proto*/ -static PyObject *__pyx_f_6CAStar_FindPath(PyObject *, int); /*proto*/ -#define __Pyx_MODULE_NAME "CAStar" -int __pyx_module_is_main_CAStar = 0; +/* Module declarations from 'CAStar.CAStar' */ +static PyTypeObject *__pyx_ptype_6CAStar_6CAStar___pyx_scope_struct__AStar2 = 0; +static float __pyx_f_6CAStar_6CAStar_EstimateDistance(int, int, int, int, int, float, float, float); /*proto*/ +static float __pyx_f_6CAStar_6CAStar_GetxCoord(int, int, int, int, float, float, float); /*proto*/ +static float __pyx_f_6CAStar_6CAStar_GetyCoord(int, int, int, int, float, float, float); /*proto*/ +static float __pyx_f_6CAStar_6CAStar_GetzCoord(int, int, int, int, float, float, float); /*proto*/ +static PyObject *__pyx_f_6CAStar_6CAStar_FindPath(PyObject *, int); /*proto*/ +#define __Pyx_MODULE_NAME "CAStar.CAStar" +int __pyx_module_is_main_CAStar__CAStar = 0; -/* Implementation of 'CAStar' */ +/* Implementation of 'CAStar.CAStar' */ static PyObject *__pyx_builtin_min; -static const char __pyx_k_[] = "*"; static const char __pyx_k_f[] = "f"; static const char __pyx_k_g[] = "g"; -static const char __pyx_k__2[] = "_"; +static const char __pyx_k__2[] = "*"; +static const char __pyx_k__3[] = "_"; static const char __pyx_k_fp[] = "fp"; -static const char __pyx_k_os[] = "os"; static const char __pyx_k_end[] = "end"; static const char __pyx_k_inf[] = "inf"; static const char __pyx_k_key[] = "key"; @@ -1135,7 +1156,6 @@ static const char __pyx_k_Found[] = "Found"; static const char __pyx_k_fTemp[] = "fTemp"; static const char __pyx_k_gNode[] = "gNode"; static const char __pyx_k_graph[] = "graph"; -static const char __pyx_k_heapq[] = "heapq"; static const char __pyx_k_print[] = "print"; static const char __pyx_k_start[] = "start"; static const char __pyx_k_xSize[] = "xSize"; @@ -1143,11 +1163,9 @@ static const char __pyx_k_ySize[] = "ySize"; static const char __pyx_k_zSize[] = "zSize"; static const char __pyx_k_AStar2[] = "AStar2"; static const char __pyx_k_A_Time[] = "[A* Time] "; -static const char __pyx_k_CAStar[] = "CAStar"; static const char __pyx_k_NodeID[] = "NodeID"; static const char __pyx_k_Target[] = "Target:"; static const char __pyx_k_import[] = "__import__"; -static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_remove[] = "remove"; static const char __pyx_k_tScore[] = "tScore"; static const char __pyx_k_target[] = "target"; @@ -1156,20 +1174,22 @@ static const char __pyx_k_yCount[] = "yCount"; static const char __pyx_k_zCount[] = "zCount"; static const char __pyx_k_AStarPQ[] = "AStarPQ"; static const char __pyx_k_EndTime[] = "EndTime"; -static const char __pyx_k_Friends[] = "Friends"; static const char __pyx_k_GetNode[] = "GetNode"; static const char __pyx_k_OpenSet[] = "OpenSet"; static const char __pyx_k_current[] = "current"; static const char __pyx_k_hashlib[] = "hashlib"; static const char __pyx_k_Get_Cost[] = "Get_Cost"; +static const char __pyx_k_Get_Size[] = "Get_Size"; static const char __pyx_k_cameFrom[] = "cameFrom"; static const char __pyx_k_ClosedSet[] = "ClosedSet"; +static const char __pyx_k_Get_Count[] = "Get_Count"; static const char __pyx_k_StartTime[] = "StartTime"; static const char __pyx_k_CAStar_pyx[] = "CAStar.pyx"; static const char __pyx_k_FriendList[] = "FriendList"; static const char __pyx_k_TargetNode[] = "TargetNode"; static const char __pyx_k_Get_Friends[] = "Get_Friends"; static const char __pyx_k_Milliseconds[] = " Milliseconds."; +static const char __pyx_k_CAStar_CAStar[] = "CAStar.CAStar"; static const char __pyx_k_PriorityQueue[] = "PriorityQueue"; static const char __pyx_k_Total_Expanded[] = " Total Expanded:"; static const char __pyx_k_AATC_Coordinate[] = "AATC_Coordinate"; @@ -1181,7 +1201,6 @@ static const char __pyx_k_PriorityQueue_PriorityQueue[] = "PriorityQueue.Priorit static const char __pyx_k_PriorityQueue_PriorityQueueC[] = "PriorityQueue.PriorityQueueC"; static const char __pyx_k_You_do_not_have_math_inf_object[] = "You do not have math.inf object, Python 3.5 onwards. Will use replacement."; static const char __pyx_k_PriotityQueueC_not_available_def[] = "PriotityQueueC not available, defaulting to pure python"; -static PyObject *__pyx_n_s_; static PyObject *__pyx_n_s_AATC_Coordinate; static PyObject *__pyx_n_s_AStar2; static PyObject *__pyx_n_s_AStar2_locals_lambda; @@ -1189,16 +1208,17 @@ static PyObject *__pyx_n_s_AStarPQ; static PyObject *__pyx_kp_s_AStarPQ_not_available; static PyObject *__pyx_kp_s_A_Search_FAILED_Start; static PyObject *__pyx_kp_s_A_Time; -static PyObject *__pyx_n_s_CAStar; +static PyObject *__pyx_n_s_CAStar_CAStar; static PyObject *__pyx_kp_s_CAStar_pyx; static PyObject *__pyx_n_s_ClosedSet; static PyObject *__pyx_n_s_EndTime; static PyObject *__pyx_n_s_Found; static PyObject *__pyx_n_s_FriendList; -static PyObject *__pyx_n_s_Friends; static PyObject *__pyx_n_s_GetNode; static PyObject *__pyx_n_s_Get_Cost; +static PyObject *__pyx_n_s_Get_Count; static PyObject *__pyx_n_s_Get_Friends; +static PyObject *__pyx_n_s_Get_Size; static PyObject *__pyx_kp_s_Milliseconds; static PyObject *__pyx_n_s_Node; static PyObject *__pyx_n_s_NodeID; @@ -1213,6 +1233,7 @@ static PyObject *__pyx_n_s_TargetNode; static PyObject *__pyx_kp_s_Total_Expanded; static PyObject *__pyx_kp_s_You_do_not_have_math_inf_object; static PyObject *__pyx_n_s__2; +static PyObject *__pyx_n_s__3; static PyObject *__pyx_n_s_cameFrom; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_current; @@ -1225,15 +1246,12 @@ static PyObject *__pyx_n_s_g; static PyObject *__pyx_n_s_gNode; static PyObject *__pyx_n_s_graph; static PyObject *__pyx_n_s_hashlib; -static PyObject *__pyx_n_s_heapq; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_inf; static PyObject *__pyx_n_s_key; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_math; static PyObject *__pyx_n_s_min; -static PyObject *__pyx_n_s_os; -static PyObject *__pyx_n_s_pickle; static PyObject *__pyx_n_s_pop; static PyObject *__pyx_n_s_print; static PyObject *__pyx_n_s_put; @@ -1249,21 +1267,23 @@ static PyObject *__pyx_n_s_yCount; static PyObject *__pyx_n_s_ySize; static PyObject *__pyx_n_s_zCount; static PyObject *__pyx_n_s_zSize; -static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_graph, int __pyx_v_start, int __pyx_v_target); /* proto */ +static PyObject *__pyx_pf_6CAStar_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_graph, int __pyx_v_start, int __pyx_v_target); /* proto */ static PyObject *__pyx_lambda_funcdef_lambda(PyObject *__pyx_self, PyObject *__pyx_v_n); /* proto */ -static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_graph, int __pyx_v_start, int __pyx_v_target); /* proto */ -static PyObject *__pyx_tp_new_6CAStar___pyx_scope_struct__AStar2(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_pf_6CAStar_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_graph, int __pyx_v_start, int __pyx_v_target); /* proto */ +static PyObject *__pyx_tp_new_6CAStar_6CAStar___pyx_scope_struct__AStar2(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static __Pyx_CachedCFunction __pyx_umethod_PyList_Type_pop = {0, &__pyx_n_s_pop, 0, 0, 0}; static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_1000; static PyObject *__pyx_int_100000000000000000000; -static PyObject *__pyx_tuple__3; -static PyObject *__pyx_tuple__5; -static PyObject *__pyx_codeobj__4; -static PyObject *__pyx_codeobj__6; - -/* "CAStar.pyx":22 +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_slice_; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_codeobj__5; +static PyObject *__pyx_codeobj__7; + +/* "CAStar/CAStar.pyx":22 * math.inf = 10**20 * * cdef float EstimateDistance(int NodeID, int TargetID, int xCount,int yCount,int zCount, float xSize, float ySize, float zSize): # <<<<<<<<<<<<<< @@ -1271,7 +1291,7 @@ static PyObject *__pyx_codeobj__6; * cdef float Distance */ -static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_TargetID, int __pyx_v_xCount, int __pyx_v_yCount, int __pyx_v_zCount, float __pyx_v_xSize, float __pyx_v_ySize, float __pyx_v_zSize) { +static float __pyx_f_6CAStar_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_TargetID, int __pyx_v_xCount, int __pyx_v_yCount, int __pyx_v_zCount, float __pyx_v_xSize, float __pyx_v_ySize, float __pyx_v_zSize) { float __pyx_v_x; float __pyx_v_y; float __pyx_v_z; @@ -1290,35 +1310,35 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta int __pyx_t_4; __Pyx_RefNannySetupContext("EstimateDistance", 0); - /* "CAStar.pyx":25 + /* "CAStar/CAStar.pyx":25 * cdef float x,y,z,Nx,Ny,Nz,Tx,Ty,Tz * cdef float Distance * Nx,Ny,Nz = GetxCoord(NodeID,xCount,yCount,zCount,xSize,ySize,zSize),GetyCoord(NodeID,xCount,yCount,zCount,xSize,ySize,zSize),GetzCoord(NodeID,xCount,yCount,zCount,xSize,ySize,zSize) # <<<<<<<<<<<<<< * Tx,Ty,Tz = GetxCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize),GetyCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize),GetzCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize) * x=(Nx-Tx)/xSize */ - __pyx_t_1 = __pyx_f_6CAStar_GetxCoord(__pyx_v_NodeID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize); - __pyx_t_2 = __pyx_f_6CAStar_GetyCoord(__pyx_v_NodeID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize); - __pyx_t_3 = __pyx_f_6CAStar_GetzCoord(__pyx_v_NodeID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize); + __pyx_t_1 = __pyx_f_6CAStar_6CAStar_GetxCoord(__pyx_v_NodeID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize); + __pyx_t_2 = __pyx_f_6CAStar_6CAStar_GetyCoord(__pyx_v_NodeID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize); + __pyx_t_3 = __pyx_f_6CAStar_6CAStar_GetzCoord(__pyx_v_NodeID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize); __pyx_v_Nx = __pyx_t_1; __pyx_v_Ny = __pyx_t_2; __pyx_v_Nz = __pyx_t_3; - /* "CAStar.pyx":26 + /* "CAStar/CAStar.pyx":26 * cdef float Distance * Nx,Ny,Nz = GetxCoord(NodeID,xCount,yCount,zCount,xSize,ySize,zSize),GetyCoord(NodeID,xCount,yCount,zCount,xSize,ySize,zSize),GetzCoord(NodeID,xCount,yCount,zCount,xSize,ySize,zSize) * Tx,Ty,Tz = GetxCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize),GetyCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize),GetzCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize) # <<<<<<<<<<<<<< * x=(Nx-Tx)/xSize * y=(Ny-Ty)/ySize */ - __pyx_t_3 = __pyx_f_6CAStar_GetxCoord(__pyx_v_TargetID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize); - __pyx_t_2 = __pyx_f_6CAStar_GetyCoord(__pyx_v_TargetID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize); - __pyx_t_1 = __pyx_f_6CAStar_GetzCoord(__pyx_v_TargetID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize); + __pyx_t_3 = __pyx_f_6CAStar_6CAStar_GetxCoord(__pyx_v_TargetID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize); + __pyx_t_2 = __pyx_f_6CAStar_6CAStar_GetyCoord(__pyx_v_TargetID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize); + __pyx_t_1 = __pyx_f_6CAStar_6CAStar_GetzCoord(__pyx_v_TargetID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize); __pyx_v_Tx = __pyx_t_3; __pyx_v_Ty = __pyx_t_2; __pyx_v_Tz = __pyx_t_1; - /* "CAStar.pyx":27 + /* "CAStar/CAStar.pyx":27 * Nx,Ny,Nz = GetxCoord(NodeID,xCount,yCount,zCount,xSize,ySize,zSize),GetyCoord(NodeID,xCount,yCount,zCount,xSize,ySize,zSize),GetzCoord(NodeID,xCount,yCount,zCount,xSize,ySize,zSize) * Tx,Ty,Tz = GetxCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize),GetyCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize),GetzCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize) * x=(Nx-Tx)/xSize # <<<<<<<<<<<<<< @@ -1327,7 +1347,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta */ __pyx_v_x = ((__pyx_v_Nx - __pyx_v_Tx) / __pyx_v_xSize); - /* "CAStar.pyx":28 + /* "CAStar/CAStar.pyx":28 * Tx,Ty,Tz = GetxCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize),GetyCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize),GetzCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize) * x=(Nx-Tx)/xSize * y=(Ny-Ty)/ySize # <<<<<<<<<<<<<< @@ -1336,7 +1356,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta */ __pyx_v_y = ((__pyx_v_Ny - __pyx_v_Ty) / __pyx_v_ySize); - /* "CAStar.pyx":29 + /* "CAStar/CAStar.pyx":29 * x=(Nx-Tx)/xSize * y=(Ny-Ty)/ySize * z=(Nz-Tz)/zSize # <<<<<<<<<<<<<< @@ -1345,7 +1365,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta */ __pyx_v_z = ((__pyx_v_Nz - __pyx_v_Tz) / __pyx_v_zSize); - /* "CAStar.pyx":30 + /* "CAStar/CAStar.pyx":30 * y=(Ny-Ty)/ySize * z=(Nz-Tz)/zSize * if x < 0: # <<<<<<<<<<<<<< @@ -1355,7 +1375,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta __pyx_t_4 = ((__pyx_v_x < 0.0) != 0); if (__pyx_t_4) { - /* "CAStar.pyx":31 + /* "CAStar/CAStar.pyx":31 * z=(Nz-Tz)/zSize * if x < 0: * x = x*-1 # <<<<<<<<<<<<<< @@ -1364,7 +1384,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta */ __pyx_v_x = (__pyx_v_x * -1.0); - /* "CAStar.pyx":30 + /* "CAStar/CAStar.pyx":30 * y=(Ny-Ty)/ySize * z=(Nz-Tz)/zSize * if x < 0: # <<<<<<<<<<<<<< @@ -1373,7 +1393,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta */ } - /* "CAStar.pyx":32 + /* "CAStar/CAStar.pyx":32 * if x < 0: * x = x*-1 * if y < 0: # <<<<<<<<<<<<<< @@ -1383,7 +1403,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta __pyx_t_4 = ((__pyx_v_y < 0.0) != 0); if (__pyx_t_4) { - /* "CAStar.pyx":33 + /* "CAStar/CAStar.pyx":33 * x = x*-1 * if y < 0: * y = y*-1 # <<<<<<<<<<<<<< @@ -1392,7 +1412,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta */ __pyx_v_y = (__pyx_v_y * -1.0); - /* "CAStar.pyx":32 + /* "CAStar/CAStar.pyx":32 * if x < 0: * x = x*-1 * if y < 0: # <<<<<<<<<<<<<< @@ -1401,7 +1421,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta */ } - /* "CAStar.pyx":34 + /* "CAStar/CAStar.pyx":34 * if y < 0: * y = y*-1 * if z < 0: # <<<<<<<<<<<<<< @@ -1411,7 +1431,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta __pyx_t_4 = ((__pyx_v_z < 0.0) != 0); if (__pyx_t_4) { - /* "CAStar.pyx":35 + /* "CAStar/CAStar.pyx":35 * y = y*-1 * if z < 0: * z = z*-1 # <<<<<<<<<<<<<< @@ -1420,7 +1440,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta */ __pyx_v_z = (__pyx_v_z * -1.0); - /* "CAStar.pyx":34 + /* "CAStar/CAStar.pyx":34 * if y < 0: * y = y*-1 * if z < 0: # <<<<<<<<<<<<<< @@ -1429,7 +1449,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta */ } - /* "CAStar.pyx":36 + /* "CAStar/CAStar.pyx":36 * if z < 0: * z = z*-1 * Distance = x+y+z # <<<<<<<<<<<<<< @@ -1438,7 +1458,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta */ __pyx_v_Distance = ((__pyx_v_x + __pyx_v_y) + __pyx_v_z); - /* "CAStar.pyx":37 + /* "CAStar/CAStar.pyx":37 * z = z*-1 * Distance = x+y+z * return Distance # <<<<<<<<<<<<<< @@ -1448,7 +1468,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta __pyx_r = __pyx_v_Distance; goto __pyx_L0; - /* "CAStar.pyx":22 + /* "CAStar/CAStar.pyx":22 * math.inf = 10**20 * * cdef float EstimateDistance(int NodeID, int TargetID, int xCount,int yCount,int zCount, float xSize, float ySize, float zSize): # <<<<<<<<<<<<<< @@ -1462,7 +1482,7 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta return __pyx_r; } -/* "CAStar.pyx":39 +/* "CAStar/CAStar.pyx":39 * return Distance * * cdef float GetxCoord(int ID, int xCount, int yCount, int zCount, float xSize, float ySize,float zSize): # <<<<<<<<<<<<<< @@ -1470,13 +1490,13 @@ static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_Ta * xCoord = ((ID-1)//(zCount*yCount)) * xSize */ -static float __pyx_f_6CAStar_GetxCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v_xCount, int __pyx_v_yCount, int __pyx_v_zCount, float __pyx_v_xSize, CYTHON_UNUSED float __pyx_v_ySize, CYTHON_UNUSED float __pyx_v_zSize) { +static float __pyx_f_6CAStar_6CAStar_GetxCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v_xCount, int __pyx_v_yCount, int __pyx_v_zCount, float __pyx_v_xSize, CYTHON_UNUSED float __pyx_v_ySize, CYTHON_UNUSED float __pyx_v_zSize) { float __pyx_v_xCoord; float __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("GetxCoord", 0); - /* "CAStar.pyx":41 + /* "CAStar/CAStar.pyx":41 * cdef float GetxCoord(int ID, int xCount, int yCount, int zCount, float xSize, float ySize,float zSize): * cdef float xCoord * xCoord = ((ID-1)//(zCount*yCount)) * xSize # <<<<<<<<<<<<<< @@ -1485,7 +1505,7 @@ static float __pyx_f_6CAStar_GetxCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v */ __pyx_v_xCoord = (((__pyx_v_ID - 1) / (__pyx_v_zCount * __pyx_v_yCount)) * __pyx_v_xSize); - /* "CAStar.pyx":42 + /* "CAStar/CAStar.pyx":42 * cdef float xCoord * xCoord = ((ID-1)//(zCount*yCount)) * xSize * return xCoord # <<<<<<<<<<<<<< @@ -1495,7 +1515,7 @@ static float __pyx_f_6CAStar_GetxCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v __pyx_r = __pyx_v_xCoord; goto __pyx_L0; - /* "CAStar.pyx":39 + /* "CAStar/CAStar.pyx":39 * return Distance * * cdef float GetxCoord(int ID, int xCount, int yCount, int zCount, float xSize, float ySize,float zSize): # <<<<<<<<<<<<<< @@ -1509,7 +1529,7 @@ static float __pyx_f_6CAStar_GetxCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v return __pyx_r; } -/* "CAStar.pyx":44 +/* "CAStar/CAStar.pyx":44 * return xCoord * * cdef float GetyCoord(int ID, int xCount, int yCount, int zCount, float xSize, float ySize,float zSize): # <<<<<<<<<<<<<< @@ -1517,13 +1537,13 @@ static float __pyx_f_6CAStar_GetxCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v * yCoord = (((ID-1)%(zCount*yCount))//zCount)*ySize */ -static float __pyx_f_6CAStar_GetyCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v_xCount, int __pyx_v_yCount, int __pyx_v_zCount, CYTHON_UNUSED float __pyx_v_xSize, float __pyx_v_ySize, CYTHON_UNUSED float __pyx_v_zSize) { +static float __pyx_f_6CAStar_6CAStar_GetyCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v_xCount, int __pyx_v_yCount, int __pyx_v_zCount, CYTHON_UNUSED float __pyx_v_xSize, float __pyx_v_ySize, CYTHON_UNUSED float __pyx_v_zSize) { float __pyx_v_yCoord; float __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("GetyCoord", 0); - /* "CAStar.pyx":46 + /* "CAStar/CAStar.pyx":46 * cdef float GetyCoord(int ID, int xCount, int yCount, int zCount, float xSize, float ySize,float zSize): * cdef float yCoord * yCoord = (((ID-1)%(zCount*yCount))//zCount)*ySize # <<<<<<<<<<<<<< @@ -1532,7 +1552,7 @@ static float __pyx_f_6CAStar_GetyCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v */ __pyx_v_yCoord = ((((__pyx_v_ID - 1) % (__pyx_v_zCount * __pyx_v_yCount)) / __pyx_v_zCount) * __pyx_v_ySize); - /* "CAStar.pyx":47 + /* "CAStar/CAStar.pyx":47 * cdef float yCoord * yCoord = (((ID-1)%(zCount*yCount))//zCount)*ySize * return yCoord # <<<<<<<<<<<<<< @@ -1542,7 +1562,7 @@ static float __pyx_f_6CAStar_GetyCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v __pyx_r = __pyx_v_yCoord; goto __pyx_L0; - /* "CAStar.pyx":44 + /* "CAStar/CAStar.pyx":44 * return xCoord * * cdef float GetyCoord(int ID, int xCount, int yCount, int zCount, float xSize, float ySize,float zSize): # <<<<<<<<<<<<<< @@ -1556,7 +1576,7 @@ static float __pyx_f_6CAStar_GetyCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v return __pyx_r; } -/* "CAStar.pyx":49 +/* "CAStar/CAStar.pyx":49 * return yCoord * * cdef float GetzCoord(int ID, int xCount, int yCount, int zCount, float xSize, float ySize,float zSize): # <<<<<<<<<<<<<< @@ -1564,13 +1584,13 @@ static float __pyx_f_6CAStar_GetyCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v * zCoord = ((ID-1)%zCount)*zSize */ -static float __pyx_f_6CAStar_GetzCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v_xCount, CYTHON_UNUSED int __pyx_v_yCount, int __pyx_v_zCount, CYTHON_UNUSED float __pyx_v_xSize, CYTHON_UNUSED float __pyx_v_ySize, float __pyx_v_zSize) { +static float __pyx_f_6CAStar_6CAStar_GetzCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v_xCount, CYTHON_UNUSED int __pyx_v_yCount, int __pyx_v_zCount, CYTHON_UNUSED float __pyx_v_xSize, CYTHON_UNUSED float __pyx_v_ySize, float __pyx_v_zSize) { float __pyx_v_zCoord; float __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("GetzCoord", 0); - /* "CAStar.pyx":51 + /* "CAStar/CAStar.pyx":51 * cdef float GetzCoord(int ID, int xCount, int yCount, int zCount, float xSize, float ySize,float zSize): * cdef float zCoord * zCoord = ((ID-1)%zCount)*zSize # <<<<<<<<<<<<<< @@ -1579,7 +1599,7 @@ static float __pyx_f_6CAStar_GetzCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v */ __pyx_v_zCoord = (((__pyx_v_ID - 1) % __pyx_v_zCount) * __pyx_v_zSize); - /* "CAStar.pyx":52 + /* "CAStar/CAStar.pyx":52 * cdef float zCoord * zCoord = ((ID-1)%zCount)*zSize * return zCoord # <<<<<<<<<<<<<< @@ -1589,7 +1609,7 @@ static float __pyx_f_6CAStar_GetzCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v __pyx_r = __pyx_v_zCoord; goto __pyx_L0; - /* "CAStar.pyx":49 + /* "CAStar/CAStar.pyx":49 * return yCoord * * cdef float GetzCoord(int ID, int xCount, int yCount, int zCount, float xSize, float ySize,float zSize): # <<<<<<<<<<<<<< @@ -1603,7 +1623,7 @@ static float __pyx_f_6CAStar_GetzCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v return __pyx_r; } -/* "CAStar.pyx":54 +/* "CAStar/CAStar.pyx":54 * return zCoord * * def AStarPQ(graph, int start, int target): # Set all g to node_count + 1 # <<<<<<<<<<<<<< @@ -1612,9 +1632,9 @@ static float __pyx_f_6CAStar_GetzCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v */ /* Python wrapper */ -static PyObject *__pyx_pw_6CAStar_1AStarPQ(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_6CAStar_1AStarPQ = {"AStarPQ", (PyCFunction)__pyx_pw_6CAStar_1AStarPQ, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6CAStar_1AStarPQ(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_6CAStar_6CAStar_1AStarPQ(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_6CAStar_1AStarPQ = {"AStarPQ", (PyCFunction)__pyx_pw_6CAStar_6CAStar_1AStarPQ, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_6CAStar_1AStarPQ(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_graph = 0; int __pyx_v_start; int __pyx_v_target; @@ -1673,18 +1693,18 @@ static PyObject *__pyx_pw_6CAStar_1AStarPQ(PyObject *__pyx_self, PyObject *__pyx __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("AStarPQ", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 54, __pyx_L3_error) __pyx_L3_error:; - __Pyx_AddTraceback("CAStar.AStarPQ", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("CAStar.CAStar.AStarPQ", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6CAStar_AStarPQ(__pyx_self, __pyx_v_graph, __pyx_v_start, __pyx_v_target); + __pyx_r = __pyx_pf_6CAStar_6CAStar_AStarPQ(__pyx_self, __pyx_v_graph, __pyx_v_start, __pyx_v_target); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_graph, int __pyx_v_start, int __pyx_v_target) { +static PyObject *__pyx_pf_6CAStar_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_graph, int __pyx_v_start, int __pyx_v_target) { PyObject *__pyx_v_StartTime = NULL; float __pyx_v_xSize; float __pyx_v_ySize; @@ -1714,19 +1734,20 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - float __pyx_t_6; + PyObject *(*__pyx_t_6)(PyObject *); float __pyx_t_7; float __pyx_t_8; - int __pyx_t_9; + float __pyx_t_9; int __pyx_t_10; int __pyx_t_11; - Py_ssize_t __pyx_t_12; - int __pyx_t_13; + int __pyx_t_12; + Py_ssize_t __pyx_t_13; int __pyx_t_14; PyObject *__pyx_t_15 = NULL; + int __pyx_t_16; __Pyx_RefNannySetupContext("AStarPQ", 0); - /* "CAStar.pyx":55 + /* "CAStar/CAStar.pyx":55 * * def AStarPQ(graph, int start, int target): # Set all g to node_count + 1 * StartTime = time.time() # <<<<<<<<<<<<<< @@ -1759,12 +1780,12 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_v_StartTime = __pyx_t_1; __pyx_t_1 = 0; - /* "CAStar.pyx":63 + /* "CAStar/CAStar.pyx":63 * * * TargetNode = graph.GetNode(target) # <<<<<<<<<<<<<< - * xSize,ySize,zSize = graph.xSize,graph.ySize,graph.zSize - * xCount,yCount,zCount = graph.xCount,graph.yCount,graph.zCount + * xSize,ySize,zSize = graph.Get_Size() + * xCount,yCount,zCount = graph.Get_Count() */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); @@ -1819,54 +1840,196 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_v_TargetNode = __pyx_t_1; __pyx_t_1 = 0; - /* "CAStar.pyx":64 + /* "CAStar/CAStar.pyx":64 * * TargetNode = graph.GetNode(target) - * xSize,ySize,zSize = graph.xSize,graph.ySize,graph.zSize # <<<<<<<<<<<<<< - * xCount,yCount,zCount = graph.xCount,graph.yCount,graph.zCount + * xSize,ySize,zSize = graph.Get_Size() # <<<<<<<<<<<<<< + * xCount,yCount,zCount = graph.Get_Count() * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_xSize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_ySize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_7 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_7 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_zSize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_Get_Size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error) + } __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_xSize = __pyx_t_6; - __pyx_v_ySize = __pyx_t_7; - __pyx_v_zSize = __pyx_t_8; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 3)) { + if (size > 3) __Pyx_RaiseTooManyValuesError(3); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 64, __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_t_5 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_3 = PyList_GET_ITEM(sequence, 0); + __pyx_t_5 = PyList_GET_ITEM(sequence, 1); + __pyx_t_2 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_2); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; + index = 0; __pyx_t_3 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + index = 1; __pyx_t_5 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_5)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 2; __pyx_t_2 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_4), 3) < 0) __PYX_ERR(0, 64, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L4_unpacking_done; + __pyx_L3_unpacking_failed:; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 64, __pyx_L1_error) + __pyx_L4_unpacking_done:; + } + __pyx_t_7 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_7 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_xSize = __pyx_t_7; + __pyx_v_ySize = __pyx_t_8; + __pyx_v_zSize = __pyx_t_9; - /* "CAStar.pyx":65 + /* "CAStar/CAStar.pyx":65 * TargetNode = graph.GetNode(target) - * xSize,ySize,zSize = graph.xSize,graph.ySize,graph.zSize - * xCount,yCount,zCount = graph.xCount,graph.yCount,graph.zCount # <<<<<<<<<<<<<< + * xSize,ySize,zSize = graph.Get_Size() + * xCount,yCount,zCount = graph.Get_Count() # <<<<<<<<<<<<<< * * ClosedSet = {} #Dict to hash find closed nodes */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_xCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_yCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_zCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_Get_Count); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error) + } __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_xCount = __pyx_t_9; - __pyx_v_yCount = __pyx_t_10; - __pyx_v_zCount = __pyx_t_11; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 3)) { + if (size > 3) __Pyx_RaiseTooManyValuesError(3); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 65, __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_t_5 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_5 = PyList_GET_ITEM(sequence, 1); + __pyx_t_3 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; + index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_5 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 2; __pyx_t_3 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_4), 3) < 0) __PYX_ERR(0, 65, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 65, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_xCount = __pyx_t_10; + __pyx_v_yCount = __pyx_t_11; + __pyx_v_zCount = __pyx_t_12; - /* "CAStar.pyx":67 - * xCount,yCount,zCount = graph.xCount,graph.yCount,graph.zCount + /* "CAStar/CAStar.pyx":67 + * xCount,yCount,zCount = graph.Get_Count() * * ClosedSet = {} #Dict to hash find closed nodes # <<<<<<<<<<<<<< * OpenSet = {start:1} @@ -1877,7 +2040,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_v_ClosedSet = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "CAStar.pyx":68 + /* "CAStar/CAStar.pyx":68 * * ClosedSet = {} #Dict to hash find closed nodes * OpenSet = {start:1} # <<<<<<<<<<<<<< @@ -1893,7 +2056,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_v_OpenSet = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "CAStar.pyx":69 + /* "CAStar/CAStar.pyx":69 * ClosedSet = {} #Dict to hash find closed nodes * OpenSet = {start:1} * cameFrom = {} # <<<<<<<<<<<<<< @@ -1905,7 +2068,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_v_cameFrom = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "CAStar.pyx":70 + /* "CAStar/CAStar.pyx":70 * OpenSet = {start:1} * cameFrom = {} * g,f = {},{} # <<<<<<<<<<<<<< @@ -1921,7 +2084,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_v_f = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "CAStar.pyx":71 + /* "CAStar/CAStar.pyx":71 * cameFrom = {} * g,f = {},{} * current = -1 # <<<<<<<<<<<<<< @@ -1930,7 +2093,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_v_current = -1; - /* "CAStar.pyx":72 + /* "CAStar/CAStar.pyx":72 * g,f = {},{} * current = -1 * fp = PriorityQueue.PriorityQueue() # <<<<<<<<<<<<<< @@ -1963,7 +2126,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_v_fp = __pyx_t_3; __pyx_t_3 = 0; - /* "CAStar.pyx":75 + /* "CAStar/CAStar.pyx":75 * * * g[start] = 0 # <<<<<<<<<<<<<< @@ -1975,14 +2138,14 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_3, __pyx_int_0) < 0)) __PYX_ERR(0, 75, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "CAStar.pyx":76 + /* "CAStar/CAStar.pyx":76 * * g[start] = 0 * f[start] = EstimateDistance(start,target,xCount,yCount,zCount,xSize,ySize,zSize) # <<<<<<<<<<<<<< * fp.put((EstimateDistance(start,target,xCount,yCount,zCount,xSize,ySize,zSize),start)) * Found = False */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_f_6CAStar_EstimateDistance(__pyx_v_start, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_f_6CAStar_6CAStar_EstimateDistance(__pyx_v_start, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); @@ -1990,7 +2153,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "CAStar.pyx":77 + /* "CAStar/CAStar.pyx":77 * g[start] = 0 * f[start] = EstimateDistance(start,target,xCount,yCount,zCount,xSize,ySize,zSize) * fp.put((EstimateDistance(start,target,xCount,yCount,zCount,xSize,ySize,zSize),start)) # <<<<<<<<<<<<<< @@ -1999,7 +2162,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_put); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = PyFloat_FromDouble(__pyx_f_6CAStar_EstimateDistance(__pyx_v_start, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_f_6CAStar_6CAStar_EstimateDistance(__pyx_v_start, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -2059,7 +2222,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "CAStar.pyx":78 + /* "CAStar/CAStar.pyx":78 * f[start] = EstimateDistance(start,target,xCount,yCount,zCount,xSize,ySize,zSize) * fp.put((EstimateDistance(start,target,xCount,yCount,zCount,xSize,ySize,zSize),start)) * Found = False # <<<<<<<<<<<<<< @@ -2068,7 +2231,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_v_Found = 0; - /* "CAStar.pyx":79 + /* "CAStar/CAStar.pyx":79 * fp.put((EstimateDistance(start,target,xCount,yCount,zCount,xSize,ySize,zSize),start)) * Found = False * while len(OpenSet) != 0: # <<<<<<<<<<<<<< @@ -2076,11 +2239,11 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py * if current == target: */ while (1) { - __pyx_t_12 = PyDict_Size(__pyx_v_OpenSet); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 79, __pyx_L1_error) - __pyx_t_13 = ((__pyx_t_12 != 0) != 0); - if (!__pyx_t_13) break; + __pyx_t_13 = PyDict_Size(__pyx_v_OpenSet); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 79, __pyx_L1_error) + __pyx_t_14 = ((__pyx_t_13 != 0) != 0); + if (!__pyx_t_14) break; - /* "CAStar.pyx":80 + /* "CAStar/CAStar.pyx":80 * Found = False * while len(OpenSet) != 0: * current = fp.pop()[1] # <<<<<<<<<<<<<< @@ -2092,21 +2255,21 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 80, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 80, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_current = __pyx_t_11; + __pyx_v_current = __pyx_t_12; - /* "CAStar.pyx":81 + /* "CAStar/CAStar.pyx":81 * while len(OpenSet) != 0: * current = fp.pop()[1] * if current == target: # <<<<<<<<<<<<<< * Found = True * break */ - __pyx_t_13 = ((__pyx_v_current == __pyx_v_target) != 0); - if (__pyx_t_13) { + __pyx_t_14 = ((__pyx_v_current == __pyx_v_target) != 0); + if (__pyx_t_14) { - /* "CAStar.pyx":82 + /* "CAStar/CAStar.pyx":82 * current = fp.pop()[1] * if current == target: * Found = True # <<<<<<<<<<<<<< @@ -2115,16 +2278,16 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_v_Found = 1; - /* "CAStar.pyx":83 + /* "CAStar/CAStar.pyx":83 * if current == target: * Found = True * break # <<<<<<<<<<<<<< * * */ - goto __pyx_L4_break; + goto __pyx_L8_break; - /* "CAStar.pyx":81 + /* "CAStar/CAStar.pyx":81 * while len(OpenSet) != 0: * current = fp.pop()[1] * if current == target: # <<<<<<<<<<<<<< @@ -2133,7 +2296,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ } - /* "CAStar.pyx":86 + /* "CAStar/CAStar.pyx":86 * * * OpenSet.pop(current) # <<<<<<<<<<<<<< @@ -2192,85 +2355,103 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "CAStar.pyx":87 + /* "CAStar/CAStar.pyx":87 * * OpenSet.pop(current) * ClosedSet[current] = 1 # <<<<<<<<<<<<<< * - * FriendList = graph.GetNode(current).Friends + * FriendList = graph.GetNode(current).Get_Friends() */ __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely(PyDict_SetItem(__pyx_v_ClosedSet, __pyx_t_5, __pyx_int_1) < 0)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "CAStar.pyx":89 + /* "CAStar/CAStar.pyx":89 * ClosedSet[current] = 1 * - * FriendList = graph.GetNode(current).Friends # <<<<<<<<<<<<<< + * FriendList = graph.GetNode(current).Get_Friends() # <<<<<<<<<<<<<< * for NodeID in FriendList: * if NodeID in ClosedSet: */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_1); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); + __Pyx_DECREF_SET(__pyx_t_2, function); } } - if (!__pyx_t_1) { - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_5); + if (!__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GOTREF(__pyx_t_3); } else { #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_3)) { - PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_2}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { - PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_2}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { - __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = NULL; - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Get_Friends); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Friends); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (!(likely(PyList_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_XDECREF_SET(__pyx_v_FriendList, ((PyObject*)__pyx_t_3)); - __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!(likely(PyList_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_5)->tp_name), 0))) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_FriendList, ((PyObject*)__pyx_t_5)); + __pyx_t_5 = 0; - /* "CAStar.pyx":90 + /* "CAStar/CAStar.pyx":90 * - * FriendList = graph.GetNode(current).Friends + * FriendList = graph.GetNode(current).Get_Friends() * for NodeID in FriendList: # <<<<<<<<<<<<<< * if NodeID in ClosedSet: * continue @@ -2279,44 +2460,44 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 90, __pyx_L1_error) } - __pyx_t_3 = __pyx_v_FriendList; __Pyx_INCREF(__pyx_t_3); __pyx_t_12 = 0; + __pyx_t_5 = __pyx_v_FriendList; __Pyx_INCREF(__pyx_t_5); __pyx_t_13 = 0; for (;;) { - if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_3)) break; + if (__pyx_t_13 >= PyList_GET_SIZE(__pyx_t_5)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_12); __Pyx_INCREF(__pyx_t_5); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(0, 90, __pyx_L1_error) + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_13); __Pyx_INCREF(__pyx_t_2); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 90, __pyx_L1_error) #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 90, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = PySequence_ITEM(__pyx_t_5, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); #endif - __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 90, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_NodeID = __pyx_t_11; + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_NodeID = __pyx_t_12; - /* "CAStar.pyx":91 - * FriendList = graph.GetNode(current).Friends + /* "CAStar/CAStar.pyx":91 + * FriendList = graph.GetNode(current).Get_Friends() * for NodeID in FriendList: * if NodeID in ClosedSet: # <<<<<<<<<<<<<< * continue * if NodeID not in OpenSet: */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_13 = (__Pyx_PyDict_ContainsTF(__pyx_t_5, __pyx_v_ClosedSet, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_14 = (__pyx_t_13 != 0); - if (__pyx_t_14) { + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_14 = (__Pyx_PyDict_ContainsTF(__pyx_t_2, __pyx_v_ClosedSet, Py_EQ)); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_16 = (__pyx_t_14 != 0); + if (__pyx_t_16) { - /* "CAStar.pyx":92 + /* "CAStar/CAStar.pyx":92 * for NodeID in FriendList: * if NodeID in ClosedSet: * continue # <<<<<<<<<<<<<< * if NodeID not in OpenSet: * OpenSet[NodeID] = 1 */ - goto __pyx_L6_continue; + goto __pyx_L10_continue; - /* "CAStar.pyx":91 - * FriendList = graph.GetNode(current).Friends + /* "CAStar/CAStar.pyx":91 + * FriendList = graph.GetNode(current).Get_Friends() * for NodeID in FriendList: * if NodeID in ClosedSet: # <<<<<<<<<<<<<< * continue @@ -2324,141 +2505,141 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ } - /* "CAStar.pyx":93 + /* "CAStar/CAStar.pyx":93 * if NodeID in ClosedSet: * continue * if NodeID not in OpenSet: # <<<<<<<<<<<<<< * OpenSet[NodeID] = 1 * g[NodeID] = math.inf */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 93, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_14 = (__Pyx_PyDict_ContainsTF(__pyx_t_5, __pyx_v_OpenSet, Py_NE)); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 93, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_13 = (__pyx_t_14 != 0); - if (__pyx_t_13) { + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_16 = (__Pyx_PyDict_ContainsTF(__pyx_t_2, __pyx_v_OpenSet, Py_NE)); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_14 = (__pyx_t_16 != 0); + if (__pyx_t_14) { - /* "CAStar.pyx":94 + /* "CAStar/CAStar.pyx":94 * continue * if NodeID not in OpenSet: * OpenSet[NodeID] = 1 # <<<<<<<<<<<<<< * g[NodeID] = math.inf * f[NodeID] = math.inf */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(PyDict_SetItem(__pyx_v_OpenSet, __pyx_t_5, __pyx_int_1) < 0)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(PyDict_SetItem(__pyx_v_OpenSet, __pyx_t_2, __pyx_int_1) < 0)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "CAStar.pyx":95 + /* "CAStar/CAStar.pyx":95 * if NodeID not in OpenSet: * OpenSet[NodeID] = 1 * g[NodeID] = math.inf # <<<<<<<<<<<<<< * f[NodeID] = math.inf * fp.put((math.inf,NodeID)) */ - __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 95, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_inf); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 95, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 95, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_5, __pyx_t_4) < 0)) __PYX_ERR(0, 95, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_inf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_2, __pyx_t_3) < 0)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "CAStar.pyx":96 + /* "CAStar/CAStar.pyx":96 * OpenSet[NodeID] = 1 * g[NodeID] = math.inf * f[NodeID] = math.inf # <<<<<<<<<<<<<< * fp.put((math.inf,NodeID)) * */ - __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_inf); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 96, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely(PyDict_SetItem(__pyx_v_f, __pyx_t_4, __pyx_t_5) < 0)) __PYX_ERR(0, 96, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_inf); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(PyDict_SetItem(__pyx_v_f, __pyx_t_3, __pyx_t_2) < 0)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "CAStar.pyx":97 + /* "CAStar/CAStar.pyx":97 * g[NodeID] = math.inf * f[NodeID] = math.inf * fp.put((math.inf,NodeID)) # <<<<<<<<<<<<<< * * Node = graph.GetNode(NodeID) */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_put); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_inf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_put); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_inf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_15 = PyTuple_New(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 97, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_15); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_15); __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_2); + __pyx_t_15 = 0; + __pyx_t_15 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_15)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_15); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); + __Pyx_DECREF_SET(__pyx_t_3, function); } } - if (!__pyx_t_2) { - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_GOTREF(__pyx_t_5); + if (!__pyx_t_15) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); } else { #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_15}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_15}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __pyx_t_2 = NULL; - __Pyx_GIVEREF(__pyx_t_15); - PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_15); - __pyx_t_15 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_15); __pyx_t_15 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "CAStar.pyx":93 + /* "CAStar/CAStar.pyx":93 * if NodeID in ClosedSet: * continue * if NodeID not in OpenSet: # <<<<<<<<<<<<<< @@ -2467,137 +2648,137 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ } - /* "CAStar.pyx":99 + /* "CAStar/CAStar.pyx":99 * fp.put((math.inf,NodeID)) * * Node = graph.GetNode(NodeID) # <<<<<<<<<<<<<< * tScore = g[current]+ Node.Get_Cost() * if tScore >= g[NodeID]: */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 99, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_15 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_15)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_15); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); + __Pyx_DECREF_SET(__pyx_t_3, function); } } - if (!__pyx_t_15) { - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error) + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_2); } else { #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_1}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_GOTREF(__pyx_t_5); + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_1}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { - __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_15); __pyx_t_15 = NULL; + __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_4); __pyx_t_4 = NULL; __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_15, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF_SET(__pyx_v_Node, __pyx_t_5); - __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_Node, __pyx_t_2); + __pyx_t_2 = 0; - /* "CAStar.pyx":100 + /* "CAStar/CAStar.pyx":100 * * Node = graph.GetNode(NodeID) * tScore = g[current]+ Node.Get_Cost() # <<<<<<<<<<<<<< * if tScore >= g[NodeID]: * continue */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_Node, __pyx_n_s_Get_Cost); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_Node, __pyx_n_s_Get_Cost); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_15))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_15); if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); + __Pyx_DECREF_SET(__pyx_t_15, function); } } if (__pyx_t_1) { - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 100, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { - __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 100, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_15); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) } - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_15 = PyNumber_Add(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_tScore = __pyx_t_11; + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_15); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_v_tScore = __pyx_t_12; - /* "CAStar.pyx":101 + /* "CAStar/CAStar.pyx":101 * Node = graph.GetNode(NodeID) * tScore = g[current]+ Node.Get_Cost() * if tScore >= g[NodeID]: # <<<<<<<<<<<<<< * continue * cameFrom[NodeID] = current */ - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_tScore); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_tScore); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyObject_RichCompare(__pyx_t_2, __pyx_t_4, Py_GE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 101, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (__pyx_t_13) { + __pyx_t_2 = PyObject_RichCompare(__pyx_t_15, __pyx_t_3, Py_GE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_14) { - /* "CAStar.pyx":102 + /* "CAStar/CAStar.pyx":102 * tScore = g[current]+ Node.Get_Cost() * if tScore >= g[NodeID]: * continue # <<<<<<<<<<<<<< * cameFrom[NodeID] = current * g[NodeID] = tScore */ - goto __pyx_L6_continue; + goto __pyx_L10_continue; - /* "CAStar.pyx":101 + /* "CAStar/CAStar.pyx":101 * Node = graph.GetNode(NodeID) * tScore = g[current]+ Node.Get_Cost() * if tScore >= g[NodeID]: # <<<<<<<<<<<<<< @@ -2606,131 +2787,131 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ } - /* "CAStar.pyx":103 + /* "CAStar/CAStar.pyx":103 * if tScore >= g[NodeID]: * continue * cameFrom[NodeID] = current # <<<<<<<<<<<<<< * g[NodeID] = tScore * fp.remove((f[NodeID],NodeID)) */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 103, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 103, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely(PyDict_SetItem(__pyx_v_cameFrom, __pyx_t_4, __pyx_t_5) < 0)) __PYX_ERR(0, 103, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(PyDict_SetItem(__pyx_v_cameFrom, __pyx_t_3, __pyx_t_2) < 0)) __PYX_ERR(0, 103, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "CAStar.pyx":104 + /* "CAStar/CAStar.pyx":104 * continue * cameFrom[NodeID] = current * g[NodeID] = tScore # <<<<<<<<<<<<<< * fp.remove((f[NodeID],NodeID)) * fTemp = g[NodeID] + EstimateDistance(NodeID,target,xCount,yCount,zCount,xSize,ySize,zSize) */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_tScore); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_4, __pyx_t_5) < 0)) __PYX_ERR(0, 104, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_tScore); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_3, __pyx_t_2) < 0)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "CAStar.pyx":105 + /* "CAStar/CAStar.pyx":105 * cameFrom[NodeID] = current * g[NodeID] = tScore * fp.remove((f[NodeID],NodeID)) # <<<<<<<<<<<<<< * fTemp = g[NodeID] + EstimateDistance(NodeID,target,xCount,yCount,zCount,xSize,ySize,zSize) * f[NodeID] = fTemp */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_remove); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_f, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 105, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_remove); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_f, __pyx_t_15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_15 = PyTuple_New(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_15); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_15); __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_2); + __pyx_t_15 = 0; + __pyx_t_15 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_15)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_15); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); + __Pyx_DECREF_SET(__pyx_t_3, function); } } - if (!__pyx_t_2) { - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_GOTREF(__pyx_t_5); + if (!__pyx_t_15) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_2); } else { #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_15}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_15}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 105, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __pyx_t_2 = NULL; - __Pyx_GIVEREF(__pyx_t_15); - PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_15); - __pyx_t_15 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 105, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_15); __pyx_t_15 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "CAStar.pyx":106 + /* "CAStar/CAStar.pyx":106 * g[NodeID] = tScore * fp.remove((f[NodeID],NodeID)) * fTemp = g[NodeID] + EstimateDistance(NodeID,target,xCount,yCount,zCount,xSize,ySize,zSize) # <<<<<<<<<<<<<< * f[NodeID] = fTemp * fp.put((fTemp,NodeID)) */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyFloat_FromDouble(__pyx_f_6CAStar_EstimateDistance(__pyx_v_NodeID, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = PyNumber_Add(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 106, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyFloat_FromDouble(__pyx_f_6CAStar_6CAStar_EstimateDistance(__pyx_v_NodeID, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 106, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 106, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 106, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_fTemp = __pyx_t_8; + __pyx_v_fTemp = __pyx_t_9; - /* "CAStar.pyx":107 + /* "CAStar/CAStar.pyx":107 * fp.remove((f[NodeID],NodeID)) * fTemp = g[NodeID] + EstimateDistance(NodeID,target,xCount,yCount,zCount,xSize,ySize,zSize) * f[NodeID] = fTemp # <<<<<<<<<<<<<< @@ -2739,93 +2920,93 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_t_1 = PyFloat_FromDouble(__pyx_v_fTemp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 107, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(PyDict_SetItem(__pyx_v_f, __pyx_t_5, __pyx_t_1) < 0)) __PYX_ERR(0, 107, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(PyDict_SetItem(__pyx_v_f, __pyx_t_2, __pyx_t_1) < 0)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "CAStar.pyx":108 + /* "CAStar/CAStar.pyx":108 * fTemp = g[NodeID] + EstimateDistance(NodeID,target,xCount,yCount,zCount,xSize,ySize,zSize) * f[NodeID] = fTemp * fp.put((fTemp,NodeID)) # <<<<<<<<<<<<<< * * f.pop(current) #These values will not be refered to again since the current NodeID has been moved to the closed set . This therefore reduces memory usage very slightly */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_put); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = PyFloat_FromDouble(__pyx_v_fTemp); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 108, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_put); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_fTemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 108, __pyx_L1_error) + __pyx_t_15 = PyTuple_New(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_15); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_15); + PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_4); + __pyx_t_3 = 0; __pyx_t_4 = 0; - __pyx_t_15 = 0; - __pyx_t_15 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_15)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_15); + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); + __Pyx_DECREF_SET(__pyx_t_2, function); } } - if (!__pyx_t_15) { - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_GOTREF(__pyx_t_1); } else { #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_2}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_15}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } else #endif #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_2}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_15}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } else #endif { - __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_15); __pyx_t_15 = NULL; - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_GIVEREF(__pyx_t_15); + PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_15); + __pyx_t_15 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __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; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "CAStar.pyx":90 + /* "CAStar/CAStar.pyx":90 * - * FriendList = graph.GetNode(current).Friends + * FriendList = graph.GetNode(current).Get_Friends() * for NodeID in FriendList: # <<<<<<<<<<<<<< * if NodeID in ClosedSet: * continue */ - __pyx_L6_continue:; + __pyx_L10_continue:; } - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "CAStar.pyx":110 + /* "CAStar/CAStar.pyx":110 * fp.put((fTemp,NodeID)) * * f.pop(current) #These values will not be refered to again since the current NodeID has been moved to the closed set . This therefore reduces memory usage very slightly # <<<<<<<<<<<<<< @@ -2834,57 +3015,57 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_pop); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = NULL; + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_4)) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } - if (!__pyx_t_4) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GOTREF(__pyx_t_3); + if (!__pyx_t_3) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_5); } else { #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_2}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_2}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else #endif { - __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL; - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_5); - __pyx_t_5 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_15, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "CAStar.pyx":111 + /* "CAStar/CAStar.pyx":111 * * f.pop(current) #These values will not be refered to again since the current NodeID has been moved to the closed set . This therefore reduces memory usage very slightly * g.pop(current) # <<<<<<<<<<<<<< @@ -2893,59 +3074,59 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_g, __pyx_n_s_pop); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = NULL; + __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_5)) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } - if (!__pyx_t_5) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_3); + if (!__pyx_t_2) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_GOTREF(__pyx_t_5); } else { #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_2}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_15}; + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_2}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_15}; + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } else #endif { - __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __pyx_t_5 = NULL; - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_GIVEREF(__pyx_t_15); + PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_15); + __pyx_t_15 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - __pyx_L4_break:; + __pyx_L8_break:; - /* "CAStar.pyx":112 + /* "CAStar/CAStar.pyx":112 * f.pop(current) #These values will not be refered to again since the current NodeID has been moved to the closed set . This therefore reduces memory usage very slightly * g.pop(current) * EndTime = time.time() # <<<<<<<<<<<<<< @@ -2954,88 +3135,88 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_time); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 112, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); + __Pyx_DECREF_SET(__pyx_t_3, function); } } if (__pyx_t_1) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { - __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 112, __pyx_L1_error) } - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_EndTime = __pyx_t_3; - __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_EndTime = __pyx_t_5; + __pyx_t_5 = 0; - /* "CAStar.pyx":113 + /* "CAStar/CAStar.pyx":113 * g.pop(current) * EndTime = time.time() * print("[A* Time] "+str((EndTime-StartTime)*1000)+" Milliseconds."+" Total Expanded:"+str(len(cameFrom))) # <<<<<<<<<<<<<< * if Found: * return FindPath(cameFrom,current) */ - __pyx_t_3 = PyNumber_Subtract(__pyx_v_EndTime, __pyx_v_StartTime); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error) + __pyx_t_5 = PyNumber_Subtract(__pyx_v_EndTime, __pyx_v_StartTime); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = PyNumber_Multiply(__pyx_t_5, __pyx_int_1000); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_int_1000); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Add(__pyx_kp_s_A_Time, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyNumber_Add(__pyx_kp_s_A_Time, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error) + __pyx_t_3 = PyNumber_Add(__pyx_t_5, __pyx_kp_s_Milliseconds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyNumber_Add(__pyx_t_3, __pyx_kp_s_Milliseconds); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Add(__pyx_t_3, __pyx_kp_s_Total_Expanded); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_kp_s_Total_Expanded); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error) + __pyx_t_13 = PyDict_Size(__pyx_v_cameFrom); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 113, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_12 = PyDict_Size(__pyx_v_cameFrom); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 113, __pyx_L1_error) - __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error) + __pyx_t_1 = PyNumber_Add(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_PrintOne(0, __pyx_t_1) < 0) __PYX_ERR(0, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "CAStar.pyx":114 + /* "CAStar/CAStar.pyx":114 * EndTime = time.time() * print("[A* Time] "+str((EndTime-StartTime)*1000)+" Milliseconds."+" Total Expanded:"+str(len(cameFrom))) * if Found: # <<<<<<<<<<<<<< * return FindPath(cameFrom,current) * else: */ - __pyx_t_13 = (__pyx_v_Found != 0); - if (__pyx_t_13) { + __pyx_t_14 = (__pyx_v_Found != 0); + if (__pyx_t_14) { - /* "CAStar.pyx":115 + /* "CAStar/CAStar.pyx":115 * print("[A* Time] "+str((EndTime-StartTime)*1000)+" Milliseconds."+" Total Expanded:"+str(len(cameFrom))) * if Found: * return FindPath(cameFrom,current) # <<<<<<<<<<<<<< @@ -3043,13 +3224,13 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py * print("A* Search FAILED. Start:",start,"Target:",target) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 115, __pyx_L1_error) + __pyx_t_1 = __pyx_f_6CAStar_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "CAStar.pyx":114 + /* "CAStar/CAStar.pyx":114 * EndTime = time.time() * print("[A* Time] "+str((EndTime-StartTime)*1000)+" Milliseconds."+" Total Expanded:"+str(len(cameFrom))) * if Found: # <<<<<<<<<<<<<< @@ -3058,7 +3239,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ } - /* "CAStar.pyx":117 + /* "CAStar/CAStar.pyx":117 * return FindPath(cameFrom,current) * else: * print("A* Search FAILED. Start:",start,"Target:",target) # <<<<<<<<<<<<<< @@ -3068,38 +3249,38 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py /*else*/ { __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_target); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 117, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_target); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(__pyx_kp_s_A_Search_FAILED_Start); __Pyx_GIVEREF(__pyx_kp_s_A_Search_FAILED_Start); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_s_A_Search_FAILED_Start); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_s_A_Search_FAILED_Start); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); __Pyx_INCREF(__pyx_kp_s_Target); __Pyx_GIVEREF(__pyx_kp_s_Target); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_s_Target); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_s_Target); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_3); __pyx_t_1 = 0; - __pyx_t_4 = 0; - if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = 0; + if (__Pyx_PrintOne(0, __pyx_t_5) < 0) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "CAStar.pyx":118 + /* "CAStar/CAStar.pyx":118 * else: * print("A* Search FAILED. Start:",start,"Target:",target) * print(FindPath(cameFrom,current)) # <<<<<<<<<<<<<< * return None * */ - __pyx_t_3 = __pyx_f_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 118, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_f_6CAStar_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_PrintOne(0, __pyx_t_5) < 0) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "CAStar.pyx":119 + /* "CAStar/CAStar.pyx":119 * print("A* Search FAILED. Start:",start,"Target:",target) * print(FindPath(cameFrom,current)) * return None # <<<<<<<<<<<<<< @@ -3112,7 +3293,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py goto __pyx_L0; } - /* "CAStar.pyx":54 + /* "CAStar/CAStar.pyx":54 * return zCoord * * def AStarPQ(graph, int start, int target): # Set all g to node_count + 1 # <<<<<<<<<<<<<< @@ -3128,7 +3309,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_15); - __Pyx_AddTraceback("CAStar.AStarPQ", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("CAStar.CAStar.AStarPQ", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_StartTime); @@ -3147,7 +3328,7 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py return __pyx_r; } -/* "CAStar.pyx":121 +/* "CAStar/CAStar.pyx":121 * return None * * def AStar2(graph, int start, int target): # Set all g to node_count + 1 # <<<<<<<<<<<<<< @@ -3156,9 +3337,9 @@ static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, Py */ /* Python wrapper */ -static PyObject *__pyx_pw_6CAStar_3AStar2(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_6CAStar_3AStar2 = {"AStar2", (PyCFunction)__pyx_pw_6CAStar_3AStar2, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_6CAStar_3AStar2(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_6CAStar_6CAStar_3AStar2(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_6CAStar_3AStar2 = {"AStar2", (PyCFunction)__pyx_pw_6CAStar_6CAStar_3AStar2, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_6CAStar_6CAStar_3AStar2(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_graph = 0; int __pyx_v_start; int __pyx_v_target; @@ -3217,18 +3398,18 @@ static PyObject *__pyx_pw_6CAStar_3AStar2(PyObject *__pyx_self, PyObject *__pyx_ __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("AStar2", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 121, __pyx_L3_error) __pyx_L3_error:; - __Pyx_AddTraceback("CAStar.AStar2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("CAStar.CAStar.AStar2", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_6CAStar_2AStar2(__pyx_self, __pyx_v_graph, __pyx_v_start, __pyx_v_target); + __pyx_r = __pyx_pf_6CAStar_6CAStar_2AStar2(__pyx_self, __pyx_v_graph, __pyx_v_start, __pyx_v_target); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "CAStar.pyx":145 +/* "CAStar/CAStar.pyx":145 * Found = False * while len(OpenSet) != 0: * current = min(f, key = lambda n:f[n]) #Faster (106 vs 62 ms) and doesnt require OpenList to be made # <<<<<<<<<<<<<< @@ -3237,9 +3418,9 @@ static PyObject *__pyx_pw_6CAStar_3AStar2(PyObject *__pyx_self, PyObject *__pyx_ */ /* Python wrapper */ -static PyObject *__pyx_pw_6CAStar_6AStar2_lambda(PyObject *__pyx_self, PyObject *__pyx_v_n); /*proto*/ -static PyMethodDef __pyx_mdef_6CAStar_6AStar2_lambda = {"lambda", (PyCFunction)__pyx_pw_6CAStar_6AStar2_lambda, METH_O, 0}; -static PyObject *__pyx_pw_6CAStar_6AStar2_lambda(PyObject *__pyx_self, PyObject *__pyx_v_n) { +static PyObject *__pyx_pw_6CAStar_6CAStar_6AStar2_lambda(PyObject *__pyx_self, PyObject *__pyx_v_n); /*proto*/ +static PyMethodDef __pyx_mdef_6CAStar_6CAStar_6AStar2_lambda = {"lambda", (PyCFunction)__pyx_pw_6CAStar_6CAStar_6AStar2_lambda, METH_O, 0}; +static PyObject *__pyx_pw_6CAStar_6CAStar_6AStar2_lambda(PyObject *__pyx_self, PyObject *__pyx_v_n) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("lambda (wrapper)", 0); @@ -3251,13 +3432,13 @@ static PyObject *__pyx_pw_6CAStar_6AStar2_lambda(PyObject *__pyx_self, PyObject } static PyObject *__pyx_lambda_funcdef_lambda(PyObject *__pyx_self, PyObject *__pyx_v_n) { - struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *__pyx_cur_scope; - struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *__pyx_outer_scope; + struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *__pyx_cur_scope; + struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *__pyx_outer_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("lambda", 0); - __pyx_outer_scope = (struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *) __Pyx_CyFunction_GetClosure(__pyx_self); + __pyx_outer_scope = (struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *) __Pyx_CyFunction_GetClosure(__pyx_self); __pyx_cur_scope = __pyx_outer_scope; __Pyx_XDECREF(__pyx_r); if (unlikely(!__pyx_cur_scope->__pyx_v_f)) { __Pyx_RaiseClosureNameError("f"); __PYX_ERR(0, 145, __pyx_L1_error) } @@ -3274,7 +3455,7 @@ static PyObject *__pyx_lambda_funcdef_lambda(PyObject *__pyx_self, PyObject *__p /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("CAStar.AStar2.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("CAStar.CAStar.AStar2.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -3282,7 +3463,7 @@ static PyObject *__pyx_lambda_funcdef_lambda(PyObject *__pyx_self, PyObject *__p return __pyx_r; } -/* "CAStar.pyx":121 +/* "CAStar/CAStar.pyx":121 * return None * * def AStar2(graph, int start, int target): # Set all g to node_count + 1 # <<<<<<<<<<<<<< @@ -3290,8 +3471,8 @@ static PyObject *__pyx_lambda_funcdef_lambda(PyObject *__pyx_self, PyObject *__p * */ -static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_graph, int __pyx_v_start, int __pyx_v_target) { - struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *__pyx_cur_scope; +static PyObject *__pyx_pf_6CAStar_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_graph, int __pyx_v_start, int __pyx_v_target) { + struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *__pyx_cur_scope; PyObject *__pyx_v_StartTime = NULL; float __pyx_v_xSize; float __pyx_v_ySize; @@ -3318,27 +3499,28 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - float __pyx_t_6; + PyObject *(*__pyx_t_6)(PyObject *); float __pyx_t_7; float __pyx_t_8; - int __pyx_t_9; + float __pyx_t_9; int __pyx_t_10; int __pyx_t_11; - Py_ssize_t __pyx_t_12; - int __pyx_t_13; - PyObject *__pyx_t_14 = NULL; - int __pyx_t_15; + int __pyx_t_12; + Py_ssize_t __pyx_t_13; + int __pyx_t_14; + PyObject *__pyx_t_15 = NULL; + int __pyx_t_16; __Pyx_RefNannySetupContext("AStar2", 0); - __pyx_cur_scope = (struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *)__pyx_tp_new_6CAStar___pyx_scope_struct__AStar2(__pyx_ptype_6CAStar___pyx_scope_struct__AStar2, __pyx_empty_tuple, NULL); + __pyx_cur_scope = (struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *)__pyx_tp_new_6CAStar_6CAStar___pyx_scope_struct__AStar2(__pyx_ptype_6CAStar_6CAStar___pyx_scope_struct__AStar2, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { - __pyx_cur_scope = ((struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *)Py_None); + __pyx_cur_scope = ((struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(0, 121, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } - /* "CAStar.pyx":122 + /* "CAStar/CAStar.pyx":122 * * def AStar2(graph, int start, int target): # Set all g to node_count + 1 * StartTime = time.time() # <<<<<<<<<<<<<< @@ -3371,12 +3553,12 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_v_StartTime = __pyx_t_1; __pyx_t_1 = 0; - /* "CAStar.pyx":130 + /* "CAStar/CAStar.pyx":130 * * * TargetNode = graph.GetNode(target) # <<<<<<<<<<<<<< - * xSize,ySize,zSize = graph.xSize,graph.ySize,graph.zSize - * xCount,yCount,zCount = graph.xCount,graph.yCount,graph.zCount + * xSize,ySize,zSize = graph.Get_Size() + * xCount,yCount,zCount = graph.Get_Count() */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 130, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); @@ -3431,54 +3613,196 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_v_TargetNode = __pyx_t_1; __pyx_t_1 = 0; - /* "CAStar.pyx":131 + /* "CAStar/CAStar.pyx":131 * * TargetNode = graph.GetNode(target) - * xSize,ySize,zSize = graph.xSize,graph.ySize,graph.zSize # <<<<<<<<<<<<<< - * xCount,yCount,zCount = graph.xCount,graph.yCount,graph.zCount + * xSize,ySize,zSize = graph.Get_Size() # <<<<<<<<<<<<<< + * xCount,yCount,zCount = graph.Get_Count() * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_xSize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_ySize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_7 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_7 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_zSize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_Get_Size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) + } __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_xSize = __pyx_t_6; - __pyx_v_ySize = __pyx_t_7; - __pyx_v_zSize = __pyx_t_8; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 3)) { + if (size > 3) __Pyx_RaiseTooManyValuesError(3); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 131, __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_t_5 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_3 = PyList_GET_ITEM(sequence, 0); + __pyx_t_5 = PyList_GET_ITEM(sequence, 1); + __pyx_t_2 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_2); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; + index = 0; __pyx_t_3 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + index = 1; __pyx_t_5 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_5)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 2; __pyx_t_2 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_4), 3) < 0) __PYX_ERR(0, 131, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L4_unpacking_done; + __pyx_L3_unpacking_failed:; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 131, __pyx_L1_error) + __pyx_L4_unpacking_done:; + } + __pyx_t_7 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_7 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_xSize = __pyx_t_7; + __pyx_v_ySize = __pyx_t_8; + __pyx_v_zSize = __pyx_t_9; - /* "CAStar.pyx":132 + /* "CAStar/CAStar.pyx":132 * TargetNode = graph.GetNode(target) - * xSize,ySize,zSize = graph.xSize,graph.ySize,graph.zSize - * xCount,yCount,zCount = graph.xCount,graph.yCount,graph.zCount # <<<<<<<<<<<<<< + * xSize,ySize,zSize = graph.Get_Size() + * xCount,yCount,zCount = graph.Get_Count() # <<<<<<<<<<<<<< * * ClosedSet = {} #Dict to hash find closed nodes */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_xCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_yCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_zCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_Get_Count); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error) + } __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_xCount = __pyx_t_9; - __pyx_v_yCount = __pyx_t_10; - __pyx_v_zCount = __pyx_t_11; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 3)) { + if (size > 3) __Pyx_RaiseTooManyValuesError(3); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 132, __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_t_5 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 2); + } else { + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_5 = PyList_GET_ITEM(sequence, 1); + __pyx_t_3 = PyList_GET_ITEM(sequence, 2); + } + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; + index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_5 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + index = 2; __pyx_t_3 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_4), 3) < 0) __PYX_ERR(0, 132, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 132, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_xCount = __pyx_t_10; + __pyx_v_yCount = __pyx_t_11; + __pyx_v_zCount = __pyx_t_12; - /* "CAStar.pyx":134 - * xCount,yCount,zCount = graph.xCount,graph.yCount,graph.zCount + /* "CAStar/CAStar.pyx":134 + * xCount,yCount,zCount = graph.Get_Count() * * ClosedSet = {} #Dict to hash find closed nodes # <<<<<<<<<<<<<< * OpenSet = {start:1} @@ -3489,7 +3813,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_v_ClosedSet = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "CAStar.pyx":135 + /* "CAStar/CAStar.pyx":135 * * ClosedSet = {} #Dict to hash find closed nodes * OpenSet = {start:1} # <<<<<<<<<<<<<< @@ -3505,7 +3829,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_v_OpenSet = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "CAStar.pyx":136 + /* "CAStar/CAStar.pyx":136 * ClosedSet = {} #Dict to hash find closed nodes * OpenSet = {start:1} * cameFrom = {} # <<<<<<<<<<<<<< @@ -3517,7 +3841,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_v_cameFrom = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "CAStar.pyx":137 + /* "CAStar/CAStar.pyx":137 * OpenSet = {start:1} * cameFrom = {} * g,f = {},{} # <<<<<<<<<<<<<< @@ -3534,7 +3858,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_cur_scope->__pyx_v_f = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "CAStar.pyx":138 + /* "CAStar/CAStar.pyx":138 * cameFrom = {} * g,f = {},{} * current = -1 # <<<<<<<<<<<<<< @@ -3543,7 +3867,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_v_current = -1; - /* "CAStar.pyx":141 + /* "CAStar/CAStar.pyx":141 * * * g[start] = 0 # <<<<<<<<<<<<<< @@ -3555,14 +3879,14 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_3, __pyx_int_0) < 0)) __PYX_ERR(0, 141, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "CAStar.pyx":142 + /* "CAStar/CAStar.pyx":142 * * g[start] = 0 * f[start] = EstimateDistance(start,target,xCount,yCount,zCount,xSize,ySize,zSize) # <<<<<<<<<<<<<< * Found = False * while len(OpenSet) != 0: */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_f_6CAStar_EstimateDistance(__pyx_v_start, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 142, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_f_6CAStar_6CAStar_EstimateDistance(__pyx_v_start, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -3570,7 +3894,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "CAStar.pyx":143 + /* "CAStar/CAStar.pyx":143 * g[start] = 0 * f[start] = EstimateDistance(start,target,xCount,yCount,zCount,xSize,ySize,zSize) * Found = False # <<<<<<<<<<<<<< @@ -3579,7 +3903,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_v_Found = 0; - /* "CAStar.pyx":144 + /* "CAStar/CAStar.pyx":144 * f[start] = EstimateDistance(start,target,xCount,yCount,zCount,xSize,ySize,zSize) * Found = False * while len(OpenSet) != 0: # <<<<<<<<<<<<<< @@ -3587,11 +3911,11 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py * if current == target: */ while (1) { - __pyx_t_12 = PyDict_Size(__pyx_v_OpenSet); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 144, __pyx_L1_error) - __pyx_t_13 = ((__pyx_t_12 != 0) != 0); - if (!__pyx_t_13) break; + __pyx_t_13 = PyDict_Size(__pyx_v_OpenSet); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 144, __pyx_L1_error) + __pyx_t_14 = ((__pyx_t_13 != 0) != 0); + if (!__pyx_t_14) break; - /* "CAStar.pyx":145 + /* "CAStar/CAStar.pyx":145 * Found = False * while len(OpenSet) != 0: * current = min(f, key = lambda n:f[n]) #Faster (106 vs 62 ms) and doesnt require OpenList to be made # <<<<<<<<<<<<<< @@ -3605,7 +3929,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_cur_scope->__pyx_v_f); __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_6AStar2_lambda, 0, __pyx_n_s_AStar2_locals_lambda, ((PyObject*)__pyx_cur_scope), __pyx_n_s_CAStar, __pyx_d, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 145, __pyx_L1_error) + __pyx_t_5 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_6CAStar_6AStar2_lambda, 0, __pyx_n_s_AStar2_locals_lambda, ((PyObject*)__pyx_cur_scope), __pyx_n_s_CAStar_CAStar, __pyx_d, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_key, __pyx_t_5) < 0) __PYX_ERR(0, 145, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; @@ -3613,21 +3937,21 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 145, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 145, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_current = __pyx_t_11; + __pyx_v_current = __pyx_t_12; - /* "CAStar.pyx":146 + /* "CAStar/CAStar.pyx":146 * while len(OpenSet) != 0: * current = min(f, key = lambda n:f[n]) #Faster (106 vs 62 ms) and doesnt require OpenList to be made * if current == target: # <<<<<<<<<<<<<< * Found = True * break */ - __pyx_t_13 = ((__pyx_v_current == __pyx_v_target) != 0); - if (__pyx_t_13) { + __pyx_t_14 = ((__pyx_v_current == __pyx_v_target) != 0); + if (__pyx_t_14) { - /* "CAStar.pyx":147 + /* "CAStar/CAStar.pyx":147 * current = min(f, key = lambda n:f[n]) #Faster (106 vs 62 ms) and doesnt require OpenList to be made * if current == target: * Found = True # <<<<<<<<<<<<<< @@ -3636,16 +3960,16 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_v_Found = 1; - /* "CAStar.pyx":148 + /* "CAStar/CAStar.pyx":148 * if current == target: * Found = True * break # <<<<<<<<<<<<<< * * OpenSet.pop(current) */ - goto __pyx_L4_break; + goto __pyx_L8_break; - /* "CAStar.pyx":146 + /* "CAStar/CAStar.pyx":146 * while len(OpenSet) != 0: * current = min(f, key = lambda n:f[n]) #Faster (106 vs 62 ms) and doesnt require OpenList to be made * if current == target: # <<<<<<<<<<<<<< @@ -3654,7 +3978,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py */ } - /* "CAStar.pyx":150 + /* "CAStar/CAStar.pyx":150 * break * * OpenSet.pop(current) # <<<<<<<<<<<<<< @@ -3713,7 +4037,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "CAStar.pyx":151 + /* "CAStar/CAStar.pyx":151 * * OpenSet.pop(current) * ClosedSet[current] = 1 # <<<<<<<<<<<<<< @@ -3725,7 +4049,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py if (unlikely(PyDict_SetItem(__pyx_v_ClosedSet, __pyx_t_5, __pyx_int_1) < 0)) __PYX_ERR(0, 151, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "CAStar.pyx":153 + /* "CAStar/CAStar.pyx":153 * ClosedSet[current] = 1 * * FriendList = graph.GetNode(current).Get_Friends() # <<<<<<<<<<<<<< @@ -3770,15 +4094,15 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py } else #endif { - __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_2); __pyx_t_2 = NULL; + __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_2); __pyx_t_2 = NULL; __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_15, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -3807,7 +4131,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_XDECREF_SET(__pyx_v_FriendList, ((PyObject*)__pyx_t_5)); __pyx_t_5 = 0; - /* "CAStar.pyx":154 + /* "CAStar/CAStar.pyx":154 * * FriendList = graph.GetNode(current).Get_Friends() * for NodeID in FriendList: # <<<<<<<<<<<<<< @@ -3818,20 +4142,20 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 154, __pyx_L1_error) } - __pyx_t_5 = __pyx_v_FriendList; __Pyx_INCREF(__pyx_t_5); __pyx_t_12 = 0; + __pyx_t_5 = __pyx_v_FriendList; __Pyx_INCREF(__pyx_t_5); __pyx_t_13 = 0; for (;;) { - if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_5)) break; + if (__pyx_t_13 >= PyList_GET_SIZE(__pyx_t_5)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_12); __Pyx_INCREF(__pyx_t_4); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(0, 154, __pyx_L1_error) + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_13); __Pyx_INCREF(__pyx_t_4); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 154, __pyx_L1_error) #else - __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error) + __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif - __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 154, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_NodeID = __pyx_t_11; + __pyx_v_NodeID = __pyx_t_12; - /* "CAStar.pyx":155 + /* "CAStar/CAStar.pyx":155 * FriendList = graph.GetNode(current).Get_Friends() * for NodeID in FriendList: * if NodeID in ClosedSet: # <<<<<<<<<<<<<< @@ -3840,21 +4164,21 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 155, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_13 = (__Pyx_PyDict_ContainsTF(__pyx_t_4, __pyx_v_ClosedSet, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 155, __pyx_L1_error) + __pyx_t_14 = (__Pyx_PyDict_ContainsTF(__pyx_t_4, __pyx_v_ClosedSet, Py_EQ)); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 155, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_15 = (__pyx_t_13 != 0); - if (__pyx_t_15) { + __pyx_t_16 = (__pyx_t_14 != 0); + if (__pyx_t_16) { - /* "CAStar.pyx":156 + /* "CAStar/CAStar.pyx":156 * for NodeID in FriendList: * if NodeID in ClosedSet: * continue # <<<<<<<<<<<<<< * if NodeID not in OpenSet: * OpenSet[NodeID] = 1 */ - goto __pyx_L6_continue; + goto __pyx_L10_continue; - /* "CAStar.pyx":155 + /* "CAStar/CAStar.pyx":155 * FriendList = graph.GetNode(current).Get_Friends() * for NodeID in FriendList: * if NodeID in ClosedSet: # <<<<<<<<<<<<<< @@ -3863,7 +4187,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py */ } - /* "CAStar.pyx":157 + /* "CAStar/CAStar.pyx":157 * if NodeID in ClosedSet: * continue * if NodeID not in OpenSet: # <<<<<<<<<<<<<< @@ -3872,12 +4196,12 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_15 = (__Pyx_PyDict_ContainsTF(__pyx_t_4, __pyx_v_OpenSet, Py_NE)); if (unlikely(__pyx_t_15 < 0)) __PYX_ERR(0, 157, __pyx_L1_error) + __pyx_t_16 = (__Pyx_PyDict_ContainsTF(__pyx_t_4, __pyx_v_OpenSet, Py_NE)); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_13 = (__pyx_t_15 != 0); - if (__pyx_t_13) { + __pyx_t_14 = (__pyx_t_16 != 0); + if (__pyx_t_14) { - /* "CAStar.pyx":158 + /* "CAStar/CAStar.pyx":158 * continue * if NodeID not in OpenSet: * OpenSet[NodeID] = 1 # <<<<<<<<<<<<<< @@ -3889,7 +4213,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py if (unlikely(PyDict_SetItem(__pyx_v_OpenSet, __pyx_t_4, __pyx_int_1) < 0)) __PYX_ERR(0, 158, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "CAStar.pyx":159 + /* "CAStar/CAStar.pyx":159 * if NodeID not in OpenSet: * OpenSet[NodeID] = 1 * g[NodeID] = math.inf # <<<<<<<<<<<<<< @@ -3907,7 +4231,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "CAStar.pyx":160 + /* "CAStar/CAStar.pyx":160 * OpenSet[NodeID] = 1 * g[NodeID] = math.inf * f[NodeID] = math.inf # <<<<<<<<<<<<<< @@ -3925,7 +4249,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "CAStar.pyx":157 + /* "CAStar/CAStar.pyx":157 * if NodeID in ClosedSet: * continue * if NodeID not in OpenSet: # <<<<<<<<<<<<<< @@ -3934,7 +4258,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py */ } - /* "CAStar.pyx":162 + /* "CAStar/CAStar.pyx":162 * f[NodeID] = math.inf * * Node = graph.GetNode(NodeID) # <<<<<<<<<<<<<< @@ -3943,8 +4267,8 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_14 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 162, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); @@ -3956,35 +4280,35 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py } } if (!__pyx_t_3) { - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_14); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_15); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_GOTREF(__pyx_t_4); } else { #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_14}; + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_15}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_14}; + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_15}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } else #endif { __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL; - __Pyx_GIVEREF(__pyx_t_14); - PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_14); - __pyx_t_14 = 0; + __Pyx_GIVEREF(__pyx_t_15); + PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_15); + __pyx_t_15 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -3994,7 +4318,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_XDECREF_SET(__pyx_v_Node, __pyx_t_4); __pyx_t_4 = 0; - /* "CAStar.pyx":163 + /* "CAStar/CAStar.pyx":163 * * Node = graph.GetNode(NodeID) * tScore = g[current]+ Node.Get_Cost() # <<<<<<<<<<<<<< @@ -4008,19 +4332,19 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_Node, __pyx_n_s_Get_Cost); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_14 = NULL; + __pyx_t_15 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_14)) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_15)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_14); + __Pyx_INCREF(__pyx_t_15); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } - if (__pyx_t_14) { - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_14); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (__pyx_t_15) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_15); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error) } @@ -4030,11 +4354,11 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 163, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 163, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_tScore = __pyx_t_11; + __pyx_v_tScore = __pyx_t_12; - /* "CAStar.pyx":164 + /* "CAStar/CAStar.pyx":164 * Node = graph.GetNode(NodeID) * tScore = g[current]+ Node.Get_Cost() * if tScore >= g[NodeID]: # <<<<<<<<<<<<<< @@ -4051,20 +4375,20 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 164, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 164, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_13) { + if (__pyx_t_14) { - /* "CAStar.pyx":165 + /* "CAStar/CAStar.pyx":165 * tScore = g[current]+ Node.Get_Cost() * if tScore >= g[NodeID]: * continue # <<<<<<<<<<<<<< * cameFrom[NodeID] = current * g[NodeID] = tScore */ - goto __pyx_L6_continue; + goto __pyx_L10_continue; - /* "CAStar.pyx":164 + /* "CAStar/CAStar.pyx":164 * Node = graph.GetNode(NodeID) * tScore = g[current]+ Node.Get_Cost() * if tScore >= g[NodeID]: # <<<<<<<<<<<<<< @@ -4073,7 +4397,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py */ } - /* "CAStar.pyx":166 + /* "CAStar/CAStar.pyx":166 * if tScore >= g[NodeID]: * continue * cameFrom[NodeID] = current # <<<<<<<<<<<<<< @@ -4088,7 +4412,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "CAStar.pyx":167 + /* "CAStar/CAStar.pyx":167 * continue * cameFrom[NodeID] = current * g[NodeID] = tScore # <<<<<<<<<<<<<< @@ -4103,7 +4427,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "CAStar.pyx":168 + /* "CAStar/CAStar.pyx":168 * cameFrom[NodeID] = current * g[NodeID] = tScore * f[NodeID] = g[NodeID] + EstimateDistance(NodeID,target,xCount,yCount,zCount,xSize,ySize,zSize) # <<<<<<<<<<<<<< @@ -4115,7 +4439,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyFloat_FromDouble(__pyx_f_6CAStar_EstimateDistance(__pyx_v_NodeID, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble(__pyx_f_6CAStar_6CAStar_EstimateDistance(__pyx_v_NodeID, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -4127,18 +4451,18 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "CAStar.pyx":154 + /* "CAStar/CAStar.pyx":154 * * FriendList = graph.GetNode(current).Get_Friends() * for NodeID in FriendList: # <<<<<<<<<<<<<< * if NodeID in ClosedSet: * continue */ - __pyx_L6_continue:; + __pyx_L10_continue:; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "CAStar.pyx":169 + /* "CAStar/CAStar.pyx":169 * g[NodeID] = tScore * f[NodeID] = g[NodeID] + EstimateDistance(NodeID,target,xCount,yCount,zCount,xSize,ySize,zSize) * f.pop(current) #These values will not be refered to again since the current NodeID has been moved to the closed set . This therefore reduces memory usage very slightly # <<<<<<<<<<<<<< @@ -4183,21 +4507,21 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py } else #endif { - __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 169, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_1); __pyx_t_1 = NULL; + __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_1); __pyx_t_1 = NULL; __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_14, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_15, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "CAStar.pyx":170 + /* "CAStar/CAStar.pyx":170 * f[NodeID] = g[NodeID] + EstimateDistance(NodeID,target,xCount,yCount,zCount,xSize,ySize,zSize) * f.pop(current) #These values will not be refered to again since the current NodeID has been moved to the closed set . This therefore reduces memory usage very slightly * g.pop(current) # <<<<<<<<<<<<<< @@ -4206,8 +4530,8 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_g, __pyx_n_s_pop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_14 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 170, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); @@ -4219,35 +4543,35 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py } } if (!__pyx_t_4) { - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_14); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_GOTREF(__pyx_t_5); } else { #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_14}; + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_15}; __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_14}; + PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_15}; __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } else #endif { __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __pyx_t_4 = NULL; - __Pyx_GIVEREF(__pyx_t_14); - PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_14); - __pyx_t_14 = 0; + __Pyx_GIVEREF(__pyx_t_15); + PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_15); + __pyx_t_15 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -4256,9 +4580,9 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - __pyx_L4_break:; + __pyx_L8_break:; - /* "CAStar.pyx":171 + /* "CAStar/CAStar.pyx":171 * f.pop(current) #These values will not be refered to again since the current NodeID has been moved to the closed set . This therefore reduces memory usage very slightly * g.pop(current) * EndTime = time.time() # <<<<<<<<<<<<<< @@ -4291,7 +4615,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_v_EndTime = __pyx_t_5; __pyx_t_5 = 0; - /* "CAStar.pyx":172 + /* "CAStar/CAStar.pyx":172 * g.pop(current) * EndTime = time.time() * print("[A* Time] "+str((EndTime-StartTime)*1000)+" Milliseconds."+" Total Expanded:"+str(len(cameFrom))) # <<<<<<<<<<<<<< @@ -4320,8 +4644,8 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __pyx_t_5 = PyNumber_Add(__pyx_t_1, __pyx_kp_s_Total_Expanded); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_12 = PyDict_Size(__pyx_v_cameFrom); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 172, __pyx_L1_error) - __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error) + __pyx_t_13 = PyDict_Size(__pyx_v_cameFrom); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 172, __pyx_L1_error) + __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_13); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -4338,17 +4662,17 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(0, 172, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "CAStar.pyx":173 + /* "CAStar/CAStar.pyx":173 * EndTime = time.time() * print("[A* Time] "+str((EndTime-StartTime)*1000)+" Milliseconds."+" Total Expanded:"+str(len(cameFrom))) * if Found: # <<<<<<<<<<<<<< * return FindPath(cameFrom,current) * else: */ - __pyx_t_13 = (__pyx_v_Found != 0); - if (__pyx_t_13) { + __pyx_t_14 = (__pyx_v_Found != 0); + if (__pyx_t_14) { - /* "CAStar.pyx":174 + /* "CAStar/CAStar.pyx":174 * print("[A* Time] "+str((EndTime-StartTime)*1000)+" Milliseconds."+" Total Expanded:"+str(len(cameFrom))) * if Found: * return FindPath(cameFrom,current) # <<<<<<<<<<<<<< @@ -4356,13 +4680,13 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py * print("A* Search FAILED. Start:",start,"Target:",target) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_f_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 174, __pyx_L1_error) + __pyx_t_2 = __pyx_f_6CAStar_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 174, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "CAStar.pyx":173 + /* "CAStar/CAStar.pyx":173 * EndTime = time.time() * print("[A* Time] "+str((EndTime-StartTime)*1000)+" Milliseconds."+" Total Expanded:"+str(len(cameFrom))) * if Found: # <<<<<<<<<<<<<< @@ -4371,7 +4695,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py */ } - /* "CAStar.pyx":176 + /* "CAStar/CAStar.pyx":176 * return FindPath(cameFrom,current) * else: * print("A* Search FAILED. Start:",start,"Target:",target) # <<<<<<<<<<<<<< @@ -4400,19 +4724,19 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py if (__Pyx_PrintOne(0, __pyx_t_5) < 0) __PYX_ERR(0, 176, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "CAStar.pyx":177 + /* "CAStar/CAStar.pyx":177 * else: * print("A* Search FAILED. Start:",start,"Target:",target) * print(FindPath(cameFrom,current)) # <<<<<<<<<<<<<< * return None * */ - __pyx_t_5 = __pyx_f_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 177, __pyx_L1_error) + __pyx_t_5 = __pyx_f_6CAStar_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 177, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__Pyx_PrintOne(0, __pyx_t_5) < 0) __PYX_ERR(0, 177, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "CAStar.pyx":178 + /* "CAStar/CAStar.pyx":178 * print("A* Search FAILED. Start:",start,"Target:",target) * print(FindPath(cameFrom,current)) * return None # <<<<<<<<<<<<<< @@ -4425,7 +4749,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py goto __pyx_L0; } - /* "CAStar.pyx":121 + /* "CAStar/CAStar.pyx":121 * return None * * def AStar2(graph, int start, int target): # Set all g to node_count + 1 # <<<<<<<<<<<<<< @@ -4440,8 +4764,8 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_14); - __Pyx_AddTraceback("CAStar.AStar2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_AddTraceback("CAStar.CAStar.AStar2", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_StartTime); @@ -4459,7 +4783,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py return __pyx_r; } -/* "CAStar.pyx":181 +/* "CAStar/CAStar.pyx":181 * * * cdef FindPath(dict cameFrom, int current): # <<<<<<<<<<<<<< @@ -4467,7 +4791,7 @@ static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, Py * path = [current] */ -static PyObject *__pyx_f_6CAStar_FindPath(PyObject *__pyx_v_cameFrom, int __pyx_v_current) { +static PyObject *__pyx_f_6CAStar_6CAStar_FindPath(PyObject *__pyx_v_cameFrom, int __pyx_v_current) { PyObject *__pyx_v_path = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations @@ -4479,7 +4803,7 @@ static PyObject *__pyx_f_6CAStar_FindPath(PyObject *__pyx_v_cameFrom, int __pyx_ int __pyx_t_6; __Pyx_RefNannySetupContext("FindPath", 0); - /* "CAStar.pyx":183 + /* "CAStar/CAStar.pyx":183 * cdef FindPath(dict cameFrom, int current): * cdef list path * path = [current] # <<<<<<<<<<<<<< @@ -4496,7 +4820,7 @@ static PyObject *__pyx_f_6CAStar_FindPath(PyObject *__pyx_v_cameFrom, int __pyx_ __pyx_v_path = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; - /* "CAStar.pyx":184 + /* "CAStar/CAStar.pyx":184 * cdef list path * path = [current] * while current in cameFrom: # <<<<<<<<<<<<<< @@ -4515,12 +4839,12 @@ static PyObject *__pyx_f_6CAStar_FindPath(PyObject *__pyx_v_cameFrom, int __pyx_ __pyx_t_4 = (__pyx_t_3 != 0); if (!__pyx_t_4) break; - /* "CAStar.pyx":185 + /* "CAStar/CAStar.pyx":185 * path = [current] * while current in cameFrom: * current = cameFrom[current] # <<<<<<<<<<<<<< * path.append(current) - * return path + * return path[::-1] */ if (unlikely(__pyx_v_cameFrom == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); @@ -4535,11 +4859,11 @@ static PyObject *__pyx_f_6CAStar_FindPath(PyObject *__pyx_v_cameFrom, int __pyx_ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_current = __pyx_t_5; - /* "CAStar.pyx":186 + /* "CAStar/CAStar.pyx":186 * while current in cameFrom: * current = cameFrom[current] * path.append(current) # <<<<<<<<<<<<<< - * return path + * return path[::-1] * */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 186, __pyx_L1_error) @@ -4548,19 +4872,21 @@ static PyObject *__pyx_f_6CAStar_FindPath(PyObject *__pyx_v_cameFrom, int __pyx_ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - /* "CAStar.pyx":187 + /* "CAStar/CAStar.pyx":187 * current = cameFrom[current] * path.append(current) - * return path # <<<<<<<<<<<<<< + * return path[::-1] # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_path); - __pyx_r = __pyx_v_path; + __pyx_t_1 = PyObject_GetItem(__pyx_v_path, __pyx_slice_); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; - /* "CAStar.pyx":181 + /* "CAStar/CAStar.pyx":181 * * * cdef FindPath(dict cameFrom, int current): # <<<<<<<<<<<<<< @@ -4572,7 +4898,7 @@ static PyObject *__pyx_f_6CAStar_FindPath(PyObject *__pyx_v_cameFrom, int __pyx_ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("CAStar.FindPath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("CAStar.CAStar.FindPath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_path); @@ -4581,14 +4907,14 @@ static PyObject *__pyx_f_6CAStar_FindPath(PyObject *__pyx_v_cameFrom, int __pyx_ return __pyx_r; } -static struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *__pyx_freelist_6CAStar___pyx_scope_struct__AStar2[8]; -static int __pyx_freecount_6CAStar___pyx_scope_struct__AStar2 = 0; +static struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *__pyx_freelist_6CAStar_6CAStar___pyx_scope_struct__AStar2[8]; +static int __pyx_freecount_6CAStar_6CAStar___pyx_scope_struct__AStar2 = 0; -static PyObject *__pyx_tp_new_6CAStar___pyx_scope_struct__AStar2(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { +static PyObject *__pyx_tp_new_6CAStar_6CAStar___pyx_scope_struct__AStar2(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6CAStar___pyx_scope_struct__AStar2 > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2)))) { - o = (PyObject*)__pyx_freelist_6CAStar___pyx_scope_struct__AStar2[--__pyx_freecount_6CAStar___pyx_scope_struct__AStar2]; - memset(o, 0, sizeof(struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2)); + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_6CAStar_6CAStar___pyx_scope_struct__AStar2 > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2)))) { + o = (PyObject*)__pyx_freelist_6CAStar_6CAStar___pyx_scope_struct__AStar2[--__pyx_freecount_6CAStar_6CAStar___pyx_scope_struct__AStar2]; + memset(o, 0, sizeof(struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { @@ -4598,41 +4924,41 @@ static PyObject *__pyx_tp_new_6CAStar___pyx_scope_struct__AStar2(PyTypeObject *t return o; } -static void __pyx_tp_dealloc_6CAStar___pyx_scope_struct__AStar2(PyObject *o) { - struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *p = (struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *)o; +static void __pyx_tp_dealloc_6CAStar_6CAStar___pyx_scope_struct__AStar2(PyObject *o) { + struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *p = (struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_f); - if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6CAStar___pyx_scope_struct__AStar2 < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2)))) { - __pyx_freelist_6CAStar___pyx_scope_struct__AStar2[__pyx_freecount_6CAStar___pyx_scope_struct__AStar2++] = ((struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *)o); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_6CAStar_6CAStar___pyx_scope_struct__AStar2 < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2)))) { + __pyx_freelist_6CAStar_6CAStar___pyx_scope_struct__AStar2[__pyx_freecount_6CAStar_6CAStar___pyx_scope_struct__AStar2++] = ((struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } -static int __pyx_tp_traverse_6CAStar___pyx_scope_struct__AStar2(PyObject *o, visitproc v, void *a) { +static int __pyx_tp_traverse_6CAStar_6CAStar___pyx_scope_struct__AStar2(PyObject *o, visitproc v, void *a) { int e; - struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *p = (struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *)o; + struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *p = (struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *)o; if (p->__pyx_v_f) { e = (*v)(p->__pyx_v_f, a); if (e) return e; } return 0; } -static int __pyx_tp_clear_6CAStar___pyx_scope_struct__AStar2(PyObject *o) { +static int __pyx_tp_clear_6CAStar_6CAStar___pyx_scope_struct__AStar2(PyObject *o) { PyObject* tmp; - struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *p = (struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *)o; + struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *p = (struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *)o; tmp = ((PyObject*)p->__pyx_v_f); p->__pyx_v_f = ((PyObject*)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } -static PyTypeObject __pyx_type_6CAStar___pyx_scope_struct__AStar2 = { +static PyTypeObject __pyx_type_6CAStar_6CAStar___pyx_scope_struct__AStar2 = { PyVarObject_HEAD_INIT(0, 0) - "CAStar.__pyx_scope_struct__AStar2", /*tp_name*/ - sizeof(struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2), /*tp_basicsize*/ + "CAStar.CAStar.__pyx_scope_struct__AStar2", /*tp_name*/ + sizeof(struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2), /*tp_basicsize*/ 0, /*tp_itemsize*/ - __pyx_tp_dealloc_6CAStar___pyx_scope_struct__AStar2, /*tp_dealloc*/ + __pyx_tp_dealloc_6CAStar_6CAStar___pyx_scope_struct__AStar2, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ @@ -4654,8 +4980,8 @@ static PyTypeObject __pyx_type_6CAStar___pyx_scope_struct__AStar2 = { 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_6CAStar___pyx_scope_struct__AStar2, /*tp_traverse*/ - __pyx_tp_clear_6CAStar___pyx_scope_struct__AStar2, /*tp_clear*/ + __pyx_tp_traverse_6CAStar_6CAStar___pyx_scope_struct__AStar2, /*tp_traverse*/ + __pyx_tp_clear_6CAStar_6CAStar___pyx_scope_struct__AStar2, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ @@ -4670,7 +4996,7 @@ static PyTypeObject __pyx_type_6CAStar___pyx_scope_struct__AStar2 = { 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ - __pyx_tp_new_6CAStar___pyx_scope_struct__AStar2, /*tp_new*/ + __pyx_tp_new_6CAStar_6CAStar___pyx_scope_struct__AStar2, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ @@ -4972,7 +5298,6 @@ static struct PyModuleDef __pyx_moduledef = { #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 1}, {&__pyx_n_s_AATC_Coordinate, __pyx_k_AATC_Coordinate, sizeof(__pyx_k_AATC_Coordinate), 0, 0, 1, 1}, {&__pyx_n_s_AStar2, __pyx_k_AStar2, sizeof(__pyx_k_AStar2), 0, 0, 1, 1}, {&__pyx_n_s_AStar2_locals_lambda, __pyx_k_AStar2_locals_lambda, sizeof(__pyx_k_AStar2_locals_lambda), 0, 0, 1, 1}, @@ -4980,16 +5305,17 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_AStarPQ_not_available, __pyx_k_AStarPQ_not_available, sizeof(__pyx_k_AStarPQ_not_available), 0, 0, 1, 0}, {&__pyx_kp_s_A_Search_FAILED_Start, __pyx_k_A_Search_FAILED_Start, sizeof(__pyx_k_A_Search_FAILED_Start), 0, 0, 1, 0}, {&__pyx_kp_s_A_Time, __pyx_k_A_Time, sizeof(__pyx_k_A_Time), 0, 0, 1, 0}, - {&__pyx_n_s_CAStar, __pyx_k_CAStar, sizeof(__pyx_k_CAStar), 0, 0, 1, 1}, + {&__pyx_n_s_CAStar_CAStar, __pyx_k_CAStar_CAStar, sizeof(__pyx_k_CAStar_CAStar), 0, 0, 1, 1}, {&__pyx_kp_s_CAStar_pyx, __pyx_k_CAStar_pyx, sizeof(__pyx_k_CAStar_pyx), 0, 0, 1, 0}, {&__pyx_n_s_ClosedSet, __pyx_k_ClosedSet, sizeof(__pyx_k_ClosedSet), 0, 0, 1, 1}, {&__pyx_n_s_EndTime, __pyx_k_EndTime, sizeof(__pyx_k_EndTime), 0, 0, 1, 1}, {&__pyx_n_s_Found, __pyx_k_Found, sizeof(__pyx_k_Found), 0, 0, 1, 1}, {&__pyx_n_s_FriendList, __pyx_k_FriendList, sizeof(__pyx_k_FriendList), 0, 0, 1, 1}, - {&__pyx_n_s_Friends, __pyx_k_Friends, sizeof(__pyx_k_Friends), 0, 0, 1, 1}, {&__pyx_n_s_GetNode, __pyx_k_GetNode, sizeof(__pyx_k_GetNode), 0, 0, 1, 1}, {&__pyx_n_s_Get_Cost, __pyx_k_Get_Cost, sizeof(__pyx_k_Get_Cost), 0, 0, 1, 1}, + {&__pyx_n_s_Get_Count, __pyx_k_Get_Count, sizeof(__pyx_k_Get_Count), 0, 0, 1, 1}, {&__pyx_n_s_Get_Friends, __pyx_k_Get_Friends, sizeof(__pyx_k_Get_Friends), 0, 0, 1, 1}, + {&__pyx_n_s_Get_Size, __pyx_k_Get_Size, sizeof(__pyx_k_Get_Size), 0, 0, 1, 1}, {&__pyx_kp_s_Milliseconds, __pyx_k_Milliseconds, sizeof(__pyx_k_Milliseconds), 0, 0, 1, 0}, {&__pyx_n_s_Node, __pyx_k_Node, sizeof(__pyx_k_Node), 0, 0, 1, 1}, {&__pyx_n_s_NodeID, __pyx_k_NodeID, sizeof(__pyx_k_NodeID), 0, 0, 1, 1}, @@ -5004,6 +5330,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_Total_Expanded, __pyx_k_Total_Expanded, sizeof(__pyx_k_Total_Expanded), 0, 0, 1, 0}, {&__pyx_kp_s_You_do_not_have_math_inf_object, __pyx_k_You_do_not_have_math_inf_object, sizeof(__pyx_k_You_do_not_have_math_inf_object), 0, 0, 1, 0}, {&__pyx_n_s__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 1, 1}, + {&__pyx_n_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 1}, {&__pyx_n_s_cameFrom, __pyx_k_cameFrom, sizeof(__pyx_k_cameFrom), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_current, __pyx_k_current, sizeof(__pyx_k_current), 0, 0, 1, 1}, @@ -5016,15 +5343,12 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_gNode, __pyx_k_gNode, sizeof(__pyx_k_gNode), 0, 0, 1, 1}, {&__pyx_n_s_graph, __pyx_k_graph, sizeof(__pyx_k_graph), 0, 0, 1, 1}, {&__pyx_n_s_hashlib, __pyx_k_hashlib, sizeof(__pyx_k_hashlib), 0, 0, 1, 1}, - {&__pyx_n_s_heapq, __pyx_k_heapq, sizeof(__pyx_k_heapq), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_inf, __pyx_k_inf, sizeof(__pyx_k_inf), 0, 0, 1, 1}, {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_math, __pyx_k_math, sizeof(__pyx_k_math), 0, 0, 1, 1}, {&__pyx_n_s_min, __pyx_k_min, sizeof(__pyx_k_min), 0, 0, 1, 1}, - {&__pyx_n_s_os, __pyx_k_os, sizeof(__pyx_k_os), 0, 0, 1, 1}, - {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, {&__pyx_n_s_pop, __pyx_k_pop, sizeof(__pyx_k_pop), 0, 0, 1, 1}, {&__pyx_n_s_print, __pyx_k_print, sizeof(__pyx_k_print), 0, 0, 1, 1}, {&__pyx_n_s_put, __pyx_k_put, sizeof(__pyx_k_put), 0, 0, 1, 1}, @@ -5053,29 +5377,40 @@ static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "CAStar.pyx":54 + /* "CAStar/CAStar.pyx":187 + * current = cameFrom[current] + * path.append(current) + * return path[::-1] # <<<<<<<<<<<<<< + * + * + */ + __pyx_slice_ = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + + /* "CAStar/CAStar.pyx":54 * return zCoord * * def AStarPQ(graph, int start, int target): # Set all g to node_count + 1 # <<<<<<<<<<<<<< * StartTime = time.time() * */ - __pyx_tuple__3 = PyTuple_Pack(26, __pyx_n_s_graph, __pyx_n_s_start, __pyx_n_s_target, __pyx_n_s_StartTime, __pyx_n_s_xSize, __pyx_n_s_ySize, __pyx_n_s_zSize, __pyx_n_s_gNode, __pyx_n_s_fTemp, __pyx_n_s_ClosedSet, __pyx_n_s_OpenSet, __pyx_n_s_cameFrom, __pyx_n_s_g, __pyx_n_s_f, __pyx_n_s_NodeID, __pyx_n_s_current, __pyx_n_s_tScore, __pyx_n_s_xCount, __pyx_n_s_yCount, __pyx_n_s_zCount, __pyx_n_s_FriendList, __pyx_n_s_TargetNode, __pyx_n_s_fp, __pyx_n_s_Found, __pyx_n_s_Node, __pyx_n_s_EndTime); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); - __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(3, 0, 26, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_CAStar_pyx, __pyx_n_s_AStarPQ, 54, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 54, __pyx_L1_error) + __pyx_tuple__4 = PyTuple_Pack(26, __pyx_n_s_graph, __pyx_n_s_start, __pyx_n_s_target, __pyx_n_s_StartTime, __pyx_n_s_xSize, __pyx_n_s_ySize, __pyx_n_s_zSize, __pyx_n_s_gNode, __pyx_n_s_fTemp, __pyx_n_s_ClosedSet, __pyx_n_s_OpenSet, __pyx_n_s_cameFrom, __pyx_n_s_g, __pyx_n_s_f, __pyx_n_s_NodeID, __pyx_n_s_current, __pyx_n_s_tScore, __pyx_n_s_xCount, __pyx_n_s_yCount, __pyx_n_s_zCount, __pyx_n_s_FriendList, __pyx_n_s_TargetNode, __pyx_n_s_fp, __pyx_n_s_Found, __pyx_n_s_Node, __pyx_n_s_EndTime); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(3, 0, 26, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_CAStar_pyx, __pyx_n_s_AStarPQ, 54, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 54, __pyx_L1_error) - /* "CAStar.pyx":121 + /* "CAStar/CAStar.pyx":121 * return None * * def AStar2(graph, int start, int target): # Set all g to node_count + 1 # <<<<<<<<<<<<<< * StartTime = time.time() * */ - __pyx_tuple__5 = PyTuple_Pack(24, __pyx_n_s_graph, __pyx_n_s_start, __pyx_n_s_target, __pyx_n_s_StartTime, __pyx_n_s_xSize, __pyx_n_s_ySize, __pyx_n_s_zSize, __pyx_n_s_gNode, __pyx_n_s_ClosedSet, __pyx_n_s_OpenSet, __pyx_n_s_cameFrom, __pyx_n_s_g, __pyx_n_s_f, __pyx_n_s_NodeID, __pyx_n_s_current, __pyx_n_s_tScore, __pyx_n_s_xCount, __pyx_n_s_yCount, __pyx_n_s_zCount, __pyx_n_s_FriendList, __pyx_n_s_TargetNode, __pyx_n_s_Found, __pyx_n_s_Node, __pyx_n_s_EndTime); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 121, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); - __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(3, 0, 24, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_CAStar_pyx, __pyx_n_s_AStar2, 121, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 121, __pyx_L1_error) + __pyx_tuple__6 = PyTuple_Pack(24, __pyx_n_s_graph, __pyx_n_s_start, __pyx_n_s_target, __pyx_n_s_StartTime, __pyx_n_s_xSize, __pyx_n_s_ySize, __pyx_n_s_zSize, __pyx_n_s_gNode, __pyx_n_s_ClosedSet, __pyx_n_s_OpenSet, __pyx_n_s_cameFrom, __pyx_n_s_g, __pyx_n_s_f, __pyx_n_s_NodeID, __pyx_n_s_current, __pyx_n_s_tScore, __pyx_n_s_xCount, __pyx_n_s_yCount, __pyx_n_s_zCount, __pyx_n_s_FriendList, __pyx_n_s_TargetNode, __pyx_n_s_Found, __pyx_n_s_Node, __pyx_n_s_EndTime); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(3, 0, 24, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_CAStar_pyx, __pyx_n_s_AStar2, 121, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -5090,6 +5425,7 @@ static int __Pyx_InitGlobals(void) { __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_1000 = PyInt_FromLong(1000); if (unlikely(!__pyx_int_1000)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_100000000000000000000 = PyInt_FromString((char *)"100000000000000000000", 0, 0); if (unlikely(!__pyx_int_100000000000000000000)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; @@ -5113,6 +5449,7 @@ PyMODINIT_FUNC PyInit_CAStar(void) PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); @@ -5170,14 +5507,14 @@ PyMODINIT_FUNC PyInit_CAStar(void) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif - if (__pyx_module_is_main_CAStar) { + if (__pyx_module_is_main_CAStar__CAStar) { if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "CAStar")) { - if (unlikely(PyDict_SetItemString(modules, "CAStar", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "CAStar.CAStar")) { + if (unlikely(PyDict_SetItemString(modules, "CAStar.CAStar", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif @@ -5189,9 +5526,9 @@ PyMODINIT_FUNC PyInit_CAStar(void) /*--- Variable export code ---*/ /*--- Function export code ---*/ /*--- Type init code ---*/ - if (PyType_Ready(&__pyx_type_6CAStar___pyx_scope_struct__AStar2) < 0) __PYX_ERR(0, 121, __pyx_L1_error) - __pyx_type_6CAStar___pyx_scope_struct__AStar2.tp_print = 0; - __pyx_ptype_6CAStar___pyx_scope_struct__AStar2 = &__pyx_type_6CAStar___pyx_scope_struct__AStar2; + if (PyType_Ready(&__pyx_type_6CAStar_6CAStar___pyx_scope_struct__AStar2) < 0) __PYX_ERR(0, 121, __pyx_L1_error) + __pyx_type_6CAStar_6CAStar___pyx_scope_struct__AStar2.tp_print = 0; + __pyx_ptype_6CAStar_6CAStar___pyx_scope_struct__AStar2 = &__pyx_type_6CAStar_6CAStar___pyx_scope_struct__AStar2; /*--- Type import code ---*/ /*--- Variable import code ---*/ /*--- Function import code ---*/ @@ -5200,25 +5537,13 @@ PyMODINIT_FUNC PyInit_CAStar(void) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif - /* "CAStar.pyx":5 + /* "CAStar/CAStar.pyx":5 * * - * import os,pickle,heapq,time,math,hashlib # <<<<<<<<<<<<<< + * import time,math,hashlib # <<<<<<<<<<<<<< * from AATC_Coordinate import * * try: */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_os, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_Import(__pyx_n_s_pickle, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pickle, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_Import(__pyx_n_s_heapq, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_heapq, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_Import(__pyx_n_s_time, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_time, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) @@ -5232,26 +5557,26 @@ PyMODINIT_FUNC PyInit_CAStar(void) if (PyDict_SetItem(__pyx_d, __pyx_n_s_hashlib, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "CAStar.pyx":6 + /* "CAStar/CAStar.pyx":6 * - * import os,pickle,heapq,time,math,hashlib + * import time,math,hashlib * from AATC_Coordinate import * # <<<<<<<<<<<<<< * try: * try: */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_); - __Pyx_GIVEREF(__pyx_n_s_); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_); + __Pyx_INCREF(__pyx_n_s__2); + __Pyx_GIVEREF(__pyx_n_s__2); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s__2); __pyx_t_2 = __Pyx_Import(__pyx_n_s_AATC_Coordinate, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_import_star(__pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "CAStar.pyx":7 - * import os,pickle,heapq,time,math,hashlib + /* "CAStar/CAStar.pyx":7 + * import time,math,hashlib * from AATC_Coordinate import * * try: # <<<<<<<<<<<<<< * try: @@ -5266,7 +5591,7 @@ PyMODINIT_FUNC PyInit_CAStar(void) __Pyx_XGOTREF(__pyx_t_5); /*try:*/ { - /* "CAStar.pyx":8 + /* "CAStar/CAStar.pyx":8 * from AATC_Coordinate import * * try: * try: # <<<<<<<<<<<<<< @@ -5282,7 +5607,7 @@ PyMODINIT_FUNC PyInit_CAStar(void) __Pyx_XGOTREF(__pyx_t_8); /*try:*/ { - /* "CAStar.pyx":9 + /* "CAStar/CAStar.pyx":9 * try: * try: * import PriorityQueue.PriorityQueueC as PriorityQueue # <<<<<<<<<<<<<< @@ -5291,16 +5616,16 @@ PyMODINIT_FUNC PyInit_CAStar(void) */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_); - __Pyx_GIVEREF(__pyx_n_s_); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_); + __Pyx_INCREF(__pyx_n_s__2); + __Pyx_GIVEREF(__pyx_n_s__2); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s__2); __pyx_t_1 = __Pyx_Import(__pyx_n_s_PriorityQueue_PriorityQueueC, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_PriorityQueue, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L8_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "CAStar.pyx":8 + /* "CAStar/CAStar.pyx":8 * from AATC_Coordinate import * * try: * try: # <<<<<<<<<<<<<< @@ -5317,40 +5642,46 @@ PyMODINIT_FUNC PyInit_CAStar(void) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "CAStar.pyx":10 + /* "CAStar/CAStar.pyx":10 * try: * import PriorityQueue.PriorityQueueC as PriorityQueue * except: # <<<<<<<<<<<<<< * print("PriotityQueueC not available, defaulting to pure python") - * import PriorityQueue.PriorityQueue + * import PriorityQueue.PriorityQueue as PriorityQueue */ /*except:*/ { - __Pyx_AddTraceback("CAStar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("CAStar.CAStar", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_9) < 0) __PYX_ERR(0, 10, __pyx_L10_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_9); - /* "CAStar.pyx":11 + /* "CAStar/CAStar.pyx":11 * import PriorityQueue.PriorityQueueC as PriorityQueue * except: * print("PriotityQueueC not available, defaulting to pure python") # <<<<<<<<<<<<<< - * import PriorityQueue.PriorityQueue + * import PriorityQueue.PriorityQueue as PriorityQueue * except: */ if (__Pyx_PrintOne(0, __pyx_kp_s_PriotityQueueC_not_available_def) < 0) __PYX_ERR(0, 11, __pyx_L10_except_error) - /* "CAStar.pyx":12 + /* "CAStar/CAStar.pyx":12 * except: * print("PriotityQueueC not available, defaulting to pure python") - * import PriorityQueue.PriorityQueue # <<<<<<<<<<<<<< + * import PriorityQueue.PriorityQueue as PriorityQueue # <<<<<<<<<<<<<< * except: * print("AStarPQ not available") */ - __pyx_t_10 = __Pyx_Import(__pyx_n_s_PriorityQueue_PriorityQueue, 0, -1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 12, __pyx_L10_except_error) + __pyx_t_10 = PyList_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 12, __pyx_L10_except_error) __Pyx_GOTREF(__pyx_t_10); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_PriorityQueue, __pyx_t_10) < 0) __PYX_ERR(0, 12, __pyx_L10_except_error) + __Pyx_INCREF(__pyx_n_s__2); + __Pyx_GIVEREF(__pyx_n_s__2); + PyList_SET_ITEM(__pyx_t_10, 0, __pyx_n_s__2); + __pyx_t_11 = __Pyx_Import(__pyx_n_s_PriorityQueue_PriorityQueue, __pyx_t_10, -1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 12, __pyx_L10_except_error) + __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_PriorityQueue, __pyx_t_11) < 0) __PYX_ERR(0, 12, __pyx_L10_except_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; @@ -5358,7 +5689,7 @@ PyMODINIT_FUNC PyInit_CAStar(void) } __pyx_L10_except_error:; - /* "CAStar.pyx":8 + /* "CAStar/CAStar.pyx":8 * from AATC_Coordinate import * * try: * try: # <<<<<<<<<<<<<< @@ -5380,8 +5711,8 @@ PyMODINIT_FUNC PyInit_CAStar(void) __pyx_L13_try_end:; } - /* "CAStar.pyx":7 - * import os,pickle,heapq,time,math,hashlib + /* "CAStar/CAStar.pyx":7 + * import time,math,hashlib * from AATC_Coordinate import * * try: # <<<<<<<<<<<<<< * try: @@ -5395,26 +5726,27 @@ PyMODINIT_FUNC PyInit_CAStar(void) __pyx_L2_error:; __Pyx_PyThreadState_assign __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "CAStar.pyx":13 + /* "CAStar/CAStar.pyx":13 * print("PriotityQueueC not available, defaulting to pure python") - * import PriorityQueue.PriorityQueue + * import PriorityQueue.PriorityQueue as PriorityQueue * except: # <<<<<<<<<<<<<< * print("AStarPQ not available") * */ /*except:*/ { - __Pyx_AddTraceback("CAStar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("CAStar.CAStar", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 13, __pyx_L4_except_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_1); - /* "CAStar.pyx":14 - * import PriorityQueue.PriorityQueue + /* "CAStar/CAStar.pyx":14 + * import PriorityQueue.PriorityQueue as PriorityQueue * except: * print("AStarPQ not available") # <<<<<<<<<<<<<< * @@ -5428,8 +5760,8 @@ PyMODINIT_FUNC PyInit_CAStar(void) } __pyx_L4_except_error:; - /* "CAStar.pyx":7 - * import os,pickle,heapq,time,math,hashlib + /* "CAStar/CAStar.pyx":7 + * import time,math,hashlib * from AATC_Coordinate import * * try: # <<<<<<<<<<<<<< * try: @@ -5450,7 +5782,7 @@ PyMODINIT_FUNC PyInit_CAStar(void) __pyx_L7_try_end:; } - /* "CAStar.pyx":16 + /* "CAStar/CAStar.pyx":16 * print("AStarPQ not available") * * try: # <<<<<<<<<<<<<< @@ -5466,7 +5798,7 @@ PyMODINIT_FUNC PyInit_CAStar(void) __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "CAStar.pyx":17 + /* "CAStar/CAStar.pyx":17 * * try: * _ = math.inf # <<<<<<<<<<<<<< @@ -5478,10 +5810,10 @@ PyMODINIT_FUNC PyInit_CAStar(void) __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inf); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s__2, __pyx_t_2) < 0) __PYX_ERR(0, 17, __pyx_L18_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s__3, __pyx_t_2) < 0) __PYX_ERR(0, 17, __pyx_L18_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "CAStar.pyx":16 + /* "CAStar/CAStar.pyx":16 * print("AStarPQ not available") * * try: # <<<<<<<<<<<<<< @@ -5496,11 +5828,12 @@ PyMODINIT_FUNC PyInit_CAStar(void) __pyx_L18_error:; __Pyx_PyThreadState_assign __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "CAStar.pyx":18 + /* "CAStar/CAStar.pyx":18 * try: * _ = math.inf * except: # <<<<<<<<<<<<<< @@ -5508,13 +5841,13 @@ PyMODINIT_FUNC PyInit_CAStar(void) * math.inf = 10**20 */ /*except:*/ { - __Pyx_AddTraceback("CAStar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("CAStar.CAStar", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(0, 18, __pyx_L20_except_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_9); - /* "CAStar.pyx":19 + /* "CAStar/CAStar.pyx":19 * _ = math.inf * except: * print("You do not have math.inf object, Python 3.5 onwards. Will use replacement.") # <<<<<<<<<<<<<< @@ -5523,17 +5856,17 @@ PyMODINIT_FUNC PyInit_CAStar(void) */ if (__Pyx_PrintOne(0, __pyx_kp_s_You_do_not_have_math_inf_object) < 0) __PYX_ERR(0, 19, __pyx_L20_except_error) - /* "CAStar.pyx":20 + /* "CAStar/CAStar.pyx":20 * except: * print("You do not have math.inf object, Python 3.5 onwards. Will use replacement.") * math.inf = 10**20 # <<<<<<<<<<<<<< * * cdef float EstimateDistance(int NodeID, int TargetID, int xCount,int yCount,int zCount, float xSize, float ySize, float zSize): */ - __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 20, __pyx_L20_except_error) - __Pyx_GOTREF(__pyx_t_10); - if (__Pyx_PyObject_SetAttrStr(__pyx_t_10, __pyx_n_s_inf, __pyx_int_100000000000000000000) < 0) __PYX_ERR(0, 20, __pyx_L20_except_error) - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 20, __pyx_L20_except_error) + __Pyx_GOTREF(__pyx_t_11); + if (__Pyx_PyObject_SetAttrStr(__pyx_t_11, __pyx_n_s_inf, __pyx_int_100000000000000000000) < 0) __PYX_ERR(0, 20, __pyx_L20_except_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; @@ -5541,7 +5874,7 @@ PyMODINIT_FUNC PyInit_CAStar(void) } __pyx_L20_except_error:; - /* "CAStar.pyx":16 + /* "CAStar/CAStar.pyx":16 * print("AStarPQ not available") * * try: # <<<<<<<<<<<<<< @@ -5563,31 +5896,31 @@ PyMODINIT_FUNC PyInit_CAStar(void) __pyx_L23_try_end:; } - /* "CAStar.pyx":54 + /* "CAStar/CAStar.pyx":54 * return zCoord * * def AStarPQ(graph, int start, int target): # Set all g to node_count + 1 # <<<<<<<<<<<<<< * StartTime = time.time() * */ - __pyx_t_9 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_1AStarPQ, NULL, __pyx_n_s_CAStar); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 54, __pyx_L1_error) + __pyx_t_9 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_6CAStar_1AStarPQ, NULL, __pyx_n_s_CAStar_CAStar); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (PyDict_SetItem(__pyx_d, __pyx_n_s_AStarPQ, __pyx_t_9) < 0) __PYX_ERR(0, 54, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "CAStar.pyx":121 + /* "CAStar/CAStar.pyx":121 * return None * * def AStar2(graph, int start, int target): # Set all g to node_count + 1 # <<<<<<<<<<<<<< * StartTime = time.time() * */ - __pyx_t_9 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_3AStar2, NULL, __pyx_n_s_CAStar); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 121, __pyx_L1_error) + __pyx_t_9 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_6CAStar_3AStar2, NULL, __pyx_n_s_CAStar_CAStar); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (PyDict_SetItem(__pyx_d, __pyx_n_s_AStar2, __pyx_t_9) < 0) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "CAStar.pyx":1 + /* "CAStar/CAStar.pyx":1 * #!python # <<<<<<<<<<<<<< * #cython: boundscheck=False, wraparound=False, infer_types=True,cdivision = True * @@ -5605,13 +5938,14 @@ PyMODINIT_FUNC PyInit_CAStar(void) __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); if (__pyx_m) { if (__pyx_d) { - __Pyx_AddTraceback("init CAStar", 0, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("init CAStar.CAStar", 0, __pyx_lineno, __pyx_filename); } Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init CAStar"); + PyErr_SetString(PyExc_ImportError, "init CAStar.CAStar"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); @@ -6058,6 +6392,66 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { } #endif +/* RaiseTooManyValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* 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"); +} + +/* IterFinish */ + static CYTHON_INLINE int __Pyx_IterFinish(void) { +#if CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = PyThreadState_GET(); + PyObject* exc_type = tstate->curexc_type; + if (unlikely(exc_type)) { + if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) { + PyObject *exc_value, *exc_tb; + exc_value = tstate->curexc_value; + exc_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + Py_DECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_tb); + return 0; + } else { + return -1; + } + } + return 0; +#else + if (unlikely(PyErr_Occurred())) { + if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { + PyErr_Clear(); + return 0; + } else { + return -1; + } + } + return 0; +#endif +} + +/* UnpackItemEndCheck */ + static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } else { + return __Pyx_IterFinish(); + } + return 0; +} + /* PyObjectCallMethod0 */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { PyObject *method, *result = NULL; @@ -7014,10 +7408,14 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #ifdef CYTHON_CLINE_IN_TRACEBACK return ((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0; #else - PyObject **cython_runtime_dict; PyObject *use_cline; - cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); - if (unlikely(!cython_runtime_dict)) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + use_cline = PyDict_GetItem(*cython_runtime_dict, __pyx_n_s_cline_in_traceback); + } else +#endif + { PyObject *ptype, *pvalue, *ptraceback; PyObject *use_cline_obj; PyErr_Fetch(&ptype, &pvalue, &ptraceback); @@ -7029,8 +7427,6 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) use_cline = NULL; } PyErr_Restore(ptype, pvalue, ptraceback); - } else { - use_cline = PyDict_GetItem(*_PyObject_GetDictPtr(__pyx_cython_runtime), __pyx_n_s_cline_in_traceback); } if (!use_cline) { c_line = 0; diff --git a/CAStar/CAStar.html b/CAStar/CAStar.html index c543840..d19f83b 100644 --- a/CAStar/CAStar.html +++ b/CAStar/CAStar.html @@ -1,5 +1,5 @@ - + @@ -296,7 +296,7 @@ -

Generated by Cython 0.26

+

Generated by Cython 0.26.1

Yellow lines hint at Python interaction.
Click on a line that starts with a "+" to see the C code that Cython generated for it. @@ -306,44 +306,32 @@ 

 002: #cython: boundscheck=False, wraparound=False, infer_types=True,cdivision = True
 003: 
 004:
-
+005: import os,pickle,heapq,time,math,hashlib
-
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_os, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
+
+005: import time,math,hashlib

+
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_time, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_time, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_Import(__pyx_n_s_pickle, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_math, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pickle, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_math, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_Import(__pyx_n_s_heapq, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_Import(__pyx_n_s_hashlib, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_heapq, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_Import(__pyx_n_s_time, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_time, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_Import(__pyx_n_s_math, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_math, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_Import(__pyx_n_s_hashlib, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_hashlib, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_hashlib, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
+006: from AATC_Coordinate import *

-
  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
+
  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(__pyx_n_s_);
-  __Pyx_GIVEREF(__pyx_n_s_);
-  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_);
-  __pyx_t_2 = __Pyx_Import(__pyx_n_s_AATC_Coordinate, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error)
+  __Pyx_INCREF(__pyx_n_s__2);
+  __Pyx_GIVEREF(__pyx_n_s__2);
+  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s__2);
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_AATC_Coordinate, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (__pyx_import_star(__pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error);
+  if (__pyx_import_star(__pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
+007: try:

-
  {
+
+007: try:

+
  {
     /*try:*/ {
 /* … */
     }
@@ -354,6 +342,7 @@
     __pyx_L2_error:;
     __Pyx_PyThreadState_assign
     __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
     __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
     __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
     __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
@@ -401,30 +390,36 @@
         __pyx_L13_try_end:;
       }
 
+009:         import PriorityQueue.PriorityQueueC as PriorityQueue

-
          __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L8_error)
+
          __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L8_error)
           __Pyx_GOTREF(__pyx_t_2);
-          __Pyx_INCREF(__pyx_n_s_);
-          __Pyx_GIVEREF(__pyx_n_s_);
-          PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_);
-          __pyx_t_1 = __Pyx_Import(__pyx_n_s_PriorityQueue_PriorityQueueC, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L8_error)
+          __Pyx_INCREF(__pyx_n_s__2);
+          __Pyx_GIVEREF(__pyx_n_s__2);
+          PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s__2);
+          __pyx_t_1 = __Pyx_Import(__pyx_n_s_PriorityQueue_PriorityQueueC, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L8_error)
           __Pyx_GOTREF(__pyx_t_1);
           __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-          if (PyDict_SetItem(__pyx_d, __pyx_n_s_PriorityQueue, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L8_error)
+          if (PyDict_SetItem(__pyx_d, __pyx_n_s_PriorityQueue, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L8_error)
           __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
+010:     except:

 
        /*except:*/ {
-          __Pyx_AddTraceback("CAStar", __pyx_clineno, __pyx_lineno, __pyx_filename);
-          if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_9) < 0) __PYX_ERR(0, 10, __pyx_L10_except_error)
+          __Pyx_AddTraceback("CAStar.CAStar", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_9) < 0) __PYX_ERR(0, 10, __pyx_L10_except_error)
           __Pyx_GOTREF(__pyx_t_1);
           __Pyx_GOTREF(__pyx_t_2);
           __Pyx_GOTREF(__pyx_t_9);
 
+011:         print("PriotityQueueC not available, defaulting to pure python")

-
          if (__Pyx_PrintOne(0, __pyx_kp_s_PriotityQueueC_not_available_def) < 0) __PYX_ERR(0, 11, __pyx_L10_except_error)
-
+012:         import PriorityQueue.PriorityQueue

-
          __pyx_t_10 = __Pyx_Import(__pyx_n_s_PriorityQueue_PriorityQueue, 0, -1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 12, __pyx_L10_except_error)
+
          if (__Pyx_PrintOne(0, __pyx_kp_s_PriotityQueueC_not_available_def) < 0) __PYX_ERR(0, 11, __pyx_L10_except_error)
+
+012:         import PriorityQueue.PriorityQueue as PriorityQueue

+
          __pyx_t_10 = PyList_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 12, __pyx_L10_except_error)
           __Pyx_GOTREF(__pyx_t_10);
-          if (PyDict_SetItem(__pyx_d, __pyx_n_s_PriorityQueue, __pyx_t_10) < 0) __PYX_ERR(0, 12, __pyx_L10_except_error)
+          __Pyx_INCREF(__pyx_n_s__2);
+          __Pyx_GIVEREF(__pyx_n_s__2);
+          PyList_SET_ITEM(__pyx_t_10, 0, __pyx_n_s__2);
+          __pyx_t_11 = __Pyx_Import(__pyx_n_s_PriorityQueue_PriorityQueue, __pyx_t_10, -1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 12, __pyx_L10_except_error)
+          __Pyx_GOTREF(__pyx_t_11);
           __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+          if (PyDict_SetItem(__pyx_d, __pyx_n_s_PriorityQueue, __pyx_t_11) < 0) __PYX_ERR(0, 12, __pyx_L10_except_error)
+          __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
           __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
           __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
           __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
@@ -433,13 +428,13 @@
         __pyx_L10_except_error:;
 
+013: except:

 
    /*except:*/ {
-      __Pyx_AddTraceback("CAStar", __pyx_clineno, __pyx_lineno, __pyx_filename);
-      if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 13, __pyx_L4_except_error)
+      __Pyx_AddTraceback("CAStar.CAStar", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 13, __pyx_L4_except_error)
       __Pyx_GOTREF(__pyx_t_9);
       __Pyx_GOTREF(__pyx_t_2);
       __Pyx_GOTREF(__pyx_t_1);
 
+014:     print("AStarPQ not available")

-
      if (__Pyx_PrintOne(0, __pyx_kp_s_AStarPQ_not_available) < 0) __PYX_ERR(0, 14, __pyx_L4_except_error)
+
      if (__Pyx_PrintOne(0, __pyx_kp_s_AStarPQ_not_available) < 0) __PYX_ERR(0, 14, __pyx_L4_except_error)
       __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -447,8 +442,8 @@
     }
     __pyx_L4_except_error:;
 
 015: 

-
+016: try:

-
  {
+
+016: try:

+
  {
     /*try:*/ {
 /* … */
     }
@@ -459,6 +454,7 @@
     __pyx_L18_error:;
     __Pyx_PyThreadState_assign
     __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
     __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
     __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
     __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -478,27 +474,27 @@
     __pyx_L23_try_end:;
   }
 
+017:     _ = math.inf

-
      __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L18_error)
+
      __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L18_error)
       __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inf); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L18_error)
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inf); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L18_error)
       __Pyx_GOTREF(__pyx_t_2);
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      if (PyDict_SetItem(__pyx_d, __pyx_n_s__2, __pyx_t_2) < 0) __PYX_ERR(0, 17, __pyx_L18_error)
+      if (PyDict_SetItem(__pyx_d, __pyx_n_s__3, __pyx_t_2) < 0) __PYX_ERR(0, 17, __pyx_L18_error)
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
+018: except:

 
    /*except:*/ {
-      __Pyx_AddTraceback("CAStar", __pyx_clineno, __pyx_lineno, __pyx_filename);
-      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(0, 18, __pyx_L20_except_error)
+      __Pyx_AddTraceback("CAStar.CAStar", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(0, 18, __pyx_L20_except_error)
       __Pyx_GOTREF(__pyx_t_2);
       __Pyx_GOTREF(__pyx_t_1);
       __Pyx_GOTREF(__pyx_t_9);
 
+019:     print("You do not have math.inf object, Python 3.5 onwards. Will use replacement.")

-
      if (__Pyx_PrintOne(0, __pyx_kp_s_You_do_not_have_math_inf_object) < 0) __PYX_ERR(0, 19, __pyx_L20_except_error)
+
      if (__Pyx_PrintOne(0, __pyx_kp_s_You_do_not_have_math_inf_object) < 0) __PYX_ERR(0, 19, __pyx_L20_except_error)
 
+020:     math.inf = 10**20

-
      __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 20, __pyx_L20_except_error)
-      __Pyx_GOTREF(__pyx_t_10);
-      if (__Pyx_PyObject_SetAttrStr(__pyx_t_10, __pyx_n_s_inf, __pyx_int_100000000000000000000) < 0) __PYX_ERR(0, 20, __pyx_L20_except_error)
-      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
      __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 20, __pyx_L20_except_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      if (__Pyx_PyObject_SetAttrStr(__pyx_t_11, __pyx_n_s_inf, __pyx_int_100000000000000000000) < 0) __PYX_ERR(0, 20, __pyx_L20_except_error)
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
       __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
@@ -507,7 +503,7 @@
     __pyx_L20_except_error:;
 
 021: 

 
+022: cdef float EstimateDistance(int NodeID, int TargetID, int xCount,int yCount,int zCount, float xSize, float ySize, float zSize):

-
static float __pyx_f_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_TargetID, int __pyx_v_xCount, int __pyx_v_yCount, int __pyx_v_zCount, float __pyx_v_xSize, float __pyx_v_ySize, float __pyx_v_zSize) {
+
static float __pyx_f_6CAStar_6CAStar_EstimateDistance(int __pyx_v_NodeID, int __pyx_v_TargetID, int __pyx_v_xCount, int __pyx_v_yCount, int __pyx_v_zCount, float __pyx_v_xSize, float __pyx_v_ySize, float __pyx_v_zSize) {
   float __pyx_v_x;
   float __pyx_v_y;
   float __pyx_v_z;
@@ -530,16 +526,16 @@
 
 023:     cdef float x,y,z,Nx,Ny,Nz,Tx,Ty,Tz

 
 024:     cdef float Distance

 
+025:     Nx,Ny,Nz = GetxCoord(NodeID,xCount,yCount,zCount,xSize,ySize,zSize),GetyCoord(NodeID,xCount,yCount,zCount,xSize,ySize,zSize),GetzCoord(NodeID,xCount,yCount,zCount,xSize,ySize,zSize)

-
  __pyx_t_1 = __pyx_f_6CAStar_GetxCoord(__pyx_v_NodeID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize);
-  __pyx_t_2 = __pyx_f_6CAStar_GetyCoord(__pyx_v_NodeID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize);
-  __pyx_t_3 = __pyx_f_6CAStar_GetzCoord(__pyx_v_NodeID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize);
+
  __pyx_t_1 = __pyx_f_6CAStar_6CAStar_GetxCoord(__pyx_v_NodeID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize);
+  __pyx_t_2 = __pyx_f_6CAStar_6CAStar_GetyCoord(__pyx_v_NodeID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize);
+  __pyx_t_3 = __pyx_f_6CAStar_6CAStar_GetzCoord(__pyx_v_NodeID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize);
   __pyx_v_Nx = __pyx_t_1;
   __pyx_v_Ny = __pyx_t_2;
   __pyx_v_Nz = __pyx_t_3;
 
+026:     Tx,Ty,Tz = GetxCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize),GetyCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize),GetzCoord(TargetID,xCount,yCount,zCount,xSize,ySize,zSize)

-
  __pyx_t_3 = __pyx_f_6CAStar_GetxCoord(__pyx_v_TargetID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize);
-  __pyx_t_2 = __pyx_f_6CAStar_GetyCoord(__pyx_v_TargetID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize);
-  __pyx_t_1 = __pyx_f_6CAStar_GetzCoord(__pyx_v_TargetID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize);
+
  __pyx_t_3 = __pyx_f_6CAStar_6CAStar_GetxCoord(__pyx_v_TargetID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize);
+  __pyx_t_2 = __pyx_f_6CAStar_6CAStar_GetyCoord(__pyx_v_TargetID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize);
+  __pyx_t_1 = __pyx_f_6CAStar_6CAStar_GetzCoord(__pyx_v_TargetID, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize);
   __pyx_v_Tx = __pyx_t_3;
   __pyx_v_Ty = __pyx_t_2;
   __pyx_v_Tz = __pyx_t_1;
@@ -577,7 +573,7 @@
   goto __pyx_L0;
 
 038: 

 
+039: cdef float GetxCoord(int ID, int xCount, int yCount, int zCount, float xSize, float ySize,float zSize):

-
static float __pyx_f_6CAStar_GetxCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v_xCount, int __pyx_v_yCount, int __pyx_v_zCount, float __pyx_v_xSize, CYTHON_UNUSED float __pyx_v_ySize, CYTHON_UNUSED float __pyx_v_zSize) {
+
static float __pyx_f_6CAStar_6CAStar_GetxCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v_xCount, int __pyx_v_yCount, int __pyx_v_zCount, float __pyx_v_xSize, CYTHON_UNUSED float __pyx_v_ySize, CYTHON_UNUSED float __pyx_v_zSize) {
   float __pyx_v_xCoord;
   float __pyx_r;
   __Pyx_RefNannyDeclarations
@@ -596,7 +592,7 @@
   goto __pyx_L0;
 
 043: 

 
+044: cdef float GetyCoord(int ID, int xCount, int yCount, int zCount, float xSize, float ySize,float zSize):

-
static float __pyx_f_6CAStar_GetyCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v_xCount, int __pyx_v_yCount, int __pyx_v_zCount, CYTHON_UNUSED float __pyx_v_xSize, float __pyx_v_ySize, CYTHON_UNUSED float __pyx_v_zSize) {
+
static float __pyx_f_6CAStar_6CAStar_GetyCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v_xCount, int __pyx_v_yCount, int __pyx_v_zCount, CYTHON_UNUSED float __pyx_v_xSize, float __pyx_v_ySize, CYTHON_UNUSED float __pyx_v_zSize) {
   float __pyx_v_yCoord;
   float __pyx_r;
   __Pyx_RefNannyDeclarations
@@ -615,7 +611,7 @@
   goto __pyx_L0;
 
 048: 

 
+049: cdef float GetzCoord(int ID, int xCount, int yCount, int zCount, float xSize, float ySize,float zSize):

-
static float __pyx_f_6CAStar_GetzCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v_xCount, CYTHON_UNUSED int __pyx_v_yCount, int __pyx_v_zCount, CYTHON_UNUSED float __pyx_v_xSize, CYTHON_UNUSED float __pyx_v_ySize, float __pyx_v_zSize) {
+
static float __pyx_f_6CAStar_6CAStar_GetzCoord(int __pyx_v_ID, CYTHON_UNUSED int __pyx_v_xCount, CYTHON_UNUSED int __pyx_v_yCount, int __pyx_v_zCount, CYTHON_UNUSED float __pyx_v_xSize, CYTHON_UNUSED float __pyx_v_ySize, float __pyx_v_zSize) {
   float __pyx_v_zCoord;
   float __pyx_r;
   __Pyx_RefNannyDeclarations
@@ -635,9 +631,9 @@
 
 053: 

 
+054: def AStarPQ(graph, int start, int target):   # Set all g to node_count + 1

 
/* Python wrapper */
-static PyObject *__pyx_pw_6CAStar_1AStarPQ(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyMethodDef __pyx_mdef_6CAStar_1AStarPQ = {"AStarPQ", (PyCFunction)__pyx_pw_6CAStar_1AStarPQ, METH_VARARGS|METH_KEYWORDS, 0};
-static PyObject *__pyx_pw_6CAStar_1AStarPQ(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_6CAStar_6CAStar_1AStarPQ(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_6CAStar_1AStarPQ = {"AStarPQ", (PyCFunction)__pyx_pw_6CAStar_6CAStar_1AStarPQ, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_6CAStar_1AStarPQ(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   PyObject *__pyx_v_graph = 0;
   int __pyx_v_start;
   int __pyx_v_target;
@@ -669,17 +665,17 @@
         case  1:
         if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("AStarPQ", 1, 3, 3, 1); __PYX_ERR(0, 54, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("AStarPQ", 1, 3, 3, 1); __PYX_ERR(0, 54, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
         if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_target)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("AStarPQ", 1, 3, 3, 2); __PYX_ERR(0, 54, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("AStarPQ", 1, 3, 3, 2); __PYX_ERR(0, 54, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "AStarPQ") < 0)) __PYX_ERR(0, 54, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "AStarPQ") < 0)) __PYX_ERR(0, 54, __pyx_L3_error)
       }
     } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
       goto __pyx_L5_argtuple_error;
@@ -689,25 +685,25 @@
       values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
     }
     __pyx_v_graph = values[0];
-    __pyx_v_start = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_start == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 54, __pyx_L3_error)
-    __pyx_v_target = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_target == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 54, __pyx_L3_error)
+    __pyx_v_start = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_start == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 54, __pyx_L3_error)
+    __pyx_v_target = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_target == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 54, __pyx_L3_error)
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("AStarPQ", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 54, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("AStarPQ", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 54, __pyx_L3_error)
   __pyx_L3_error:;
-  __Pyx_AddTraceback("CAStar.AStarPQ", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("CAStar.CAStar.AStarPQ", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_6CAStar_AStarPQ(__pyx_self, __pyx_v_graph, __pyx_v_start, __pyx_v_target);
+  __pyx_r = __pyx_pf_6CAStar_6CAStar_AStarPQ(__pyx_self, __pyx_v_graph, __pyx_v_start, __pyx_v_target);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_graph, int __pyx_v_start, int __pyx_v_target) {
+static PyObject *__pyx_pf_6CAStar_6CAStar_AStarPQ(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_graph, int __pyx_v_start, int __pyx_v_target) {
   PyObject *__pyx_v_StartTime = NULL;
   float __pyx_v_xSize;
   float __pyx_v_ySize;
@@ -742,7 +738,7 @@
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
   __Pyx_XDECREF(__pyx_t_15);
-  __Pyx_AddTraceback("CAStar.AStarPQ", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("CAStar.CAStar.AStarPQ", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF(__pyx_v_StartTime);
@@ -761,19 +757,19 @@
   return __pyx_r;
 }
 /* … */
-  __pyx_tuple__3 = PyTuple_Pack(26, __pyx_n_s_graph, __pyx_n_s_start, __pyx_n_s_target, __pyx_n_s_StartTime, __pyx_n_s_xSize, __pyx_n_s_ySize, __pyx_n_s_zSize, __pyx_n_s_gNode, __pyx_n_s_fTemp, __pyx_n_s_ClosedSet, __pyx_n_s_OpenSet, __pyx_n_s_cameFrom, __pyx_n_s_g, __pyx_n_s_f, __pyx_n_s_NodeID, __pyx_n_s_current, __pyx_n_s_tScore, __pyx_n_s_xCount, __pyx_n_s_yCount, __pyx_n_s_zCount, __pyx_n_s_FriendList, __pyx_n_s_TargetNode, __pyx_n_s_fp, __pyx_n_s_Found, __pyx_n_s_Node, __pyx_n_s_EndTime); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 54, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__3);
-  __Pyx_GIVEREF(__pyx_tuple__3);
+  __pyx_tuple__4 = PyTuple_Pack(26, __pyx_n_s_graph, __pyx_n_s_start, __pyx_n_s_target, __pyx_n_s_StartTime, __pyx_n_s_xSize, __pyx_n_s_ySize, __pyx_n_s_zSize, __pyx_n_s_gNode, __pyx_n_s_fTemp, __pyx_n_s_ClosedSet, __pyx_n_s_OpenSet, __pyx_n_s_cameFrom, __pyx_n_s_g, __pyx_n_s_f, __pyx_n_s_NodeID, __pyx_n_s_current, __pyx_n_s_tScore, __pyx_n_s_xCount, __pyx_n_s_yCount, __pyx_n_s_zCount, __pyx_n_s_FriendList, __pyx_n_s_TargetNode, __pyx_n_s_fp, __pyx_n_s_Found, __pyx_n_s_Node, __pyx_n_s_EndTime); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
 /* … */
-  __pyx_t_9 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_1AStarPQ, NULL, __pyx_n_s_CAStar); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 54, __pyx_L1_error)
+  __pyx_t_9 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_6CAStar_1AStarPQ, NULL, __pyx_n_s_CAStar_CAStar); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 54, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_9);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AStarPQ, __pyx_t_9) < 0) __PYX_ERR(0, 54, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AStarPQ, __pyx_t_9) < 0) __PYX_ERR(0, 54, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-  __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(3, 0, 26, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_CAStar_pyx, __pyx_n_s_AStarPQ, 54, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 54, __pyx_L1_error)
+  __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(3, 0, 26, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_CAStar_pyx, __pyx_n_s_AStarPQ, 54, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 54, __pyx_L1_error)
 
+055:     StartTime = time.time()

-
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error)
+
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __pyx_t_2 = NULL;
@@ -787,10 +783,10 @@
     }
   }
   if (__pyx_t_2) {
-    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   } else {
-    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
   }
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -804,9 +800,9 @@
 
 061: 

 
 062: 

 
+063:     TargetNode = graph.GetNode(target)

-
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 63, __pyx_L1_error)
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 63, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_target); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_target); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_t_4 = NULL;
   if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
@@ -819,14 +815,14 @@
     }
   }
   if (!__pyx_t_4) {
-    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     __Pyx_GOTREF(__pyx_t_1);
   } else {
     #if CYTHON_FAST_PYCALL
     if (PyFunction_Check(__pyx_t_3)) {
       PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
-      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error)
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error)
       __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
       __Pyx_GOTREF(__pyx_t_1);
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -835,20 +831,20 @@
     #if CYTHON_FAST_PYCCALL
     if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
       PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
-      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error)
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error)
       __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
       __Pyx_GOTREF(__pyx_t_1);
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     } else
     #endif
     {
-      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 63, __pyx_L1_error)
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 63, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_5);
       __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
       __Pyx_GIVEREF(__pyx_t_2);
       PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2);
       __pyx_t_2 = 0;
-      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error)
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
       __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     }
@@ -856,62 +852,204 @@
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_TargetNode = __pyx_t_1;
   __pyx_t_1 = 0;
-
+064:     xSize,ySize,zSize = graph.xSize,graph.ySize,graph.zSize

-
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_xSize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_ySize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_7 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_7 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_zSize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v_xSize = __pyx_t_6;
-  __pyx_v_ySize = __pyx_t_7;
-  __pyx_v_zSize = __pyx_t_8;
-
+065:     xCount,yCount,zCount = graph.xCount,graph.yCount,graph.zCount

-
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_xCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_yCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error)
+
+064:     xSize,ySize,zSize = graph.Get_Size()

+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_Get_Size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_5) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 64, __pyx_L1_error)
+  }
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_zCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
+    PyObject* sequence = __pyx_t_1;
+    #if !CYTHON_COMPILING_IN_PYPY
+    Py_ssize_t size = Py_SIZE(sequence);
+    #else
+    Py_ssize_t size = PySequence_Size(sequence);
+    #endif
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 64, __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_t_5 = PyTuple_GET_ITEM(sequence, 1); 
+      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 2); 
+    } else {
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_5 = PyList_GET_ITEM(sequence, 1); 
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 2); 
+    }
+    __Pyx_INCREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_t_2);
+    #else
+    __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 64, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 64, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_2 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    #endif
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 64, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext;
+    index = 0; __pyx_t_3 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_3);
+    index = 1; __pyx_t_5 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_5)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_5);
+    index = 2; __pyx_t_2 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_2);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_4), 3) < 0) __PYX_ERR(0, 64, __pyx_L1_error)
+    __pyx_t_6 = NULL;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L4_unpacking_done;
+    __pyx_L3_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_6 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 64, __pyx_L1_error)
+    __pyx_L4_unpacking_done:;
+  }
+  __pyx_t_7 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_7 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_xSize = __pyx_t_7;
+  __pyx_v_ySize = __pyx_t_8;
+  __pyx_v_zSize = __pyx_t_9;
+
+065:     xCount,yCount,zCount = graph.Get_Count()

+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_Get_Count); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_5) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error)
+  }
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v_xCount = __pyx_t_9;
-  __pyx_v_yCount = __pyx_t_10;
-  __pyx_v_zCount = __pyx_t_11;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
+    PyObject* sequence = __pyx_t_1;
+    #if !CYTHON_COMPILING_IN_PYPY
+    Py_ssize_t size = Py_SIZE(sequence);
+    #else
+    Py_ssize_t size = PySequence_Size(sequence);
+    #endif
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 65, __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_t_5 = PyTuple_GET_ITEM(sequence, 1); 
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 2); 
+    } else {
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_5 = PyList_GET_ITEM(sequence, 1); 
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 2); 
+    }
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_t_3);
+    #else
+    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 65, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 65, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext;
+    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L5_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_2);
+    index = 1; __pyx_t_5 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_5);
+    index = 2; __pyx_t_3 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L5_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_4), 3) < 0) __PYX_ERR(0, 65, __pyx_L1_error)
+    __pyx_t_6 = NULL;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L6_unpacking_done;
+    __pyx_L5_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_6 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 65, __pyx_L1_error)
+    __pyx_L6_unpacking_done:;
+  }
+  __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_xCount = __pyx_t_10;
+  __pyx_v_yCount = __pyx_t_11;
+  __pyx_v_zCount = __pyx_t_12;
 
 066: 

 
+067:     ClosedSet = {}  #Dict to hash find closed nodes

-
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error)
+
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_ClosedSet = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
+068:     OpenSet = {start:1}

-
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error)
+
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 68, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 68, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_int_1) < 0) __PYX_ERR(0, 68, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_int_1) < 0) __PYX_ERR(0, 68, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_OpenSet = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
+069:     cameFrom = {}

-
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error)
+
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_cameFrom = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
+070:     g,f = {},{}

-
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 70, __pyx_L1_error)
+
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 70, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 70, __pyx_L1_error)
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 70, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_v_g = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
@@ -920,9 +1058,9 @@
 
+071:     current = -1

 
  __pyx_v_current = -1;
 
+072:     fp = PriorityQueue.PriorityQueue()

-
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_PriorityQueue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error)
+
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_PriorityQueue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_PriorityQueue); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 72, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_PriorityQueue); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 72, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
@@ -936,10 +1074,10 @@
     }
   }
   if (__pyx_t_1) {
-    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 72, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 72, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   } else {
-    __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 72, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 72, __pyx_L1_error)
   }
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
@@ -948,26 +1086,26 @@
 
 073: 

 
 074: 

 
+075:     g[start] = 0

-
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 75, __pyx_L1_error)
+
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 75, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_3, __pyx_int_0) < 0)) __PYX_ERR(0, 75, __pyx_L1_error)
+  if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_3, __pyx_int_0) < 0)) __PYX_ERR(0, 75, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
+076:     f[start] = EstimateDistance(start,target,xCount,yCount,zCount,xSize,ySize,zSize)

-
  __pyx_t_3 = PyFloat_FromDouble(__pyx_f_6CAStar_EstimateDistance(__pyx_v_start, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error)
+
  __pyx_t_3 = PyFloat_FromDouble(__pyx_f_6CAStar_6CAStar_EstimateDistance(__pyx_v_start, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  if (unlikely(PyDict_SetItem(__pyx_v_f, __pyx_t_5, __pyx_t_3) < 0)) __PYX_ERR(0, 76, __pyx_L1_error)
+  if (unlikely(PyDict_SetItem(__pyx_v_f, __pyx_t_5, __pyx_t_3) < 0)) __PYX_ERR(0, 76, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
+077:     fp.put((EstimateDistance(start,target,xCount,yCount,zCount,xSize,ySize,zSize),start))

-
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_put); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 77, __pyx_L1_error)
+
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_put); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 77, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_f_6CAStar_EstimateDistance(__pyx_v_start, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_f_6CAStar_6CAStar_EstimateDistance(__pyx_v_start, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 77, __pyx_L1_error)
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 77, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_GIVEREF(__pyx_t_1);
   PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
@@ -986,14 +1124,14 @@
     }
   }
   if (!__pyx_t_2) {
-    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     __Pyx_GOTREF(__pyx_t_3);
   } else {
     #if CYTHON_FAST_PYCALL
     if (PyFunction_Check(__pyx_t_5)) {
       PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_4};
-      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error)
       __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
       __Pyx_GOTREF(__pyx_t_3);
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -1002,20 +1140,20 @@
     #if CYTHON_FAST_PYCCALL
     if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
       PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_4};
-      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error)
       __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
       __Pyx_GOTREF(__pyx_t_3);
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     } else
     #endif
     {
-      __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error)
+      __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
       __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __pyx_t_2 = NULL;
       __Pyx_GIVEREF(__pyx_t_4);
       PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_4);
       __pyx_t_4 = 0;
-      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     }
@@ -1026,33 +1164,33 @@
 
  __pyx_v_Found = 0;
 
+079:     while len(OpenSet) != 0:

 
  while (1) {
-    __pyx_t_12 = PyDict_Size(__pyx_v_OpenSet); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 79, __pyx_L1_error)
-    __pyx_t_13 = ((__pyx_t_12 != 0) != 0);
-    if (!__pyx_t_13) break;
+    __pyx_t_13 = PyDict_Size(__pyx_v_OpenSet); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 79, __pyx_L1_error)
+    __pyx_t_14 = ((__pyx_t_13 != 0) != 0);
+    if (!__pyx_t_14) break;
 
+080:         current = fp.pop()[1]

-
    __pyx_t_3 = __Pyx_PyObject_Pop(__pyx_v_fp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error)
+
    __pyx_t_3 = __Pyx_PyObject_Pop(__pyx_v_fp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 80, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 80, __pyx_L1_error)
+    __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 80, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __pyx_v_current = __pyx_t_11;
+    __pyx_v_current = __pyx_t_12;
 
+081:         if current == target:

-
    __pyx_t_13 = ((__pyx_v_current == __pyx_v_target) != 0);
-    if (__pyx_t_13) {
+
    __pyx_t_14 = ((__pyx_v_current == __pyx_v_target) != 0);
+    if (__pyx_t_14) {
 /* … */
     }
 
+082:             Found = True

 
      __pyx_v_Found = 1;
 
+083:             break

-
      goto __pyx_L4_break;
+
      goto __pyx_L8_break;
 
 084: 

 
 085: 

 
+086:         OpenSet.pop(current)

-
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_OpenSet, __pyx_n_s_pop); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
+
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_OpenSet, __pyx_n_s_pop); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __pyx_t_4 = NULL;
     if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
@@ -1065,14 +1203,14 @@
       }
     }
     if (!__pyx_t_4) {
-      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
       __Pyx_GOTREF(__pyx_t_5);
     } else {
       #if CYTHON_FAST_PYCALL
       if (PyFunction_Check(__pyx_t_3)) {
         PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1};
-        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
         __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
         __Pyx_GOTREF(__pyx_t_5);
         __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -1081,20 +1219,20 @@
       #if CYTHON_FAST_PYCCALL
       if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
         PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1};
-        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
         __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
         __Pyx_GOTREF(__pyx_t_5);
         __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
       } else
       #endif
       {
-        __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)
+        __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_2);
         __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL;
         __Pyx_GIVEREF(__pyx_t_1);
         PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_1);
         __pyx_t_1 = 0;
-        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_5);
         __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
       }
@@ -1102,653 +1240,671 @@
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
+087:         ClosedSet[current] = 1

-
    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error)
+
    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
-    if (unlikely(PyDict_SetItem(__pyx_v_ClosedSet, __pyx_t_5, __pyx_int_1) < 0)) __PYX_ERR(0, 87, __pyx_L1_error)
+    if (unlikely(PyDict_SetItem(__pyx_v_ClosedSet, __pyx_t_5, __pyx_int_1) < 0)) __PYX_ERR(0, 87, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
 088: 

-
+089:         FriendList = graph.GetNode(current).Friends

-
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error)
+
+089:         FriendList = graph.GetNode(current).Get_Friends()

+
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_1 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
-      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
-      if (likely(__pyx_t_1)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-        __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 89, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_4);
         __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_3, function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
       }
     }
-    if (!__pyx_t_1) {
-      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __Pyx_GOTREF(__pyx_t_5);
+    if (!__pyx_t_4) {
+      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
     } else {
       #if CYTHON_FAST_PYCALL
-      if (PyFunction_Check(__pyx_t_3)) {
-        PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_2};
-        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-        __Pyx_GOTREF(__pyx_t_5);
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      if (PyFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1};
+        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
       } else
       #endif
       #if CYTHON_FAST_PYCCALL
-      if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
-        PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_2};
-        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-        __Pyx_GOTREF(__pyx_t_5);
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1};
+        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
       } else
       #endif
       {
-        __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_4);
-        __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = NULL;
-        __Pyx_GIVEREF(__pyx_t_2);
-        PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_2);
-        __pyx_t_2 = 0;
-        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 89, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_15);
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_4); __pyx_t_4 = NULL;
+        __Pyx_GIVEREF(__pyx_t_1);
+        PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_1);
+        __pyx_t_1 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
       }
     }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Get_Friends); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Friends); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    if (!(likely(PyList_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 89, __pyx_L1_error)
-    __Pyx_XDECREF_SET(__pyx_v_FriendList, ((PyObject*)__pyx_t_3));
-    __pyx_t_3 = 0;
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    if (__pyx_t_3) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else {
+      __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error)
+    }
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (!(likely(PyList_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_5)->tp_name), 0))) __PYX_ERR(0, 89, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_FriendList, ((PyObject*)__pyx_t_5));
+    __pyx_t_5 = 0;
 
+090:         for NodeID in FriendList:

 
    if (unlikely(__pyx_v_FriendList == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
-      __PYX_ERR(0, 90, __pyx_L1_error)
+      __PYX_ERR(0, 90, __pyx_L1_error)
     }
-    __pyx_t_3 = __pyx_v_FriendList; __Pyx_INCREF(__pyx_t_3); __pyx_t_12 = 0;
+    __pyx_t_5 = __pyx_v_FriendList; __Pyx_INCREF(__pyx_t_5); __pyx_t_13 = 0;
     for (;;) {
-      if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_3)) break;
+      if (__pyx_t_13 >= PyList_GET_SIZE(__pyx_t_5)) break;
       #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-      __pyx_t_5 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_12); __Pyx_INCREF(__pyx_t_5); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(0, 90, __pyx_L1_error)
+      __pyx_t_2 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_13); __Pyx_INCREF(__pyx_t_2); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 90, __pyx_L1_error)
       #else
-      __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 90, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_2 = PySequence_ITEM(__pyx_t_5, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
       #endif
-      __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 90, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_v_NodeID = __pyx_t_11;
+      __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 90, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_v_NodeID = __pyx_t_12;
 /* … */
-      __pyx_L6_continue:;
+      __pyx_L10_continue:;
     }
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
+091:             if NodeID in ClosedSet:

-
      __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 91, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_13 = (__Pyx_PyDict_ContainsTF(__pyx_t_5, __pyx_v_ClosedSet, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 91, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_t_14 = (__pyx_t_13 != 0);
-      if (__pyx_t_14) {
+
      __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 91, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_14 = (__Pyx_PyDict_ContainsTF(__pyx_t_2, __pyx_v_ClosedSet, Py_EQ)); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 91, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_16 = (__pyx_t_14 != 0);
+      if (__pyx_t_16) {
 /* … */
       }
 
+092:                 continue

-
        goto __pyx_L6_continue;
+
        goto __pyx_L10_continue;
 
+093:             if NodeID not in OpenSet:

-
      __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 93, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_14 = (__Pyx_PyDict_ContainsTF(__pyx_t_5, __pyx_v_OpenSet, Py_NE)); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 93, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_t_13 = (__pyx_t_14 != 0);
-      if (__pyx_t_13) {
+
      __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_16 = (__Pyx_PyDict_ContainsTF(__pyx_t_2, __pyx_v_OpenSet, Py_NE)); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 93, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_14 = (__pyx_t_16 != 0);
+      if (__pyx_t_14) {
 /* … */
       }
 
+094:                 OpenSet[NodeID] = 1

-
        __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 94, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        if (unlikely(PyDict_SetItem(__pyx_v_OpenSet, __pyx_t_5, __pyx_int_1) < 0)) __PYX_ERR(0, 94, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
        __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        if (unlikely(PyDict_SetItem(__pyx_v_OpenSet, __pyx_t_2, __pyx_int_1) < 0)) __PYX_ERR(0, 94, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
+095:                 g[NodeID] = math.inf

-
        __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 95, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_inf); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 95, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_4);
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 95, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_5, __pyx_t_4) < 0)) __PYX_ERR(0, 95, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-
+096:                 f[NodeID] = math.inf

-
        __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_4);
-        __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_inf); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 96, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-        __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_4);
-        if (unlikely(PyDict_SetItem(__pyx_v_f, __pyx_t_4, __pyx_t_5) < 0)) __PYX_ERR(0, 96, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-
+097:                 fp.put((math.inf,NodeID))

-
        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_put); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_4);
-        __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error)
+
        __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_inf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_inf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 95, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
         __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-        __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error)
+        __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_15 = PyTuple_New(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 97, __pyx_L1_error)
+        if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_2, __pyx_t_3) < 0)) __PYX_ERR(0, 95, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+096:                 f[NodeID] = math.inf

+
        __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_inf); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 96, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        if (unlikely(PyDict_SetItem(__pyx_v_f, __pyx_t_3, __pyx_t_2) < 0)) __PYX_ERR(0, 96, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+097:                 fp.put((math.inf,NodeID))

+
        __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_put); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 97, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_15);
+        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_inf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+        __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 97, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_15);
+        __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
         __Pyx_GIVEREF(__pyx_t_1);
-        PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_1);
-        __Pyx_GIVEREF(__pyx_t_2);
-        PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_2);
+        PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+        __Pyx_GIVEREF(__pyx_t_15);
+        PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_15);
         __pyx_t_1 = 0;
-        __pyx_t_2 = 0;
-        __pyx_t_2 = NULL;
-        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
-          __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
-          if (likely(__pyx_t_2)) {
-            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
-            __Pyx_INCREF(__pyx_t_2);
+        __pyx_t_15 = 0;
+        __pyx_t_15 = NULL;
+        if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+          __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_3);
+          if (likely(__pyx_t_15)) {
+            PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+            __Pyx_INCREF(__pyx_t_15);
             __Pyx_INCREF(function);
-            __Pyx_DECREF_SET(__pyx_t_4, function);
+            __Pyx_DECREF_SET(__pyx_t_3, function);
           }
         }
-        if (!__pyx_t_2) {
-          __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error)
-          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
-          __Pyx_GOTREF(__pyx_t_5);
+        if (!__pyx_t_15) {
+          __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error)
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_GOTREF(__pyx_t_2);
         } else {
           #if CYTHON_FAST_PYCALL
-          if (PyFunction_Check(__pyx_t_4)) {
-            PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_15};
-            __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error)
-            __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-            __Pyx_GOTREF(__pyx_t_5);
-            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+          if (PyFunction_Check(__pyx_t_3)) {
+            PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_4};
+            __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error)
+            __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+            __Pyx_GOTREF(__pyx_t_2);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
           } else
           #endif
           #if CYTHON_FAST_PYCCALL
-          if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
-            PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_15};
-            __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error)
-            __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-            __Pyx_GOTREF(__pyx_t_5);
-            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+          if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+            PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_4};
+            __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error)
+            __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+            __Pyx_GOTREF(__pyx_t_2);
+            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
           } else
           #endif
           {
-            __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error)
+            __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error)
             __Pyx_GOTREF(__pyx_t_1);
-            __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __pyx_t_2 = NULL;
-            __Pyx_GIVEREF(__pyx_t_15);
-            PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_15);
-            __pyx_t_15 = 0;
-            __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error)
-            __Pyx_GOTREF(__pyx_t_5);
+            __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_15); __pyx_t_15 = NULL;
+            __Pyx_GIVEREF(__pyx_t_4);
+            PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_4);
+            __pyx_t_4 = 0;
+            __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_2);
             __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
           }
         }
-        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
 098: 

 
+099:             Node = graph.GetNode(NodeID)

-
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 99, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L1_error)
+
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 99, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_15 = NULL;
-      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
-        __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_4);
-        if (likely(__pyx_t_15)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
-          __Pyx_INCREF(__pyx_t_15);
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+        if (likely(__pyx_t_4)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+          __Pyx_INCREF(__pyx_t_4);
           __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_4, function);
+          __Pyx_DECREF_SET(__pyx_t_3, function);
         }
       }
-      if (!__pyx_t_15) {
-        __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error)
+      if (!__pyx_t_4) {
+        __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error)
         __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_GOTREF(__pyx_t_2);
       } else {
         #if CYTHON_FAST_PYCALL
-        if (PyFunction_Check(__pyx_t_4)) {
-          PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_1};
-          __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error)
-          __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
-          __Pyx_GOTREF(__pyx_t_5);
+        if (PyFunction_Check(__pyx_t_3)) {
+          PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1};
+          __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_GOTREF(__pyx_t_2);
           __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
         } else
         #endif
         #if CYTHON_FAST_PYCCALL
-        if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
-          PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_1};
-          __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error)
-          __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
-          __Pyx_GOTREF(__pyx_t_5);
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+          PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1};
+          __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_GOTREF(__pyx_t_2);
           __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
         } else
         #endif
         {
-          __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_2);
-          __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_15); __pyx_t_15 = NULL;
+          __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 99, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_15);
+          __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_4); __pyx_t_4 = NULL;
           __Pyx_GIVEREF(__pyx_t_1);
-          PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_1);
+          PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_1);
           __pyx_t_1 = 0;
-          __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_5);
-          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_15, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
         }
       }
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __Pyx_XDECREF_SET(__pyx_v_Node, __pyx_t_5);
-      __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF_SET(__pyx_v_Node, __pyx_t_2);
+      __pyx_t_2 = 0;
 
+100:             tScore = g[current]+ Node.Get_Cost()

-
      __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 100, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 100, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_Node, __pyx_n_s_Get_Cost); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error)
+
      __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 100, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_Node, __pyx_n_s_Get_Cost); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 100, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_15);
       __pyx_t_1 = NULL;
-      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
-        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_15))) {
+        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_15);
         if (likely(__pyx_t_1)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15);
           __Pyx_INCREF(__pyx_t_1);
           __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_2, function);
+          __Pyx_DECREF_SET(__pyx_t_15, function);
         }
       }
       if (__pyx_t_1) {
-        __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 100, __pyx_L1_error)
+        __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error)
         __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
       } else {
-        __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 100, __pyx_L1_error)
+        __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_15); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error)
       }
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 100, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+      __pyx_t_15 = PyNumber_Add(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 100, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_15);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_v_tScore = __pyx_t_11;
+      __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_15); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 100, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+      __pyx_v_tScore = __pyx_t_12;
 
+101:             if tScore >= g[NodeID]:

-
      __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_tScore); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error)
+
      __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_tScore); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 101, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_15);
+      __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 101, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 101, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_t_5 = PyObject_RichCompare(__pyx_t_2, __pyx_t_4, Py_GE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 101, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 101, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 101, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      if (__pyx_t_13) {
+      __pyx_t_2 = PyObject_RichCompare(__pyx_t_15, __pyx_t_3, Py_GE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 101, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      if (__pyx_t_14) {
 /* … */
       }
 
+102:                 continue

-
        goto __pyx_L6_continue;
+
        goto __pyx_L10_continue;
 
+103:             cameFrom[NodeID] = current

-
      __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 103, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 103, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      if (unlikely(PyDict_SetItem(__pyx_v_cameFrom, __pyx_t_4, __pyx_t_5) < 0)) __PYX_ERR(0, 103, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-
+104:             g[NodeID] = tScore

-
      __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_tScore); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 104, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 104, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_4, __pyx_t_5) < 0)) __PYX_ERR(0, 104, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-
+105:             fp.remove((f[NodeID],NodeID))

-
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_remove); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 105, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
+
      __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_f, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 105, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 103, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      if (unlikely(PyDict_SetItem(__pyx_v_cameFrom, __pyx_t_3, __pyx_t_2) < 0)) __PYX_ERR(0, 103, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
+
+104:             g[NodeID] = tScore

+
      __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_tScore); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_15 = PyTuple_New(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 105, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 104, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_3, __pyx_t_2) < 0)) __PYX_ERR(0, 104, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+105:             fp.remove((f[NodeID],NodeID))

+
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_remove); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 105, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 105, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_15);
+      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_f, __pyx_t_15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 105, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+      __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 105, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_15);
+      __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 105, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
       __Pyx_GIVEREF(__pyx_t_1);
-      PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_1);
-      __Pyx_GIVEREF(__pyx_t_2);
-      PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_2);
+      PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+      __Pyx_GIVEREF(__pyx_t_15);
+      PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_15);
       __pyx_t_1 = 0;
-      __pyx_t_2 = 0;
-      __pyx_t_2 = NULL;
-      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
-        __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
-        if (likely(__pyx_t_2)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
-          __Pyx_INCREF(__pyx_t_2);
+      __pyx_t_15 = 0;
+      __pyx_t_15 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+        __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_3);
+        if (likely(__pyx_t_15)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+          __Pyx_INCREF(__pyx_t_15);
           __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_4, function);
+          __Pyx_DECREF_SET(__pyx_t_3, function);
         }
-      }
-      if (!__pyx_t_2) {
-        __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 105, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
-        __Pyx_GOTREF(__pyx_t_5);
+      }
+      if (!__pyx_t_15) {
+        __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_2);
       } else {
         #if CYTHON_FAST_PYCALL
-        if (PyFunction_Check(__pyx_t_4)) {
-          PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_15};
-          __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 105, __pyx_L1_error)
-          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-          __Pyx_GOTREF(__pyx_t_5);
-          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+        if (PyFunction_Check(__pyx_t_3)) {
+          PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_4};
+          __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
         } else
         #endif
         #if CYTHON_FAST_PYCCALL
-        if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
-          PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_15};
-          __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 105, __pyx_L1_error)
-          __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-          __Pyx_GOTREF(__pyx_t_5);
-          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+          PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_4};
+          __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
         } else
         #endif
         {
-          __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 105, __pyx_L1_error)
+          __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 105, __pyx_L1_error)
           __Pyx_GOTREF(__pyx_t_1);
-          __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __pyx_t_2 = NULL;
-          __Pyx_GIVEREF(__pyx_t_15);
-          PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_15);
-          __pyx_t_15 = 0;
-          __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 105, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_5);
+          __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_15); __pyx_t_15 = NULL;
+          __Pyx_GIVEREF(__pyx_t_4);
+          PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_4);
+          __pyx_t_4 = 0;
+          __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_2);
           __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
         }
       }
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
+106:             fTemp = g[NodeID] + EstimateDistance(NodeID,target,xCount,yCount,zCount,xSize,ySize,zSize)

-
      __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 106, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 106, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_t_5 = PyFloat_FromDouble(__pyx_f_6CAStar_EstimateDistance(__pyx_v_NodeID, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 106, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_1 = PyNumber_Add(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 106, __pyx_L1_error)
+
      __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 106, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_2 = PyFloat_FromDouble(__pyx_f_6CAStar_6CAStar_EstimateDistance(__pyx_v_NodeID, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 106, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 106, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 106, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __pyx_v_fTemp = __pyx_t_8;
+      __pyx_v_fTemp = __pyx_t_9;
 
+107:             f[NodeID] = fTemp

-
      __pyx_t_1 = PyFloat_FromDouble(__pyx_v_fTemp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error)
+
      __pyx_t_1 = PyFloat_FromDouble(__pyx_v_fTemp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 107, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      if (unlikely(PyDict_SetItem(__pyx_v_f, __pyx_t_5, __pyx_t_1) < 0)) __PYX_ERR(0, 107, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      if (unlikely(PyDict_SetItem(__pyx_v_f, __pyx_t_2, __pyx_t_1) < 0)) __PYX_ERR(0, 107, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
+108:             fp.put((fTemp,NodeID))

-
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_put); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 108, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_4 = PyFloat_FromDouble(__pyx_v_fTemp); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 108, __pyx_L1_error)
+
      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_fp, __pyx_n_s_put); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_3 = PyFloat_FromDouble(__pyx_v_fTemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 108, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 108, __pyx_L1_error)
+      __pyx_t_15 = PyTuple_New(2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 108, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_15);
-      __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3);
       __Pyx_GIVEREF(__pyx_t_4);
-      PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4);
-      __Pyx_GIVEREF(__pyx_t_15);
-      PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_15);
+      PyTuple_SET_ITEM(__pyx_t_15, 1, __pyx_t_4);
+      __pyx_t_3 = 0;
       __pyx_t_4 = 0;
-      __pyx_t_15 = 0;
-      __pyx_t_15 = NULL;
-      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
-        __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_5);
-        if (likely(__pyx_t_15)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
-          __Pyx_INCREF(__pyx_t_15);
+      __pyx_t_4 = NULL;
+      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+        if (likely(__pyx_t_4)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+          __Pyx_INCREF(__pyx_t_4);
           __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_5, function);
+          __Pyx_DECREF_SET(__pyx_t_2, function);
         }
       }
-      if (!__pyx_t_15) {
-        __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      if (!__pyx_t_4) {
+        __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
         __Pyx_GOTREF(__pyx_t_1);
       } else {
         #if CYTHON_FAST_PYCALL
-        if (PyFunction_Check(__pyx_t_5)) {
-          PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_2};
-          __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error)
-          __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+        if (PyFunction_Check(__pyx_t_2)) {
+          PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_15};
+          __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
           __Pyx_GOTREF(__pyx_t_1);
-          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
         } else
         #endif
         #if CYTHON_FAST_PYCCALL
-        if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
-          PyObject *__pyx_temp[2] = {__pyx_t_15, __pyx_t_2};
-          __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error)
-          __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+        if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+          PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_15};
+          __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error)
+          __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
           __Pyx_GOTREF(__pyx_t_1);
-          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
         } else
         #endif
         {
-          __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 108, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_4);
-          __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_15); __pyx_t_15 = NULL;
-          __Pyx_GIVEREF(__pyx_t_2);
-          PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_2);
-          __pyx_t_2 = 0;
-          __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error)
+          __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
+          __Pyx_GIVEREF(__pyx_t_15);
+          PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_15);
+          __pyx_t_15 = 0;
+          __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error)
           __Pyx_GOTREF(__pyx_t_1);
-          __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;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
 109: 

 
+110:         f.pop(current) #These values will not be refered to again since the current NodeID has been moved to the closed set . This therefore reduces memory usage very slightly

-
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_pop); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error)
+
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_pop); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_4 = NULL;
+    __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = NULL;
     if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
-      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
-      if (likely(__pyx_t_4)) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_3)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
-        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_3);
         __Pyx_INCREF(function);
         __Pyx_DECREF_SET(__pyx_t_1, function);
       }
     }
-    if (!__pyx_t_4) {
-      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __Pyx_GOTREF(__pyx_t_3);
+    if (!__pyx_t_3) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_5);
     } else {
       #if CYTHON_FAST_PYCALL
       if (PyFunction_Check(__pyx_t_1)) {
-        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5};
-        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-        __Pyx_GOTREF(__pyx_t_3);
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_2};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
       } else
       #endif
       #if CYTHON_FAST_PYCCALL
       if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
-        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5};
-        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-        __Pyx_GOTREF(__pyx_t_3);
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_2};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
       } else
       #endif
       {
-        __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL;
-        __Pyx_GIVEREF(__pyx_t_5);
-        PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_5);
-        __pyx_t_5 = 0;
-        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 110, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_3);
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 110, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_15);
+        __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3); __pyx_t_3 = NULL;
+        __Pyx_GIVEREF(__pyx_t_2);
+        PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_2);
+        __pyx_t_2 = 0;
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_15, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 110, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
       }
     }
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
+111:         g.pop(current)

-
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_g, __pyx_n_s_pop); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error)
+
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_g, __pyx_n_s_pop); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_5 = NULL;
+    __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 111, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+    __pyx_t_2 = NULL;
     if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
-      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
-      if (likely(__pyx_t_5)) {
+      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_2)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
-        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_2);
         __Pyx_INCREF(function);
         __Pyx_DECREF_SET(__pyx_t_1, function);
       }
     }
-    if (!__pyx_t_5) {
-      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __Pyx_GOTREF(__pyx_t_3);
+    if (!__pyx_t_2) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 111, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+      __Pyx_GOTREF(__pyx_t_5);
     } else {
       #if CYTHON_FAST_PYCALL
       if (PyFunction_Check(__pyx_t_1)) {
-        PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_2};
-        __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_GOTREF(__pyx_t_3);
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_15};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 111, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
       } else
       #endif
       #if CYTHON_FAST_PYCCALL
       if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
-        PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_2};
-        __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_GOTREF(__pyx_t_3);
-        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_15};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 111, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
       } else
       #endif
       {
-        __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_4);
-        __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __pyx_t_5 = NULL;
-        __Pyx_GIVEREF(__pyx_t_2);
-        PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_2);
-        __pyx_t_2 = 0;
-        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error)
+        __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_3);
-        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL;
+        __Pyx_GIVEREF(__pyx_t_15);
+        PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_15);
+        __pyx_t_15 = 0;
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 111, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       }
     }
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   }
-  __pyx_L4_break:;
+  __pyx_L8_break:;
 
+112:     EndTime = time.time()

-
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
+
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_time); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 112, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_1 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
-    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
     if (likely(__pyx_t_1)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
       __Pyx_INCREF(__pyx_t_1);
       __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_4, function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
     }
   }
   if (__pyx_t_1) {
-    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 112, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   } else {
-    __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 112, __pyx_L1_error)
   }
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_v_EndTime = __pyx_t_3;
-  __pyx_t_3 = 0;
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_EndTime = __pyx_t_5;
+  __pyx_t_5 = 0;
 
+113:     print("[A* Time] "+str((EndTime-StartTime)*1000)+" Milliseconds."+" Total Expanded:"+str(len(cameFrom)))

-
  __pyx_t_3 = PyNumber_Subtract(__pyx_v_EndTime, __pyx_v_StartTime); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error)
+
  __pyx_t_5 = PyNumber_Subtract(__pyx_v_EndTime, __pyx_v_StartTime); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyNumber_Multiply(__pyx_t_5, __pyx_int_1000); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_int_1000); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GIVEREF(__pyx_t_4);
-  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
-  __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyNumber_Add(__pyx_kp_s_A_Time, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = PyNumber_Add(__pyx_kp_s_A_Time, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __pyx_t_3 = PyNumber_Add(__pyx_t_5, __pyx_kp_s_Milliseconds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = PyNumber_Add(__pyx_t_3, __pyx_kp_s_Milliseconds); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyNumber_Add(__pyx_t_3, __pyx_kp_s_Total_Expanded); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_kp_s_Total_Expanded); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __pyx_t_13 = PyDict_Size(__pyx_v_cameFrom); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_12 = PyDict_Size(__pyx_v_cameFrom); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 113, __pyx_L1_error)
-  __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_4);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4);
-  __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __pyx_t_1 = PyNumber_Add(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 113, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (__Pyx_PrintOne(0, __pyx_t_1) < 0) __PYX_ERR(0, 113, __pyx_L1_error)
+  if (__Pyx_PrintOne(0, __pyx_t_1) < 0) __PYX_ERR(0, 113, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
+114:     if Found:

-
  __pyx_t_13 = (__pyx_v_Found != 0);
-  if (__pyx_t_13) {
+
  __pyx_t_14 = (__pyx_v_Found != 0);
+  if (__pyx_t_14) {
 /* … */
   }
 
+115:         return FindPath(cameFrom,current)

 
    __Pyx_XDECREF(__pyx_r);
-    __pyx_t_1 = __pyx_f_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 115, __pyx_L1_error)
+    __pyx_t_1 = __pyx_f_6CAStar_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 115, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __pyx_r = __pyx_t_1;
     __pyx_t_1 = 0;
@@ -1756,31 +1912,31 @@
 
 116:     else:

 
+117:         print("A* Search FAILED. Start:",start,"Target:",target)

 
  /*else*/ {
-    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 117, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 117, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_target); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 117, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 117, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_target); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 117, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 117, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
     __Pyx_INCREF(__pyx_kp_s_A_Search_FAILED_Start);
     __Pyx_GIVEREF(__pyx_kp_s_A_Search_FAILED_Start);
-    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_s_A_Search_FAILED_Start);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_s_A_Search_FAILED_Start);
     __Pyx_GIVEREF(__pyx_t_1);
-    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
     __Pyx_INCREF(__pyx_kp_s_Target);
     __Pyx_GIVEREF(__pyx_kp_s_Target);
-    PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_s_Target);
-    __Pyx_GIVEREF(__pyx_t_4);
-    PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_s_Target);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_3);
     __pyx_t_1 = 0;
-    __pyx_t_4 = 0;
-    if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 117, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = 0;
+    if (__Pyx_PrintOne(0, __pyx_t_5) < 0) __PYX_ERR(0, 117, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
+118:         print(FindPath(cameFrom,current))

-
    __pyx_t_3 = __pyx_f_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(0, 118, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
    __pyx_t_5 = __pyx_f_6CAStar_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 118, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (__Pyx_PrintOne(0, __pyx_t_5) < 0) __PYX_ERR(0, 118, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
+119:         return None

 
    __Pyx_XDECREF(__pyx_r);
     __Pyx_INCREF(Py_None);
@@ -1790,9 +1946,9 @@
 
 120: 

 
+121: def AStar2(graph, int start, int target):   # Set all g to node_count + 1

 
/* Python wrapper */
-static PyObject *__pyx_pw_6CAStar_3AStar2(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyMethodDef __pyx_mdef_6CAStar_3AStar2 = {"AStar2", (PyCFunction)__pyx_pw_6CAStar_3AStar2, METH_VARARGS|METH_KEYWORDS, 0};
-static PyObject *__pyx_pw_6CAStar_3AStar2(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_6CAStar_6CAStar_3AStar2(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_6CAStar_3AStar2 = {"AStar2", (PyCFunction)__pyx_pw_6CAStar_6CAStar_3AStar2, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_6CAStar_6CAStar_3AStar2(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   PyObject *__pyx_v_graph = 0;
   int __pyx_v_start;
   int __pyx_v_target;
@@ -1824,17 +1980,17 @@
         case  1:
         if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("AStar2", 1, 3, 3, 1); __PYX_ERR(0, 121, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("AStar2", 1, 3, 3, 1); __PYX_ERR(0, 121, __pyx_L3_error)
         }
         CYTHON_FALLTHROUGH;
         case  2:
         if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_target)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("AStar2", 1, 3, 3, 2); __PYX_ERR(0, 121, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("AStar2", 1, 3, 3, 2); __PYX_ERR(0, 121, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "AStar2") < 0)) __PYX_ERR(0, 121, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "AStar2") < 0)) __PYX_ERR(0, 121, __pyx_L3_error)
       }
     } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
       goto __pyx_L5_argtuple_error;
@@ -1844,26 +2000,26 @@
       values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
     }
     __pyx_v_graph = values[0];
-    __pyx_v_start = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_start == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 121, __pyx_L3_error)
-    __pyx_v_target = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_target == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 121, __pyx_L3_error)
+    __pyx_v_start = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_start == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 121, __pyx_L3_error)
+    __pyx_v_target = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_target == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 121, __pyx_L3_error)
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("AStar2", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 121, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("AStar2", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 121, __pyx_L3_error)
   __pyx_L3_error:;
-  __Pyx_AddTraceback("CAStar.AStar2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("CAStar.CAStar.AStar2", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_6CAStar_2AStar2(__pyx_self, __pyx_v_graph, __pyx_v_start, __pyx_v_target);
+  __pyx_r = __pyx_pf_6CAStar_6CAStar_2AStar2(__pyx_self, __pyx_v_graph, __pyx_v_start, __pyx_v_target);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 /* … */
-static PyObject *__pyx_pf_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_graph, int __pyx_v_start, int __pyx_v_target) {
-  struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *__pyx_cur_scope;
+static PyObject *__pyx_pf_6CAStar_6CAStar_2AStar2(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_graph, int __pyx_v_start, int __pyx_v_target) {
+  struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *__pyx_cur_scope;
   PyObject *__pyx_v_StartTime = NULL;
   float __pyx_v_xSize;
   float __pyx_v_ySize;
@@ -1886,11 +2042,11 @@
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("AStar2", 0);
-  __pyx_cur_scope = (struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *)__pyx_tp_new_6CAStar___pyx_scope_struct__AStar2(__pyx_ptype_6CAStar___pyx_scope_struct__AStar2, __pyx_empty_tuple, NULL);
+  __pyx_cur_scope = (struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *)__pyx_tp_new_6CAStar_6CAStar___pyx_scope_struct__AStar2(__pyx_ptype_6CAStar_6CAStar___pyx_scope_struct__AStar2, __pyx_empty_tuple, NULL);
   if (unlikely(!__pyx_cur_scope)) {
-    __pyx_cur_scope = ((struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *)Py_None);
+    __pyx_cur_scope = ((struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *)Py_None);
     __Pyx_INCREF(Py_None);
-    __PYX_ERR(0, 121, __pyx_L1_error)
+    __PYX_ERR(0, 121, __pyx_L1_error)
   } else {
     __Pyx_GOTREF(__pyx_cur_scope);
   }
@@ -1902,8 +2058,8 @@
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_14);
-  __Pyx_AddTraceback("CAStar.AStar2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_15);
+  __Pyx_AddTraceback("CAStar.CAStar.AStar2", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF(__pyx_v_StartTime);
@@ -1921,18 +2077,18 @@
   return __pyx_r;
 }
 /* … */
-  __pyx_tuple__5 = PyTuple_Pack(24, __pyx_n_s_graph, __pyx_n_s_start, __pyx_n_s_target, __pyx_n_s_StartTime, __pyx_n_s_xSize, __pyx_n_s_ySize, __pyx_n_s_zSize, __pyx_n_s_gNode, __pyx_n_s_ClosedSet, __pyx_n_s_OpenSet, __pyx_n_s_cameFrom, __pyx_n_s_g, __pyx_n_s_f, __pyx_n_s_NodeID, __pyx_n_s_current, __pyx_n_s_tScore, __pyx_n_s_xCount, __pyx_n_s_yCount, __pyx_n_s_zCount, __pyx_n_s_FriendList, __pyx_n_s_TargetNode, __pyx_n_s_Found, __pyx_n_s_Node, __pyx_n_s_EndTime); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 121, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__5);
-  __Pyx_GIVEREF(__pyx_tuple__5);
+  __pyx_tuple__6 = PyTuple_Pack(24, __pyx_n_s_graph, __pyx_n_s_start, __pyx_n_s_target, __pyx_n_s_StartTime, __pyx_n_s_xSize, __pyx_n_s_ySize, __pyx_n_s_zSize, __pyx_n_s_gNode, __pyx_n_s_ClosedSet, __pyx_n_s_OpenSet, __pyx_n_s_cameFrom, __pyx_n_s_g, __pyx_n_s_f, __pyx_n_s_NodeID, __pyx_n_s_current, __pyx_n_s_tScore, __pyx_n_s_xCount, __pyx_n_s_yCount, __pyx_n_s_zCount, __pyx_n_s_FriendList, __pyx_n_s_TargetNode, __pyx_n_s_Found, __pyx_n_s_Node, __pyx_n_s_EndTime); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
 /* … */
-  __pyx_t_9 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_3AStar2, NULL, __pyx_n_s_CAStar); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 121, __pyx_L1_error)
+  __pyx_t_9 = PyCFunction_NewEx(&__pyx_mdef_6CAStar_6CAStar_3AStar2, NULL, __pyx_n_s_CAStar_CAStar); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 121, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_9);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AStar2, __pyx_t_9) < 0) __PYX_ERR(0, 121, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AStar2, __pyx_t_9) < 0) __PYX_ERR(0, 121, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
 
+122:     StartTime = time.time()

-
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
+
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __pyx_t_2 = NULL;
@@ -1946,10 +2102,10 @@
     }
   }
   if (__pyx_t_2) {
-    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 122, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 122, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   } else {
-    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 122, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 122, __pyx_L1_error)
   }
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -1963,9 +2119,9 @@
 
 128: 

 
 129: 

 
+130:     TargetNode = graph.GetNode(target)

-
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 130, __pyx_L1_error)
+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 130, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_target); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_target); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_t_4 = NULL;
   if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
@@ -1978,14 +2134,14 @@
     }
   }
   if (!__pyx_t_4) {
-    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     __Pyx_GOTREF(__pyx_t_1);
   } else {
     #if CYTHON_FAST_PYCALL
     if (PyFunction_Check(__pyx_t_3)) {
       PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
-      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
       __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
       __Pyx_GOTREF(__pyx_t_1);
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -1994,20 +2150,20 @@
     #if CYTHON_FAST_PYCCALL
     if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
       PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
-      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
       __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
       __Pyx_GOTREF(__pyx_t_1);
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     } else
     #endif
     {
-      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 130, __pyx_L1_error)
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 130, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_5);
       __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
       __Pyx_GIVEREF(__pyx_t_2);
       PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2);
       __pyx_t_2 = 0;
-      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 130, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
       __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     }
@@ -2015,62 +2171,204 @@
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_TargetNode = __pyx_t_1;
   __pyx_t_1 = 0;
-
+131:     xSize,ySize,zSize = graph.xSize,graph.ySize,graph.zSize

-
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_xSize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_ySize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_7 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_7 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_zSize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v_xSize = __pyx_t_6;
-  __pyx_v_ySize = __pyx_t_7;
-  __pyx_v_zSize = __pyx_t_8;
-
+132:     xCount,yCount,zCount = graph.xCount,graph.yCount,graph.zCount

-
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_xCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_yCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error)
+
+131:     xSize,ySize,zSize = graph.Get_Size()

+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_Get_Size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_5) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error)
+  }
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_zCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
+    PyObject* sequence = __pyx_t_1;
+    #if !CYTHON_COMPILING_IN_PYPY
+    Py_ssize_t size = Py_SIZE(sequence);
+    #else
+    Py_ssize_t size = PySequence_Size(sequence);
+    #endif
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 131, __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_t_5 = PyTuple_GET_ITEM(sequence, 1); 
+      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 2); 
+    } else {
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_5 = PyList_GET_ITEM(sequence, 1); 
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 2); 
+    }
+    __Pyx_INCREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_t_2);
+    #else
+    __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 131, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_2 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    #endif
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 131, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext;
+    index = 0; __pyx_t_3 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_3);
+    index = 1; __pyx_t_5 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_5)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_5);
+    index = 2; __pyx_t_2 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_2);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_4), 3) < 0) __PYX_ERR(0, 131, __pyx_L1_error)
+    __pyx_t_6 = NULL;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L4_unpacking_done;
+    __pyx_L3_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_6 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 131, __pyx_L1_error)
+    __pyx_L4_unpacking_done:;
+  }
+  __pyx_t_7 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_7 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_8 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_8 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_9 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_9 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_xSize = __pyx_t_7;
+  __pyx_v_ySize = __pyx_t_8;
+  __pyx_v_zSize = __pyx_t_9;
+
+132:     xCount,yCount,zCount = graph.Get_Count()

+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_Get_Count); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 132, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_5) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error)
+  }
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v_xCount = __pyx_t_9;
-  __pyx_v_yCount = __pyx_t_10;
-  __pyx_v_zCount = __pyx_t_11;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
+    PyObject* sequence = __pyx_t_1;
+    #if !CYTHON_COMPILING_IN_PYPY
+    Py_ssize_t size = Py_SIZE(sequence);
+    #else
+    Py_ssize_t size = PySequence_Size(sequence);
+    #endif
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(0, 132, __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_t_5 = PyTuple_GET_ITEM(sequence, 1); 
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 2); 
+    } else {
+      __pyx_t_2 = PyList_GET_ITEM(sequence, 0); 
+      __pyx_t_5 = PyList_GET_ITEM(sequence, 1); 
+      __pyx_t_3 = PyList_GET_ITEM(sequence, 2); 
+    }
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx_t_3);
+    #else
+    __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 132, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 132, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_3 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 132, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 132, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext;
+    index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L5_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_2);
+    index = 1; __pyx_t_5 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_5);
+    index = 2; __pyx_t_3 = __pyx_t_6(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L5_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_3);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_4), 3) < 0) __PYX_ERR(0, 132, __pyx_L1_error)
+    __pyx_t_6 = NULL;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    goto __pyx_L6_unpacking_done;
+    __pyx_L5_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_6 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(0, 132, __pyx_L1_error)
+    __pyx_L6_unpacking_done:;
+  }
+  __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 132, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_xCount = __pyx_t_10;
+  __pyx_v_yCount = __pyx_t_11;
+  __pyx_v_zCount = __pyx_t_12;
 
 133: 

 
+134:     ClosedSet = {}  #Dict to hash find closed nodes

-
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
+
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 134, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_ClosedSet = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
+135:     OpenSet = {start:1}

-
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error)
+
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 135, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 135, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_int_1) < 0) __PYX_ERR(0, 135, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_int_1) < 0) __PYX_ERR(0, 135, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_OpenSet = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
+136:     cameFrom = {}

-
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error)
+
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_cameFrom = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
+137:     g,f = {},{}

-
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 137, __pyx_L1_error)
+
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 137, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 137, __pyx_L1_error)
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 137, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_v_g = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
@@ -2082,30 +2380,30 @@
 
 139: 

 
 140: 

 
+141:     g[start] = 0

-
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 141, __pyx_L1_error)
+
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 141, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_3, __pyx_int_0) < 0)) __PYX_ERR(0, 141, __pyx_L1_error)
+  if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_3, __pyx_int_0) < 0)) __PYX_ERR(0, 141, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
+142:     f[start] = EstimateDistance(start,target,xCount,yCount,zCount,xSize,ySize,zSize)

-
  __pyx_t_3 = PyFloat_FromDouble(__pyx_f_6CAStar_EstimateDistance(__pyx_v_start, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 142, __pyx_L1_error)
+
  __pyx_t_3 = PyFloat_FromDouble(__pyx_f_6CAStar_6CAStar_EstimateDistance(__pyx_v_start, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 142, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 142, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (unlikely(PyDict_SetItem(__pyx_cur_scope->__pyx_v_f, __pyx_t_1, __pyx_t_3) < 0)) __PYX_ERR(0, 142, __pyx_L1_error)
+  if (unlikely(PyDict_SetItem(__pyx_cur_scope->__pyx_v_f, __pyx_t_1, __pyx_t_3) < 0)) __PYX_ERR(0, 142, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
+143:     Found = False

 
  __pyx_v_Found = 0;
 
+144:     while len(OpenSet) != 0:

 
  while (1) {
-    __pyx_t_12 = PyDict_Size(__pyx_v_OpenSet); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 144, __pyx_L1_error)
-    __pyx_t_13 = ((__pyx_t_12 != 0) != 0);
-    if (!__pyx_t_13) break;
+    __pyx_t_13 = PyDict_Size(__pyx_v_OpenSet); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 144, __pyx_L1_error)
+    __pyx_t_14 = ((__pyx_t_13 != 0) != 0);
+    if (!__pyx_t_14) break;
 
+145:         current = min(f, key = lambda n:f[n])  #Faster (106 vs 62 ms) and doesnt require OpenList to be made

 
/* Python wrapper */
-static PyObject *__pyx_pw_6CAStar_6AStar2_lambda(PyObject *__pyx_self, PyObject *__pyx_v_n); /*proto*/
-static PyMethodDef __pyx_mdef_6CAStar_6AStar2_lambda = {"lambda", (PyCFunction)__pyx_pw_6CAStar_6AStar2_lambda, METH_O, 0};
-static PyObject *__pyx_pw_6CAStar_6AStar2_lambda(PyObject *__pyx_self, PyObject *__pyx_v_n) {
+static PyObject *__pyx_pw_6CAStar_6CAStar_6AStar2_lambda(PyObject *__pyx_self, PyObject *__pyx_v_n); /*proto*/
+static PyMethodDef __pyx_mdef_6CAStar_6CAStar_6AStar2_lambda = {"lambda", (PyCFunction)__pyx_pw_6CAStar_6CAStar_6AStar2_lambda, METH_O, 0};
+static PyObject *__pyx_pw_6CAStar_6CAStar_6AStar2_lambda(PyObject *__pyx_self, PyObject *__pyx_v_n) {
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("lambda (wrapper)", 0);
@@ -2117,20 +2415,20 @@
 }
 
 static PyObject *__pyx_lambda_funcdef_lambda(PyObject *__pyx_self, PyObject *__pyx_v_n) {
-  struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *__pyx_cur_scope;
-  struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *__pyx_outer_scope;
+  struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *__pyx_cur_scope;
+  struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *__pyx_outer_scope;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("lambda", 0);
-  __pyx_outer_scope = (struct __pyx_obj_6CAStar___pyx_scope_struct__AStar2 *) __Pyx_CyFunction_GetClosure(__pyx_self);
+  __pyx_outer_scope = (struct __pyx_obj_6CAStar_6CAStar___pyx_scope_struct__AStar2 *) __Pyx_CyFunction_GetClosure(__pyx_self);
   __pyx_cur_scope = __pyx_outer_scope;
   __Pyx_XDECREF(__pyx_r);
-  if (unlikely(!__pyx_cur_scope->__pyx_v_f)) { __Pyx_RaiseClosureNameError("f"); __PYX_ERR(0, 145, __pyx_L1_error) }
+  if (unlikely(!__pyx_cur_scope->__pyx_v_f)) { __Pyx_RaiseClosureNameError("f"); __PYX_ERR(0, 145, __pyx_L1_error) }
   if (unlikely(__pyx_cur_scope->__pyx_v_f == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
-    __PYX_ERR(0, 145, __pyx_L1_error)
+    __PYX_ERR(0, 145, __pyx_L1_error)
   }
-  __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_f, __pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_f, __pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -2139,7 +2437,7 @@
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("CAStar.AStar2.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("CAStar.CAStar.AStar2.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
@@ -2147,38 +2445,38 @@
   return __pyx_r;
 }
 /* … */
-    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 145, __pyx_L1_error)
+    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 145, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_INCREF(__pyx_cur_scope->__pyx_v_f);
     __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_f);
     PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_cur_scope->__pyx_v_f);
-    __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error)
+    __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_5 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_6AStar2_lambda, 0, __pyx_n_s_AStar2_locals_lambda, ((PyObject*)__pyx_cur_scope), __pyx_n_s_CAStar, __pyx_d, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 145, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6CAStar_6CAStar_6AStar2_lambda, 0, __pyx_n_s_AStar2_locals_lambda, ((PyObject*)__pyx_cur_scope), __pyx_n_s_CAStar_CAStar, __pyx_d, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 145, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
-    if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_key, __pyx_t_5) < 0) __PYX_ERR(0, 145, __pyx_L1_error)
+    if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_key, __pyx_t_5) < 0) __PYX_ERR(0, 145, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_min, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 145, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_min, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 145, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 145, __pyx_L1_error)
+    __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 145, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __pyx_v_current = __pyx_t_11;
+    __pyx_v_current = __pyx_t_12;
 
+146:         if current == target:

-
    __pyx_t_13 = ((__pyx_v_current == __pyx_v_target) != 0);
-    if (__pyx_t_13) {
+
    __pyx_t_14 = ((__pyx_v_current == __pyx_v_target) != 0);
+    if (__pyx_t_14) {
 /* … */
     }
 
+147:             Found = True

 
      __pyx_v_Found = 1;
 
+148:             break

-
      goto __pyx_L4_break;
+
      goto __pyx_L8_break;
 
 149: 

 
+150:         OpenSet.pop(current)

-
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_OpenSet, __pyx_n_s_pop); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error)
+
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_OpenSet, __pyx_n_s_pop); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 150, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_t_2 = NULL;
     if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
@@ -2191,14 +2489,14 @@
       }
     }
     if (!__pyx_t_2) {
-      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 150, __pyx_L1_error)
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 150, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       __Pyx_GOTREF(__pyx_t_5);
     } else {
       #if CYTHON_FAST_PYCALL
       if (PyFunction_Check(__pyx_t_1)) {
         PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_3};
-        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 150, __pyx_L1_error)
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 150, __pyx_L1_error)
         __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
         __Pyx_GOTREF(__pyx_t_5);
         __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -2207,20 +2505,20 @@
       #if CYTHON_FAST_PYCCALL
       if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
         PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_3};
-        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 150, __pyx_L1_error)
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 150, __pyx_L1_error)
         __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
         __Pyx_GOTREF(__pyx_t_5);
         __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       } else
       #endif
       {
-        __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
+        __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 150, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_4);
         __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
         __Pyx_GIVEREF(__pyx_t_3);
         PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_3);
         __pyx_t_3 = 0;
-        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 150, __pyx_L1_error)
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 150, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_5);
         __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       }
@@ -2228,15 +2526,15 @@
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
+151:         ClosedSet[current] = 1

-
    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 151, __pyx_L1_error)
+
    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 151, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
-    if (unlikely(PyDict_SetItem(__pyx_v_ClosedSet, __pyx_t_5, __pyx_int_1) < 0)) __PYX_ERR(0, 151, __pyx_L1_error)
+    if (unlikely(PyDict_SetItem(__pyx_v_ClosedSet, __pyx_t_5, __pyx_int_1) < 0)) __PYX_ERR(0, 151, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
 152: 

 
+153:         FriendList = graph.GetNode(current).Get_Friends()

-
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error)
+
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 153, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_t_2 = NULL;
     if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
@@ -2249,14 +2547,14 @@
       }
     }
     if (!__pyx_t_2) {
-      __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
+      __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       __Pyx_GOTREF(__pyx_t_1);
     } else {
       #if CYTHON_FAST_PYCALL
       if (PyFunction_Check(__pyx_t_4)) {
         PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_3};
-        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
+        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
         __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
         __Pyx_GOTREF(__pyx_t_1);
         __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -2265,26 +2563,26 @@
       #if CYTHON_FAST_PYCCALL
       if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
         PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_3};
-        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
+        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
         __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
         __Pyx_GOTREF(__pyx_t_1);
         __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
       } else
       #endif
       {
-        __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 153, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_14);
-        __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_2); __pyx_t_2 = NULL;
+        __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 153, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_15);
+        __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_2); __pyx_t_2 = NULL;
         __Pyx_GIVEREF(__pyx_t_3);
-        PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_t_3);
+        PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_3);
         __pyx_t_3 = 0;
-        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
+        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_15, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 153, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_1);
-        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
       }
     }
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Get_Friends); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Get_Friends); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     __pyx_t_1 = NULL;
@@ -2298,90 +2596,90 @@
       }
     }
     if (__pyx_t_1) {
-      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 153, __pyx_L1_error)
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 153, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     } else {
-      __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 153, __pyx_L1_error)
+      __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 153, __pyx_L1_error)
     }
     __Pyx_GOTREF(__pyx_t_5);
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    if (!(likely(PyList_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_5)->tp_name), 0))) __PYX_ERR(0, 153, __pyx_L1_error)
+    if (!(likely(PyList_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_5)->tp_name), 0))) __PYX_ERR(0, 153, __pyx_L1_error)
     __Pyx_XDECREF_SET(__pyx_v_FriendList, ((PyObject*)__pyx_t_5));
     __pyx_t_5 = 0;
 
+154:         for NodeID in FriendList:

 
    if (unlikely(__pyx_v_FriendList == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
-      __PYX_ERR(0, 154, __pyx_L1_error)
+      __PYX_ERR(0, 154, __pyx_L1_error)
     }
-    __pyx_t_5 = __pyx_v_FriendList; __Pyx_INCREF(__pyx_t_5); __pyx_t_12 = 0;
+    __pyx_t_5 = __pyx_v_FriendList; __Pyx_INCREF(__pyx_t_5); __pyx_t_13 = 0;
     for (;;) {
-      if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_5)) break;
+      if (__pyx_t_13 >= PyList_GET_SIZE(__pyx_t_5)) break;
       #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-      __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_12); __Pyx_INCREF(__pyx_t_4); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(0, 154, __pyx_L1_error)
+      __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_13); __Pyx_INCREF(__pyx_t_4); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 154, __pyx_L1_error)
       #else
-      __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error)
+      __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 154, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
       #endif
-      __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 154, __pyx_L1_error)
+      __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 154, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_v_NodeID = __pyx_t_11;
+      __pyx_v_NodeID = __pyx_t_12;
 /* … */
-      __pyx_L6_continue:;
+      __pyx_L10_continue:;
     }
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
+155:             if NodeID in ClosedSet:

-
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 155, __pyx_L1_error)
+
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 155, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_13 = (__Pyx_PyDict_ContainsTF(__pyx_t_4, __pyx_v_ClosedSet, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 155, __pyx_L1_error)
+      __pyx_t_14 = (__Pyx_PyDict_ContainsTF(__pyx_t_4, __pyx_v_ClosedSet, Py_EQ)); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 155, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_15 = (__pyx_t_13 != 0);
-      if (__pyx_t_15) {
+      __pyx_t_16 = (__pyx_t_14 != 0);
+      if (__pyx_t_16) {
 /* … */
       }
 
+156:                 continue

-
        goto __pyx_L6_continue;
+
        goto __pyx_L10_continue;
 
+157:             if NodeID not in OpenSet:

-
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L1_error)
+
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_15 = (__Pyx_PyDict_ContainsTF(__pyx_t_4, __pyx_v_OpenSet, Py_NE)); if (unlikely(__pyx_t_15 < 0)) __PYX_ERR(0, 157, __pyx_L1_error)
+      __pyx_t_16 = (__Pyx_PyDict_ContainsTF(__pyx_t_4, __pyx_v_OpenSet, Py_NE)); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 157, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_13 = (__pyx_t_15 != 0);
-      if (__pyx_t_13) {
+      __pyx_t_14 = (__pyx_t_16 != 0);
+      if (__pyx_t_14) {
 /* … */
       }
 
+158:                 OpenSet[NodeID] = 1

-
        __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error)
+
        __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 158, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_4);
-        if (unlikely(PyDict_SetItem(__pyx_v_OpenSet, __pyx_t_4, __pyx_int_1) < 0)) __PYX_ERR(0, 158, __pyx_L1_error)
+        if (unlikely(PyDict_SetItem(__pyx_v_OpenSet, __pyx_t_4, __pyx_int_1) < 0)) __PYX_ERR(0, 158, __pyx_L1_error)
         __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
+159:                 g[NodeID] = math.inf

-
        __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 159, __pyx_L1_error)
+
        __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 159, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_4);
-        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_inf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error)
+        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_inf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_1);
         __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-        __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 159, __pyx_L1_error)
+        __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 159, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_4);
-        if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_4, __pyx_t_1) < 0)) __PYX_ERR(0, 159, __pyx_L1_error)
+        if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_4, __pyx_t_1) < 0)) __PYX_ERR(0, 159, __pyx_L1_error)
         __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
         __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
+160:                 f[NodeID] = math.inf

-
        __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
+
        __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_math); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_1);
-        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inf); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 160, __pyx_L1_error)
+        __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_inf); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 160, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_4);
         __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-        __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
+        __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_1);
-        if (unlikely(PyDict_SetItem(__pyx_cur_scope->__pyx_v_f, __pyx_t_1, __pyx_t_4) < 0)) __PYX_ERR(0, 160, __pyx_L1_error)
+        if (unlikely(PyDict_SetItem(__pyx_cur_scope->__pyx_v_f, __pyx_t_1, __pyx_t_4) < 0)) __PYX_ERR(0, 160, __pyx_L1_error)
         __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
         __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
 161: 

 
+162:             Node = graph.GetNode(NodeID)

-
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error)
+
      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_graph, __pyx_n_s_GetNode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_14 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 162, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_14);
+      __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 162, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_15);
       __pyx_t_3 = NULL;
       if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
         __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
@@ -2393,36 +2691,36 @@
         }
       }
       if (!__pyx_t_3) {
-        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_14); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_15); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
         __Pyx_GOTREF(__pyx_t_4);
       } else {
         #if CYTHON_FAST_PYCALL
         if (PyFunction_Check(__pyx_t_1)) {
-          PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_14};
-          __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error)
+          PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_15};
+          __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error)
           __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
           __Pyx_GOTREF(__pyx_t_4);
-          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
         } else
         #endif
         #if CYTHON_FAST_PYCCALL
         if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
-          PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_14};
-          __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error)
+          PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_15};
+          __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error)
           __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
           __Pyx_GOTREF(__pyx_t_4);
-          __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
         } else
         #endif
         {
-          __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __pyx_L1_error)
+          __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __pyx_L1_error)
           __Pyx_GOTREF(__pyx_t_2);
           __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL;
-          __Pyx_GIVEREF(__pyx_t_14);
-          PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_14);
-          __pyx_t_14 = 0;
-          __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error)
+          __Pyx_GIVEREF(__pyx_t_15);
+          PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_15);
+          __pyx_t_15 = 0;
+          __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error)
           __Pyx_GOTREF(__pyx_t_4);
           __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
         }
@@ -2431,93 +2729,93 @@
       __Pyx_XDECREF_SET(__pyx_v_Node, __pyx_t_4);
       __pyx_t_4 = 0;
 
+163:             tScore = g[current]+ Node.Get_Cost()

-
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error)
+
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 163, __pyx_L1_error)
+      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 163, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_Node, __pyx_n_s_Get_Cost); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error)
+      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_Node, __pyx_n_s_Get_Cost); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_14 = NULL;
+      __pyx_t_15 = NULL;
       if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
-        __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_2);
-        if (likely(__pyx_t_14)) {
+        __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_2);
+        if (likely(__pyx_t_15)) {
           PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
-          __Pyx_INCREF(__pyx_t_14);
+          __Pyx_INCREF(__pyx_t_15);
           __Pyx_INCREF(function);
           __Pyx_DECREF_SET(__pyx_t_2, function);
         }
       }
-      if (__pyx_t_14) {
-        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_14); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+      if (__pyx_t_15) {
+        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_15); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
       } else {
-        __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error)
+        __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error)
       }
       __Pyx_GOTREF(__pyx_t_4);
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error)
+      __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_2);
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 163, __pyx_L1_error)
+      __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 163, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_v_tScore = __pyx_t_11;
+      __pyx_v_tScore = __pyx_t_12;
 
+164:             if tScore >= g[NodeID]:

-
      __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_tScore); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 164, __pyx_L1_error)
+
      __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_tScore); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 164, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error)
+      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error)
+      __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 164, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 164, __pyx_L1_error)
+      __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 164, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      if (__pyx_t_13) {
+      if (__pyx_t_14) {
 /* … */
       }
 
+165:                 continue

-
        goto __pyx_L6_continue;
+
        goto __pyx_L10_continue;
 
+166:             cameFrom[NodeID] = current

-
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 166, __pyx_L1_error)
+
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 166, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 166, __pyx_L1_error)
+      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 166, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
-      if (unlikely(PyDict_SetItem(__pyx_v_cameFrom, __pyx_t_1, __pyx_t_4) < 0)) __PYX_ERR(0, 166, __pyx_L1_error)
+      if (unlikely(PyDict_SetItem(__pyx_v_cameFrom, __pyx_t_1, __pyx_t_4) < 0)) __PYX_ERR(0, 166, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
+167:             g[NodeID] = tScore

-
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_tScore); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 167, __pyx_L1_error)
+
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_tScore); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 167, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error)
+      __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
-      if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_1, __pyx_t_4) < 0)) __PYX_ERR(0, 167, __pyx_L1_error)
+      if (unlikely(PyDict_SetItem(__pyx_v_g, __pyx_t_1, __pyx_t_4) < 0)) __PYX_ERR(0, 167, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
+168:             f[NodeID] = g[NodeID] + EstimateDistance(NodeID,target,xCount,yCount,zCount,xSize,ySize,zSize)

-
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error)
+
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error)
+      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_g, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_4 = PyFloat_FromDouble(__pyx_f_6CAStar_EstimateDistance(__pyx_v_NodeID, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error)
+      __pyx_t_4 = PyFloat_FromDouble(__pyx_f_6CAStar_6CAStar_EstimateDistance(__pyx_v_NodeID, __pyx_v_target, __pyx_v_xCount, __pyx_v_yCount, __pyx_v_zCount, __pyx_v_xSize, __pyx_v_ySize, __pyx_v_zSize)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 168, __pyx_L1_error)
+      __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 168, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_2);
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_NodeID); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 168, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      if (unlikely(PyDict_SetItem(__pyx_cur_scope->__pyx_v_f, __pyx_t_4, __pyx_t_2) < 0)) __PYX_ERR(0, 168, __pyx_L1_error)
+      if (unlikely(PyDict_SetItem(__pyx_cur_scope->__pyx_v_f, __pyx_t_4, __pyx_t_2) < 0)) __PYX_ERR(0, 168, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
+169:         f.pop(current) #These values will not be refered to again since the current NodeID has been moved to the closed set . This therefore reduces memory usage very slightly

-
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_f, __pyx_n_s_pop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 169, __pyx_L1_error)
+
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_f, __pyx_n_s_pop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 169, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 169, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 169, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
     __pyx_t_1 = NULL;
     if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
@@ -2530,14 +2828,14 @@
       }
     }
     if (!__pyx_t_1) {
-      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L1_error)
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       __Pyx_GOTREF(__pyx_t_5);
     } else {
       #if CYTHON_FAST_PYCALL
       if (PyFunction_Check(__pyx_t_2)) {
         PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_4};
-        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L1_error)
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L1_error)
         __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
         __Pyx_GOTREF(__pyx_t_5);
         __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -2546,31 +2844,31 @@
       #if CYTHON_FAST_PYCCALL
       if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
         PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_t_4};
-        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L1_error)
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L1_error)
         __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
         __Pyx_GOTREF(__pyx_t_5);
         __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       } else
       #endif
       {
-        __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 169, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_14);
-        __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_1); __pyx_t_1 = NULL;
+        __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 169, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_15);
+        __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_1); __pyx_t_1 = NULL;
         __Pyx_GIVEREF(__pyx_t_4);
-        PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_t_4);
+        PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_4);
         __pyx_t_4 = 0;
-        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_14, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L1_error)
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_15, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_5);
-        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
       }
     }
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
+170:         g.pop(current)

-
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_g, __pyx_n_s_pop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 170, __pyx_L1_error)
+
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_g, __pyx_n_s_pop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 170, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_14 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 170, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_14);
+    __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 170, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
     __pyx_t_4 = NULL;
     if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
       __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
@@ -2582,36 +2880,36 @@
       }
     }
     if (!__pyx_t_4) {
-      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_14); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
       __Pyx_GOTREF(__pyx_t_5);
     } else {
       #if CYTHON_FAST_PYCALL
       if (PyFunction_Check(__pyx_t_2)) {
-        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_14};
-        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error)
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_15};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error)
         __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
         __Pyx_GOTREF(__pyx_t_5);
-        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
       } else
       #endif
       #if CYTHON_FAST_PYCCALL
       if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
-        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_14};
-        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error)
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_15};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error)
         __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
         __Pyx_GOTREF(__pyx_t_5);
-        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+        __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
       } else
       #endif
       {
-        __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error)
+        __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_1);
         __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __pyx_t_4 = NULL;
-        __Pyx_GIVEREF(__pyx_t_14);
-        PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_14);
-        __pyx_t_14 = 0;
-        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error)
+        __Pyx_GIVEREF(__pyx_t_15);
+        PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_15);
+        __pyx_t_15 = 0;
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 170, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_5);
         __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
       }
@@ -2619,11 +2917,11 @@
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   }
-  __pyx_L4_break:;
+  __pyx_L8_break:;
 
+171:     EndTime = time.time()

-
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 171, __pyx_L1_error)
+
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 171, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 171, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 171, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __pyx_t_2 = NULL;
@@ -2637,63 +2935,63 @@
     }
   }
   if (__pyx_t_2) {
-    __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 171, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 171, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   } else {
-    __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 171, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 171, __pyx_L1_error)
   }
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_EndTime = __pyx_t_5;
   __pyx_t_5 = 0;
 
+172:     print("[A* Time] "+str((EndTime-StartTime)*1000)+" Milliseconds."+" Total Expanded:"+str(len(cameFrom)))

-
  __pyx_t_5 = PyNumber_Subtract(__pyx_v_EndTime, __pyx_v_StartTime); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 172, __pyx_L1_error)
+
  __pyx_t_5 = PyNumber_Subtract(__pyx_v_EndTime, __pyx_v_StartTime); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 172, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_1 = PyNumber_Multiply(__pyx_t_5, __pyx_int_1000); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __pyx_t_1 = PyNumber_Multiply(__pyx_t_5, __pyx_int_1000); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 172, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_GIVEREF(__pyx_t_1);
   PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
   __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = PyNumber_Add(__pyx_kp_s_A_Time, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __pyx_t_5 = PyNumber_Add(__pyx_kp_s_A_Time, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 172, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyNumber_Add(__pyx_t_5, __pyx_kp_s_Milliseconds); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __pyx_t_1 = PyNumber_Add(__pyx_t_5, __pyx_kp_s_Milliseconds); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = PyNumber_Add(__pyx_t_1, __pyx_kp_s_Total_Expanded); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __pyx_t_5 = PyNumber_Add(__pyx_t_1, __pyx_kp_s_Total_Expanded); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 172, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_12 = PyDict_Size(__pyx_v_cameFrom); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 172, __pyx_L1_error)
-  __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __pyx_t_13 = PyDict_Size(__pyx_v_cameFrom); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_13); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 172, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_GIVEREF(__pyx_t_1);
   PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
   __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 172, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = PyNumber_Add(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 172, __pyx_L1_error)
+  __pyx_t_2 = PyNumber_Add(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 172, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(0, 172, __pyx_L1_error)
+  if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(0, 172, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
+173:     if Found:

-
  __pyx_t_13 = (__pyx_v_Found != 0);
-  if (__pyx_t_13) {
+
  __pyx_t_14 = (__pyx_v_Found != 0);
+  if (__pyx_t_14) {
 /* … */
   }
 
+174:         return FindPath(cameFrom,current)

 
    __Pyx_XDECREF(__pyx_r);
-    __pyx_t_2 = __pyx_f_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 174, __pyx_L1_error)
+    __pyx_t_2 = __pyx_f_6CAStar_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 174, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
     __pyx_r = __pyx_t_2;
     __pyx_t_2 = 0;
@@ -2701,11 +2999,11 @@
 
 175:     else:

 
+176:         print("A* Search FAILED. Start:",start,"Target:",target)

 
  /*else*/ {
-    __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 176, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_start); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 176, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_target); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_target); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 176, __pyx_L1_error)
+    __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 176, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
     __Pyx_INCREF(__pyx_kp_s_A_Search_FAILED_Start);
     __Pyx_GIVEREF(__pyx_kp_s_A_Search_FAILED_Start);
@@ -2719,12 +3017,12 @@
     PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_1);
     __pyx_t_2 = 0;
     __pyx_t_1 = 0;
-    if (__Pyx_PrintOne(0, __pyx_t_5) < 0) __PYX_ERR(0, 176, __pyx_L1_error)
+    if (__Pyx_PrintOne(0, __pyx_t_5) < 0) __PYX_ERR(0, 176, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
+177:         print(FindPath(cameFrom,current))

-
    __pyx_t_5 = __pyx_f_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 177, __pyx_L1_error)
+
    __pyx_t_5 = __pyx_f_6CAStar_6CAStar_FindPath(__pyx_v_cameFrom, __pyx_v_current); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 177, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
-    if (__Pyx_PrintOne(0, __pyx_t_5) < 0) __PYX_ERR(0, 177, __pyx_L1_error)
+    if (__Pyx_PrintOne(0, __pyx_t_5) < 0) __PYX_ERR(0, 177, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
+178:         return None

 
    __Pyx_XDECREF(__pyx_r);
@@ -2735,7 +3033,7 @@
 
 179: 

 
 180: 

 
+181: cdef FindPath(dict cameFrom, int current):

-
static PyObject *__pyx_f_6CAStar_FindPath(PyObject *__pyx_v_cameFrom, int __pyx_v_current) {
+
static PyObject *__pyx_f_6CAStar_6CAStar_FindPath(PyObject *__pyx_v_cameFrom, int __pyx_v_current) {
   PyObject *__pyx_v_path = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
@@ -2745,7 +3043,7 @@
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("CAStar.FindPath", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("CAStar.CAStar.FindPath", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = 0;
   __pyx_L0:;
   __Pyx_XDECREF(__pyx_v_path);
@@ -2755,9 +3053,9 @@
 }
 
 182:     cdef list path

 
+183:     path = [current]

-
  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 183, __pyx_L1_error)
+
  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 183, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 183, __pyx_L1_error)
+  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 183, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_GIVEREF(__pyx_t_1);
   PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
@@ -2766,40 +3064,46 @@
   __pyx_t_2 = 0;
 
+184:     while current in cameFrom:

 
  while (1) {
-    __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
     if (unlikely(__pyx_v_cameFrom == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
-      __PYX_ERR(0, 184, __pyx_L1_error)
+      __PYX_ERR(0, 184, __pyx_L1_error)
     }
-    __pyx_t_3 = (__Pyx_PyDict_ContainsTF(__pyx_t_2, __pyx_v_cameFrom, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 184, __pyx_L1_error)
+    __pyx_t_3 = (__Pyx_PyDict_ContainsTF(__pyx_t_2, __pyx_v_cameFrom, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 184, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     __pyx_t_4 = (__pyx_t_3 != 0);
     if (!__pyx_t_4) break;
 
+185:         current = cameFrom[current]

 
    if (unlikely(__pyx_v_cameFrom == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
-      __PYX_ERR(0, 185, __pyx_L1_error)
+      __PYX_ERR(0, 185, __pyx_L1_error)
     }
-    __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 185, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 185, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_cameFrom, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 185, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_cameFrom, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 185, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 185, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 185, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     __pyx_v_current = __pyx_t_5;
 
+186:         path.append(current)

-
    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 186, __pyx_L1_error)
+
    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_current); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 186, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_path, __pyx_t_1); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 186, __pyx_L1_error)
+    __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_path, __pyx_t_1); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 186, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   }
-
+187:     return path

-
  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_path);
-  __pyx_r = __pyx_v_path;
+
+187:     return path[::-1]

+
  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyObject_GetItem(__pyx_v_path, __pyx_slice_); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
+/* … */
+  __pyx_slice_ = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_slice_);
+  __Pyx_GIVEREF(__pyx_slice_);
 
 188: 

 
 189: 

 
 190: 

diff --git a/CAStar/CAStar.pyd b/CAStar/CAStar.pyd
new file mode 100644
index 0000000000000000000000000000000000000000..3bd0e25b41317f632e7dc3cfce4aef804b8cbcc8
GIT binary patch
literal 151577
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
!1u^t67CZTq2mN+S!0xlw*m8vnpMs#za
zSz)F?!}R3s)4vd2RJ(^b1$1uwS+EXxC6pq}MSzUpL_fY9ds5U)kypCfeYR!t{z)kN
z>^%(B2vB^o|Fou)a`(FB_+;P8a(W))_eB|!NKPR61K9-YZbeId`5v0kvmg6o
zyfsaiMJ-Z;TMWVJ&z7jm9SYB7gT}OV2coej0!v@ma$t{G0njm1>ExtIK!q6#^`WfY
zq#nUjS%*CZKU$l2b=qWb4blWtLcxT+;&zAHRX9@v8)mLM11-L7AOEEyl
zejHg3aaZV5)7hLG^qYb=PyCed{R~a2@g4;xw1>gd3Kt=#njfe_Ls2Ljhh|Ep@aP`{
z&UrqeamVCa4zjCG8t@kGn6PPccYzWSr4X{sRYZ8~?vS*dGXG34zjhUNdOz!bvK`fO
zg@RA^_<*_j7RT0LXuGr>JxN|3{u@*PJPU^kupR`7h`Q4XQm{tOIOgCtyY1kSXC52e
z0AUD|I?n1M_Gk10wQ)k#4Hu}f=
zX-x0JEaaaU%mb@}Sim61d$KOMY5!CDXCvrl4$bws}{!7@rvfj
M8%A2zINM7`=
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
De&(qq

literal 0
HcmV?d00001

diff --git a/CAStar/CAStar.pyx b/CAStar/CAStar.pyx
index 4b59077..20d67ba 100644
--- a/CAStar/CAStar.pyx
+++ b/CAStar/CAStar.pyx
@@ -2,14 +2,14 @@
 #cython: boundscheck=False, wraparound=False, infer_types=True,cdivision = True
 
 
-import os,pickle,heapq,time,math,hashlib
+import time,math,hashlib
 from AATC_Coordinate import *
 try:
     try:
         import PriorityQueue.PriorityQueueC as PriorityQueue
     except:
         print("PriotityQueueC not available, defaulting to pure python")
-        import PriorityQueue.PriorityQueue
+        import PriorityQueue.PriorityQueue as PriorityQueue
 except:
     print("AStarPQ not available")
     
@@ -61,8 +61,8 @@ def AStarPQ(graph, int start, int target):   # Set all g to node_count + 1
 
 
     TargetNode = graph.GetNode(target)
-    xSize,ySize,zSize = graph.xSize,graph.ySize,graph.zSize
-    xCount,yCount,zCount = graph.xCount,graph.yCount,graph.zCount
+    xSize,ySize,zSize = graph.Get_Size()
+    xCount,yCount,zCount = graph.Get_Count()
     
     ClosedSet = {}  #Dict to hash find closed nodes
     OpenSet = {start:1}
@@ -86,7 +86,7 @@ def AStarPQ(graph, int start, int target):   # Set all g to node_count + 1
         OpenSet.pop(current)
         ClosedSet[current] = 1
 
-        FriendList = graph.GetNode(current).Friends
+        FriendList = graph.GetNode(current).Get_Friends()
         for NodeID in FriendList:
             if NodeID in ClosedSet:
                 continue
@@ -128,8 +128,8 @@ def AStar2(graph, int start, int target):   # Set all g to node_count + 1
 
 
     TargetNode = graph.GetNode(target)
-    xSize,ySize,zSize = graph.xSize,graph.ySize,graph.zSize
-    xCount,yCount,zCount = graph.xCount,graph.yCount,graph.zCount
+    xSize,ySize,zSize = graph.Get_Size()
+    xCount,yCount,zCount = graph.Get_Count()
     
     ClosedSet = {}  #Dict to hash find closed nodes
     OpenSet = {start:1}
@@ -184,7 +184,7 @@ cdef FindPath(dict cameFrom, int current):
     while current in cameFrom:
         current = cameFrom[current]
         path.append(current)
-    return path
+    return path[::-1]
 
 
         
diff --git a/CAStar/CAStar.so b/CAStar/CAStar.so
index 170cd4be509ec258b82473c31dd7fae6b72b5d76..8df8716b297c4b10beafe1b30c518c8185edc4cc 100644
GIT binary patch
literal 122796
zcmd440i0D;x&OV-%o!Mlkq$W2L{l7X%&A5_+N6_V9%Rzd(2jzNH8&2z=wKs^Fd7=Z
z4KN7mAcKsE334iKk$G?9&58_dQYtdK(G_oG+&VLdEjSXPVvXtH@+Vyyu-@=`1i;ywq`ao!~el>~nIRQl6LcT-Ralb?JH3
zUb}(*RY_Wx|Lk(Nbq=@3{HcD7OXbSA3b`)2>`Etk>cNKFH?^PJ_`5G&HuB&#KmPS)
zKii~di?~FK>fPBKiz+;iiiKUzSqksbViv(vG~DXp)=OmJ;ZWD^Q9xr
zBlDm7P$>fKpYB^izUmGYtj{Bd7==)*_|8h@x3>MYz3Dnp9g3$8=A$*fU&%YVE
z9|)B{BlP^y5I>FL7-~G7J1O-1+adZ_hVHKp(O(d1f3?Lep#IGc;ja(#H}w35Pfir_=>2i1e^-a@H-y^n
z4&mPtqW{9s{jN~?lSA~(2;KiUL|;#cAA#adoM%fz?d=KO-w_xsPw~@5`Jb+I#HN5od9w>W_AA2$f$5zjsn!-5N{%t3uBw
z<>4D|Y_dPUk7ItX4?TY;coMB%r^Y#@&b1+Y&dizD-#CBX%!RG97PQWs>CBuvZ*HqI
z^E!Yt^Wy23&YaV@pz->-3tJl(OuuwW^Za>@(`Q}V+~_?U{>jYQi)IPItme75QSg#m
zW?o@2Olh9AaAD&@XJ+cwnU{fTTI+(FXSX`3TkGb|Zk>5q;}=MN`q~>Bxw&Y{%;^he
z&HnsQ&czF-FSr?e)K$XP)$N6|niu-_sar2xFzd!fi|muP%xa#g|4im57tvc$Ku@om
zHMd!~rZ+8UoHb`!>#WwsnNx0Fu%L0C=&?jhnbm9x&79KIIQ#QgG|s+x!NR$>G@9(x
zt)E=5VCJW1leeI84s~=pt+5rl=FYp`kQuBsf8Nx&H^N!UEt)-Z+O073MrzDoFw`1d
zzH*-5=_}{Wojrd}1S|(mHqkJU#H!>bD4Qyw;PLx;XvT
zmPWsWm)(5hwT%mAPMr^9Qnw1soV?K93Hu<4Mh`A(Y`qxnTs^n7$wx5#=9cEhnJJ6i
zW3<;}kBph0Y807zid9aD83;F!eh#;A{U-zt!ybISaAt+VFNlO&9+
zCbzUS&eNzIqEk9W#)UV}n=SqI`7kA%abffPS*_@2-Ta$n=+wGVC^1;|&0~9G+Olbn
zU!Lv`mJ^*8QGjVvtS;GcF?mja(ktf9ZW>YzTS8Jr1mdgBx%B4d*10Xsw~{l+kZB8%
z*36)eS<*aJus5*Z@4J$z`7PkM7^^>X%4F=IF-X&9E}Ykb9c#UgXBsG1HDdX^L64lS
zp0!|}(a8&LZEajQbI1@)o;Sy8jIZUxJ+s4&ZhK>mHipC`)fhB&B3XJcNBzuKpTRPA
zG*7{fw>F+dIlt+;Mp@9IiuJP=O3{Yc%;ZHX`T#_UOjX>>q7;Mdq7AwAKjW^xg
zh;b2vtac62XfuLZVUf(7*>dZmnKybyXzs$9H=?+f_cMoNU@BUX$(~+3Z%*SPf3Pb<
zjGBAx&8>qLU`Uf0^g|{?glJs&Y{AM*zp!?&Lzm8KX<@>W1zqSg&%O3~%+l!#=bwJ2
zZdzK+^r-uU?q@4?wllMF&aBp1Os3Z^TvV;5
zhW!h;TjqKAe%MO?zt2=J6ptGI--q$Zl|7A7pLwQ!P!Nek;NthaEgg((ZCTR6kQW(yZt*kNJD!fh7z
zSh(B5Jr?e@@PLJry1ahXTi9S>+QJqKTP#3wK+%$HD^^
z9<=aH3!VEsx?&cVSy*Xdm4&qyPO@;Sg((Zu7S6G-)xt#7FJt0$-<!3l~|q*uoAAJ1xvu
zxY@$TEZl104hwf$xYxq0g@-LXVqx@tuRp~WmRne1VYP(`3zHVsSvcLo85TBK*lgiq
z3)?L0w6M#<%@%I4aI1yeEZk|~E(^03?z8ZSg-0zcUhnm%)WQl2;}#|?tg*1p!g>p5
zSlD1;vxO}dwprM2VV8yLE!<+^BNlG6u*bq(7VfripM?i3JZj;a7M4C>$Bl(?3o9+G
zv9Q*{dJCsoxY)v#7VflgmxZNY_VCwQILX3#3#VE*!@>p&7g?CGaI=M5EPTwutrl*x
zaEFCEE!<_{UJJ7p?z8Z)g-0wrYGL$2tG5=GTUcRX+`?)L6BgE3n6$9Y!s!;yu&~L(
zW(yZv*k)m;gj7BLyY>xk_L&Sg(XaIxd;
z5o~sxy@EG7PF8S%b%Hn!^@8P&Gga{2j*}9c;5gF-
z-{Uwl1leS15M-YyE%-jinIkySahe3{HXCgnrvyh+QN06T&-s59}A4PtG
zXCptsbC91PLC5WaA47hE=ORDBk0U?9Nyty|Jme?%3FIe;zGMZbAV0x6$2lPQNyj-T
zcp>|Pf)_c?5y5)LIVyOu$Gd!5PS3@EYVV_!;Cc_*vvH_&MY+m`47B*CKzx*~njT4)PalME-);BY(jr?U_ic6GM+@RM%U!UD(n>FT~ypXunUdUc!Yr{jTic_1ANq>BS-Cy+k+$`GEzf%Jhu
zIvYsu38Z%g(mMj_ommB@IR0~5J+bO={
z=fd7bVr%yo#Mkb3VzaVi5^ML5ojAYuE8{Y~1x~6r63>i{#Fwy5n(8e`kWOgFcUmqY
z+Or$?T{SS!AEBM-;f?!t+*sgr^I$XABV30kpZ21Y%=9`vnOtnwrG1eWaHc8itm;d&
zb-Bf{Red$tF1Iwks;@AW=}q*syS30=Bgj>nSmipCSH1X?zYn~WAYbh=rA{b~Z6tkp
z4)|0wf
zCR_Gu#s0FtkKMm^>b2R}hejUy*=<`7#r{5Sf9HgehaQ?dD?9nNQxEOG;pm~Uua4c{
z$@88Yt~>Nl!L`}_H*7tmGBNU<8(uiH|F)xtvbSA-Xxyvg_OFf1&bF1@aj5g$5rjD*4^k;)lPyFBC7C4SE4eybZFN=SxRWtgM0qEk
z$!XkGJ8RvCRWFh1=ZhHZk*`p*xDf-
zLnl1jB0ceSD_>6}gIfBq{^kN_G1t*4r@eUK%uTMt*xNU2ld%gU(yOzjaoM;lawi-5
z)*g^9V*}lKYx`)s#Mr8&_~7*4Bf3e8Hlr7*Ozv9pyH48Vc7eYj4$kCK>`|9n7+beL
zf_|#+i+NrKuk<_`TZ=td>K4;ROXBHVEV0z3o&IYrPhN!|;`v0=R;te(7$`}K_V|5<
zZftR%6JPF@rm!2GYu#w#0XNyAeq601UK2*q_mOdI53;yKIOsFWzkWwJ#;Wh@_R9ug
z*WFm+UU<2zPc%g0>-HD4DgR#Rnbyma@)_ZfJcaWd+3eVT*pKyYEWXB_1MkmDOnE92
zzo0J`U*b+VGxO_ZiDkQ3qV{iaXv=)#-4?Bp*y^ludpVF;M#9(0BOWE8Csu+T=d0_L8Z-QJt%^EHfv>
zYc{#xM=lkWo80@xMvRU})7W`r+Q7UzBfbopm$^;!QSytaemd1xnpij9NiG}zesJvj
zh=(Kl{!Q-v7Du@LZ>S%OtwTT7xj#k@%u7!rgJ%n!%O#6vBk_W#q_f|ay^F(-*s?xP
zC(wuZI=680(*4D;JCM^q=G930+hY07l6t~a=-UeI_0ac?G-`rq_;&NBCL=WUGh2;-2@!UXl>
z6Sf~!+-J_(8t7HTAKs;JcTTdOQEy4%1_4f4W_f~eFX8hKJ`*CpB
zf%})o!Tk{alz1l_vxmB(^K$Bz*}5_6{^~e&Wk-&rHW}U*rB-L>V3)dV`(5DJi~aav
zJd2(lrE%`WJ6+K%8!DP9
zHldic!_SaokmkQIXKC(#o&4=-csUC>ie}bPkp%N1<4FB1K!3$6;ZK2A>kZ*8rX95r
zfv3f+iyZ6=YpXtoIigrL#mv20BP})k_2x3oy+I#2BR(8R(YDqZYNG*OX-!axuOeF-
z6E5as@yweCmbjIy$4nd8GtJMe-FQxaWwXdDG;Q2#*I`~8#n2sz-MjxK`g?%>s=c`S
zV0{G98K>{`xi>-ERfZ1M0MHOMGfveJQI!b
zQG)o&ERO2`Mf>|^dVP{lzL~z(gTvF~X}RI(mk&IZGU6*?Va)-(#uvn&eHZug9qU*#
z$zSy3x)i@?ExMea=k;Mo2C%iH9-G<+Pom5w-R~2fAoWIv&e{gFYKQkKw1pGS8MepCgWtIWZE8Fk~;!jithwliZ_wwKRNqOa+?BbaliGVO
z`_+o4Mmo;(PK@<(VvXg~68!G2ebK}tZhS?UA
z28SN;TxCq($yb@9^e39Q-<2=p>%?p5f$sGzi4A-81CiV$ba#^EfGv~$N)B!Cq?+f4
zcwWVG*~#GZMLgg2FP`sPT^DgGxZ=r(b6`rud6UZ_tr&*pRMD+uyN+gU(Yq|MEX&%c-{eh3=6@aNPeIEFXVn4q^%=>I`Xii;
z2Z&b~pY4y7e^&YUS8pJrO6aeQ$tK-5xURUJ=Q+x)Y#3S_)WQ?34Jv{DcsU6k7Be=y
zHqayVrkHq1I3^-{JT=bx7=7{VGqxEUIuf~;I;m%o{e;4?OS9g1V;z`WV#b^Ln?b*P
zeGbM|`k}A&x`IJkDvmRDE9}@U#=dCHwB7Qgf-$UhmBvi5u_J5U$KM#}Z?QHbVezqc
zGyO^o)2|Mm#X|j$4O8ylDJL5eQK4rVal=PR8kWvS2Ikxsg$b=l~cSetUqkAmDGpI)elpSby!I%
zR1SN848D^oS8L0$tywb3=*F}hTcXcL)5$)q%kc~Pl^;nhXWqE7ceLX?9Cf~DWFtQ)
zOrv5HLH+y_`l&Yl^Dm4w#zn2@a59S7nwW}j&*o7sSZ`10{+ZDIw$S~*hwd|>`+Gz8
z?V)@5^uhL=o^v0bOY
z3ytYh@KXgft}mgU+V|s24rMiW9VOq7AxF}R*WlZkxho~vl*q?CTecMY#uoGhe;n$W
z*3JI2D|zORz3{UX&;0Qgepb&je~cA{aH>CwW$NT#^vza$K&6QbK*qn=#v>+
z`RfHgUt>^yyw-P$tyY*hZ^Pi6*K>5>CC!afuk?IktxH=cMV#Z&FF%exj1ANOPSJz^
z=lkgO&|m-m0sZX1^d5K%`a3QC9n**C-}mu*B4|}h%G9|AJJOI*Ow%E
zDm{^JsThDC!#f)~{W4mc`MMM=a~fq{Kvt#nMS8UR+=#Q6OMTIvz;Jzup!;Re8y}`G
z@&CiV#E(N~VW2O`D?D1$ZDV(?X@wf8n%V>>!7_d)J|&pf8Mqt*w({TKPO;e9&kOewy50vol>dA66+
zGJP%1k6!Teo+NKu;@RG|k<0SR4fkAi{e0=JNi&z`ULWY+D|(p|%{X?lxnA_J867U|
zS?e~T2N9=>b;>GuLX6(%w&rke-Cv46gyX2##AEs*J5-Jy$EjbK=o%aw^J!b{9Y}dH
z+KWGssf{?DTrJ2-^Z3ftCik6c2O71ODuR!SKN%jHeH@KjV({?ko9YYe6h@A*@$4=3
zk6>;GYwk@wV=sZcl3Hj{zSc1E@z2sT){>q~?l7`EWcraGo8AY$NuMroGBltu*_!oq
zN#_G}4vAHv_Gcy(01ch!5cehGx%?0LFCT^HvK0mKhX&`gV#?^*={!^4yt$ywThkaj
zbwy5m6&{tVr(EW;p;(M~k)}_T$VF>e@yggT#+jI;@#Af?jkZCk6J-y%P=~nd(S#71vZVPSC
zmEr)szoPv|z@>Hjh_)eI|7vj&vn`RIv*FSLXWNVdr-o}g`hED*r@dH^$@DH_udV|5
z7EWH0El;l^{*p2A%1DZ~I%P*!5y$y}TiUjYeY#a{tYsCkj8(4oJ2l3N
zmf@%8=hrEXjzoE`a~cu$dL?6y{xJ@)$?S7-ED(S1JMi<09P23fj_-%PjTD@i`?8*O
z(ZW=tP2Eo8D{8)c(%gH#qwXK&zD%|R+|8t8@m+2@UeK53zPP8e
zDBjaKzRZrlY3BK_hn~mR6vgp9iNyC3E1BTL9|X_6?$>QU8GjEix9LUnN&R~cKEFxX
z(ecJ?jQfJvUHhGc>P^f22l*;Py?z4&{Y;B))|A>Oly7`s+$Q$``)=|vE?3_ZqcV~wdfX`jl9KUybiE#>obrMVyC?-#i*)4UCR;33`ye-ef8
zhrNX~{7J(f=+yHI%yanTKTp7)#G3Ji&Q*p#>U&{=e#bYuh4H)gYaNMQHu`!Nw5rce
z&qnrQgzt*n*WgDndwF*dkBidRD1G*98|z2nW$OD{>b+n66z`eC{klz}B_5Df547~G
z8Lu|(qFuqq!7pBRkKN>MhWUzMpM(GvfTf92z5WkHbi?<%U`)rvkWwOJRIiE5+DI@xJP-e$4WzMF|W425;
zWx9tca~fqf*fQ%WvwoN|m6U0xjA(A7OxrMJ-lMiYRp7i?gBOBLT2##p`;mw20KUlHNjk
zJ?V1N?W8+@yvddQ)B003v>jQ=7PcX~N^D_qH*ua$bT_?We`y=@Y6^Q6CzhMV?qu)j
zi)EL(g)Qh1G224tbG>I0%PqCzJdPZ7Zm*nqxGdY{@~otod9IYWk?gr_XE`=?w8lne
z73W;AjVbIYx>}Z9#rXtmZV&lfi_sIcq4==QlIZ-1&XXukyo_@s{<)Iid67!1%jM8B
zg*xn$;MQK58*AwLOztG?MKR+^G^w8ENS{`XVaZA{ob%N-a}o0t{mJCy;}t>UFM-A2
zE+HmeOkL&q^?%AU^{X_tyifBL2K}Y~w0Waqncfomru_dQU-O?|PqZ+0`gdM96kjeq
z&5IprAF57%4)#EH2>V$gpGCflzowSo@_%a|s*ae|+uetXf70{Ww7;@44Ik+a6^yT4$a6ha>P7AIS6t{GJcjZv0&BV;(I8*s6ATw
z1lrG#58PFi+s9d@kAmY0sDgLUFsFRgV`@OP!H
zH{aId>`DpeFAc66Y~E_}G``AD^4c%%!PbMXz_B#MH-L{b-{5Pd+~K$v^He#}dyw%O
zE_)_r=Tde%WmQIHH9v>Tok}^y^heUS3oSjw@Jl+d1*RT->oWGhr^V~ryQ!zxzv|W6
zdSAAE)7kF`dh63SW0-bFQGcneUuEmxPyH-;QDn*ap#E)BIGclgS&!{*VJ_F4-T~ak
z{M=-(Zr~2)V$HuC;OX199Q&^IWeaO)@D!$@qm7si@|Ip-=i7;7Cb#XQp5HSyCZFl@
z96D7}m&MnOf3B}8;#{)y%q3Z!7eE(#@n;{`SYti&G
zp4r()e$|oP*|RL$v4*;x4^a0S#k8N-Jgjo;FF!sCUpms$@f7>^y;F#hci46c$!8rq
zq2s1C#uxDH_zJhYXp=iK#(aJXGD)y^?yTRh_=o1Mze-!-wZ6yG{I$Mp&lcN{4^Ss9
z`jT_{MAy_#>DM*6&E)GWsPgJE=wQz!eR|iU6q?UQ_d3qJ)951eXm8x;Vgq{_o-Urw
zJavh5F}@64yu7y>or)x`&3^6tW!a|_OS8)&)I|nS^h>%}2u@&sSe{yA?bKYsIPqzl
z3Eh&3d^wHvQIc6Y)606RzXYgrpDL^UwL<4Jz1Px@J08vSc91{1`_616bC>C7G+l=n=Oo8%UFSy*qzyvk)>?8>;mV!`z6<)
zOg~}t`~ee>@aLS5QEof7emnMA?H0t>@1KNyPsY}|_kr)g-v|0@oK=0bu~mJO;;Z_e
zAW!-)-4FU)pN3B3CuF3npUIVUW+Ek`-O2P`BOPO2`3Pe&O#+e}wzS=aOs3_|
zP~T~1q|7af=X(sm_OB?SblxV#tzbl&L{Uh3STG|XA
zCw{*>l{4A+(AoMPWE@}N)^YymSJ0)oME&vhn!k*%KSZPQ?ub0FU%C
zvBVO$AWa_YbIsSRIi8V^D?iygTgCdBSnl!8R;hh#+2FetQ=}izruxI3tx|kQ{BOdR
zD1NyMe#_7Np_SE6@s+jCRLUjW?lon#&z_?E$H84iepLh<>IY*m_)!~TKaJeCptsW5$+jQ=ruh#)ROd@RWpTU#
zzD3~hVmU)P{MzAxmxyoni|>)RW@G+1#@8yC1I@*fHn5${;6x&{uxYtv(
zsr{m+bFc&G(q8Eq*9NYh$?PF<$-k_BFL58PDA(o+d`aF-X+q~T-)qk=jehxhr*?w6
zS8wJbPZz6<-m$ht?~2j2O5_twd3skV9c{^+7(W@kYw0X1lx%wP&+`?uNrvl<-Z57^
zqxtruT0ar5Io>-!#mtpqIlm7-%v<-nNobcZkmUIs^lZ*pWNmdSsArJ?-RR^qqp%gywYNk6@pMgn(0mu3
zpMP%bO#VE#9T|U5eL*kr!;PN(h`g=RL8}*=^c>sgpcnGR@WcBRbKDTp->WFs%`@cO
zhwkM@at2Z3_gmyCHe!4r`nSupm+Ad)@*AwK-(lN$(&{>UDgB+MoOc$on)Yf!?VZc>
zpHS{_&9OS#F~K_%xe{2#RnDb#&d!g~uk;mt(YsIkV;A}<`w>ZE|DaFtK>1Sbz?EDb
zTt6(5JzRr-HZ8XxLVO>eA?B>%{kS!5dne@_ubk#ufB*Tv-laHWr&~e&0`x-h8^ve7
zTIBS1viA8Z7rt)4!?l9+w#2SpmF*zr9mG>-@sx+~tOd`5)cdypo_j4Gl|5MN*~Lku
z3(@06J?LVB_vd0-3+vpy_l{O6>o)8JXP*n0$S==ji?l~K1wC%V2f=<|LkiDq%NBR*
z?DO5&Eyel%@!98s*xd(y`KN)Gnr1NfrB-LRr|;uEjQhNOV9AvA7V9bdUU2*P!?YV^
ztvm_3>sgaYCR#6UkF9mbjnIBfruQt3DizJ<C6+f|{q+iCk6`8_O1!FH^a8)+ubJa6>ARK+;5L``bUp&`p@S2
z5A5xuT-{vSD>=-&o`qTVfzY`FPqWW^qGEiV`?VKUjO|bie-CB$DCR&6Kx+-zChZ9+
zwsETZ#j_sDJQP?j+}bm=9`V;AnZix(t=QBJ2A78?uKAHM(uJQ9z59uSX5W)|uk4+_
z4*fanwkPAeIDfROcj-CH%skN=%5xI4`!s)4pvw_wVXm3A-;WOoH*sfzR
z()I(;8HZl=L;cZN3gH%xg^3@%AUp@j3%02_W$rL-D!<&eIg2(o2ioLWQ3Gvm#drHM
zZ9azY=C`T+rC^(8&LXcgDcdtWw^nOx_%LL9+TYUlTsR83(~id2;v{DzG|m!htewB2
z_jL54+4!1k%(~~c5kqSn`I@(Aj!AoVUOuUOP3c6^_?xVA{(&ueafJ8ox%?Y*F4x*2
zW9Q$d9rA7c-eKmpHnWz`*NZPAkMMkOT3|lV-gj`kb~1jR!xjZ?({9agj2D0Wyu`i6
zPZGHX$50Jp=yrULxm>>A@+H#S63?+;#aN(Da6S8>03F-$+k$j-LC2p$bQ}uN@pnr{
zU5JiLEFDd>&3TG`{N;YpG5svwcbrt<#JLWByufM4uxicHeJ<~xvWD&;-BVlOq`0!I
zXS8N6eHZ_|oA+EoEYhH;L5WpN0~BU9GJn!EazH8TT!l-Q^A{H4aC*L
zRec86>BL7)D{%Hz^Zx0Fc^8!?{58`7(mOuLxgV}axYl#+s-g|>6n_A^PT?8XBb3`-
z#5=aYZG{o1=l#TDqQvlli-6*}_!8#%>FAC7N5*_2)tBJ;et6hx?<=|gJY%2&oz5sP
zo$C94xZj?w&Oda^j>@ZS-taV=NA@lEqIrJ=V!Xlr21Bq
z-fr=4AYGik+f|#(Y~HuYtD8L0#IST;N$bK5_iI^=Ly=kJ9X)j7krVfy
zdfS#mv2&e6T~E!#1&38(gO5%rNl>0f~E9trIyN9|8(^-9Q
zq_bqip^I*N^fG<3u-DcvQzm^Nl(f551ngy@f5reZzk!UwbxPZi=78etY}1>a}bs%Cm0#zkFQ@dPlo04
zGx9c^HPQI(Gdi`-UY)Ip6Q9R-n~t0w<5?B=PCVK_ewXAmQJiW
z=)LD2mmh?DO7WK&3Asw!hdS9^od;r%*z*zfosb9F)4jvJ!1n9=C3?RMy`xN%qi>b0
zayKXMb!$8Cb$5YZeqq5F{BY!{HAgXVZM~yd+OooR+A_H$u~6C7GN8^L)l2T?Eb85E
zqFZ^aBg{Jq?c?QBmba~NE4YGZDJ!|J;fjO1s*`6XZY`hoPPdx;NnEvDbzJpaQ@K)H
z8=x;md-Bn=FS-TW^*;JlOe}NX3DVX4eWF(wbFmtahmW-BtlfIo|JKP9@S%)nnpesz
zDU;ONf%7cEwL_=Y4iC_OzN5j~L1UzdcC}Y*zGuQ%5$(gR9fo27L+b}4Gu94@#f0@`
zFSLeji1Nhi)$A`~adPzz^SkPY`uQ8mX)M+wSJAo&y^y{Xe{>>quXiq1HoqHwX&n~@
zM{wSG1zyxs{&vY9TU5<+%|re=WLq)okfiqHr{{jaxG=szo5p}-CSO2%-Ac399h!S?
zqP+O-uR|8mmewI(P+Og;zN=}gGk6?0SRJ}SIH)tjmS2pHY*aiM+B?A~
z{AXCciB|1f_(EAn%hSuY6#fi-n-#rx3@=~W?o5?-xTxavpL)sqo*y@8!dZE`DUJ-Ow6~G{LyRH
z?$_R4a4xu<{aM*P=AGV~OyBZlcmsA%w)oR8dE@aK%4l56hV1VrFPZB5PKm~Je!Z6&
z)B5($1`}UGC%Y9(o7TIReL~rgs&3{q6L({7qW}2V$D9|a`OHN00skPiI@=w)&s{Hj
zMSBm7^K8P0EKQ#~QRBF4&?a1bqI4FSqq7(COgdhi_RqOVXZ`rj9i){nIbdT4>BwJq
zC|=~-h>_rvjfksl*$8MUO?7Z?7TxOXa7T#0$gYa9K2CAJHr~}?Y=2|yvE$Y2bLg9k
zA>Y$06FMJY<^s{|oqO`ic;~D9HFWc5J)hI(-Nlx7pDpuv_dCfB`Y+)=$h(h}!MjfJ
z?wVYJXOim>?>NWs7QB0}!8OFI1D03f#cs8i@_6xU@=H6H8(zhFmK*<1Jo_oJ1@Y?#
zR%XHV)wfMvzF+=oO!VcC#TUub`HZ{&rv2^w{l&w)PyZxzR4~UMW^d?+q{~T{@GYL=
zl;YidPlA~BV?1M@q`!!ZATe8&1O1A9D>fcOUlb=V1-1hv?JM+EO+dIH?%+RjV;A?{WkgVL;rgF?NM{yp&S2*
zvYI1Cw{gDo6WB9&TYWmPhw~k2uB7-0=64dna~=Vdaz_0p4cruQY@V^4$UHf-1&aGm^K
z?@Yl6XcE2=&@`e4ex^N~BQlv@eLFAB*^Cp2yz;H*)KZf7sKfU(>TzDll@
z$yM%6I!BjC^;LpbHugCa56K@htBlO@$KTz58M3)PZFiV&T;#X?E82cC{Twm(=X&qB
zei{3Y*Y!o5TXJ7T-Y*^S=BrI_aL#uUvEsH&Ze=y!X2gbQPFsf!k?knPcE}DD_jop=
zIL*2SyHT9Pp0r`txQa8_b6_o3C0Bw=^W-5D|IYWdIitpW;n5l9UmvmHZO|(^Z%O~?
z1uv%0y^ZN7;gR+Qx}g7umVWIEkYBW#e(e0X*N+_^9_q)JZ9h1-!d`&K3++D$r|{tj
z5FZcftb!I(SyZ_mE1aS~}_jbUb9~csSIa=n&2q
zL;1@4zL}r${lq^GlXuoI^LUlX%h&a0+Sq!oXG6WSMycM`qXQ*hv3ruW^nXY9Q%9AmG&AVZ$rGiFcLoHdd!@pkr%hl~68
zHeGa`Z)tphwPqALq^}Ni+-CLlBLRJtu1YtJ-lCg>a~*kcuCT6_k;gZC`zw%FVbe^SiyhH1T4?2X*d|eKTa!#WRf$?WY+&Wxcb*)1h-Q&+e|k?})XVXERub
zc>YMcd%EUoo{Rnl@O4`H$GvZ8yanm^Y5ySfMJW6Fe$Dx*KF)I4d3l*x=aeSzAfCaV
zM~h-rSLZ%bNL*a!2pp|pB`?M4j=#rGc@w9T&n|oAeRtT~hyLH}|4gO*aI6k_7Tqe_
zg^o!t%HX5_O^iWV^SoYX6yQ%Cbo=ss_I=(v#6@Z1h}b0YC@f#!9vx4{&#-4VL1!%13M@*wBrRW2zM=fWH2IrobJ9q7
z@m&W|P`=z_`LElH2f2FLyR`6+k99j>a
z%~=;{Il$S4B4`$kwJFap)%o}YR}p;>e~ReCGI&%?o_KUSJgOmG#UhR#i*Cza{_
zBfODbP1AjvF^N8}q^+e6b0TeB&-hhalCP0P3wXFjws~!h%ml_U`EjmVu1c;1*EHHX
z+xETh^?{Naa7%|0;9f=>!u=&{BQB=xTPEfdZs|n
z6X@PA?ET|bPsNu<%JTKJl`=X5s{Z|ibRGTU`|SPOY~2jF7IVHr{M0uG{JyQQeft%>
z8BkgDZ!@&apse~iow9GIpY8D>-R=tY^C$E(k&vyOmSfv=@Ov(7o0f>)3)F5h)yMW|
ziM~lVUHc=^6LVML<0So~ir~;%J&zq_3O{806(q&bayC#(9mj>io&|c=c``@Pj9ME$j8@@k4rzGSN>n{?7|v!gzpIU6N?%=yFeTY-*mU#
zN6*(2%>mrGA5>-*BeAJ&z6t1Egp@yWQSE55I+@~?#Qm8W<03VWE#Ij2#^dHOr7
zP5YJ|gQf7ZwujhSn`g&MTd*_S`+iL|=^8G@6BWN(e==tZI3G|mkuwht-{5{%RKH_k=;m9rASIT5~t1w8sD=MUaf;Oqo$=Ic6-@Vp+F
z0`7h{XByt%x7l9feFUy5?i1W^E9W~Ve{q~NunAZLoCMtQF3va{rEOpXum(5@7<-kG
z%C+d71y0-R{Dv8DI^K?V7GM%s58VAH$LZp9?a?S_L8u=cQ{cqNJ8(jQbNCSOMb3tBE#``0?H%%q$=^(!
zuF?W$!ylOefHQ!bDbsln+D1bgu(}A^Uf}od_E8^LO`Xla9!5_}`1+t5#eI|KH3y&p
z&msB;@N%9*o__=Pi%GBlJ#{&DTa(k-dd`ecZwqh>um(5@DE)|@NlfgdiS7!kAK!lq
z{TNO+=9=|P{#xiee;(+c4qoA$0q!4wQ}bzMO8Zdwb?BTQ`;xyhBI)@MBQo9^*7x^<
zeqD-jD|$DBcQZIwT6%vLpjWyqJr>U4X#E7V?xp^n)Xjq9SxZ+5^+Z<*bxUZYI^(TT
zd>l30S8<(A{j#%&^{0rfob2IIzn-%+{4@Qkpg-Zb=SXZ_Gx&w41^mbJgVn!ParQmZ
zo`3g8Y@GbM5yQyhz2FS{zFuB_Y~^IiWocV;w(rNQZ)Uy5I%yUDuVM-fr2ljt{x9h?
zX~mOA#y!7E=Lufkhuvo#q4~r6*7_Z2?iIx7SB*dT=D-A(e%BS!4!*}%R2E<8r*G;!
zUVgkXN7?5o+k7H?aNx)LC%QUQDPLK#D%ZE;
zQ(p9|?0>vA(7%~{@pTLNZ^hSp0(||8
zkI67kWj&h5w0U-74E?GkPw}nKH3p8?Rs-i6>e|Dn9o^#*)82
z4#q#Up42zJ!+lu|jWwKykS^D99%49M7Qfe^$CB-PPxoxY0Bgu12fG`~^!}U9B($XZ
zayoYv8h7Z<*w3;a^4Fl!C4U`yrQunApZUfc`*)e%ufh|ZA;EbzXLYn^eXjEGwf{4E
z?4EUp;t<5JKBxDxsDH1m-v&+1_<*XfGe0^n_**^0PNYX1i$~|>)0E%J`uRcmoY1g~
zeRSn*BR=-Ri{zzJeJjZe@0ocvF+B5Jht5%4Da$|sA=-%
zSXvf|7TV=7m&p??Pm31l`){*nmtXfA)Da3jxuJbRy;J#L+!tUwT60C
z;oZ=AiIepX4C_q2XEf2^(fdGJBPd>Y2lM98S;uf2QFCsC-;9e7t(Vjn_-Dqo^1r9E
z2Z>al^0$g7G3Hg?|8ZjA<{hjf;z^7)Ox{wHS5ID{bRIl4@byC5_Zs?R&Wnd+SR^{g
z^UIfW7EkBzRNj;Q5WkJiA#cghk10k;-@_iM&cd`ftK4skPS#ezz0BW3QwwtFu(bSw
zG8!K%b&pQQxtCmI&tA}eD{>hnJop|#zr$u`mqu`W|j4`^wc~$0NwK2F?m}H+Yy~@2_XBTPfOD3kCufJL13E{bQIW+n6
zsz0Z;;hS!MuXnyt->TXRt>TL#o*<6{JQHtxzMMP^Urri^FBR$o=ZR#G{I(vVt*}4w
zU*y$~5#Lv5pXjAO%(F-FJHL$|+dzI$W=*FbE3-xK8yRX-#%=opOi_;kDr+8(uS
z-DmyjZJ(IvZUa})pZ*MGRzb%uo=N|A(|%FQu|BQze;s34{!W9{|EC!@FQ|=FruQ#L
z2Kw)_?d9lOIcGAQwoI;qGZ|}Qo?gf|6TkiascP^v;9qK8)eWvX>MTWvbY|x{_B=Fx
zrc=K(uB>a
z+W8!Mt2Re~TW!hj8v)HDk|F&?FPED&U;ZBZqek}m`;M29C;iaasnYp5Z0K-$JE|o!
zc1l2ZxgXT2^9#|`TgrKdHLrOHj=lG^CS1u$LtwE+sEn_PxnXC*OBy5JoVS&
zm%_WP)G1D7dLN^X_#?h7wc~mey$9cdXYUB{>>29rJAwwS9Y%
z@)2a)A$j3LoN4xI=%3B2*=?=i&xJHh)_vV0ESjsmY_ISRazYa{p?
zs3$u(1A0dGcsBb1WGi|^i$4y29Y_LQVs;W_O_
z;v@98_vnM(x6ZaZ54i8vn8Ejc6d!VX>;bpY>?Nf7GV*;x^V65i-o?<`=6bsiaFN-+
z;A~`KmHRvShOB>rXJnhHSB+kXwkt&^_GBtDYyA{^$;s8(9q7sWKah`2on&O0f3D8>
zjhxNanD^&J>87hX;5vyq(mU-{R(>3rqEn?Qe&ajcxnFYnZ^bFVJ$e}2gr!T4T(Zfm
z9YxDdr^~(E;{As4Rr34d(UNbkw^CoUss1kdGTHX!1jECB+?T~_-`3wv{WER*uMgAy
z7;x6o*ApnCHNoF0v)s1#Ie0I=Y|=e4oyNU>>sdVT*Me&;FSZ(91`;OnsGalY?hu5B_#7
zdey?*Tg4cs4cQET?v?K&+`qE^)O_%&-W1_tuG4QSD4tn*?k2aqWtE#L$36zmGQ9MA
z&U@3IzB8qAt(4O|r}h?6R`Z5mp6|??`9o(Q{)c)E(A5A?$D#r!rleU$$y{V{PO>iq4Mff9Xt#@}P~$Jo2sZ<`9A6(7_0JVb~3EPklH2F@tY
z;9T;^B;(G^8%x|XHE*;rHnE2(`XW2K;~eZQWrpU`rS6)9=F+9^2TZ-CF5ffnf1Un_
zrgfaJ6Cd`{X6L)|d6l6Izop*4cqH3iJKI_2d(MLdGFqjd3>8^yFcprOuJ4Q@|hMe?@D)#
zezhIz%RY#FaJsK1L5tu)}gr8Rk
zKHrCIh0b=yMhlnLtLAJbvTI>{v?7laB|~C&Uc7|39r3Xu6Wj6D31OawV;H9fWgX%_
z-=64iV4QuGakhi=9rDklvs$wR$JvNvruUZfot$ig-UpEHb|rjSPo0P8e-~#${Qmno
zFFUC7S?d4Ct|I>x!w{zznOXim0R6H#Kd?4u
zBKUPiNaNA0jmtQ1$a?)v&SEHT5o`0-E?Tdj!#F;`S&aic8?>+Xx$K(g?+?iDo#58@
zKD4IUMxD>2KjM{dlVz(!uWXa*`aaw!_!TA2r#VqFGx5RL8uv`aiax%P&A(D{j=d${`h;3sh>Y~uAp24_@$TnZTq4gPsWC3@ef=0RcxYU
zBfHp&oVBm9mzdE$&U9puZ6C;PksLyeV3l9@82EN@uluYgoXrp(@yyq6)%W}VHT2K$4|)Fwyih!%
z10HOpzUn=u`rtXHz8xRI`hT_Wsqih}e*OM|`m~t(-$LJv%+lUmyCW9KnfL;DrDqzm
zzOK!K_GbDnnbnB~%7|`LUv1LYhXOJ`&&qrzZKfQ~JP^sM09FFG4@8_@L>$|ID}hHj
z$FS}1e1j6$!8MiibYPszKUY%xH@>04*@m9~;k*WiblQNedmN{XbjM%$4Ty;2IKZAa
zc*d3Z3%?=pJZCmIz_jwziY3}6&k4D2~b|9(mPz?H!1T&1MTfID}RkN4aT
ztOX{4M_BE?`3rc;)y1`lYZ7^Nz@sn1DByPB&S#JTumjl4Rm)ZVG`xBt;_Ukwya7H2
zT*)<+^bBCrQ_uz6@l(f1yL{&abRGNnUg%GtgLHEba^Sw0`>tHX*|1$+P{e5fRsbu3
zJ-qd>gLWE#4Zt#B1#nMq#MuM>PT+dr3}6E=1}q2e%<}xl$P2g?*aln)tOeErkNzRz
zIKUoowQuvz#>@du{}DKT4-R1KSoTg6?2~g2MB`AlJ2?J|(u^r|T<@%HW(;~~X_vTr
z8H3(jv&7x-%0T~P!b7>O;2ALt9uteOIJ|MZ#C_h3<0Wnf^$+$=bic~@J52pIh%4&1
z$9y_8#uPUxWSq{3-{X!-YaHI=n%GI~9^+5n#kf+tr94YKHPKbs8qSUgr@k{KT&46=
zbJ~|DdbH1ocQAMGo_!DN1H~p8w|o!0zlrl7YO|U8n&13!t-71QcNz7IX-77pIO*90
z`M<)UzFiNF%@)TNaHviY$5h+Ci3Nc}G|R4(g3Hj+v&y{+96E>cNZhkYiW$9-V0}Xz
zN%NoL3?qA(1F5Td@Dj?Gp6KzufV?u!cLZfQf-J~CJN>!gdIMRkqu22C7j
zHD^$Q@;iw9?qMyq58<_McNe?C-sVuW|q!ihmsh#|zevQXhoF_s4@i)c3)ob133P`FL+k`}`8m#jg?2
zuJJ5?@DK2526`_V)c-BWY%2BDMvAj6;qjA!mOnGTPlpf9lrwy28RCWP%?!R5^DX#c
zYz^th4NvZLmqObH>PUuK`%9*x&G^8!P6KeOE#FRg?O~rMog|L%6Jk|bXM9Ze#Ec&0
zUU3G+K%#MCepYuMh$vo>?=!8YY&eFooILH#o?`LeWbvP5@xKEOQe@nPz9+j`~bt$x!>?}Ig!96ogMgziK2CEbTU
zx0mnf@r|UHp9e=e)wh=NMc~!C_D|J8TE0|)&gz3ukN(m
z;VK^dMc#jF#W&wM5iM=fIG*;QgSFH%dQO?}c>kRp@4p3qgTVu^eaCm`%Uos
z@x;5(d$qZdyq&hrJ;T&#=ec;ho9~>6uZ8d=c$SCnCHMQW9sexHFNw)J=X&-oIsyAh
zAA@$Y4?AgWCw!E>lq`+UVD08L;2as(c=5*JEb)i_DGn0c``FGt@{iaz7JW^$*F;-E
z+5hUd120WNw-@tFGHd(LkZwzU(kIa&JL|8lwxA>ayjNxQ{Z#dl_D4XEKi;C?4bL%e
z5TnV`)(G0#M_XG0{Z?C*=&{<9&6XZ(ZD`t}|7Nad?tKrsR`GFfY{fr}{}lp-4)fwv>PSz6I;|nFC4-8kwE>&p|_R#J`Ia~8t8wJhG6}HL4R?X
z`!Mw%p}y0`?{`sGHc~YF9XYDL*>eMz?=wr5lH)zp+e`$+J~=NOr0?GBy_&W99|7w6naA!UQUulip|Ir+L;$9!#2W=q_k
z7(Z``dmB8Qah^we12|p@=-|J|SJ5-*XyI8{*L+{>u$BLH(9`ut`U4&7DPKz4!S&2n
z;m=(Y*)Qy&zbW<0Tf@lqYF(3NO(Pq8B{c1(-EUF8I=RvPg{5g9IF0`Ue(^|p>W?j-
zw--{knDZiPqm=U^qQ$r0YG3u1L4$PYf7m+=>*g)^j{f^&pJHzH-+8Jh{hdA7CT#mB
zNeABz`Y`u;H%Q-^4Za(6A@2db`#A3gscd+@-*O=T-JtXP^WO~`uFl#0_z3K;4fk%4
z%7@<#Ql8!os^Dx%%wcUvoG`)pl0uz1ig~fiNfYzW92H?(!?eCf?ONZ&x0COL-XDrb
z_$4RuT(-KMcG|%gwAFJcGn%qdC)4{~()upY4rtm!S=k)PMzYnIki2KGH~-CqbV0GS
zo4ZZd$>9qUp&6NRX!|l
zQC9YC=La_B*+7j^**=Y7*-$eNq%*zOh2-}s?2YDWf4`$W#Xd(T-;C86xwcf_IL2jo
zJu|%Do&PM$V^CD(Yf%dr{^h5p&8uUJ{+LG@2YjJbdiSaOsvSysX1C5gl5?WI)cVGGA
zK)=2bFPd9V@#+U@_v!Y>$)^K!^JDec$ozeSn~8rXz^8Fn4ZcS$FT!i|diJF?S7pIb
zO!-H#zfsCxIM!Q3h;K#Og9zbIk(Xs}M)*YM49-P&Cln{R!<}@d`gDiOH-h_nDAP^b
z+t|PH%c>8;>(5Q6TN-*8=h{<}e6*(&E-xMHj(dAO)wa%N+Gw_IG^q}CMNhb&AF}1Y
zPWd{@kAUtZZ{&X)gOi~->(bO^j=%Ph5BKd-Z{+NSxR05?MN?X(9SokUifsXefcE5
zp2@cx7tl4|CSM5;Dr|qt|3QC)erU|nTW9FaUt3?o*xAKijrhNlJ*S6#+89UDm%%Xr
zjlRA4Mu4`2^oRPgS6$Q>p5PeLnAF~(?|(mxE}1wEGX09BD+XObd$qEMIfzTY^DZ
z&=2)reyI8oN#mPwzsC0A58&~2Axy{fFA<9cf7AgNG_KXV)V5Ejm_FryLrJ!7-%GN!
z9<4!J_j_>Zx7~cYN})siHt%<0(;mhi==`PZ-0jxRZH2aC>KxC9Fm;k%oiExtKcLQ@
zgr^U?L4H*^tZ@`I24U806Ur~gL2^Y^8|
z?+MMZzb7RBWV6HGX#men7LR<@pnr8KcotFbt^l6-7LUqqzYN(Y^?N{FoTKV;71tYh
z4jm-^@@Eq-^!JIEyE^l-{uBAX9iZO>dKa-y&Duzwm9Otj*JXqxpS^q2B?T%b7O+cYw;zM?U-x
zP}xLuKgDkVfk)?}VsYM!;GL>iyv>bd$cym}JKmpql<#=!8z#J0krUnerjvei#+>1#
zKl;6z;m)1DV?_RMla*0N``+XDCa!El*#CQh*ie+;7b>QWCeFkLe{(_aj%Da~kY~%e
zSNv;(<^KZScTrrWF3$R#Z_|Dd{VMGw&cnA)KVW3Tw@;J)-u<1{S6=4r$5SsD3({F=
z*&zS>;Qx+%3Y<)Co!TPK^$=~9cCK(^#L868|E;v=$lnU>Ti@%+=dJiUc9io>C43!;
z4msFC*);v$Tjl@D-uuT#Rb2o7HzXk;i5MhWM3hxQK#{JB8Z~MVL{!vOQKO>SK%zt=
zS(BhaX&WUVD%7Y^X~nW_dAC$)OQNG)w?OZ&m{dA{b(
zWba-V#P|36`21xakDI$^ew;aT=FH5QGw060rwFpIb1(PD+w_@PSHVaBzCpE#_?yd_
z_Th8A_fVfOzn=*3d+#}!{BEP{8Pvt_TW!U6lv98=lTQ9nl9{PS_H++W=OGMFMWX)}
z_!GVdsDXUpveyL4UKA=@_W-qp%Dx3ye4c9CHdyAxrp(N{fS$}!W-?IbkWiVr3#cwfn)d#lS$inW8Qu6XBBPqK-CaO?1}smVfz0kcOSpVIN1N|olD(_A3#fnJT|k*S
z(reh|g7@-hY2Gp5<#N|K4`GPuY?K9BXI!1l%qum9x
zI7^ut-`!n6?Ueb&K$*nle}*zkDRbx{*vtZD?(Z(3u*@%I407Y!#_~*A(A_q3L$XjE
zk_Gh%$wCY|gYxhz?v(i&^6&%?YtJ2cMeKNv-#YU}X~T4!%2?*;m>Qx(ciVhEM2E^%
z-*Ynggr#Fzhz{<=*|CyxI|Fn)Yw1whFdd(Sj(YJp8rxb<{4?OKv+!tO-L<0qju8rr
z$F_bSIEjrxbM9!u)#e&M_5HTNgM4W0EHrl#WRB-$eE)d4#a&6Bm%w$2g=M?^4e(?O
z%lGna;PP83EB;7NPwYwN`X~LpOr@!eZT%bZetrD;Lt|q2{<-~fopEGSAdEnC;)y-Welcs=t=b3NuI42aEK7Z&3$Mx&rp?LJ$H+>#m!FleBCi^_n
zw*%5ubU)3pq8t8j9{~G=nY_6a9MdYFNyQ@E>jD1`?tYp*=6;&ep#|@)=bjnePxBM*
ztkL~61@~;{ewu>5`)L+&zf9@bMeiy8wP)A7H;emhbU)3-&z{KrG=I;ypGNo0nEPp-
z{aWAsGy|S}=)JFS=gnyDxzT+#x|62++3%RUZ1nqqd+vVkl4rkp`9sg13I6ZCcS&*A
zdyiUv%z+=`&*Orbx9_K}GY*79xLLwUirP63OaJ5)Y$Gl9DhL{Fn&bjBKB=@o5)JD?9(cYBn^9yGEbnUF3s
z%iP=W6lGk~TL(_*iiO{Kw
z^zB1w2j9Vy&gnI0bH9!3B|T*yuGcgS^j@n#UbUAly(UV1rPow|TWg<>s@F(AzKrt2
zwnYP?_
zi1!=mnk6P|Q7X6QG4$_idpChc`m6k1)#m5WKAW)v^ou9qbF3BQzPdLWI?>A&BmSwWg<%G
zvu6#NKJWW!MwdcAznAh%<(c(4&MPCng7?Pn;txvFWjs^<8=82AeaH7bjoS6T>C8C0CG6XW{B@
z0NIr*d2}wA?hNqn3b=-~>jz~Oa}eWV_PYZ7xa)1c%>4;JF8f^peq8oD1{4=Pb$BY;
z&*z)gC2{(_yDQ-DzvH`8%|Titf5=?{E5Y?)XZ;`OJpXCrmw%Xa0-raUn|IBp$S;m=R-0%K@yt=}1JVoO@NcV{9$yu$vF=K72T5
zVsz#!&w*@jpXSVS&9Rzu3#g0k73;HUvYs?{H@?N|yMNo>Z=SZhU1{xZ={wHv?6d!>
zpHpwfnIGdP8Rl0vev??}d*^S|`0UPePuq?CGXk(FCZyltYl)q6*%`xA%Z~7QaiDrV
z#`yrMm)6M6rl>Ol`s&7bxIdfX{oE@SyjR?fl_Siz>6!X8arr;u`&{R%S4Nr6U(e9){g84`DPF@`U8Rnc4<{QmBB}sqYF>?;`ud_}fJUZV*=fr9+
zrjkedJ~~&njHfz_uK5$>F@j%Z|8C}3{5>_VsoaeDjxsgBsoe9KOEt%7F70J5-QQfN
z`SnW5t2gbI+;UTvZ`fX=>>qgk`MGTc^U(?7d~uTKy_bG-i1ML-wsJqz8t4;W){5|?;-#6Sms*h8(G5E8`;eC@pzW7WzeSfcK2{}
z@;%2(whoW#EF*k!*ODfD568b)53C@3MUfo`y0vGcZ)@*o&t`GT)1Hm@dB%*Zwv2Fl
zHpsTt76-d$lOEsF`wFfO&ilFlZaV&zYUen9oYE~-r(fE>?fSLkRej9)&N}g)r{8NPN`FD15J`HoX
z_O`R_6=st=&3zYP+X%0LhnPBN-mmpbGe>3G?-V9JcB*cP*w%-s!&{dPH@3fW!nNMl
zUADhbJmWI=p<)}&#IXk)anhEam)UmOkCbkFIP{seV{DfGlMAde@3w8HJ8U)oJG<^b
z2dM3IuI2T;yNykXJ;{Wd`_*>NruP89Grtjef%F=ST-(h9x7zMbmDL^FdIDvaaA&3b
zBT6e5r=-`Y4Rq$hOxgI*HFVzPK*Q5aKZy;7mdv_;PUT&}{0ScMN_WjZCp$87@)ybu
z%hpqdzI0v3$Y#lR(~_SPZ2H1VSJ#C`9(*}%|3F<|6)wt^9y646o7zwH3zxah(4A>Z
zm;Gb&L8#fZM|wxMX5LRK*<$F$-U|PsZT?*(KCKU=Hl2@6
z4msX9e7PBK<}n7WCrsl}OQ~-!Y$Z(gzSX2Dpii`QF<%iso%rL-{jEz=1y?@)PQKd6
zw6pr_g47oF;G{2j$>f%!3=Nqwa0>FMKJ|y6`R!0a8p*Qy+uaIdyx{)Y4}1%B7B}jvVS?*|Gn;Ujr-@4{?^|AS=gbrQ{5#GvIFS1+nb-rZ)5{K`Za^=
zbA7VE3|O-NEtQ4rKL}hBx3bUutpmhYwH>m*LUxd3Y-_X|ySphjQ}*jjSf&l)d=r*A
z#+**r&YPB}w6EgsVSUHi&dZ5Y-RD|*jsgzWJuh&FZH~c>{l2g63l3QK_qdZ*zM`(*
zuLV}!RktRUN559xzH08SU1;iF+P$!E4NzwrPjB0L{O-*yN>}bx0=5%=3(4@ns(BYjeO|~;*eEY*z4HyhTzYUH%xu~>37tJwf@?$Vc)wy
zG4|a|Jut=je{ac00=hS|7oTV89$RT`c)UmR^FBMId$t_RwJyaWIoR195ql^JoZ^?`MdP@N~o$eCWTXbiV?oS%eqi<9z
zdE}F)`;y)w$Hq+GSdu~w)51!+B7=e_t2eAGH0
zzn?nmjF5r0&Yz;r`4QjmPkVQ}L|fFilXI`o&_(iTfWCIh7hgo*p_V@JMQf@5jV}7S
z)_Cw_1?9y&>3Yd6FHzsmTi$RET~V1WyOgpWZ${d(A13YZl(sUtrJg$M!hb-ru@nD+
zkIJV}`{C0nXiN@RZtjtkJl9&NANz`AtD0@Yuw@OM0=+FqX3Fyr;<-1>)U}@9
z(`;S;3;L^V-ixSfCG?BW70~bMI>y#j`yHcg{YD&Q{U$`xvVX>Y>Zk8a7mEgXcse|E
z-%>n;Z;ktQ<^lQH&`!NSB^~<7e8J4CZlCK5*k+0}PZ8$D-FJTr%-n*X@ds=)(s@d$
zPaOXUwU^EcJDBzg*5~Z~)JJ1zm90-Z^%32R?fFc%|0;bp;@8cZGSim#_dxyI0`>ot
zt^b#8{pW`2|1IkOn&v9iKayF0vmVDZb|B9_V=^Y4LLS-`&+<@Rng&dbha_H7vJM4Qgu=`XrS7v8&>qdNC+
zR|$R$I&11eOIy9AZ6I`y?OBo<2u|T12u|T181Zor6y6B+<&p1!&Vzc0`iAWy-JhGX|MyC8~
zH|5tHVA?E}wxdahQv03)KcddZC$PU4VXbNQ_bRo%<4$bmn#GixAK{$%GQS^aF4sKn
z^aD44OHa@oK7{8oWOq9Grm#m}1lj}c}_QQc8!9#&z}PL
zBK}k)Xjh({;9ZlO){|a;4gBZ>(v#|poj+5ToDVJckf)?lek#*?UuW*on!m8at!djs
zdT!==a~XE-ya;+O_&ea4Y|($DuP-uw7ycf=X=V?AHFM-~{Dcqd{iOB)V*VaLE$JBB
z2ge8F*Bt*`{)g=Wu=V|#`l|d?`onAasL20igvUI806Td$TZR12v`%3Q+tfK|cjeou
zK^_0l9OIAWzPCJHzM;6^XKma
z?FF3N->;wB3(%VA|BpI80S)1GIQ7r(4(tbL9CZ5ujyG$FZ#c!*A7=4=i1?s>AUTy>
zenI`VgT9G8ntmIz{WfXkvKzVNQJ=jKIXlbBBX@QWZ2|9)L76&D@2mUXy@oOLQ%VP}
zBhbzFcxiba8j$D7oY~I(%{%gNFxc~L{1$jN^Az%wd<&m|E?VhP&r2-ELeA6kJbnfp
z_&@M&=Uu|PjQ7rOAW^`|{A$~*F<9B(x7D{*+(!+Z4?In#_ypsLUC@Gb=&
z!g~?vTa!6n+kN2Uk^hDBkr;9>GyoU!Ui1adFe7g{?@Hcl$UBel(oa!e;8vcoJX658
z1_z67!e@bR>^=CE07rp4!L*gJ*5Gk}-S)g4yI*B)s{*galj-EokIFC0_f0Oh_lYgzKCy3UO%Ba}
z`^Ua#+bC}ie$4HpS6M3Oi=2TMo=Y!htO)O6Pa^DYTd$|7*A#HAr~F|3k0qWx26Hc+
z*NyKoby7c5S!PXyjpb5o*|N>cF8<9kSwHhzXC>(#0qHQhldkNz;eBhXe+BmNG=DnX
zNb{`Ii-LP~x%A<%ew4_f8~l=UCMVkZETTR`D0k6enf3Y8`hD--M}3wNr*=w0*MZt;
zYM`CIZ`-MwvNw@W{E$8+`o(wg#f?3a$S3}2U4E1FSL*4;pYi;5dZF|`&D#-Zl8vUb
zgS9@kwJWf>jpvLl=fC%wvAsRjH+Q|lIO^suodxDqCI?R+j9gYe^`Uc@?pW8{rEh(u
zC%AE)`477na|O2h(u3T;mVI`p@pa9#1ED7z{uOg4gTIF*y}|7nCUqXDozGmD&YB&P
z$K7+#rFH1bw3B39dv_a&<{nt6k^QX8rLoE%Dye`oqlrVaB++NukDmw{(B_+A5#@a<1Wa`>bhZ3N$T
z)dQKyhc3R2Fneq{k>r;DL%&8ZGrF4efpy$XGoG?~sHgljhmB<4iajh39!cIt_S&L4Sg+4>)ZHjg#Abk56F;{
zl~VXtf=@$UH|y*Zc+>C1f9cVpRXVhEXSL;J5&xU%4Yuzl;C~cf2=Q|Yd4v3%MtG2)
zjam44Wfp!;g`bO|NAl1C&eyFx^w}Gs)7Tv2{`im&olYiXYdn_x>nu&{Lo{s)(R4``
znl8&i(-d%)oaxh4ivPr?tR6oATEwFP&@uozDrl1onFoHK@vV})vW4kBnZMG;;%^K*
zZoC!_jnQVjga58RZcQs6iw@HlGkv#4AkX17ox-GFc33;cS;&adqmk{;7$4M3JL&JJ
zTi7pVJvd6(uaw_;Zo(hO+#PQlm=C2VFZ~I!SIM^^tPA>6o^~mY7*_Am5JB{|FI}l30+0dRj;~Wzq*IHL3_se)Gx=@`8IPmVdmIynfe=REk4m5s{Gg6{MWE<
zoyWMV{KBJeWRi+wJU%ze-F}Uf*GhWbaX3T$TQ)RsC`|VXeqDB0`uuXU_nJwAzekkG
zE75X>rR6^Im^~9{=^sgM`Lv}YI^cu*R3{jIX09uTX;1DF#)!&Cde-2Bd$t{aVtfy?
zwzM;~P_#ksx#s(r%)Eu<6)l5RCiEXq8nbr=E&0%Lqow7rLq$twUcX+MavL7+vekXn
z4fvp{?P8DgY%6^tb+hH&dcI*;<2{io68&AVt=|D&OZ>IQ#vR-0?>Rng$Nq=S*ze`)VDtS*m-~L?Nu!J0J&?V(F8S!)*xN!HFY+||
zlhoJTp-5TChwE$MGuUfLulp2r)|`?u$@9oySg`FW?fA$*>Q2(zRyF|MFryx_}x$5gR&-R@!zk%+S#3n@3*t?x_btMH_R9AgYWarEj0FmOy6Q(
zW-@(ZwKsW{<;`2@dgj|O=lgsHFX
zL$1s|d}VUWIOU~&{@mjC%L$SR(!FoXI01hs$=|;O(+>v$i^tN>ud_VfMz$@6{ve8ne+r>>xXNZ&Yei0{*Abc}?rV@OvwYs4h{L&w}m
zKIws*$d?!Q^}uMtw~gkJM!KNW1EmvcJ@#*_3;u!pQ}DgedRO+sxyaiTzJn|Dl3R3!
zy!7WT)2U$yLJ$Eu~-ZO4_
z-+FE&a$ZQBvqc_D8F>lc7TE<&UNSj&)hCyyN|K+?&;1aesdwzXUXmemrx$HvbQ<{a
zQPy$yWSO7qS%ZXitr?tQDm$y{J`uSrJkRkkwk3*>jPBZ1z4EZJjwjyvS#KsCde-1g
z@S!B}#D~`FpNDv_X?;{cy^J5&|FT}MV&gkkeF6O?pSIcq9aZ*>1-B>v&N|}b%op*=
zTfO)K+Wy*JY?4Le*}vDiG0OdFF)NoNoLp+pGo<^;uUEQ(=5UQe*Qi{^$lw2E-_Tw7
zBna0|d=j))kc>N7?ROOR0%ZF@_Diitk6`W7MSkhug~+O8^f30YO6i|@nhSI;3j7k^
zjLaef|KLo{He2>Q^16DQVC&&*IweVeed2WaW9T1$7GL1o&*5P=yr>NMGJKABot370
z(KK#q?f$0Cqp|bhzw9f5k48W3TMKru7NjqpFMrSk_eep1c-^-?i!Hn~Ul~&!4{H|QQi+2-el?^qoHA2z)wMU@SSDl
zOn2PLU*Qex@Y`7nb(3y{mBpw{GlKZn@Rbhh>3_sd*u#3Q1D}JUID6@@E>B$x-JK{@1WVe5(k=E^1-SboV)WP+UQz=hvHdA^zvV11vczz|{=^;;(@MpLVT$SMN1ef}I
z0XT%a02~F#h^xQmw2P^C|40&5p7|R-PZsUqybK$NXxocFfyR$L_!Edm;al(_efR`$
zP8FWYrDSoz3|N$_m%74IDR8zj@#&Inr-y<$s0p8iF<;!Ik-OJk1b!a
zV}#E9FSoRf7j4jLXoE)KHu4zA_mI6mNBOkId0qU7CAYkTjPB`=?09^uZh7=y^p$#O
zyW7IIz_T98keqEig83!juNEOqHEF|R#bCyim1p?86Kz4>sg16;ZS)Jl^qvry-dZ>r5VMfu>f^1Tw2edw0#1pCva%wK!RCs{)8
z=+!-d>T}Zf)DOKQ#1sD;+IL>w_wMe~IU5w80^xT1>%w<~ZI|7)U8A@6ad
zsl_Lvpj0~31FUnAiMFTTk?!+dYp*#Z3m(6InfCk$G-zHE9lDEjoGqi-*bqM4uCr~T
z{Ivc2x{LG}TaW8a{>*x0D}N>VweD2;x{Gw6Ex+j?%de!bzx_jh%^Agxa@C(P*EOpwPh0fOr(;9cP9bf)l
zA{$vI{&)GdMScliLD#E7E>w>P%v=@Qx^fr$v8OIiH8VzZ9OsXp>X*{5)F(84svrIJ
zr1Us3m$S8VV#(g~8LL$9vu(XkHFgf|PsxVxAig|0pX8}Nzli^0ZB{{96^Hrr#ew`H
zmax`xejnnW_>-}JhHYbi-$-Wj{m?pNx%d#`&57tG;XN{?#a2GF{S;phXu}V}ts{CF
zZ^Rdkf!X%4PK7tDaeF6Y%bGffu>rb8zvjjmXD++7!n>R!s<>y=ZgJ)gVA&K-()Wka
z*w*LK5sKlx`DTqZUM_LY_MmThx3LGWJ^l?1XaXJVz2C|HJ?|3U9Sb?z;Su)v6YS65
zj-LTf?PqhmhDP@Bd5`BkWC?x)v$-Q{7JdmlvlbJ72R;tGhw)zbF#ZVOF63Rty9XTG
zZ^38cA$%tIJ(~A;-X*-tcyD|VUyR$hYpaeuf1XNydxRD8UcV^E+gK01JPrJA;XQ))
zSl-(oz)yhkSMc5o-5aP=3-9qfyBFXm(T;Bg_}0$Hm!g(4FL^t^hUsniPt-s&?;*U`
zbFk#5IOjs}UctNcMrhz!Tn)XS_Roiie2Q{!#t-5q?m*+&buWGu)A4oSY2~Q^p2XYZ
zS$$8Ax0d{icq;ilMel3jMKk^&93HTW_iEm2uJC;#BG+(61y6+V(S*zAqJp@pt7)4i
zd`5V$;gX#0tMF0bt-f=+`a9$7S@^X3It7mo#su_}8+CRzcF6&zFW7mQeXBxz1f)-uyga;bP0=WwCF-v!%)CyS
zT2mBsr`HrmGp~pB%c-XhPu)bj#K1W=pkI!o9HqSpI-Ne7AZN;&OvKP=-TZsP-
z=`=QX+C9Y)vZ2S5TfR*JiA2jeSV$r`P+u-24H|E_B?N1muOa(_W<8LpM?HxwZUoPr@M9Bx5o?Z0uY=TQoQz8c*BWmLxJxRv
zuQIK--rbd&kiO+?{i0jH(eJe1WX?cYNcyXL^U>{$&V>vfD;Z4kU7>99p?S0_a7U`M
zkz5U(349k45qvMY>30#%(L%Q{YY*C7>ygjV{{3UnDHz!(Xa013a$W@69{JSYBtL7w
zl@~{rNT>cKT)JoUW+O}Yr_Mf0vUGoHBJ~xHn*)7ym-2#ZH$E3ZSq%2o@<3m$v^cbG
ztqsvJ{tR%0Xqahf_`aoKOenwVuX?D?3G%D1!8*A7-?RB6u1hRk{2kq6}mM(sa%auZ-FnL{K0aoE!~rBx&3VZ>HzOb@lg<-GW-(u
zH_lxg;N1?+H+OB=ioRJ*`-_Gcc>FfIFEyF+ba$ZmqIIMAqPqjdmp94ZN?NU7=TW9x
zhyJ%+hboU`NNIy>yst67t}I|qVLV&>lHV^6!v}f>W1aTa?p0VvZ0i{0SAFen!Hg|B
zw^ll_^zQ)?z8$i8FD=x*OXhx*_OHTwF{Ok_2cM~Yj9vHAXN14n;=dhO`%Gr-1OBgC
z{Oorfk(+3L0EX-
z%*UTOU#LDOSv*bT>4#ia2!@~UQ~zxH*}aA7{p=pYw}ao$&S(F?om(P%x0}yo>kjU7
zKL%byi_(Z5>ZCL}r!^OvJ!DUN-CBp~yhPy|ptVoLPj`dpVl5clw=7WEgsDy2Nw04x
zhM>Fa9&MesWcGXEv!7=^@^)pfp_ed~Y0~rEy>xwZK9iZ7CNjR>Pg>5k5`Mya$?g4~V%LrOHaI-yW|ITq(Y=Q{Csg0f1n)hJFn8+S!*8n`-7z@*>>vpm65rx#rHvgQ?et(=Z*rs;}uh(T!G?V$h*8MAh~;
zT3Xch=UMvt!s#yxA4Ry4ThiaA^t6Y=v(aIc@iJ)YY;qN;u-LXmMNC*g}@~p3po~*KGT){M)@4ARq0>&I8pw=
z@G|rJWM7Ul{nWxTeMP`0OZ(VPmpB`}Anb4Ymn?fIz8`6(j{PR-+9QQlyA&>S0_L67T{^sLY=A5MYc+ZQz40cnuVdo7`l^>I-
zM}LX<@3Chvb)dfUv7WB7{v2kg2eJpO)Oarkv;9p=Y9n$r0i8h0NsasJq8
z;@r4N+`Wop9pc*b4q(?Vvyk=TZeLfaWz4R?-$3o}^o4(0eL;MYo}fBPZ}>U)gE$;&
z+gjSEg}ncyOKtn4{@{|H{GAZ4Jm@iJR8Zzx`8|+M^ay8AZxp@q
zclbLxkbKO)DLnM$+&J~2f6s)bJ>>rbH0}H|Hlc*C!>PVnqv~!v>14&wS4x&=&1B!0hv{KYLADTtKyVp}ZsCPUdt$2`2n!WfVsD1Vv
z^Fba6SJ8?1@59?Lu4}=iZ_Xrds(+AX?fZmjUPd`Thu2GAPnRQ{qS@>*LQ8mmaVUJ&
zm{>#^PClQ@VsH4O3Co-dpCT-Zufu>!zQ?5OMs#P%iR4pqQj}n?v6}~8NM9|AVgCr&
zQ~wWr^UrJjF@iQIl017IzRp|=uD9?9P#bK%X{!12LIe%PO0U8Z4Y?h
z|G*-zcNzJGXDL1zt}VrH@je%tj0|=_W9j`V$>H>#`|;tsKlNws=o63S(`?#OX~3m6
zHT{dcs^=8&ipMHLeL{GJQ+=ZV+T1gX^8Ea<(#QJjqhIEpIFEWu
z_uq>z#q)N&?GFtq%jo~m(H|OuYk-yD-iVKcvuiwL`6`~?rtcx+^ata6qW*Ag?*eG}
zH0y)>2x}?mke>Lm@}RqT@l0RkR?;?;)_vO^qkp;YpD*LL@{d(s=E#eIrT@5Z+oQmR
z^t*oea>{?C-(Mc-xP&uc%j`MIBY7Xea}3Yg*rqLBtZwU^*h_DR=f|qplEd?{_Z0ov
zw_8hA)t9Af5@)_;%0(W301lnSw&1$?2G>sd$=b*!c(o)I9uul!&*Y!+r+q`;CCv{?
z$w#{TM%{1H>Yixn(8{N~C0mbT-<2|3@WBZB^v@z(ZLhgW?S7BtVbIt657-35w)Wp>
zy=mL%*Tm}#iwL-acBbEaf8Vv02n^SbA8Gky`d
z`ktlKACER1nb}r{W@)Qpl}UX?ryCFZL+g*lAN1*5;v2x<4z6HZH4?w~ZNII$`K@!u
zUo&l$o!{{f;rEb_z;C4u^ZVWqzyAzvL4Ie;^Y+{O=eN>_`K>U0?>-$L3h}!I--{r>
zXAQ~Z_qSDNcpK~+8&qb9-#>xYdZmTm>xkcrk3s}oL4FS={zc30T7K(ncc0(BU&!=;
zUZpX88#s*qLLV}76#b+MeX7Cqk^54=JX?L_zLf6ibp1;>%-ByoHQ%fV;b_qKK%O_r
zE1Qn`o^aHJa7aIsk4CV3m-h|w-ou`N%Iw$87~jD|S<{(!G@mH%c$+s(_x+ac`%^zR
zbl;!4%9be|UwLk4{`ANv9D7foeZU)>Kl{hf2`I<;1Fj3qp{hrj=22*JG-&==a|Zj!
z;8_hm%|Bs$%BMN$cKD*X?`3dGC&~%ol786&F4-d!;M$*l>F}I%a?;>Ak~;Rj;LF7+
z>>G(bS6|Vo`$<(#-A}5z1?e;Alg86J!)=zv?^qf)GdAwRM?$*HPJAT7x=eW99S2QL
z=XjO8($So*n(RiG<5?D4k~&5j
z-tH%4=&#^$yp#Uw?9EdRU72TIcS6I4(|j3PfBf>)Z2F+-v(O`2!fhdZmj?9VGr`$u
z^LJ#)FMf%4;*Z+$!a&~94jG~g6Px5K}
zG3lyEmjLfH@IGttN=}WulHbwqaDS6LVc)bL%AYo5NBJ&cE$sKNN#ILxCH@b*6TI_y
z7xM0C#GiqM#CYBnym!vV?*X5IB=2Rsycmyw}}={{{I@$Ll$ZGI_W09?yF$@3q(AQ^JQN^LV%L9?N?K?~T{u
zb8;qS@m|ThiuZKhdAtjGkGKZ^4i14?Gz}jc@K5F0do}l`@b2Qhc09b|y@>ZDo;;p)
zSHauU;3@Am-jjI8cvtXv{4V6Z@k;856V)=_D|pL)WYx*g1w0;jR}5d3Q=prtgQpg_
zjQ55ss51-9Hr|VPSMZ+1dw+JGLy$?W=WBX=+rSqGc=V^?M#ot($lvRe+~>x98;{0}
z{G`w;}tpBdwP&2s}}pW#dp?RvhQ^WaVM$
zx`+?1E)Qp^%X8Aj_v6p;BxUrco&!pgTQ0Y@JJ}7wzTk}CgH{A-WeyA4yq>XsE22?4
z?w#1Wrkv)}I`w#;Rx{tW`Sb07nEwrWaBRF;ZHL}i6Y+6KZ)^vL+Dy7Zafd%%nzmxi
zthK{!cKzH$9m6{DTJma)l|HOI{#ct{d(X0YZ?kzF?TygB+tR)#3+IeVgy9L!(
zaVqOZ;yOsHGCN7zpE84GIX(pWeN3o4(YZnNQa{m}=2<&yC+1k@r7FX-_S6xfyecp6
z^lbc2=e^eE9Z24>BYj#`2kC{Xljj{TXGUaT;PCnEI{{yZfFWv8rUAv2W%B(->VOjb{u30B!
z`hbP^BICxVGjsp?M%r)$eiUjm(e1`2@u3Jli00gw-?yh6;q%1#ny4Pq$5n?vQ!nvB
z^nVTd`$2zkDfuHyQrFvWceRgqyP-YvdsNo5gU$-jruD7U{Z7+a2G+*y_F(=P*dGy{
z>I*&iaESJ8)J1(#awpo=2BJ$ccPs5FdMDX69j&pW)cQqC{x0Jw_Jn?a-B&b>d0>S6
zEaI#gN3oYgn+o4o(SL+b`cK$y?ew3^jsBBq2j9*9K?8UORQfy?uY%>i(3JOIwg`@wk*INccS#?=SIyoRRH<-<)s7(0Y_Jk4v#
zLqBL$-)Ml>Mz*QP_JC|0M;Y{#UCGsLwEJG_x@xG`>y7!~p4lmO{8M`>z3MXJET1={NiSNn
z$)W0}Iz3DI>M!qZquf$E$Ce_q;Hf=wcuKaOSp#^3N4zyWp-%GS5ua6VJ-8&_vM)WY
z`gojS#qU)b8w2xpJ$31VCgoWTZpSCnN5CokPgwq%{u0nb)C&hdF3;qDLF3WIVnAm-0=
z8l!H9ZfAcvCosRYfLHUI
zGV+QqNobM1AV`bG8rcsFKIpkFK+kCwm+~51$W#xwuAzTy1DB&kW1H~Qvv(itPwF3q
z6@LFH8N2`fF$+0U|G1j6)jy68lq)`{9aX-@hM4djfDgA=J`@LWAU6(&`cDTq9PP5#
z){1bzb?
z(@8gn^5fu8dZkq!wVBfe4;kz8{b}fKw|EyRJ#`PJm%PrgZB=aZe3m?2wv5%mGRUhk
zRF?7$Aib0G=b&rOcl`PHEqp$(WL!2xm0J=^+gWBp>m-|Z3VH8>FUqU*L4J&~b-NEb`$w4jJ@!OPISWWM
zgLf}9w1Y?eGn+kSy|t&@N&c0jyAz%jkal{c-Spi8%9H)&$2MJ@bQ?$~THHNLul{*o
zQJv+{E9`M5=+pVo;ejiLztvFLy`g0*w0P7*aXAt8)8+d|_*;YzJAeOW|J0T}fwI+S
z>)@kg^;qOSMn1{?G<-F}az7yEj}@x7_}f33=I49819!9tWM=4-d%w
z2#3Scb2Rkm%njkvnHynxghO+DxE~&7@yxV%*0WZbgndqUDzWY5LzDQe{7z2usf+65
z`tq+CLw>s2m(v2x5AkI0r{HT|zvawzkMw-U#?}38U(r9=_u7T+Y}cU7eW^Q0lOWGq
z*wZAl;A$c@J)Ed<5BQLv})dxe5&tArZqmg@%pD*IR_5BYCAXX
z2JyB)%Lwp@XHK6`8yGzeysEqKb%Q7DQ+ASUc%icbsz
zwNpN8@P_tI!LdCG4rtyMS)Te8{Z=^CmxRNt8L5A;9p=yuYn6v`*N|s_<-TFdT}-*1
zHhl-_h1--7qVwlA{R51!aOxzQF`;^|Tge3@z
z@E*du>oU%K9fysMcMI=w-j%!yd6)9uJQaH!cCB4koczb>_{-!~CVOxE!)06Ld%;;Q
zTg8vusDECgSGmN{*V2tHmRPd2mG?ZJHlB8#MLdgnI(RyH-ud>vcjqE|h2Zs~zCVZX
z6?m+jh+7)@U20kMcPZTwqqAsq{?~QLc+bhpQ=FBtRkri>@IiUJ2=|r|o=4uigx_C&
z4i3@j(T+KhWbYHeT2En$eRjpU@`=DUO`c=QattrkcZ5rQOKmGZvlb6Mg*k
zcj7yvadkSrD(aI}#Fe7^n)IBx9;CIOS&Mh{?bWTWATK=W2frjoqp9zWe^|10*CQ`(
z|2%yE0(=+GzsxuAi>HznUOi{|Cz@hjJ7bVn)H2Vfp&;S6+i5n`<2yw!zk83uA-&{UL;npgvYU7#rXV
z?OsLuOg8fIK|B3AakMf%nINpq}C
z^EJ|RPEk80d+)RKYfM?j*svKH6kYe)@TG*kN!Y&+P4?bp!`2h_I$_fa!NJ%z4ckrF4+$FqZGId3K291(%Z5lckX>YB4`XS*&GUGU_rlTo&DgUB
z{_eWSms`y#_b5EUHw=Wob*A69qV%P`mH7A}r%L1Qw10&(=3DZF=)A7?dEiyxT17t9
zdsU)6wVQHtJ!Fr3pR?uHLUWw76Na~M_3rFUwZ%JAL*Y$(59c8iKDvETcW0{Xi=C+<
zkK*fgAM(q*7a?6Evn2H?Tc1fe?WwWUCk8E=Yp3-f=i(E1HJ48X_ZbQN8oVW`p%KPo
z>RQ;1?*&g8k9_L$dZ3fXi!VtHqpV09v{P2sH#KI(w!|o7Fl9^>&%oQ(Mm@!|gyk7!
z=0WqYFG7RzlO|6%D7z3mqp4d7_!pC|v|G9g{3`YNHYDQnO@4gh+i3ESC9n419ls)7
z;7X$3Bz^uko|S`Fyo!NyY7hJ(O(pp!wZSjthex8{>tRhp9kwEu;?rFCF|AFqk?frU
z&Ei)TG!KD4;(_>93ce5U3A}30VM*#pIpWc+mPgaU{~GwCPv8&H@kr0mB@b?uU+>ez
zYyA2%W8yl`FKgK?52jk%+EX*E50ghCs;
zlpYP`l&518G?W{H^7Ebi8J(^efPH6z?WXF(hmD6u<
zZ$5Atu;#r_P_9RKHNR()Ugc|iyH_~6D4(=@Shq^o(;cCT(-=S&myeLcj`8NJg;u~x{{9(RI&xI3g
zn*OAjx}P)`*fj5RSJzmj@vw8TF2A8{|LcXnlD3evg@^g`jMGOuss9nod%Ibirsrng
z)*{{QGE)})p8T8cV?8Kd!bg2GKbmjjqgDoI{%7B_Yb=feQz!pBZQ0hYHaM`UfnzCY
zsz>DXPG@e>{2!07M@c!a5$Dbq2=luIe%A^&^^CK2zS7n+ye9e{I3|%UkM^t_M7u+W
z+S}FjZD<`!{8(@Zm(f4KB|NJV{@TjfFTMh$dkmGF%xG5e3}cyAEA
zokpF@xC4f#f!{5>V?0rw)u&RP(wqW56x~FWw7gfAa;FT>Xr6Y;Dj5X*1MwZ=Sr2Z7
zhx;){u`ot(wnLwy?>@WvnCJCL0VJ9PZ^$SXRpYM;6G5xSk8DekGo@L@kUO!v?Z};
zXzZ$d;+-O7TQ&(irBc&P-|I{*BJX0-cSM(Ly^b)+_C?PlyUdvy+jVw)cMUezxaNi@
zGv)@J`>rrIH|SgYhMXr;i`V%1HMg8j{%o}W4BE?P3Jp!&`Fl3)*1~ZE}m9@71OwY16f|(KoG~
zTyipmu!GV8YW+6X*$^s6x`^6*-k>K__t`eT4c#c4%!J$A)mL(Ju7(*hZMSn0^)2P>{k-8uztTGX=tJ7Ju85$Udu>}E`i9?E=)YS!;bVmHK|1JEbh>jb
zKc0mjou+Lw<#`loCtV1B#-J(r^ile`bhys=658&Oo;d^4M_>7**>P+LwF5D>(ny7y~t5M`0y3#C8Qm2%H!{p#2!zTCLT}agKMyGu|}6Y*4YR9G=
zH**{uXF_-ViZgf@0pHkrh#B{OpDN~?eSQzkiGFr#zi!5V>CruJ8ofTpyLk&Xf}uI3
zdsDeRnh&n*Wglgz7yZ4VS^foiJzf01x%ZERoAdmUt%8VbS=^OoW%drn=7X8T#EYDc
z2e;;W*Khfe>~4wVmf9HOOJ%ZG_j>EM!gk{ev>Sh#px(7eWiii=BwesAzk`l7tlUp4
zdtZM`6KWOp$ZRLtGWRgfkjf)mYr=55E|HE1uCN^4YvtlppR!d@F&u=l4gMEdkc*|Ud6d_FPZp-
zDKmb@wbshM&#(+R_U8-Mgmx_U_Y5+}IQmb~TMrIT-SC+uTYCl!mwvNV>j%wSyQ8DP
zkB?4=-=^`>rK!%YC0nPnwy2`5`-HYq{s-v)3G&s7
zj|w^jV{v-@_Lh-{MMlq5KBa$C^=<1s;64;C=~i#_>!7(hn|w?qU6B6$rQ=A(qOu0$
zAGsM);_I`W$erXTjxIBu{fa8ucFyRwdEWB(AIt9Km=Zy^B~$xInOfJ7+#RSGr}IHYv)k96{IsVO}dr?q}xEc
z?Vn=2SiWTI&O?0NNP9B7;$tXJZT%E&{S1orp4^Ut9y+FR-
zk>^&)19{FMk95YMUiKT4uRV3M@h{5!mXPyDcXW_1H?IA=CsT)kYXI$l>7eK|ey<$P
z*g{*$9`mE;XanqgEZvKKq2IFUwGn6bvD-~M_~T}#4+LM*^cIsR2VLwP=1`Thhx{rh
zpYXk>vG0m4GN^z2R`{t$|0KRW>U+qg^N)_9Hw58pfxE#`<|TXA9=|;Gt;79!K0Lp6
zk*<_F&EdUN>ETt-j@M=R`xWBn5kEK-|5Y3R1>&Vc{SMvP>8(!JokBj%@7f#n{khV5
z@XC-b^$o#+dW{2b3HfasX6QScZ5#dx-^-n+a&I`a!JmvY+iaR`qzURJZ%Pj$k8FiO
zx!7gXZzg?`c;Q=yO;Yo*>hRv-AJkEP7Q+22aLX<#dV;v$wzz*7N{`OIqmuLkP5QL{
zGQp%@nCc4g=&=yIP%!z!`p;Uc|NH=1*^a$%0Cm`g&G5Tr*=1oh>DH5O+VMHP@<&>S
z?NN2sSXGG)Uh@7PG8p6|>x&&p(v?8_zbH@NLn@ud`>N7~sSf(E`sO0~=3@HvKTRLu
zt{}!?zmGg<`p7XxC(hI@js*7<=qWaQNzdckO}!SSN{E*oRAsA-f2>paema#Wo2|+e
z4e{_&ZMFEnNEGwZobTi3tg#U}iLgxld1zQ5SA|3v&6;=^-It8Fvv$UBy0
ziNDLn-$;Crk2ixa2-gD3uDO8??n3O3Wh|g}mH_iCJ}JkG@gB>wmqBFxiJU3TJIRya
ziSq0n!*_JNw}GRLyc_fJMPh|m#S`Uuiw%jjJj-|rD^LDoVcUz_tE*#kTX`nWnLV?m
zzHxT-BgX4c(NH(P#J`V$>Zj*f8|(8LdkH~A-=7`eKxrfKG^
z$m9tZPrY!`xX9I1vV|`z{l5tUV^?NYkSG&=>bQ!A#+fw@&FAr>=8hS)HGJXe|IKWu
zpIuj7KfAi634&+T%)H$XpDDx#
zb)qS7oc{ujTn10-o9kva&W1ytcTrtS_2j1dIv`Wfw3?<{>sl^vtgZ9Q_2Z`2H@En(
z#Yf}%u&MR5`a5iLZ(>7Zb6xG#bvC&-v*wPv$xV%S_^JK!CN?^3oUdNfJgcF8hBtFg
zQxmP@U6H7pt=!OMh`4Zet-)^j>D@E2aSqA6x%S;^-*6kcvGZR&v#|+cn(FRoyo-0W
zlfi1A0>6G|dqRHkBrFp&qzbqx;>Y{#<9YX7U4M`2G}pdc?OUR(x+R+GMTU24Q%z!)
z-j-#zOsl&i0X!KpYk9X=)>K!w)HSzMTPi$H@=G-I-BCkp_l4h5-(XnjS|Bk;rBGg@
zu#&HSwt3%PH`l!B0_IHvn)fY!GS4AA(S$;uefz0_8yaUIfRSU*jf@_BS7Uu`QuU1Gd($ScRk&APD`Y&
zsj0CkQa_utSC}4Kt-*wEa%axH#SSr%k=I0OS|TG8>I~J@HM1EUYBaPoS64^wnA6-6
znNb&Mu4~cIP!p-GpV?wNzi6$lzWr`HdVFZ|>goffY?+gwa;`3pxKYifL=ALJa~XZ+
znw||owRH`3Ep>+Z&}N3N?0F2;vm0lhEXtwx&N(#=v*{h#D%aeCc-`uVsIETPbR)-&
zSM8hXTIMv(uB(N{*(WP3GP-4MqAoIW+^NxMGp+1-HM41qmbzQ(Xq09$+&QPdNwpYl
z{#+xSIA-*TC#vu8Tbm;%AU&sCGc{6C5jnMd%$P9}7KzaZ
z@gT4t70Kw)vAGkjo_O)azQiD*0c!4sN2Z()q_HLW39{6Ok>Y<RM}NwlvITimmI*kdgj^np!h3M11+6!~2@T#Iz=%jz2DP*@e@lR9`W5
z(uAuny4t5N($F|t^4L5lA+4dV_E^=~h%9{RqcdFHX7~aL&1a9SMeuHEsuR1L>ZMRn
z`Q}jw_bqkIEi+-&j5?YC%A1?(Z=G$p4}nB6X{o<8&umOE`f7{}&U2$Kr@GS+{ZY0@
zI(|0KnbAD6sXo!7!us;qtahgN=XYB|)`+K%m%VB`yW4^@=!X@)&Jw#aM4y|HX`|Y4
zBPCQb8}CRkF=)z*+*Q}q%wQRzZ5nTh+|gJ&$27;dQy73op~)GUqleVAph7hL-M&oGxFL39O?tax$K!VXQPKOm)OT=1`!)nUG4NqD>F_tsBUbk
zzM~G+Nd2a|8d07z6HP$B{l22#N?cvrXml~E-8hp#6Q+UPa2)Yx!{&=!^500@c+s`4PnJFV)l`pv?k)e5Nj@_zYbxvu}?(5Z4%+
z%<@Q-ef;+^2R`P&#~k>W10QqXV-9@GfsZ-xF$X^8z{ec;m;(pmzj{TZ3K{C!r&Gdma6}qj=@<;CJce0S~kA-~Y3(aSy-qdAK{x
z>(86dJ>+!iale?yR-;$SlgqQ0eE5NQJ^U-<&F2jszM
zBCI<^OPsJ)%Fx*6(oG|*G6Nsy5mWA(P~PpTFJTOgeR)5G2-Ey#{=ipBSYZg?Si)w7@M)Zhhr$+-E*YY^n=p@bL7r|S
zZx3O?dTbP*Ltzo&BP__P9?~r(ELe{bq}v$EtFd!^C~P`mRfGlkQbOMDP`XmW_E3*t
z-`AKM3+0WGZdWLs#^vpyuvMg6MBZRMc9O1*uwXq_6V?;TyOOXep>o#{wmFn;6=9X3
zbZZIQ7)sYgSa~R&YyRLnIF5EQ$GHBUI6au^BmTDYK^wZu}?+U{d6yg3c80Ipy^DCsi{^$tc?~A8zt@s(!v*MxfqJda61I`Bz3?!0
zej3SQoae(~Z;`Gc%2?CqQH8G@VeNzk|Mn182|skMzWZAWzHnF`ZP*>kTb3m(LfGa|
zx@eZL3c~VEaV7fiDOtj%5w@Oza#(=A+ALu$gjIrXdPN#%J7GExU+4aR*xyAHC!QS{
zeN|0!Vn#h~1>?t^HSW}tPl=B4e|Zzc?wY!q8TDR{BshPfcII18o^bkUUjKmw6AE(%
z^ef6Q>33LOS+Ct>w0l~6a(%65AbEs&<7(&5Ca3?#(Zj^pJ>?9bnz*LA2Br6ZBpO;g90Tk5525_W
z<)NOa#@d>e8gE?Ptm<2uw0&mMRM#{$)y(zNxZk(U1SRNd?x>$hQH`MRv(9L4_QtU%
zEWZJ7+=Qzx8&}hUZ^n!{cy?uF^ClabYkP^-O!~{UGn>{-KJ3pVT1)w`-($4q@nL_o
z)0)VK{gGH}Cm;4lT&<~m*q@!Xrt@JRvDQC6?9b?1I()8KDSBRnG1rgh!}-8p
zZdyY$p}DLmgX2)1_m_Q_5L05;y;_k<&314<;2VHP2jZ39@ylbz5$yP(74l8M?$6=x
zw)}MI$6J0W{a0LK-Y&hyZ~w2@d!8SHrLT*goxC-+*IHQg?GB_DJ?SyB*gJs=3r+;m
z*Y=G+#fE;3gZ^K!$MFbeTy*7et%w;DHEcM3tO=x7dFgSl*kkH5u*=^GtnqGaAphP_
z{`5Fk?0u8;f`jFi1N(nIy-pt0UOy$h;3|v12e=J*g@r|*#y$V9*!u_Zg4Yn>>a!~l
zuk;!d{l8-G2t-Tp6atj~Okj=uj=n2_HD4xeyxL>PY5X&P#omL&k2pS)|LwpoUgZr7
zq+d>Y!4=Ty=qn$enZ7Cjzesw)Ljvim`g91NUum79*n5NYf)|6*;olQVues9yEA|dy
z$PqlrrXK~Y`CL6;`OgQ|+LLdr4SX$ctzU=Pc=2OV-+I=kC%xt^_8LepSXC0f1;E|F
zPJYCn&g1!K{))Zj#0wrmJ(T|2z^g{$mrlIkUSO?<kh@6k!a=Fi8!A^`u8
z^n#PbyZTmK;HP%{aW)3QzaqWhMS=9|Lg}T~`G3XUUq~;wHITkyVme;(Fev~RG35zX
zzjySMU6`4EL;xN^dck`s$E9C&aXS5F#Lqe*vwg;nO2@1Gi2j+sVy~X`f>#F0U(>g6
z_4z0L%%$%nz2M;Z(>gUBFVt-T_*eH~si&+n*VZ~QGoQ4&@>bW$m`0{V0Va2z2iSo16&2H`9<)M0>%npsl0+u1$Oo+
z!8ZasTaw`Uz|N*6cqOp2dkNkET!pRZNQ-X=a4YZ;7A`CVe;|G&u(K^GevvVqbK5%y+
z{&8Su&sF@Ffj1Hln+^VN0Xy4^;(rL-6Nujk?Cd{^{{!%@K>T~a&bFlZ_kpF9I{uWv
zh*DrzpQC_>0K4)}1dasKp9LHZ#7_Zs_8sBB7TDQ^1lIyPdy?QLU}x77+y?AyWP(2n
z90xyQZR)=acvb*@7B~@r*8sN$;8%d#fEmV3{x^Z0Ell`(fR_g1{{)-_7F!hmZ{V&#
zd;yGF6M)NryMY;wP5KD%`T#r@cw+!A2i_cjCjs{a;27}s06ZOd7cgp?!GA089$HQdZbZ0-KFAM%9a2NJZpZ>$WUf}7(mmv^}-woVByrXyEA)eWL
zaqw_p?YlVmJYem)I5-BJ48V5+dja?{VC}QG^ece1$Kv3%z==TmUjS=w#l^o3JSzb2
z0geaYLIy_dr?~V-18XnE!Jh=yK8k}c0Dda~R{`${zzN{m0KU%vPYJ*sz}ho$_`U>O
z7=T{@)?SH=?*Z06iGvFmxV1;(;M0Id2jGi<^8)boz}gpa>1PA)4bZy?cx52|+rWzh
za5wOZ0Q@sx?SVLaJ;2)kaPa%UQv>mbA~@><@X^4N0`M5%XaGJ7cwGS2nS|QsaQLqQ
zt_;96z+(gOoxqC%@Otjs@Uhz^elANx<4$aOIs1tbGLsUka=}1qa^-#u8^ZpQ|L2c~qrvC@9qtW9Q4;L%
zUjrNkj*uY7JKTE&I2MS13V2!o{xWb?0DcZQ9)Q0MTpNJb12+IO3>p0Y1Kb*je;0UO
z0Dd31EdZBb@@o&kM*=Sjz@vZ{2jKC*9Rc`a;A8-91MUvMi-Fe#;HAKu0`RlIy8`g{
zfXf2%@H5~c0r*eA!vgU8zzqSogo&s%03QuJF944PZV$lcYT~kgvJXxHcJ@+fm6s3~
z9p_RMd)E-}V7ESK2*fM>ya0R~=^gCSuMNaYo}9f^-UZ6<{Dic={}lNh?D9uGnWpD)
z;v?`+5-Ir-K4<@>=XqZu-of$^5Ptb0`G3XUtHe9l;cp4V3!i+D{J%rJUy|Oz(xMfw
z^8LTVy)Zu&@9fohJ$bvy?_g==ig)~$CsMz|({Nzd+Mrka3?$z1OY`qhz|NkXL;MI}
zM~~v8!18_4pW;=2XMdNcl*-?9v|{yFWcaf=08b{r`_q_kV+d{t!FPw?2Se}|Lh!R8
z_(vglV*oym@^=Ja(X%H2M}W(;kg|V@KQ;u93&9m3_-bIszf$C>CKP{10A?uh+5)i3
zdn^Pm55fN(f?o;2{}Y0Dh2Wx3*vj!T^$WpK;EnWe{fYi_Lh)08)AcL!t_a0fhv3E#
zyeI^JJ_J7>f?oi3`xl2XN_PVX>Dv%WuLB$1pX&Gb5S)wQR_p(HBjm4F>-y|I$SACt(lZ5_8LO)69AA*kU_pOBgvxNS0LjOIX{{uSC4=AJIVtYUF*?7F-
z`3kgM!K#o4=U;
zGYS2Lgua*1?Sy_cq5BE_^@RRTM9-uAA4N3l^ET+;`RAuk!N2|~;lG>E?odvmZw^+dH>#kxv(ZjI(ew7%cRs
zqnB_H{o?W^?3dtfjN`)vY}Ht3H2hzkz+gH%X-wu`=mUfYXT~3A{Zn^1o_k^V|H*rd
zy#2xO0gm|cJT_oK09(Xu8kxJJyzqI$G2f7Qa0W=Fkiv4fG35@5jj$yE!6GN7E1(kq
z2MUNQsBMyrT%Mh-=h)Hd+GKWix}M3y)5>w}%RwecS$oh>C2}`I)$5BdfNkpe(c$WP
z0S`FiduW_Jes&cbAdKtgz3GKj|2lXuZE;A`BGOOjnf)b);450!
zlk`+#`-FHMrg-+Hfv(X&mQ(8`94KV=vKs0!-tiIwR3=507z*KFdKcq
zkTg#6X}@u+TC9zoDu-r$V>eUaCOeUFVJG%0N)xW45+wtJ90M7suU6CzJ6BzRAvANr
zZ7>^HBg_T#)SYFcY7WB;04fgMS!E$I8p>TklEe0^aXverPR;=fT
z4JwD$UQ_lh4|#EI<(3RN2Bq${d%f3OXMd~J>uzs3*I2r}viLHKt>N5K9o2A_upLp$
zJ9R|BD-Z@9b{V>WFi4<^AP7i77?=nUQV>9FvtyXDn%t;C#7>X%1BgFct
zTt7l=j3gK$VgCV7Fq8#oDG%poQ4y@5MfpNtRUtD`P>%?DK`6irT1)^KvoH`FlXl##6Xru=yG}7Y~22$Y)jr6F6Mk*#y
zXuM(<2GT
z|KXNHEd8JMv1I_rHiGux`H_&Aj-X(!sKVIg5p{kAyXW+nHgu2{bTH;*8h81&}w1kLR6^_R#%Ig@T
z13c?j85r$&a4?1f8Wo;bRcKu71_#0xT72O1Vf*X7mT>43tcQw-TE`gJz%KJ0dCtt4
z#dVHW1a9)vDi94dmQw2=DOqu9BAqxf#+986W8x7cw4k&K5^G^dWnV?H#Qj;6VZ26q
zsPW&Fj)t0%07@;2EW1mJ)J+;K{=czFVS3FFkiDr$C*e48#3aLv!hU;;ww6vtCSiN29>ALBb2U)}8+5wr<%YA#G+Ci++pfK}hRSNq?S7a~;F!ik
z;HIp?~)O}wRAr=WrCrJf+fV!2HaGWo2AWIX~^
zYbw-XI(1k>L}!s@uj^b-eTa46-RzK6zzH^e)P#DGne+@>J<3KzOE1@|)iLOQh_o+}
zVC#a?fxQPw5Re81PZ7c{!cp)dWUQO)sC
zym4p^lv^rlvwwchN5?N^S7;pDhPhE%MrAzgPsgaW%jEE$DhN5KW}^DH+*)=9nrXIZ
zAnc!FQ7^Q5Q?Z<{ilnp$QI!-sZ1FHUfEV5uLUSewLp_9GFoprTFoh9
zyoxsfMGLCS5#ryvLkoh!yxB;ZK}pDq5d|G=oQ6%yF|%$1l-lv1*nxDgS`=z2i*+>2
z5sXTfYmp;06cn>b;9k0F*x~Us>kskFHOpMfKd+$tJ(rJVqBum_Jphaof;p@NA{m#l
zR?%$t0OnrQcnc>kL-jkDt3Y+J>c^$isL2?#P?Fk9uK2SyJ~-CbCKtqHMlp2!XvB~`
z7m|1dmlh|rg)NR5igJc*p5x~TFtY*Vwso8hFpjWzkOLW8m$Z}U$#~;rgoCHZ2)c$@
zs;Zf~1FZcFJx3f|=Z;4BK@GGBKaCOlC=3WcVc6g_Wdhoah)YoQxv
z*)r=+%`|i0$k3~MoF>7JTOF(^m;()&0|&Jx?zOM9>9(1B&2q3IFYjsm*8*X@tHEo<
zHnK@RV=i3v3)YKZaR4zi0?53$6=^f@AWIP}-xaqT;)N6}~hp7hYKohk}v4
zuQ-gIB0E^qSG{&J7mS3qfaOOyR%3)fxm5(7X=nH=5>f7>2qyOk
z_spMXEco3$1NWoaW#xVi5hiCCU_)bq$6JQiBRQTuW_TVy_-L0U`DP@?Jyr~n`a*lZ
z?d4E)IqSspPTYrXm!)}v2$n)Q?onj0vM6i!-@`qVi@vzG@JYSgTadwaaFOF4%nw~7
z_cml$F7xAF$mg$-`#Jd3G3B`D@#B#D7w)ZI{A63+L9qO|_wjwm;Wz2SMLCAwAebEY
zRQ}_;z#U?T`^)t5ThP2`x!gN9|NZCYej4Rxa=!

literal 119216
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
bWtPOp>lIYq;;_lhPbtkwwPOTX3B(Klb%P}w

literal 0
HcmV?d00001

diff --git a/PriorityQueue/CAStar.so b/PriorityQueue/CAStar.so
new file mode 100644
index 0000000000000000000000000000000000000000..0301528842cf61905f41e4a81945e373001acbca
GIT binary patch
literal 58300
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
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
@@ -47,6 +47,8 @@
   #define CYTHON_COMPILING_IN_CPYTHON 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
@@ -74,6 +76,8 @@
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
@@ -105,6 +109,12 @@
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #if PY_VERSION_HEX < 0x02070000
+    #undef CYTHON_USE_PYTYPE_LOOKUP
+    #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+    #define CYTHON_USE_PYTYPE_LOOKUP 1
+  #endif
   #if PY_MAJOR_VERSION < 3
     #undef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 0
@@ -467,8 +477,8 @@ static CYTHON_INLINE float __PYX_NAN() {
   #endif
 #endif
 
-#define __PYX_HAVE__PriorityQueueC
-#define __PYX_HAVE_API__PriorityQueueC
+#define __PYX_HAVE__PriorityQueue__PriorityQueueC
+#define __PYX_HAVE_API__PriorityQueue__PriorityQueueC
 #ifdef _OPENMP
 #include 
 #endif /* _OPENMP */
@@ -1014,12 +1024,12 @@ static int __Pyx_check_binary_version(void);
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
 
-/* Module declarations from 'PriorityQueueC' */
-static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *, PyObject *); /*proto*/
-#define __Pyx_MODULE_NAME "PriorityQueueC"
-int __pyx_module_is_main_PriorityQueueC = 0;
+/* Module declarations from 'PriorityQueue.PriorityQueueC' */
+static PyObject *__pyx_f_13PriorityQueue_14PriorityQueueC_BinarySearch(PyObject *, PyObject *); /*proto*/
+#define __Pyx_MODULE_NAME "PriorityQueue.PriorityQueueC"
+int __pyx_module_is_main_PriorityQueue__PriorityQueueC = 0;
 
-/* Implementation of 'PriorityQueueC' */
+/* Implementation of 'PriorityQueue.PriorityQueueC' */
 static PyObject *__pyx_builtin_ValueError;
 static const char __pyx_k_doc[] = "__doc__";
 static const char __pyx_k_pop[] = "pop";
@@ -1029,7 +1039,7 @@ static const char __pyx_k_item[] = "item";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_self[] = "self";
 static const char __pyx_k_test[] = "__test__";
-static const char __pyx_k_Queue[] = "Queue";
+static const char __pyx_k_Queue[] = "_Queue";
 static const char __pyx_k_found[] = "found";
 static const char __pyx_k_index[] = "index";
 static const char __pyx_k_insert[] = "insert";
@@ -1040,7 +1050,6 @@ static const char __pyx_k_qualname[] = "__qualname__";
 static const char __pyx_k_metaclass[] = "__metaclass__";
 static const char __pyx_k_ValueError[] = "ValueError";
 static const char __pyx_k_PriorityQueue[] = "PriorityQueue";
-static const char __pyx_k_PriorityQueueC[] = "PriorityQueueC";
 static const char __pyx_k_PriorityQueue_pop[] = "PriorityQueue.pop";
 static const char __pyx_k_PriorityQueue_put[] = "PriorityQueue.put";
 static const char __pyx_k_PriorityQueueC_pyx[] = "PriorityQueueC.pyx";
@@ -1048,10 +1057,11 @@ static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
 static const char __pyx_k_PriorityQueue___init[] = "PriorityQueue.__init__";
 static const char __pyx_k_PriorityQueue_remove[] = "PriorityQueue.remove";
 static const char __pyx_k_Item_not_in_priority_queue[] = "Item not in priority queue";
+static const char __pyx_k_PriorityQueue_PriorityQueueC[] = "PriorityQueue.PriorityQueueC";
 static PyObject *__pyx_kp_s_Item_not_in_priority_queue;
 static PyObject *__pyx_n_s_PriorityQueue;
-static PyObject *__pyx_n_s_PriorityQueueC;
 static PyObject *__pyx_kp_s_PriorityQueueC_pyx;
+static PyObject *__pyx_n_s_PriorityQueue_PriorityQueueC;
 static PyObject *__pyx_n_s_PriorityQueue___init;
 static PyObject *__pyx_n_s_PriorityQueue_pop;
 static PyObject *__pyx_n_s_PriorityQueue_put;
@@ -1075,10 +1085,10 @@ static PyObject *__pyx_n_s_qualname;
 static PyObject *__pyx_n_s_remove;
 static PyObject *__pyx_n_s_self;
 static PyObject *__pyx_n_s_test;
-static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_2put(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_item); /* proto */
-static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_4pop(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_6remove(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_item); /* proto */
+static PyObject *__pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_2put(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_item); /* proto */
+static PyObject *__pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_4pop(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_6remove(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_item); /* proto */
 static PyObject *__pyx_int_0;
 static PyObject *__pyx_tuple_;
 static PyObject *__pyx_tuple__2;
@@ -1090,38 +1100,38 @@ static PyObject *__pyx_codeobj__5;
 static PyObject *__pyx_codeobj__7;
 static PyObject *__pyx_codeobj__9;
 
-/* "PriorityQueueC.pyx":5
+/* "PriorityQueue/PriorityQueueC.pyx":5
  * 
  * class PriorityQueue:
  *     def __init__(self):             # <<<<<<<<<<<<<<
- *         self.Queue = []
+ *         self._Queue = []
  * 
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_1__init__(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static PyMethodDef __pyx_mdef_14PriorityQueueC_13PriorityQueue_1__init__ = {"__init__", (PyCFunction)__pyx_pw_14PriorityQueueC_13PriorityQueue_1__init__, METH_O, 0};
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_1__init__(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_1__init__(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static PyMethodDef __pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_1__init__ = {"__init__", (PyCFunction)__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_1__init__, METH_O, 0};
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_1__init__(PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_14PriorityQueueC_13PriorityQueue___init__(__pyx_self, ((PyObject *)__pyx_v_self));
+  __pyx_r = __pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue___init__(__pyx_self, ((PyObject *)__pyx_v_self));
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   __Pyx_RefNannySetupContext("__init__", 0);
 
-  /* "PriorityQueueC.pyx":6
+  /* "PriorityQueue/PriorityQueueC.pyx":6
  * class PriorityQueue:
  *     def __init__(self):
- *         self.Queue = []             # <<<<<<<<<<<<<<
+ *         self._Queue = []             # <<<<<<<<<<<<<<
  * 
  *     def put(self,item):
  */
@@ -1130,11 +1140,11 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue___init__(CYTHON_UNUSE
   if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Queue, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "PriorityQueueC.pyx":5
+  /* "PriorityQueue/PriorityQueueC.pyx":5
  * 
  * class PriorityQueue:
  *     def __init__(self):             # <<<<<<<<<<<<<<
- *         self.Queue = []
+ *         self._Queue = []
  * 
  */
 
@@ -1143,7 +1153,7 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue___init__(CYTHON_UNUSE
   goto __pyx_L0;
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("PriorityQueueC.PriorityQueue.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.PriorityQueue.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
@@ -1151,8 +1161,8 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue___init__(CYTHON_UNUSE
   return __pyx_r;
 }
 
-/* "PriorityQueueC.pyx":8
- *         self.Queue = []
+/* "PriorityQueue/PriorityQueueC.pyx":8
+ *         self._Queue = []
  * 
  *     def put(self,item):             # <<<<<<<<<<<<<<
  *         cdef int index
@@ -1160,9 +1170,9 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue___init__(CYTHON_UNUSE
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_3put(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyMethodDef __pyx_mdef_14PriorityQueueC_13PriorityQueue_3put = {"put", (PyCFunction)__pyx_pw_14PriorityQueueC_13PriorityQueue_3put, METH_VARARGS|METH_KEYWORDS, 0};
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_3put(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_3put(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_3put = {"put", (PyCFunction)__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_3put, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_3put(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   PyObject *__pyx_v_self = 0;
   PyObject *__pyx_v_item = 0;
   PyObject *__pyx_r = 0;
@@ -1210,18 +1220,18 @@ static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_3put(PyObject *__pyx_
   __pyx_L5_argtuple_error:;
   __Pyx_RaiseArgtupleInvalid("put", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 8, __pyx_L3_error)
   __pyx_L3_error:;
-  __Pyx_AddTraceback("PriorityQueueC.PriorityQueue.put", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.PriorityQueue.put", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_14PriorityQueueC_13PriorityQueue_2put(__pyx_self, __pyx_v_self, __pyx_v_item);
+  __pyx_r = __pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_2put(__pyx_self, __pyx_v_self, __pyx_v_item);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_2put(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_item) {
+static PyObject *__pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_2put(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_item) {
   int __pyx_v_index;
   CYTHON_UNUSED PyObject *__pyx_v_found = NULL;
   PyObject *__pyx_r = NULL;
@@ -1237,17 +1247,17 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_2put(CYTHON_UNUSED Py
   PyObject *__pyx_t_9 = NULL;
   __Pyx_RefNannySetupContext("put", 0);
 
-  /* "PriorityQueueC.pyx":11
+  /* "PriorityQueue/PriorityQueueC.pyx":11
  *         cdef int index
  * ##        print(self.Queue,  "<--" , item)
- *         found,index = BinarySearch(self.Queue,item)             # <<<<<<<<<<<<<<
- *         if self.Queue != [] and self.Queue[index] < item:
+ *         found,index = BinarySearch(self._Queue,item)             # <<<<<<<<<<<<<<
+ *         if self._Queue != [] and self._Queue[index] < item:
  *             index +=1
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 11, __pyx_L1_error)
-  __pyx_t_2 = __pyx_f_14PriorityQueueC_BinarySearch(((PyObject*)__pyx_t_1), __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 11, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_13PriorityQueue_14PriorityQueueC_BinarySearch(((PyObject*)__pyx_t_1), __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 11, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
@@ -1306,12 +1316,12 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_2put(CYTHON_UNUSED Py
   __pyx_t_1 = 0;
   __pyx_v_index = __pyx_t_6;
 
-  /* "PriorityQueueC.pyx":12
+  /* "PriorityQueue/PriorityQueueC.pyx":12
  * ##        print(self.Queue,  "<--" , item)
- *         found,index = BinarySearch(self.Queue,item)
- *         if self.Queue != [] and self.Queue[index] < item:             # <<<<<<<<<<<<<<
+ *         found,index = BinarySearch(self._Queue,item)
+ *         if self._Queue != [] and self._Queue[index] < item:             # <<<<<<<<<<<<<<
  *             index +=1
- *         self.Queue.insert(index,item)
+ *         self._Queue.insert(index,item)
  */
   __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
@@ -1340,28 +1350,28 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_2put(CYTHON_UNUSED Py
   __pyx_L6_bool_binop_done:;
   if (__pyx_t_7) {
 
-    /* "PriorityQueueC.pyx":13
- *         found,index = BinarySearch(self.Queue,item)
- *         if self.Queue != [] and self.Queue[index] < item:
+    /* "PriorityQueue/PriorityQueueC.pyx":13
+ *         found,index = BinarySearch(self._Queue,item)
+ *         if self._Queue != [] and self._Queue[index] < item:
  *             index +=1             # <<<<<<<<<<<<<<
- *         self.Queue.insert(index,item)
+ *         self._Queue.insert(index,item)
  * ##        print(self.Queue,index)
  */
     __pyx_v_index = (__pyx_v_index + 1);
 
-    /* "PriorityQueueC.pyx":12
+    /* "PriorityQueue/PriorityQueueC.pyx":12
  * ##        print(self.Queue,  "<--" , item)
- *         found,index = BinarySearch(self.Queue,item)
- *         if self.Queue != [] and self.Queue[index] < item:             # <<<<<<<<<<<<<<
+ *         found,index = BinarySearch(self._Queue,item)
+ *         if self._Queue != [] and self._Queue[index] < item:             # <<<<<<<<<<<<<<
  *             index +=1
- *         self.Queue.insert(index,item)
+ *         self._Queue.insert(index,item)
  */
   }
 
-  /* "PriorityQueueC.pyx":14
- *         if self.Queue != [] and self.Queue[index] < item:
+  /* "PriorityQueue/PriorityQueueC.pyx":14
+ *         if self._Queue != [] and self._Queue[index] < item:
  *             index +=1
- *         self.Queue.insert(index,item)             # <<<<<<<<<<<<<<
+ *         self._Queue.insert(index,item)             # <<<<<<<<<<<<<<
  * ##        print(self.Queue,index)
  * 
  */
@@ -1421,8 +1431,8 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_2put(CYTHON_UNUSED Py
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "PriorityQueueC.pyx":8
- *         self.Queue = []
+  /* "PriorityQueue/PriorityQueueC.pyx":8
+ *         self._Queue = []
  * 
  *     def put(self,item):             # <<<<<<<<<<<<<<
  *         cdef int index
@@ -1438,7 +1448,7 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_2put(CYTHON_UNUSED Py
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_AddTraceback("PriorityQueueC.PriorityQueue.put", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.PriorityQueue.put", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF(__pyx_v_found);
@@ -1447,39 +1457,39 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_2put(CYTHON_UNUSED Py
   return __pyx_r;
 }
 
-/* "PriorityQueueC.pyx":17
+/* "PriorityQueue/PriorityQueueC.pyx":17
  * ##        print(self.Queue,index)
  * 
  *     def pop(self):             # <<<<<<<<<<<<<<
- *         return self.Queue.pop(0)
+ *         return self._Queue.pop(0)
  * 
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_5pop(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static PyMethodDef __pyx_mdef_14PriorityQueueC_13PriorityQueue_5pop = {"pop", (PyCFunction)__pyx_pw_14PriorityQueueC_13PriorityQueue_5pop, METH_O, 0};
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_5pop(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_5pop(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static PyMethodDef __pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_5pop = {"pop", (PyCFunction)__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_5pop, METH_O, 0};
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_5pop(PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("pop (wrapper)", 0);
-  __pyx_r = __pyx_pf_14PriorityQueueC_13PriorityQueue_4pop(__pyx_self, ((PyObject *)__pyx_v_self));
+  __pyx_r = __pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_4pop(__pyx_self, ((PyObject *)__pyx_v_self));
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_4pop(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_4pop(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
   __Pyx_RefNannySetupContext("pop", 0);
 
-  /* "PriorityQueueC.pyx":18
+  /* "PriorityQueue/PriorityQueueC.pyx":18
  * 
  *     def pop(self):
- *         return self.Queue.pop(0)             # <<<<<<<<<<<<<<
+ *         return self._Queue.pop(0)             # <<<<<<<<<<<<<<
  * 
  *     def remove(self,item):
  */
@@ -1493,11 +1503,11 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_4pop(CYTHON_UNUSED Py
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "PriorityQueueC.pyx":17
+  /* "PriorityQueue/PriorityQueueC.pyx":17
  * ##        print(self.Queue,index)
  * 
  *     def pop(self):             # <<<<<<<<<<<<<<
- *         return self.Queue.pop(0)
+ *         return self._Queue.pop(0)
  * 
  */
 
@@ -1505,7 +1515,7 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_4pop(CYTHON_UNUSED Py
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("PriorityQueueC.PriorityQueue.pop", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.PriorityQueue.pop", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
@@ -1513,18 +1523,18 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_4pop(CYTHON_UNUSED Py
   return __pyx_r;
 }
 
-/* "PriorityQueueC.pyx":20
- *         return self.Queue.pop(0)
+/* "PriorityQueue/PriorityQueueC.pyx":20
+ *         return self._Queue.pop(0)
  * 
  *     def remove(self,item):             # <<<<<<<<<<<<<<
  *         cdef int index
- *         found,index = BinarySearch(self.Queue,item)
+ *         found,index = BinarySearch(self._Queue,item)
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_7remove(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyMethodDef __pyx_mdef_14PriorityQueueC_13PriorityQueue_7remove = {"remove", (PyCFunction)__pyx_pw_14PriorityQueueC_13PriorityQueue_7remove, METH_VARARGS|METH_KEYWORDS, 0};
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_7remove(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_7remove(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_7remove = {"remove", (PyCFunction)__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_7remove, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_7remove(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   PyObject *__pyx_v_self = 0;
   PyObject *__pyx_v_item = 0;
   PyObject *__pyx_r = 0;
@@ -1572,18 +1582,18 @@ static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_7remove(PyObject *__p
   __pyx_L5_argtuple_error:;
   __Pyx_RaiseArgtupleInvalid("remove", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 20, __pyx_L3_error)
   __pyx_L3_error:;
-  __Pyx_AddTraceback("PriorityQueueC.PriorityQueue.remove", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.PriorityQueue.remove", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_14PriorityQueueC_13PriorityQueue_6remove(__pyx_self, __pyx_v_self, __pyx_v_item);
+  __pyx_r = __pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_6remove(__pyx_self, __pyx_v_self, __pyx_v_item);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_6remove(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_item) {
+static PyObject *__pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_6remove(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_item) {
   int __pyx_v_index;
   PyObject *__pyx_v_found = NULL;
   PyObject *__pyx_r = NULL;
@@ -1597,17 +1607,17 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_6remove(CYTHON_UNUSED
   int __pyx_t_7;
   __Pyx_RefNannySetupContext("remove", 0);
 
-  /* "PriorityQueueC.pyx":22
+  /* "PriorityQueue/PriorityQueueC.pyx":22
  *     def remove(self,item):
  *         cdef int index
- *         found,index = BinarySearch(self.Queue,item)             # <<<<<<<<<<<<<<
+ *         found,index = BinarySearch(self._Queue,item)             # <<<<<<<<<<<<<<
  *         if found:
- *             self.Queue.pop(index)
+ *             self._Queue.pop(index)
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 22, __pyx_L1_error)
-  __pyx_t_2 = __pyx_f_14PriorityQueueC_BinarySearch(((PyObject*)__pyx_t_1), __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_13PriorityQueue_14PriorityQueueC_BinarySearch(((PyObject*)__pyx_t_1), __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
@@ -1666,20 +1676,20 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_6remove(CYTHON_UNUSED
   __pyx_t_1 = 0;
   __pyx_v_index = __pyx_t_6;
 
-  /* "PriorityQueueC.pyx":23
+  /* "PriorityQueue/PriorityQueueC.pyx":23
  *         cdef int index
- *         found,index = BinarySearch(self.Queue,item)
+ *         found,index = BinarySearch(self._Queue,item)
  *         if found:             # <<<<<<<<<<<<<<
- *             self.Queue.pop(index)
+ *             self._Queue.pop(index)
  *         else:
  */
   __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_found); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 23, __pyx_L1_error)
   if (__pyx_t_7) {
 
-    /* "PriorityQueueC.pyx":24
- *         found,index = BinarySearch(self.Queue,item)
+    /* "PriorityQueue/PriorityQueueC.pyx":24
+ *         found,index = BinarySearch(self._Queue,item)
  *         if found:
- *             self.Queue.pop(index)             # <<<<<<<<<<<<<<
+ *             self._Queue.pop(index)             # <<<<<<<<<<<<<<
  *         else:
  *             raise ValueError("Item not in priority queue")
  */
@@ -1690,18 +1700,18 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_6remove(CYTHON_UNUSED
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-    /* "PriorityQueueC.pyx":23
+    /* "PriorityQueue/PriorityQueueC.pyx":23
  *         cdef int index
- *         found,index = BinarySearch(self.Queue,item)
+ *         found,index = BinarySearch(self._Queue,item)
  *         if found:             # <<<<<<<<<<<<<<
- *             self.Queue.pop(index)
+ *             self._Queue.pop(index)
  *         else:
  */
     goto __pyx_L5;
   }
 
-  /* "PriorityQueueC.pyx":26
- *             self.Queue.pop(index)
+  /* "PriorityQueue/PriorityQueueC.pyx":26
+ *             self._Queue.pop(index)
  *         else:
  *             raise ValueError("Item not in priority queue")             # <<<<<<<<<<<<<<
  * 
@@ -1716,12 +1726,12 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_6remove(CYTHON_UNUSED
   }
   __pyx_L5:;
 
-  /* "PriorityQueueC.pyx":20
- *         return self.Queue.pop(0)
+  /* "PriorityQueue/PriorityQueueC.pyx":20
+ *         return self._Queue.pop(0)
  * 
  *     def remove(self,item):             # <<<<<<<<<<<<<<
  *         cdef int index
- *         found,index = BinarySearch(self.Queue,item)
+ *         found,index = BinarySearch(self._Queue,item)
  */
 
   /* function exit code */
@@ -1732,7 +1742,7 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_6remove(CYTHON_UNUSED
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_AddTraceback("PriorityQueueC.PriorityQueue.remove", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.PriorityQueue.remove", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF(__pyx_v_found);
@@ -1741,7 +1751,7 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_6remove(CYTHON_UNUSED
   return __pyx_r;
 }
 
-/* "PriorityQueueC.pyx":29
+/* "PriorityQueue/PriorityQueueC.pyx":29
  * 
  * 
  * cdef BinarySearch(list SearchList,item):             # <<<<<<<<<<<<<<
@@ -1749,7 +1759,7 @@ static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_6remove(CYTHON_UNUSED
  *     found = False
  */
 
-static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchList, PyObject *__pyx_v_item) {
+static PyObject *__pyx_f_13PriorityQueue_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchList, PyObject *__pyx_v_item) {
   int __pyx_v_start;
   int __pyx_v_end;
   int __pyx_v_mid;
@@ -1765,7 +1775,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
   PyObject *__pyx_t_6 = NULL;
   __Pyx_RefNannySetupContext("BinarySearch", 0);
 
-  /* "PriorityQueueC.pyx":31
+  /* "PriorityQueue/PriorityQueueC.pyx":31
  * cdef BinarySearch(list SearchList,item):
  *     cdef int start,end,mid
  *     found = False             # <<<<<<<<<<<<<<
@@ -1774,7 +1784,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
  */
   __pyx_v_found = 0;
 
-  /* "PriorityQueueC.pyx":32
+  /* "PriorityQueue/PriorityQueueC.pyx":32
  *     cdef int start,end,mid
  *     found = False
  *     start = 0             # <<<<<<<<<<<<<<
@@ -1783,7 +1793,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
  */
   __pyx_v_start = 0;
 
-  /* "PriorityQueueC.pyx":33
+  /* "PriorityQueue/PriorityQueueC.pyx":33
  *     found = False
  *     start = 0
  *     end = len(SearchList)-1             # <<<<<<<<<<<<<<
@@ -1797,7 +1807,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
   __pyx_t_1 = PyList_GET_SIZE(__pyx_v_SearchList); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 33, __pyx_L1_error)
   __pyx_v_end = (__pyx_t_1 - 1);
 
-  /* "PriorityQueueC.pyx":34
+  /* "PriorityQueue/PriorityQueueC.pyx":34
  *     start = 0
  *     end = len(SearchList)-1
  *     mid = (start+end)//2             # <<<<<<<<<<<<<<
@@ -1806,7 +1816,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
  */
   __pyx_v_mid = ((__pyx_v_start + __pyx_v_end) / 2);
 
-  /* "PriorityQueueC.pyx":35
+  /* "PriorityQueue/PriorityQueueC.pyx":35
  *     end = len(SearchList)-1
  *     mid = (start+end)//2
  *     while not found and start <= end:             # <<<<<<<<<<<<<<
@@ -1825,7 +1835,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
     __pyx_L5_bool_binop_done:;
     if (!__pyx_t_2) break;
 
-    /* "PriorityQueueC.pyx":36
+    /* "PriorityQueue/PriorityQueueC.pyx":36
  *     mid = (start+end)//2
  *     while not found and start <= end:
  *         mid = (start+end)//2             # <<<<<<<<<<<<<<
@@ -1834,7 +1844,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
  */
     __pyx_v_mid = ((__pyx_v_start + __pyx_v_end) / 2);
 
-    /* "PriorityQueueC.pyx":37
+    /* "PriorityQueue/PriorityQueueC.pyx":37
  *     while not found and start <= end:
  *         mid = (start+end)//2
  *         current = SearchList[mid]             # <<<<<<<<<<<<<<
@@ -1850,7 +1860,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
     __Pyx_XDECREF_SET(__pyx_v_current, __pyx_t_4);
     __pyx_t_4 = 0;
 
-    /* "PriorityQueueC.pyx":38
+    /* "PriorityQueue/PriorityQueueC.pyx":38
  *         mid = (start+end)//2
  *         current = SearchList[mid]
  *         if current < item:             # <<<<<<<<<<<<<<
@@ -1862,7 +1872,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     if (__pyx_t_2) {
 
-      /* "PriorityQueueC.pyx":39
+      /* "PriorityQueue/PriorityQueueC.pyx":39
  *         current = SearchList[mid]
  *         if current < item:
  *             start = mid +1             # <<<<<<<<<<<<<<
@@ -1871,7 +1881,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
  */
       __pyx_v_start = (__pyx_v_mid + 1);
 
-      /* "PriorityQueueC.pyx":38
+      /* "PriorityQueue/PriorityQueueC.pyx":38
  *         mid = (start+end)//2
  *         current = SearchList[mid]
  *         if current < item:             # <<<<<<<<<<<<<<
@@ -1881,7 +1891,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
       goto __pyx_L7;
     }
 
-    /* "PriorityQueueC.pyx":40
+    /* "PriorityQueue/PriorityQueueC.pyx":40
  *         if current < item:
  *             start = mid +1
  *         elif current > item:             # <<<<<<<<<<<<<<
@@ -1893,7 +1903,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     if (__pyx_t_2) {
 
-      /* "PriorityQueueC.pyx":41
+      /* "PriorityQueue/PriorityQueueC.pyx":41
  *             start = mid +1
  *         elif current > item:
  *             end = mid - 1             # <<<<<<<<<<<<<<
@@ -1902,7 +1912,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
  */
       __pyx_v_end = (__pyx_v_mid - 1);
 
-      /* "PriorityQueueC.pyx":40
+      /* "PriorityQueue/PriorityQueueC.pyx":40
  *         if current < item:
  *             start = mid +1
  *         elif current > item:             # <<<<<<<<<<<<<<
@@ -1912,7 +1922,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
       goto __pyx_L7;
     }
 
-    /* "PriorityQueueC.pyx":43
+    /* "PriorityQueue/PriorityQueueC.pyx":43
  *             end = mid - 1
  *         else:
  *             found = True             # <<<<<<<<<<<<<<
@@ -1925,7 +1935,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
     __pyx_L7:;
   }
 
-  /* "PriorityQueueC.pyx":51
+  /* "PriorityQueue/PriorityQueueC.pyx":51
  * ##            end = mid - 1
  * 
  *     return found,mid             # <<<<<<<<<<<<<<
@@ -1948,7 +1958,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
   __pyx_t_6 = 0;
   goto __pyx_L0;
 
-  /* "PriorityQueueC.pyx":29
+  /* "PriorityQueue/PriorityQueueC.pyx":29
  * 
  * 
  * cdef BinarySearch(list SearchList,item):             # <<<<<<<<<<<<<<
@@ -1961,7 +1971,7 @@ static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchL
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
   __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_AddTraceback("PriorityQueueC.BinarySearch", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.BinarySearch", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = 0;
   __pyx_L0:;
   __Pyx_XDECREF(__pyx_v_current);
@@ -1995,8 +2005,8 @@ static struct PyModuleDef __pyx_moduledef = {
 static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {&__pyx_kp_s_Item_not_in_priority_queue, __pyx_k_Item_not_in_priority_queue, sizeof(__pyx_k_Item_not_in_priority_queue), 0, 0, 1, 0},
   {&__pyx_n_s_PriorityQueue, __pyx_k_PriorityQueue, sizeof(__pyx_k_PriorityQueue), 0, 0, 1, 1},
-  {&__pyx_n_s_PriorityQueueC, __pyx_k_PriorityQueueC, sizeof(__pyx_k_PriorityQueueC), 0, 0, 1, 1},
   {&__pyx_kp_s_PriorityQueueC_pyx, __pyx_k_PriorityQueueC_pyx, sizeof(__pyx_k_PriorityQueueC_pyx), 0, 0, 1, 0},
+  {&__pyx_n_s_PriorityQueue_PriorityQueueC, __pyx_k_PriorityQueue_PriorityQueueC, sizeof(__pyx_k_PriorityQueue_PriorityQueueC), 0, 0, 1, 1},
   {&__pyx_n_s_PriorityQueue___init, __pyx_k_PriorityQueue___init, sizeof(__pyx_k_PriorityQueue___init), 0, 0, 1, 1},
   {&__pyx_n_s_PriorityQueue_pop, __pyx_k_PriorityQueue_pop, sizeof(__pyx_k_PriorityQueue_pop), 0, 0, 1, 1},
   {&__pyx_n_s_PriorityQueue_put, __pyx_k_PriorityQueue_put, sizeof(__pyx_k_PriorityQueue_put), 0, 0, 1, 1},
@@ -2033,8 +2043,8 @@ static int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
-  /* "PriorityQueueC.pyx":26
- *             self.Queue.pop(index)
+  /* "PriorityQueue/PriorityQueueC.pyx":26
+ *             self._Queue.pop(index)
  *         else:
  *             raise ValueError("Item not in priority queue")             # <<<<<<<<<<<<<<
  * 
@@ -2044,11 +2054,11 @@ static int __Pyx_InitCachedConstants(void) {
   __Pyx_GOTREF(__pyx_tuple_);
   __Pyx_GIVEREF(__pyx_tuple_);
 
-  /* "PriorityQueueC.pyx":5
+  /* "PriorityQueue/PriorityQueueC.pyx":5
  * 
  * class PriorityQueue:
  *     def __init__(self):             # <<<<<<<<<<<<<<
- *         self.Queue = []
+ *         self._Queue = []
  * 
  */
   __pyx_tuple__2 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 5, __pyx_L1_error)
@@ -2056,8 +2066,8 @@ static int __Pyx_InitCachedConstants(void) {
   __Pyx_GIVEREF(__pyx_tuple__2);
   __pyx_codeobj__3 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_PriorityQueueC_pyx, __pyx_n_s_init, 5, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(0, 5, __pyx_L1_error)
 
-  /* "PriorityQueueC.pyx":8
- *         self.Queue = []
+  /* "PriorityQueue/PriorityQueueC.pyx":8
+ *         self._Queue = []
  * 
  *     def put(self,item):             # <<<<<<<<<<<<<<
  *         cdef int index
@@ -2068,11 +2078,11 @@ static int __Pyx_InitCachedConstants(void) {
   __Pyx_GIVEREF(__pyx_tuple__4);
   __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_PriorityQueueC_pyx, __pyx_n_s_put, 8, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 8, __pyx_L1_error)
 
-  /* "PriorityQueueC.pyx":17
+  /* "PriorityQueue/PriorityQueueC.pyx":17
  * ##        print(self.Queue,index)
  * 
  *     def pop(self):             # <<<<<<<<<<<<<<
- *         return self.Queue.pop(0)
+ *         return self._Queue.pop(0)
  * 
  */
   __pyx_tuple__6 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 17, __pyx_L1_error)
@@ -2080,12 +2090,12 @@ static int __Pyx_InitCachedConstants(void) {
   __Pyx_GIVEREF(__pyx_tuple__6);
   __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_PriorityQueueC_pyx, __pyx_n_s_pop, 17, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 17, __pyx_L1_error)
 
-  /* "PriorityQueueC.pyx":20
- *         return self.Queue.pop(0)
+  /* "PriorityQueue/PriorityQueueC.pyx":20
+ *         return self._Queue.pop(0)
  * 
  *     def remove(self,item):             # <<<<<<<<<<<<<<
  *         cdef int index
- *         found,index = BinarySearch(self.Queue,item)
+ *         found,index = BinarySearch(self._Queue,item)
  */
   __pyx_tuple__8 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_item, __pyx_n_s_index, __pyx_n_s_found); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 20, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__8);
@@ -2173,14 +2183,14 @@ PyMODINIT_FUNC PyInit_PriorityQueueC(void)
   #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
   if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
-  if (__pyx_module_is_main_PriorityQueueC) {
+  if (__pyx_module_is_main_PriorityQueue__PriorityQueueC) {
     if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   }
   #if PY_MAJOR_VERSION >= 3
   {
     PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
-    if (!PyDict_GetItemString(modules, "PriorityQueueC")) {
-      if (unlikely(PyDict_SetItemString(modules, "PriorityQueueC", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+    if (!PyDict_GetItemString(modules, "PriorityQueue.PriorityQueueC")) {
+      if (unlikely(PyDict_SetItemString(modules, "PriorityQueue.PriorityQueueC", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
     }
   }
   #endif
@@ -2200,70 +2210,70 @@ PyMODINIT_FUNC PyInit_PriorityQueueC(void)
   if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
 
-  /* "PriorityQueueC.pyx":4
+  /* "PriorityQueue/PriorityQueueC.pyx":4
  * #cython: boundscheck=False, wraparound=False, infer_types=True,cdivision = True
  * 
  * class PriorityQueue:             # <<<<<<<<<<<<<<
  *     def __init__(self):
- *         self.Queue = []
+ *         self._Queue = []
  */
-  __pyx_t_1 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_PriorityQueue, __pyx_n_s_PriorityQueue, (PyObject *) NULL, __pyx_n_s_PriorityQueueC, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_PriorityQueue, __pyx_n_s_PriorityQueue, (PyObject *) NULL, __pyx_n_s_PriorityQueue_PriorityQueueC, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
 
-  /* "PriorityQueueC.pyx":5
+  /* "PriorityQueue/PriorityQueueC.pyx":5
  * 
  * class PriorityQueue:
  *     def __init__(self):             # <<<<<<<<<<<<<<
- *         self.Queue = []
+ *         self._Queue = []
  * 
  */
-  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_14PriorityQueueC_13PriorityQueue_1__init__, 0, __pyx_n_s_PriorityQueue___init, NULL, __pyx_n_s_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_1__init__, 0, __pyx_n_s_PriorityQueue___init, NULL, __pyx_n_s_PriorityQueue_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_init, __pyx_t_2) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "PriorityQueueC.pyx":8
- *         self.Queue = []
+  /* "PriorityQueue/PriorityQueueC.pyx":8
+ *         self._Queue = []
  * 
  *     def put(self,item):             # <<<<<<<<<<<<<<
  *         cdef int index
  * ##        print(self.Queue,  "<--" , item)
  */
-  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_14PriorityQueueC_13PriorityQueue_3put, 0, __pyx_n_s_PriorityQueue_put, NULL, __pyx_n_s_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__5)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_3put, 0, __pyx_n_s_PriorityQueue_put, NULL, __pyx_n_s_PriorityQueue_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__5)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_put, __pyx_t_2) < 0) __PYX_ERR(0, 8, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "PriorityQueueC.pyx":17
+  /* "PriorityQueue/PriorityQueueC.pyx":17
  * ##        print(self.Queue,index)
  * 
  *     def pop(self):             # <<<<<<<<<<<<<<
- *         return self.Queue.pop(0)
+ *         return self._Queue.pop(0)
  * 
  */
-  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_14PriorityQueueC_13PriorityQueue_5pop, 0, __pyx_n_s_PriorityQueue_pop, NULL, __pyx_n_s_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_5pop, 0, __pyx_n_s_PriorityQueue_pop, NULL, __pyx_n_s_PriorityQueue_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_pop, __pyx_t_2) < 0) __PYX_ERR(0, 17, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "PriorityQueueC.pyx":20
- *         return self.Queue.pop(0)
+  /* "PriorityQueue/PriorityQueueC.pyx":20
+ *         return self._Queue.pop(0)
  * 
  *     def remove(self,item):             # <<<<<<<<<<<<<<
  *         cdef int index
- *         found,index = BinarySearch(self.Queue,item)
+ *         found,index = BinarySearch(self._Queue,item)
  */
-  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_14PriorityQueueC_13PriorityQueue_7remove, 0, __pyx_n_s_PriorityQueue_remove, NULL, __pyx_n_s_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_7remove, 0, __pyx_n_s_PriorityQueue_remove, NULL, __pyx_n_s_PriorityQueue_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_remove, __pyx_t_2) < 0) __PYX_ERR(0, 20, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "PriorityQueueC.pyx":4
+  /* "PriorityQueue/PriorityQueueC.pyx":4
  * #cython: boundscheck=False, wraparound=False, infer_types=True,cdivision = True
  * 
  * class PriorityQueue:             # <<<<<<<<<<<<<<
  *     def __init__(self):
- *         self.Queue = []
+ *         self._Queue = []
  */
   __pyx_t_2 = __Pyx_Py3ClassCreate(((PyObject*)&__Pyx_DefaultClassType), __pyx_n_s_PriorityQueue, __pyx_empty_tuple, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
@@ -2271,7 +2281,7 @@ PyMODINIT_FUNC PyInit_PriorityQueueC(void)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "PriorityQueueC.pyx":1
+  /* "PriorityQueue/PriorityQueueC.pyx":1
  * #!python             # <<<<<<<<<<<<<<
  * #cython: boundscheck=False, wraparound=False, infer_types=True,cdivision = True
  * 
@@ -2289,11 +2299,11 @@ PyMODINIT_FUNC PyInit_PriorityQueueC(void)
   __Pyx_XDECREF(__pyx_t_2);
   if (__pyx_m) {
     if (__pyx_d) {
-      __Pyx_AddTraceback("init PriorityQueueC", 0, __pyx_lineno, __pyx_filename);
+      __Pyx_AddTraceback("init PriorityQueue.PriorityQueueC", 0, __pyx_lineno, __pyx_filename);
     }
     Py_DECREF(__pyx_m); __pyx_m = 0;
   } else if (!PyErr_Occurred()) {
-    PyErr_SetString(PyExc_ImportError, "init PriorityQueueC");
+    PyErr_SetString(PyExc_ImportError, "init PriorityQueue.PriorityQueueC");
   }
   __pyx_L0:;
   __Pyx_RefNannyFinishContext();
@@ -3849,10 +3859,14 @@ static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObj
 #ifdef CYTHON_CLINE_IN_TRACEBACK
     return ((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0;
 #else
-    PyObject **cython_runtime_dict;
     PyObject *use_cline;
-    cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime);
-    if (unlikely(!cython_runtime_dict)) {
+#if CYTHON_COMPILING_IN_CPYTHON
+    PyObject **cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime);
+    if (likely(cython_runtime_dict)) {
+      use_cline = PyDict_GetItem(*cython_runtime_dict, __pyx_n_s_cline_in_traceback);
+    } else
+#endif
+    {
       PyObject *ptype, *pvalue, *ptraceback;
       PyObject *use_cline_obj;
       PyErr_Fetch(&ptype, &pvalue, &ptraceback);
@@ -3864,8 +3878,6 @@ static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObj
         use_cline = NULL;
       }
       PyErr_Restore(ptype, pvalue, ptraceback);
-    } else {
-      use_cline = PyDict_GetItem(*_PyObject_GetDictPtr(__pyx_cython_runtime), __pyx_n_s_cline_in_traceback);
     }
     if (!use_cline) {
         c_line = 0;
diff --git a/PriorityQueue/PriorityQueueC.html b/PriorityQueue/PriorityQueueC.html
index c7a90b5..62272b3 100644
--- a/PriorityQueue/PriorityQueueC.html
+++ b/PriorityQueue/PriorityQueueC.html
@@ -1,5 +1,5 @@
 
-
+
 
 
     
@@ -296,7 +296,7 @@
     
 
 
-
Generated by Cython 0.26

+
Generated by Cython 0.26.1

 

     Yellow lines hint at Python interaction.

     Click on a line that starts with a "+" to see the C code that Cython generated for it.
@@ -306,30 +306,30 @@
 
 02: #cython: boundscheck=False, wraparound=False, infer_types=True,cdivision = True

 
 03: 

 
+04: class PriorityQueue:

-
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_PriorityQueue, __pyx_n_s_PriorityQueue, (PyObject *) NULL, __pyx_n_s_PriorityQueueC, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+
  __pyx_t_1 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_PriorityQueue, __pyx_n_s_PriorityQueue, (PyObject *) NULL, __pyx_n_s_PriorityQueue_PriorityQueueC, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
 /* … */
-  __pyx_t_2 = __Pyx_Py3ClassCreate(((PyObject*)&__Pyx_DefaultClassType), __pyx_n_s_PriorityQueue, __pyx_empty_tuple, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_Py3ClassCreate(((PyObject*)&__Pyx_DefaultClassType), __pyx_n_s_PriorityQueue, __pyx_empty_tuple, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PriorityQueue, __pyx_t_2) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PriorityQueue, __pyx_t_2) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
+05:     def __init__(self):

 
/* Python wrapper */
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_1__init__(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static PyMethodDef __pyx_mdef_14PriorityQueueC_13PriorityQueue_1__init__ = {"__init__", (PyCFunction)__pyx_pw_14PriorityQueueC_13PriorityQueue_1__init__, METH_O, 0};
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_1__init__(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_1__init__(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static PyMethodDef __pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_1__init__ = {"__init__", (PyCFunction)__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_1__init__, METH_O, 0};
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_1__init__(PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_14PriorityQueueC_13PriorityQueue___init__(__pyx_self, ((PyObject *)__pyx_v_self));
+  __pyx_r = __pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue___init__(__pyx_self, ((PyObject *)__pyx_v_self));
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("__init__", 0);
@@ -339,7 +339,7 @@
   goto __pyx_L0;
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("PriorityQueueC.PriorityQueue.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.PriorityQueue.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
@@ -347,26 +347,26 @@
   return __pyx_r;
 }
 /* … */
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 5, __pyx_L1_error)
+  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 5, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__2);
   __Pyx_GIVEREF(__pyx_tuple__2);
 /* … */
-  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_14PriorityQueueC_13PriorityQueue_1__init__, 0, __pyx_n_s_PriorityQueue___init, NULL, __pyx_n_s_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_1__init__, 0, __pyx_n_s_PriorityQueue___init, NULL, __pyx_n_s_PriorityQueue_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_init, __pyx_t_2) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_init, __pyx_t_2) < 0) __PYX_ERR(0, 5, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_codeobj__3 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_PriorityQueueC_pyx, __pyx_n_s_init, 5, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(0, 5, __pyx_L1_error)
-
+06:         self.Queue = []

-
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
+  __pyx_codeobj__3 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_PriorityQueueC_pyx, __pyx_n_s_init, 5, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(0, 5, __pyx_L1_error)
+
+06:         self._Queue = []

+
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Queue, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error)
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Queue, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
 07: 

 
+08:     def put(self,item):

 
/* Python wrapper */
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_3put(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyMethodDef __pyx_mdef_14PriorityQueueC_13PriorityQueue_3put = {"put", (PyCFunction)__pyx_pw_14PriorityQueueC_13PriorityQueue_3put, METH_VARARGS|METH_KEYWORDS, 0};
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_3put(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_3put(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_3put = {"put", (PyCFunction)__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_3put, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_3put(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   PyObject *__pyx_v_self = 0;
   PyObject *__pyx_v_item = 0;
   PyObject *__pyx_r = 0;
@@ -395,11 +395,11 @@
         case  1:
         if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_item)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("put", 1, 2, 2, 1); __PYX_ERR(0, 8, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("put", 1, 2, 2, 1); __PYX_ERR(0, 8, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "put") < 0)) __PYX_ERR(0, 8, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "put") < 0)) __PYX_ERR(0, 8, __pyx_L3_error)
       }
     } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
       goto __pyx_L5_argtuple_error;
@@ -412,20 +412,20 @@
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("put", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 8, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("put", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 8, __pyx_L3_error)
   __pyx_L3_error:;
-  __Pyx_AddTraceback("PriorityQueueC.PriorityQueue.put", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.PriorityQueue.put", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_14PriorityQueueC_13PriorityQueue_2put(__pyx_self, __pyx_v_self, __pyx_v_item);
+  __pyx_r = __pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_2put(__pyx_self, __pyx_v_self, __pyx_v_item);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_2put(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_item) {
+static PyObject *__pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_2put(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_item) {
   int __pyx_v_index;
   CYTHON_UNUSED PyObject *__pyx_v_found = NULL;
   PyObject *__pyx_r = NULL;
@@ -441,7 +441,7 @@
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_AddTraceback("PriorityQueueC.PriorityQueue.put", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.PriorityQueue.put", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF(__pyx_v_found);
@@ -450,22 +450,22 @@
   return __pyx_r;
 }
 /* … */
-  __pyx_tuple__4 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_item, __pyx_n_s_index, __pyx_n_s_found); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __pyx_tuple__4 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_item, __pyx_n_s_index, __pyx_n_s_found); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 8, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__4);
   __Pyx_GIVEREF(__pyx_tuple__4);
 /* … */
-  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_14PriorityQueueC_13PriorityQueue_3put, 0, __pyx_n_s_PriorityQueue_put, NULL, __pyx_n_s_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__5)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_3put, 0, __pyx_n_s_PriorityQueue_put, NULL, __pyx_n_s_PriorityQueue_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__5)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_put, __pyx_t_2) < 0) __PYX_ERR(0, 8, __pyx_L1_error)
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_put, __pyx_t_2) < 0) __PYX_ERR(0, 8, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_PriorityQueueC_pyx, __pyx_n_s_put, 8, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_PriorityQueueC_pyx, __pyx_n_s_put, 8, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 8, __pyx_L1_error)
 
 09:         cdef int index

 
 10: ##        print(self.Queue,  "<--" , item)

-
+11:         found,index = BinarySearch(self.Queue,item)

-
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
+
+11:         found,index = BinarySearch(self._Queue,item)

+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 11, __pyx_L1_error)
-  __pyx_t_2 = __pyx_f_14PriorityQueueC_BinarySearch(((PyObject*)__pyx_t_1), __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 11, __pyx_L1_error)
+  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 11, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_13PriorityQueue_14PriorityQueueC_BinarySearch(((PyObject*)__pyx_t_1), __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 11, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
@@ -478,7 +478,7 @@
     if (unlikely(size != 2)) {
       if (size > 2) __Pyx_RaiseTooManyValuesError(2);
       else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-      __PYX_ERR(0, 11, __pyx_L1_error)
+      __PYX_ERR(0, 11, __pyx_L1_error)
     }
     #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
     if (likely(PyTuple_CheckExact(sequence))) {
@@ -491,15 +491,15 @@
     __Pyx_INCREF(__pyx_t_1);
     __Pyx_INCREF(__pyx_t_3);
     #else
-    __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
+    __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 11, __pyx_L1_error)
+    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 11, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     #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, 11, __pyx_L1_error)
+    __pyx_t_4 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 11, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     __pyx_t_5 = Py_TYPE(__pyx_t_4)->tp_iternext;
@@ -507,7 +507,7 @@
     __Pyx_GOTREF(__pyx_t_1);
     index = 1; __pyx_t_3 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
     __Pyx_GOTREF(__pyx_t_3);
-    if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(0, 11, __pyx_L1_error)
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(0, 11, __pyx_L1_error)
     __pyx_t_5 = NULL;
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     goto __pyx_L4_unpacking_done;
@@ -515,37 +515,37 @@
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     __pyx_t_5 = NULL;
     if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-    __PYX_ERR(0, 11, __pyx_L1_error)
+    __PYX_ERR(0, 11, __pyx_L1_error)
     __pyx_L4_unpacking_done:;
   }
-  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 11, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 11, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_found = __pyx_t_1;
   __pyx_t_1 = 0;
   __pyx_v_index = __pyx_t_6;
-
+12:         if self.Queue != [] and self.Queue[index] < item:

-
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error)
+
+12:         if self._Queue != [] and self._Queue[index] < item:

+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 12, __pyx_L1_error)
+  __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 12, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error)
+  __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 12, __pyx_L1_error)
+  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 12, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   if (__pyx_t_8) {
   } else {
     __pyx_t_7 = __pyx_t_8;
     goto __pyx_L6_bool_binop_done;
   }
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_index, int, 1, __Pyx_PyInt_From_int, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 12, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_index, int, 1, __Pyx_PyInt_From_int, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 12, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_v_item, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error)
+  __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_v_item, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 12, __pyx_L1_error)
+  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 12, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_7 = __pyx_t_8;
   __pyx_L6_bool_binop_done:;
@@ -554,13 +554,13 @@
   }
 
+13:             index +=1

 
    __pyx_v_index = (__pyx_v_index + 1);
-
+14:         self.Queue.insert(index,item)

-
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 14, __pyx_L1_error)
+
+14:         self._Queue.insert(index,item)

+
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 14, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_insert); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_insert); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 14, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 14, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_4 = NULL;
   __pyx_t_6 = 0;
@@ -577,7 +577,7 @@
   #if CYTHON_FAST_PYCALL
   if (PyFunction_Check(__pyx_t_2)) {
     PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_v_item};
-    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -586,14 +586,14 @@
   #if CYTHON_FAST_PYCCALL
   if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
     PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_v_item};
-    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   } else
   #endif
   {
-    __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 14, __pyx_L1_error)
+    __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 14, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_9);
     if (__pyx_t_4) {
       __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_4); __pyx_t_4 = NULL;
@@ -604,7 +604,7 @@
     __Pyx_GIVEREF(__pyx_v_item);
     PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_v_item);
     __pyx_t_3 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
   }
@@ -614,20 +614,20 @@
 
 16: 

 
+17:     def pop(self):

 
/* Python wrapper */
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_5pop(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static PyMethodDef __pyx_mdef_14PriorityQueueC_13PriorityQueue_5pop = {"pop", (PyCFunction)__pyx_pw_14PriorityQueueC_13PriorityQueue_5pop, METH_O, 0};
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_5pop(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_5pop(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
+static PyMethodDef __pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_5pop = {"pop", (PyCFunction)__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_5pop, METH_O, 0};
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_5pop(PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("pop (wrapper)", 0);
-  __pyx_r = __pyx_pf_14PriorityQueueC_13PriorityQueue_4pop(__pyx_self, ((PyObject *)__pyx_v_self));
+  __pyx_r = __pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_4pop(__pyx_self, ((PyObject *)__pyx_v_self));
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_4pop(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_4pop(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("pop", 0);
@@ -636,7 +636,7 @@
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("PriorityQueueC.PriorityQueue.pop", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.PriorityQueue.pop", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
@@ -644,20 +644,20 @@
   return __pyx_r;
 }
 /* … */
-  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 17, __pyx_L1_error)
+  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 17, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__6);
   __Pyx_GIVEREF(__pyx_tuple__6);
 /* … */
-  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_14PriorityQueueC_13PriorityQueue_5pop, 0, __pyx_n_s_PriorityQueue_pop, NULL, __pyx_n_s_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_5pop, 0, __pyx_n_s_PriorityQueue_pop, NULL, __pyx_n_s_PriorityQueue_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_pop, __pyx_t_2) < 0) __PYX_ERR(0, 17, __pyx_L1_error)
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_pop, __pyx_t_2) < 0) __PYX_ERR(0, 17, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_PriorityQueueC_pyx, __pyx_n_s_pop, 17, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 17, __pyx_L1_error)
-
+18:         return self.Queue.pop(0)

+  __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_PriorityQueueC_pyx, __pyx_n_s_pop, 17, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 17, __pyx_L1_error)
+
+18:         return self._Queue.pop(0)

 
  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_PopIndex(__pyx_t_1, __pyx_int_0, 0, 1, Py_ssize_t, PyInt_FromSsize_t); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_PopIndex(__pyx_t_1, __pyx_int_0, 0, 1, Py_ssize_t, PyInt_FromSsize_t); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_r = __pyx_t_2;
@@ -666,9 +666,9 @@
 
 19: 

 
+20:     def remove(self,item):

 
/* Python wrapper */
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_7remove(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyMethodDef __pyx_mdef_14PriorityQueueC_13PriorityQueue_7remove = {"remove", (PyCFunction)__pyx_pw_14PriorityQueueC_13PriorityQueue_7remove, METH_VARARGS|METH_KEYWORDS, 0};
-static PyObject *__pyx_pw_14PriorityQueueC_13PriorityQueue_7remove(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_7remove(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_7remove = {"remove", (PyCFunction)__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_7remove, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_13PriorityQueue_14PriorityQueueC_13PriorityQueue_7remove(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
   PyObject *__pyx_v_self = 0;
   PyObject *__pyx_v_item = 0;
   PyObject *__pyx_r = 0;
@@ -697,11 +697,11 @@
         case  1:
         if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_item)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("remove", 1, 2, 2, 1); __PYX_ERR(0, 20, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("remove", 1, 2, 2, 1); __PYX_ERR(0, 20, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "remove") < 0)) __PYX_ERR(0, 20, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "remove") < 0)) __PYX_ERR(0, 20, __pyx_L3_error)
       }
     } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
       goto __pyx_L5_argtuple_error;
@@ -714,20 +714,20 @@
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("remove", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 20, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("remove", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 20, __pyx_L3_error)
   __pyx_L3_error:;
-  __Pyx_AddTraceback("PriorityQueueC.PriorityQueue.remove", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.PriorityQueue.remove", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_14PriorityQueueC_13PriorityQueue_6remove(__pyx_self, __pyx_v_self, __pyx_v_item);
+  __pyx_r = __pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_6remove(__pyx_self, __pyx_v_self, __pyx_v_item);
 
   /* function exit code */
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_14PriorityQueueC_13PriorityQueue_6remove(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_item) {
+static PyObject *__pyx_pf_13PriorityQueue_14PriorityQueueC_13PriorityQueue_6remove(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_item) {
   int __pyx_v_index;
   PyObject *__pyx_v_found = NULL;
   PyObject *__pyx_r = NULL;
@@ -742,7 +742,7 @@
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_AddTraceback("PriorityQueueC.PriorityQueue.remove", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.PriorityQueue.remove", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF(__pyx_v_found);
@@ -751,20 +751,20 @@
   return __pyx_r;
 }
 /* … */
-  __pyx_tuple__8 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_item, __pyx_n_s_index, __pyx_n_s_found); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 20, __pyx_L1_error)
+  __pyx_tuple__8 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_item, __pyx_n_s_index, __pyx_n_s_found); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 20, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__8);
   __Pyx_GIVEREF(__pyx_tuple__8);
 /* … */
-  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_14PriorityQueueC_13PriorityQueue_7remove, 0, __pyx_n_s_PriorityQueue_remove, NULL, __pyx_n_s_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_13PriorityQueue_14PriorityQueueC_13PriorityQueue_7remove, 0, __pyx_n_s_PriorityQueue_remove, NULL, __pyx_n_s_PriorityQueue_PriorityQueueC, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 20, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_remove, __pyx_t_2) < 0) __PYX_ERR(0, 20, __pyx_L1_error)
+  if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_remove, __pyx_t_2) < 0) __PYX_ERR(0, 20, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
 21:         cdef int index

-
+22:         found,index = BinarySearch(self.Queue,item)

-
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)
+
+22:         found,index = BinarySearch(self._Queue,item)

+
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 22, __pyx_L1_error)
-  __pyx_t_2 = __pyx_f_14PriorityQueueC_BinarySearch(((PyObject*)__pyx_t_1), __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
+  if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 22, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_13PriorityQueue_14PriorityQueueC_BinarySearch(((PyObject*)__pyx_t_1), __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
@@ -777,7 +777,7 @@
     if (unlikely(size != 2)) {
       if (size > 2) __Pyx_RaiseTooManyValuesError(2);
       else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-      __PYX_ERR(0, 22, __pyx_L1_error)
+      __PYX_ERR(0, 22, __pyx_L1_error)
     }
     #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
     if (likely(PyTuple_CheckExact(sequence))) {
@@ -790,15 +790,15 @@
     __Pyx_INCREF(__pyx_t_1);
     __Pyx_INCREF(__pyx_t_3);
     #else
-    __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)
+    __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
+    __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     #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, 22, __pyx_L1_error)
+    __pyx_t_4 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     __pyx_t_5 = Py_TYPE(__pyx_t_4)->tp_iternext;
@@ -806,7 +806,7 @@
     __Pyx_GOTREF(__pyx_t_1);
     index = 1; __pyx_t_3 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
     __Pyx_GOTREF(__pyx_t_3);
-    if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(0, 22, __pyx_L1_error)
     __pyx_t_5 = NULL;
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     goto __pyx_L4_unpacking_done;
@@ -814,45 +814,45 @@
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     __pyx_t_5 = NULL;
     if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-    __PYX_ERR(0, 22, __pyx_L1_error)
+    __PYX_ERR(0, 22, __pyx_L1_error)
     __pyx_L4_unpacking_done:;
   }
-  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 22, __pyx_L1_error)
+  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 22, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_found = __pyx_t_1;
   __pyx_t_1 = 0;
   __pyx_v_index = __pyx_t_6;
 
+23:         if found:

-
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_found); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 23, __pyx_L1_error)
+
  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_found); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 23, __pyx_L1_error)
   if (__pyx_t_7) {
 /* … */
     goto __pyx_L5;
   }
-
+24:             self.Queue.pop(index)

-
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error)
+
+24:             self._Queue.pop(index)

+
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Queue); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_3 = __Pyx_PyObject_PopIndex(__pyx_t_2, Py_None, __pyx_v_index, 1, int, __Pyx_PyInt_From_int); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 24, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_PopIndex(__pyx_t_2, Py_None, __pyx_v_index, 1, int, __Pyx_PyInt_From_int); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 24, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
 25:         else:

 
+26:             raise ValueError("Item not in priority queue")

 
  /*else*/ {
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_Raise(__pyx_t_3, 0, 0, 0);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __PYX_ERR(0, 26, __pyx_L1_error)
+    __PYX_ERR(0, 26, __pyx_L1_error)
   }
   __pyx_L5:;
 /* … */
-  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_Item_not_in_priority_queue); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 26, __pyx_L1_error)
+  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_Item_not_in_priority_queue); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 26, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple_);
   __Pyx_GIVEREF(__pyx_tuple_);
 
 27: 

 
 28: 

 
+29: cdef BinarySearch(list SearchList,item):

-
static PyObject *__pyx_f_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchList, PyObject *__pyx_v_item) {
+
static PyObject *__pyx_f_13PriorityQueue_14PriorityQueueC_BinarySearch(PyObject *__pyx_v_SearchList, PyObject *__pyx_v_item) {
   int __pyx_v_start;
   int __pyx_v_end;
   int __pyx_v_mid;
@@ -867,7 +867,7 @@
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
   __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_AddTraceback("PriorityQueueC.BinarySearch", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("PriorityQueue.PriorityQueueC.BinarySearch", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = 0;
   __pyx_L0:;
   __Pyx_XDECREF(__pyx_v_current);
@@ -883,9 +883,9 @@
 
+33:     end = len(SearchList)-1

 
  if (unlikely(__pyx_v_SearchList == Py_None)) {
     PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
-    __PYX_ERR(0, 33, __pyx_L1_error)
+    __PYX_ERR(0, 33, __pyx_L1_error)
   }
-  __pyx_t_1 = PyList_GET_SIZE(__pyx_v_SearchList); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 33, __pyx_L1_error)
+  __pyx_t_1 = PyList_GET_SIZE(__pyx_v_SearchList); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 33, __pyx_L1_error)
   __pyx_v_end = (__pyx_t_1 - 1);
 
+34:     mid = (start+end)//2

 
  __pyx_v_mid = ((__pyx_v_start + __pyx_v_end) / 2);
@@ -906,15 +906,15 @@
 
+37:         current = SearchList[mid]

 
    if (unlikely(__pyx_v_SearchList == Py_None)) {
       PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
-      __PYX_ERR(0, 37, __pyx_L1_error)
+      __PYX_ERR(0, 37, __pyx_L1_error)
     }
     __pyx_t_4 = PyList_GET_ITEM(__pyx_v_SearchList, __pyx_v_mid);
     __Pyx_INCREF(__pyx_t_4);
     __Pyx_XDECREF_SET(__pyx_v_current, __pyx_t_4);
     __pyx_t_4 = 0;
 
+38:         if current < item:

-
    __pyx_t_4 = PyObject_RichCompare(__pyx_v_current, __pyx_v_item, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 38, __pyx_L1_error)
-    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 38, __pyx_L1_error)
+
    __pyx_t_4 = PyObject_RichCompare(__pyx_v_current, __pyx_v_item, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 38, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 38, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     if (__pyx_t_2) {
 /* … */
@@ -923,8 +923,8 @@
 
+39:             start = mid +1

 
      __pyx_v_start = (__pyx_v_mid + 1);
 
+40:         elif current > item:

-
    __pyx_t_4 = PyObject_RichCompare(__pyx_v_current, __pyx_v_item, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 40, __pyx_L1_error)
-    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 40, __pyx_L1_error)
+
    __pyx_t_4 = PyObject_RichCompare(__pyx_v_current, __pyx_v_item, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 40, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 40, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     if (__pyx_t_2) {
 /* … */
@@ -948,11 +948,11 @@
 
 50: 

 
+51:     return found,mid

 
  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_found); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 51, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_found); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 51, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_mid); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 51, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_mid); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 51, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 51, __pyx_L1_error)
+  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 51, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_6);
   __Pyx_GIVEREF(__pyx_t_4);
   PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4);
diff --git a/PriorityQueue/PriorityQueueC.pyd b/PriorityQueue/PriorityQueueC.pyd
new file mode 100644
index 0000000000000000000000000000000000000000..a09935c1c7b6120209678d0bd333a9877d02808e
GIT binary patch
literal 83565
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%0D{kqQZkZ`s+@dlyb^zhC6p$56<~Yu7Gnr?AOf%%G
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
H7>F4FYY!Yz

literal 0
HcmV?d00001

diff --git a/PriorityQueue/__pycache__/__init__.cpython-34.pyc b/PriorityQueue/__pycache__/__init__.cpython-34.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7498fbce020c565b2d8b8a38fabfd03918bbd05e
GIT binary patch
literal 141
zcmaFI!^_36;#4F95IhDEFu(|8H~?`m3y?@*UT=>Px#

literal 0
HcmV?d00001

diff --git a/PriorityQueue/__pycache__/__init__.cpython-35.pyc b/PriorityQueue/__pycache__/__init__.cpython-35.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6e0327bc19d5a126d4d8c6d5ff5459e2a1f1f52d
GIT binary patch
literal 129
zcmWgR<>mS?^Hd}Q5IhDEFu(|8H~?`m3y?@*Ug9wlMt1|z`*brh~a<<$Z`PUVjduo!jQt4&J@Lv!W7J)$$X19peQrHD6^z8
zur#$a^%frr*V#{#@fLf0d}2;ceEdp=A{L;2F!4*z)hZ@3HL*y+&?v?^KewQ?Br`8P
j21RpBe0*kJW=VX!UP0w84x8Nkl+v73J4TQ@fS3UQrN1ys

literal 0
HcmV?d00001