From 60df33bb235891d3bd4e2fe9ef275e0a08b30798 Mon Sep 17 00:00:00 2001
From: BullyWiiPlaza <bullywiihacks@gmail.com>
Date: Tue, 30 May 2017 11:03:23 +0200
Subject: [PATCH] Add the old memory search back to support the VC injection
 tool again

---
 src/common/cafe.h                 | 106 +++++++++++++
 src/common/fs_defs.h              |   3 +-
 src/common/kernel_types.h         |  10 ++
 src/common/os_defs.h              | 100 ------------
 src/common/retain_vars.c          |   2 +
 src/common/retain_vars.h          |   1 +
 src/dynamic_libs/aoc_functions.c  |   1 +
 src/dynamic_libs/os_functions.c   |   6 +
 src/dynamic_libs/os_functions.h   |   5 +
 src/game/memory_area_table.c      |   2 +-
 src/kernel/syscalls.c             |   1 -
 src/pygecko.c                     | 123 ++++++++++++---
 src/system/exception_handler.c    |   4 +-
 src/system/exception_handler.h    |   1 +
 src/system/software_breakpoints.h | 249 ++++++++++++++++++++++++++++++
 src/system/stack.h                |  30 ++++
 src/system/utilities.h            |  24 +++
 tcpgecko.elf                      | Bin 141988 -> 146828 bytes
 18 files changed, 537 insertions(+), 131 deletions(-)
 create mode 100644 src/common/cafe.h
 create mode 100644 src/common/kernel_types.h
 create mode 100644 src/system/software_breakpoints.h
 create mode 100644 src/system/stack.h
 create mode 100644 src/system/utilities.h

diff --git a/src/common/cafe.h b/src/common/cafe.h
new file mode 100644
index 0000000..b6b6d1c
--- /dev/null
+++ b/src/common/cafe.h
@@ -0,0 +1,106 @@
+#ifndef TCPGECKO_STACK_H
+#define TCPGECKO_STACK_H
+
+#include "kernel_types.h"
+
+typedef struct OSThread;
+
+typedef struct OSThreadLink {
+	OSThread *next;
+	OSThread *prev;
+} OSThreadLink;
+
+typedef struct OSThreadQueue {
+	OSThread *head;
+	OSThread *tail;
+	void *parentStruct;
+	u32 reserved;
+} OSThreadQueue;
+
+typedef struct OSMessage {
+	u32 message;
+	u32 data0;
+	u32 data1;
+	u32 data2;
+} OSMessage;
+
+typedef struct OSMessageQueue {
+	u32 tag;
+	char *name;
+	u32 reserved;
+
+	OSThreadQueue sendQueue;
+	OSThreadQueue recvQueue;
+	OSMessage *messages;
+	int msgCount;
+	int firstIndex;
+	int usedCount;
+} OSMessageQueue;
+
+typedef struct OSContext {
+	char tag[8];
+
+	u32 gpr[32];
+
+	u32 cr;
+	u32 lr;
+	u32 ctr;
+	u32 xer;
+
+	u32 srr0;
+	u32 srr1;
+
+	u32 ex0;
+	u32 ex1;
+
+	u32 exception_type;
+	u32 reserved;
+
+	double fpscr;
+	double fpr[32];
+
+	u16 spinLockCount;
+	u16 state;
+
+	u32 gqr[8];
+	u32 pir;
+	double psf[32];
+
+	u64 coretime[3];
+	u64 starttime;
+
+	u32 error;
+	u32 attributes;
+
+	u32 pmc1;
+	u32 pmc2;
+	u32 pmc3;
+	u32 pmc4;
+	u32 mmcr0;
+	u32 mmcr1;
+} OSContext;
+
+typedef int (*ThreadFunc)(int argc, void *argv);
+
+typedef struct OSThread {
+	OSContext context;
+
+	u32 txtTag;
+	u8 state;
+	u8 attr;
+
+	short threadId;
+	int suspend;
+	int priority;
+
+	char _[0x394 - 0x330];
+
+	void *stackBase;
+	void *stackEnd;
+
+	ThreadFunc entryPoint;
+
+	char _3A0[0x6A0 - 0x3A0];
+} OSThread;
+
+#endif
\ No newline at end of file
diff --git a/src/common/fs_defs.h b/src/common/fs_defs.h
index 0b71bb3..c5aa881 100644
--- a/src/common/fs_defs.h
+++ b/src/common/fs_defs.h
@@ -2,12 +2,12 @@
 #define	FS_DEFS_H
 
 #include "types.h"
+#include "kernel_types.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-
 /* FS defines and types */
 #define FS_MAX_LOCALPATH_SIZE           511
 #define FS_MAX_MOUNTPATH_SIZE           128
@@ -31,7 +31,6 @@ extern "C" {
 
 #define FS_SOURCETYPE_EXTERNAL          0
 #define FS_SOURCETYPE_HFIO              1
-#define FS_SOURCETYPE_HFIO              1
 /* FS data buffer alignment */
 #define FS_IO_BUFFER_ALIGN              64
 
diff --git a/src/common/kernel_types.h b/src/common/kernel_types.h
new file mode 100644
index 0000000..3b04fb0
--- /dev/null
+++ b/src/common/kernel_types.h
@@ -0,0 +1,10 @@
+#pragma once
+
+typedef unsigned char u8;
+// typedef unsigned int uint8_t;
+typedef unsigned short u16;
+// typedef unsigned int uint16_t;
+typedef unsigned int u32;
+typedef unsigned int uint32_t;
+// typedef unsigned long uint64_t;
+typedef unsigned long long u64;
\ No newline at end of file
diff --git a/src/common/os_defs.h b/src/common/os_defs.h
index d171c3d..48a4c8f 100644
--- a/src/common/os_defs.h
+++ b/src/common/os_defs.h
@@ -5,106 +5,6 @@
 extern "C" {
 #endif
 
-/*struct OSThread;
-
-struct OSThreadLink {
-	OSThread *next;
-	OSThread *prev;
-};
-
-struct OSThreadQueue {
-	OSThread *head;
-	OSThread *tail;
-	void *parentStruct;
-	u32 reserved;
-};
-
-struct OSMessage {
-	u32 message;
-	u32 data0;
-	u32 data1;
-	u32 data2;
-};
-
-struct OSMessageQueue {
-	u32 tag;
-	char *name;
-	u32 reserved;
-
-	OSThreadQueue sendQueue;
-	OSThreadQueue recvQueue;
-	OSMessage *messages;
-	int msgCount;
-	int firstIndex;
-	int usedCount;
-};
-
-struct OSContext {
-	char tag[8];
-
-	u32 gpr[32];
-
-	u32 cr;
-	u32 lr;
-	u32 ctr;
-	u32 xer;
-
-	u32 srr0;
-	u32 srr1;
-
-	u32 ex0;
-	u32 ex1;
-
-	u32 exception_type;
-	u32 reserved;
-
-	double fpscr;
-	double fpr[32];
-
-	u16 spinLockCount;
-	u16 state;
-
-	u32 gqr[8];
-	u32 pir;
-	double psf[32];
-
-	u64 coretime[3];
-	u64 starttime;
-
-	u32 error;
-	u32 attributes;
-
-	u32 pmc1;
-	u32 pmc2;
-	u32 pmc3;
-	u32 pmc4;
-	u32 mmcr0;
-	u32 mmcr1;
-};
-
-typedef int (*ThreadFunc)(int argc, void *argv);
-
-struct OSThread {
-	OSContext context;
-
-	u32 txtTag;
-	u8 state;
-	u8 attr;
-
-	short threadId;
-	int suspend;
-	int priority;
-
-	char _[0x394 - 0x330];
-
-	void *stackBase;
-	void *stackEnd;
-
-	ThreadFunc entryPoint;
-
-	char _3A0[0x6A0 - 0x3A0];
-};*/
-
 typedef struct _OsSpecifics
 {
     unsigned int addr_OSDynLoad_Acquire;
diff --git a/src/common/retain_vars.c b/src/common/retain_vars.c
index 36e1192..05585b2 100644
--- a/src/common/retain_vars.c
+++ b/src/common/retain_vars.c
@@ -1,4 +1,6 @@
 #include <gctypes.h>
+#include "fs_defs.h"
+
 u8 gSettingLaunchPyGecko __attribute__((section(".data"))) = 0;
 u8 gSettingUseUpdatepath __attribute__((section(".data"))) = 0;
 u8 gSettingPadconMode __attribute__((section(".data"))) = 0;
diff --git a/src/common/retain_vars.h b/src/common/retain_vars.h
index 9a50978..e8c353f 100644
--- a/src/common/retain_vars.h
+++ b/src/common/retain_vars.h
@@ -1,6 +1,7 @@
 #ifndef RETAINS_VARS_H_
 #define RETAINS_VARS_H_
 #include <gctypes.h>
+#include "kernel_types.h"
 
 extern u8 gSettingLaunchPyGecko;
 extern u8 gSettingUseUpdatepath;
diff --git a/src/dynamic_libs/aoc_functions.c b/src/dynamic_libs/aoc_functions.c
index e3449e7..a9faeec 100644
--- a/src/dynamic_libs/aoc_functions.c
+++ b/src/dynamic_libs/aoc_functions.c
@@ -22,6 +22,7 @@
  * distribution.
  ***************************************************************************/
 #include "os_functions.h"
+#include "../common/fs_defs.h"
 
 EXPORT_DECL(s32, AOC_Initialize, void);
 EXPORT_DECL(s32, AOC_Finalize, void);
diff --git a/src/dynamic_libs/os_functions.c b/src/dynamic_libs/os_functions.c
index ea07ea6..04f90bd 100644
--- a/src/dynamic_libs/os_functions.c
+++ b/src/dynamic_libs/os_functions.c
@@ -62,6 +62,8 @@ EXPORT_DECL(int, OSIsDebuggerPresent, void);
 
 EXPORT_DECL(void, OSRestoreInterrupts, void);
 
+// EXPORT_DECL(bool, OSSendMessage, struct OSMessageQueue* mq, struct OSMessage* msg, s32 flags);
+
 EXPORT_DECL(void, OSSetDABR, int, int, int, int);
 
 EXPORT_DECL(void, OSSetIABR, int, int);
@@ -119,6 +121,8 @@ EXPORT_DECL(void, OSFatal, const char *msg);
 
 EXPORT_DECL(void, OSSetExceptionCallback, u8 exceptionType, exception_callback callback);
 
+EXPORT_DECL(void, OSSetExceptionCallbackEx, u8 exceptionMode, u8 exceptionType, exception_callback callback);
+
 EXPORT_DECL(void, __OSSetInterruptHandler, u8 exceptionType, exception_callback callback);
 
 EXPORT_DECL(void, DCFlushRange, const void *addr, u32
@@ -265,6 +269,7 @@ void InitOSFunctionPointers(void) {
 	OS_FIND_EXPORT(coreinit_handle, OSFatal);
 	OS_FIND_EXPORT(coreinit_handle, OSGetTitleID);
 	OS_FIND_EXPORT(coreinit_handle, OSSetExceptionCallback);
+	OS_FIND_EXPORT(coreinit_handle, OSSetExceptionCallbackEx);
 	OS_FIND_EXPORT(coreinit_handle, __OSSetInterruptHandler);
 	OS_FIND_EXPORT(coreinit_handle, DCFlushRange);
 	OS_FIND_EXPORT(coreinit_handle, ICInvalidateRange);
@@ -300,6 +305,7 @@ void InitOSFunctionPointers(void) {
 	OS_FIND_EXPORT(coreinit_handle, OSIsInterruptEnabled);
 	OS_FIND_EXPORT(coreinit_handle, OSIsDebuggerPresent);
 	OS_FIND_EXPORT(coreinit_handle, OSRestoreInterrupts);
+	// OS_FIND_EXPORT(coreinit_handle, OSSendMessage);
 	OS_FIND_EXPORT(coreinit_handle, OSSetDABR);
 	OS_FIND_EXPORT(coreinit_handle, OSSetIABR);
 	OS_FIND_EXPORT(coreinit_handle, OSGetCurrentThread);
diff --git a/src/dynamic_libs/os_functions.h b/src/dynamic_libs/os_functions.h
index 6383b80..77d3d8c 100644
--- a/src/dynamic_libs/os_functions.h
+++ b/src/dynamic_libs/os_functions.h
@@ -26,6 +26,7 @@
 
 #include <gctypes.h>
 #include "common/os_defs.h"
+// #include "../cafe.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -148,6 +149,8 @@ extern int (*OSIsInterruptEnabled)(void);
 
 extern int (*OSIsDebuggerPresent)(void);
 
+// extern bool (*OSSendMessage)(struct OSMessageQueue*, struct OSMessage*, s32);
+
 extern void (*OSRestoreInterrupts)(void);
 
 extern void (*OSSetDABR)(int, int, int, int);
@@ -232,6 +235,8 @@ typedef unsigned char (*exception_callback)(void *interruptedContext);
 
 extern void (*OSSetExceptionCallback)(u8 exceptionType, exception_callback callback);
 
+extern void (*OSSetExceptionCallbackEx)(u8 exceptionMode, u8 exceptionType, exception_callback callback);
+
 extern void (*__OSSetInterruptHandler)(u8 interruptType, exception_callback callback);
 
 extern int (*OSAllocFromSystem)(unsigned int size, unsigned int align);
diff --git a/src/game/memory_area_table.c b/src/game/memory_area_table.c
index 20ea351..5978ab6 100644
--- a/src/game/memory_area_table.c
+++ b/src/game/memory_area_table.c
@@ -17,7 +17,7 @@
 #include <malloc.h>
 #include <string.h>
 #include <gctypes.h>
-#include "common/common.h"
+#include "../common/common.h"
 #include "memory_area_table.h"
 
 typedef struct _memory_values_t
diff --git a/src/kernel/syscalls.c b/src/kernel/syscalls.c
index 474238f..03bcca6 100644
--- a/src/kernel/syscalls.c
+++ b/src/kernel/syscalls.c
@@ -2,7 +2,6 @@
 #include "../common/kernel_defs.h"
 #include "../common/common.h"
 #include "../dynamic_libs/os_functions.h"
-#include "../utils/utils.h"
 #include "syscalls.h"
 
 extern void my_PrepareTitle_hook(void);
diff --git a/src/pygecko.c b/src/pygecko.c
index dc4df3f..cbed7b7 100644
--- a/src/pygecko.c
+++ b/src/pygecko.c
@@ -12,16 +12,12 @@
 #include "dynamic_libs/gx2_functions.h"
 #include "kernel/syscalls.h"
 #include "dynamic_libs/fs_functions.h"
-#include "system/exception_handler.h"
 #include "utils/logger.h"
 #include "system/memory.h"
-#include "system/breakpoints.h"
-#include "system/threads.h"
+#include "system/hardware_breakpoints.h"
 #include "utils/linked_list.h"
-#include "assertions.h"
-#include "kernel.h"
 #include "address.h"
-#include "disassembler.h"
+#include "system/stack.h"
 
 void *client;
 void *commandBlock;
@@ -58,7 +54,8 @@ struct pygecko_bss_t {
 #define COMMAND_FOLLOW_POINTER 0x60
 #define COMMAND_REMOTE_PROCEDURE_CALL 0x70
 #define COMMAND_GET_SYMBOL 0x71
-#define COMMAND_MEMORY_SEARCH 0x73
+#define COMMAND_MEMORY_SEARCH 0x72
+#define COMMAND_ADVANCED_MEMORY_SEARCH 0x73
 #define COMMAND_EXECUTE_ASSEMBLY 0x81
 #define COMMAND_PAUSE_CONSOLE 0x82
 #define COMMAND_RESUME_CONSOLE 0x83
@@ -67,6 +64,10 @@ struct pygecko_bss_t {
 #define COMMAND_GET_OS_VERSION 0x9A
 #define COMMAND_SET_DATA_BREAKPOINT 0xA0
 #define COMMAND_SET_INSTRUCTION_BREAKPOINT 0xA2
+#define COMMAND_TOGGLE_BREAKPOINT 0xA5
+#define COMMAND_REMOVE_ALL_BREAKPOINTS 0xA6
+#define COMMAND_POKE_REGISTERS 0xA7
+#define COMMAND_GET_STACK_TRACE 0xA8
 #define COMMAND_RUN_KERNEL_COPY_SERVICE 0xCD
 #define COMMAND_IOSU_HAX_READ_FILE 0xD0
 #define COMMAND_GET_VERSION_HASH 0xE0
@@ -104,7 +105,8 @@ unsigned char *memcpy_buffer[DATA_BUFFER_SIZE];
 
 void pygecko_memcpy(unsigned char *destinationBuffer, unsigned char *sourceBuffer, unsigned int length) {
 	memcpy(memcpy_buffer, sourceBuffer, length);
-	SC0x25_KernelCopyData((unsigned int) OSEffectiveToPhysical(destinationBuffer), (unsigned int) &memcpy_buffer, length);
+	SC0x25_KernelCopyData((unsigned int) OSEffectiveToPhysical(destinationBuffer), (unsigned int) &memcpy_buffer,
+						  length);
 	DCFlushRange(destinationBuffer, (u32) length);
 }
 
@@ -121,7 +123,7 @@ unsigned long getConsoleStatePatchAddress() {
 		// Acquire the RPL and function
 		log_print("Acquiring...\n");
 		unsigned int avm_handle;
-		OSDynLoad_Acquire("avm.rpl", (u32 * ) & avm_handle);
+		OSDynLoad_Acquire("avm.rpl", (u32 *) &avm_handle);
 		ASSERT_ALLOCATED(avm_handle, "avm.rpl")
 		OSDynLoad_FindExport((u32) avm_handle, 0, "AVMGetDRCScanMode", &AVMGetDRCScanMode);
 		ASSERT_ALLOCATED(AVMGetDRCScanMode, "AVMGetDRCScanMode")
@@ -405,7 +407,6 @@ static int processCommands(struct pygecko_bss_t *bss, int clientfd) {
 						ret = sendByte(bss, clientfd, ONLY_ZEROS_READ);
 						CHECK_ERROR(ret < 0)
 					} else {
-						// TODO Compression of ptr, sending of status, compressed size and data, length: 1 + 4 + len(data)
 						buffer[0] = NON_ZEROS_READ;
 
 						if (useKernRead) {
@@ -968,7 +969,7 @@ static int processCommands(struct pygecko_bss_t *bss, int clientfd) {
 				ASSERT_FUNCTION_SUCCEEDED(ret, "sendwait (thread count)");
 
 				// Send the thread addresses and data
-				struct node* currentThread = threads;
+				struct node *currentThread = threads;
 				while (currentThread != NULL) {
 					int data = (int) currentThread->data;
 					log_printf("Thread data: %08x\n", data);
@@ -1018,16 +1019,16 @@ static int processCommands(struct pygecko_bss_t *bss, int clientfd) {
 
 				break;
 			}
-			/*case COMMAND_WRITE_SCREEN: {
-				char message[WRITE_SCREEN_MESSAGE_BUFFER_SIZE];
-				ret = recvwait(bss, clientfd, buffer, 4);
-				ASSERT_FUNCTION_SUCCEEDED(ret, "recvwait (write screen seconds)")
-				int seconds = ((int *) buffer)[0];
-				receiveString(bss, clientfd, message, WRITE_SCREEN_MESSAGE_BUFFER_SIZE);
-				writeScreen(message, seconds);
+				/*case COMMAND_WRITE_SCREEN: {
+					char message[WRITE_SCREEN_MESSAGE_BUFFER_SIZE];
+					ret = recvwait(bss, clientfd, buffer, 4);
+					ASSERT_FUNCTION_SUCCEEDED(ret, "recvwait (write screen seconds)")
+					int seconds = ((int *) buffer)[0];
+					receiveString(bss, clientfd, message, WRITE_SCREEN_MESSAGE_BUFFER_SIZE);
+					writeScreen(message, seconds);
 
-				break;
-			}*/
+					break;
+				}*/
 			case COMMAND_FOLLOW_POINTER: {
 				ret = recvwait(bss, clientfd, buffer, 8);
 				ASSERT_FUNCTION_SUCCEEDED(ret, "recvwait (Pointer address and offsets count)")
@@ -1130,6 +1131,27 @@ static int processCommands(struct pygecko_bss_t *bss, int clientfd) {
 				break;
 			}
 			case COMMAND_MEMORY_SEARCH: {
+				ret = recvwait(bss, clientfd, buffer, sizeof(int) * 3);
+				CHECK_ERROR(ret < 0);
+				int address = ((int *) buffer)[0];
+				int value = ((int *) buffer)[1];
+				int length = ((int *) buffer)[2];
+				int index;
+				int foundAddress = 0;
+				for (index = address; index < address + length; index += sizeof(int)) {
+					if (*(int *) index == value) {
+						foundAddress = index;
+						break;
+					}
+				}
+
+				((int *) buffer)[0] = foundAddress;
+				ret = sendwait(bss, clientfd, buffer, sizeof(int));
+				CHECK_ERROR(ret < 0)
+
+				break;
+			}
+			case COMMAND_ADVANCED_MEMORY_SEARCH: {
 				// Receive the initial data
 				ret = recvwait(bss, clientfd, buffer, 4 * 6);
 				ASSERT_FUNCTION_SUCCEEDED(ret, "recvwait (memory search information)")
@@ -1263,6 +1285,57 @@ static int processCommands(struct pygecko_bss_t *bss, int clientfd) {
 				setInstructionAddressBreakPointRegister(address);
 
 				break;
+			}
+			case COMMAND_TOGGLE_BREAKPOINT: {
+				// Read the address
+				ret = recvwait(bss, clientfd, buffer, sizeof(int));
+				ASSERT_FUNCTION_SUCCEEDED(ret, "recvwait (toggle breakpoint)");
+				u32 address = ((unsigned int *) buffer)[0];
+
+				struct Breakpoint *breakpoint = getBreakpoint(address, GENERAL_BREAKPOINTS_COUNT);
+
+				if (breakpoint != NULL) {
+					breakpoint = removeBreakpoint(breakpoint);
+				} else {
+					breakpoint = allocateBreakpoint();
+
+					if (breakpoint != NULL) {
+						breakpoint = setBreakpoint(breakpoint, address);
+					}
+				}
+
+				break;
+			}
+			case COMMAND_REMOVE_ALL_BREAKPOINTS: {
+				removeAllBreakpoints();
+				break;
+			}
+			case COMMAND_GET_STACK_TRACE: {
+				log_print("Getting stack trace...\n");
+				struct node *stackTrace = getStackTrace(NULL);
+				int stackTraceLength = length(stackTrace);
+
+				// Let the client know the length beforehand
+				int bufferIndex = 0;
+				((int *) buffer)[bufferIndex++] = stackTraceLength;
+
+				struct node *currentStackTraceElement = stackTrace;
+				while (currentStackTraceElement != NULL) {
+					int address = (int) currentStackTraceElement->data;
+					log_printf("Stack trace element address: %08x\n", address);
+					((int *) buffer)[bufferIndex++] = (int) currentStackTraceElement->data;
+
+					currentStackTraceElement = currentStackTraceElement->next;
+				}
+
+				log_printf("Sending stack trace with length %i\n", stackTraceLength);
+				ret = sendwait(bss, clientfd, buffer, sizeof(int) + stackTraceLength);
+				ASSERT_FUNCTION_SUCCEEDED(ret, "sendwait (stack trace)");
+
+				break;
+			}
+			case COMMAND_POKE_REGISTERS: {
+
 			}
 			case COMMAND_RUN_KERNEL_COPY_SERVICE: {
 				if (!kernelCopyServiceStarted) {
@@ -1290,9 +1363,9 @@ struct sockaddr_in socketAddress;
 struct pygecko_bss_t *bss;
 
 static int runTCPGeckoServer(int argc, void *argv) {
-	bss = argv;
+	bss = (struct pygecko_bss_t *) argv;
 
-	// setup_os_exceptions();
+	setup_os_exceptions();
 	socket_lib_init();
 
 	log_init(COMPUTER_IP_ADDRESS);
@@ -1307,17 +1380,17 @@ static int runTCPGeckoServer(int argc, void *argv) {
 		CHECK_ERROR(sockfd == -1)
 
 		log_printf("bind()...\n");
-		ret = bind(sockfd, (void *) &socketAddress, 16);
+		ret = bind(sockfd, (struct sockaddr *) &socketAddress, (s32) 16);
 		CHECK_ERROR(ret < 0)
 
 		log_printf("listen()...\n");
-		ret = listen(sockfd, 20);
+		ret = listen(sockfd, (s32) 20);
 		CHECK_ERROR(ret < 0)
 
 		while (true) {
 			log_printf("accept()...\n");
 			len = 16;
-			clientfd = accept(sockfd, (void *) &socketAddress, &len);
+			clientfd = accept(sockfd, (struct sockaddr *) &socketAddress, (s32 * ) & len);
 			CHECK_ERROR(clientfd == -1)
 			log_printf("commands()...\n");
 			ret = processCommands(bss, clientfd);
diff --git a/src/system/exception_handler.c b/src/system/exception_handler.c
index 9c7bee0..d3998bd 100644
--- a/src/system/exception_handler.c
+++ b/src/system/exception_handler.c
@@ -133,12 +133,12 @@ static unsigned char isi_exception_cb(void *context) {
 	return exceptionCallback(context, 1);
 }
 
-static unsigned char program_exception_cb(void *context) {
+unsigned char program_exception_cb(void *context) {
 	return exceptionCallback(context, 2);
 }
 
 void setup_os_exceptions() {
 	OSSetExceptionCallback(OS_EXCEPTION_DSI, &dsi_exception_cb);
 	OSSetExceptionCallback(OS_EXCEPTION_ISI, &isi_exception_cb);
-	OSSetExceptionCallback(OS_EXCEPTION_PROGRAM, &program_exception_cb);
+	// OSSetExceptionCallback(OS_EXCEPTION_PROGRAM, &program_exception_cb);
 }
\ No newline at end of file
diff --git a/src/system/exception_handler.h b/src/system/exception_handler.h
index a464522..d1dac63 100644
--- a/src/system/exception_handler.h
+++ b/src/system/exception_handler.h
@@ -6,6 +6,7 @@ extern "C" {
 #endif
 
 #include "../utils/stringify.h"
+#include "../common/kernel_types.h"
 
 #define OS_EXCEPTION_DSI                        2
 #define OS_EXCEPTION_ISI                        3
diff --git a/src/system/software_breakpoints.h b/src/system/software_breakpoints.h
new file mode 100644
index 0000000..28c5834
--- /dev/null
+++ b/src/system/software_breakpoints.h
@@ -0,0 +1,249 @@
+// https://github.com/Kinnay/DiiBugger/blob/master/wiiu_code/server.cpp
+
+#ifndef TCPGECKO_BREAKPOINT_EXECUTE_H
+#define TCPGECKO_BREAKPOINT_EXECUTE_H
+
+#include "utilities.h"
+#include "exception_handler.h"
+
+#define OS_EXCEPTION_DSI 		2
+#define OS_EXCEPTION_ISI 		3
+#define OS_EXCEPTION_PROGRAM 	6
+
+#define OS_EXCEPTION_MODE_THREAD               1
+#define OS_EXCEPTION_MODE_GLOBAL               2
+#define OS_EXCEPTION_MODE_THREAD_ALL_CORES     3
+#define OS_EXCEPTION_MODE_GLOBAL_ALL_CORES     4
+
+struct Breakpoint {
+	u32 address;
+	u32 instruction;
+};
+
+#define INSTRUCTION_TRAP 0x7FE00008 // https://stackoverflow.com/a/10286705/3764804
+#define INSTRUCTION_NOP 0x60000000
+
+#define STEP1 10
+#define STEP2 11
+
+#define GENERAL_BREAKPOINTS_COUNT 10
+#define STEP_BREAKPOINTS_COUNT 2
+
+unsigned char ProgramHandler_Debug(void *interruptedContext) {
+	OSFatal("Hi");
+
+	return 0;
+}
+
+void installBreakpointHandler() {
+	OSSetExceptionCallbackEx((u8) OS_EXCEPTION_MODE_GLOBAL_ALL_CORES, (u8) OS_EXCEPTION_PROGRAM, ProgramHandler_Debug);
+}
+
+struct Breakpoint breakpoints[GENERAL_BREAKPOINTS_COUNT + STEP_BREAKPOINTS_COUNT];
+
+struct Breakpoint *removeBreakpoint(struct Breakpoint *breakpoint) {
+	writeCode(breakpoint->address, breakpoint->instruction);
+	breakpoint->address = 0;
+	breakpoint->instruction = 0;
+
+	return breakpoint;
+}
+
+void removeAllBreakpoints() {
+	for (int index = 0; index < GENERAL_BREAKPOINTS_COUNT; index++) {
+		struct Breakpoint *breakpoint = &breakpoints[index];
+		if (breakpoint->address != 0) {
+			removeBreakpoint(breakpoint);
+		}
+	}
+}
+
+struct Breakpoint *setBreakpoint(struct Breakpoint *breakpoint, u32 address) {
+	breakpoint->address = address;
+	breakpoint->instruction = *(u32 *) address;
+	writeCode(address, (u32) INSTRUCTION_TRAP);
+
+	return breakpoint;
+}
+
+struct Breakpoint *getBreakpoint(u32 address, int size) {
+	for (int index = 0; index < GENERAL_BREAKPOINTS_COUNT; index++) {
+		if (breakpoints[index].address == address) {
+			return &breakpoints[index];
+		}
+	}
+
+	return NULL;
+}
+
+void pokeRegisters(OSContext context, uint32_t gpr[32], double fpr[32]) {
+	memcpy(&context.gpr, &gpr, sizeof(gpr));
+	// memcpy(&context.fpr, &fpr, sizeof(fpr));
+}
+
+struct Breakpoint *allocateBreakpoint() {
+	for (int breakpointsIndex = 0; breakpointsIndex < GENERAL_BREAKPOINTS_COUNT; breakpointsIndex++) {
+		if (breakpoints[breakpointsIndex].address == 0) {
+			return &breakpoints[breakpointsIndex];
+		}
+	}
+
+	return NULL;
+}
+
+// TODO
+u32 stepSource;
+
+void RestoreStepInstructions() {
+	writeCode(breakpoints[STEP1].address, breakpoints[STEP1].instruction);
+	breakpoints[STEP1].address = 0;
+	breakpoints[STEP1].instruction = 0;
+	if (breakpoints[STEP2].address) {
+		writeCode(breakpoints[STEP2].address, breakpoints[STEP2].instruction);
+		breakpoints[STEP2].address = 0;
+		breakpoints[STEP2].instruction = 0;
+	}
+
+	struct Breakpoint *breakpoint = getBreakpoint(stepSource, GENERAL_BREAKPOINTS_COUNT);
+	if (breakpoint) {
+		writeCode(breakpoint->address, (u32) INSTRUCTION_TRAP);
+	}
+}
+
+u32 getInstruction(u32 address) {
+	struct Breakpoint *breakpoint = getBreakpoint(address, GENERAL_BREAKPOINTS_COUNT + STEP_BREAKPOINTS_COUNT);
+	if (breakpoint != NULL) {
+		return breakpoint->instruction;
+	}
+
+	return *(u32 *) address;
+}
+
+struct Breakpoint *getBreakpointRange(u32 address, u32 length, struct Breakpoint *previousBreakpoint) {
+	unsigned long startingIndex = 0;
+	if (previousBreakpoint) {
+		startingIndex = (previousBreakpoint - breakpoints) + 1;
+	}
+
+	for (unsigned long index = startingIndex; index < GENERAL_BREAKPOINTS_COUNT + STEP_BREAKPOINTS_COUNT; index++) {
+		struct Breakpoint breakpoint = breakpoints[index];
+
+		if (breakpoint.address >= address && breakpoint.address < address + length) {
+			return &breakpoints[index];
+		}
+	}
+
+	return NULL;
+}
+
+// TODO
+OSContext crashContext;
+
+void predictStepAddresses(bool stepOver) {
+	u32 currentAddress = crashContext.srr0;
+	u32 instruction = getInstruction(currentAddress);
+
+	struct Breakpoint *step1 = &breakpoints[STEP1];
+	struct Breakpoint *step2 = &breakpoints[STEP2];
+	step1->address = currentAddress + 4;
+	step2->address = 0;
+
+	u8 opcode = instruction >> 26;
+	if (opcode == 19) {
+		u16 XO = (instruction >> 1) & 0x3FF;
+		bool LK = instruction & 1;
+		if (!LK || !stepOver) {
+			if (XO == 16) step2->address = crashContext.lr; // bclr
+			if (XO == 528) step2->address = crashContext.ctr; // bcctr
+		}
+	} else if (opcode == 18) { //b
+		bool AA = instruction & 2;
+		bool LK = instruction & 1;
+		u32 LI = instruction & 0x3FFFFFC;
+		if (!LK || !stepOver) {
+			if (AA) step1->address = LI;
+			else {
+				if (LI & 0x2000000) LI -= 0x4000000;
+				step1->address = currentAddress + LI;
+			}
+		}
+	} else if (opcode == 16) { //bc
+		bool AA = instruction & 2;
+		bool LK = instruction & 1;
+		u32 BD = instruction & 0xFFFC;
+		if (!LK || !stepOver) {
+			if (AA) step2->address = BD;
+			else {
+				if (BD & 0x8000) BD -= 0x10000;
+				step2->address = currentAddress + BD;
+			}
+		}
+	}
+}
+
+void ReportCrash(u32 msg) {
+	/*crashState = CRASH_STATE_UNRECOVERABLE;
+
+	struct OSMessage messageStruct;
+	messageStruct.message = msg;
+	messageStruct.data0 = (u32) & crashContext;
+	messageStruct.data1 = sizeof(crashContext);
+	OSSendMessage(&serverQueue, &messageStruct, OS_MESSAGE_BLOCK);
+	while (true) {
+		OSSleepTicks((u64) 1000000);
+	}*/
+}
+
+/*void HandleProgram(OSContext crashContext) {
+	//Check if the exception was caused by a breakpoint
+	if (!(crashContext.srr1 & 0x20000)) {
+		ReportCrash(SERVER_MESSAGE_PROGRAM);
+	}
+
+	// Special case, the twu instruction at the start
+	if (crashContext.srr0 == (u32) entryPoint + 0x48) {
+		writeCode(crashContext.srr0, (u32) INSTRUCTION_NOP);
+	}
+
+	if (stepState == STEP_STATE_RUNNING || stepState == STEP_STATE_STEPPING) {
+		crashState = CRASH_STATE_BREAKPOINT;
+
+		OSMessage message;
+		message.message = SERVER_MESSAGE_PROGRAM;
+		message.data0 = (u32) & crashContext;
+		message.data1 = sizeof(crashContext);
+		OSSendMessage(&serverQueue, &message, OS_MESSAGE_BLOCK);
+		OSReceiveMessage(&clientQueue, &message, OS_MESSAGE_BLOCK);
+
+		if (stepState == STEP_STATE_STEPPING) {
+			RestoreStepInstructions();
+		}
+
+		Breakpoint *breakpoint = getBreakpoint(crashContext.srr0);
+		if (breakpoint != NULL) {
+			writeCode(breakpoint->address, breakpoint->instruction);
+		}
+
+		PredictStepAddresses((u32) message.message == CLIENT_MESSAGE_STEP_OVER);
+		breakpoints[STEP1].instruction = *(u32 * )(breakpoints[STEP1].address);
+		writeCode(breakpoints[STEP1].address, TRAP);
+		if (breakpoints[STEP2].address) {
+			breakpoints[STEP2].instruction = *(u32 * )(breakpoints[STEP2].address);
+			writeCode(breakpoints[STEP2].address, TRAP);
+		}
+
+		stepSource = crashContext.srr0;
+
+		if ((u32) message.message == CLIENT_MESSAGE_CONTINUE) stepState = STEP_STATE_CONTINUE;
+		else stepState = STEP_STATE_STEPPING;
+	} else if (stepState == STEP_STATE_CONTINUE) {
+		RestoreStepInstructions();
+		stepState = STEP_STATE_RUNNING;
+		crashState = CRASH_STATE_NONE;
+	}
+
+	// Resume execution
+	OSLoadContext(&crashContext);
+}*/
+
+#endif
\ No newline at end of file
diff --git a/src/system/stack.h b/src/system/stack.h
new file mode 100644
index 0000000..426b1b1
--- /dev/null
+++ b/src/system/stack.h
@@ -0,0 +1,30 @@
+#ifndef TCPGECKO_STACK_H
+#define TCPGECKO_STACK_H
+
+#include "../utils/linked_list.h"
+#include "../common/cafe.h"
+
+bool isValidStackPointer(u32 stackPointer) {
+	return stackPointer >= 0x10000000 && stackPointer < 0x20000000;
+}
+
+struct node *getStackTrace(OSContext *context) {
+	struct node *stackTrace = NULL;
+	u32 stackPointer = context->gpr[1];
+	u32 stackPointersCount = 0;
+
+	while (isValidStackPointer(stackPointer)) {
+		stackPointer = *(u32 *) stackPointer;
+		if (!isValidStackPointer(stackPointer)) {
+			break;
+		}
+
+		int data = *(u32 * )(stackPointer + 4);
+		stackTrace = insert(stackTrace, (void *) data);
+		stackPointersCount++;
+	}
+
+	return stackTrace;
+}
+
+#endif
diff --git a/src/system/utilities.h b/src/system/utilities.h
new file mode 100644
index 0000000..1f74cdf
--- /dev/null
+++ b/src/system/utilities.h
@@ -0,0 +1,24 @@
+#ifndef TCPGECKO_UTILITIES_H
+#define TCPGECKO_UTILITIES_H
+
+#include "../dynamic_libs/os_functions.h"
+#include "../utils/logger.h"
+#include "../kernel.h"
+#include "../common/kernel_types.h"
+
+void writeCode(u32 address, u32 instruction) {
+	u32 *pointer = (u32 *) (address + 0xA0000000);
+	*pointer = instruction;
+	DCFlushRange(pointer, 4);
+	ICInvalidateRange(pointer, 4);
+}
+
+void patchFunction(void *function, char *patchBytes, unsigned int patchBytesSize, int functionOffset) {
+	log_print("Patching function...\n");
+	void *patchAddress = function + functionOffset;
+	log_printf("Patch address: %p\n", patchAddress);
+	kernelCopy((unsigned char *) patchAddress, (unsigned char *) patchBytes, patchBytesSize);
+	log_print("Successfully patched!\n");
+}
+
+#endif
\ No newline at end of file
diff --git a/tcpgecko.elf b/tcpgecko.elf
index 71a64bf5b217a7a950bd6412dcf07252faa8083c..423b2e3dcaffb60c01624ef154b6da411aaa7c13 100644
GIT binary patch
delta 30860
zcmbuo4_s7b);Rv$VMIjKQ4z;+#F3B%LIl?IGBdzXv^$9vARyUfLttT%QBpgtBlixl
z@2b%*`cOkT5^dO8xy5ew!)>X?&3bj$Hg>aKcO#{5*lJ;7YEdEcJLkFg&Og!G_pQ%(
z&wZYA&U2pgoadbLJomYmuJ@x_zKd#2P?<g35)&fL1`;8VZ7V)g?Yfcj+`m+1duXgG
zNmaI+npHo)_SW|oHxXj#Ah9AxV)z9l${7{$tQCr^#5K!Gp4??6_uOc<lSaO(M{6a2
z+$qD!R`Tj5E4k$m9Z{vKcAlh(5xIi+3!nfh+oM+U^jRzEoF`!q9uNk<b67d^Ti9BD
zhuX6xkC4S%5GH!W!Fs-G@G#&!ElH$yZ0f$p;Vho%Fk48Y{aTwLr;{{R{?0}a-(F=i
zm^(?6eb-aO`Al*VFA`#%&t*SoCC~gmZ-6vf$@9DNM7;jtwj2X#bfv6{*{)uiRCdJp
z%HUDs2PgEKQX-zcNmMUz<(2jGc0z*hsZAXp`O0lBbJ+kD)p1M92Atc!j0G$Xv5>FH
zOE{Bfm4<Q1DH{d>xDYN-Mh~lRQk7e&e!|kMvOyFv1Y?=MjB!OyR?^Oi@7ao6rDff;
zc|xk{1fks%k|IwKkaCFjLkV1>B2yFiY%Bqu6ZuY}LaF%uWH0iU`!qyLBa<SRyut{@
zNF5S-;Bvx7_eI7>pRkGRNEE9ah)hantO&50j%*k^=qzJpEISz@Hr&%C6SHRgVW*XJ
zPg?vGGoM~7dG31Zn7Agjtjk_yA*KOIRmi~%>f)PwtbFGpr<Lq0%VEP&=Gh(<A7@K0
z^!a$+?z;%rQmJN@nl6b-&F#_Vb&|$bj_B#fB-Tpy&T1MX?XH}%-NGl|Ih4_o&37{z
z1z&Zl0`UHcIMfrRi#+9l+gIptRBH68`W0_yf;GJIsC3KAx3|Epq1qXxdbVwWZ&>2e
zqlFe@pygP)pF~;7%L`=g(969z$`)R{FUCq<{HIfx`*40E@xnNO@}P|S@gdfUb>*?9
z<0J~YE(&j+bMVa%*U{aR(wDyYoXn~p*glG=TT*Pv@=Peex;!uI$Y|aGHw|#snT~-4
z#YCq^eg@O;<xFacPKqzrD%}UI)u8am2|6IUQdSPo=IDg--#y`6H`kFCLCCf|8=v3E
z#Uct1astXpzSHMZSg<~b#KYU8MQP^z?zSM>0-()6TA&-IqtU6+S((x;m}ti2INfJF
z|Mq7U!oR<Bph|JT<!X`IC&x!;{_|37aa`<uljDU<mx2wmyV2}rB4;ss-1V6q8glTJ
zBr3ciEK|B83O2sbH|F8lkdQ2_vvQd!-@~_+@im3@AdGPVFcv}0eW-GpPqcX!(o8v`
zF|GD^X=_Z9u59;qFddV&tc$vcL0I*k157B{lwIbbeKE^bFn;<e*QP#y!P&qJ2OSR>
zlZJr1`dBh1PLGnJ;kdwv=;kTcMlWWD;z|L9*OkUae%1$i7^cHh;&f$Vu!Km6bHkNV
zuBC>l>CuZPDZNI*T&BRzD=829ca#rNT>2})EaDi8-f$N5=+u(v^hJJ5FpJ2~WB9i}
zH`AhNajG(r)=W!Zy5ljYbFKpgw2~cL7Vm_>q}P)CCw+a3cQ7Yn!Kngu_kwm5yh^Ik
zB<oGbd_I%U=aUgqf)M5bf-%Wvf$3U`^9b~9g{YDt&9l$@tmJo-Ahwl)U07(HCSk_s
zgQjDjpSO}d@5}N!XqP6*SmuP{QS7|%);Z>0_~SN<<V<ZAd4@JiT!%D3{$LPSE!9t-
z8kgqR02(i_%HqLjsbxAiUy<6TCuCjip9~BGOcSvb^A_Gdcj+AJo}RGulHOGWdiR2>
z$!D|3a%J#OkpdhYl#fQuF#3D@!a{#<OJ^jl{z1L13H0{)x4_dBpmrce$a5<737KX0
zc-<YIk&u;oeF(-6>2ATy<*M?Nv~{MN`|b8wamJK6!7R`r2>&e)kHoGTbPOJ7$bN}Y
zI%0nk2@|AhsGd4wd3CmdAjjzBe1)UmeGL^L(@Pi>%}PgE#956~7gZxs>0dO)?35Gr
zR1>F*FJobn8OT*EnTgErSUeyeFRjToaLLpfw^da>NRPysxI<JkI|*-!QVi;RF>{dG
zW-piqCekRB*5rz$(fG>gG}<;hDgLTWFfE8>CutX+`~;=~(Fo6+EEZPlVlA#kJT01U
zpaTok0`Db<S~n2V`W{g`H_mnN(zsOfLP?92TX?-|Nm;jffSF*m_}fz~wGr<6(9!Vh
z3l79ldg@vV`hk1JcQy$thlT7{V}&P<TJk+U@S_*&^Sr<ZlAZSBMKPu~;CHNi${<J<
zBfJJu{pMmRwPYvKjC6Huwn5E1e>T_AdM5;(B%%iDHtN;J%_v8FsV5$wd3to1iW#Yb
z>V+`u45=R~fftHmuw5&cxKIQgZ5rI@;Gu2as}fA{=-<DcA~x7~DVxk)f@6~hKUYd=
zDVm7*gsp(#zdb?E`$|i*i4^Wk*|q{4Fbs>9q{a+`F#4SX8)|csD3hJ2p>u<%c~>sv
zgP&}42nFxa<Hp%m-YirdW#f?V@*OcgRnme@iVlpXrL_(J^^8M&0;a}*&nLc7TB@ki
zxe1)SXg=EbMu`WxZ-0Zv=@NzPG{y{6fy|H*Z#Mv=vVG8hi=X%*j1W1V#gCyuaB8%Z
zT)+j%8ch~LjBTa1TnpGv=4nr^9j=<wt*&}P8s2)@fr8<fNkRed`Je*>A=wtt!_sw9
z-V25U(q)~uxQIt^f^q!M%aX-44HP$gjTT3m6+JWz{)wK^8PJmF>V$;M91y~lRo2ae
z!HBz05fHq(A?Xo^@Y~Os>+~DgkI}$Z4lA7!R{twjc&v})@AM^O$7K!Lc`s-VG#H{i
z43VPIfp`sXz6?>Vte5ejyXMXj7CbS&VSMch7=}?qTG=o%&>)y$94{@!kwRV}2GN*S
z{{!s7A*}t-!P67Q>B2HG+$wShV1O*}vy;ZA+e>SVUzhT^oiI2hr_bkl;kx0A7}qiw
zB(xYDB(xalH_C#2N8^+-+DtR=<*H4cMBNH`q_8bulMRWW=UtzJ4DaiwXJ$CjLo{Sc
z#$@W`svEXF<M$j`Zh6`l7{|m%=$W`Vk^}iUIFNq@IS?2pzLQj2Im2|<HL?T2@s%A2
zk7Io24hK3C|M)To5*S|y5^BJMAQ3!?=kE_2t4etmUwAGsSlRtSgB3Q5i-%wqS17Ys
z_)eO%ICv&enzYKSZrezrERCwoRJ_h$%@>!f5Wt#+je)5qTU;GX4-zzID-;Wr=4`eF
zh2g!@w4^Obx>?2+*4FK%rOKp0=dd_wws6g6)(ALhoX>2I!jPj0usLf1KR>^;#^eP_
zpISMLW`Jg5%sdm72X)3*z8D6x=rp!{(Pu3ALR{Rz0>EZhI%FcvpEy`H0<H)JR)j<o
z0YM$Yo5MxI&FE7-zQcg<+txZ5(>@}P0g(ejJm*@bjHl%6aZK5G{)DnQ>mN@eBr1D;
zq{~doz(ADWadm<4`sWVI&T9y|2<FD$94;2HN!P-9l##i~=1=HLJToi52q>Rq3W^x>
ziv41MDJf=!F5{B81Y!ioCDFHX*!56pJx;w~--bR7d|L(cYwIEwvh_Smt;NI<Md6Us
zwklR&dHRACOyg>BWCO|Zf}X85a)`9jzy!OY=^2!|nmM(%&%m-Xne9)QMV>$=p+`ko
z$<BKVeP>t_YPN%!R1IYa2c-M~>WXt<RMC7~%gee<&)MubgeTi3+3cHch<FwgShQ84
z3nuWbFuSd!<19l?Df6(EA{ewX%!R)5wnE?V4S8PDi0Z_~7-7}9L`e|O35-}fFf79_
z5S7m-%29bD^mN#uyL)aWHWJ)ZjIoOA=HEV-A^h@_5Z5gW1>;Z@6A<WJ8^%`@2xx4k
zPBL}#rzF}Wz*a&eAt($TNHMC;L9UX5T86e$bq|i$Ht*N+xf*O6Tt_TzN!7)b4?bqX
zRkxfmz}&Sw{bhTApD>3d?%{n2;@2$k8>`Rjgb<eFv70{f*fE2*bS$cd*&8LpF#u~M
zIBhS$S{b$hY>;6!z-)bP>9~3iz!{4L#^`Ev1H8;=H^6L(01XrYY{l~Yj<dV-p6evC
zB0a)0pF3P@$O;gYjqtYHq`exsz7y+}Iy4cS@U6#)6@DuUeP?Zmx8(+#Sy;RkdvbOK
zAaL!6Z017W$=?Hl8AnFE^Awmt`#byq%#0tAm>e?AR~hB=<=ik#gsm1!{?5$qrsoLB
z$$|SV?7man2@b;!`)9;G1x*O=0p^-s13U}RF9&*tUu3cD^a+Ew`T~T7=&H~zTVeQ3
zPmw5CcBL^Ppd19zNH+S!ji3?Ibd0DUGZQs)ZymmVOi$64#k)?$%6JQxy++iQr-xa}
zi6({S6lw><6|P)bl9D1>mN5G<R0>)G&N-aFXsw_`Hh;yxoYG2`FuDY%4qtT!b}iix
zv%Yc@ZoqEH<poe)DZ>?kx!isWikshiX1A4#EK{Z+@To=7R|w1*v|qzqrH3<{MQ|jY
z&`|T4W`5V1LH>A23yvxfe-zZ%$v^|{Z&(8!GAKe$i5ZH7Kk1bK{;)a-|B#H|CJIG*
z1DcDK&|7c~AW1)L5UQo{3_aROEopH=rY#SYV_H3&0lJJ8j~D5MWB)H!_^)9Y%uI{u
zgLXR!=RB5CluckfcYGNu$uMyjTdrUCo&&>>G)C_1#U4<|PG2v|E8#^ia8~=9x5;?Z
zrMe0CI!%E}naSf9tekpR5K*f{^!P`GzArM+ketTJ4wIKeQNvZssCz*v_glz2<8r~n
zakDraavW+LcC<FdK`Fz|zx|~Xg9<Xmc_ibD)RK^@%NWJZG@SU8LlSVtTH&g{g75j~
zZL~QdEB>D;QugKRHyM0BbaONh>=67kb8X&4LruPD*vl4Wa{lgG0IMA%#OnO_fX`5!
zm9(C~G}8G1PLl0^R0a|Uk*^v)AoaEFtUO*vkvWXv`|f@cg$?5JgEdw(KVfyeT3P>L
zYO#1bdKJ>8q!76xq!xLlH4V2=hw+26F{b$>#`yJFL#`dting;$F!RJ52eW5WXJi+$
zmYXl58S~?!HD?<>`4dP<Q($SCAj~-u+*(sM%vPYbbog2uuA_jqZC;`8^8(Z-3J+u8
z;GZhB^HpanP;ezkxN^&!W^7p~wPP8K3*mR2t>%xH+HgEvd8IbVKc<1B4dC(uAToko
zXWIa|LPoBTkW;%ukOR10z-5UuFlIYI`5mbl<Kuow_~R>wCB7?%CB7-$C=j+w>kL^5
zDSGS+8*!ne<x&synKlrK?wDSN%1{h3-2Z?fCQJV3!g;i6OoEX)?=6Bz3Hbo5YK32X
z;>fd;#zNn}C!uBXokfIga&c4t?lQqHqIX_=Bs~N>+8#PMFDp*7GYo4j!%B<S3A7Ti
z%=T$MUMwQ^s&0R}2m#_SCNMZ^_GWla;ZJ0?-B#%PWR7B@p^414e6yEl(JRLSbZ-+*
zNoZOR+3bbBb3<&ZX0xfPh2|G5RL${H>s7ym>DqUd&Nxlka=Ow~JsP~6Ky88+MVgqH
zq)J^uS0w6GlP}WRg>xpubE3sNXZrFx5=GjQn1H(}-HEuhf-Oz;?{g|+F^*Fh8Mh_N
zLfwo{Gf?HQ#&rl2-h@efJR6!!$i2!b9Q#MC&~cQ&UdRDRBS&)xH%(c6R7P3IV{-$}
zAv92(@CM8zHRj@#&1ASsGLy3&TC_A>HER#ulddzKQ0Ea?Ds+N1YHfC$^TN*$7A@XU
z1ls{KMoo4wl!gx-!cKXg2-9-hk#Ws9xqb1~b2>x!R!+p=V41umk=A7=sp3XyVn!<4
zlFCR|4XR;3=IZIip(KL^bVX*WptS~jyF3eN+$z8h_v#+))~Co60m4J$?U=4@U5Mtz
zSDo93B3sELilZJezVdm2;<9j_89(^k23>2;GeFlI9&f`2($~;N`pP#<8^gIN^XV&Z
zn>J<@$ksnfW>K!@2Vl{1ytFQx5awBmKJ`v5j%<u?g|Z+*c(k(h7qTgx2O5Gj*l^LO
z1?dVd);Aq0XZD?)a&n~MnHL;QkhMW_1nzk2_2{nAZwivbd?X*%E?x9bM2)7xyu}Ve
z@}Q@t*FI;B^PR9vhuCW+Ehk*C-_MJ1FXN(cEZ&eUr?Fuah&6bq>~OY$aK%ZHxu#=8
zkHT5WmP1P8(6#`o-1?U2E3HETkYVeH$BP0WQ)pBzH+sL^s9!*EHKOU*kA{L8zaNLo
zN;YqjRQ&m7XiR=OTGq+}l$}H>yd@0^Wo@_u<?U=y8CF@=9!?}P-UEy$$c;^x%FdmH
zhUKMBc~nCIbu_Hq;lPa$Y!LXfr;Rf1DB!-u1h^`tY*djbkTRTSkAR?&-xc~kCUk&L
zRn4lQHH#CbmU$HHLf=3atBE7@KzNN6Yf@*mzzUj88)YXh#{y<?9A*lv+tA&)Af!Uj
ztCl9Fo{CH7a`0?%>2h`Xpld13{iz{t8st;3^l$VX6*hvqz^&8Qk0(;YvPCmFb@8%)
z5e{}>yf{ydN5N~^mzk#D7dq39$I?B^(p8!vU>{3|mqn|NS?TC9UHRm}8)INqWr29%
zg+TlVd<;6J6fA`kI$#s6WAYK_#xJ34!)?+|sPClk<S>@^!p72T?LJ7!w@<ZOw!jl8
zpqFtoX)PbGo7}5N#2lC3dra=4b<3`vzAIG1j|P|~XLiw;?08tA75Wa{*bb>S(8~M3
zAE{x*nWQ?#x*|-|1}nDd4Joy0JPwWna{9(Mhz9pig`M5R;^77nZiqWcnjn|SC8Tlt
zQ>C@JFc7(R(rDQ>^C)I{COd3-W|SQ;ep+@AT1^xp-gKB?y<jB`rx!m7fng`<Mjn=J
zlUoEj&$vL{@USbBUTa(y!A(3xoyK|dIgYujLf^p$omFvl&MK}=xDNIsffI1ar~8b#
zs_0}oVw^vvm2K>4(VfBrzCCl;w!4~#ZFjoDG)Lf6>u~qeJRk*sv^ch-qAWfRo{AEF
z`kp@nb+KL0z%n|2+gL#(^pOYOgqcRG54P>)^=?BOu6O?x*s*JVM%wLz0aPq|`|N4*
z(wf_klO%@(HZU;o@&2XtP_GnOKDC1ZFXnh!ZC+^NxO{Ub?5Rpy9h3N77hwOD@K)0M
z7TXj44Y2_S*u#SdJvhc3HyvBS^oEL7>G|W(Q958|PxeO4S=T;)8d8XdEsZlQ$ka-D
z)=Kx&kGS$mI+uY<-IfRYa!(&UkNHnXQiVH7Pao~4-bCCkfMA|V*b|>C^oa%XLf_y%
zw8^BY&R|m$1<13WB4C*Jeq87~nkYv-HAcOqQ$ws0QJFX}0+LAgF2a?pG7@Z)>*@dT
zf@q2GEaPY&?afF^pH!jD_D7DxuFF&4<Y8vBRqg9+dLB{4vACujq?*jDr>_p3OaB7~
zwJiOPm_Y>*eUB>-<n|E_`WxpdW2~@+hjk}1oNCBU0Vfal7SGgJ*A1}J*lNL~d<ca{
zy`l+Ss?!e~7}RGqgf{-cKE$R)nMuOr?%=?lI{<45=#BB~9&K(XSO+W&FmPLm^9k80
z@53N&C7T|UtzkqC<c)a-(u}rgdf4O5vk<oGl4<$?|9T1EAHVCfF@6g`5EQ`cLj(9G
z#pIL#UXKmP0i59?)5`~N=ih^3C<^_Kiw}+80^M=B0506`GF~o#J0He|A%NFkCV<z2
z#>&DPFNXMCj{>mx{SAxXLRbKAxF|Pzg#f<sqO@MyI7w132Jnri<l(qX0KZ)PzLw4C
zD+KV3+vIVJ!Qk8gen{~@g}(RLvXz;Ux;NO2AR}r<TXx+h?YaqDiY)mZv(sGhFi~*7
zsbjWQ9D}XBEj+++d&FZzD{RR?xLtf5PE2e`Mz~q*Aj!fO1HyG;1IZA!Xb~=OH4t9d
zQh{)W7*8w$?8f1ZzUg&h6}FrNc-CIrAVY-3oADamviO(meqix`v1{MrU$CopaWlJi
zOTja)eeomge)D4Ren8)f`#RYcGRe~MkAr2)wLI?TZOSc9-?XMA);u5#U`i*rQox%3
z%^u{dx1|!bJQ|+Xivfo%mtC^OSLpjkop}HpIG7YVJP0ECpjG7K;>lBnLf^6WMLG~@
z%lSkT1OeC-E`aFXZ36ex?kk!YgIR@?iU_J2#W^Xdh^6D4x6t?ZVLV}xzw>kyt{!n0
zT?%?%Ujq+%x-d^uhE`C&$?Cy~uYsq-9<0Lz6YKHe9ZM#k=(AWlhV}s8b_g7YTJMLA
z%D=;dq&(P$;-$y|PaZHk7`X_s?~+H+nDpUd3~?~MMy4Q$Nc-~QqEFNp`c4cYUpkzp
z6Gk4xNQ=rrMJW#r{88@UDfN{iZK3Z%3qI5ai?s?ju!D_|fe`Lm%b2*yH2k8p1>l4F
zFS}Q*)))cb;D68n4;^^H3r|rUU<L;1aS=Xgz$Xry*2xc1G46>UY69KHQ2zDD>`8|g
zH>XNk#Al@^@PH#dBn>)i0CPU%Nk^gYUkAXs;1Pm#=(&Z!!}Px9utqjvBf@UBYg~;3
zq$JdMm?7jbe^?_;Z=gp0xjDyxKA`k~GWdnQce~`q+vTv4BR|RSi{b?`2`xdm9+wd3
z{|P(Jy%MsDhQ^q8`>`C78~?5y`HJN!XxeNfnPQ}T2$do|Z25A<_`7!3&W`x4vw?n*
zuPynC?YCT+&G~W9a-hKky7}!;u!QT;QZFcO^hy$Tk0)U$>k}s>rKndK2gv<_(fgYy
zH+hJP1v=rvT1oj=QpoW6@pddioBLQ9un$AW;GI!P3@$AGzca|nm%%xdFoMI%#s)q@
zHHkqfh5Q87^7K1t{%2?NZXxGc7nJeDLBZrN@JQ)2TcwVtF~kcD#^H8FGq?_LI_Ve7
zwd>Da2-lB76fl_6v6$Q{4n)Qm6+Cn*g}!&Z-`}mnkPj6kMUNd-<iHWCJ(m+Mfui|<
z1Yfp({|FsBFONiKsKWnxL~c$tZsALLpW{j<an3W|K_x{nsmuSiqu}VYU~UJWtf)|Q
zj>&nxIJqA2gsKmvlNGmt1Cbc~WsfXzQJBOUx%~Rj^1qD8<)*N5b{Go%fHZxDvu}OB
zO3xd<zlZ1K2GwEf=)c$`K~yzif)udwn+>Yl!Ya~af|+6E@R)@8;Fm+o4~=36z!Pe~
z+#NLWrzLP~u(UZcR|GfDLqJ9iV_J?$Hm2k(vgH-UV45Dft~dzi$}+ANn3E59i9^ZQ
zFjE;kHfjA7)`oDH3LcHtVgLe{J7Tin^|TuD5)Pu(J{Ev~ewmXT<jlvHJ;{Mj{_k3K
zrK240nt6XPUpZ_gXCA|aI7Tx((!-AbU_^^-V!<5dS~UnmOm+~O&eAOu)JMY4Imt$8
zx!iFdi}>Fy$XjU_+EjKCyOp-_ifWees`<CSu#9UmKLSRI#TWYidx^|cTGNs*p2ML;
zuN7F+4pECWE)@fEaIiRiG>r1bODPADQn-Y&cAV$GD93;D{5J!h|1K%?9jO_IS6T=!
z0X&{8+9jDLjtnqLhF=;m(~QF`F@)Lo^D+RhL`bamDZC&RhJ;ai%B}wonQ4KU9+=q`
zW<k7Se;_YGd1S5uX0gC5Y8+;`Ir5*VKMHuk4&Xn!^R@&%%5Q?>SZmmhsKm>LkMe~e
z^#g*^5c&Y7emH~x%wQ|w9~I*WR-oYjz;gi>;8g&;0yb6{P(RMx|D=~ZFoSah|6qO(
z+|MC;a(R5o=l=7|N|aZEE3lWdw$laQAL0MIR`zNV+s|Ihk*D7OjqP76{A@MLb$5JL
z9L`obc^HuPi{$a7Rq&+n_wA8v!_A|n&LVhof<zViK5PqarsUN7-`~vX+V5}XZKt0t
z>iX0r3E?=pJ~|#-1y7Rxpb|ltu7#67AdmXO_Wf-CqDP!U-(TB6nYcA5FYr!2rfB0*
z{|p<E*MXhDV^Hn54m!lkexNXx{qsqG`i1_Py}IzFHayo0b<`iIW!YpF|MsW!eimm3
zugv0oWsRk<@OKYc2>ABH**)LGLXiSAgi-U~`Ipxai*%r%(|gBPP;dZyi!T&>duQQ+
z$wJ>-PTr0OcGmt;Ie$~=``baxpOxW3tFV$!{TWyI@L)aQUbgX2t2)mk-&$$hu~(no
z`vZD4u3d#rwm*jj*H33Dd;<y>udML*DhhpnI4$XA|3QF1mf*Jym+IrhE`|N&_3=eu
z9U2r-!`2mV*P=o|A7Ch`j}!i+z}%@EOOZwo@Yri0Fv`uBb|iR&|Ex9JAt9H}iL5|e
z!AkC&10#D9vcE}XIa)r)0tg)^(}jl5V&U<W2bil}CZf*sz|PbSutfuLXPY_fT-i9W
z$a(Bkdh3T6i(b<JZ}4)yF1SvFs|T);aBYLDKun#|-hH9(gD6NjA@%%B4;2#tp&qWl
zfTgApaIJ=W6<lpWYR{6)a4<7R_V|i+6!W^0b{d+5;C13#iO>M#yknzq1wqEngFqnh
zsTR0`#HX6!3OzaHgewSmsvfQ&;Hg@;f`F&0;R*ttvPnmNc0b6@`n>*bDeQZ!fVaB3
z*;`#MV#yQXy+e;}iD@GIgYOm5(W0cR3pLv-i9Q#GXgj>xl?yoApC*a9opAk_q!~5k
zhv7}Ij68U-O&5?QChblKEiF!iA-t72k-Py+H_H#e$q$nKxALQ=jkYvQPmLQcw3%MB
zS&ePw116tMZG7cImuYo*pE2{oUUcbb6Zr0}DZBK5l~leX%zo2hgk30DPB>gJ)Y)W0
z^|nc{??@mwuQ`>5c4H+~JK^yLS={8KXNs3iJ(aNyo*T$D#dJwYx~ggctuBGrBISdm
zcbul}CFwIxB}+(myn>dNy}Z1i9xX|odWQ?1sSweLYX9SHRI@TwcgGE`?7#+RL)8xX
zWYHa&v~=Y%;Q<s0#>gs*SR>!_?A|irK@bS*ljZtaxn3*3iP^1m8(-&QL+~+KVI{ZA
zuTOpjJ2v($yd7Vj<G>HzTFKV5jRap+g)$w!QFrT&@*8#RRRgmqzfqT1dTsRaZxn;{
zzft#<72l{!ha4W>D^k`Ch^4$yr<6&OeN~Op(7w{7=;P~xnZ;p{_=>3&hfl5&X<Au)
z^zndqgZJ?y%q6Jt5KOTwK~>g5yULd0rN0c``E8+5<?zmS%gY(%DsJj$6_4Q-drp}X
zJlzUvS(Tt$Ie?R5+XA)^O|XjJ^;Mf(J$qrl$+L0*=N>o*^`)4fi3%otch$_PKn%_e
zi-1W#9bT0hQuK8c6wRi26``14^VD7uhFQljUkb-;qkZ9+y$o~yEnz%iVRcI=&k=Y+
z4z2$>40FUxyTdVSp=dVsg=4l+!|E`e2N>pkt3z8KIZs=|FuzG-n8(8~zp37SYbeWa
zb~D7AZw+PnO+T#*!~9myFy9En{I-A&gk#o2(QLZd7RvKmI5uPpZT$-i!+a_nbC7z&
zFu&6<%xSlU^8C(9Gj0pz`CT2u6v8n(X=ga*L56uI4D)m=)vO8Sd3rAu*UYB3uL*5^
zl!xL_%+YFw`ED5IX&W65!~9|e!_2!ql;@c!YQH^<=Xr+tQW)k%1MRzAdUfz(2G!e*
z>@C8toYZF5Nnj^+Dqt`5DBwxjD}!HaX}<!lprZ=tp!!OQ!`GeEtbhlpO##nSrwoo5
zs7C=;&|U>}(0&E%qN56UgzE2*_<j>b%?fCtHU)H2rvmPy9tAv4du8z3WZJKQ5bP9C
zr1~m}@3-)^2n7Ur6>yk3W$?R1>QTT_+N*#f?N`7(bW{P4Qhl|=_q$PQmcdaiwJBf$
zbt+&z^(bH)?Nz|Nv|j;_&`}w@NT_}-xK0PPtkuo9SOlRX2BR)ISNPC@lZsEqExlL)
zA2^6%MGHub^!#VazC14^ZRj3zOGVi|;zj{}bpagdMJGM{q%L8K$8@Yzl+gTMG#G6+
zqS2{$#wzX--%#Ckv5#il={G!9G!_L#v#D^W-$bS2CA2dfvzlR^3CC=sn!Cby9-!h~
zFqQ5K<2ee&p_slzhWTz7rVpl4IHreT=GBDq^bJvaO(;(|SBR~@6ov_@Q(rh{3&Whh
zE|e!ZKrQRSc#bg4Ux#7ByS3e6m|O)Efu|40+)NF3hw|i(GR*t#4sBhfrLAF@Dv9Uu
zaLmr__k^-kon$O;z9*Dr#1dK;h8a=MFy9Er+(QS#G2u0ud%)AzhVoSFX;E!x>*`X5
z`BXS&GxdgJ9%h)+?hWNRA%<q$8_IJ6gdS*J2*+%uo#B`V80ML9%u%XYAIdWlT>5%2
z&-J0LN7g}c80H>^`EEGoARP|FoCxRffM?!)p*$zrsQtcBo)g;`=1bw2M`&LdW>gHr
zoL?8pGs;XYb)h_?P;^K{!ZAB(cR1z|C<5~g!<-aL4fm%`k+Uu40VdIx>a_H}`$HR_
z<e{zihc-S*VtG6aGdgPf1EGk~JZt;r2SQm!*U-9fOvqS3$~VF>hv>iqxh(EYCUnR%
zm*#Dl&2BH+scnPg$1iTCP6gacJqkETdu4Demi8-P0UcGqdaAFNIE-~svjQHaHW~Cq
zQKtg()T4m)v{wOpX}=7@ryoWYa0%5vDDfpV)U1G=)TV$(s8a^HDC$u_p7ttW4eeLJ
z-E>p|hpGM{iLWYynia5~+7z&tI%P0IO+5+-5nKT`(|!f?(oqE*q57XmeAU2L0jsG^
z0U_g1z(MMf!3hT1tAIAzuYevps(=t_9TMM24K*v^3TjipX6jTxFZC$k2<?@@iA!j|
z0@l${1>8gR4@-O}o}^|OjM7t^0<NG=1r(`A0lR6h0>a0PWN=a%9aX?Os{gsfcTzVs
zD<FI?K?b9>)Tw}0>QO+E_9~#4_WwLLVR9k_e*;GKZFyx5lMix&r->d{aIWRBZQlW_
zCiBLGcv#>-kmq+zULrjEIeRY?-sWL%2j+KZK;;{C3AhHDT#J<Bpftk{v4)Bp<0Q1M
z%b?ZZMlzyBGHwT{XX9KhHb6IW8M+Lh)B5RRcpBrJ%Yo06+lvv$r<*ncbcO)k0SYg2
zaS)&ty7QNz^8#J6pKeMT9Rj*EKi!nesA1Y>pvwr*by3@<x!jTf-R0UV0y+o_vR<Yp
z(!)S!_R~#eA5yqf?bEbCX9>`?P;<jvt{_0yJAVJB4gejz{;RY%LiYgO3P0U6{xWpC
zfv(6;H?5ZH1#P11cA~~yP_m$D-MIb6A14)nTZ&6(Ofdtj_g#iHs=yXteUk1G=5lsF
zoyKq(I#fZmpH5Rv_2OKvCP3FYKHU^lL2ZC;fVKb~1Txt)reCJLDX4;aKi%{SItp}-
z0A1^4+N%RPXMpY?t#!@iL_gh(*vruIK-cW2n^8*pfo^kv?sDznGn<wG-C??-aW2;y
zpu3DI#vBAX$Pr}In5n0|K-cc4n|T>ijA;crPk^qOrZvswIs<fj$M0VZnn_oH4tzS$
z?e^2fGGBG6>Bks=ZjYZXb_I=Tp38Ly=q}?DCZ7bly#cyz>IAxd0lLBQ<(%9NbiIDM
zS&4KA=)8WqS@z4&Ie_j!fUcF=eleFj7@#|R89EEl9S+cq(!)U4=ckKfTc(%lWpWhI
z9r4q}l~VJ6&4pZFvFo_Y=q0)j==uY6@a7fJ4Fu@=$Cop@9q0!AbhBfq{+DyPlYY9{
zOD;oa2fCpEosG8qQd=G5N;rPk>~`6eoCn-t#g)LJTE*S4uLT0$UT`-fSExS>^`lCC
zK(xyY^(2@A9Px{$O{BKXIu)n(6Kb8~_h}N$0Z5{hxufl+hd0lq!p7MwC~7Y=<0ioj
z;52@!IZLQ{OK?z}bD3Z>31$GN4bXMbJwT_&f^>|obNbObP*S$W&xdf%P6J1s%rOwL
zG9^~+ngkoAw{r$su=TpkZah$b^;T6<e#a!U1anIPcH*(#tG94z`5jTcc%WI@_0`4F
zeOrH=lbB=RNM*{mFgrNdTt;}}5Ws0U2H)ArlwT|XI3ve!=Htqgodn<|5^OdD%v0~y
zB*E7Opv-0r6*wLnc(CPbm)L*Z62SioCYK+71Yo(@JNscTJPqzy)A$|F$`p?m?&ao9
zqfIWNg?qlq?Rt=#Ne3Q@Hcqzsbp@#peAZ$`ptqCRtdaLhu&ySkZVw%LL}#3QG>p76
zfD)q#s|!+O416}KMW>2sr?wWIG3H1p=CCHfWr}|@9&<DJ97bADT><R|E>lE$7`RM1
z5XMCeU`|zs)p>&ImQcf^I@MHIDLe}Al6t~0hl4QtLhH`P1nQ<~Xe)4;W~F<8%e3Y&
zOnVUK!LYg@S*DF{|CLUq;i>*tI-@3F$E@pTgGAA=j3O{LUj~Vy8KHH+W%?4@0$irE
znG}Q>B+B%zP*J{g2E?2Wdl0~72Bhb}WkyXHW?ukvMmU$Dpt_^9=+`>cOhRjatuxNd
z2<39l62P2U9ad)xs)G-SA(sQRAGwT#VRi>FV_Ad<^!D80pgJ4PXw|7=Tj`2coiWxM
z%H_Nv2y-;7&K#(l#nVpUGOLdE0+(4~eLvqCgvp{uK$i1+0(EgQRI^Q|isNb8Hk~n!
z#nAxf1rmhW5-Q6DeNY|5X5<2&b_Fi8wPBcb0nFK!u)3C@I(SU8O;<iUtkYj522iwN
zZsMz;fz!5yvi>S);Iw_zzFnu96GNTbb;dd2T!IE}PMEX#Drn&5?4y0#b;6use?#Ec
z3w>X!f4Fm8Q&;F4DUk3F41yDso$s4R0G6Gv`Y6D%Grgt$5@$L)g<1eX_NG}L#hbdt
z2VphWO((BKo?K-LsSWUqiV5&+#&+en&>;p`<@5p!r#ill{UP#ELtBCXpI&gmp6h;+
zVe-PsK8~1CHSpQmC47~RXN%tfdFMN)%)x?}OIiR!J^Kb8Zfz^;7o_EP>55=$Tr0vu
zZf1y=*4v>zmet=bZ>fhdr~?Ge6&P&Bz4!2X6cz=5@<eGdrR$`I$KW;71M*h90gI)r
zc-;}&`q<nBrKXR{4`Acla{W8;L0EHR04qJP3!ljEnwv%sKNhq#hD8-r{dicBlbXYe
zJhVQ%sF&^uFY2d*;YFiV?+#_J*VEGQA~S6XFRG>o!i!qysJlGcR>Vdor~Cl5wWqU9
zIDI>9ZI`x8bltRD0Z-CC8Jr8xOBIl(nkOXOxptbNfX%c>0paCe1w24o6%anPAcJ}}
z?Nh)+I;?<Js(Di4tFNOOPx_z1==Z|lUh)h^rT5bICt-ZqK@NCk9TOPed0Kde5+7ea
z8aBAWC`EuWmtM6abVqZZ2>X=tY1NMTOfU1=*k0u`JEXlzJv{l`A&EFIjSeWFeY?jm
z?7ZG_g`Ibh)_CIMR>fTUTxi}f^#J{<80z&TM8nB}s(GWPV{kj<$&!RPLKAl;;n&eu
z?9{1ty#I2|P8Bypy9tjJuya10_?>mSjygLYQfWCjO`wGrnr9Ebta<A32;Hh!OkHn$
zofzap5d+y4LY}x`RV?-XCSG-@n-2WuCe>feG~=0a)j>7g{LIhcND%T?+@#o1zMIW`
zIK{(P*$h@P<0D9e@z`@0;x!#B->u-nStd2UV2`gT0^TchMOS>h&A>O?*r%{i3?xM~
zab5XtKylE`U0FZ*wg1>94jCrjFq+l;u6P!V@GwRA0f+Dd7OoVVZTqe)m92s<+0~$m
zH`Bel60YqyY5Y1q+4NeO$F#bv(?kf#wZkjnBK)8o_OT9-6pq|j;lnh)z@t1(9lnvK
zT;F+12gk#)cgM@xXR|nP0_^(*aEwH(hi$)#-@Y0NEMF_@q}tu(!l)fPh5F4-fsd<J
zMzoYRYm9l&(k784nKsT(b3SKCryoan@ZBdkPr|-G-O5FDZF5D`Zr>jP5=4m9712uf
zN3?HuMbvG7I--92#}Q7tAflP(M{K4~N3=<YY91}ihBQum1AfOzG8|ZOh=Pw;o$GY5
z@Y-(;zk@825f^1ce8X4y067Mb)0}sI84IrmuK=9YfLkl$O+bdin^5-#_}$|q!?}*(
z6#?Ea0k2NNYx#)rlknh(FIgh<D-{57FCfYvM{jv0h@ln`d6{7a;C&2u@*$s=M}rvZ
z0naQmwDCK*setE{8(tg4&j5H9nV%i-On@h_vwiT%j2vVL1<i7A5*fqeqyP|Wpy$;x
z!&yNLTYzD^%+LdPk4ZR>oDC8VUXLQ3$P4QKEZ6_N=_&YX0cfM~xIo(RgH}!RNlSi*
zDiN6j;u&OWf)^}gf~WD25)!~^ID(Ii7d;N|Iha(>7<Z^1GJdDJ!T2YYKEH$1Z+M<W
zSQ@##>GR-i%k5kp3WAo30?53|*c+PLx!S9D!iOP*4o<(g9p5(PI$6&W|LVZT@jEm!
z!9pZx0wGZd(`xvu1FsPdg@9MU+mNQoN80%vsy?KXXttg;ZB$+KYvDKu55@~xR0}8I
z>)`X@16v>vBzH0L*G;zWM`Tcy#@PTy=OeL50Ek*13=0tT&bxIA^T+r~e3=E#AHmE4
zPZDxqN`#r=f|&uwusB?SHo}Z(gc-5P<uWwFY-xm<(F8N531&xAeuS{O38q{VOrIv0
zCQUGfnqaE&3nDsi5{UtOjDn%G0%%5jj;Q4xPQUs|cpXvJjHP4jB%CE1L2clB$^lJm
zImOid;@APE4b(31!cXK%d<6K`3NQiUE=Jt-0wc!plMuE%C)bw>;3ELf?lez!z?Y5t
zc@YmIes>VAa4POQFaG%e^dn}GxS;nc{1XCs1E8V2vR1zNeGlYlv5K#S)DqNR)@oh`
z$W4HVssf@2L;&PA_(L2T2=xYFI)F@}j=&R)*t||)m{abc&AXH0%JG;M`~I`S*OgZ;
zQt$56+;aS;8&QgLV4zypt<oYTaEemOUAZy~_=caq3|S;Uml`)N3%z?d8lEJyJU2sC
z-by>4OP{eyE2kvLnKZ2_Z>9s!#pRZ_ioz<r$u50nmpVhxq9E=xD-8;VpvxkOKsKP4
zL<)3t$@B1WqB?4S9zL60OE*6suPd*|9T}O3MIvX@Rrsa*I_gENI(qW?5><IUHNOy#
zceWSS;9c(vB?;x5#k*H2OCv^_V?oO;Z^L+pbu?oS{80r&(<?2=A@?W?pK$z=*6&Hs
zm20+vIVzH)2bZc7YH0VKcvS+t!Mw*9nb2)|En$Fae)qfzF1^3|QUymtyI)M5vC5F|
zA$H6om;lSmN9fRtS<&T3AeV=)gRL^q<d?D{R~bMwST?<+i(6#?<IsaK7;rk^Fv6cP
zG0@hRbShgS-SbjXq%G0(8vK2Tqc5e$+Y+s$=^`F^gpZa~<caW^&Q5p}%~L*TdJTxY
zzb~LQ-SJ4cx%(m2D#P~QFU@_flD+%xA$?8zNi6%eU<ZMZQLJJyAEX`1vqPgMTcUJQ
zhAd$`zYA-&vGNMdE{7&xj`_pVDAiSaXu+#@s}{Ds-2Lim6<%Xrdq{=F&2Oy6+krRM
zv*MyZuaCrH??EFLj~*<KP$dk%TzYstht~t|{EbsB8lr9Q-mO|R@`t`LHD2C-bplk<
z-hcfH?&yjS{{|>8>-(RbnwqEHb`^ZkQ$(M6u@uzk;wR-Lx6a4cmo65dS}_?CCoMYv
z^3Z43s<MLd$IPMlV`;qIHwGJX-63@L)Bl<d62ENrC8$-a5_{|soN<zBk+a7W!)0+$
z)6+MF`v>;b-KF7P)LpRSh{BY446lYNqC$4rDU14hYNvCbO;n{fyDR2!tMR&b4%Z0R
z9$v@&T*V6X06;~?JnmZ6D!aRW9+w_pz7HbMX0%NnI*PLihZg^kN2>rh-g#V{s@&^7
zI*&_Tv&s$~5V1wDIy;!#Ud5)f;j@R^@>bcQlRiAl&FmZa@l`kZXDsrAI*a1*aN-BN
z9kgYS=i-(F&l{voScNCd?pVLGV-8NTX>r{uJIZ>aN6K_jF5rC<`e6atyl!v2)KB$%
z4nF+mbtli~ma~4(=ZsTh+1D@e;JcN?-stX~&!sPoohO~5C-5O3i0A@-4`wEOFdUL4
z`2K-Y(7|_AW^TcDkUz9@gSZLgHW;{L!1wV5-1bPO7O%T~0r&r~DQ5z=MkyOe;Qowd
zT~~2NxvXdKD(>4Dl`Y0SkO70HzQJwI<SLZI%v$F?a~+_eL5KlEtxuE9Zchfs3)sGC
z01n!&v&G~X1Yc!}&*%KbRSsAYY0x9U70%lGe7|2n;=pOBo>)K}5T%Bp+zAV5gvD%&
zDr(2a<Y6cif1gicw^agNCDB?*M80bQiP~`r_(Q9p_dyn97Lb#&FPYTHe*zyfm}JxT
zbY^ldMyS5I#a(m_w<f*_y<C68&C~(cUX#bB0qz5))$mf(u_9Z~;cK`Voa&}__rOvv
zUiI~J|KBq1b+u~!F1Odj{hFKAQ)K2~nieIyy*b=Nsv@(S&*gpvOnpy5p5uu#Z{f&q
z;G_0Gwd|a^IoAtcs{Eix?;gzMzT+144CHZJf!6G<&F4N<6=`}(ujQ6<I*HiQ5#exg
zq}~if*~{TGhHn>D^mJXv#Z6Rwa=NE?IhO>ai9Lgb+!vf`;C=Uz8@boxZ@tCIKBONx
zvVA}C!XCpOh>TG%<Pfxvf8*}HiThH8Y;NYh1!|4EvzU8ZRit&-lyK>)Rb}q>60o@<
zLr-rBldP!6TFO0(m_5T~Fry-iG}#4k6H~$cg~RbbdJC7Uvc>jjS96c6kzw~5WN?f7
z$Qqc%#e3Zqw{yR`w%Czlxh@0LYsev_@lZ{1`$f^7jBuWXG#-p9Ze`^hG3<Y}xc*{G
zg%Qd+vpLdw(OQ#yXg%;vwsT8WB?CQnJD1AEl|Y(M`eJ@#^g#?QWhoPL4?Vx~pu4jY
zWL&x19dj?2=<cuNW~hpt?%_%<A-cH!5J&j^&lNYj^>=VaUCF?vuF@Bgc>mqSEf+-+
z4;fR-{?*0x?z%g;5~MqD2bVCTm~GRU#p^QQ1qAK>DkvYhgL_g{yxZMY1zj($b04V!
z)fH8^)zvT+N(S8aYA#g;d|IlxT+rA4>SEE|SIs3v7K?{|1-cul=6*6kRlK>!ayPe~
zlO(HSlJ(yMx+~uNcrEuO2#7r#okX(o8&!u<&}>3f*~_Kg-OMd?+wSGEu$|U>!7icQ
z?t8&)KwIbUMfqFY*7e-0NyQ=<Gi>33_7{+hQ4;aM{wIs;aVmm7GP1QkA8R@JKJIPZ
ztpiHfg((V~V#Hv!<I5Pg?siAjfeX%dxtr^tui3>td+X5pUftExe?RxOTD7vTr|Ti^
z$;i00-$~}jWxyA0H2CF}Lf=b^+@+g1qw1xP-L0FrHL90f?%_?`eX|xIs-@9K7%F^~
ztk8G$S$BN{_XQeMwZOf)OxV=!8@n$Ge%0{v`o`*FePj36`NkgT@{M8LhBV*UgXbmq
zXCB|!&jx*C#YNIR*8d-W!vB@Q|B+shdT{r?|9wwN+I(Xr!@jYVrM|JU0pHjv;B~j&
zH&zAOsXp*Md<8(NJo-IIfO91^-{bI&Ibg^hCcd$|TCa>7&WDXZ7TyU-$X#aN*sU4x
z+w-3>31>Rqy{+CicAMoAz5?r6tz7Z&;Q)dY1i5X%H?{_ZSrb$~9`pZwnLPgg8wMzt
zLT5JwV5RH_U2l-bwrB{F9uD#zSeAdr6W35H{B{%9`D*w%;nxYj1Mur7u5&ixy5N9c
zGyMACH*8%;NYB8lT#U+{@fug)9_r<m#w2e@F+8yLu5}yg*FMm*{x$CBQNjajs~-AU
z<+^%9a{YaG-Br8RaK{5{EAOehZ{7NOSPK#I)3x>W>(<|8*ic_tb&sL`fy%12>FMdw
zWM$yqu(o#Xy=&Lk8!D@-A6UC#gVC@sgLgy|vU2VE>M&Zv&(_t~7;4w9zY8u4*G11J
z8vscXAgGCyo=@N6*38!3ymIB*`s*E4YwPOQ-M9X_%G%mHK#c1hgt&DdaSLLucNo@f
zFx*tOVg>Z}x{tUwrbqq_+^ns_9d(BLN#x%$04{ZxBK(dMV4J)13|AnK#)Jy^+2CjQ
zb2rpKT({P+aD(B#s;UPccwlYy0_Z~6e?KiM$;iO&RTvQD{b1%&KbW<IfzbppGX2FF
z*?v&ST;_+ft_i}<@)u_YTFDHwk|nhwvHo!YInYXGpp`7C5eZq635CwgG6+fsvI4DS
zNv%lOl1vOc&`MUIl`N?h2|3X7%s?wyfv)^mYD7Y2GTp_rml<d!E6~c1rB<TJiV_3-
z$0S`@Qj)<yhXKG$2@DyWf_%hg$OS8JSXsirX!pmDa<gNiSC-~qS7<0GyRpdV{{64H
z1rrR57UdccOlDv-137j{Q!T8++pA-uue-V6dWnkFESR&f&M3FR8uI_c+KHP64U-$-
zS5$KIPfPM|bboS&qr$L_sNw%8_=!XCUL2V~G;k-uk;DN1ORyTsHAMV$5Nb72xeSX0
z{%0`Ya)iMMsnjyesW_E}!G`L!ch*+cuQg<*XQf|bxbD853&Y&n=%jQtX-tnLu2Xez
zh53=520t_Wtnh<bkY0;*J>qxV;|9U7!slCHlYWMQ0IZZL*SVX0KEn~Iey-Q&i|?1<
z`591N{rx|MPuNxPH?CC7t^wu+5_9FM)ZsP0PpU(Bc5DC+#)&%|D4$m!fP--)SO~2&
zv;fmuNdRn|31F4V6yo{A5{&`=2*zy4?hHdd-+Z%FHXm>iFD^*Pc|&O0!T$xhnVw(I
zQ+*TZ9)6Tly9ds|KP`!>sU^wHq%m<1AsiS07Z2#uNaG?H)gQIVq*58)G%jkD%VxrL
zBK$=|pL`E>tHJNBK1dpG<<ZI)Ml{~k=DvR$_p_c~E>zKoq!V?_NYGHO@N-*IRK^*r
zYDgpeT;*os+M*$iMYZmh6xE%n?pS|wgn*5*|E9ygAUaVISC5u(ZulEQo&#=uswzHf
v<p5DF;R%VdFih#6C>fp)SA-+LdBgJ5?11m;4Y+GlRq(fm9q!gtRqX!{?x2O>

delta 28602
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