From b1a2a27868efe713e878db02e7a4ac7f0e858ebe Mon Sep 17 00:00:00 2001 From: Karmaz95 Date: Sat, 23 Dec 2023 20:56:10 +0100 Subject: [PATCH] --- I. Mach-O/custom/MyBundle.c | 7 + I. Mach-O/custom/hello.c | 6 + I. Mach-O/custom/mylib.c | 5 + I. Mach-O/mac/byte_order.h | 374 +++ I. Mach-O/mac/fat.h | 67 + I. Mach-O/mac/fixup-chains.h | 259 ++ I. Mach-O/mac/loader.h | 1593 +++++++++++ I. Mach-O/mac/mach_loader.c | 3912 +++++++++++++++++++++++++++ I. Mach-O/mac/machine.h | 416 +++ I. Mach-O/mac/nlist.h | 320 +++ I. Mach-O/mac/vm_param.h | 207 ++ I. Mach-O/mac/vm_prot.h | 191 ++ I. Mach-O/mac/vmparam.h | 57 + I. Mach-O/python/CrimsonUroboros.py | 285 ++ I. Mach-O/python/MachOFileFinder.py | 57 + LICENSE | 811 ++++-- README.md | 58 + img/CrimsonUroboros.jpg | Bin 0 -> 140440 bytes img/Snake_Apple.jpg | Bin 0 -> 188099 bytes 19 files changed, 8456 insertions(+), 169 deletions(-) create mode 100644 I. Mach-O/custom/MyBundle.c create mode 100644 I. Mach-O/custom/hello.c create mode 100644 I. Mach-O/custom/mylib.c create mode 100644 I. Mach-O/mac/byte_order.h create mode 100644 I. Mach-O/mac/fat.h create mode 100644 I. Mach-O/mac/fixup-chains.h create mode 100644 I. Mach-O/mac/loader.h create mode 100644 I. Mach-O/mac/mach_loader.c create mode 100644 I. Mach-O/mac/machine.h create mode 100644 I. Mach-O/mac/nlist.h create mode 100644 I. Mach-O/mac/vm_param.h create mode 100644 I. Mach-O/mac/vm_prot.h create mode 100644 I. Mach-O/mac/vmparam.h create mode 100755 I. Mach-O/python/CrimsonUroboros.py create mode 100755 I. Mach-O/python/MachOFileFinder.py create mode 100644 img/CrimsonUroboros.jpg create mode 100644 img/Snake_Apple.jpg diff --git a/I. Mach-O/custom/MyBundle.c b/I. Mach-O/custom/MyBundle.c new file mode 100644 index 0000000..bd8d819 --- /dev/null +++ b/I. Mach-O/custom/MyBundle.c @@ -0,0 +1,7 @@ +// MyBundle.c +#include + +void sayHello() { + printf("Hello from MyBundle!\n"); +} + diff --git a/I. Mach-O/custom/hello.c b/I. Mach-O/custom/hello.c new file mode 100644 index 0000000..f26b97c --- /dev/null +++ b/I. Mach-O/custom/hello.c @@ -0,0 +1,6 @@ +#include + +int main() { + printf("Hello, World!\n"); + return 0; +} diff --git a/I. Mach-O/custom/mylib.c b/I. Mach-O/custom/mylib.c new file mode 100644 index 0000000..1292f06 --- /dev/null +++ b/I. Mach-O/custom/mylib.c @@ -0,0 +1,5 @@ +#include + +void my_function() { + printf("Hello from my_function!\n"); +} diff --git a/I. Mach-O/mac/byte_order.h b/I. Mach-O/mac/byte_order.h new file mode 100644 index 0000000..c698e71 --- /dev/null +++ b/I. Mach-O/mac/byte_order.h @@ -0,0 +1,374 @@ +// Extracted from Xcode 15 Beta 7 +// /Library/Developer/CommandLineTools/SDKs/MacOSX14.0.sdk/System/Library/Frameworks/Kernel.framework/Versions/A/Headers/architecture/byte_order.h */ + +/* + * Copyright (c) 1999-2002 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 1.0 (the 'License'). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License." + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Copyright (c) 1992 NeXT Computer, Inc. + * + * Byte ordering conversion. + * + */ + +#ifndef _ARCHITECTURE_BYTE_ORDER_H_ +#define _ARCHITECTURE_BYTE_ORDER_H_ + +#include + +typedef unsigned long NXSwappedFloat; +typedef unsigned long long NXSwappedDouble; + +static __inline__ +unsigned short +NXSwapShort( + unsigned short inv +) +{ + return (unsigned short)OSSwapInt16((uint16_t)inv); +} + +static __inline__ +unsigned int +NXSwapInt( + unsigned int inv +) +{ + return (unsigned int)OSSwapInt32((uint32_t)inv); +} + +static __inline__ +unsigned long +NXSwapLong( + unsigned long inv +) +{ + return (unsigned long)OSSwapInt32((uint32_t)inv); +} + +static __inline__ +unsigned long long +NXSwapLongLong( + unsigned long long inv +) +{ + return (unsigned long long)OSSwapInt64((uint64_t)inv); +} + +static __inline__ NXSwappedFloat +NXConvertHostFloatToSwapped(float x) +{ + union fconv { + float number; + NXSwappedFloat sf; + } u; + u.number = x; + return u.sf; +} + +static __inline__ float +NXConvertSwappedFloatToHost(NXSwappedFloat x) +{ + union fconv { + float number; + NXSwappedFloat sf; + } u; + u.sf = x; + return u.number; +} + +static __inline__ NXSwappedDouble +NXConvertHostDoubleToSwapped(double x) +{ + union dconv { + double number; + NXSwappedDouble sd; + } u; + u.number = x; + return u.sd; +} + +static __inline__ double +NXConvertSwappedDoubleToHost(NXSwappedDouble x) +{ + union dconv { + double number; + NXSwappedDouble sd; + } u; + u.sd = x; + return u.number; +} + +static __inline__ NXSwappedFloat +NXSwapFloat(NXSwappedFloat x) +{ + return (NXSwappedFloat)OSSwapInt32((uint32_t)x); +} + +static __inline__ NXSwappedDouble +NXSwapDouble(NXSwappedDouble x) +{ + return (NXSwappedDouble)OSSwapInt64((uint64_t)x); +} + +/* + * Identify the byte order + * of the current host. + */ + +enum NXByteOrder { + NX_UnknownByteOrder, + NX_LittleEndian, + NX_BigEndian +}; + +static __inline__ +enum NXByteOrder +NXHostByteOrder(void) +{ +#if defined(__LITTLE_ENDIAN__) + return NX_LittleEndian; +#elif defined(__BIG_ENDIAN__) + return NX_BigEndian; +#else + return NX_UnknownByteOrder; +#endif +} + +static __inline__ +unsigned short +NXSwapBigShortToHost( + unsigned short x +) +{ + return (unsigned short)OSSwapBigToHostInt16((uint16_t)x); +} + +static __inline__ +unsigned int +NXSwapBigIntToHost( + unsigned int x +) +{ + return (unsigned int)OSSwapBigToHostInt32((uint32_t)x); +} + +static __inline__ +unsigned long +NXSwapBigLongToHost( + unsigned long x +) +{ + return (unsigned long)OSSwapBigToHostInt32((uint32_t)x); +} + +static __inline__ +unsigned long long +NXSwapBigLongLongToHost( + unsigned long long x +) +{ + return (unsigned long long)OSSwapBigToHostInt64((uint64_t)x); +} + +static __inline__ +double +NXSwapBigDoubleToHost( + NXSwappedDouble x +) +{ + return NXConvertSwappedDoubleToHost((NXSwappedDouble)OSSwapBigToHostInt64((uint64_t)x)); +} + +static __inline__ +float +NXSwapBigFloatToHost( + NXSwappedFloat x +) +{ + return NXConvertSwappedFloatToHost((NXSwappedFloat)OSSwapBigToHostInt32((uint32_t)x)); +} + +static __inline__ +unsigned short +NXSwapHostShortToBig( + unsigned short x +) +{ + return (unsigned short)OSSwapHostToBigInt16((uint16_t)x); +} + +static __inline__ +unsigned int +NXSwapHostIntToBig( + unsigned int x +) +{ + return (unsigned int)OSSwapHostToBigInt32((uint32_t)x); +} + +static __inline__ +unsigned long +NXSwapHostLongToBig( + unsigned long x +) +{ + return (unsigned long)OSSwapHostToBigInt32((uint32_t)x); +} + +static __inline__ +unsigned long long +NXSwapHostLongLongToBig( + unsigned long long x +) +{ + return (unsigned long long)OSSwapHostToBigInt64((uint64_t)x); +} + +static __inline__ +NXSwappedDouble +NXSwapHostDoubleToBig( + double x +) +{ + return (NXSwappedDouble)OSSwapHostToBigInt64((uint64_t)NXConvertHostDoubleToSwapped(x)); +} + +static __inline__ +NXSwappedFloat +NXSwapHostFloatToBig( + float x +) +{ + return (NXSwappedFloat)OSSwapHostToBigInt32((uint32_t)NXConvertHostFloatToSwapped(x)); +} + +static __inline__ +unsigned short +NXSwapLittleShortToHost( + unsigned short x +) +{ + return (unsigned short)OSSwapLittleToHostInt16((uint16_t)x); +} + +static __inline__ +unsigned int +NXSwapLittleIntToHost( + unsigned int x +) +{ + return (unsigned int)OSSwapLittleToHostInt32((uint32_t)x); +} + +static __inline__ +unsigned long +NXSwapLittleLongToHost( + unsigned long x +) +{ + return (unsigned long)OSSwapLittleToHostInt32((uint32_t)x); +} + +static __inline__ +unsigned long long +NXSwapLittleLongLongToHost( + unsigned long long x +) +{ + return (unsigned long long)OSSwapLittleToHostInt64((uint64_t)x); +} + +static __inline__ +double +NXSwapLittleDoubleToHost( + NXSwappedDouble x +) +{ + return NXConvertSwappedDoubleToHost((NXSwappedDouble)OSSwapLittleToHostInt64((uint64_t)x)); +} + +static __inline__ +float +NXSwapLittleFloatToHost( + NXSwappedFloat x +) +{ + return NXConvertSwappedFloatToHost((NXSwappedFloat)OSSwapLittleToHostInt32((uint32_t)x)); +} + +static __inline__ +unsigned short +NXSwapHostShortToLittle( + unsigned short x +) +{ + return (unsigned short)OSSwapHostToLittleInt16((uint16_t)x); +} + +static __inline__ +unsigned int +NXSwapHostIntToLittle( + unsigned int x +) +{ + return (unsigned int)OSSwapHostToLittleInt32((uint32_t)x); +} + +static __inline__ +unsigned long +NXSwapHostLongToLittle( + unsigned long x +) +{ + return (unsigned long)OSSwapHostToLittleInt32((uint32_t)x); +} + +static __inline__ +unsigned long long +NXSwapHostLongLongToLittle( + unsigned long long x +) +{ + return (unsigned long long)OSSwapHostToLittleInt64((uint64_t)x); +} + +static __inline__ +NXSwappedDouble +NXSwapHostDoubleToLittle( + double x +) +{ + return (NXSwappedDouble)OSSwapHostToLittleInt64((uint64_t)NXConvertHostDoubleToSwapped(x)); +} + +static __inline__ +NXSwappedFloat +NXSwapHostFloatToLittle( + float x +) +{ + return (NXSwappedFloat)OSSwapHostToLittleInt32((uint32_t)NXConvertHostFloatToSwapped(x)); +} + +#endif /* _ARCHITECTURE_BYTE_ORDER_H_ */ \ No newline at end of file diff --git a/I. Mach-O/mac/fat.h b/I. Mach-O/mac/fat.h new file mode 100644 index 0000000..03e7359 --- /dev/null +++ b/I. Mach-O/mac/fat.h @@ -0,0 +1,67 @@ +// Extracted from Xcode 15 Beta 7 +// /Library/Developer/CommandLineTools/SDKs/MacOSX14.0.sdk/System/Library/Frameworks/Kernel.framework/Versions/A/Headers/mach-o/fat.h */ + +/* + * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +#ifndef _MACH_O_FAT_H_ +#define _MACH_O_FAT_H_ +/* + * This header file describes the structures of the file format for "fat" + * architecture specific file (wrapper design). At the begining of the file + * there is one fat_header structure followed by a number of fat_arch + * structures. For each architecture in the file, specified by a pair of + * cputype and cpusubtype, the fat_header describes the file offset, file + * size and alignment in the file of the architecture specific member. + * The padded bytes in the file to place each member on it's specific alignment + * are defined to be read as zeros and can be left as "holes" if the file system + * can support them as long as they read as zeros. + * + * All structures defined here are always written and read to/from disk + * in big-endian order. + */ + +/* + * is needed here for the cpu_type_t and cpu_subtype_t types + * and contains the constants for the possible values of these types. + */ +#include +#include +#include + +#define FAT_MAGIC 0xcafebabe +#define FAT_CIGAM 0xbebafeca /* NXSwapLong(FAT_MAGIC) */ + +struct fat_header { + uint32_t magic; /* FAT_MAGIC */ + uint32_t nfat_arch; /* number of structs that follow */ +}; + +struct fat_arch { + cpu_type_t cputype; /* cpu specifier (int) */ + cpu_subtype_t cpusubtype; /* machine specifier (int) */ + uint32_t offset; /* file offset to this object file */ + uint32_t size; /* size of this object file */ + uint32_t align; /* alignment as a power of 2 */ +}; + +#endif /* _MACH_O_FAT_H_ */ \ No newline at end of file diff --git a/I. Mach-O/mac/fixup-chains.h b/I. Mach-O/mac/fixup-chains.h new file mode 100644 index 0000000..f56dcfd --- /dev/null +++ b/I. Mach-O/mac/fixup-chains.h @@ -0,0 +1,259 @@ +// Extracted from Xcode 15 Beta 7 +// /Library/Developer/CommandLineTools/SDKs/MacOSX14.0.sdk/System/Library/Frameworks/Kernel.framework/Versions/A/Headers/mach-o/fixup-chains.h */ +/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*- + * + * Copyright (c) 2018 Apple Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +#ifndef __MACH_O_FIXUP_CHAINS__ +#define __MACH_O_FIXUP_CHAINS__ 5 + + +#include + + +//#define LC_DYLD_EXPORTS_TRIE 0x80000033 // used with linkedit_data_command +//#define LC_DYLD_CHAINED_FIXUPS 0x80000034 // used with linkedit_data_command, payload is dyld_chained_fixups_header + + +// header of the LC_DYLD_CHAINED_FIXUPS payload +struct dyld_chained_fixups_header +{ + uint32_t fixups_version; // 0 + uint32_t starts_offset; // offset of dyld_chained_starts_in_image in chain_data + uint32_t imports_offset; // offset of imports table in chain_data + uint32_t symbols_offset; // offset of symbol strings in chain_data + uint32_t imports_count; // number of imported symbol names + uint32_t imports_format; // DYLD_CHAINED_IMPORT* + uint32_t symbols_format; // 0 => uncompressed, 1 => zlib compressed +}; + +// This struct is embedded in LC_DYLD_CHAINED_FIXUPS payload +struct dyld_chained_starts_in_image +{ + uint32_t seg_count; + uint32_t seg_info_offset[1]; // each entry is offset into this struct for that segment + // followed by pool of dyld_chain_starts_in_segment data +}; + +// This struct is embedded in dyld_chain_starts_in_image +// and passed down to the kernel for page-in linking +struct dyld_chained_starts_in_segment +{ + uint32_t size; // size of this (amount kernel needs to copy) + uint16_t page_size; // 0x1000 or 0x4000 + uint16_t pointer_format; // DYLD_CHAINED_PTR_* + uint64_t segment_offset; // offset in memory to start of segment + uint32_t max_valid_pointer; // for 32-bit OS, any value beyond this is not a pointer + uint16_t page_count; // how many pages are in array + uint16_t page_start[1]; // each entry is offset in each page of first element in chain + // or DYLD_CHAINED_PTR_START_NONE if no fixups on page + // uint16_t chain_starts[1]; // some 32-bit formats may require multiple starts per page. + // for those, if high bit is set in page_starts[], then it + // is index into chain_starts[] which is a list of starts + // the last of which has the high bit set +}; + +enum { + DYLD_CHAINED_PTR_START_NONE = 0xFFFF, // used in page_start[] to denote a page with no fixups + DYLD_CHAINED_PTR_START_MULTI = 0x8000, // used in page_start[] to denote a page which has multiple starts + DYLD_CHAINED_PTR_START_LAST = 0x8000, // used in chain_starts[] to denote last start in list for page +}; + +// This struct is embedded in __TEXT,__chain_starts section in firmware +struct dyld_chained_starts_offsets +{ + uint32_t pointer_format; // DYLD_CHAINED_PTR_32_FIRMWARE + uint32_t starts_count; // number of starts in array + uint32_t chain_starts[1]; // array chain start offsets +}; + + +// values for dyld_chained_starts_in_segment.pointer_format +enum { + DYLD_CHAINED_PTR_ARM64E = 1, // stride 8, unauth target is vmaddr + DYLD_CHAINED_PTR_64 = 2, // target is vmaddr + DYLD_CHAINED_PTR_32 = 3, + DYLD_CHAINED_PTR_32_CACHE = 4, + DYLD_CHAINED_PTR_32_FIRMWARE = 5, + DYLD_CHAINED_PTR_64_OFFSET = 6, // target is vm offset + DYLD_CHAINED_PTR_ARM64E_OFFSET = 7, // old name + DYLD_CHAINED_PTR_ARM64E_KERNEL = 7, // stride 4, unauth target is vm offset + DYLD_CHAINED_PTR_64_KERNEL_CACHE = 8, + DYLD_CHAINED_PTR_ARM64E_USERLAND = 9, // stride 8, unauth target is vm offset + DYLD_CHAINED_PTR_ARM64E_FIRMWARE = 10, // stride 4, unauth target is vmaddr + DYLD_CHAINED_PTR_X86_64_KERNEL_CACHE = 11, // stride 1, x86_64 kernel caches + DYLD_CHAINED_PTR_ARM64E_USERLAND24 = 12, // stride 8, unauth target is vm offset, 24-bit bind +}; + + +// DYLD_CHAINED_PTR_ARM64E +struct dyld_chained_ptr_arm64e_rebase +{ + uint64_t target : 43, + high8 : 8, + next : 11, // 4 or 8-byte stide + bind : 1, // == 0 + auth : 1; // == 0 +}; + +// DYLD_CHAINED_PTR_ARM64E +struct dyld_chained_ptr_arm64e_bind +{ + uint64_t ordinal : 16, + zero : 16, + addend : 19, // +/-256K + next : 11, // 4 or 8-byte stide + bind : 1, // == 1 + auth : 1; // == 0 +}; + +// DYLD_CHAINED_PTR_ARM64E +struct dyld_chained_ptr_arm64e_auth_rebase +{ + uint64_t target : 32, // runtimeOffset + diversity : 16, + addrDiv : 1, + key : 2, + next : 11, // 4 or 8-byte stide + bind : 1, // == 0 + auth : 1; // == 1 +}; + +// DYLD_CHAINED_PTR_ARM64E +struct dyld_chained_ptr_arm64e_auth_bind +{ + uint64_t ordinal : 16, + zero : 16, + diversity : 16, + addrDiv : 1, + key : 2, + next : 11, // 4 or 8-byte stide + bind : 1, // == 1 + auth : 1; // == 1 +}; + +// DYLD_CHAINED_PTR_64/DYLD_CHAINED_PTR_64_OFFSET +struct dyld_chained_ptr_64_rebase +{ + uint64_t target : 36, // 64GB max image size (DYLD_CHAINED_PTR_64 => vmAddr, DYLD_CHAINED_PTR_64_OFFSET => runtimeOffset) + high8 : 8, // top 8 bits set to this (DYLD_CHAINED_PTR_64 => after slide added, DYLD_CHAINED_PTR_64_OFFSET => before slide added) + reserved : 7, // all zeros + next : 12, // 4-byte stride + bind : 1; // == 0 +}; + +// DYLD_CHAINED_PTR_64 +struct dyld_chained_ptr_64_bind +{ + uint64_t ordinal : 24, + addend : 8, // 0 thru 255 + reserved : 19, // all zeros + next : 12, // 4-byte stride + bind : 1; // == 1 +}; + +// DYLD_CHAINED_PTR_64_KERNEL_CACHE, DYLD_CHAINED_PTR_X86_64_KERNEL_CACHE +struct dyld_chained_ptr_64_kernel_cache_rebase +{ + uint64_t target : 30, // basePointers[cacheLevel] + target + cacheLevel : 2, // what level of cache to bind to (indexes a mach_header array) + diversity : 16, + addrDiv : 1, + key : 2, + next : 12, // 1 or 4-byte stide + isAuth : 1; // 0 -> not authenticated. 1 -> authenticated +}; + +// DYLD_CHAINED_PTR_32 +// Note: for DYLD_CHAINED_PTR_32 some non-pointer values are co-opted into the chain +// as out of range rebases. If an entry in the chain is > max_valid_pointer, then it +// is not a pointer. To restore the value, subtract off the bias, which is +// (64MB+max_valid_pointer)/2. +struct dyld_chained_ptr_32_rebase +{ + uint32_t target : 26, // vmaddr, 64MB max image size + next : 5, // 4-byte stride + bind : 1; // == 0 +}; + +// DYLD_CHAINED_PTR_32 +struct dyld_chained_ptr_32_bind +{ + uint32_t ordinal : 20, + addend : 6, // 0 thru 63 + next : 5, // 4-byte stride + bind : 1; // == 1 +}; + +// DYLD_CHAINED_PTR_32_CACHE +struct dyld_chained_ptr_32_cache_rebase +{ + uint32_t target : 30, // 1GB max dyld cache TEXT and DATA + next : 2; // 4-byte stride +}; + + +// DYLD_CHAINED_PTR_32_FIRMWARE +struct dyld_chained_ptr_32_firmware_rebase +{ + uint32_t target : 26, // 64MB max firmware TEXT and DATA + next : 6; // 4-byte stride +}; + + + +// values for dyld_chained_fixups_header.imports_format +enum { + DYLD_CHAINED_IMPORT = 1, + DYLD_CHAINED_IMPORT_ADDEND = 2, + DYLD_CHAINED_IMPORT_ADDEND64 = 3, +}; + +// DYLD_CHAINED_IMPORT +struct dyld_chained_import +{ + uint32_t lib_ordinal : 8, + weak_import : 1, + name_offset : 23; +}; + +// DYLD_CHAINED_IMPORT_ADDEND +struct dyld_chained_import_addend +{ + uint32_t lib_ordinal : 8, + weak_import : 1, + name_offset : 23; + int32_t addend; +}; + +// DYLD_CHAINED_IMPORT_ADDEND64 +struct dyld_chained_import_addend64 +{ + uint64_t lib_ordinal : 16, + weak_import : 1, + reserved : 15, + name_offset : 32; + uint64_t addend; +}; + +#endif // __MACH_O_FIXUP_CHAINS__ diff --git a/I. Mach-O/mac/loader.h b/I. Mach-O/mac/loader.h new file mode 100644 index 0000000..ac7ff18 --- /dev/null +++ b/I. Mach-O/mac/loader.h @@ -0,0 +1,1593 @@ +// Extracted from Xcode 15 Beta 7 +/* /Library/Developer/CommandLineTools/SDKs/MacOSX14.0.sdk/System/Library/Frameworks/Kernel.framework/Versions/A/Headers/mach-o/loader.h */ + +/* + * Copyright (c) 1999-2019 Apple Inc. All Rights Reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +#ifndef _MACHO_LOADER_H_ +#define _MACHO_LOADER_H_ + +/* + * This file describes the format of mach object files. + */ +#include + +/* + * is needed here for the cpu_type_t and cpu_subtype_t types + * and contains the constants for the possible values of these types. + */ +#include + +/* + * is needed here for the vm_prot_t type and contains the + * constants that are or'ed together for the possible values of this type. + */ +#include + +/* + * is expected to define the flavors of the thread + * states and the structures of those flavors for each machine. + */ +#include +#include + +/* + * The 32-bit mach header appears at the very beginning of the object file for + * 32-bit architectures. + */ +struct mach_header { + uint32_t magic; /* mach magic number identifier */ + cpu_type_t cputype; /* cpu specifier */ + cpu_subtype_t cpusubtype; /* machine specifier */ + uint32_t filetype; /* type of file */ + uint32_t ncmds; /* number of load commands */ + uint32_t sizeofcmds; /* the size of all the load commands */ + uint32_t flags; /* flags */ +}; + +/* Constant for the magic field of the mach_header (32-bit architectures) */ +#define MH_MAGIC 0xfeedface /* the mach magic number */ +#define MH_CIGAM 0xcefaedfe /* NXSwapInt(MH_MAGIC) */ + +/* + * The 64-bit mach header appears at the very beginning of object files for + * 64-bit architectures. + */ +struct mach_header_64 { + uint32_t magic; /* mach magic number identifier */ + cpu_type_t cputype; /* cpu specifier */ + cpu_subtype_t cpusubtype; /* machine specifier */ + uint32_t filetype; /* type of file */ + uint32_t ncmds; /* number of load commands */ + uint32_t sizeofcmds; /* the size of all the load commands */ + uint32_t flags; /* flags */ + uint32_t reserved; /* reserved */ +}; + +/* Constant for the magic field of the mach_header_64 (64-bit architectures) */ +#define MH_MAGIC_64 0xfeedfacf /* the 64-bit mach magic number */ +#define MH_CIGAM_64 0xcffaedfe /* NXSwapInt(MH_MAGIC_64) */ + +/* + * The layout of the file depends on the filetype. For all but the MH_OBJECT + * file type the segments are padded out and aligned on a segment alignment + * boundary for efficient demand pageing. The MH_EXECUTE, MH_FVMLIB, MH_DYLIB, + * MH_DYLINKER and MH_BUNDLE file types also have the headers included as part + * of their first segment. + * + * The file type MH_OBJECT is a compact format intended as output of the + * assembler and input (and possibly output) of the link editor (the .o + * format). All sections are in one unnamed segment with no segment padding. + * This format is used as an executable format when the file is so small the + * segment padding greatly increases its size. + * + * The file type MH_PRELOAD is an executable format intended for things that + * are not executed under the kernel (proms, stand alones, kernels, etc). The + * format can be executed under the kernel but may demand paged it and not + * preload it before execution. + * + * A core file is in MH_CORE format and can be any in an arbritray legal + * Mach-O file. + * + * Constants for the filetype field of the mach_header + */ +#define MH_OBJECT 0x1 /* relocatable object file */ +#define MH_EXECUTE 0x2 /* demand paged executable file */ +#define MH_FVMLIB 0x3 /* fixed VM shared library file */ +#define MH_CORE 0x4 /* core file */ +#define MH_PRELOAD 0x5 /* preloaded executable file */ +#define MH_DYLIB 0x6 /* dynamically bound shared library */ +#define MH_DYLINKER 0x7 /* dynamic link editor */ +#define MH_BUNDLE 0x8 /* dynamically bound bundle file */ +#define MH_DYLIB_STUB 0x9 /* shared library stub for static */ + /* linking only, no section contents */ +#define MH_DSYM 0xa /* companion file with only debug */ + /* sections */ +#define MH_KEXT_BUNDLE 0xb /* x86_64 kexts */ +#define MH_FILESET 0xc /* set of mach-o's */ + +/* Constants for the flags field of the mach_header */ +#define MH_NOUNDEFS 0x1 /* the object file has no undefined + references */ +#define MH_INCRLINK 0x2 /* the object file is the output of an + incremental link against a base file + and can't be link edited again */ +#define MH_DYLDLINK 0x4 /* the object file is input for the + dynamic linker and can't be staticly + link edited again */ +#define MH_BINDATLOAD 0x8 /* the object file's undefined + references are bound by the dynamic + linker when loaded. */ +#define MH_PREBOUND 0x10 /* the file has its dynamic undefined + references prebound. */ +#define MH_SPLIT_SEGS 0x20 /* the file has its read-only and + read-write segments split */ +#define MH_LAZY_INIT 0x40 /* the shared library init routine is + to be run lazily via catching memory + faults to its writeable segments + (obsolete) */ +#define MH_TWOLEVEL 0x80 /* the image is using two-level name + space bindings */ +#define MH_FORCE_FLAT 0x100 /* the executable is forcing all images + to use flat name space bindings */ +#define MH_NOMULTIDEFS 0x200 /* this umbrella guarantees no multiple + defintions of symbols in its + sub-images so the two-level namespace + hints can always be used. */ +#define MH_NOFIXPREBINDING 0x400 /* do not have dyld notify the + prebinding agent about this + executable */ +#define MH_PREBINDABLE 0x800 /* the binary is not prebound but can + have its prebinding redone. only used + when MH_PREBOUND is not set. */ +#define MH_ALLMODSBOUND 0x1000 /* indicates that this binary binds to + all two-level namespace modules of + its dependent libraries. only used + when MH_PREBINDABLE and MH_TWOLEVEL + are both set. */ +#define MH_SUBSECTIONS_VIA_SYMBOLS 0x2000/* safe to divide up the sections into + sub-sections via symbols for dead + code stripping */ +#define MH_CANONICAL 0x4000 /* the binary has been canonicalized + via the unprebind operation */ +#define MH_WEAK_DEFINES 0x8000 /* the final linked image contains + external weak symbols */ +#define MH_BINDS_TO_WEAK 0x10000 /* the final linked image uses + weak symbols */ + +#define MH_ALLOW_STACK_EXECUTION 0x20000/* When this bit is set, all stacks + in the task will be given stack + execution privilege. Only used in + MH_EXECUTE filetypes. */ +#define MH_ROOT_SAFE 0x40000 /* When this bit is set, the binary + declares it is safe for use in + processes with uid zero */ + +#define MH_SETUID_SAFE 0x80000 /* When this bit is set, the binary + declares it is safe for use in + processes when issetugid() is true */ + +#define MH_NO_REEXPORTED_DYLIBS 0x100000 /* When this bit is set on a dylib, + the static linker does not need to + examine dependent dylibs to see + if any are re-exported */ +#define MH_PIE 0x200000 /* When this bit is set, the OS will + load the main executable at a + random address. Only used in + MH_EXECUTE filetypes. */ +#define MH_DEAD_STRIPPABLE_DYLIB 0x400000 /* Only for use on dylibs. When + linking against a dylib that + has this bit set, the static linker + will automatically not create a + LC_LOAD_DYLIB load command to the + dylib if no symbols are being + referenced from the dylib. */ +#define MH_HAS_TLV_DESCRIPTORS 0x800000 /* Contains a section of type + S_THREAD_LOCAL_VARIABLES */ + +#define MH_NO_HEAP_EXECUTION 0x1000000 /* When this bit is set, the OS will + run the main executable with + a non-executable heap even on + platforms (e.g. i386) that don't + require it. Only used in MH_EXECUTE + filetypes. */ + +#define MH_APP_EXTENSION_SAFE 0x02000000 /* The code was linked for use in an + application extension. */ + +#define MH_NLIST_OUTOFSYNC_WITH_DYLDINFO 0x04000000 /* The external symbols + listed in the nlist symbol table do + not include all the symbols listed in + the dyld info. */ + +#define MH_SIM_SUPPORT 0x08000000 /* Allow LC_MIN_VERSION_MACOS and + LC_BUILD_VERSION load commands with + the platforms macOS, iOSMac, + iOSSimulator, tvOSSimulator and + watchOSSimulator. */ + +#define MH_DYLIB_IN_CACHE 0x80000000 /* Only for use on dylibs. When this bit + is set, the dylib is part of the dyld + shared cache, rather than loose in + the filesystem. */ + +/* + * The load commands directly follow the mach_header. The total size of all + * of the commands is given by the sizeofcmds field in the mach_header. All + * load commands must have as their first two fields cmd and cmdsize. The cmd + * field is filled in with a constant for that command type. Each command type + * has a structure specifically for it. The cmdsize field is the size in bytes + * of the particular load command structure plus anything that follows it that + * is a part of the load command (i.e. section structures, strings, etc.). To + * advance to the next load command the cmdsize can be added to the offset or + * pointer of the current load command. The cmdsize for 32-bit architectures + * MUST be a multiple of 4 bytes and for 64-bit architectures MUST be a multiple + * of 8 bytes (these are forever the maximum alignment of any load commands). + * The padded bytes must be zero. All tables in the object file must also + * follow these rules so the file can be memory mapped. Otherwise the pointers + * to these tables will not work well or at all on some machines. With all + * padding zeroed like objects will compare byte for byte. + */ +struct load_command { + uint32_t cmd; /* type of load command */ + uint32_t cmdsize; /* total size of command in bytes */ +}; + +/* + * After MacOS X 10.1 when a new load command is added that is required to be + * understood by the dynamic linker for the image to execute properly the + * LC_REQ_DYLD bit will be or'ed into the load command constant. If the dynamic + * linker sees such a load command it it does not understand will issue a + * "unknown load command required for execution" error and refuse to use the + * image. Other load commands without this bit that are not understood will + * simply be ignored. + */ +#define LC_REQ_DYLD 0x80000000 + +/* Constants for the cmd field of all load commands, the type */ +#define LC_SEGMENT 0x1 /* segment of this file to be mapped */ +#define LC_SYMTAB 0x2 /* link-edit stab symbol table info */ +#define LC_SYMSEG 0x3 /* link-edit gdb symbol table info (obsolete) */ +#define LC_THREAD 0x4 /* thread */ +#define LC_UNIXTHREAD 0x5 /* unix thread (includes a stack) */ +#define LC_LOADFVMLIB 0x6 /* load a specified fixed VM shared library */ +#define LC_IDFVMLIB 0x7 /* fixed VM shared library identification */ +#define LC_IDENT 0x8 /* object identification info (obsolete) */ +#define LC_FVMFILE 0x9 /* fixed VM file inclusion (internal use) */ +#define LC_PREPAGE 0xa /* prepage command (internal use) */ +#define LC_DYSYMTAB 0xb /* dynamic link-edit symbol table info */ +#define LC_LOAD_DYLIB 0xc /* load a dynamically linked shared library */ +#define LC_ID_DYLIB 0xd /* dynamically linked shared lib ident */ +#define LC_LOAD_DYLINKER 0xe /* load a dynamic linker */ +#define LC_ID_DYLINKER 0xf /* dynamic linker identification */ +#define LC_PREBOUND_DYLIB 0x10 /* modules prebound for a dynamically */ + /* linked shared library */ +#define LC_ROUTINES 0x11 /* image routines */ +#define LC_SUB_FRAMEWORK 0x12 /* sub framework */ +#define LC_SUB_UMBRELLA 0x13 /* sub umbrella */ +#define LC_SUB_CLIENT 0x14 /* sub client */ +#define LC_SUB_LIBRARY 0x15 /* sub library */ +#define LC_TWOLEVEL_HINTS 0x16 /* two-level namespace lookup hints */ +#define LC_PREBIND_CKSUM 0x17 /* prebind checksum */ + +/* + * load a dynamically linked shared library that is allowed to be missing + * (all symbols are weak imported). + */ +#define LC_LOAD_WEAK_DYLIB (0x18 | LC_REQ_DYLD) + +#define LC_SEGMENT_64 0x19 /* 64-bit segment of this file to be + mapped */ +#define LC_ROUTINES_64 0x1a /* 64-bit image routines */ +#define LC_UUID 0x1b /* the uuid */ +#define LC_RPATH (0x1c | LC_REQ_DYLD) /* runpath additions */ +#define LC_CODE_SIGNATURE 0x1d /* local of code signature */ +#define LC_SEGMENT_SPLIT_INFO 0x1e /* local of info to split segments */ +#define LC_REEXPORT_DYLIB (0x1f | LC_REQ_DYLD) /* load and re-export dylib */ +#define LC_LAZY_LOAD_DYLIB 0x20 /* delay load of dylib until first use */ +#define LC_ENCRYPTION_INFO 0x21 /* encrypted segment information */ +#define LC_DYLD_INFO 0x22 /* compressed dyld information */ +#define LC_DYLD_INFO_ONLY (0x22|LC_REQ_DYLD) /* compressed dyld information only */ +#define LC_LOAD_UPWARD_DYLIB (0x23 | LC_REQ_DYLD) /* load upward dylib */ +#define LC_VERSION_MIN_MACOSX 0x24 /* build for MacOSX min OS version */ +#define LC_VERSION_MIN_IPHONEOS 0x25 /* build for iPhoneOS min OS version */ +#define LC_FUNCTION_STARTS 0x26 /* compressed table of function start addresses */ +#define LC_DYLD_ENVIRONMENT 0x27 /* string for dyld to treat + like environment variable */ +#define LC_MAIN (0x28|LC_REQ_DYLD) /* replacement for LC_UNIXTHREAD */ +#define LC_DATA_IN_CODE 0x29 /* table of non-instructions in __text */ +#define LC_SOURCE_VERSION 0x2A /* source version used to build binary */ +#define LC_DYLIB_CODE_SIGN_DRS 0x2B /* Code signing DRs copied from linked dylibs */ +#define LC_ENCRYPTION_INFO_64 0x2C /* 64-bit encrypted segment information */ +#define LC_LINKER_OPTION 0x2D /* linker options in MH_OBJECT files */ +#define LC_LINKER_OPTIMIZATION_HINT 0x2E /* optimization hints in MH_OBJECT files */ +#define LC_VERSION_MIN_TVOS 0x2F /* build for AppleTV min OS version */ +#define LC_VERSION_MIN_WATCHOS 0x30 /* build for Watch min OS version */ +#define LC_NOTE 0x31 /* arbitrary data included within a Mach-O file */ +#define LC_BUILD_VERSION 0x32 /* build for platform min OS version */ +#define LC_DYLD_EXPORTS_TRIE (0x33 | LC_REQ_DYLD) /* used with linkedit_data_command, payload is trie */ +#define LC_DYLD_CHAINED_FIXUPS (0x34 | LC_REQ_DYLD) /* used with linkedit_data_command */ +#define LC_FILESET_ENTRY (0x35 | LC_REQ_DYLD) /* used with fileset_entry_command */ + +/* + * A variable length string in a load command is represented by an lc_str + * union. The strings are stored just after the load command structure and + * the offset is from the start of the load command structure. The size + * of the string is reflected in the cmdsize field of the load command. + * Once again any padded bytes to bring the cmdsize field to a multiple + * of 4 bytes must be zero. + */ +union lc_str { + uint32_t offset; /* offset to the string */ +#ifndef __LP64__ + char *ptr; /* pointer to the string */ +#endif +}; + +/* + * The segment load command indicates that a part of this file is to be + * mapped into the task's address space. The size of this segment in memory, + * vmsize, maybe equal to or larger than the amount to map from this file, + * filesize. The file is mapped starting at fileoff to the beginning of + * the segment in memory, vmaddr. The rest of the memory of the segment, + * if any, is allocated zero fill on demand. The segment's maximum virtual + * memory protection and initial virtual memory protection are specified + * by the maxprot and initprot fields. If the segment has sections then the + * section structures directly follow the segment command and their size is + * reflected in cmdsize. + */ +struct segment_command { /* for 32-bit architectures */ + uint32_t cmd; /* LC_SEGMENT */ + uint32_t cmdsize; /* includes sizeof section structs */ + char segname[16]; /* segment name */ + uint32_t vmaddr; /* memory address of this segment */ + uint32_t vmsize; /* memory size of this segment */ + uint32_t fileoff; /* file offset of this segment */ + uint32_t filesize; /* amount to map from the file */ + vm_prot_t maxprot; /* maximum VM protection */ + vm_prot_t initprot; /* initial VM protection */ + uint32_t nsects; /* number of sections in segment */ + uint32_t flags; /* flags */ +}; + +/* + * The 64-bit segment load command indicates that a part of this file is to be + * mapped into a 64-bit task's address space. If the 64-bit segment has + * sections then section_64 structures directly follow the 64-bit segment + * command and their size is reflected in cmdsize. + */ +struct segment_command_64 { /* for 64-bit architectures */ + uint32_t cmd; /* LC_SEGMENT_64 */ + uint32_t cmdsize; /* includes sizeof section_64 structs */ + char segname[16]; /* segment name */ + uint64_t vmaddr; /* memory address of this segment */ + uint64_t vmsize; /* memory size of this segment */ + uint64_t fileoff; /* file offset of this segment */ + uint64_t filesize; /* amount to map from the file */ + vm_prot_t maxprot; /* maximum VM protection */ + vm_prot_t initprot; /* initial VM protection */ + uint32_t nsects; /* number of sections in segment */ + uint32_t flags; /* flags */ +}; + +/* Constants for the flags field of the segment_command */ +#define SG_HIGHVM 0x1 /* the file contents for this segment is for + the high part of the VM space, the low part + is zero filled (for stacks in core files) */ +#define SG_FVMLIB 0x2 /* this segment is the VM that is allocated by + a fixed VM library, for overlap checking in + the link editor */ +#define SG_NORELOC 0x4 /* this segment has nothing that was relocated + in it and nothing relocated to it, that is + it maybe safely replaced without relocation*/ +#define SG_PROTECTED_VERSION_1 0x8 /* This segment is protected. If the + segment starts at file offset 0, the + first page of the segment is not + protected. All other pages of the + segment are protected. */ +#define SG_READ_ONLY 0x10 /* This segment is made read-only after fixups */ + + + +/* + * A segment is made up of zero or more sections. Non-MH_OBJECT files have + * all of their segments with the proper sections in each, and padded to the + * specified segment alignment when produced by the link editor. The first + * segment of a MH_EXECUTE and MH_FVMLIB format file contains the mach_header + * and load commands of the object file before its first section. The zero + * fill sections are always last in their segment (in all formats). This + * allows the zeroed segment padding to be mapped into memory where zero fill + * sections might be. The gigabyte zero fill sections, those with the section + * type S_GB_ZEROFILL, can only be in a segment with sections of this type. + * These segments are then placed after all other segments. + * + * The MH_OBJECT format has all of its sections in one segment for + * compactness. There is no padding to a specified segment boundary and the + * mach_header and load commands are not part of the segment. + * + * Sections with the same section name, sectname, going into the same segment, + * segname, are combined by the link editor. The resulting section is aligned + * to the maximum alignment of the combined sections and is the new section's + * alignment. The combined sections are aligned to their original alignment in + * the combined section. Any padded bytes to get the specified alignment are + * zeroed. + * + * The format of the relocation entries referenced by the reloff and nreloc + * fields of the section structure for mach object files is described in the + * header file . + */ +struct section { /* for 32-bit architectures */ + char sectname[16]; /* name of this section */ + char segname[16]; /* segment this section goes in */ + uint32_t addr; /* memory address of this section */ + uint32_t size; /* size in bytes of this section */ + uint32_t offset; /* file offset of this section */ + uint32_t align; /* section alignment (power of 2) */ + uint32_t reloff; /* file offset of relocation entries */ + uint32_t nreloc; /* number of relocation entries */ + uint32_t flags; /* flags (section type and attributes)*/ + uint32_t reserved1; /* reserved (for offset or index) */ + uint32_t reserved2; /* reserved (for count or sizeof) */ +}; + +struct section_64 { /* for 64-bit architectures */ + char sectname[16]; /* name of this section */ + char segname[16]; /* segment this section goes in */ + uint64_t addr; /* memory address of this section */ + uint64_t size; /* size in bytes of this section */ + uint32_t offset; /* file offset of this section */ + uint32_t align; /* section alignment (power of 2) */ + uint32_t reloff; /* file offset of relocation entries */ + uint32_t nreloc; /* number of relocation entries */ + uint32_t flags; /* flags (section type and attributes)*/ + uint32_t reserved1; /* reserved (for offset or index) */ + uint32_t reserved2; /* reserved (for count or sizeof) */ + uint32_t reserved3; /* reserved */ +}; + +/* + * The flags field of a section structure is separated into two parts a section + * type and section attributes. The section types are mutually exclusive (it + * can only have one type) but the section attributes are not (it may have more + * than one attribute). + */ +#define SECTION_TYPE 0x000000ff /* 256 section types */ +#define SECTION_ATTRIBUTES 0xffffff00 /* 24 section attributes */ + +/* Constants for the type of a section */ +#define S_REGULAR 0x0 /* regular section */ +#define S_ZEROFILL 0x1 /* zero fill on demand section */ +#define S_CSTRING_LITERALS 0x2 /* section with only literal C strings*/ +#define S_4BYTE_LITERALS 0x3 /* section with only 4 byte literals */ +#define S_8BYTE_LITERALS 0x4 /* section with only 8 byte literals */ +#define S_LITERAL_POINTERS 0x5 /* section with only pointers to */ + /* literals */ +/* + * For the two types of symbol pointers sections and the symbol stubs section + * they have indirect symbol table entries. For each of the entries in the + * section the indirect symbol table entries, in corresponding order in the + * indirect symbol table, start at the index stored in the reserved1 field + * of the section structure. Since the indirect symbol table entries + * correspond to the entries in the section the number of indirect symbol table + * entries is inferred from the size of the section divided by the size of the + * entries in the section. For symbol pointers sections the size of the entries + * in the section is 4 bytes and for symbol stubs sections the byte size of the + * stubs is stored in the reserved2 field of the section structure. + */ +#define S_NON_LAZY_SYMBOL_POINTERS 0x6 /* section with only non-lazy + symbol pointers */ +#define S_LAZY_SYMBOL_POINTERS 0x7 /* section with only lazy symbol + pointers */ +#define S_SYMBOL_STUBS 0x8 /* section with only symbol + stubs, byte size of stub in + the reserved2 field */ +#define S_MOD_INIT_FUNC_POINTERS 0x9 /* section with only function + pointers for initialization*/ +#define S_MOD_TERM_FUNC_POINTERS 0xa /* section with only function + pointers for termination */ +#define S_COALESCED 0xb /* section contains symbols that + are to be coalesced */ +#define S_GB_ZEROFILL 0xc /* zero fill on demand section + (that can be larger than 4 + gigabytes) */ +#define S_INTERPOSING 0xd /* section with only pairs of + function pointers for + interposing */ +#define S_16BYTE_LITERALS 0xe /* section with only 16 byte + literals */ +#define S_DTRACE_DOF 0xf /* section contains + DTrace Object Format */ +#define S_LAZY_DYLIB_SYMBOL_POINTERS 0x10 /* section with only lazy + symbol pointers to lazy + loaded dylibs */ +/* + * Section types to support thread local variables + */ +#define S_THREAD_LOCAL_REGULAR 0x11 /* template of initial + values for TLVs */ +#define S_THREAD_LOCAL_ZEROFILL 0x12 /* template of initial + values for TLVs */ +#define S_THREAD_LOCAL_VARIABLES 0x13 /* TLV descriptors */ +#define S_THREAD_LOCAL_VARIABLE_POINTERS 0x14 /* pointers to TLV + descriptors */ +#define S_THREAD_LOCAL_INIT_FUNCTION_POINTERS 0x15 /* functions to call + to initialize TLV + values */ +#define S_INIT_FUNC_OFFSETS 0x16 /* 32-bit offsets to + initializers */ + +/* + * Constants for the section attributes part of the flags field of a section + * structure. + */ +#define SECTION_ATTRIBUTES_USR 0xff000000 /* User setable attributes */ +#define S_ATTR_PURE_INSTRUCTIONS 0x80000000 /* section contains only true + machine instructions */ +#define S_ATTR_NO_TOC 0x40000000 /* section contains coalesced + symbols that are not to be + in a ranlib table of + contents */ +#define S_ATTR_STRIP_STATIC_SYMS 0x20000000 /* ok to strip static symbols + in this section in files + with the MH_DYLDLINK flag */ +#define S_ATTR_NO_DEAD_STRIP 0x10000000 /* no dead stripping */ +#define S_ATTR_LIVE_SUPPORT 0x08000000 /* blocks are live if they + reference live blocks */ +#define S_ATTR_SELF_MODIFYING_CODE 0x04000000 /* Used with i386 code stubs + written on by dyld */ +/* + * If a segment contains any sections marked with S_ATTR_DEBUG then all + * sections in that segment must have this attribute. No section other than + * a section marked with this attribute may reference the contents of this + * section. A section with this attribute may contain no symbols and must have + * a section type S_REGULAR. The static linker will not copy section contents + * from sections with this attribute into its output file. These sections + * generally contain DWARF debugging info. + */ +#define S_ATTR_DEBUG 0x02000000 /* a debug section */ +#define SECTION_ATTRIBUTES_SYS 0x00ffff00 /* system setable attributes */ +#define S_ATTR_SOME_INSTRUCTIONS 0x00000400 /* section contains some + machine instructions */ +#define S_ATTR_EXT_RELOC 0x00000200 /* section has external + relocation entries */ +#define S_ATTR_LOC_RELOC 0x00000100 /* section has local + relocation entries */ + + +/* + * The names of segments and sections in them are mostly meaningless to the + * link-editor. But there are few things to support traditional UNIX + * executables that require the link-editor and assembler to use some names + * agreed upon by convention. + * + * The initial protection of the "__TEXT" segment has write protection turned + * off (not writeable). + * + * The link-editor will allocate common symbols at the end of the "__common" + * section in the "__DATA" segment. It will create the section and segment + * if needed. + */ + +/* The currently known segment names and the section names in those segments */ + +#define SEG_PAGEZERO "__PAGEZERO" /* the pagezero segment which has no */ + /* protections and catches NULL */ + /* references for MH_EXECUTE files */ + + +#define SEG_TEXT "__TEXT" /* the tradition UNIX text segment */ +#define SECT_TEXT "__text" /* the real text part of the text */ + /* section no headers, and no padding */ +#define SECT_FVMLIB_INIT0 "__fvmlib_init0" /* the fvmlib initialization */ + /* section */ +#define SECT_FVMLIB_INIT1 "__fvmlib_init1" /* the section following the */ + /* fvmlib initialization */ + /* section */ + +#define SEG_DATA "__DATA" /* the tradition UNIX data segment */ +#define SECT_DATA "__data" /* the real initialized data section */ + /* no padding, no bss overlap */ +#define SECT_BSS "__bss" /* the real uninitialized data section*/ + /* no padding */ +#define SECT_COMMON "__common" /* the section common symbols are */ + /* allocated in by the link editor */ + +#define SEG_OBJC "__OBJC" /* objective-C runtime segment */ +#define SECT_OBJC_SYMBOLS "__symbol_table" /* symbol table */ +#define SECT_OBJC_MODULES "__module_info" /* module information */ +#define SECT_OBJC_STRINGS "__selector_strs" /* string table */ +#define SECT_OBJC_REFS "__selector_refs" /* string table */ + +#define SEG_ICON "__ICON" /* the icon segment */ +#define SECT_ICON_HEADER "__header" /* the icon headers */ +#define SECT_ICON_TIFF "__tiff" /* the icons in tiff format */ + +#define SEG_LINKEDIT "__LINKEDIT" /* the segment containing all structs */ + /* created and maintained by the link */ + /* editor. Created with -seglinkedit */ + /* option to ld(1) for MH_EXECUTE and */ + /* FVMLIB file types only */ + +#define SEG_LINKINFO "__LINKINFO" /* the segment overlapping with linkedit */ + /* containing linking information */ + +#define SEG_UNIXSTACK "__UNIXSTACK" /* the unix stack segment */ + +#define SEG_IMPORT "__IMPORT" /* the segment for the self (dyld) */ + /* modifing code stubs that has read, */ + /* write and execute permissions */ + +/* + * Fixed virtual memory shared libraries are identified by two things. The + * target pathname (the name of the library as found for execution), and the + * minor version number. The address of where the headers are loaded is in + * header_addr. (THIS IS OBSOLETE and no longer supported). + */ +struct fvmlib { + union lc_str name; /* library's target pathname */ + uint32_t minor_version; /* library's minor version number */ + uint32_t header_addr; /* library's header address */ +}; + +/* + * A fixed virtual shared library (filetype == MH_FVMLIB in the mach header) + * contains a fvmlib_command (cmd == LC_IDFVMLIB) to identify the library. + * An object that uses a fixed virtual shared library also contains a + * fvmlib_command (cmd == LC_LOADFVMLIB) for each library it uses. + * (THIS IS OBSOLETE and no longer supported). + */ +struct fvmlib_command { + uint32_t cmd; /* LC_IDFVMLIB or LC_LOADFVMLIB */ + uint32_t cmdsize; /* includes pathname string */ + struct fvmlib fvmlib; /* the library identification */ +}; + +/* + * Dynamicly linked shared libraries are identified by two things. The + * pathname (the name of the library as found for execution), and the + * compatibility version number. The pathname must match and the compatibility + * number in the user of the library must be greater than or equal to the + * library being used. The time stamp is used to record the time a library was + * built and copied into user so it can be use to determined if the library used + * at runtime is exactly the same as used to built the program. + */ +struct dylib { + union lc_str name; /* library's path name */ + uint32_t timestamp; /* library's build time stamp */ + uint32_t current_version; /* library's current version number */ + uint32_t compatibility_version; /* library's compatibility vers number*/ +}; + +/* + * A dynamically linked shared library (filetype == MH_DYLIB in the mach header) + * contains a dylib_command (cmd == LC_ID_DYLIB) to identify the library. + * An object that uses a dynamically linked shared library also contains a + * dylib_command (cmd == LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, or + * LC_REEXPORT_DYLIB) for each library it uses. + */ +struct dylib_command { + uint32_t cmd; /* LC_ID_DYLIB, LC_LOAD_{,WEAK_}DYLIB, + LC_REEXPORT_DYLIB */ + uint32_t cmdsize; /* includes pathname string */ + struct dylib dylib; /* the library identification */ +}; + +/* + * A dynamically linked shared library may be a subframework of an umbrella + * framework. If so it will be linked with "-umbrella umbrella_name" where + * Where "umbrella_name" is the name of the umbrella framework. A subframework + * can only be linked against by its umbrella framework or other subframeworks + * that are part of the same umbrella framework. Otherwise the static link + * editor produces an error and states to link against the umbrella framework. + * The name of the umbrella framework for subframeworks is recorded in the + * following structure. + */ +struct sub_framework_command { + uint32_t cmd; /* LC_SUB_FRAMEWORK */ + uint32_t cmdsize; /* includes umbrella string */ + union lc_str umbrella; /* the umbrella framework name */ +}; + +/* + * For dynamically linked shared libraries that are subframework of an umbrella + * framework they can allow clients other than the umbrella framework or other + * subframeworks in the same umbrella framework. To do this the subframework + * is built with "-allowable_client client_name" and an LC_SUB_CLIENT load + * command is created for each -allowable_client flag. The client_name is + * usually a framework name. It can also be a name used for bundles clients + * where the bundle is built with "-client_name client_name". + */ +struct sub_client_command { + uint32_t cmd; /* LC_SUB_CLIENT */ + uint32_t cmdsize; /* includes client string */ + union lc_str client; /* the client name */ +}; + +/* + * A dynamically linked shared library may be a sub_umbrella of an umbrella + * framework. If so it will be linked with "-sub_umbrella umbrella_name" where + * Where "umbrella_name" is the name of the sub_umbrella framework. When + * staticly linking when -twolevel_namespace is in effect a twolevel namespace + * umbrella framework will only cause its subframeworks and those frameworks + * listed as sub_umbrella frameworks to be implicited linked in. Any other + * dependent dynamic libraries will not be linked it when -twolevel_namespace + * is in effect. The primary library recorded by the static linker when + * resolving a symbol in these libraries will be the umbrella framework. + * Zero or more sub_umbrella frameworks may be use by an umbrella framework. + * The name of a sub_umbrella framework is recorded in the following structure. + */ +struct sub_umbrella_command { + uint32_t cmd; /* LC_SUB_UMBRELLA */ + uint32_t cmdsize; /* includes sub_umbrella string */ + union lc_str sub_umbrella; /* the sub_umbrella framework name */ +}; + +/* + * A dynamically linked shared library may be a sub_library of another shared + * library. If so it will be linked with "-sub_library library_name" where + * Where "library_name" is the name of the sub_library shared library. When + * staticly linking when -twolevel_namespace is in effect a twolevel namespace + * shared library will only cause its subframeworks and those frameworks + * listed as sub_umbrella frameworks and libraries listed as sub_libraries to + * be implicited linked in. Any other dependent dynamic libraries will not be + * linked it when -twolevel_namespace is in effect. The primary library + * recorded by the static linker when resolving a symbol in these libraries + * will be the umbrella framework (or dynamic library). Zero or more sub_library + * shared libraries may be use by an umbrella framework or (or dynamic library). + * The name of a sub_library framework is recorded in the following structure. + * For example /usr/lib/libobjc_profile.A.dylib would be recorded as "libobjc". + */ +struct sub_library_command { + uint32_t cmd; /* LC_SUB_LIBRARY */ + uint32_t cmdsize; /* includes sub_library string */ + union lc_str sub_library; /* the sub_library name */ +}; + +/* + * A program (filetype == MH_EXECUTE) that is + * prebound to its dynamic libraries has one of these for each library that + * the static linker used in prebinding. It contains a bit vector for the + * modules in the library. The bits indicate which modules are bound (1) and + * which are not (0) from the library. The bit for module 0 is the low bit + * of the first byte. So the bit for the Nth module is: + * (linked_modules[N/8] >> N%8) & 1 + */ +struct prebound_dylib_command { + uint32_t cmd; /* LC_PREBOUND_DYLIB */ + uint32_t cmdsize; /* includes strings */ + union lc_str name; /* library's path name */ + uint32_t nmodules; /* number of modules in library */ + union lc_str linked_modules; /* bit vector of linked modules */ +}; + +/* + * A program that uses a dynamic linker contains a dylinker_command to identify + * the name of the dynamic linker (LC_LOAD_DYLINKER). And a dynamic linker + * contains a dylinker_command to identify the dynamic linker (LC_ID_DYLINKER). + * A file can have at most one of these. + * This struct is also used for the LC_DYLD_ENVIRONMENT load command and + * contains string for dyld to treat like environment variable. + */ +struct dylinker_command { + uint32_t cmd; /* LC_ID_DYLINKER, LC_LOAD_DYLINKER or + LC_DYLD_ENVIRONMENT */ + uint32_t cmdsize; /* includes pathname string */ + union lc_str name; /* dynamic linker's path name */ +}; + +/* + * Thread commands contain machine-specific data structures suitable for + * use in the thread state primitives. The machine specific data structures + * follow the struct thread_command as follows. + * Each flavor of machine specific data structure is preceded by an uint32_t + * constant for the flavor of that data structure, an uint32_t that is the + * count of uint32_t's of the size of the state data structure and then + * the state data structure follows. This triple may be repeated for many + * flavors. The constants for the flavors, counts and state data structure + * definitions are expected to be in the header file . + * These machine specific data structures sizes must be multiples of + * 4 bytes. The cmdsize reflects the total size of the thread_command + * and all of the sizes of the constants for the flavors, counts and state + * data structures. + * + * For executable objects that are unix processes there will be one + * thread_command (cmd == LC_UNIXTHREAD) created for it by the link-editor. + * This is the same as a LC_THREAD, except that a stack is automatically + * created (based on the shell's limit for the stack size). Command arguments + * and environment variables are copied onto that stack. + */ +struct thread_command { + uint32_t cmd; /* LC_THREAD or LC_UNIXTHREAD */ + uint32_t cmdsize; /* total size of this command */ + /* uint32_t flavor flavor of thread state */ + /* uint32_t count count of uint32_t's in thread state */ + /* struct XXX_thread_state state thread state for this flavor */ + /* ... */ +}; + +/* + * The routines command contains the address of the dynamic shared library + * initialization routine and an index into the module table for the module + * that defines the routine. Before any modules are used from the library the + * dynamic linker fully binds the module that defines the initialization routine + * and then calls it. This gets called before any module initialization + * routines (used for C++ static constructors) in the library. + */ +struct routines_command { /* for 32-bit architectures */ + uint32_t cmd; /* LC_ROUTINES */ + uint32_t cmdsize; /* total size of this command */ + uint32_t init_address; /* address of initialization routine */ + uint32_t init_module; /* index into the module table that */ + /* the init routine is defined in */ + uint32_t reserved1; + uint32_t reserved2; + uint32_t reserved3; + uint32_t reserved4; + uint32_t reserved5; + uint32_t reserved6; +}; + +/* + * The 64-bit routines command. Same use as above. + */ +struct routines_command_64 { /* for 64-bit architectures */ + uint32_t cmd; /* LC_ROUTINES_64 */ + uint32_t cmdsize; /* total size of this command */ + uint64_t init_address; /* address of initialization routine */ + uint64_t init_module; /* index into the module table that */ + /* the init routine is defined in */ + uint64_t reserved1; + uint64_t reserved2; + uint64_t reserved3; + uint64_t reserved4; + uint64_t reserved5; + uint64_t reserved6; +}; + +/* + * The symtab_command contains the offsets and sizes of the link-edit 4.3BSD + * "stab" style symbol table information as described in the header files + * and . + */ +struct symtab_command { + uint32_t cmd; /* LC_SYMTAB */ + uint32_t cmdsize; /* sizeof(struct symtab_command) */ + uint32_t symoff; /* symbol table offset */ + uint32_t nsyms; /* number of symbol table entries */ + uint32_t stroff; /* string table offset */ + uint32_t strsize; /* string table size in bytes */ +}; + +/* + * This is the second set of the symbolic information which is used to support + * the data structures for the dynamically link editor. + * + * The original set of symbolic information in the symtab_command which contains + * the symbol and string tables must also be present when this load command is + * present. When this load command is present the symbol table is organized + * into three groups of symbols: + * local symbols (static and debugging symbols) - grouped by module + * defined external symbols - grouped by module (sorted by name if not lib) + * undefined external symbols (sorted by name if MH_BINDATLOAD is not set, + * and in order the were seen by the static + * linker if MH_BINDATLOAD is set) + * In this load command there are offsets and counts to each of the three groups + * of symbols. + * + * This load command contains a the offsets and sizes of the following new + * symbolic information tables: + * table of contents + * module table + * reference symbol table + * indirect symbol table + * The first three tables above (the table of contents, module table and + * reference symbol table) are only present if the file is a dynamically linked + * shared library. For executable and object modules, which are files + * containing only one module, the information that would be in these three + * tables is determined as follows: + * table of contents - the defined external symbols are sorted by name + * module table - the file contains only one module so everything in the + * file is part of the module. + * reference symbol table - is the defined and undefined external symbols + * + * For dynamically linked shared library files this load command also contains + * offsets and sizes to the pool of relocation entries for all sections + * separated into two groups: + * external relocation entries + * local relocation entries + * For executable and object modules the relocation entries continue to hang + * off the section structures. + */ +struct dysymtab_command { + uint32_t cmd; /* LC_DYSYMTAB */ + uint32_t cmdsize; /* sizeof(struct dysymtab_command) */ + + /* + * The symbols indicated by symoff and nsyms of the LC_SYMTAB load command + * are grouped into the following three groups: + * local symbols (further grouped by the module they are from) + * defined external symbols (further grouped by the module they are from) + * undefined symbols + * + * The local symbols are used only for debugging. The dynamic binding + * process may have to use them to indicate to the debugger the local + * symbols for a module that is being bound. + * + * The last two groups are used by the dynamic binding process to do the + * binding (indirectly through the module table and the reference symbol + * table when this is a dynamically linked shared library file). + */ + uint32_t ilocalsym; /* index to local symbols */ + uint32_t nlocalsym; /* number of local symbols */ + + uint32_t iextdefsym;/* index to externally defined symbols */ + uint32_t nextdefsym;/* number of externally defined symbols */ + + uint32_t iundefsym; /* index to undefined symbols */ + uint32_t nundefsym; /* number of undefined symbols */ + + /* + * For the for the dynamic binding process to find which module a symbol + * is defined in the table of contents is used (analogous to the ranlib + * structure in an archive) which maps defined external symbols to modules + * they are defined in. This exists only in a dynamically linked shared + * library file. For executable and object modules the defined external + * symbols are sorted by name and is use as the table of contents. + */ + uint32_t tocoff; /* file offset to table of contents */ + uint32_t ntoc; /* number of entries in table of contents */ + + /* + * To support dynamic binding of "modules" (whole object files) the symbol + * table must reflect the modules that the file was created from. This is + * done by having a module table that has indexes and counts into the merged + * tables for each module. The module structure that these two entries + * refer to is described below. This exists only in a dynamically linked + * shared library file. For executable and object modules the file only + * contains one module so everything in the file belongs to the module. + */ + uint32_t modtaboff; /* file offset to module table */ + uint32_t nmodtab; /* number of module table entries */ + + /* + * To support dynamic module binding the module structure for each module + * indicates the external references (defined and undefined) each module + * makes. For each module there is an offset and a count into the + * reference symbol table for the symbols that the module references. + * This exists only in a dynamically linked shared library file. For + * executable and object modules the defined external symbols and the + * undefined external symbols indicates the external references. + */ + uint32_t extrefsymoff; /* offset to referenced symbol table */ + uint32_t nextrefsyms; /* number of referenced symbol table entries */ + + /* + * The sections that contain "symbol pointers" and "routine stubs" have + * indexes and (implied counts based on the size of the section and fixed + * size of the entry) into the "indirect symbol" table for each pointer + * and stub. For every section of these two types the index into the + * indirect symbol table is stored in the section header in the field + * reserved1. An indirect symbol table entry is simply a 32bit index into + * the symbol table to the symbol that the pointer or stub is referring to. + * The indirect symbol table is ordered to match the entries in the section. + */ + uint32_t indirectsymoff; /* file offset to the indirect symbol table */ + uint32_t nindirectsyms; /* number of indirect symbol table entries */ + + /* + * To support relocating an individual module in a library file quickly the + * external relocation entries for each module in the library need to be + * accessed efficiently. Since the relocation entries can't be accessed + * through the section headers for a library file they are separated into + * groups of local and external entries further grouped by module. In this + * case the presents of this load command who's extreloff, nextrel, + * locreloff and nlocrel fields are non-zero indicates that the relocation + * entries of non-merged sections are not referenced through the section + * structures (and the reloff and nreloc fields in the section headers are + * set to zero). + * + * Since the relocation entries are not accessed through the section headers + * this requires the r_address field to be something other than a section + * offset to identify the item to be relocated. In this case r_address is + * set to the offset from the vmaddr of the first LC_SEGMENT command. + * For MH_SPLIT_SEGS images r_address is set to the the offset from the + * vmaddr of the first read-write LC_SEGMENT command. + * + * The relocation entries are grouped by module and the module table + * entries have indexes and counts into them for the group of external + * relocation entries for that the module. + * + * For sections that are merged across modules there must not be any + * remaining external relocation entries for them (for merged sections + * remaining relocation entries must be local). + */ + uint32_t extreloff; /* offset to external relocation entries */ + uint32_t nextrel; /* number of external relocation entries */ + + /* + * All the local relocation entries are grouped together (they are not + * grouped by their module since they are only used if the object is moved + * from it staticly link edited address). + */ + uint32_t locreloff; /* offset to local relocation entries */ + uint32_t nlocrel; /* number of local relocation entries */ + +}; + +/* + * An indirect symbol table entry is simply a 32bit index into the symbol table + * to the symbol that the pointer or stub is refering to. Unless it is for a + * non-lazy symbol pointer section for a defined symbol which strip(1) as + * removed. In which case it has the value INDIRECT_SYMBOL_LOCAL. If the + * symbol was also absolute INDIRECT_SYMBOL_ABS is or'ed with that. + */ +#define INDIRECT_SYMBOL_LOCAL 0x80000000 +#define INDIRECT_SYMBOL_ABS 0x40000000 + + +/* a table of contents entry */ +struct dylib_table_of_contents { + uint32_t symbol_index; /* the defined external symbol + (index into the symbol table) */ + uint32_t module_index; /* index into the module table this symbol + is defined in */ +}; + +/* a module table entry */ +struct dylib_module { + uint32_t module_name; /* the module name (index into string table) */ + + uint32_t iextdefsym; /* index into externally defined symbols */ + uint32_t nextdefsym; /* number of externally defined symbols */ + uint32_t irefsym; /* index into reference symbol table */ + uint32_t nrefsym; /* number of reference symbol table entries */ + uint32_t ilocalsym; /* index into symbols for local symbols */ + uint32_t nlocalsym; /* number of local symbols */ + + uint32_t iextrel; /* index into external relocation entries */ + uint32_t nextrel; /* number of external relocation entries */ + + uint32_t iinit_iterm; /* low 16 bits are the index into the init + section, high 16 bits are the index into + the term section */ + uint32_t ninit_nterm; /* low 16 bits are the number of init section + entries, high 16 bits are the number of + term section entries */ + + uint32_t /* for this module address of the start of */ + objc_module_info_addr; /* the (__OBJC,__module_info) section */ + uint32_t /* for this module size of */ + objc_module_info_size; /* the (__OBJC,__module_info) section */ +}; + +/* a 64-bit module table entry */ +struct dylib_module_64 { + uint32_t module_name; /* the module name (index into string table) */ + + uint32_t iextdefsym; /* index into externally defined symbols */ + uint32_t nextdefsym; /* number of externally defined symbols */ + uint32_t irefsym; /* index into reference symbol table */ + uint32_t nrefsym; /* number of reference symbol table entries */ + uint32_t ilocalsym; /* index into symbols for local symbols */ + uint32_t nlocalsym; /* number of local symbols */ + + uint32_t iextrel; /* index into external relocation entries */ + uint32_t nextrel; /* number of external relocation entries */ + + uint32_t iinit_iterm; /* low 16 bits are the index into the init + section, high 16 bits are the index into + the term section */ + uint32_t ninit_nterm; /* low 16 bits are the number of init section + entries, high 16 bits are the number of + term section entries */ + + uint32_t /* for this module size of */ + objc_module_info_size; /* the (__OBJC,__module_info) section */ + uint64_t /* for this module address of the start of */ + objc_module_info_addr; /* the (__OBJC,__module_info) section */ +}; + +/* + * The entries in the reference symbol table are used when loading the module + * (both by the static and dynamic link editors) and if the module is unloaded + * or replaced. Therefore all external symbols (defined and undefined) are + * listed in the module's reference table. The flags describe the type of + * reference that is being made. The constants for the flags are defined in + * as they are also used for symbol table entries. + */ +struct dylib_reference { + uint32_t isym:24, /* index into the symbol table */ + flags:8; /* flags to indicate the type of reference */ +}; + +/* + * The twolevel_hints_command contains the offset and number of hints in the + * two-level namespace lookup hints table. + */ +struct twolevel_hints_command { + uint32_t cmd; /* LC_TWOLEVEL_HINTS */ + uint32_t cmdsize; /* sizeof(struct twolevel_hints_command) */ + uint32_t offset; /* offset to the hint table */ + uint32_t nhints; /* number of hints in the hint table */ +}; + +/* + * The entries in the two-level namespace lookup hints table are twolevel_hint + * structs. These provide hints to the dynamic link editor where to start + * looking for an undefined symbol in a two-level namespace image. The + * isub_image field is an index into the sub-images (sub-frameworks and + * sub-umbrellas list) that made up the two-level image that the undefined + * symbol was found in when it was built by the static link editor. If + * isub-image is 0 the the symbol is expected to be defined in library and not + * in the sub-images. If isub-image is non-zero it is an index into the array + * of sub-images for the umbrella with the first index in the sub-images being + * 1. The array of sub-images is the ordered list of sub-images of the umbrella + * that would be searched for a symbol that has the umbrella recorded as its + * primary library. The table of contents index is an index into the + * library's table of contents. This is used as the starting point of the + * binary search or a directed linear search. + */ +struct twolevel_hint { + uint32_t + isub_image:8, /* index into the sub images */ + itoc:24; /* index into the table of contents */ +}; + +/* + * The prebind_cksum_command contains the value of the original check sum for + * prebound files or zero. When a prebound file is first created or modified + * for other than updating its prebinding information the value of the check sum + * is set to zero. When the file has it prebinding re-done and if the value of + * the check sum is zero the original check sum is calculated and stored in + * cksum field of this load command in the output file. If when the prebinding + * is re-done and the cksum field is non-zero it is left unchanged from the + * input file. + */ +struct prebind_cksum_command { + uint32_t cmd; /* LC_PREBIND_CKSUM */ + uint32_t cmdsize; /* sizeof(struct prebind_cksum_command) */ + uint32_t cksum; /* the check sum or zero */ +}; + +/* + * The uuid load command contains a single 128-bit unique random number that + * identifies an object produced by the static link editor. + */ +struct uuid_command { + uint32_t cmd; /* LC_UUID */ + uint32_t cmdsize; /* sizeof(struct uuid_command) */ + uint8_t uuid[16]; /* the 128-bit uuid */ +}; + +/* + * The rpath_command contains a path which at runtime should be added to + * the current run path used to find @rpath prefixed dylibs. + */ +struct rpath_command { + uint32_t cmd; /* LC_RPATH */ + uint32_t cmdsize; /* includes string */ + union lc_str path; /* path to add to run path */ +}; + +/* + * The linkedit_data_command contains the offsets and sizes of a blob + * of data in the __LINKEDIT segment. + */ +struct linkedit_data_command { + uint32_t cmd; /* LC_CODE_SIGNATURE, LC_SEGMENT_SPLIT_INFO, + LC_FUNCTION_STARTS, LC_DATA_IN_CODE, + LC_DYLIB_CODE_SIGN_DRS, + LC_LINKER_OPTIMIZATION_HINT, + LC_DYLD_EXPORTS_TRIE, or + LC_DYLD_CHAINED_FIXUPS. */ + uint32_t cmdsize; /* sizeof(struct linkedit_data_command) */ + uint32_t dataoff; /* file offset of data in __LINKEDIT segment */ + uint32_t datasize; /* file size of data in __LINKEDIT segment */ +}; + +struct fileset_entry_command { + uint32_t cmd; /* LC_FILESET_ENTRY */ + uint32_t cmdsize; /* includes id string */ + uint64_t vmaddr; /* memory address of the dylib */ + uint64_t fileoff; /* file offset of the dylib */ + union lc_str entry_id; /* contained entry id */ + uint32_t reserved; /* entry_id is 32-bits long, so this is the reserved padding */ +}; + +/* + * The encryption_info_command contains the file offset and size of an + * of an encrypted segment. + */ +struct encryption_info_command { + uint32_t cmd; /* LC_ENCRYPTION_INFO */ + uint32_t cmdsize; /* sizeof(struct encryption_info_command) */ + uint32_t cryptoff; /* file offset of encrypted range */ + uint32_t cryptsize; /* file size of encrypted range */ + uint32_t cryptid; /* which enryption system, + 0 means not-encrypted yet */ +}; + +/* + * The encryption_info_command_64 contains the file offset and size of an + * of an encrypted segment (for use in x86_64 targets). + */ +struct encryption_info_command_64 { + uint32_t cmd; /* LC_ENCRYPTION_INFO_64 */ + uint32_t cmdsize; /* sizeof(struct encryption_info_command_64) */ + uint32_t cryptoff; /* file offset of encrypted range */ + uint32_t cryptsize; /* file size of encrypted range */ + uint32_t cryptid; /* which enryption system, + 0 means not-encrypted yet */ + uint32_t pad; /* padding to make this struct's size a multiple + of 8 bytes */ +}; + +/* + * The version_min_command contains the min OS version on which this + * binary was built to run. + */ +struct version_min_command { + uint32_t cmd; /* LC_VERSION_MIN_MACOSX or + LC_VERSION_MIN_IPHONEOS or + LC_VERSION_MIN_WATCHOS or + LC_VERSION_MIN_TVOS */ + uint32_t cmdsize; /* sizeof(struct min_version_command) */ + uint32_t version; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ + uint32_t sdk; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ +}; + +/* + * The build_version_command contains the min OS version on which this + * binary was built to run for its platform. The list of known platforms and + * tool values following it. + */ +struct build_version_command { + uint32_t cmd; /* LC_BUILD_VERSION */ + uint32_t cmdsize; /* sizeof(struct build_version_command) plus */ + /* ntools * sizeof(struct build_tool_version) */ + uint32_t platform; /* platform */ + uint32_t minos; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ + uint32_t sdk; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ + uint32_t ntools; /* number of tool entries following this */ +}; + +struct build_tool_version { + uint32_t tool; /* enum for the tool */ + uint32_t version; /* version number of the tool */ +}; + +/* Known values for the platform field above. */ +#define PLATFORM_MACOS 1 +#define PLATFORM_IOS 2 +#define PLATFORM_TVOS 3 +#define PLATFORM_WATCHOS 4 +#define PLATFORM_BRIDGEOS 5 +#define PLATFORM_MACCATALYST 6 +#define PLATFORM_IOSSIMULATOR 7 +#define PLATFORM_TVOSSIMULATOR 8 +#define PLATFORM_WATCHOSSIMULATOR 9 +#define PLATFORM_DRIVERKIT 10 +#define PLATFORM_MAX PLATFORM_DRIVERKIT +/* Addition of simulated platfrom also needs to update proc_is_simulated() */ + +/* Known values for the tool field above. */ +#define TOOL_CLANG 1 +#define TOOL_SWIFT 2 +#define TOOL_LD 3 + +/* + * The dyld_info_command contains the file offsets and sizes of + * the new compressed form of the information dyld needs to + * load the image. This information is used by dyld on Mac OS X + * 10.6 and later. All information pointed to by this command + * is encoded using byte streams, so no endian swapping is needed + * to interpret it. + */ +struct dyld_info_command { + uint32_t cmd; /* LC_DYLD_INFO or LC_DYLD_INFO_ONLY */ + uint32_t cmdsize; /* sizeof(struct dyld_info_command) */ + + /* + * Dyld rebases an image whenever dyld loads it at an address different + * from its preferred address. The rebase information is a stream + * of byte sized opcodes whose symbolic names start with REBASE_OPCODE_. + * Conceptually the rebase information is a table of tuples: + * + * The opcodes are a compressed way to encode the table by only + * encoding when a column changes. In addition simple patterns + * like "every n'th offset for m times" can be encoded in a few + * bytes. + */ + uint32_t rebase_off; /* file offset to rebase info */ + uint32_t rebase_size; /* size of rebase info */ + + /* + * Dyld binds an image during the loading process, if the image + * requires any pointers to be initialized to symbols in other images. + * The bind information is a stream of byte sized + * opcodes whose symbolic names start with BIND_OPCODE_. + * Conceptually the bind information is a table of tuples: + * + * The opcodes are a compressed way to encode the table by only + * encoding when a column changes. In addition simple patterns + * like for runs of pointers initialzed to the same value can be + * encoded in a few bytes. + */ + uint32_t bind_off; /* file offset to binding info */ + uint32_t bind_size; /* size of binding info */ + + /* + * Some C++ programs require dyld to unique symbols so that all + * images in the process use the same copy of some code/data. + * This step is done after binding. The content of the weak_bind + * info is an opcode stream like the bind_info. But it is sorted + * alphabetically by symbol name. This enable dyld to walk + * all images with weak binding information in order and look + * for collisions. If there are no collisions, dyld does + * no updating. That means that some fixups are also encoded + * in the bind_info. For instance, all calls to "operator new" + * are first bound to libstdc++.dylib using the information + * in bind_info. Then if some image overrides operator new + * that is detected when the weak_bind information is processed + * and the call to operator new is then rebound. + */ + uint32_t weak_bind_off; /* file offset to weak binding info */ + uint32_t weak_bind_size; /* size of weak binding info */ + + /* + * Some uses of external symbols do not need to be bound immediately. + * Instead they can be lazily bound on first use. The lazy_bind + * are contains a stream of BIND opcodes to bind all lazy symbols. + * Normal use is that dyld ignores the lazy_bind section when + * loading an image. Instead the static linker arranged for the + * lazy pointer to initially point to a helper function which + * pushes the offset into the lazy_bind area for the symbol + * needing to be bound, then jumps to dyld which simply adds + * the offset to lazy_bind_off to get the information on what + * to bind. + */ + uint32_t lazy_bind_off; /* file offset to lazy binding info */ + uint32_t lazy_bind_size; /* size of lazy binding infs */ + + /* + * The symbols exported by a dylib are encoded in a trie. This + * is a compact representation that factors out common prefixes. + * It also reduces LINKEDIT pages in RAM because it encodes all + * information (name, address, flags) in one small, contiguous range. + * The export area is a stream of nodes. The first node sequentially + * is the start node for the trie. + * + * Nodes for a symbol start with a uleb128 that is the length of + * the exported symbol information for the string so far. + * If there is no exported symbol, the node starts with a zero byte. + * If there is exported info, it follows the length. + * + * First is a uleb128 containing flags. Normally, it is followed by + * a uleb128 encoded offset which is location of the content named + * by the symbol from the mach_header for the image. If the flags + * is EXPORT_SYMBOL_FLAGS_REEXPORT, then following the flags is + * a uleb128 encoded library ordinal, then a zero terminated + * UTF8 string. If the string is zero length, then the symbol + * is re-export from the specified dylib with the same name. + * If the flags is EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER, then following + * the flags is two uleb128s: the stub offset and the resolver offset. + * The stub is used by non-lazy pointers. The resolver is used + * by lazy pointers and must be called to get the actual address to use. + * + * After the optional exported symbol information is a byte of + * how many edges (0-255) that this node has leaving it, + * followed by each edge. + * Each edge is a zero terminated UTF8 of the addition chars + * in the symbol, followed by a uleb128 offset for the node that + * edge points to. + * + */ + uint32_t export_off; /* file offset to lazy binding info */ + uint32_t export_size; /* size of lazy binding infs */ +}; + +/* + * The following are used to encode rebasing information + */ +#define REBASE_TYPE_POINTER 1 +#define REBASE_TYPE_TEXT_ABSOLUTE32 2 +#define REBASE_TYPE_TEXT_PCREL32 3 + +#define REBASE_OPCODE_MASK 0xF0 +#define REBASE_IMMEDIATE_MASK 0x0F +#define REBASE_OPCODE_DONE 0x00 +#define REBASE_OPCODE_SET_TYPE_IMM 0x10 +#define REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB 0x20 +#define REBASE_OPCODE_ADD_ADDR_ULEB 0x30 +#define REBASE_OPCODE_ADD_ADDR_IMM_SCALED 0x40 +#define REBASE_OPCODE_DO_REBASE_IMM_TIMES 0x50 +#define REBASE_OPCODE_DO_REBASE_ULEB_TIMES 0x60 +#define REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB 0x70 +#define REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB 0x80 + + +/* + * The following are used to encode binding information + */ +#define BIND_TYPE_POINTER 1 +#define BIND_TYPE_TEXT_ABSOLUTE32 2 +#define BIND_TYPE_TEXT_PCREL32 3 + +#define BIND_SPECIAL_DYLIB_SELF 0 +#define BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE -1 +#define BIND_SPECIAL_DYLIB_FLAT_LOOKUP -2 +#define BIND_SPECIAL_DYLIB_WEAK_LOOKUP -3 + +#define BIND_SYMBOL_FLAGS_WEAK_IMPORT 0x1 +#define BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION 0x8 + +#define BIND_OPCODE_MASK 0xF0 +#define BIND_IMMEDIATE_MASK 0x0F +#define BIND_OPCODE_DONE 0x00 +#define BIND_OPCODE_SET_DYLIB_ORDINAL_IMM 0x10 +#define BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB 0x20 +#define BIND_OPCODE_SET_DYLIB_SPECIAL_IMM 0x30 +#define BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM 0x40 +#define BIND_OPCODE_SET_TYPE_IMM 0x50 +#define BIND_OPCODE_SET_ADDEND_SLEB 0x60 +#define BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB 0x70 +#define BIND_OPCODE_ADD_ADDR_ULEB 0x80 +#define BIND_OPCODE_DO_BIND 0x90 +#define BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB 0xA0 +#define BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED 0xB0 +#define BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB 0xC0 +#define BIND_OPCODE_THREADED 0xD0 +#define BIND_SUBOPCODE_THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB 0x00 +#define BIND_SUBOPCODE_THREADED_APPLY 0x01 + + +/* + * The following are used on the flags byte of a terminal node + * in the export information. + */ +#define EXPORT_SYMBOL_FLAGS_KIND_MASK 0x03 +#define EXPORT_SYMBOL_FLAGS_KIND_REGULAR 0x00 +#define EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL 0x01 +#define EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE 0x02 +#define EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION 0x04 +#define EXPORT_SYMBOL_FLAGS_REEXPORT 0x08 +#define EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER 0x10 + +/* + * The linker_option_command contains linker options embedded in object files. + */ +struct linker_option_command { + uint32_t cmd; /* LC_LINKER_OPTION only used in MH_OBJECT filetypes */ + uint32_t cmdsize; + uint32_t count; /* number of strings */ + /* concatenation of zero terminated UTF8 strings. + Zero filled at end to align */ +}; + +/* + * The symseg_command contains the offset and size of the GNU style + * symbol table information as described in the header file . + * The symbol roots of the symbol segments must also be aligned properly + * in the file. So the requirement of keeping the offsets aligned to a + * multiple of a 4 bytes translates to the length field of the symbol + * roots also being a multiple of a long. Also the padding must again be + * zeroed. (THIS IS OBSOLETE and no longer supported). + */ +struct symseg_command { + uint32_t cmd; /* LC_SYMSEG */ + uint32_t cmdsize; /* sizeof(struct symseg_command) */ + uint32_t offset; /* symbol segment offset */ + uint32_t size; /* symbol segment size in bytes */ +}; + +/* + * The ident_command contains a free format string table following the + * ident_command structure. The strings are null terminated and the size of + * the command is padded out with zero bytes to a multiple of 4 bytes/ + * (THIS IS OBSOLETE and no longer supported). + */ +struct ident_command { + uint32_t cmd; /* LC_IDENT */ + uint32_t cmdsize; /* strings that follow this command */ +}; + +/* + * The fvmfile_command contains a reference to a file to be loaded at the + * specified virtual address. (Presently, this command is reserved for + * internal use. The kernel ignores this command when loading a program into + * memory). + */ +struct fvmfile_command { + uint32_t cmd; /* LC_FVMFILE */ + uint32_t cmdsize; /* includes pathname string */ + union lc_str name; /* files pathname */ + uint32_t header_addr; /* files virtual address */ +}; + + +/* + * The entry_point_command is a replacement for thread_command. + * It is used for main executables to specify the location (file offset) + * of main(). If -stack_size was used at link time, the stacksize + * field will contain the stack size need for the main thread. + */ +struct entry_point_command { + uint32_t cmd; /* LC_MAIN only used in MH_EXECUTE filetypes */ + uint32_t cmdsize; /* 24 */ + uint64_t entryoff; /* file (__TEXT) offset of main() */ + uint64_t stacksize;/* if not zero, initial stack size */ +}; + + +/* + * The source_version_command is an optional load command containing + * the version of the sources used to build the binary. + */ +struct source_version_command { + uint32_t cmd; /* LC_SOURCE_VERSION */ + uint32_t cmdsize; /* 16 */ + uint64_t version; /* A.B.C.D.E packed as a24.b10.c10.d10.e10 */ +}; + + +/* + * The LC_DATA_IN_CODE load commands uses a linkedit_data_command + * to point to an array of data_in_code_entry entries. Each entry + * describes a range of data in a code section. + */ +struct data_in_code_entry { + uint32_t offset; /* from mach_header to start of data range*/ + uint16_t length; /* number of bytes in data range */ + uint16_t kind; /* a DICE_KIND_* value */ +}; +#define DICE_KIND_DATA 0x0001 +#define DICE_KIND_JUMP_TABLE8 0x0002 +#define DICE_KIND_JUMP_TABLE16 0x0003 +#define DICE_KIND_JUMP_TABLE32 0x0004 +#define DICE_KIND_ABS_JUMP_TABLE32 0x0005 + + + +/* + * Sections of type S_THREAD_LOCAL_VARIABLES contain an array + * of tlv_descriptor structures. + */ +struct tlv_descriptor +{ + void* (*thunk)(struct tlv_descriptor*); + unsigned long key; + unsigned long offset; +}; + +/* + * LC_NOTE commands describe a region of arbitrary data included in a Mach-O + * file. Its initial use is to record extra data in MH_CORE files. + */ +struct note_command { + uint32_t cmd; /* LC_NOTE */ + uint32_t cmdsize; /* sizeof(struct note_command) */ + char data_owner[16]; /* owner name for this LC_NOTE */ + uint64_t offset; /* file offset of this data */ + uint64_t size; /* length of data region */ +}; + +#endif /* _MACHO_LOADER_H_ */ diff --git a/I. Mach-O/mac/mach_loader.c b/I. Mach-O/mac/mach_loader.c new file mode 100644 index 0000000..98a3ca2 --- /dev/null +++ b/I. Mach-O/mac/mach_loader.c @@ -0,0 +1,3912 @@ +// SOURCE: https://raw.githubusercontent.com/apple-oss-distributions/xnu/xnu-10002.61.3/bsd/kern/mach_loader.c + +/* + * Copyright (c) 2000-2020 Apple Inc. All rights reserved. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. + * + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ + */ +/* + * Copyright (C) 1988, 1989, NeXT, Inc. + * + * File: kern/mach_loader.c + * Author: Avadis Tevanian, Jr. + * + * Mach object file loader (kernel version, for now). + * + * 21-Jul-88 Avadis Tevanian, Jr. (avie) at NeXT + * Started. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include /* vm_allocate() */ +#include /* mach_vm_allocate() */ +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include /* for kIOReturnNotPrivileged */ +#include /* for IOVnodeHasEntitlement */ + +#include +#include + +#include "kern_exec_internal.h" + +/* XXX should have prototypes in a shared header file */ +extern int get_map_nentries(vm_map_t); + +extern kern_return_t memory_object_signed(memory_object_control_t control, + boolean_t is_signed); + + +/* An empty load_result_t */ +static const load_result_t load_result_null = { + .mach_header = MACH_VM_MIN_ADDRESS, + .entry_point = MACH_VM_MIN_ADDRESS, + .user_stack = MACH_VM_MIN_ADDRESS, + .user_stack_size = 0, + .user_stack_alloc = MACH_VM_MIN_ADDRESS, + .user_stack_alloc_size = 0, + .all_image_info_addr = MACH_VM_MIN_ADDRESS, + .all_image_info_size = 0, + .thread_count = 0, + .unixproc = 0, + .dynlinker = 0, + .needs_dynlinker = 0, + .validentry = 0, + .using_lcmain = 0, + .is_64bit_addr = 0, + .is_64bit_data = 0, + .custom_stack = 0, + .csflags = 0, + .has_pagezero = 0, + .uuid = { 0 }, + .min_vm_addr = MACH_VM_MAX_ADDRESS, + .max_vm_addr = MACH_VM_MIN_ADDRESS, + .ro_vm_start = MACH_VM_MIN_ADDRESS, + .ro_vm_end = MACH_VM_MIN_ADDRESS, + .cs_end_offset = 0, + .threadstate = NULL, + .threadstate_sz = 0, + .is_rosetta = 0, + .dynlinker_ro_vm_start = 0, + .dynlinker_ro_vm_end = 0, + .dynlinker_mach_header = MACH_VM_MIN_ADDRESS, + .dynlinker_fd = -1, +}; + +/* + * Prototypes of static functions. + */ +static load_return_t +parse_machfile( + struct vnode *vp, + vm_map_t map, + thread_t thread, + struct mach_header *header, + off_t file_offset, + off_t macho_size, + int depth, + int64_t slide, + int64_t dyld_slide, + load_result_t *result, + load_result_t *binresult, + struct image_params *imgp + ); + +static load_return_t +load_segment( + struct load_command *lcp, + uint32_t filetype, + void *control, + off_t pager_offset, + off_t macho_size, + struct vnode *vp, + vm_map_t map, + int64_t slide, + load_result_t *result, + struct image_params *imgp + ); + +static load_return_t +load_uuid( + struct uuid_command *uulp, + char *command_end, + load_result_t *result + ); + +static load_return_t +load_version( + struct version_min_command *vmc, + boolean_t *found_version_cmd, + struct image_params *imgp, + load_result_t *result + ); + +static load_return_t +load_code_signature( + struct linkedit_data_command *lcp, + struct vnode *vp, + off_t macho_offset, + off_t macho_size, + cpu_type_t cputype, + cpu_subtype_t cpusubtype, + load_result_t *result, + struct image_params *imgp); + +#if CONFIG_CODE_DECRYPTION +static load_return_t +set_code_unprotect( + struct encryption_info_command *lcp, + caddr_t addr, + vm_map_t map, + int64_t slide, + struct vnode *vp, + off_t macho_offset, + cpu_type_t cputype, + cpu_subtype_t cpusubtype); +#endif + +static +load_return_t +load_main( + struct entry_point_command *epc, + thread_t thread, + int64_t slide, + load_result_t *result + ); + +static +load_return_t +setup_driver_main( + thread_t thread, + int64_t slide, + load_result_t *result + ); + +static load_return_t +load_unixthread( + struct thread_command *tcp, + thread_t thread, + int64_t slide, + boolean_t is_x86_64_compat_binary, + load_result_t *result + ); + +static load_return_t +load_threadstate( + thread_t thread, + uint32_t *ts, + uint32_t total_size, + load_result_t * + ); + +static load_return_t +load_threadstack( + thread_t thread, + uint32_t *ts, + uint32_t total_size, + mach_vm_offset_t *user_stack, + int *customstack, + boolean_t is_x86_64_compat_binary, + load_result_t *result + ); + +static load_return_t +load_threadentry( + thread_t thread, + uint32_t *ts, + uint32_t total_size, + mach_vm_offset_t *entry_point + ); + +static load_return_t +load_dylinker( + struct dylinker_command *lcp, + integer_t archbits, + vm_map_t map, + thread_t thread, + int depth, + int64_t slide, + load_result_t *result, + struct image_params *imgp + ); + + +#if CONFIG_ROSETTA +static load_return_t +load_rosetta( + vm_map_t map, + thread_t thread, + load_result_t *result, + struct image_params *imgp + ); +#endif + +#if __x86_64__ +extern int bootarg_no32exec; +static boolean_t +check_if_simulator_binary( + struct image_params *imgp, + off_t file_offset, + off_t macho_size); +#endif + +struct macho_data; + +static load_return_t +get_macho_vnode( + const char *path, + integer_t archbits, + struct mach_header *mach_header, + off_t *file_offset, + off_t *macho_size, + struct macho_data *macho_data, + struct vnode **vpp, + struct image_params *imgp + ); + +static inline void +widen_segment_command(const struct segment_command *scp32, + struct segment_command_64 *scp) +{ + scp->cmd = scp32->cmd; + scp->cmdsize = scp32->cmdsize; + bcopy(scp32->segname, scp->segname, sizeof(scp->segname)); + scp->vmaddr = scp32->vmaddr; + scp->vmsize = scp32->vmsize; + scp->fileoff = scp32->fileoff; + scp->filesize = scp32->filesize; + scp->maxprot = scp32->maxprot; + scp->initprot = scp32->initprot; + scp->nsects = scp32->nsects; + scp->flags = scp32->flags; +} + +static void +note_all_image_info_section(const struct segment_command_64 *scp, + boolean_t is64, size_t section_size, const void *sections, + int64_t slide, load_result_t *result) +{ + const union { + struct section s32; + struct section_64 s64; + } *sectionp; + unsigned int i; + + + if (strncmp(scp->segname, "__DATA_DIRTY", sizeof(scp->segname)) != 0 && + strncmp(scp->segname, "__DATA", sizeof(scp->segname)) != 0) { + return; + } + for (i = 0; i < scp->nsects; ++i) { + sectionp = (const void *) + ((const char *)sections + section_size * i); + if (0 == strncmp(sectionp->s64.sectname, "__all_image_info", + sizeof(sectionp->s64.sectname))) { + result->all_image_info_addr = + is64 ? sectionp->s64.addr : sectionp->s32.addr; + result->all_image_info_addr += slide; + result->all_image_info_size = + is64 ? sectionp->s64.size : sectionp->s32.size; + return; + } + } +} + +#if __arm64__ +/* + * Allow bypassing some security rules (hard pagezero, no write+execute) + * in exchange for better binary compatibility for legacy apps built + * before 16KB-alignment was enforced. + */ +const int fourk_binary_compatibility_unsafe = TRUE; +const int fourk_binary_compatibility_allow_wx = FALSE; +#endif /* __arm64__ */ + +#if __has_feature(ptrauth_calls) && XNU_TARGET_OS_OSX +/** + * Determines whether this is an arm64e process which may host in-process + * plugins. + */ +static inline bool +arm64e_plugin_host(struct image_params *imgp, load_result_t *result) +{ + if (imgp->ip_flags & IMGPF_NOJOP) { + return false; + } + + if (!result->platform_binary) { + return false; + } + + struct cs_blob *csblob = csvnode_get_blob(imgp->ip_vp, imgp->ip_arch_offset); + const char *identity = csblob_get_identity(csblob); + if (!identity) { + return false; + } + + /* Check if override host plugin entitlement is present and posix spawn attribute to disable A keys is passed */ + if (IOVnodeHasEntitlement(imgp->ip_vp, (int64_t)imgp->ip_arch_offset, OVERRIDE_PLUGIN_HOST_ENTITLEMENT)) { + bool ret = imgp->ip_flags & IMGPF_PLUGIN_HOST_DISABLE_A_KEYS; + if (ret) { + proc_t p = vfs_context_proc(imgp->ip_vfs_context); + set_proc_name(imgp, p); + os_log(OS_LOG_DEFAULT, "%s: running binary \"%s\" in keys-off mode due to posix_spawnattr_disable_ptr_auth_a_keys_np", __func__, p->p_name); + } + return ret; + } + + /* Disabling library validation is a good signal that this process plans to host plugins */ + const char *const disable_lv_entitlements[] = { + "com.apple.security.cs.disable-library-validation", + "com.apple.private.cs.automator-plugins", + CLEAR_LV_ENTITLEMENT, + }; + for (size_t i = 0; i < ARRAY_COUNT(disable_lv_entitlements); i++) { + const char *entitlement = disable_lv_entitlements[i]; + if (IOVnodeHasEntitlement(imgp->ip_vp, (int64_t)imgp->ip_arch_offset, entitlement)) { + proc_t p = vfs_context_proc(imgp->ip_vfs_context); + set_proc_name(imgp, p); + os_log(OS_LOG_DEFAULT, "%s: running binary \"%s\" in keys-off mode due to entitlement: %s", __func__, p->p_name, entitlement); + return true; + } + } + + /* From /System/Library/Security/HardeningExceptions.plist */ + const char *const hardening_exceptions[] = { + "com.apple.perl5", /* Scripting engines may load third party code and jit*/ + "com.apple.perl", /* Scripting engines may load third party code and jit*/ + "org.python.python", /* Scripting engines may load third party code and jit*/ + "com.apple.expect", /* Scripting engines may load third party code and jit*/ + "com.tcltk.wish", /* Scripting engines may load third party code and jit*/ + "com.tcltk.tclsh", /* Scripting engines may load third party code and jit*/ + "com.apple.ruby", /* Scripting engines may load third party code and jit*/ + "com.apple.bash", /* Required for the 'enable' command */ + "com.apple.zsh", /* Required for the 'zmodload' command */ + "com.apple.ksh", /* Required for 'builtin' command */ + }; + for (size_t i = 0; i < ARRAY_COUNT(hardening_exceptions); i++) { + if (strncmp(hardening_exceptions[i], identity, strlen(hardening_exceptions[i])) == 0) { + proc_t p = vfs_context_proc(imgp->ip_vfs_context); + set_proc_name(imgp, p); + os_log(OS_LOG_DEFAULT, "%s: running binary \"%s\" in keys-off mode due to identity: %s", __func__, p->p_name, identity); + return true; + } + } + + return false; +} +#endif /* __has_feature(ptrauth_calls) && XNU_TARGET_OS_OSX */ + +load_return_t +load_machfile( + struct image_params *imgp, + struct mach_header *header, + thread_t thread, + vm_map_t *mapp, + load_result_t *result + ) +{ + struct vnode *vp = imgp->ip_vp; + off_t file_offset = imgp->ip_arch_offset; + off_t macho_size = imgp->ip_arch_size; + off_t total_size = 0; + off_t file_size = imgp->ip_vattr->va_data_size; + pmap_t pmap = 0; /* protected by create_map */ + vm_map_t map; + load_result_t myresult; + load_return_t lret; + boolean_t enforce_hard_pagezero = TRUE; + int in_exec = (imgp->ip_flags & IMGPF_EXEC); + task_t task = current_task(); + int64_t aslr_page_offset = 0; + int64_t dyld_aslr_page_offset = 0; + int64_t aslr_section_size = 0; + int64_t aslr_section_offset = 0; + kern_return_t kret; + unsigned int pmap_flags = 0; + + if (os_add_overflow(file_offset, macho_size, &total_size) || + total_size > file_size) { + return LOAD_BADMACHO; + } + + result->is_64bit_addr = ((imgp->ip_flags & IMGPF_IS_64BIT_ADDR) == IMGPF_IS_64BIT_ADDR); + result->is_64bit_data = ((imgp->ip_flags & IMGPF_IS_64BIT_DATA) == IMGPF_IS_64BIT_DATA); +#if defined(HAS_APPLE_PAC) + pmap_flags |= (imgp->ip_flags & IMGPF_NOJOP) ? PMAP_CREATE_DISABLE_JOP : 0; +#endif /* defined(HAS_APPLE_PAC) */ +#if CONFIG_ROSETTA + pmap_flags |= (imgp->ip_flags & IMGPF_ROSETTA) ? PMAP_CREATE_ROSETTA : 0; +#endif + pmap_flags |= result->is_64bit_addr ? PMAP_CREATE_64BIT : 0; + + task_t ledger_task; + if (imgp->ip_new_thread) { + ledger_task = get_threadtask(imgp->ip_new_thread); + } else { + ledger_task = task; + } + +#if XNU_TARGET_OS_OSX && _POSIX_SPAWN_FORCE_4K_PAGES && PMAP_CREATE_FORCE_4K_PAGES + if (imgp->ip_px_sa != NULL) { + struct _posix_spawnattr* psa = (struct _posix_spawnattr *) imgp->ip_px_sa; + if (psa->psa_flags & _POSIX_SPAWN_FORCE_4K_PAGES) { + pmap_flags |= PMAP_CREATE_FORCE_4K_PAGES; + } + } +#endif /* XNU_TARGET_OS_OSX && _POSIX_SPAWN_FORCE_4K_PAGES && PMAP_CREATE_FORCE_4K_PAGE */ + + pmap = pmap_create_options(get_task_ledger(ledger_task), + (vm_map_size_t) 0, + pmap_flags); + if (pmap == NULL) { + return LOAD_RESOURCE; + } + map = vm_map_create_options(pmap, 0, + vm_compute_max_offset(result->is_64bit_addr), + VM_MAP_CREATE_PAGEABLE); + +#if defined(__arm64__) + if (result->is_64bit_addr) { + /* enforce 16KB alignment of VM map entries */ + vm_map_set_page_shift(map, SIXTEENK_PAGE_SHIFT); + } else { + vm_map_set_page_shift(map, page_shift_user32); + } +#endif /* __arm64__ */ + +#if PMAP_CREATE_FORCE_4K_PAGES + if (pmap_flags & PMAP_CREATE_FORCE_4K_PAGES) { + DEBUG4K_LIFE("***** launching '%s' as 4k *****\n", vp->v_name); + vm_map_set_page_shift(map, FOURK_PAGE_SHIFT); + } +#endif /* PMAP_CREATE_FORCE_4K_PAGES */ + +#ifndef CONFIG_ENFORCE_SIGNED_CODE + /* This turns off faulting for executable pages, which allows + * to circumvent Code Signing Enforcement. The per process + * flag (CS_ENFORCEMENT) is not set yet, but we can use the + * global flag. + */ + if (!cs_process_global_enforcement() && (header->flags & MH_ALLOW_STACK_EXECUTION)) { + vm_map_disable_NX(map); + // TODO: Message Trace or log that this is happening + } +#endif + + /* Forcibly disallow execution from data pages on even if the arch + * normally permits it. */ + if ((header->flags & MH_NO_HEAP_EXECUTION) && !(imgp->ip_flags & IMGPF_ALLOW_DATA_EXEC)) { + vm_map_disallow_data_exec(map); + } + + /* + * Compute a random offset for ASLR, and an independent random offset for dyld. + */ + if (!(imgp->ip_flags & IMGPF_DISABLE_ASLR)) { + vm_map_get_max_aslr_slide_section(map, &aslr_section_offset, &aslr_section_size); + aslr_section_offset = (random() % aslr_section_offset) * aslr_section_size; + + aslr_page_offset = random(); + aslr_page_offset = (aslr_page_offset % (vm_map_get_max_aslr_slide_pages(map) - 1)) + 1; + aslr_page_offset <<= vm_map_page_shift(map); + + dyld_aslr_page_offset = random(); + dyld_aslr_page_offset = (dyld_aslr_page_offset % + (vm_map_get_max_loader_aslr_slide_pages(map) - 1)) + 1; + dyld_aslr_page_offset <<= vm_map_page_shift(map); + + aslr_page_offset += aslr_section_offset; + } + if (vm_map_page_shift(map) < (int)PAGE_SHIFT) { + DEBUG4K_LOAD("slide=0x%llx dyld_slide=0x%llx\n", aslr_page_offset, dyld_aslr_page_offset); + } + + if (!result) { + result = &myresult; + } + + *result = load_result_null; + + /* + * re-set the bitness on the load result since we cleared the load result above. + */ + result->is_64bit_addr = ((imgp->ip_flags & IMGPF_IS_64BIT_ADDR) == IMGPF_IS_64BIT_ADDR); + result->is_64bit_data = ((imgp->ip_flags & IMGPF_IS_64BIT_DATA) == IMGPF_IS_64BIT_DATA); + + lret = parse_machfile(vp, map, thread, header, file_offset, macho_size, + 0, aslr_page_offset, dyld_aslr_page_offset, result, + NULL, imgp); + + if (lret != LOAD_SUCCESS) { + vm_map_deallocate(map); /* will lose pmap reference too */ + return lret; + } + +#if __x86_64__ + /* + * On x86, for compatibility, don't enforce the hard page-zero restriction for 32-bit binaries. + */ + if (!result->is_64bit_addr) { + enforce_hard_pagezero = FALSE; + } + + /* + * For processes with IMGPF_HIGH_BITS_ASLR, add a few random high bits + * to the start address for "anywhere" memory allocations. + */ +#define VM_MAP_HIGH_START_BITS_COUNT 8 +#define VM_MAP_HIGH_START_BITS_SHIFT 27 + if (result->is_64bit_addr && + (imgp->ip_flags & IMGPF_HIGH_BITS_ASLR)) { + int random_bits; + vm_map_offset_t high_start; + + random_bits = random(); + random_bits &= (1 << VM_MAP_HIGH_START_BITS_COUNT) - 1; + high_start = (((vm_map_offset_t)random_bits) + << VM_MAP_HIGH_START_BITS_SHIFT); + vm_map_set_high_start(map, high_start); + } +#endif /* __x86_64__ */ + + /* + * Check to see if the page zero is enforced by the map->min_offset. + */ + if (enforce_hard_pagezero && + (vm_map_has_hard_pagezero(map, 0x1000) == FALSE)) { +#if __arm64__ + if ( + !result->is_64bit_addr && /* not 64-bit address space */ + !(header->flags & MH_PIE) && /* not PIE */ + (vm_map_page_shift(map) != FOURK_PAGE_SHIFT || + PAGE_SHIFT != FOURK_PAGE_SHIFT) && /* page size != 4KB */ + result->has_pagezero && /* has a "soft" page zero */ + fourk_binary_compatibility_unsafe) { + /* + * For backwards compatibility of "4K" apps on + * a 16K system, do not enforce a hard page zero... + */ + } else +#endif /* __arm64__ */ + { + vm_map_deallocate(map); /* will lose pmap reference too */ + return LOAD_BADMACHO; + } + } + +#if __arm64__ + if (enforce_hard_pagezero && result->is_64bit_addr && (header->cputype == CPU_TYPE_ARM64)) { + /* 64 bit ARM binary must have "hard page zero" of 4GB to cover the lower 32 bit address space */ + if (vm_map_has_hard_pagezero(map, 0x100000000) == FALSE) { + vm_map_deallocate(map); /* will lose pmap reference too */ + return LOAD_BADMACHO; + } + } +#endif + + vm_commit_pagezero_status(map); + + /* + * If this is an exec, then we are going to destroy the old + * task, and it's correct to halt it; if it's spawn, the + * task is not yet running, and it makes no sense. + */ + if (in_exec) { + proc_t p = current_proc(); + /* + * Mark the task as halting and start the other + * threads towards terminating themselves. Then + * make sure any threads waiting for a process + * transition get informed that we are committed to + * this transition, and then finally complete the + * task halting (wait for threads and then cleanup + * task resources). + * + * NOTE: task_start_halt() makes sure that no new + * threads are created in the task during the transition. + * We need to mark the workqueue as exiting before we + * wait for threads to terminate (at the end of which + * we no longer have a prohibition on thread creation). + * + * Finally, clean up any lingering workqueue data structures + * that may have been left behind by the workqueue threads + * as they exited (and then clean up the work queue itself). + */ + kret = task_start_halt(task); + if (kret != KERN_SUCCESS) { + vm_map_deallocate(map); /* will lose pmap reference too */ + return LOAD_FAILURE; + } + proc_transcommit(p, 0); + workq_mark_exiting(p); + task_complete_halt(task); + workq_exit(p); + + /* + * Roll up accounting info to new task. The roll up is done after + * task_complete_halt to make sure the thread accounting info is + * rolled up to current_task. + */ + task_rollup_accounting_info(get_threadtask(thread), task); + } + *mapp = map; + +#if __has_feature(ptrauth_calls) && defined(XNU_TARGET_OS_OSX) + /* + * arm64e plugin hosts currently run with JOP keys disabled, since they + * may need to run arm64 plugins. + */ + if (arm64e_plugin_host(imgp, result)) { + imgp->ip_flags |= IMGPF_NOJOP; + pmap_disable_user_jop(pmap); + } + +#if CONFIG_ROSETTA + /* Disable JOP keys if the Rosetta runtime being used isn't arm64e */ + if (result->is_rosetta && (imgp->ip_flags & IMGPF_NOJOP)) { + pmap_disable_user_jop(pmap); + } +#endif /* CONFIG_ROSETTA */ +#endif /* __has_feature(ptrauth_calls) && defined(XNU_TARGET_OS_OSX) */ + + + return LOAD_SUCCESS; +} + +int macho_printf = 0; +#define MACHO_PRINTF(args) \ + do { \ + if (macho_printf) { \ + printf args; \ + } \ + } while (0) + + +static boolean_t +pie_required( + cpu_type_t exectype, + cpu_subtype_t execsubtype) +{ + switch (exectype) { + case CPU_TYPE_X86_64: + return FALSE; + case CPU_TYPE_ARM64: + return TRUE; + case CPU_TYPE_ARM: + switch (execsubtype) { + case CPU_SUBTYPE_ARM_V7K: + return TRUE; + } + break; + } + return FALSE; +} + +/* + * The file size of a mach-o file is limited to 32 bits; this is because + * this is the limit on the kalloc() of enough bytes for a mach_header and + * the contents of its sizeofcmds, which is currently constrained to 32 + * bits in the file format itself. We read into the kernel buffer the + * commands section, and then parse it in order to parse the mach-o file + * format load_command segment(s). We are only interested in a subset of + * the total set of possible commands. If "map"==VM_MAP_NULL or + * "thread"==THREAD_NULL, do not make permament VM modifications, + * just preflight the parse. + */ +static +load_return_t +parse_machfile( + struct vnode *vp, + vm_map_t map, + thread_t thread, + struct mach_header *header, + off_t file_offset, + off_t macho_size, + int depth, + int64_t aslr_offset, + int64_t dyld_aslr_offset, + load_result_t *result, + load_result_t *binresult, + struct image_params *imgp + ) +{ + uint32_t ncmds; + struct load_command *lcp; + struct dylinker_command *dlp = 0; + void * control; + load_return_t ret = LOAD_SUCCESS; + void * addr; + vm_size_t alloc_size, cmds_size; + size_t offset; + size_t oldoffset; /* for overflow check */ + int pass; + proc_t p = vfs_context_proc(imgp->ip_vfs_context); + int error; + int resid = 0; + int spawn = (imgp->ip_flags & IMGPF_SPAWN); + size_t mach_header_sz = sizeof(struct mach_header); + boolean_t abi64; + boolean_t got_code_signatures = FALSE; + boolean_t found_header_segment = FALSE; + boolean_t found_xhdr = FALSE; + boolean_t found_version_cmd = FALSE; + int64_t slide = 0; + boolean_t dyld_no_load_addr = FALSE; + boolean_t is_dyld = FALSE; + vm_map_offset_t effective_page_mask = PAGE_MASK; +#if __arm64__ + uint64_t pagezero_end = 0; + uint64_t executable_end = 0; + uint64_t writable_start = 0; + vm_map_size_t effective_page_size; + + effective_page_mask = vm_map_page_mask(map); + effective_page_size = vm_map_page_size(map); +#endif /* __arm64__ */ + + if (header->magic == MH_MAGIC_64 || + header->magic == MH_CIGAM_64) { + mach_header_sz = sizeof(struct mach_header_64); + } + + /* + * Break infinite recursion + */ + if (depth > 2) { + return LOAD_FAILURE; + } + + depth++; + + /* + * Set CS_NO_UNTRUSTED_HELPERS by default; load_dylinker and load_rosetta + * will unset it if necessary. + */ + if (depth == 1) { + result->csflags |= CS_NO_UNTRUSTED_HELPERS; + } + + /* + * Check to see if right machine type. + */ + if (((cpu_type_t)(header->cputype & ~CPU_ARCH_MASK) != (cpu_type() & ~CPU_ARCH_MASK)) + ) { + return LOAD_BADARCH; + } + + if (!grade_binary(header->cputype, + header->cpusubtype & ~CPU_SUBTYPE_MASK, + header->cpusubtype & CPU_SUBTYPE_MASK, TRUE)) { + return LOAD_BADARCH; + } + + abi64 = ((header->cputype & CPU_ARCH_ABI64) == CPU_ARCH_ABI64); + + switch (header->filetype) { + case MH_EXECUTE: + if (depth != 1 && depth != 3) { + return LOAD_FAILURE; + } + if (header->flags & MH_DYLDLINK) { + /* Check properties of dynamic executables */ + if (!(header->flags & MH_PIE) && pie_required(header->cputype, header->cpusubtype & ~CPU_SUBTYPE_MASK)) { + return LOAD_FAILURE; + } + result->needs_dynlinker = TRUE; + } else if (header->cputype == CPU_TYPE_X86_64) { + /* x86_64 static binaries allowed */ +#if CONFIG_ROSETTA + } else if (imgp->ip_flags & IMGPF_ROSETTA) { + /* Rosetta runtime allowed */ +#endif /* CONFIG_X86_64_COMPAT */ + } else { + /* Check properties of static executables (disallowed except for development) */ +#if !(DEVELOPMENT || DEBUG) + return LOAD_FAILURE; +#endif + } + break; + case MH_DYLINKER: + if (depth != 2) { + return LOAD_FAILURE; + } + is_dyld = TRUE; + break; + + default: + return LOAD_FAILURE; + } + + /* + * For PIE and dyld, slide everything by the ASLR offset. + */ + if ((header->flags & MH_PIE) || is_dyld) { + slide = aslr_offset; + } + + /* + * Get the pager for the file. + */ + control = ubc_getobject(vp, UBC_FLAGS_NONE); + + /* ensure header + sizeofcmds falls within the file */ + if (os_add_overflow(mach_header_sz, header->sizeofcmds, &cmds_size) || + (off_t)cmds_size > macho_size || + round_page_overflow(cmds_size, &alloc_size) || + alloc_size > INT_MAX) { + return LOAD_BADMACHO; + } + + /* + * Map the load commands into kernel memory. + */ + addr = kalloc_data(alloc_size, Z_WAITOK); + if (addr == NULL) { + return LOAD_NOSPACE; + } + + error = vn_rdwr(UIO_READ, vp, addr, (int)alloc_size, file_offset, + UIO_SYSSPACE, 0, vfs_context_ucred(imgp->ip_vfs_context), &resid, p); + if (error) { + kfree_data(addr, alloc_size); + return LOAD_IOERROR; + } + + if (resid) { + { + /* We must be able to read in as much as the mach_header indicated */ + kfree_data(addr, alloc_size); + return LOAD_BADMACHO; + } + } + + /* + * Scan through the commands, processing each one as necessary. + * We parse in three passes through the headers: + * 0: determine if TEXT and DATA boundary can be page-aligned, load platform version + * 1: thread state, uuid, code signature + * 2: segments + * 3: dyld, encryption, check entry point + */ + + boolean_t slide_realign = FALSE; +#if __arm64__ + if (!abi64) { + slide_realign = TRUE; + } +#endif + + for (pass = 0; pass <= 3; pass++) { + if (pass == 1) { +#if __arm64__ + boolean_t is_pie; + int64_t adjust; + + is_pie = ((header->flags & MH_PIE) != 0); + if (pagezero_end != 0 && + pagezero_end < effective_page_size) { + /* need at least 1 page for PAGEZERO */ + adjust = effective_page_size; + MACHO_PRINTF(("pagezero boundary at " + "0x%llx; adjust slide from " + "0x%llx to 0x%llx%s\n", + (uint64_t) pagezero_end, + slide, + slide + adjust, + (is_pie + ? "" + : " BUT NO PIE ****** :-("))); + if (is_pie) { + slide += adjust; + pagezero_end += adjust; + executable_end += adjust; + writable_start += adjust; + } + } + if (pagezero_end != 0) { + result->has_pagezero = TRUE; + } + if (executable_end == writable_start && + (executable_end & effective_page_mask) != 0 && + (executable_end & FOURK_PAGE_MASK) == 0) { + /* + * The TEXT/DATA boundary is 4K-aligned but + * not page-aligned. Adjust the slide to make + * it page-aligned and avoid having a page + * with both write and execute permissions. + */ + adjust = + (effective_page_size - + (executable_end & effective_page_mask)); + MACHO_PRINTF(("page-unaligned X-W boundary at " + "0x%llx; adjust slide from " + "0x%llx to 0x%llx%s\n", + (uint64_t) executable_end, + slide, + slide + adjust, + (is_pie + ? "" + : " BUT NO PIE ****** :-("))); + if (is_pie) { + slide += adjust; + } + } +#endif /* __arm64__ */ + + if (dyld_no_load_addr && binresult) { + /* + * The dyld Mach-O does not specify a load address. Try to locate + * it right after the main binary. If binresult == NULL, load + * directly to the given slide. + */ + mach_vm_address_t max_vm_addr = binresult->max_vm_addr; + slide = vm_map_round_page(slide + max_vm_addr, effective_page_mask); + } + } + + /* + * Check that the entry point is contained in an executable segment + */ + if ((pass == 3) && (thread != THREAD_NULL)) { + if (depth == 1 && imgp && (imgp->ip_flags & IMGPF_DRIVER)) { + /* Driver binaries must have driverkit platform */ + if (result->ip_platform == PLATFORM_DRIVERKIT) { + /* Driver binaries have no entry point */ + ret = setup_driver_main(thread, slide, result); + } else { + ret = LOAD_FAILURE; + } + } else if (!result->using_lcmain && result->validentry == 0) { + ret = LOAD_FAILURE; + } + if (ret != KERN_SUCCESS) { + thread_state_initialize(thread); + break; + } + } + + /* + * Check that some segment maps the start of the mach-o file, which is + * needed by the dynamic loader to read the mach headers, etc. + */ + if ((pass == 3) && (found_header_segment == FALSE)) { + ret = LOAD_BADMACHO; + break; + } + + /* + * Loop through each of the load_commands indicated by the + * Mach-O header; if an absurd value is provided, we just + * run off the end of the reserved section by incrementing + * the offset too far, so we are implicitly fail-safe. + */ + offset = mach_header_sz; + ncmds = header->ncmds; + + while (ncmds--) { + /* ensure enough space for a minimal load command */ + if (offset + sizeof(struct load_command) > cmds_size) { + ret = LOAD_BADMACHO; + break; + } + + /* + * Get a pointer to the command. + */ + lcp = (struct load_command *)((uintptr_t)addr + offset); + oldoffset = offset; + + /* + * Perform prevalidation of the struct load_command + * before we attempt to use its contents. Invalid + * values are ones which result in an overflow, or + * which can not possibly be valid commands, or which + * straddle or exist past the reserved section at the + * start of the image. + */ + if (os_add_overflow(offset, lcp->cmdsize, &offset) || + lcp->cmdsize < sizeof(struct load_command) || + offset > cmds_size) { + ret = LOAD_BADMACHO; + break; + } + + /* + * Act on struct load_command's for which kernel + * intervention is required. + * Note that each load command implementation is expected to validate + * that lcp->cmdsize is large enough to fit its specific struct type + * before dereferencing fields not covered by struct load_command. + */ + switch (lcp->cmd) { + case LC_SEGMENT: { + struct segment_command *scp = (struct segment_command *) lcp; + if (scp->cmdsize < sizeof(*scp)) { + ret = LOAD_BADMACHO; + break; + } + if (pass == 0) { + if (is_dyld && scp->vmaddr == 0 && scp->fileoff == 0) { + dyld_no_load_addr = TRUE; + if (!slide_realign) { + /* got what we need, bail early on pass 0 */ + continue; + } + } + +#if __arm64__ + assert(!abi64); + + if (scp->initprot == 0 && scp->maxprot == 0 && scp->vmaddr == 0) { + /* PAGEZERO */ + if (os_add3_overflow(scp->vmaddr, scp->vmsize, slide, &pagezero_end) || pagezero_end > UINT32_MAX) { + ret = LOAD_BADMACHO; + break; + } + } + if (scp->initprot & VM_PROT_EXECUTE) { + /* TEXT */ + if (os_add3_overflow(scp->vmaddr, scp->vmsize, slide, &executable_end) || executable_end > UINT32_MAX) { + ret = LOAD_BADMACHO; + break; + } + } + if (scp->initprot & VM_PROT_WRITE) { + /* DATA */ + if (os_add_overflow(scp->vmaddr, slide, &writable_start) || writable_start > UINT32_MAX) { + ret = LOAD_BADMACHO; + break; + } + } +#endif /* __arm64__ */ + break; + } + + if (pass == 1 && !strncmp(scp->segname, "__XHDR", sizeof(scp->segname))) { + found_xhdr = TRUE; + } + + if (pass != 2) { + break; + } + + if (abi64) { + /* + * Having an LC_SEGMENT command for the + * wrong ABI is invalid + */ + ret = LOAD_BADMACHO; + break; + } + + ret = load_segment(lcp, + header->filetype, + control, + file_offset, + macho_size, + vp, + map, + slide, + result, + imgp); + if (ret == LOAD_SUCCESS && scp->fileoff == 0 && scp->filesize > 0) { + /* Enforce a single segment mapping offset zero, with R+X + * protection. */ + if (found_header_segment || + ((scp->initprot & (VM_PROT_READ | VM_PROT_EXECUTE)) != (VM_PROT_READ | VM_PROT_EXECUTE))) { + ret = LOAD_BADMACHO; + break; + } + found_header_segment = TRUE; + } + + break; + } + case LC_SEGMENT_64: { + struct segment_command_64 *scp64 = (struct segment_command_64 *) lcp; + if (scp64->cmdsize < sizeof(*scp64)) { + ret = LOAD_BADMACHO; + break; + } + if (pass == 0) { + if (is_dyld && scp64->vmaddr == 0 && scp64->fileoff == 0) { + dyld_no_load_addr = TRUE; + } + /* got what we need, bail early on pass 0 */ + continue; + } + + if (pass == 1 && !strncmp(scp64->segname, "__XHDR", sizeof(scp64->segname))) { + found_xhdr = TRUE; + } + + if (pass != 2) { + break; + } + + if (!abi64) { + /* + * Having an LC_SEGMENT_64 command for the + * wrong ABI is invalid + */ + ret = LOAD_BADMACHO; + break; + } + + ret = load_segment(lcp, + header->filetype, + control, + file_offset, + macho_size, + vp, + map, + slide, + result, + imgp); + + if (ret == LOAD_SUCCESS && scp64->fileoff == 0 && scp64->filesize > 0) { + /* Enforce a single segment mapping offset zero, with R+X + * protection. */ + if (found_header_segment || + ((scp64->initprot & (VM_PROT_READ | VM_PROT_EXECUTE)) != (VM_PROT_READ | VM_PROT_EXECUTE))) { + ret = LOAD_BADMACHO; + break; + } + found_header_segment = TRUE; + } + + break; + } + case LC_UNIXTHREAD: { + boolean_t is_x86_64_compat_binary = FALSE; + if (pass != 1) { + break; + } +#if CONFIG_ROSETTA + if (depth == 2 && (imgp->ip_flags & IMGPF_ROSETTA)) { + // Ignore dyld, Rosetta will parse it's load commands to get the + // entry point. + result->validentry = 1; + break; + } +#endif + ret = load_unixthread( + (struct thread_command *) lcp, + thread, + slide, + is_x86_64_compat_binary, + result); + break; + } + case LC_MAIN: + if (pass != 1) { + break; + } + if (depth != 1) { + break; + } + ret = load_main( + (struct entry_point_command *) lcp, + thread, + slide, + result); + break; + case LC_LOAD_DYLINKER: + if (pass != 3) { + break; + } + if ((depth == 1) && (dlp == 0)) { + dlp = (struct dylinker_command *)lcp; + } else { + ret = LOAD_FAILURE; + } + break; + case LC_UUID: + if (pass == 1 && depth == 1) { + ret = load_uuid((struct uuid_command *) lcp, + (char *)addr + cmds_size, + result); + } + break; + case LC_CODE_SIGNATURE: + /* CODE SIGNING */ + if (pass != 1) { + break; + } + + /* pager -> uip -> + * load signatures & store in uip + * set VM object "signed_pages" + */ + ret = load_code_signature( + (struct linkedit_data_command *) lcp, + vp, + file_offset, + macho_size, + header->cputype, + header->cpusubtype, + result, + imgp); + if (ret != LOAD_SUCCESS) { + printf("proc %d: load code signature error %d " + "for file \"%s\"\n", + proc_getpid(p), ret, vp->v_name); + /* + * Allow injections to be ignored on devices w/o enforcement enabled + */ + if (!cs_process_global_enforcement()) { + ret = LOAD_SUCCESS; /* ignore error */ + } + } else { + got_code_signatures = TRUE; + } + + if (got_code_signatures) { + unsigned tainted = CS_VALIDATE_TAINTED; + boolean_t valid = FALSE; + vm_size_t off = 0; + + + if (cs_debug > 10) { + printf("validating initial pages of %s\n", vp->v_name); + } + + while (off < alloc_size && ret == LOAD_SUCCESS) { + tainted = CS_VALIDATE_TAINTED; + + valid = cs_validate_range(vp, + NULL, + file_offset + off, + (const void *)((uintptr_t)addr + off), + MIN(PAGE_SIZE, cmds_size), + &tainted); + if (!valid || (tainted & CS_VALIDATE_TAINTED)) { + if (cs_debug) { + printf("CODE SIGNING: %s[%d]: invalid initial page at offset %lld validated:%d tainted:%d csflags:0x%x\n", + vp->v_name, proc_getpid(p), (long long)(file_offset + off), valid, tainted, result->csflags); + } + if (cs_process_global_enforcement() || + (result->csflags & (CS_HARD | CS_KILL | CS_ENFORCEMENT))) { + ret = LOAD_FAILURE; + } + result->csflags &= ~CS_VALID; + } + off += PAGE_SIZE; + } + } + + break; +#if CONFIG_CODE_DECRYPTION + case LC_ENCRYPTION_INFO: + case LC_ENCRYPTION_INFO_64: + if (pass != 3) { + break; + } + ret = set_code_unprotect( + (struct encryption_info_command *) lcp, + addr, map, slide, vp, file_offset, + header->cputype, header->cpusubtype); + if (ret != LOAD_SUCCESS) { + os_reason_t load_failure_reason = OS_REASON_NULL; + printf("proc %d: set_code_unprotect() error %d " + "for file \"%s\"\n", + proc_getpid(p), ret, vp->v_name); + /* + * Don't let the app run if it's + * encrypted but we failed to set up the + * decrypter. If the keys are missing it will + * return LOAD_DECRYPTFAIL. + */ + if (ret == LOAD_DECRYPTFAIL) { + /* failed to load due to missing FP keys */ + proc_lock(p); + p->p_lflag |= P_LTERM_DECRYPTFAIL; + proc_unlock(p); + + KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_PROC, BSD_PROC_EXITREASON_CREATE) | DBG_FUNC_NONE, + proc_getpid(p), OS_REASON_EXEC, EXEC_EXIT_REASON_FAIRPLAY_DECRYPT, 0, 0); + load_failure_reason = os_reason_create(OS_REASON_EXEC, EXEC_EXIT_REASON_FAIRPLAY_DECRYPT); + } else { + KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_PROC, BSD_PROC_EXITREASON_CREATE) | DBG_FUNC_NONE, + proc_getpid(p), OS_REASON_EXEC, EXEC_EXIT_REASON_DECRYPT, 0, 0); + load_failure_reason = os_reason_create(OS_REASON_EXEC, EXEC_EXIT_REASON_DECRYPT); + } + + /* + * Don't signal the process if it was forked and in a partially constructed + * state as part of a spawn -- it will just be torn down when the exec fails. + */ + if (!spawn) { + assert(load_failure_reason != OS_REASON_NULL); + { + psignal_with_reason(current_proc(), SIGKILL, load_failure_reason); + load_failure_reason = OS_REASON_NULL; + } + } else { + os_reason_free(load_failure_reason); + load_failure_reason = OS_REASON_NULL; + } + } + break; +#endif + case LC_VERSION_MIN_IPHONEOS: + case LC_VERSION_MIN_MACOSX: + case LC_VERSION_MIN_WATCHOS: + case LC_VERSION_MIN_TVOS: { + struct version_min_command *vmc; + + if (depth != 1 || pass != 0) { + break; + } + vmc = (struct version_min_command *) lcp; + ret = load_version(vmc, &found_version_cmd, imgp, result); +#if XNU_TARGET_OS_OSX + if (ret == LOAD_SUCCESS) { + if (result->ip_platform == PLATFORM_IOS) { + vm_map_mark_alien(map); + } else { + assert(!vm_map_is_alien(map)); + } + } +#endif /* XNU_TARGET_OS_OSX */ + break; + } + case LC_BUILD_VERSION: { + if (depth != 1 || pass != 0) { + break; + } + struct build_version_command* bvc = (struct build_version_command*)lcp; + if (bvc->cmdsize < sizeof(*bvc)) { + ret = LOAD_BADMACHO; + break; + } + if (found_version_cmd == TRUE) { + ret = LOAD_BADMACHO; + break; + } + result->ip_platform = bvc->platform; + result->lr_sdk = bvc->sdk; + result->lr_min_sdk = bvc->minos; + found_version_cmd = TRUE; +#if XNU_TARGET_OS_OSX + if (result->ip_platform == PLATFORM_IOS) { + vm_map_mark_alien(map); + } else { + assert(!vm_map_is_alien(map)); + } +#endif /* XNU_TARGET_OS_OSX */ + break; + } + default: + /* Other commands are ignored by the kernel */ + ret = LOAD_SUCCESS; + break; + } + if (ret != LOAD_SUCCESS) { + break; + } + } + if (ret != LOAD_SUCCESS) { + break; + } + } + + if (ret == LOAD_SUCCESS) { + if (!got_code_signatures && cs_process_global_enforcement()) { + ret = LOAD_FAILURE; + } + + /* Make sure if we need dyld, we got it */ + if (result->needs_dynlinker && !dlp) { + ret = LOAD_FAILURE; + } + + if ((ret == LOAD_SUCCESS) && (dlp != 0)) { + /* + * load the dylinker, and slide it by the independent DYLD ASLR + * offset regardless of the PIE-ness of the main binary. + */ + ret = load_dylinker(dlp, header->cputype, map, thread, depth, + dyld_aslr_offset, result, imgp); + } + +#if CONFIG_ROSETTA + if ((ret == LOAD_SUCCESS) && (depth == 1) && (imgp->ip_flags & IMGPF_ROSETTA)) { + ret = load_rosetta(map, thread, result, imgp); + if (ret == LOAD_SUCCESS) { + if (result->user_stack_alloc_size != 0) { + // If a stack allocation is required then add a 4gb gap after the main + // binary/dyld for the worst case static translation size. + mach_vm_size_t reserved_aot_size = 0x100000000; + vm_map_offset_t mask = vm_map_page_mask(map); + + mach_vm_address_t vm_end; + if (dlp != 0) { + vm_end = vm_map_round_page(result->dynlinker_max_vm_addr, mask); + } else { + vm_end = vm_map_round_page(result->max_vm_addr, mask); + } + + mach_vm_size_t user_stack_size = vm_map_round_page(result->user_stack_alloc_size, mask); + result->user_stack = vm_map_round_page(vm_end + user_stack_size + reserved_aot_size + slide, mask); + } + } + } +#endif + + if ((ret == LOAD_SUCCESS) && (depth == 1)) { + if (result->thread_count == 0) { + ret = LOAD_FAILURE; + } +#if CONFIG_ENFORCE_SIGNED_CODE + if (!(result->csflags & CS_NO_UNTRUSTED_HELPERS)) { + ret = LOAD_FAILURE; + } +#endif + } + } + + if (ret == LOAD_BADMACHO && found_xhdr) { + ret = LOAD_BADMACHO_UPX; + } + + kfree_data(addr, alloc_size); + + return ret; +} + +load_return_t +validate_potential_simulator_binary( + cpu_type_t exectype __unused, + struct image_params *imgp __unused, + off_t file_offset __unused, + off_t macho_size __unused) +{ +#if __x86_64__ + /* Allow 32 bit exec only for simulator binaries */ + if (bootarg_no32exec && imgp != NULL && exectype == CPU_TYPE_X86) { + if (imgp->ip_simulator_binary == IMGPF_SB_DEFAULT) { + boolean_t simulator_binary = check_if_simulator_binary(imgp, file_offset, macho_size); + imgp->ip_simulator_binary = simulator_binary ? IMGPF_SB_TRUE : IMGPF_SB_FALSE; + } + + if (imgp->ip_simulator_binary != IMGPF_SB_TRUE) { + return LOAD_BADARCH; + } + } +#endif + return LOAD_SUCCESS; +} + +#if __x86_64__ +static boolean_t +check_if_simulator_binary( + struct image_params *imgp, + off_t file_offset, + off_t macho_size) +{ + struct mach_header *header; + char *ip_vdata = NULL; + kauth_cred_t cred = NULL; + uint32_t ncmds; + struct load_command *lcp; + boolean_t simulator_binary = FALSE; + void * addr = NULL; + vm_size_t alloc_size, cmds_size; + size_t offset; + proc_t p = current_proc(); /* XXXX */ + int error; + int resid = 0; + size_t mach_header_sz = sizeof(struct mach_header); + + + cred = kauth_cred_proc_ref(p); + + /* Allocate page to copyin mach header */ + ip_vdata = kalloc_data(PAGE_SIZE, Z_WAITOK | Z_ZERO); + if (ip_vdata == NULL) { + goto bad; + } + + /* Read the Mach-O header */ + error = vn_rdwr(UIO_READ, imgp->ip_vp, ip_vdata, + PAGE_SIZE, file_offset, + UIO_SYSSPACE, (IO_UNIT | IO_NODELOCKED), + cred, &resid, p); + if (error) { + goto bad; + } + + header = (struct mach_header *)ip_vdata; + + if (header->magic == MH_MAGIC_64 || + header->magic == MH_CIGAM_64) { + mach_header_sz = sizeof(struct mach_header_64); + } + + /* ensure header + sizeofcmds falls within the file */ + if (os_add_overflow(mach_header_sz, header->sizeofcmds, &cmds_size) || + (off_t)cmds_size > macho_size || + round_page_overflow(cmds_size, &alloc_size) || + alloc_size > INT_MAX) { + goto bad; + } + + /* + * Map the load commands into kernel memory. + */ + addr = kalloc_data(alloc_size, Z_WAITOK); + if (addr == NULL) { + goto bad; + } + + error = vn_rdwr(UIO_READ, imgp->ip_vp, addr, (int)alloc_size, file_offset, + UIO_SYSSPACE, IO_NODELOCKED, cred, &resid, p); + if (error) { + goto bad; + } + + if (resid) { + /* We must be able to read in as much as the mach_header indicated */ + goto bad; + } + + /* + * Loop through each of the load_commands indicated by the + * Mach-O header; if an absurd value is provided, we just + * run off the end of the reserved section by incrementing + * the offset too far, so we are implicitly fail-safe. + */ + offset = mach_header_sz; + ncmds = header->ncmds; + + while (ncmds--) { + /* ensure enough space for a minimal load command */ + if (offset + sizeof(struct load_command) > cmds_size) { + break; + } + + /* + * Get a pointer to the command. + */ + lcp = (struct load_command *)((uintptr_t)addr + offset); + + /* + * Perform prevalidation of the struct load_command + * before we attempt to use its contents. Invalid + * values are ones which result in an overflow, or + * which can not possibly be valid commands, or which + * straddle or exist past the reserved section at the + * start of the image. + */ + if (os_add_overflow(offset, lcp->cmdsize, &offset) || + lcp->cmdsize < sizeof(struct load_command) || + offset > cmds_size) { + break; + } + + /* Check if its a simulator binary. */ + switch (lcp->cmd) { + case LC_VERSION_MIN_WATCHOS: + simulator_binary = TRUE; + break; + + case LC_BUILD_VERSION: { + struct build_version_command *bvc; + + bvc = (struct build_version_command *) lcp; + if (bvc->cmdsize < sizeof(*bvc)) { + /* unsafe to use this command struct if cmdsize + * validated above is too small for it to fit */ + break; + } + if (bvc->platform == PLATFORM_IOSSIMULATOR || + bvc->platform == PLATFORM_WATCHOSSIMULATOR) { + simulator_binary = TRUE; + } + + break; + } + + case LC_VERSION_MIN_IPHONEOS: { + simulator_binary = TRUE; + break; + } + + default: + /* ignore other load commands */ + break; + } + + if (simulator_binary == TRUE) { + break; + } + } + +bad: + if (ip_vdata) { + kfree_data(ip_vdata, PAGE_SIZE); + } + + if (cred) { + kauth_cred_unref(&cred); + } + + if (addr) { + kfree_data(addr, alloc_size); + } + + return simulator_binary; +} +#endif /* __x86_64__ */ + +#if CONFIG_CODE_DECRYPTION + +#define APPLE_UNPROTECTED_HEADER_SIZE (3 * 4096) + +static load_return_t +unprotect_dsmos_segment( + uint64_t file_off, + uint64_t file_size, + struct vnode *vp, + off_t macho_offset, + vm_map_t map, + vm_map_offset_t map_addr, + vm_map_size_t map_size) +{ + kern_return_t kr; + uint64_t slice_off; + + /* + * The first APPLE_UNPROTECTED_HEADER_SIZE bytes (from offset 0 of + * this part of a Universal binary) are not protected... + * The rest needs to be "transformed". + */ + slice_off = file_off - macho_offset; + if (slice_off <= APPLE_UNPROTECTED_HEADER_SIZE && + slice_off + file_size <= APPLE_UNPROTECTED_HEADER_SIZE) { + /* it's all unprotected, nothing to do... */ + kr = KERN_SUCCESS; + } else { + if (slice_off <= APPLE_UNPROTECTED_HEADER_SIZE) { + /* + * We start mapping in the unprotected area. + * Skip the unprotected part... + */ + uint64_t delta_file; + vm_map_offset_t delta_map; + + delta_file = (uint64_t)APPLE_UNPROTECTED_HEADER_SIZE; + delta_file -= slice_off; + if (os_convert_overflow(delta_file, &delta_map)) { + return LOAD_BADMACHO; + } + if (os_add_overflow(map_addr, delta_map, &map_addr)) { + return LOAD_BADMACHO; + } + if (os_sub_overflow(map_size, delta_map, &map_size)) { + return LOAD_BADMACHO; + } + } + /* ... transform the rest of the mapping. */ + struct pager_crypt_info crypt_info; + crypt_info.page_decrypt = dsmos_page_transform; + crypt_info.crypt_ops = NULL; + crypt_info.crypt_end = NULL; +#pragma unused(vp, macho_offset) + crypt_info.crypt_ops = (void *)0x2e69cf40; + vm_map_offset_t crypto_backing_offset; + crypto_backing_offset = -1; /* i.e. use map entry's offset */ +#if VM_MAP_DEBUG_APPLE_PROTECT + if (vm_map_debug_apple_protect) { + struct proc *p; + p = current_proc(); + printf("APPLE_PROTECT: %d[%s] map %p " + "[0x%llx:0x%llx] %s(%s)\n", + proc_getpid(p), p->p_comm, map, + (uint64_t) map_addr, + (uint64_t) (map_addr + map_size), + __FUNCTION__, vp->v_name); + } +#endif /* VM_MAP_DEBUG_APPLE_PROTECT */ + + /* The DSMOS pager can only be used by apple signed code */ + struct cs_blob * blob = csvnode_get_blob(vp, file_off); + if (blob == NULL || !blob->csb_platform_binary || blob->csb_platform_path) { + return LOAD_FAILURE; + } + + kr = vm_map_apple_protected(map, + map_addr, + map_addr + map_size, + crypto_backing_offset, + &crypt_info, + CRYPTID_APP_ENCRYPTION); + } + + if (kr != KERN_SUCCESS) { + return LOAD_FAILURE; + } + return LOAD_SUCCESS; +} +#else /* CONFIG_CODE_DECRYPTION */ +static load_return_t +unprotect_dsmos_segment( + __unused uint64_t file_off, + __unused uint64_t file_size, + __unused struct vnode *vp, + __unused off_t macho_offset, + __unused vm_map_t map, + __unused vm_map_offset_t map_addr, + __unused vm_map_size_t map_size) +{ + return LOAD_SUCCESS; +} +#endif /* CONFIG_CODE_DECRYPTION */ + + +/* + * map_segment: + * Maps a Mach-O segment, taking care of mis-alignment (wrt the system + * page size) issues. + * + * The mapping might result in 1, 2 or 3 map entries: + * 1. for the first page, which could be overlap with the previous + * mapping, + * 2. for the center (if applicable), + * 3. for the last page, which could overlap with the next mapping. + * + * For each of those map entries, we might have to interpose a + * "fourk_pager" to deal with mis-alignment wrt the system page size, + * either in the mapping address and/or size or the file offset and/or + * size. + * The "fourk_pager" itself would be mapped with proper alignment + * wrt the system page size and would then be populated with the + * information about the intended mapping, with a "4KB" granularity. + */ +static kern_return_t +map_segment( + vm_map_t map, + vm_map_offset_t vm_start, + vm_map_offset_t vm_end, + memory_object_control_t control, + vm_map_offset_t file_start, + vm_map_offset_t file_end, + vm_prot_t initprot, + vm_prot_t maxprot, + load_result_t *result) +{ + vm_map_offset_t cur_offset, cur_start, cur_end; + kern_return_t ret; + vm_map_offset_t effective_page_mask; + vm_map_kernel_flags_t vmk_flags, cur_vmk_flags; + + if (vm_end < vm_start || + file_end < file_start) { + return LOAD_BADMACHO; + } + if (vm_end == vm_start || + file_end == file_start) { + /* nothing to map... */ + return LOAD_SUCCESS; + } + + effective_page_mask = vm_map_page_mask(map); + + vmk_flags = VM_MAP_KERNEL_FLAGS_FIXED(); + if (vm_map_page_aligned(vm_start, effective_page_mask) && + vm_map_page_aligned(vm_end, effective_page_mask) && + vm_map_page_aligned(file_start, effective_page_mask) && + vm_map_page_aligned(file_end, effective_page_mask)) { + /* all page-aligned and map-aligned: proceed */ + } else { +#if __arm64__ + /* use an intermediate "4K" pager */ + vmk_flags.vmkf_fourk = TRUE; +#else /* __arm64__ */ + panic("map_segment: unexpected mis-alignment " + "vm[0x%llx:0x%llx] file[0x%llx:0x%llx]\n", + (uint64_t) vm_start, + (uint64_t) vm_end, + (uint64_t) file_start, + (uint64_t) file_end); +#endif /* __arm64__ */ + } + + cur_offset = 0; + cur_start = vm_start; + cur_end = vm_start; +#if __arm64__ + if (!vm_map_page_aligned(vm_start, effective_page_mask)) { + /* one 4K pager for the 1st page */ + cur_end = vm_map_round_page(cur_start, effective_page_mask); + if (cur_end > vm_end) { + cur_end = vm_start + (file_end - file_start); + } + if (control != MEMORY_OBJECT_CONTROL_NULL) { + /* no copy-on-read for mapped binaries */ + vmk_flags.vmkf_no_copy_on_read = 1; + ret = vm_map_enter_mem_object_control( + map, + &cur_start, + cur_end - cur_start, + (mach_vm_offset_t)0, + vmk_flags, + control, + file_start + cur_offset, + TRUE, /* copy */ + initprot, maxprot, + VM_INHERIT_DEFAULT); + } else { + ret = vm_map_enter_mem_object( + map, + &cur_start, + cur_end - cur_start, + (mach_vm_offset_t)0, + vmk_flags, + IPC_PORT_NULL, + 0, /* offset */ + TRUE, /* copy */ + initprot, maxprot, + VM_INHERIT_DEFAULT); + } + if (ret != KERN_SUCCESS) { + return LOAD_NOSPACE; + } + cur_offset += cur_end - cur_start; + } +#endif /* __arm64__ */ + if (cur_end >= vm_start + (file_end - file_start)) { + /* all mapped: done */ + goto done; + } + if (vm_map_round_page(cur_end, effective_page_mask) >= + vm_map_trunc_page(vm_start + (file_end - file_start), + effective_page_mask)) { + /* no middle */ + } else { + cur_start = cur_end; + if ((vm_start & effective_page_mask) != + (file_start & effective_page_mask)) { + /* one 4K pager for the middle */ + cur_vmk_flags = vmk_flags; + } else { + /* regular mapping for the middle */ + cur_vmk_flags = VM_MAP_KERNEL_FLAGS_FIXED(); + } + +#if !defined(XNU_TARGET_OS_OSX) + (void) result; +#else /* !defined(XNU_TARGET_OS_OSX) */ + /* + * This process doesn't have its new csflags (from + * the image being loaded) yet, so tell VM to override the + * current process's CS_ENFORCEMENT for this mapping. + */ + if (result->csflags & CS_ENFORCEMENT) { + cur_vmk_flags.vmkf_cs_enforcement = TRUE; + } else { + cur_vmk_flags.vmkf_cs_enforcement = FALSE; + } + cur_vmk_flags.vmkf_cs_enforcement_override = TRUE; +#endif /* !defined(XNU_TARGET_OS_OSX) */ + + if (result->is_rosetta && (initprot & VM_PROT_EXECUTE) == VM_PROT_EXECUTE) { + cur_vmk_flags.vmkf_translated_allow_execute = TRUE; + } + + cur_end = vm_map_trunc_page(vm_start + (file_end - + file_start), + effective_page_mask); + if (control != MEMORY_OBJECT_CONTROL_NULL) { + /* no copy-on-read for mapped binaries */ + cur_vmk_flags.vmkf_no_copy_on_read = 1; + ret = vm_map_enter_mem_object_control( + map, + &cur_start, + cur_end - cur_start, + (mach_vm_offset_t)0, + cur_vmk_flags, + control, + file_start + cur_offset, + TRUE, /* copy */ + initprot, maxprot, + VM_INHERIT_DEFAULT); + } else { + ret = vm_map_enter_mem_object( + map, + &cur_start, + cur_end - cur_start, + (mach_vm_offset_t)0, + cur_vmk_flags, + IPC_PORT_NULL, + 0, /* offset */ + TRUE, /* copy */ + initprot, maxprot, + VM_INHERIT_DEFAULT); + } + if (ret != KERN_SUCCESS) { + return LOAD_NOSPACE; + } + cur_offset += cur_end - cur_start; + } + if (cur_end >= vm_start + (file_end - file_start)) { + /* all mapped: done */ + goto done; + } + cur_start = cur_end; +#if __arm64__ + if (!vm_map_page_aligned(vm_start + (file_end - file_start), + effective_page_mask)) { + /* one 4K pager for the last page */ + cur_end = vm_start + (file_end - file_start); + if (control != MEMORY_OBJECT_CONTROL_NULL) { + /* no copy-on-read for mapped binaries */ + vmk_flags.vmkf_no_copy_on_read = 1; + ret = vm_map_enter_mem_object_control( + map, + &cur_start, + cur_end - cur_start, + (mach_vm_offset_t)0, + vmk_flags, + control, + file_start + cur_offset, + TRUE, /* copy */ + initprot, maxprot, + VM_INHERIT_DEFAULT); + } else { + ret = vm_map_enter_mem_object( + map, + &cur_start, + cur_end - cur_start, + (mach_vm_offset_t)0, + vmk_flags, + IPC_PORT_NULL, + 0, /* offset */ + TRUE, /* copy */ + initprot, maxprot, + VM_INHERIT_DEFAULT); + } + if (ret != KERN_SUCCESS) { + return LOAD_NOSPACE; + } + cur_offset += cur_end - cur_start; + } +#endif /* __arm64__ */ +done: + assert(cur_end >= vm_start + (file_end - file_start)); + return LOAD_SUCCESS; +} + +static +load_return_t +load_segment( + struct load_command *lcp, + uint32_t filetype, + void * control, + off_t pager_offset, + off_t macho_size, + struct vnode *vp, + vm_map_t map, + int64_t slide, + load_result_t *result, + struct image_params *imgp) +{ + struct segment_command_64 segment_command, *scp; + kern_return_t ret; + vm_map_size_t delta_size; + vm_prot_t initprot; + vm_prot_t maxprot; + size_t segment_command_size, total_section_size, + single_section_size; + uint64_t file_offset, file_size; + vm_map_offset_t vm_offset; + size_t vm_size; + vm_map_offset_t vm_start, vm_end, vm_end_aligned; + vm_map_offset_t file_start, file_end; + kern_return_t kr; + boolean_t verbose; + vm_map_size_t effective_page_size; + vm_map_offset_t effective_page_mask; +#if __arm64__ + boolean_t fourk_align; +#endif /* __arm64__ */ + + (void)imgp; + + effective_page_size = vm_map_page_size(map); + effective_page_mask = vm_map_page_mask(map); + + verbose = FALSE; + if (LC_SEGMENT_64 == lcp->cmd) { + segment_command_size = sizeof(struct segment_command_64); + single_section_size = sizeof(struct section_64); +#if __arm64__ + /* 64-bit binary: should already be 16K-aligned */ + fourk_align = FALSE; + + if (vm_map_page_shift(map) == FOURK_PAGE_SHIFT && + PAGE_SHIFT != FOURK_PAGE_SHIFT) { + fourk_align = TRUE; + verbose = TRUE; + } +#endif /* __arm64__ */ + } else { + segment_command_size = sizeof(struct segment_command); + single_section_size = sizeof(struct section); +#if __arm64__ + /* 32-bit binary: might need 4K-alignment */ + if (effective_page_size != FOURK_PAGE_SIZE) { + /* not using 4K page size: need fourk_pager */ + fourk_align = TRUE; + verbose = TRUE; + } else { + /* using 4K page size: no need for re-alignment */ + fourk_align = FALSE; + } +#endif /* __arm64__ */ + } + if (lcp->cmdsize < segment_command_size) { + DEBUG4K_ERROR("LOAD_BADMACHO cmdsize %d < %zu\n", lcp->cmdsize, segment_command_size); + return LOAD_BADMACHO; + } + total_section_size = lcp->cmdsize - segment_command_size; + + if (LC_SEGMENT_64 == lcp->cmd) { + scp = (struct segment_command_64 *)lcp; + } else { + scp = &segment_command; + widen_segment_command((struct segment_command *)lcp, scp); + } + + if (verbose) { + MACHO_PRINTF(("+++ load_segment %s " + "vm[0x%llx:0x%llx] file[0x%llx:0x%llx] " + "prot %d/%d flags 0x%x\n", + scp->segname, + (uint64_t)(slide + scp->vmaddr), + (uint64_t)(slide + scp->vmaddr + scp->vmsize), + pager_offset + scp->fileoff, + pager_offset + scp->fileoff + scp->filesize, + scp->initprot, + scp->maxprot, + scp->flags)); + } + + /* + * Make sure what we get from the file is really ours (as specified + * by macho_size). + */ + if (scp->fileoff + scp->filesize < scp->fileoff || + scp->fileoff + scp->filesize > (uint64_t)macho_size) { + DEBUG4K_ERROR("LOAD_BADMACHO fileoff 0x%llx filesize 0x%llx macho_size 0x%llx\n", scp->fileoff, scp->filesize, (uint64_t)macho_size); + return LOAD_BADMACHO; + } + /* + * Ensure that the number of sections specified would fit + * within the load command size. + */ + if (total_section_size / single_section_size < scp->nsects) { + DEBUG4K_ERROR("LOAD_BADMACHO 0x%zx 0x%zx %d\n", total_section_size, single_section_size, scp->nsects); + return LOAD_BADMACHO; + } + /* + * Make sure the segment is page-aligned in the file. + */ + if (os_add_overflow(pager_offset, scp->fileoff, &file_offset)) { + DEBUG4K_ERROR("LOAD_BADMACHO file_offset: 0x%llx + 0x%llx\n", pager_offset, scp->fileoff); + return LOAD_BADMACHO; + } + file_size = scp->filesize; +#if __arm64__ + if (fourk_align) { + if ((file_offset & FOURK_PAGE_MASK) != 0) { + /* + * we can't mmap() it if it's not at least 4KB-aligned + * in the file + */ + DEBUG4K_ERROR("LOAD_BADMACHO file_offset 0x%llx\n", file_offset); + return LOAD_BADMACHO; + } + } else +#endif /* __arm64__ */ + if ((file_offset & PAGE_MASK_64) != 0 || + /* we can't mmap() it if it's not page-aligned in the file */ + (file_offset & vm_map_page_mask(map)) != 0) { + /* + * The 1st test would have failed if the system's page size + * was what this process believe is the page size, so let's + * fail here too for the sake of consistency. + */ + DEBUG4K_ERROR("LOAD_BADMACHO file_offset 0x%llx\n", file_offset); + return LOAD_BADMACHO; + } + + /* + * If we have a code signature attached for this slice + * require that the segments are within the signed part + * of the file. + */ + if (result->cs_end_offset && + result->cs_end_offset < (off_t)scp->fileoff && + result->cs_end_offset - scp->fileoff < scp->filesize) { + if (cs_debug) { + printf("section outside code signature\n"); + } + DEBUG4K_ERROR("LOAD_BADMACHO end_offset 0x%llx fileoff 0x%llx filesize 0x%llx\n", result->cs_end_offset, scp->fileoff, scp->filesize); + return LOAD_BADMACHO; + } + + if (os_add_overflow(scp->vmaddr, slide, &vm_offset)) { + if (cs_debug) { + printf("vmaddr too large\n"); + } + DEBUG4K_ERROR("LOAD_BADMACHO vmaddr 0x%llx slide 0x%llx vm_offset 0x%llx\n", scp->vmaddr, slide, (uint64_t)vm_offset); + return LOAD_BADMACHO; + } + + if (scp->vmsize > SIZE_MAX) { + DEBUG4K_ERROR("LOAD_BADMACHO vmsize 0x%llx\n", scp->vmsize); + return LOAD_BADMACHO; + } + + vm_size = (size_t)scp->vmsize; + + if (vm_size == 0) { + return LOAD_SUCCESS; + } + if (scp->vmaddr == 0 && + file_size == 0 && + vm_size != 0 && + (scp->initprot & VM_PROT_ALL) == VM_PROT_NONE && + (scp->maxprot & VM_PROT_ALL) == VM_PROT_NONE) { + if (map == VM_MAP_NULL) { + return LOAD_SUCCESS; + } + + /* + * For PIE, extend page zero rather than moving it. Extending + * page zero keeps early allocations from falling predictably + * between the end of page zero and the beginning of the first + * slid segment. + */ + /* + * This is a "page zero" segment: it starts at address 0, + * is not mapped from the binary file and is not accessible. + * User-space should never be able to access that memory, so + * make it completely off limits by raising the VM map's + * minimum offset. + */ + vm_end = (vm_map_offset_t)(vm_offset + vm_size); + if (vm_end < vm_offset) { + DEBUG4K_ERROR("LOAD_BADMACHO vm_end 0x%llx vm_offset 0x%llx vm_size 0x%llx\n", (uint64_t)vm_end, (uint64_t)vm_offset, (uint64_t)vm_size); + return LOAD_BADMACHO; + } + + if (verbose) { + MACHO_PRINTF(("++++++ load_segment: " + "page_zero up to 0x%llx\n", + (uint64_t) vm_end)); + } +#if __arm64__ + if (fourk_align) { + /* raise min_offset as much as page-alignment allows */ + vm_end_aligned = vm_map_trunc_page(vm_end, + effective_page_mask); + } else +#endif /* __arm64__ */ + { + vm_end = vm_map_round_page(vm_end, + PAGE_MASK_64); + vm_end_aligned = vm_end; + } + ret = vm_map_raise_min_offset(map, + vm_end_aligned); +#if __arm64__ + if (ret == 0 && + vm_end > vm_end_aligned) { + /* use fourk_pager to map the rest of pagezero */ + assert(fourk_align); + ret = vm_map_enter_mem_object( + map, + &vm_end_aligned, + vm_end - vm_end_aligned, + (mach_vm_offset_t) 0, /* mask */ + VM_MAP_KERNEL_FLAGS_FIXED(.vmkf_fourk = true), + IPC_PORT_NULL, + 0, + FALSE, /* copy */ + (scp->initprot & VM_PROT_ALL), + (scp->maxprot & VM_PROT_ALL), + VM_INHERIT_DEFAULT); + } +#endif /* __arm64__ */ + + if (ret != KERN_SUCCESS) { + DEBUG4K_ERROR("LOAD_FAILURE ret 0x%x\n", ret); + return LOAD_FAILURE; + } + return LOAD_SUCCESS; + } else { +#if !defined(XNU_TARGET_OS_OSX) + /* not PAGEZERO: should not be mapped at address 0 */ + if (filetype != MH_DYLINKER && (imgp->ip_flags & IMGPF_ROSETTA) == 0 && scp->vmaddr == 0) { + DEBUG4K_ERROR("LOAD_BADMACHO filetype %d vmaddr 0x%llx\n", filetype, scp->vmaddr); + return LOAD_BADMACHO; + } +#endif /* !defined(XNU_TARGET_OS_OSX) */ + } + +#if __arm64__ + if (fourk_align) { + /* 4K-align */ + file_start = vm_map_trunc_page(file_offset, + FOURK_PAGE_MASK); + file_end = vm_map_round_page(file_offset + file_size, + FOURK_PAGE_MASK); + vm_start = vm_map_trunc_page(vm_offset, + FOURK_PAGE_MASK); + vm_end = vm_map_round_page(vm_offset + vm_size, + FOURK_PAGE_MASK); + + if (file_offset - file_start > FOURK_PAGE_MASK || + file_end - file_offset - file_size > FOURK_PAGE_MASK) { + DEBUG4K_ERROR("LOAD_BADMACHO file_start / file_size wrap " + "[0x%llx:0x%llx] -> [0x%llx:0x%llx]\n", + file_offset, + file_offset + file_size, + (uint64_t) file_start, + (uint64_t) file_end); + return LOAD_BADMACHO; + } + + if (!strncmp(scp->segname, "__LINKEDIT", 11) && + page_aligned(file_start) && + vm_map_page_aligned(file_start, vm_map_page_mask(map)) && + page_aligned(vm_start) && + vm_map_page_aligned(vm_start, vm_map_page_mask(map))) { + /* XXX last segment: ignore mis-aligned tail */ + file_end = vm_map_round_page(file_end, + effective_page_mask); + vm_end = vm_map_round_page(vm_end, + effective_page_mask); + } + } else +#endif /* __arm64__ */ + { + file_start = vm_map_trunc_page(file_offset, + effective_page_mask); + file_end = vm_map_round_page(file_offset + file_size, + effective_page_mask); + vm_start = vm_map_trunc_page(vm_offset, + effective_page_mask); + vm_end = vm_map_round_page(vm_offset + vm_size, + effective_page_mask); + + if (file_offset - file_start > effective_page_mask || + file_end - file_offset - file_size > effective_page_mask) { + DEBUG4K_ERROR("LOAD_BADMACHO file_start / file_size wrap " + "[0x%llx:0x%llx] -> [0x%llx:0x%llx]\n", + file_offset, + file_offset + file_size, + (uint64_t) file_start, + (uint64_t) file_end); + return LOAD_BADMACHO; + } + } + + if (vm_start < result->min_vm_addr) { + result->min_vm_addr = vm_start; + } + if (vm_end > result->max_vm_addr) { + result->max_vm_addr = vm_end; + } + + if (map == VM_MAP_NULL) { + return LOAD_SUCCESS; + } + + if (scp->flags & SG_READ_ONLY) { + /* + * Record the VM start/end of a segment which should + * be RO after fixups. Only __DATA_CONST should + * have this flag. + */ + if (result->ro_vm_start != MACH_VM_MIN_ADDRESS || + result->ro_vm_end != MACH_VM_MIN_ADDRESS) { + DEBUG4K_ERROR("LOAD_BADMACHO segment flags [%x] " + "multiple segments with SG_READ_ONLY flag\n", + scp->flags); + return LOAD_BADMACHO; + } + + result->ro_vm_start = vm_start; + result->ro_vm_end = vm_end; + } + + if (vm_size > 0) { + initprot = (scp->initprot) & VM_PROT_ALL; + maxprot = (scp->maxprot) & VM_PROT_ALL; + /* + * Map a copy of the file into the address space. + */ + if (verbose) { + MACHO_PRINTF(("++++++ load_segment: " + "mapping at vm [0x%llx:0x%llx] of " + "file [0x%llx:0x%llx]\n", + (uint64_t) vm_start, + (uint64_t) vm_end, + (uint64_t) file_start, + (uint64_t) file_end)); + } + ret = map_segment(map, + vm_start, + vm_end, + control, + file_start, + file_end, + initprot, + maxprot, + result); + if (ret) { + DEBUG4K_ERROR("LOAD_NOSPACE start 0x%llx end 0x%llx ret 0x%x\n", (uint64_t)vm_start, (uint64_t)vm_end, ret); + return LOAD_NOSPACE; + } + +#if FIXME + /* + * If the file didn't end on a page boundary, + * we need to zero the leftover. + */ + delta_size = map_size - scp->filesize; + if (delta_size > 0) { + void *tmp = kalloc_data(delta_size, Z_WAITOK | Z_ZERO); + int rc; + + if (tmp == NULL) { + DEBUG4K_ERROR("LOAD_RESOURCE delta_size 0x%llx ret 0x%x\n", delta_size, ret); + return LOAD_RESOURCE; + } + + rc = copyout(tmp, map_addr + scp->filesize, delta_size); + kfree_data(tmp, delta_size); + + if (rc) { + DEBUG4K_ERROR("LOAD_FAILURE copyout 0x%llx 0x%llx\n", map_addr + scp->filesize, delta_size); + return LOAD_FAILURE; + } + } +#endif /* FIXME */ + } + + /* + * If the virtual size of the segment is greater + * than the size from the file, we need to allocate + * zero fill memory for the rest. + */ + if ((vm_end - vm_start) > (file_end - file_start)) { + delta_size = (vm_end - vm_start) - (file_end - file_start); + } else { + delta_size = 0; + } + if (delta_size > 0) { + vm_map_offset_t tmp_start; + vm_map_offset_t tmp_end; + + if (os_add_overflow(vm_start, file_end - file_start, &tmp_start)) { + DEBUG4K_ERROR("LOAD_NOSPACE tmp_start: 0x%llx + 0x%llx\n", (uint64_t)vm_start, (uint64_t)(file_end - file_start)); + return LOAD_NOSPACE; + } + + if (os_add_overflow(tmp_start, delta_size, &tmp_end)) { + DEBUG4K_ERROR("LOAD_NOSPACE tmp_end: 0x%llx + 0x%llx\n", (uint64_t)tmp_start, (uint64_t)delta_size); + return LOAD_NOSPACE; + } + + if (verbose) { + MACHO_PRINTF(("++++++ load_segment: " + "delta mapping vm [0x%llx:0x%llx]\n", + (uint64_t) tmp_start, + (uint64_t) tmp_end)); + } + kr = map_segment(map, + tmp_start, + tmp_end, + MEMORY_OBJECT_CONTROL_NULL, + 0, + delta_size, + scp->initprot, + scp->maxprot, + result); + if (kr != KERN_SUCCESS) { + DEBUG4K_ERROR("LOAD_NOSPACE 0x%llx 0x%llx kr 0x%x\n", (unsigned long long)tmp_start, (uint64_t)delta_size, kr); + return LOAD_NOSPACE; + } + } + + if ((scp->fileoff == 0) && (scp->filesize != 0)) { + result->mach_header = vm_offset; + } + + if (scp->flags & SG_PROTECTED_VERSION_1) { + ret = unprotect_dsmos_segment(file_start, + file_end - file_start, + vp, + pager_offset, + map, + vm_start, + vm_end - vm_start); + if (ret != LOAD_SUCCESS) { + DEBUG4K_ERROR("unprotect 0x%llx 0x%llx ret %d \n", (uint64_t)vm_start, (uint64_t)vm_end, ret); + return ret; + } + } else { + ret = LOAD_SUCCESS; + } + + if (LOAD_SUCCESS == ret && + filetype == MH_DYLINKER && + result->all_image_info_addr == MACH_VM_MIN_ADDRESS) { + note_all_image_info_section(scp, + LC_SEGMENT_64 == lcp->cmd, + single_section_size, + ((const char *)lcp + + segment_command_size), + slide, + result); + } + + if (result->entry_point != MACH_VM_MIN_ADDRESS) { + if ((result->entry_point >= vm_offset) && (result->entry_point < (vm_offset + vm_size))) { + if ((scp->initprot & (VM_PROT_READ | VM_PROT_EXECUTE)) == (VM_PROT_READ | VM_PROT_EXECUTE)) { + result->validentry = 1; + } else { + /* right range but wrong protections, unset if previously validated */ + result->validentry = 0; + } + } + } + + if (ret != LOAD_SUCCESS && verbose) { + DEBUG4K_ERROR("ret %d\n", ret); + } + return ret; +} + +static +load_return_t +load_uuid( + struct uuid_command *uulp, + char *command_end, + load_result_t *result + ) +{ + /* + * We need to check the following for this command: + * - The command size should be atleast the size of struct uuid_command + * - The UUID part of the command should be completely within the mach-o header + */ + + if ((uulp->cmdsize < sizeof(struct uuid_command)) || + (((char *)uulp + sizeof(struct uuid_command)) > command_end)) { + return LOAD_BADMACHO; + } + + memcpy(&result->uuid[0], &uulp->uuid[0], sizeof(result->uuid)); + return LOAD_SUCCESS; +} + +static +load_return_t +load_version( + struct version_min_command *vmc, + boolean_t *found_version_cmd, + struct image_params *imgp __unused, + load_result_t *result + ) +{ + uint32_t platform = 0; + uint32_t sdk; + uint32_t min_sdk; + + if (vmc->cmdsize < sizeof(*vmc)) { + return LOAD_BADMACHO; + } + if (*found_version_cmd == TRUE) { + return LOAD_BADMACHO; + } + *found_version_cmd = TRUE; + sdk = vmc->sdk; + min_sdk = vmc->version; + switch (vmc->cmd) { + case LC_VERSION_MIN_MACOSX: + platform = PLATFORM_MACOS; + break; +#if __x86_64__ /* __x86_64__ */ + case LC_VERSION_MIN_IPHONEOS: + platform = PLATFORM_IOSSIMULATOR; + break; + case LC_VERSION_MIN_WATCHOS: + platform = PLATFORM_WATCHOSSIMULATOR; + break; + case LC_VERSION_MIN_TVOS: + platform = PLATFORM_TVOSSIMULATOR; + break; +#else + case LC_VERSION_MIN_IPHONEOS: { +#if __arm64__ + if (vmc->sdk < (12 << 16)) { + /* app built with a pre-iOS12 SDK: apply legacy footprint mitigation */ + result->legacy_footprint = TRUE; + } +#endif /* __arm64__ */ + platform = PLATFORM_IOS; + break; + } + case LC_VERSION_MIN_WATCHOS: + platform = PLATFORM_WATCHOS; + break; + case LC_VERSION_MIN_TVOS: + platform = PLATFORM_TVOS; + break; +#endif /* __x86_64__ */ + /* All LC_VERSION_MIN_* load commands are legacy and we will not be adding any more */ + default: + sdk = (uint32_t)-1; + min_sdk = (uint32_t)-1; + __builtin_unreachable(); + } + result->ip_platform = platform; + result->lr_min_sdk = min_sdk; + result->lr_sdk = sdk; + return LOAD_SUCCESS; +} + +static +load_return_t +load_main( + struct entry_point_command *epc, + thread_t thread, + int64_t slide, + load_result_t *result + ) +{ + mach_vm_offset_t addr; + kern_return_t ret; + + if (epc->cmdsize < sizeof(*epc)) { + return LOAD_BADMACHO; + } + if (result->thread_count != 0) { + return LOAD_FAILURE; + } + + if (thread == THREAD_NULL) { + return LOAD_SUCCESS; + } + + /* + * LC_MAIN specifies stack size but not location. + * Add guard page to allocation size (MAXSSIZ includes guard page). + */ + if (epc->stacksize) { + if (os_add_overflow(epc->stacksize, 4 * PAGE_SIZE, &result->user_stack_size)) { + /* + * We are going to immediately throw away this result, but we want + * to make sure we aren't loading a dangerously close to + * overflowing value, since this will have a guard page added to it + * and be rounded to page boundaries + */ + return LOAD_BADMACHO; + } + result->user_stack_size = epc->stacksize; + if (os_add_overflow(epc->stacksize, PAGE_SIZE, &result->user_stack_alloc_size)) { + return LOAD_BADMACHO; + } + result->custom_stack = TRUE; + } else { + result->user_stack_alloc_size = MAXSSIZ; + } + + /* use default location for stack */ + ret = thread_userstackdefault(&addr, result->is_64bit_addr); + if (ret != KERN_SUCCESS) { + return LOAD_FAILURE; + } + + /* The stack slides down from the default location */ + result->user_stack = (user_addr_t)mach_vm_trunc_page((user_addr_t)addr - slide); + + if (result->using_lcmain || result->entry_point != MACH_VM_MIN_ADDRESS) { + /* Already processed LC_MAIN or LC_UNIXTHREAD */ + return LOAD_FAILURE; + } + + /* kernel does *not* use entryoff from LC_MAIN. Dyld uses it. */ + result->needs_dynlinker = TRUE; + result->using_lcmain = TRUE; + + ret = thread_state_initialize( thread ); + if (ret != KERN_SUCCESS) { + return LOAD_FAILURE; + } + + result->unixproc = TRUE; + result->thread_count++; + + return LOAD_SUCCESS; +} + +static +load_return_t +setup_driver_main( + thread_t thread, + int64_t slide, + load_result_t *result + ) +{ + mach_vm_offset_t addr; + kern_return_t ret; + + /* Driver binaries have no LC_MAIN, use defaults */ + + if (thread == THREAD_NULL) { + return LOAD_SUCCESS; + } + + result->user_stack_alloc_size = MAXSSIZ; + + /* use default location for stack */ + ret = thread_userstackdefault(&addr, result->is_64bit_addr); + if (ret != KERN_SUCCESS) { + return LOAD_FAILURE; + } + + /* The stack slides down from the default location */ + result->user_stack = (user_addr_t)addr; + result->user_stack -= slide; + + if (result->using_lcmain || result->entry_point != MACH_VM_MIN_ADDRESS) { + /* Already processed LC_MAIN or LC_UNIXTHREAD */ + return LOAD_FAILURE; + } + + result->needs_dynlinker = TRUE; + + ret = thread_state_initialize( thread ); + if (ret != KERN_SUCCESS) { + return LOAD_FAILURE; + } + + result->unixproc = TRUE; + result->thread_count++; + + return LOAD_SUCCESS; +} + +static +load_return_t +load_unixthread( + struct thread_command *tcp, + thread_t thread, + int64_t slide, + boolean_t is_x86_64_compat_binary, + load_result_t *result + ) +{ + load_return_t ret; + int customstack = 0; + mach_vm_offset_t addr; + if (tcp->cmdsize < sizeof(*tcp)) { + return LOAD_BADMACHO; + } + if (result->thread_count != 0) { + return LOAD_FAILURE; + } + + if (thread == THREAD_NULL) { + return LOAD_SUCCESS; + } + + ret = load_threadstack(thread, + (uint32_t *)(((vm_offset_t)tcp) + + sizeof(struct thread_command)), + tcp->cmdsize - sizeof(struct thread_command), + &addr, &customstack, is_x86_64_compat_binary, result); + if (ret != LOAD_SUCCESS) { + return ret; + } + + /* LC_UNIXTHREAD optionally specifies stack size and location */ + + if (customstack) { + result->custom_stack = TRUE; + } else { + result->user_stack_alloc_size = MAXSSIZ; + } + + /* The stack slides down from the default location */ + result->user_stack = (user_addr_t)mach_vm_trunc_page((user_addr_t)addr - slide); + + { + ret = load_threadentry(thread, + (uint32_t *)(((vm_offset_t)tcp) + + sizeof(struct thread_command)), + tcp->cmdsize - sizeof(struct thread_command), + &addr); + if (ret != LOAD_SUCCESS) { + return ret; + } + + if (result->using_lcmain || result->entry_point != MACH_VM_MIN_ADDRESS) { + /* Already processed LC_MAIN or LC_UNIXTHREAD */ + return LOAD_FAILURE; + } + + result->entry_point = (user_addr_t)addr; + result->entry_point += slide; + + ret = load_threadstate(thread, + (uint32_t *)(((vm_offset_t)tcp) + sizeof(struct thread_command)), + tcp->cmdsize - sizeof(struct thread_command), + result); + if (ret != LOAD_SUCCESS) { + return ret; + } + } + + result->unixproc = TRUE; + result->thread_count++; + + return LOAD_SUCCESS; +} + +static +load_return_t +load_threadstate( + thread_t thread, + uint32_t *ts, + uint32_t total_size, + load_result_t *result + ) +{ + uint32_t size; + int flavor; + uint32_t thread_size; + uint32_t *local_ts = NULL; + uint32_t local_ts_size = 0; + int ret; + + (void)thread; + + if (total_size > 0) { + local_ts_size = total_size; + local_ts = (uint32_t *)kalloc_data(local_ts_size, Z_WAITOK); + if (local_ts == NULL) { + return LOAD_FAILURE; + } + memcpy(local_ts, ts, local_ts_size); + ts = local_ts; + } + + /* + * Validate the new thread state; iterate through the state flavors in + * the Mach-O file. + * XXX: we should validate the machine state here, to avoid failing at + * activation time where we can't bail out cleanly. + */ + while (total_size > 0) { + if (total_size < 2 * sizeof(uint32_t)) { + return LOAD_BADMACHO; + } + + flavor = *ts++; + size = *ts++; + + if (os_add_and_mul_overflow(size, 2, sizeof(uint32_t), &thread_size) || + os_sub_overflow(total_size, thread_size, &total_size)) { + ret = LOAD_BADMACHO; + goto bad; + } + + ts += size; /* ts is a (uint32_t *) */ + } + + result->threadstate = local_ts; + result->threadstate_sz = local_ts_size; + return LOAD_SUCCESS; + +bad: + if (local_ts) { + kfree_data(local_ts, local_ts_size); + } + return ret; +} + + +static +load_return_t +load_threadstack( + thread_t thread, + uint32_t *ts, + uint32_t total_size, + mach_vm_offset_t *user_stack, + int *customstack, + __unused boolean_t is_x86_64_compat_binary, + load_result_t *result + ) +{ + kern_return_t ret; + uint32_t size; + int flavor; + uint32_t stack_size; + + if (total_size == 0) { + return LOAD_BADMACHO; + } + + while (total_size > 0) { + if (total_size < 2 * sizeof(uint32_t)) { + return LOAD_BADMACHO; + } + + flavor = *ts++; + size = *ts++; + if (UINT32_MAX - 2 < size || + UINT32_MAX / sizeof(uint32_t) < size + 2) { + return LOAD_BADMACHO; + } + stack_size = (size + 2) * sizeof(uint32_t); + if (stack_size > total_size) { + return LOAD_BADMACHO; + } + total_size -= stack_size; + + /* + * Third argument is a kernel space pointer; it gets cast + * to the appropriate type in thread_userstack() based on + * the value of flavor. + */ + { + ret = thread_userstack(thread, flavor, (thread_state_t)ts, size, user_stack, customstack, result->is_64bit_data); + if (ret != KERN_SUCCESS) { + return LOAD_FAILURE; + } + } + + ts += size; /* ts is a (uint32_t *) */ + } + return LOAD_SUCCESS; +} + +static +load_return_t +load_threadentry( + thread_t thread, + uint32_t *ts, + uint32_t total_size, + mach_vm_offset_t *entry_point + ) +{ + kern_return_t ret; + uint32_t size; + int flavor; + uint32_t entry_size; + + /* + * Set the thread state. + */ + *entry_point = MACH_VM_MIN_ADDRESS; + while (total_size > 0) { + if (total_size < 2 * sizeof(uint32_t)) { + return LOAD_BADMACHO; + } + + flavor = *ts++; + size = *ts++; + if (UINT32_MAX - 2 < size || + UINT32_MAX / sizeof(uint32_t) < size + 2) { + return LOAD_BADMACHO; + } + entry_size = (size + 2) * sizeof(uint32_t); + if (entry_size > total_size) { + return LOAD_BADMACHO; + } + total_size -= entry_size; + /* + * Third argument is a kernel space pointer; it gets cast + * to the appropriate type in thread_entrypoint() based on + * the value of flavor. + */ + ret = thread_entrypoint(thread, flavor, (thread_state_t)ts, size, entry_point); + if (ret != KERN_SUCCESS) { + return LOAD_FAILURE; + } + ts += size; /* ts is a (uint32_t *) */ + } + return LOAD_SUCCESS; +} + +struct macho_data { + struct nameidata __nid; + union macho_vnode_header { + struct mach_header mach_header; + struct fat_header fat_header; + char __pad[512]; + } __header; +}; + +#define DEFAULT_DYLD_PATH "/usr/lib/dyld" + +#if (DEVELOPMENT || DEBUG) +extern char dyld_alt_path[]; +extern int use_alt_dyld; + +extern char dyld_suffix[]; +extern int use_dyld_suffix; + +typedef struct _dyld_suffix_map_entry { + const char *suffix; + const char *path; +} dyld_suffix_map_entry_t; + +static const dyld_suffix_map_entry_t _dyld_suffix_map[] = { + [0] = { + .suffix = "", + .path = DEFAULT_DYLD_PATH, + }, { + .suffix = "release", + .path = DEFAULT_DYLD_PATH, + }, { + .suffix = "bringup", + .path = "/usr/appleinternal/lib/dyld.bringup", + }, +}; +#endif + +static load_return_t +load_dylinker( + struct dylinker_command *lcp, + cpu_type_t cputype, + vm_map_t map, + thread_t thread, + int depth, + int64_t slide, + load_result_t *result, + struct image_params *imgp + ) +{ + const char *name; + struct vnode *vp = NULLVP; /* set by get_macho_vnode() */ + struct mach_header *header; + off_t file_offset = 0; /* set by get_macho_vnode() */ + off_t macho_size = 0; /* set by get_macho_vnode() */ + load_result_t *myresult; + kern_return_t ret; + struct macho_data *macho_data; + struct { + struct mach_header __header; + load_result_t __myresult; + struct macho_data __macho_data; + } *dyld_data; + + if (lcp->cmdsize < sizeof(*lcp) || lcp->name.offset >= lcp->cmdsize) { + return LOAD_BADMACHO; + } + + name = (const char *)lcp + lcp->name.offset; + + /* Check for a proper null terminated string. */ + size_t maxsz = lcp->cmdsize - lcp->name.offset; + size_t namelen = strnlen(name, maxsz); + if (namelen >= maxsz) { + return LOAD_BADMACHO; + } + +#if (DEVELOPMENT || DEBUG) + + /* + * rdar://23680808 + * If an alternate dyld has been specified via boot args, check + * to see if PROC_UUID_ALT_DYLD_POLICY has been set on this + * executable and redirect the kernel to load that linker. + */ + + if (use_alt_dyld) { + int policy_error; + uint32_t policy_flags = 0; + int32_t policy_gencount = 0; + + policy_error = proc_uuid_policy_lookup(result->uuid, &policy_flags, &policy_gencount); + if (policy_error == 0) { + if (policy_flags & PROC_UUID_ALT_DYLD_POLICY) { + name = dyld_alt_path; + } + } + } else if (use_dyld_suffix) { + size_t i = 0; + +#define countof(x) (sizeof(x) / sizeof(x[0])) + for (i = 0; i < countof(_dyld_suffix_map); i++) { + const dyld_suffix_map_entry_t *entry = &_dyld_suffix_map[i]; + + if (strcmp(entry->suffix, dyld_suffix) == 0) { + name = entry->path; + break; + } + } + } +#endif + +#if !(DEVELOPMENT || DEBUG) + if (0 != strcmp(name, DEFAULT_DYLD_PATH)) { + return LOAD_BADMACHO; + } +#endif + + /* Allocate wad-of-data from heap to reduce excessively deep stacks */ + + dyld_data = kalloc_type(typeof(*dyld_data), Z_WAITOK); + header = &dyld_data->__header; + myresult = &dyld_data->__myresult; + macho_data = &dyld_data->__macho_data; + + { + cputype = (cputype & CPU_ARCH_MASK) | (cpu_type() & ~CPU_ARCH_MASK); + } + + ret = get_macho_vnode(name, cputype, header, + &file_offset, &macho_size, macho_data, &vp, imgp); + if (ret) { + goto novp_out; + } + + *myresult = load_result_null; + myresult->is_64bit_addr = result->is_64bit_addr; + myresult->is_64bit_data = result->is_64bit_data; + + ret = parse_machfile(vp, map, thread, header, file_offset, + macho_size, depth, slide, 0, myresult, result, imgp); + + if (ret == LOAD_SUCCESS) { + if (result->threadstate) { + /* don't use the app's threadstate if we have a dyld */ + kfree_data(result->threadstate, result->threadstate_sz); + } + result->threadstate = myresult->threadstate; + result->threadstate_sz = myresult->threadstate_sz; + + result->dynlinker = TRUE; + result->entry_point = myresult->entry_point; + result->validentry = myresult->validentry; + result->all_image_info_addr = myresult->all_image_info_addr; + result->all_image_info_size = myresult->all_image_info_size; + if (!myresult->platform_binary) { + result->csflags &= ~CS_NO_UNTRUSTED_HELPERS; + } + +#if CONFIG_ROSETTA + if (imgp->ip_flags & IMGPF_ROSETTA) { + extern const struct fileops vnops; + // Save the file descriptor and mach header address for dyld. These will + // be passed on the stack for the Rosetta runtime's use. + struct fileproc *fp; + int dyld_fd; + proc_t p = vfs_context_proc(imgp->ip_vfs_context); + int error = falloc(p, &fp, &dyld_fd, imgp->ip_vfs_context); + if (error == 0) { + error = VNOP_OPEN(vp, FREAD, imgp->ip_vfs_context); + if (error == 0) { + fp->fp_glob->fg_flag = FREAD; + fp->fp_glob->fg_ops = &vnops; + fp_set_data(fp, vp); + + proc_fdlock(p); + procfdtbl_releasefd(p, dyld_fd, NULL); + fp_drop(p, dyld_fd, fp, 1); + proc_fdunlock(p); + + vnode_ref(vp); + + result->dynlinker_fd = dyld_fd; + result->dynlinker_fp = fp; + result->dynlinker_mach_header = myresult->mach_header; + result->dynlinker_max_vm_addr = myresult->max_vm_addr; + result->dynlinker_ro_vm_start = myresult->ro_vm_start; + result->dynlinker_ro_vm_end = myresult->ro_vm_end; + } else { + fp_free(p, dyld_fd, fp); + ret = LOAD_IOERROR; + } + } else { + ret = LOAD_IOERROR; + } + } +#endif + } + + struct vnode_attr *va; + va = kalloc_type(struct vnode_attr, Z_WAITOK | Z_ZERO); + VATTR_INIT(va); + VATTR_WANTED(va, va_fsid64); + VATTR_WANTED(va, va_fsid); + VATTR_WANTED(va, va_fileid); + int error = vnode_getattr(vp, va, imgp->ip_vfs_context); + if (error == 0) { + imgp->ip_dyld_fsid = vnode_get_va_fsid(va); + imgp->ip_dyld_fsobjid = va->va_fileid; + } + + vnode_put(vp); + kfree_type(struct vnode_attr, va); +novp_out: + kfree_type(typeof(*dyld_data), dyld_data); + return ret; +} + +#if CONFIG_ROSETTA +static const char* rosetta_runtime_path = "/usr/libexec/rosetta/runtime"; + +#if (DEVELOPMENT || DEBUG) +static const char* rosetta_runtime_path_alt_x86 = "/usr/local/libexec/rosetta/runtime_internal"; +static const char* rosetta_runtime_path_alt_arm = "/usr/local/libexec/rosetta/runtime_arm_internal"; +#endif + +static load_return_t +load_rosetta( + vm_map_t map, + thread_t thread, + load_result_t *result, + struct image_params *imgp) +{ + struct vnode *vp = NULLVP; /* set by get_macho_vnode() */ + struct mach_header *header; + off_t file_offset = 0; /* set by get_macho_vnode() */ + off_t macho_size = 0; /* set by get_macho_vnode() */ + load_result_t *myresult; + kern_return_t ret; + struct macho_data *macho_data; + const char *rosetta_file_path; + struct { + struct mach_header __header; + load_result_t __myresult; + struct macho_data __macho_data; + } *rosetta_data; + mach_vm_address_t rosetta_load_addr; + mach_vm_size_t rosetta_size; + mach_vm_address_t shared_cache_base = SHARED_REGION_BASE_ARM64; + int64_t slide = 0; + + /* Allocate wad-of-data from heap to reduce excessively deep stacks */ + rosetta_data = kalloc_type(typeof(*rosetta_data), Z_WAITOK | Z_NOFAIL); + header = &rosetta_data->__header; + myresult = &rosetta_data->__myresult; + macho_data = &rosetta_data->__macho_data; + + rosetta_file_path = rosetta_runtime_path; + +#if (DEVELOPMENT || DEBUG) + bool use_alt_rosetta = false; + if (imgp->ip_flags & IMGPF_ALT_ROSETTA) { + use_alt_rosetta = true; + } else { + int policy_error; + uint32_t policy_flags = 0; + int32_t policy_gencount = 0; + policy_error = proc_uuid_policy_lookup(result->uuid, &policy_flags, &policy_gencount); + if (policy_error == 0 && (policy_flags & PROC_UUID_ALT_ROSETTA_POLICY) != 0) { + use_alt_rosetta = true; + } + } + + if (use_alt_rosetta) { + if (imgp->ip_origcputype == CPU_TYPE_X86_64) { + rosetta_file_path = rosetta_runtime_path_alt_x86; + } else if (imgp->ip_origcputype == CPU_TYPE_ARM64) { + rosetta_file_path = rosetta_runtime_path_alt_arm; + } else { + ret = LOAD_BADARCH; + goto novp_out; + } + } +#endif + + ret = get_macho_vnode(rosetta_file_path, CPU_TYPE_ARM64, header, + &file_offset, &macho_size, macho_data, &vp, imgp); + if (ret) { + goto novp_out; + } + + *myresult = load_result_null; + myresult->is_64bit_addr = TRUE; + myresult->is_64bit_data = TRUE; + + ret = parse_machfile(vp, NULL, NULL, header, file_offset, macho_size, + 2, 0, 0, myresult, NULL, imgp); + if (ret != LOAD_SUCCESS) { + goto out; + } + + if (!(imgp->ip_flags & IMGPF_DISABLE_ASLR)) { + slide = random(); + slide = (slide % (vm_map_get_max_loader_aslr_slide_pages(map) - 1)) + 1; + slide <<= vm_map_page_shift(map); + } + + if (imgp->ip_origcputype == CPU_TYPE_X86_64) { + shared_cache_base = SHARED_REGION_BASE_X86_64; + } + + rosetta_size = round_page(myresult->max_vm_addr - myresult->min_vm_addr); + rosetta_load_addr = shared_cache_base - rosetta_size - slide; + + *myresult = load_result_null; + myresult->is_64bit_addr = TRUE; + myresult->is_64bit_data = TRUE; + myresult->is_rosetta = TRUE; + + ret = parse_machfile(vp, map, thread, header, file_offset, macho_size, + 2, rosetta_load_addr, 0, myresult, result, imgp); + if (ret == LOAD_SUCCESS) { + if (result) { + if (result->threadstate) { + /* don't use the app's/dyld's threadstate */ + kfree_data(result->threadstate, result->threadstate_sz); + } + assert(myresult->threadstate != NULL); + + result->is_rosetta = TRUE; + + result->threadstate = myresult->threadstate; + result->threadstate_sz = myresult->threadstate_sz; + + result->entry_point = myresult->entry_point; + result->validentry = myresult->validentry; + if (!myresult->platform_binary) { + result->csflags &= ~CS_NO_UNTRUSTED_HELPERS; + } + + if ((header->cpusubtype & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_ARM64E) { + imgp->ip_flags |= IMGPF_NOJOP; + } + } + } + +out: + vnode_put(vp); +novp_out: + kfree_type(typeof(*rosetta_data), rosetta_data); + return ret; +} +#endif + +static void +set_signature_error( + struct vnode* vp, + struct image_params * imgp, + const char* fatal_failure_desc, + const size_t fatal_failure_desc_len) +{ + char *vn_path = NULL; + vm_size_t vn_pathlen = MAXPATHLEN; + char const *path = NULL; + + vn_path = zalloc(ZV_NAMEI); + if (vn_getpath(vp, vn_path, (int*)&vn_pathlen) == 0) { + path = vn_path; + } else { + path = "(get vnode path failed)"; + } + os_reason_t reason = os_reason_create(OS_REASON_CODESIGNING, + CODESIGNING_EXIT_REASON_TASKGATED_INVALID_SIG); + + if (reason == OS_REASON_NULL) { + printf("load_code_signature: %s: failure to allocate exit reason for validation failure: %s\n", + path, fatal_failure_desc); + goto out; + } + + imgp->ip_cs_error = reason; + reason->osr_flags = (OS_REASON_FLAG_GENERATE_CRASH_REPORT | + OS_REASON_FLAG_CONSISTENT_FAILURE); + + mach_vm_address_t data_addr = 0; + + int reason_error = 0; + int kcdata_error = 0; + + if ((reason_error = os_reason_alloc_buffer_noblock(reason, kcdata_estimate_required_buffer_size + (1, (uint32_t)fatal_failure_desc_len))) == 0 && + (kcdata_error = kcdata_get_memory_addr(&reason->osr_kcd_descriptor, + EXIT_REASON_USER_DESC, (uint32_t)fatal_failure_desc_len, + &data_addr)) == KERN_SUCCESS) { + kern_return_t mc_error = kcdata_memcpy(&reason->osr_kcd_descriptor, (mach_vm_address_t)data_addr, + fatal_failure_desc, (uint32_t)fatal_failure_desc_len); + + if (mc_error != KERN_SUCCESS) { + printf("load_code_signature: %s: failed to copy reason string " + "(kcdata_memcpy error: %d, length: %ld)\n", + path, mc_error, fatal_failure_desc_len); + } + } else { + printf("load_code_signature: %s: failed to allocate space for reason string " + "(os_reason_alloc_buffer error: %d, kcdata error: %d, length: %ld)\n", + path, reason_error, kcdata_error, fatal_failure_desc_len); + } +out: + if (vn_path) { + zfree(ZV_NAMEI, vn_path); + } +} + +static load_return_t +load_code_signature( + struct linkedit_data_command *lcp, + struct vnode *vp, + off_t macho_offset, + off_t macho_size, + cpu_type_t cputype, + cpu_subtype_t cpusubtype, + load_result_t *result, + struct image_params *imgp) +{ + int ret; + kern_return_t kr; + vm_offset_t addr; + int resid; + struct cs_blob *blob; + int error; + vm_size_t blob_size; + uint32_t sum; + boolean_t anyCPU; + + addr = 0; + blob = NULL; + + cpusubtype &= ~CPU_SUBTYPE_MASK; + + blob = ubc_cs_blob_get(vp, cputype, cpusubtype, macho_offset); + + if (blob != NULL) { + /* we already have a blob for this vnode and cpu(sub)type */ + anyCPU = blob->csb_cpu_type == -1; + if ((blob->csb_cpu_type != cputype && + blob->csb_cpu_subtype != cpusubtype && !anyCPU) || + (blob->csb_base_offset != macho_offset) || + ((blob->csb_flags & CS_VALID) == 0)) { + /* the blob has changed for this vnode: fail ! */ + ret = LOAD_BADMACHO; + const char* fatal_failure_desc = "embedded signature doesn't match attached signature"; + const size_t fatal_failure_desc_len = strlen(fatal_failure_desc) + 1; + + printf("load_code_signature: %s\n", fatal_failure_desc); + set_signature_error(vp, imgp, fatal_failure_desc, fatal_failure_desc_len); + goto out; + } + + /* It matches the blob we want here, let's verify the version */ + if (!anyCPU && ubc_cs_generation_check(vp) == 0) { + /* No need to revalidate, we're good! */ + ret = LOAD_SUCCESS; + goto out; + } + + /* That blob may be stale, let's revalidate. */ + error = ubc_cs_blob_revalidate(vp, blob, imgp, 0, result->ip_platform); + if (error == 0) { + /* Revalidation succeeded, we're good! */ + /* If we were revaliding a CS blob with any CPU arch we adjust it */ + if (anyCPU) { + vnode_lock_spin(vp); + struct cs_cpu_info cpu_info = { + .csb_cpu_type = cputype, + .csb_cpu_subtype = cpusubtype + }; + zalloc_ro_update_field(ZONE_ID_CS_BLOB, blob, csb_cpu_info, &cpu_info); + vnode_unlock(vp); + } + ret = LOAD_SUCCESS; + goto out; + } + + if (error != EAGAIN) { + printf("load_code_signature: revalidation failed: %d\n", error); + ret = LOAD_FAILURE; + goto out; + } + + assert(error == EAGAIN); + + /* + * Revalidation was not possible for this blob. We just continue as if there was no blob, + * rereading the signature, and ubc_cs_blob_add will do the right thing. + */ + blob = NULL; + } + + if (lcp->cmdsize != sizeof(struct linkedit_data_command)) { + ret = LOAD_BADMACHO; + goto out; + } + + sum = 0; + if (os_add_overflow(lcp->dataoff, lcp->datasize, &sum) || sum > macho_size) { + ret = LOAD_BADMACHO; + goto out; + } + + blob_size = lcp->datasize; + kr = ubc_cs_blob_allocate(&addr, &blob_size); + if (kr != KERN_SUCCESS) { + ret = LOAD_NOSPACE; + goto out; + } + + resid = 0; + error = vn_rdwr(UIO_READ, + vp, + (caddr_t) addr, + lcp->datasize, + macho_offset + lcp->dataoff, + UIO_SYSSPACE, + 0, + kauth_cred_get(), + &resid, + current_proc()); + if (error || resid != 0) { + ret = LOAD_IOERROR; + goto out; + } + + if (ubc_cs_blob_add(vp, + result->ip_platform, + cputype, + cpusubtype, + macho_offset, + &addr, + lcp->datasize, + imgp, + 0, + &blob)) { + if (addr) { + ubc_cs_blob_deallocate(addr, blob_size); + addr = 0; + } + ret = LOAD_FAILURE; + goto out; + } else { + /* ubc_cs_blob_add() has consumed "addr" */ + addr = 0; + } + +#if CHECK_CS_VALIDATION_BITMAP + ubc_cs_validation_bitmap_allocate( vp ); +#endif + + ret = LOAD_SUCCESS; +out: + if (ret == LOAD_SUCCESS) { + if (blob == NULL) { + panic("success, but no blob!"); + } + + result->csflags |= blob->csb_flags; + result->platform_binary = blob->csb_platform_binary; + result->cs_end_offset = blob->csb_end_offset; + } + if (addr != 0) { + ubc_cs_blob_deallocate(addr, blob_size); + addr = 0; + } + + return ret; +} + + +#if CONFIG_CODE_DECRYPTION + +static load_return_t +set_code_unprotect( + struct encryption_info_command *eip, + caddr_t addr, + vm_map_t map, + int64_t slide, + struct vnode *vp, + off_t macho_offset, + cpu_type_t cputype, + cpu_subtype_t cpusubtype) +{ + int error, len; + pager_crypt_info_t crypt_info; + const char * cryptname = 0; + char *vpath; + + size_t offset; + struct segment_command_64 *seg64; + struct segment_command *seg32; + vm_map_offset_t map_offset, map_size; + vm_object_offset_t crypto_backing_offset; + kern_return_t kr; + + if (eip->cmdsize < sizeof(*eip)) { + return LOAD_BADMACHO; + } + + switch (eip->cryptid) { + case 0: + /* not encrypted, just an empty load command */ + return LOAD_SUCCESS; + case 1: + cryptname = "com.apple.unfree"; + break; + case 0x10: + /* some random cryptid that you could manually put into + * your binary if you want NULL */ + cryptname = "com.apple.null"; + break; + default: + return LOAD_BADMACHO; + } + + if (map == VM_MAP_NULL) { + return LOAD_SUCCESS; + } + if (NULL == text_crypter_create) { + return LOAD_FAILURE; + } + + vpath = zalloc(ZV_NAMEI); + + len = MAXPATHLEN; + error = vn_getpath(vp, vpath, &len); + if (error) { + zfree(ZV_NAMEI, vpath); + return LOAD_FAILURE; + } + + if (eip->cryptsize == 0) { + printf("%s:%d '%s': cryptoff 0x%llx cryptsize 0x%llx cryptid 0x%x ignored\n", __FUNCTION__, __LINE__, vpath, (uint64_t)eip->cryptoff, (uint64_t)eip->cryptsize, eip->cryptid); + zfree(ZV_NAMEI, vpath); + return LOAD_SUCCESS; + } + + /* set up decrypter first */ + crypt_file_data_t crypt_data = { + .filename = vpath, + .cputype = cputype, + .cpusubtype = cpusubtype, + .origin = CRYPT_ORIGIN_APP_LAUNCH, + }; + kr = text_crypter_create(&crypt_info, cryptname, (void*)&crypt_data); +#if VM_MAP_DEBUG_APPLE_PROTECT + if (vm_map_debug_apple_protect) { + struct proc *p; + p = current_proc(); + printf("APPLE_PROTECT: %d[%s] map %p %s(%s) -> 0x%x\n", + proc_getpid(p), p->p_comm, map, __FUNCTION__, vpath, kr); + } +#endif /* VM_MAP_DEBUG_APPLE_PROTECT */ + zfree(ZV_NAMEI, vpath); + + if (kr) { + printf("set_code_unprotect: unable to create decrypter %s, kr=%d\n", + cryptname, kr); + if (kr == kIOReturnNotPrivileged) { + /* text encryption returned decryption failure */ + return LOAD_DECRYPTFAIL; + } else { + return LOAD_RESOURCE; + } + } + + /* this is terrible, but we have to rescan the load commands to find the + * virtual address of this encrypted stuff. This code is gonna look like + * the dyld source one day... */ + struct mach_header *header = (struct mach_header *)addr; + size_t mach_header_sz = sizeof(struct mach_header); + if (header->magic == MH_MAGIC_64 || + header->magic == MH_CIGAM_64) { + mach_header_sz = sizeof(struct mach_header_64); + } + offset = mach_header_sz; + uint32_t ncmds = header->ncmds; + while (ncmds--) { + /* + * Get a pointer to the command. + */ + struct load_command *lcp = (struct load_command *)(addr + offset); + offset += lcp->cmdsize; + + switch (lcp->cmd) { + case LC_SEGMENT_64: + seg64 = (struct segment_command_64 *)lcp; + if ((seg64->fileoff <= eip->cryptoff) && + (seg64->fileoff + seg64->filesize >= + eip->cryptoff + eip->cryptsize)) { + map_offset = (vm_map_offset_t)(seg64->vmaddr + eip->cryptoff - seg64->fileoff + slide); + map_size = eip->cryptsize; + crypto_backing_offset = macho_offset + eip->cryptoff; + goto remap_now; + } + break; + case LC_SEGMENT: + seg32 = (struct segment_command *)lcp; + if ((seg32->fileoff <= eip->cryptoff) && + (seg32->fileoff + seg32->filesize >= + eip->cryptoff + eip->cryptsize)) { + map_offset = (vm_map_offset_t)(seg32->vmaddr + eip->cryptoff - seg32->fileoff + slide); + map_size = eip->cryptsize; + crypto_backing_offset = macho_offset + eip->cryptoff; + goto remap_now; + } + break; + } + } + + /* if we get here, did not find anything */ + return LOAD_BADMACHO; + +remap_now: + /* now remap using the decrypter */ + MACHO_PRINTF(("+++ set_code_unprotect: vm[0x%llx:0x%llx]\n", + (uint64_t) map_offset, + (uint64_t) (map_offset + map_size))); + kr = vm_map_apple_protected(map, + map_offset, + map_offset + map_size, + crypto_backing_offset, + &crypt_info, + CRYPTID_APP_ENCRYPTION); + if (kr) { + printf("set_code_unprotect(): mapping failed with %x\n", kr); + return LOAD_PROTECT; + } + + return LOAD_SUCCESS; +} + +#endif + +/* + * This routine exists to support the load_dylinker(). + * + * This routine has its own, separate, understanding of the FAT file format, + * which is terrifically unfortunate. + */ +static +load_return_t +get_macho_vnode( + const char *path, + cpu_type_t cputype, + struct mach_header *mach_header, + off_t *file_offset, + off_t *macho_size, + struct macho_data *data, + struct vnode **vpp, + struct image_params *imgp + ) +{ + struct vnode *vp; + vfs_context_t ctx = vfs_context_current(); + proc_t p = vfs_context_proc(ctx); + kauth_cred_t kerncred; + struct nameidata *ndp = &data->__nid; + boolean_t is_fat; + struct fat_arch fat_arch; + int error; + int resid; + union macho_vnode_header *header = &data->__header; + off_t fsize = (off_t)0; + + /* + * Capture the kernel credential for use in the actual read of the + * file, since the user doing the execution may have execute rights + * but not read rights, but to exec something, we have to either map + * or read it into the new process address space, which requires + * read rights. This is to deal with lack of common credential + * serialization code which would treat NOCRED as "serialize 'root'". + */ + kerncred = vfs_context_ucred(vfs_context_kernel()); + + /* init the namei data to point the file user's program name */ + NDINIT(ndp, LOOKUP, OP_OPEN, FOLLOW | LOCKLEAF, UIO_SYSSPACE, CAST_USER_ADDR_T(path), ctx); + + if ((error = namei(ndp)) != 0) { + if (error == ENOENT) { + error = LOAD_ENOENT; + } else { + error = LOAD_FAILURE; + } + return error; + } + nameidone(ndp); + vp = ndp->ni_vp; + + /* check for regular file */ + if (vp->v_type != VREG) { + error = LOAD_PROTECT; + goto bad1; + } + + /* get size */ + if ((error = vnode_size(vp, &fsize, ctx)) != 0) { + error = LOAD_FAILURE; + goto bad1; + } + + /* Check mount point */ + if (vp->v_mount->mnt_flag & MNT_NOEXEC) { + error = LOAD_PROTECT; + goto bad1; + } + + /* check access */ + if ((error = vnode_authorize(vp, NULL, KAUTH_VNODE_EXECUTE | KAUTH_VNODE_READ_DATA, ctx)) != 0) { + error = LOAD_PROTECT; + goto bad1; + } + + /* try to open it */ + if ((error = VNOP_OPEN(vp, FREAD, ctx)) != 0) { + error = LOAD_PROTECT; + goto bad1; + } + + if ((error = vn_rdwr(UIO_READ, vp, (caddr_t)header, sizeof(*header), 0, + UIO_SYSSPACE, IO_NODELOCKED, kerncred, &resid, p)) != 0) { + error = LOAD_IOERROR; + goto bad2; + } + + if (resid) { + error = LOAD_BADMACHO; + goto bad2; + } + + if (header->mach_header.magic == MH_MAGIC || + header->mach_header.magic == MH_MAGIC_64) { + is_fat = FALSE; + } else if (OSSwapBigToHostInt32(header->fat_header.magic) == FAT_MAGIC) { + is_fat = TRUE; + } else { + error = LOAD_BADMACHO; + goto bad2; + } + + if (is_fat) { + error = fatfile_validate_fatarches((vm_offset_t)(&header->fat_header), + sizeof(*header), fsize); + if (error != LOAD_SUCCESS) { + goto bad2; + } + + /* Look up our architecture in the fat file. */ + error = fatfile_getbestarch_for_cputype(cputype, CPU_SUBTYPE_ANY, + (vm_offset_t)(&header->fat_header), sizeof(*header), imgp, &fat_arch); + if (error != LOAD_SUCCESS) { + goto bad2; + } + + /* Read the Mach-O header out of it */ + error = vn_rdwr(UIO_READ, vp, (caddr_t)&header->mach_header, + sizeof(header->mach_header), fat_arch.offset, + UIO_SYSSPACE, IO_NODELOCKED, kerncred, &resid, p); + if (error) { + error = LOAD_IOERROR; + goto bad2; + } + + if (resid) { + error = LOAD_BADMACHO; + goto bad2; + } + + /* Is this really a Mach-O? */ + if (header->mach_header.magic != MH_MAGIC && + header->mach_header.magic != MH_MAGIC_64) { + error = LOAD_BADMACHO; + goto bad2; + } + + *file_offset = fat_arch.offset; + *macho_size = fat_arch.size; + } else { + /* + * Force get_macho_vnode() to fail if the architecture bits + * do not match the expected architecture bits. This in + * turn causes load_dylinker() to fail for the same reason, + * so it ensures the dynamic linker and the binary are in + * lock-step. This is potentially bad, if we ever add to + * the CPU_ARCH_* bits any bits that are desirable but not + * required, since the dynamic linker might work, but we will + * refuse to load it because of this check. + */ + if ((cpu_type_t)header->mach_header.cputype != cputype) { + error = LOAD_BADARCH; + goto bad2; + } + + *file_offset = 0; + *macho_size = fsize; + } + + *mach_header = header->mach_header; + *vpp = vp; + + ubc_setsize(vp, fsize); + return error; + +bad2: + (void) VNOP_CLOSE(vp, FREAD, ctx); +bad1: + vnode_put(vp); + return error; +} \ No newline at end of file diff --git a/I. Mach-O/mac/machine.h b/I. Mach-O/mac/machine.h new file mode 100644 index 0000000..3f49d43 --- /dev/null +++ b/I. Mach-O/mac/machine.h @@ -0,0 +1,416 @@ +// Extracted from Xcode 15 Beta 7 +/* /Library/Developer/CommandLineTools/SDKs/MacOSX14.0.sdk/System/Library/Frameworks/Kernel.framework/Versions/A/Headers/mach/machine.h */ +/* + * Copyright (c) 2007-2016 Apple, Inc. All rights reserved. + * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. + * + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ + */ +/* + * Mach Operating System + * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University + * All Rights Reserved. + * + * Permission to use, copy, modify and distribute this software and its + * documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR + * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie Mellon + * the rights to redistribute these changes. + */ +/* File: machine.h + * Author: Avadis Tevanian, Jr. + * Date: 1986 + * + * Machine independent machine abstraction. + */ + +#ifndef _MACH_MACHINE_H_ +#define _MACH_MACHINE_H_ + +#ifndef __ASSEMBLER__ + +#include +#include +#include + +typedef integer_t cpu_type_t; +typedef integer_t cpu_subtype_t; +typedef integer_t cpu_threadtype_t; + +#define CPU_STATE_MAX 4 + +#define CPU_STATE_USER 0 +#define CPU_STATE_SYSTEM 1 +#define CPU_STATE_IDLE 2 +#define CPU_STATE_NICE 3 + + + +/* + * Capability bits used in the definition of cpu_type. + */ +#define CPU_ARCH_MASK 0xff000000 /* mask for architecture bits */ +#define CPU_ARCH_ABI64 0x01000000 /* 64 bit ABI */ +#define CPU_ARCH_ABI64_32 0x02000000 /* ABI for 64-bit hardware with 32-bit types; LP32 */ + +/* + * Machine types known by all. + */ + +#define CPU_TYPE_ANY ((cpu_type_t) -1) + +#define CPU_TYPE_VAX ((cpu_type_t) 1) +/* skip ((cpu_type_t) 2) */ +/* skip ((cpu_type_t) 3) */ +/* skip ((cpu_type_t) 4) */ +/* skip ((cpu_type_t) 5) */ +#define CPU_TYPE_MC680x0 ((cpu_type_t) 6) +#define CPU_TYPE_X86 ((cpu_type_t) 7) +#define CPU_TYPE_I386 CPU_TYPE_X86 /* compatibility */ +#define CPU_TYPE_X86_64 (CPU_TYPE_X86 | CPU_ARCH_ABI64) + +/* skip CPU_TYPE_MIPS ((cpu_type_t) 8) */ +/* skip ((cpu_type_t) 9) */ +#define CPU_TYPE_MC98000 ((cpu_type_t) 10) +#define CPU_TYPE_HPPA ((cpu_type_t) 11) +#define CPU_TYPE_ARM ((cpu_type_t) 12) +#define CPU_TYPE_ARM64 (CPU_TYPE_ARM | CPU_ARCH_ABI64) +#define CPU_TYPE_ARM64_32 (CPU_TYPE_ARM | CPU_ARCH_ABI64_32) +#define CPU_TYPE_MC88000 ((cpu_type_t) 13) +#define CPU_TYPE_SPARC ((cpu_type_t) 14) +#define CPU_TYPE_I860 ((cpu_type_t) 15) +/* skip CPU_TYPE_ALPHA ((cpu_type_t) 16) */ +/* skip ((cpu_type_t) 17) */ +#define CPU_TYPE_POWERPC ((cpu_type_t) 18) +#define CPU_TYPE_POWERPC64 (CPU_TYPE_POWERPC | CPU_ARCH_ABI64) +/* skip ((cpu_type_t) 19) */ +/* skip ((cpu_type_t) 20 */ +/* skip ((cpu_type_t) 21 */ +/* skip ((cpu_type_t) 22 */ +/* skip ((cpu_type_t) 23 */ + +/* + * Machine subtypes (these are defined here, instead of in a machine + * dependent directory, so that any program can get all definitions + * regardless of where is it compiled). + */ + +/* + * Capability bits used in the definition of cpu_subtype. + */ +#define CPU_SUBTYPE_MASK 0xff000000 /* mask for feature flags */ +#define CPU_SUBTYPE_LIB64 0x80000000 /* 64 bit libraries */ +#define CPU_SUBTYPE_PTRAUTH_ABI 0x80000000 /* pointer authentication with versioned ABI */ + +/* + * When selecting a slice, ANY will pick the slice with the best + * grading for the selected cpu_type_t, unlike the "ALL" subtypes, + * which are the slices that can run on any hardware for that cpu type. + */ +#define CPU_SUBTYPE_ANY ((cpu_subtype_t) -1) + +/* + * Object files that are hand-crafted to run on any + * implementation of an architecture are tagged with + * CPU_SUBTYPE_MULTIPLE. This functions essentially the same as + * the "ALL" subtype of an architecture except that it allows us + * to easily find object files that may need to be modified + * whenever a new implementation of an architecture comes out. + * + * It is the responsibility of the implementor to make sure the + * software handles unsupported implementations elegantly. + */ +#define CPU_SUBTYPE_MULTIPLE ((cpu_subtype_t) -1) +#define CPU_SUBTYPE_LITTLE_ENDIAN ((cpu_subtype_t) 0) +#define CPU_SUBTYPE_BIG_ENDIAN ((cpu_subtype_t) 1) + +/* + * Machine threadtypes. + * This is none - not defined - for most machine types/subtypes. + */ +#define CPU_THREADTYPE_NONE ((cpu_threadtype_t) 0) + +/* + * VAX subtypes (these do *not* necessary conform to the actual cpu + * ID assigned by DEC available via the SID register). + */ + +#define CPU_SUBTYPE_VAX_ALL ((cpu_subtype_t) 0) +#define CPU_SUBTYPE_VAX780 ((cpu_subtype_t) 1) +#define CPU_SUBTYPE_VAX785 ((cpu_subtype_t) 2) +#define CPU_SUBTYPE_VAX750 ((cpu_subtype_t) 3) +#define CPU_SUBTYPE_VAX730 ((cpu_subtype_t) 4) +#define CPU_SUBTYPE_UVAXI ((cpu_subtype_t) 5) +#define CPU_SUBTYPE_UVAXII ((cpu_subtype_t) 6) +#define CPU_SUBTYPE_VAX8200 ((cpu_subtype_t) 7) +#define CPU_SUBTYPE_VAX8500 ((cpu_subtype_t) 8) +#define CPU_SUBTYPE_VAX8600 ((cpu_subtype_t) 9) +#define CPU_SUBTYPE_VAX8650 ((cpu_subtype_t) 10) +#define CPU_SUBTYPE_VAX8800 ((cpu_subtype_t) 11) +#define CPU_SUBTYPE_UVAXIII ((cpu_subtype_t) 12) + +/* + * 680x0 subtypes + * + * The subtype definitions here are unusual for historical reasons. + * NeXT used to consider 68030 code as generic 68000 code. For + * backwards compatability: + * + * CPU_SUBTYPE_MC68030 symbol has been preserved for source code + * compatability. + * + * CPU_SUBTYPE_MC680x0_ALL has been defined to be the same + * subtype as CPU_SUBTYPE_MC68030 for binary comatability. + * + * CPU_SUBTYPE_MC68030_ONLY has been added to allow new object + * files to be tagged as containing 68030-specific instructions. + */ + +#define CPU_SUBTYPE_MC680x0_ALL ((cpu_subtype_t) 1) +#define CPU_SUBTYPE_MC68030 ((cpu_subtype_t) 1) /* compat */ +#define CPU_SUBTYPE_MC68040 ((cpu_subtype_t) 2) +#define CPU_SUBTYPE_MC68030_ONLY ((cpu_subtype_t) 3) + +/* + * I386 subtypes + */ + +#define CPU_SUBTYPE_INTEL(f, m) ((cpu_subtype_t) (f) + ((m) << 4)) + +#define CPU_SUBTYPE_I386_ALL CPU_SUBTYPE_INTEL(3, 0) +#define CPU_SUBTYPE_386 CPU_SUBTYPE_INTEL(3, 0) +#define CPU_SUBTYPE_486 CPU_SUBTYPE_INTEL(4, 0) +#define CPU_SUBTYPE_486SX CPU_SUBTYPE_INTEL(4, 8) // 8 << 4 = 128 +#define CPU_SUBTYPE_586 CPU_SUBTYPE_INTEL(5, 0) +#define CPU_SUBTYPE_PENT CPU_SUBTYPE_INTEL(5, 0) +#define CPU_SUBTYPE_PENTPRO CPU_SUBTYPE_INTEL(6, 1) +#define CPU_SUBTYPE_PENTII_M3 CPU_SUBTYPE_INTEL(6, 3) +#define CPU_SUBTYPE_PENTII_M5 CPU_SUBTYPE_INTEL(6, 5) +#define CPU_SUBTYPE_CELERON CPU_SUBTYPE_INTEL(7, 6) +#define CPU_SUBTYPE_CELERON_MOBILE CPU_SUBTYPE_INTEL(7, 7) +#define CPU_SUBTYPE_PENTIUM_3 CPU_SUBTYPE_INTEL(8, 0) +#define CPU_SUBTYPE_PENTIUM_3_M CPU_SUBTYPE_INTEL(8, 1) +#define CPU_SUBTYPE_PENTIUM_3_XEON CPU_SUBTYPE_INTEL(8, 2) +#define CPU_SUBTYPE_PENTIUM_M CPU_SUBTYPE_INTEL(9, 0) +#define CPU_SUBTYPE_PENTIUM_4 CPU_SUBTYPE_INTEL(10, 0) +#define CPU_SUBTYPE_PENTIUM_4_M CPU_SUBTYPE_INTEL(10, 1) +#define CPU_SUBTYPE_ITANIUM CPU_SUBTYPE_INTEL(11, 0) +#define CPU_SUBTYPE_ITANIUM_2 CPU_SUBTYPE_INTEL(11, 1) +#define CPU_SUBTYPE_XEON CPU_SUBTYPE_INTEL(12, 0) +#define CPU_SUBTYPE_XEON_MP CPU_SUBTYPE_INTEL(12, 1) + +#define CPU_SUBTYPE_INTEL_FAMILY(x) ((x) & 15) +#define CPU_SUBTYPE_INTEL_FAMILY_MAX 15 + +#define CPU_SUBTYPE_INTEL_MODEL(x) ((x) >> 4) +#define CPU_SUBTYPE_INTEL_MODEL_ALL 0 + +/* + * X86 subtypes. + */ + +#define CPU_SUBTYPE_X86_ALL ((cpu_subtype_t)3) +#define CPU_SUBTYPE_X86_64_ALL ((cpu_subtype_t)3) +#define CPU_SUBTYPE_X86_ARCH1 ((cpu_subtype_t)4) +#define CPU_SUBTYPE_X86_64_H ((cpu_subtype_t)8) /* Haswell feature subset */ + + +#define CPU_THREADTYPE_INTEL_HTT ((cpu_threadtype_t) 1) + +/* + * Mips subtypes. + */ + +#define CPU_SUBTYPE_MIPS_ALL ((cpu_subtype_t) 0) +#define CPU_SUBTYPE_MIPS_R2300 ((cpu_subtype_t) 1) +#define CPU_SUBTYPE_MIPS_R2600 ((cpu_subtype_t) 2) +#define CPU_SUBTYPE_MIPS_R2800 ((cpu_subtype_t) 3) +#define CPU_SUBTYPE_MIPS_R2000a ((cpu_subtype_t) 4) /* pmax */ +#define CPU_SUBTYPE_MIPS_R2000 ((cpu_subtype_t) 5) +#define CPU_SUBTYPE_MIPS_R3000a ((cpu_subtype_t) 6) /* 3max */ +#define CPU_SUBTYPE_MIPS_R3000 ((cpu_subtype_t) 7) + +/* + * MC98000 (PowerPC) subtypes + */ +#define CPU_SUBTYPE_MC98000_ALL ((cpu_subtype_t) 0) +#define CPU_SUBTYPE_MC98601 ((cpu_subtype_t) 1) + +/* + * HPPA subtypes for Hewlett-Packard HP-PA family of + * risc processors. Port by NeXT to 700 series. + */ + +#define CPU_SUBTYPE_HPPA_ALL ((cpu_subtype_t) 0) +#define CPU_SUBTYPE_HPPA_7100 ((cpu_subtype_t) 0) /* compat */ +#define CPU_SUBTYPE_HPPA_7100LC ((cpu_subtype_t) 1) + +/* + * MC88000 subtypes. + */ +#define CPU_SUBTYPE_MC88000_ALL ((cpu_subtype_t) 0) +#define CPU_SUBTYPE_MC88100 ((cpu_subtype_t) 1) +#define CPU_SUBTYPE_MC88110 ((cpu_subtype_t) 2) + +/* + * SPARC subtypes + */ +#define CPU_SUBTYPE_SPARC_ALL ((cpu_subtype_t) 0) + +/* + * I860 subtypes + */ +#define CPU_SUBTYPE_I860_ALL ((cpu_subtype_t) 0) +#define CPU_SUBTYPE_I860_860 ((cpu_subtype_t) 1) + +/* + * PowerPC subtypes + */ +#define CPU_SUBTYPE_POWERPC_ALL ((cpu_subtype_t) 0) +#define CPU_SUBTYPE_POWERPC_601 ((cpu_subtype_t) 1) +#define CPU_SUBTYPE_POWERPC_602 ((cpu_subtype_t) 2) +#define CPU_SUBTYPE_POWERPC_603 ((cpu_subtype_t) 3) +#define CPU_SUBTYPE_POWERPC_603e ((cpu_subtype_t) 4) +#define CPU_SUBTYPE_POWERPC_603ev ((cpu_subtype_t) 5) +#define CPU_SUBTYPE_POWERPC_604 ((cpu_subtype_t) 6) +#define CPU_SUBTYPE_POWERPC_604e ((cpu_subtype_t) 7) +#define CPU_SUBTYPE_POWERPC_620 ((cpu_subtype_t) 8) +#define CPU_SUBTYPE_POWERPC_750 ((cpu_subtype_t) 9) +#define CPU_SUBTYPE_POWERPC_7400 ((cpu_subtype_t) 10) +#define CPU_SUBTYPE_POWERPC_7450 ((cpu_subtype_t) 11) +#define CPU_SUBTYPE_POWERPC_970 ((cpu_subtype_t) 100) + +/* + * ARM subtypes + */ +#define CPU_SUBTYPE_ARM_ALL ((cpu_subtype_t) 0) +#define CPU_SUBTYPE_ARM_V4T ((cpu_subtype_t) 5) +#define CPU_SUBTYPE_ARM_V6 ((cpu_subtype_t) 6) +#define CPU_SUBTYPE_ARM_V5TEJ ((cpu_subtype_t) 7) +#define CPU_SUBTYPE_ARM_XSCALE ((cpu_subtype_t) 8) +#define CPU_SUBTYPE_ARM_V7 ((cpu_subtype_t) 9) /* ARMv7-A and ARMv7-R */ +#define CPU_SUBTYPE_ARM_V7F ((cpu_subtype_t) 10) /* Cortex A9 */ +#define CPU_SUBTYPE_ARM_V7S ((cpu_subtype_t) 11) /* Swift */ +#define CPU_SUBTYPE_ARM_V7K ((cpu_subtype_t) 12) +#define CPU_SUBTYPE_ARM_V8 ((cpu_subtype_t) 13) +#define CPU_SUBTYPE_ARM_V6M ((cpu_subtype_t) 14) /* Not meant to be run under xnu */ +#define CPU_SUBTYPE_ARM_V7M ((cpu_subtype_t) 15) /* Not meant to be run under xnu */ +#define CPU_SUBTYPE_ARM_V7EM ((cpu_subtype_t) 16) /* Not meant to be run under xnu */ +#define CPU_SUBTYPE_ARM_V8M ((cpu_subtype_t) 17) /* Not meant to be run under xnu */ + +/* + * ARM64 subtypes + */ +#define CPU_SUBTYPE_ARM64_ALL ((cpu_subtype_t) 0) +#define CPU_SUBTYPE_ARM64_V8 ((cpu_subtype_t) 1) +#define CPU_SUBTYPE_ARM64E ((cpu_subtype_t) 2) + +/* CPU subtype feature flags for ptrauth on arm64e platforms */ +#define CPU_SUBTYPE_ARM64_PTR_AUTH_MASK 0x0f000000 +#define CPU_SUBTYPE_ARM64_PTR_AUTH_VERSION(x) (((x) & CPU_SUBTYPE_ARM64_PTR_AUTH_MASK) >> 24) + +/* + * ARM64_32 subtypes + */ +#define CPU_SUBTYPE_ARM64_32_ALL ((cpu_subtype_t) 0) +#define CPU_SUBTYPE_ARM64_32_V8 ((cpu_subtype_t) 1) + +#endif /* !__ASSEMBLER__ */ + +/* + * CPU families (sysctl hw.cpufamily) + * + * These are meant to identify the CPU's marketing name - an + * application can map these to (possibly) localized strings. + * NB: the encodings of the CPU families are intentionally arbitrary. + * There is no ordering, and you should never try to deduce whether + * or not some feature is available based on the family. + * Use feature flags (eg, hw.optional.altivec) to test for optional + * functionality. + */ +#define CPUFAMILY_UNKNOWN 0 +#define CPUFAMILY_POWERPC_G3 0xcee41549 +#define CPUFAMILY_POWERPC_G4 0x77c184ae +#define CPUFAMILY_POWERPC_G5 0xed76d8aa +#define CPUFAMILY_INTEL_6_13 0xaa33392b +#define CPUFAMILY_INTEL_PENRYN 0x78ea4fbc +#define CPUFAMILY_INTEL_NEHALEM 0x6b5a4cd2 +#define CPUFAMILY_INTEL_WESTMERE 0x573b5eec +#define CPUFAMILY_INTEL_SANDYBRIDGE 0x5490b78c +#define CPUFAMILY_INTEL_IVYBRIDGE 0x1f65e835 +#define CPUFAMILY_INTEL_HASWELL 0x10b282dc +#define CPUFAMILY_INTEL_BROADWELL 0x582ed09c +#define CPUFAMILY_INTEL_SKYLAKE 0x37fc219f +#define CPUFAMILY_INTEL_KABYLAKE 0x0f817246 +#define CPUFAMILY_INTEL_ICELAKE 0x38435547 +#define CPUFAMILY_INTEL_COMETLAKE 0x1cf8a03e +#define CPUFAMILY_ARM_9 0xe73283ae +#define CPUFAMILY_ARM_11 0x8ff620d8 +#define CPUFAMILY_ARM_XSCALE 0x53b005f5 +#define CPUFAMILY_ARM_12 0xbd1b0ae9 +#define CPUFAMILY_ARM_13 0x0cc90e64 +#define CPUFAMILY_ARM_14 0x96077ef1 +#define CPUFAMILY_ARM_15 0xa8511bca +#define CPUFAMILY_ARM_SWIFT 0x1e2d6381 +#define CPUFAMILY_ARM_CYCLONE 0x37a09642 +#define CPUFAMILY_ARM_TYPHOON 0x2c91a47e +#define CPUFAMILY_ARM_TWISTER 0x92fb37c8 +#define CPUFAMILY_ARM_HURRICANE 0x67ceee93 +#define CPUFAMILY_ARM_MONSOON_MISTRAL 0xe81e7ef6 +#define CPUFAMILY_ARM_VORTEX_TEMPEST 0x07d34b9f +#define CPUFAMILY_ARM_LIGHTNING_THUNDER 0x462504d2 +#define CPUFAMILY_ARM_FIRESTORM_ICESTORM 0x1b588bb3 +#define CPUFAMILY_ARM_BLIZZARD_AVALANCHE 0xda33d83d +#define CPUFAMILY_ARM_EVEREST_SAWTOOTH 0x8765edea + +/* Described in rdar://64125549 */ +#define CPUSUBFAMILY_UNKNOWN 0 +#define CPUSUBFAMILY_ARM_HP 1 +#define CPUSUBFAMILY_ARM_HG 2 +#define CPUSUBFAMILY_ARM_M 3 +#define CPUSUBFAMILY_ARM_HS 4 +#define CPUSUBFAMILY_ARM_HC_HD 5 +#define CPUSUBFAMILY_ARM_HA 6 + +/* The following synonyms are deprecated: */ +#define CPUFAMILY_INTEL_6_23 CPUFAMILY_INTEL_PENRYN +#define CPUFAMILY_INTEL_6_26 CPUFAMILY_INTEL_NEHALEM + + +#endif /* _MACH_MACHINE_H_ */ \ No newline at end of file diff --git a/I. Mach-O/mac/nlist.h b/I. Mach-O/mac/nlist.h new file mode 100644 index 0000000..9033bee --- /dev/null +++ b/I. Mach-O/mac/nlist.h @@ -0,0 +1,320 @@ +// Extracted from Xcode 15 Beta 7 +// /Library/Developer/CommandLineTools/SDKs/MacOSX14.0.sdk/System/Library/Frameworks/Kernel.framework/Versions/A/Headers/mach-o/nlist.h */ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +#ifndef _MACHO_NLIST_H_ +#define _MACHO_NLIST_H_ +/* $NetBSD: nlist.h,v 1.5 1994/10/26 00:56:11 cgd Exp $ */ + +/*- + * Copyright (c) 1991, 1993 + * The Regents of the University of California. All rights reserved. + * (c) UNIX System Laboratories, Inc. + * All or some portions of this file are derived from material licensed + * to the University of California by American Telephone and Telegraph + * Co. or Unix System Laboratories, Inc. and are reproduced herein with + * the permission of UNIX System Laboratories, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)nlist.h 8.2 (Berkeley) 1/21/94 + */ +#include + +/* + * Format of a symbol table entry of a Mach-O file for 32-bit architectures. + * Modified from the BSD format. The modifications from the original format + * were changing n_other (an unused field) to n_sect and the addition of the + * N_SECT type. These modifications are required to support symbols in a larger + * number of sections not just the three sections (text, data and bss) in a BSD + * file. + */ +struct nlist { + union { +#ifndef __LP64__ + char *n_name; /* for use when in-core */ +#endif + uint32_t n_strx; /* index into the string table */ + } n_un; + uint8_t n_type; /* type flag, see below */ + uint8_t n_sect; /* section number or NO_SECT */ + int16_t n_desc; /* see */ + uint32_t n_value; /* value of this symbol (or stab offset) */ +}; + +/* + * This is the symbol table entry structure for 64-bit architectures. + */ +struct nlist_64 { + union { + uint32_t n_strx; /* index into the string table */ + } n_un; + uint8_t n_type; /* type flag, see below */ + uint8_t n_sect; /* section number or NO_SECT */ + uint16_t n_desc; /* see */ + uint64_t n_value; /* value of this symbol (or stab offset) */ +}; + +/* + * Symbols with a index into the string table of zero (n_un.n_strx == 0) are + * defined to have a null, "", name. Therefore all string indexes to non null + * names must not have a zero string index. This is bit historical information + * that has never been well documented. + */ + +/* + * The n_type field really contains four fields: + * unsigned char N_STAB:3, + * N_PEXT:1, + * N_TYPE:3, + * N_EXT:1; + * which are used via the following masks. + */ +#define N_STAB 0xe0 /* if any of these bits set, a symbolic debugging entry */ +#define N_PEXT 0x10 /* private external symbol bit */ +#define N_TYPE 0x0e /* mask for the type bits */ +#define N_EXT 0x01 /* external symbol bit, set for external symbols */ + +/* + * Only symbolic debugging entries have some of the N_STAB bits set and if any + * of these bits are set then it is a symbolic debugging entry (a stab). In + * which case then the values of the n_type field (the entire field) are given + * in + */ + +/* + * Values for N_TYPE bits of the n_type field. + */ +#define N_UNDF 0x0 /* undefined, n_sect == NO_SECT */ +#define N_ABS 0x2 /* absolute, n_sect == NO_SECT */ +#define N_SECT 0xe /* defined in section number n_sect */ +#define N_PBUD 0xc /* prebound undefined (defined in a dylib) */ +#define N_INDR 0xa /* indirect */ + +/* + * If the type is N_INDR then the symbol is defined to be the same as another + * symbol. In this case the n_value field is an index into the string table + * of the other symbol's name. When the other symbol is defined then they both + * take on the defined type and value. + */ + +/* + * If the type is N_SECT then the n_sect field contains an ordinal of the + * section the symbol is defined in. The sections are numbered from 1 and + * refer to sections in order they appear in the load commands for the file + * they are in. This means the same ordinal may very well refer to different + * sections in different files. + * + * The n_value field for all symbol table entries (including N_STAB's) gets + * updated by the link editor based on the value of it's n_sect field and where + * the section n_sect references gets relocated. If the value of the n_sect + * field is NO_SECT then it's n_value field is not changed by the link editor. + */ +#define NO_SECT 0 /* symbol is not in any section */ +#define MAX_SECT 255 /* 1 thru 255 inclusive */ + +/* + * Common symbols are represented by undefined (N_UNDF) external (N_EXT) types + * who's values (n_value) are non-zero. In which case the value of the n_value + * field is the size (in bytes) of the common symbol. The n_sect field is set + * to NO_SECT. The alignment of a common symbol may be set as a power of 2 + * between 2^1 and 2^15 as part of the n_desc field using the macros below. If + * the alignment is not set (a value of zero) then natural alignment based on + * the size is used. + */ +#define GET_COMM_ALIGN(n_desc) (((n_desc) >> 8) & 0x0f) +#define SET_COMM_ALIGN(n_desc,align) \ + (n_desc) = (((n_desc) & 0xf0ff) | (((align) & 0x0f) << 8)) + +/* + * To support the lazy binding of undefined symbols in the dynamic link-editor, + * the undefined symbols in the symbol table (the nlist structures) are marked + * with the indication if the undefined reference is a lazy reference or + * non-lazy reference. If both a non-lazy reference and a lazy reference is + * made to the same symbol the non-lazy reference takes precedence. A reference + * is lazy only when all references to that symbol are made through a symbol + * pointer in a lazy symbol pointer section. + * + * The implementation of marking nlist structures in the symbol table for + * undefined symbols will be to use some of the bits of the n_desc field as a + * reference type. The mask REFERENCE_TYPE will be applied to the n_desc field + * of an nlist structure for an undefined symbol to determine the type of + * undefined reference (lazy or non-lazy). + * + * The constants for the REFERENCE FLAGS are propagated to the reference table + * in a shared library file. In that case the constant for a defined symbol, + * REFERENCE_FLAG_DEFINED, is also used. + */ +/* Reference type bits of the n_desc field of undefined symbols */ +#define REFERENCE_TYPE 0x7 +/* types of references */ +#define REFERENCE_FLAG_UNDEFINED_NON_LAZY 0 +#define REFERENCE_FLAG_UNDEFINED_LAZY 1 +#define REFERENCE_FLAG_DEFINED 2 +#define REFERENCE_FLAG_PRIVATE_DEFINED 3 +#define REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY 4 +#define REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY 5 + +/* + * To simplify stripping of objects that use are used with the dynamic link + * editor, the static link editor marks the symbols defined an object that are + * referenced by a dynamicly bound object (dynamic shared libraries, bundles). + * With this marking strip knows not to strip these symbols. + */ +#define REFERENCED_DYNAMICALLY 0x0010 + +/* + * For images created by the static link editor with the -twolevel_namespace + * option in effect the flags field of the mach header is marked with + * MH_TWOLEVEL. And the binding of the undefined references of the image are + * determined by the static link editor. Which library an undefined symbol is + * bound to is recorded by the static linker in the high 8 bits of the n_desc + * field using the SET_LIBRARY_ORDINAL macro below. The ordinal recorded + * references the libraries listed in the Mach-O's LC_LOAD_DYLIB, + * LC_LOAD_WEAK_DYLIB, LC_REEXPORT_DYLIB, LC_LOAD_UPWARD_DYLIB, and + * LC_LAZY_LOAD_DYLIB, etc. load commands in the order they appear in the + * headers. The library ordinals start from 1. + * For a dynamic library that is built as a two-level namespace image the + * undefined references from module defined in another use the same nlist struct + * an in that case SELF_LIBRARY_ORDINAL is used as the library ordinal. For + * defined symbols in all images they also must have the library ordinal set to + * SELF_LIBRARY_ORDINAL. The EXECUTABLE_ORDINAL refers to the executable + * image for references from plugins that refer to the executable that loads + * them. + * + * The DYNAMIC_LOOKUP_ORDINAL is for undefined symbols in a two-level namespace + * image that are looked up by the dynamic linker with flat namespace semantics. + * This ordinal was added as a feature in Mac OS X 10.3 by reducing the + * value of MAX_LIBRARY_ORDINAL by one. So it is legal for existing binaries + * or binaries built with older tools to have 0xfe (254) dynamic libraries. In + * this case the ordinal value 0xfe (254) must be treated as a library ordinal + * for compatibility. + */ +#define GET_LIBRARY_ORDINAL(n_desc) (((n_desc) >> 8) & 0xff) +#define SET_LIBRARY_ORDINAL(n_desc,ordinal) \ + (n_desc) = (((n_desc) & 0x00ff) | (((ordinal) & 0xff) << 8)) +#define SELF_LIBRARY_ORDINAL 0x0 +#define MAX_LIBRARY_ORDINAL 0xfd +#define DYNAMIC_LOOKUP_ORDINAL 0xfe +#define EXECUTABLE_ORDINAL 0xff + +/* + * The bit 0x0020 of the n_desc field is used for two non-overlapping purposes + * and has two different symbolic names, N_NO_DEAD_STRIP and N_DESC_DISCARDED. + */ + +/* + * The N_NO_DEAD_STRIP bit of the n_desc field only ever appears in a + * relocatable .o file (MH_OBJECT filetype). And is used to indicate to the + * static link editor it is never to dead strip the symbol. + */ +#define N_NO_DEAD_STRIP 0x0020 /* symbol is not to be dead stripped */ + +/* + * The N_DESC_DISCARDED bit of the n_desc field never appears in linked image. + * But is used in very rare cases by the dynamic link editor to mark an in + * memory symbol as discared and longer used for linking. + */ +#define N_DESC_DISCARDED 0x0020 /* symbol is discarded */ + +/* + * The N_WEAK_REF bit of the n_desc field indicates to the dynamic linker that + * the undefined symbol is allowed to be missing and is to have the address of + * zero when missing. + */ +#define N_WEAK_REF 0x0040 /* symbol is weak referenced */ + +/* + * The N_WEAK_DEF bit of the n_desc field indicates to the static and dynamic + * linkers that the symbol definition is weak, allowing a non-weak symbol to + * also be used which causes the weak definition to be discared. Currently this + * is only supported for symbols in coalesed sections. + */ +#define N_WEAK_DEF 0x0080 /* coalesed symbol is a weak definition */ + +/* + * The N_REF_TO_WEAK bit of the n_desc field indicates to the dynamic linker + * that the undefined symbol should be resolved using flat namespace searching. + */ +#define N_REF_TO_WEAK 0x0080 /* reference to a weak symbol */ + +/* + * The N_ARM_THUMB_DEF bit of the n_desc field indicates that the symbol is + * a defintion of a Thumb function. + */ +#define N_ARM_THUMB_DEF 0x0008 /* symbol is a Thumb function (ARM) */ + +/* + * The N_SYMBOL_RESOLVER bit of the n_desc field indicates that the + * that the function is actually a resolver function and should + * be called to get the address of the real function to use. + * This bit is only available in .o files (MH_OBJECT filetype) + */ +#define N_SYMBOL_RESOLVER 0x0100 + +/* + * The N_ALT_ENTRY bit of the n_desc field indicates that the + * symbol is pinned to the previous content. + */ +#define N_ALT_ENTRY 0x0200 + +#ifndef __STRICT_BSD__ +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ +/* + * The function nlist(3) from the C library. + */ +extern int nlist (const char *filename, struct nlist *list); +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* __STRICT_BSD__ */ + +#endif /* _MACHO_LIST_H_ */ \ No newline at end of file diff --git a/I. Mach-O/mac/vm_param.h b/I. Mach-O/mac/vm_param.h new file mode 100644 index 0000000..7d130cf --- /dev/null +++ b/I. Mach-O/mac/vm_param.h @@ -0,0 +1,207 @@ +// Extracted from Xcode 15 Beta 7 +/* /Library/Developer/CommandLineTools/SDKs/MacOSX14.0.sdk/System/Library/Frameworks/Kernel.framework/Versions/A/Headers/mach/arm/vm_param.h */ +/* + * Copyright (c) 2007 Apple Inc. All rights reserved. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. + * + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ + */ +/* + * FILE_ID: vm_param.h + */ + +/* + * ARM machine dependent virtual memory parameters. + */ + +#ifndef _MACH_ARM_VM_PARAM_H_ +#define _MACH_ARM_VM_PARAM_H_ + +#if defined (__arm__) || defined (__arm64__) + + + + +#define BYTE_SIZE 8 /* byte size in bits */ + + +#ifndef __ASSEMBLER__ + +#ifdef __arm__ +#define PAGE_SHIFT_CONST 12 +#elif defined(__arm64__) +extern int PAGE_SHIFT_CONST; +#else +#error Unsupported arch +#endif + +#define PAGE_SHIFT PAGE_SHIFT_CONST +#define PAGE_SIZE (1 << PAGE_SHIFT) +#define PAGE_MASK (PAGE_SIZE-1) + +#define VM_PAGE_SIZE PAGE_SIZE + +#define machine_ptob(x) ((x) << PAGE_SHIFT) + +/* + * Defined for the purpose of testing the pmap advertised page + * size; this does not necessarily match the hardware page size. + */ +#define TEST_PAGE_SIZE_16K ((PAGE_SHIFT_CONST == 14)) +#define TEST_PAGE_SIZE_4K ((PAGE_SHIFT_CONST == 12)) + +#endif /* !__ASSEMBLER__ */ + + +#define PAGE_MAX_SHIFT 14 +#define PAGE_MAX_SIZE (1 << PAGE_MAX_SHIFT) +#define PAGE_MAX_MASK (PAGE_MAX_SIZE-1) + +#define PAGE_MIN_SHIFT 12 +#define PAGE_MIN_SIZE (1 << PAGE_MIN_SHIFT) +#define PAGE_MIN_MASK (PAGE_MIN_SIZE-1) + +#define VM_MAX_PAGE_ADDRESS MACH_VM_MAX_ADDRESS + +#ifndef __ASSEMBLER__ + + +#if defined (__arm__) + +#define VM_MIN_ADDRESS ((vm_address_t) 0x00000000) +#define VM_MAX_ADDRESS ((vm_address_t) 0x80000000) + +/* system-wide values */ +#define MACH_VM_MIN_ADDRESS ((mach_vm_offset_t) 0) +#define MACH_VM_MAX_ADDRESS ((mach_vm_offset_t) VM_MAX_ADDRESS) + +#elif defined (__arm64__) + +#define VM_MIN_ADDRESS ((vm_address_t) 0x0000000000000000ULL) +#define VM_MAX_ADDRESS ((vm_address_t) 0x00000000F0000000ULL) + +/* system-wide values */ +#define MACH_VM_MIN_ADDRESS_RAW 0x0ULL +#define MACH_VM_MAX_ADDRESS_RAW 0x00007FFFFE000000ULL + +#define MACH_VM_MIN_ADDRESS ((mach_vm_offset_t) MACH_VM_MIN_ADDRESS_RAW) +#define MACH_VM_MAX_ADDRESS ((mach_vm_offset_t) MACH_VM_MAX_ADDRESS_RAW) + +#define MACH_VM_MIN_GPU_CARVEOUT_ADDRESS_RAW 0x0000001000000000ULL +#define MACH_VM_MAX_GPU_CARVEOUT_ADDRESS_RAW 0x0000007000000000ULL +#define MACH_VM_MIN_GPU_CARVEOUT_ADDRESS ((mach_vm_offset_t) MACH_VM_MIN_GPU_CARVEOUT_ADDRESS_RAW) +#define MACH_VM_MAX_GPU_CARVEOUT_ADDRESS ((mach_vm_offset_t) MACH_VM_MAX_GPU_CARVEOUT_ADDRESS_RAW) + +#else /* defined(__arm64__) */ +#error architecture not supported +#endif + +#define VM_MAP_MIN_ADDRESS VM_MIN_ADDRESS +#define VM_MAP_MAX_ADDRESS VM_MAX_ADDRESS + + +#if defined (__arm__) +#define VM_KERNEL_POINTER_SIGNIFICANT_BITS 31 +#define VM_MIN_KERNEL_ADDRESS ((vm_address_t) 0x80000000) +#define VM_MAX_KERNEL_ADDRESS ((vm_address_t) 0xFFFEFFFF) +#define VM_HIGH_KERNEL_WINDOW ((vm_address_t) 0xFFFE0000) + +#elif defined (__arm64__) +/* + * kalloc() parameters: + * + * Historically kalloc's underlying zones were power-of-2 sizes, with a + * KALLOC_MINSIZE of 16 bytes. Thus the allocator ensured that + * (sizeof == alignof) >= 16 for all kalloc allocations. + * + * Today kalloc may use zones with intermediate (small) sizes, constrained by + * KALLOC_MINSIZE and a minimum alignment, expressed by KALLOC_LOG2_MINALIGN. + * + * Note that most dynamically allocated data structures contain more than + * one int/long/pointer member, so KALLOC_MINSIZE should probably start at 8. + */ +#define TiB(x) ((0ULL + (x)) << 40) +#define GiB(x) ((0ULL + (x)) << 30) +#define KALLOC_MINSIZE 16 /* minimum allocation size */ +#define KALLOC_LOG2_MINALIGN 4 /* log2 minimum alignment */ + +/* + * The minimum and maximum kernel address; some configurations may + * constrain the address space further. + */ + +// Inform kexts about largest possible kernel address space +#define VM_KERNEL_POINTER_SIGNIFICANT_BITS 41 +#define VM_MIN_KERNEL_ADDRESS ((vm_address_t) (0ULL - TiB(2))) +#define VM_MAX_KERNEL_ADDRESS ((vm_address_t) 0xfffffffbffffffffULL) +#else +#error architecture not supported +#endif + +#define VM_MIN_KERNEL_AND_KEXT_ADDRESS VM_MIN_KERNEL_ADDRESS + +#if defined (__arm64__) +/* Top-Byte-Ignore */ +#define ARM_TBI_USER_MASK (0xFF00000000000000ULL) +#define VM_USER_STRIP_TBI(_v) ((typeof (_v))(((uintptr_t)(_v)) &~ (ARM_TBI_USER_MASK))) +#else /* __arm64__ */ +#define VM_USER_STRIP_TBI(_v) (_v) +#endif /* __arm64__ */ + +#if CONFIG_KERNEL_TAGGING +#include +/* + * 'strip' in PAC sense, therefore replacing the stripped bits sign extending + * the sign bit. In kernel space the sign bit is 1, so 0xFF is a valid mask + * here. + */ +#define VM_KERNEL_STRIP_TAG(_v) (vm_memtag_canonicalize_address((vm_offset_t)_v)) +#else /* CONFIG_KERNEL_TAGGING */ +#define VM_KERNEL_STRIP_TAG(_v) (_v) +#endif /* CONFIG_KERNEL_TAGGING */ + +#if __has_feature(ptrauth_calls) +#include +#define VM_KERNEL_STRIP_PAC(_v) (ptrauth_strip((void *)(uintptr_t)(_v), ptrauth_key_asia)) +#else /* !ptrauth_calls */ +#define VM_KERNEL_STRIP_PAC(_v) (_v) +#endif /* ptrauth_calls */ + +#define VM_KERNEL_STRIP_PTR(_va) ((VM_KERNEL_STRIP_TAG(VM_KERNEL_STRIP_PAC((_va))))) +#define VM_KERNEL_STRIP_UPTR(_va) ((vm_address_t)VM_KERNEL_STRIP_PTR((uintptr_t)(_va))) +#define VM_KERNEL_ADDRESS(_va) \ + ((VM_KERNEL_STRIP_UPTR(_va) >= VM_MIN_KERNEL_ADDRESS) && \ + (VM_KERNEL_STRIP_UPTR(_va) <= VM_MAX_KERNEL_ADDRESS)) + +#define VM_USER_STRIP_PTR(_v) (VM_USER_STRIP_TBI(_v)) + + + +#endif /* !__ASSEMBLER__ */ + +#define SWI_SYSCALL 0x80 + +#endif /* defined (__arm__) || defined (__arm64__) */ + +#endif /* _MACH_ARM_VM_PARAM_H_ */ \ No newline at end of file diff --git a/I. Mach-O/mac/vm_prot.h b/I. Mach-O/mac/vm_prot.h new file mode 100644 index 0000000..2b70c5f --- /dev/null +++ b/I. Mach-O/mac/vm_prot.h @@ -0,0 +1,191 @@ +// Extracted from Xcode 15 Beta 7 +// /Library/Developer/CommandLineTools/SDKs/MacOSX14.0.sdk/System/Library/Frameworks/Kernel.framework/Versions/A/Headers/mach/vm_prot.h */ + +/* + * Copyright (c) 2000-2021 Apple Computer, Inc. All rights reserved. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. + * + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ + */ +/* + * @OSF_COPYRIGHT@ + */ +/* + * Mach Operating System + * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University + * All Rights Reserved. + * + * Permission to use, copy, modify and distribute this software and its + * documentation is hereby granted, provided that both the copyright + * notice and this permission notice appear in all copies of the + * software, derivative works or modified versions, and any portions + * thereof, and that both notices appear in supporting documentation. + * + * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" + * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR + * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. + * + * Carnegie Mellon requests users of this software to return to + * + * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU + * School of Computer Science + * Carnegie Mellon University + * Pittsburgh PA 15213-3890 + * + * any improvements or extensions that they make and grant Carnegie Mellon + * the rights to redistribute these changes. + */ +/* + */ +/* + * File: mach/vm_prot.h + * Author: Avadis Tevanian, Jr., Michael Wayne Young + * + * Virtual memory protection definitions. + * + */ + +#ifndef _MACH_VM_PROT_H_ +#define _MACH_VM_PROT_H_ + +/* + * Types defined: + * + * vm_prot_t VM protection values. + */ + +typedef int vm_prot_t; + +/* + * Protection values, defined as bits within the vm_prot_t type + */ + +#define VM_PROT_NONE ((vm_prot_t) 0x00) + +#define VM_PROT_READ ((vm_prot_t) 0x01) /* read permission */ +#define VM_PROT_WRITE ((vm_prot_t) 0x02) /* write permission */ +#define VM_PROT_EXECUTE ((vm_prot_t) 0x04) /* execute permission */ + +/* + * The default protection for newly-created virtual memory + */ + +#define VM_PROT_DEFAULT (VM_PROT_READ|VM_PROT_WRITE) + +/* + * The maximum privileges possible, for parameter checking. + */ + +#define VM_PROT_ALL (VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE) + +/* + * This is an alias to VM_PROT_EXECUTE to identify callers that + * want to allocate an hardware assisted Read-only/read-write + * trusted path in userland. + */ +#define VM_PROT_RORW_TP (VM_PROT_EXECUTE) + +/* + * An invalid protection value. + * Used only by memory_object_lock_request to indicate no change + * to page locks. Using -1 here is a bad idea because it + * looks like VM_PROT_ALL and then some. + */ + +#define VM_PROT_NO_CHANGE_LEGACY ((vm_prot_t) 0x08) +#define VM_PROT_NO_CHANGE ((vm_prot_t) 0x01000000) + +/* + * When a caller finds that he cannot obtain write permission on a + * mapped entry, the following flag can be used. The entry will + * be made "needs copy" effectively copying the object (using COW), + * and write permission will be added to the maximum protections + * for the associated entry. + */ + +#define VM_PROT_COPY ((vm_prot_t) 0x10) + + +/* + * Another invalid protection value. + * Used only by memory_object_data_request upon an object + * which has specified a copy_call copy strategy. It is used + * when the kernel wants a page belonging to a copy of the + * object, and is only asking the object as a result of + * following a shadow chain. This solves the race between pages + * being pushed up by the memory manager and the kernel + * walking down the shadow chain. + */ + +#define VM_PROT_WANTS_COPY ((vm_prot_t) 0x10) + + +/* + * Another invalid protection value. + * Indicates that the other protection bits are to be applied as a mask + * against the actual protection bits of the map entry. + */ +#define VM_PROT_IS_MASK ((vm_prot_t) 0x40) + +/* + * Another invalid protection value to support execute-only protection. + * VM_PROT_STRIP_READ is a special marker that tells mprotect to not + * set VM_PROT_READ. We have to do it this way because existing code + * expects the system to set VM_PROT_READ if VM_PROT_EXECUTE is set. + * VM_PROT_EXECUTE_ONLY is just a convenience value to indicate that + * the memory should be executable and explicitly not readable. It will + * be ignored on platforms that do not support this type of protection. + */ +#define VM_PROT_STRIP_READ ((vm_prot_t) 0x80) +#define VM_PROT_EXECUTE_ONLY (VM_PROT_EXECUTE|VM_PROT_STRIP_READ) + + +/* + * Another invalid protection value to support pager TPRO protection. + * VM_PROT_TPRO is a special marker that tells the a pager to + * set TPRO flags on a given entry. We do it this way to prevent + * bloating the pager structures and it allows dyld to pass through + * this flag in lieue of specifying explicit VM flags, allowing us to handle + * the final permissions internally. + */ +#define VM_PROT_TPRO ((vm_prot_t) 0x200) + +#if defined(__x86_64__) +/* + * Another invalid protection value to support specifying different + * execute permissions for user- and supervisor- modes. When + * MBE is enabled in a VM, VM_PROT_EXECUTE is used to indicate + * supervisor-mode execute permission, and VM_PROT_UEXEC specifies + * user-mode execute permission. Currently only used by the + * x86 Hypervisor kext. + */ +#define VM_PROT_UEXEC ((vm_prot_t) 0x8) /* User-mode Execute Permission */ + +#define VM_PROT_ALLEXEC (VM_PROT_EXECUTE | VM_PROT_UEXEC) +#else +#define VM_PROT_ALLEXEC (VM_PROT_EXECUTE) +#endif /* defined(__x86_64__) */ + + +#endif /* _MACH_VM_PROT_H_ */ \ No newline at end of file diff --git a/I. Mach-O/mac/vmparam.h b/I. Mach-O/mac/vmparam.h new file mode 100644 index 0000000..9ab244c --- /dev/null +++ b/I. Mach-O/mac/vmparam.h @@ -0,0 +1,57 @@ +// Source: https://github.com/apple-oss-distributions/xnu/blob/xnu-10002.61.3/bsd/arm/vmparam.h + +/* + * Copyright (c) 2000-2007 Apple Inc. All rights reserved. + */ + +#ifndef _BSD_ARM_VMPARAM_H_ +#define _BSD_ARM_VMPARAM_H_ 1 + +#if defined (__arm__) || defined (__arm64__) + +#include + +#ifndef KERNEL +#include +#endif + +#define USRSTACK (0x27E00000) /* ASLR slides stack down by up to 1MB */ +#define USRSTACK64 (0x000000016FE00000ULL) + +/* + * Virtual memory related constants, all in bytes + */ +#ifndef DFLDSIZ +#define DFLDSIZ (RLIM_INFINITY) /* initial data size limit */ +#endif +#ifndef MAXDSIZ +#define MAXDSIZ (RLIM_INFINITY) /* max data size */ +#endif +#ifndef DFLSSIZ +/* XXX stack size default is a platform property: use getrlimit(2) */ +#if (defined(TARGET_OS_OSX) && (TARGET_OS_OSX != 0)) || \ + (defined(KERNEL) && XNU_TARGET_OS_OSX) +#define DFLSSIZ (8*1024*1024 - 16*1024) +#else +#define DFLSSIZ (1024*1024 - 16*1024) /* initial stack size limit */ +#endif /* TARGET_OS_OSX .. || XNU_KERNEL_PRIVATE .. */ +#endif /* DFLSSIZ */ +#ifndef MAXSSIZ +/* XXX stack size limit is a platform property: use getrlimit(2) */ +#if (defined(TARGET_OS_OSX) && (TARGET_OS_OSX != 0)) || \ + (defined(KERNEL) && XNU_TARGET_OS_OSX) +#define MAXSSIZ (64*1024*1024) /* max stack size */ +#else +#define MAXSSIZ (1024*1024) /* max stack size */ +#endif /* TARGET_OS_OSX .. || XNU_KERNEL_PRIVATE .. */ +#endif /* MAXSSIZ */ +#ifndef DFLCSIZ +#define DFLCSIZ (0) /* initial core size limit */ +#endif +#ifndef MAXCSIZ +#define MAXCSIZ (RLIM_INFINITY) /* max core size */ +#endif /* MAXCSIZ */ + +#endif /* defined (__arm__) || defined (__arm64__) */ + +#endif /* _BSD_ARM_VMPARAM_H_ */ \ No newline at end of file diff --git a/I. Mach-O/python/CrimsonUroboros.py b/I. Mach-O/python/CrimsonUroboros.py new file mode 100755 index 0000000..16fe4fd --- /dev/null +++ b/I. Mach-O/python/CrimsonUroboros.py @@ -0,0 +1,285 @@ +#!/usr/bin/env python3 +import lief +import uuid +import argparse +import subprocess +from asn1crypto.cms import ContentInfo +import os +import sys + +### --- I. MACH-O --- ### +class SnakeI: + def __init__(self, binaries): + '''When initiated, the program parses a Universal binary (binaries parameter) and extracts the ARM64 Mach-O. If the file is not in a universal format but is a valid ARM64 Mach-O, it is taken as a binary parameter during initialization.''' + self.binary = self.parseFatBinary(binaries) + self.fat_offset = self.binary.fat_offset # For various calculations, if ARM64 Mach-O extracted from Universal Binary + self.prot_map = { + 0: '---', + 1: 'r--', + 2: '-w-', + 3: 'rw-', + 4: '--x', + 5: 'r-x', + 6: '-wx', + 7: 'rwx' + } + self.segment_flags_map = { + 0x1: 'SG_HIGHVM', + 0x2: 'SG_FVMLIB', + 0x4: 'SG_NORELOC', + 0x8: 'SG_PROTECTED_VERSION_1', + 0x10: 'SG_READ_ONLY', + } + + def mapProtection(self, numeric_protection): + '''Maps numeric protection to its string representation.''' + return self.prot_map.get(numeric_protection, 'Unknown') + + def getSegmentFlags(self, flags): + '''Maps numeric segment flags to its string representation.''' + return self.segment_flags_map.get(flags, '') + #return " ".join(activated_flags) + + def parseFatBinary(self, binaries): + '''Parse Mach-O file, whether compiled for multiple architectures or just for a single one. It returns the ARM64 binary if it exists. If not, it exits the program.''' + for binary in binaries: + if binary.header.cpu_type == lief.MachO.CPU_TYPES.ARM64: + arm64_bin = binary + if arm64_bin == None: + print('The specified Mach-O file is not in ARM64 architecture.') + exit() + return arm64_bin + + def getFileType(self): + """Extract and return the file type from a binary object's header.""" + return self.binary.header.file_type.name + + def getHeaderFlags(self): + '''Return binary header flags.''' + return self.binary.header.flags_list + + def getEndianess(self): + '''Check the endianness of a binary based on the system and binary's magic number.''' + magic = self.binary.header.magic.name + endianness = sys.byteorder + if endianness == 'little' and (magic == 'MAGIC_64' or magic == 'MAGIC' or magic == 'FAT_MAGIC'): + return 'little' + else: + return 'big' + + def getBinaryHeader(self): + '''https://lief-project.github.io/doc/stable/api/python/macho.html#header''' + return self.binary.header + + def getLoadCommands(self): + '''https://lief-project.github.io/doc/stable/api/python/macho.html#loadcommand''' + return self.binary.commands + + def getSegments(self): + '''Extract segmenents from binary and return a human readable string: https://lief-project.github.io/doc/stable/api/python/macho.html#lief.MachO.SegmentCommand''' + segment_info = [] + for segment in self.binary.segments: + name = segment.name + va_start = '0x' + format(segment.virtual_address, '016x') + va_end = '0x' + format(int(va_start, 16) + segment.virtual_size, '016x') + file_start = hex(segment.file_size + self.fat_offset) + file_end = hex(int(file_start, 16) + segment.file_size) + init_prot = self.mapProtection(segment.init_protection) + max_prot = self.mapProtection(segment.max_protection) + flags = self.getSegmentFlags(segment.flags) + if flags != '': + segment_info.append(f'{name.ljust(16)}{init_prot}/{max_prot.ljust(8)} VM: {va_start}-{va_end.ljust(24)} FILE: {file_start}-{file_end} ({flags})') + else: + segment_info.append(f'{name.ljust(16)}{init_prot}/{max_prot.ljust(8)} VM: {va_start}-{va_end.ljust(24)} FILE: {file_start}-{file_end}') + return segment_info + + def getSections(self): + '''Extract sections from binary and return in human readable format: https://lief-project.github.io/doc/stable/api/python/macho.html#lief.MachO.Section''' + sections_info = [] + sections_info.append("SEGMENT".ljust(14) + "SECTION".ljust(20) + "TYPE".ljust(28) + "VIRTUAL MEMORY".ljust(32) + "FILE".ljust(26) + "FLAGS".ljust(40)) + sections_info.append(len(sections_info[0])*"=") + for section in self.binary.sections: + segment_name = section.segment_name + section_name = section.fullname + section_type = section.type.name + section_va_start = hex(section.virtual_address) + section_va_end = hex(section.virtual_address + section.offset) + section_size_start = hex(section.offset + self.fat_offset) + section_size_end = hex(section.size + section.offset + self.fat_offset) + section_flags_list = section.flags_list + flags_strings = [flag.name for flag in section_flags_list] + flags = " ".join(flags_strings) + sections_info.append((f'{segment_name.ljust(14)}{section_name.ljust(20)}{section_type.ljust(28)}{section_va_start}-{section_va_end.ljust(20)}{section_size_start}-{section_size_end}\t\t({flags})')) + return sections_info + + def getSymbols(self): + '''Get all symbols from the binary (LC_SYMTAB, Chained Fixups, Exports Trie): https://lief-project.github.io/doc/stable/api/python/macho.html#symbol''' + return self.binary.symbols + + def getChainedFixups(self): + '''Return Chained Fixups information: https://lief-project.github.io/doc/latest/api/python/macho.html#chained-binding-info''' + return self.binary.dyld_chained_fixups + + def getExportTrie(self): + '''Return Export Trie information: https://lief-project.github.io/doc/latest/api/python/macho.html#dyldexportstrie-command''' + try: + return self.binary.dyld_exports_trie.show_export_trie() + except: + return "NO EXPORT TRIE" + + def getUUID(self): + '''Return UUID as string and in UUID format: https://lief-project.github.io/doc/stable/api/python/macho.html#uuidcommand''' + for cmd in self.binary.commands: + if isinstance(cmd, lief.MachO.UUIDCommand): + uuid_bytes = cmd.uuid + break + uuid_string = str(uuid.UUID(bytes=bytes(uuid_bytes))) + return uuid_string + + def getMain(self): + '''Determine the entry point of an executable.''' + return self.binary.main_command + + def getStringSection(self): + '''Return strings from the __cstring (string table).''' + extracted_strings = set() + for section in self.binary.sections: + if section.type == lief.MachO.SECTION_TYPES.CSTRING_LITERALS: + extracted_strings.update(section.content.tobytes().split(b'\x00')) + return extracted_strings + + def findAllStringsInBinary(self): + '''Check every binary section to find strings.''' + extracted_strings = "" + byte_set = set() + for section in self.binary.sections: + byte_set.update(section.content.tobytes().split(b'\x00')) + for byte_item in byte_set: + try: + decoded_string = byte_item.decode('utf-8') + extracted_strings += decoded_string + "\n" + except UnicodeDecodeError: + pass + return extracted_strings +### --- --- --- ### + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Mach-O files parser for binary analysis.") + ### --- I. MACH-O --- ### + parser.add_argument('-p', '--path', required=True, help="Path to the Mach-O file.") + parser.add_argument('--file_type', action='store_true', help="Print binary file type.") + parser.add_argument('--header_flags', action='store_true', help="Print binary header flags.") + parser.add_argument('--endian', action='store_true', help="Print binary endianess.") + parser.add_argument('--header', action='store_true', help="Print binary header.") + parser.add_argument('--load_commands', action='store_true', help="Print binary load commands names.") + parser.add_argument('--segments', action='store_true', help="Print binary segments in human friendly form.") + parser.add_argument('--sections', action='store_true', help="Print binary sections in human friendly form.") + parser.add_argument('--symbols', action='store_true', help="Print all binary symbols.") + parser.add_argument('--chained_fixups', action='store_true', help="Print Chained Fixups information.") + parser.add_argument('--exports_trie', action='store_true', help="Print Export Trie information.") + parser.add_argument('--uuid', action='store_true', help="Print UUID.") + parser.add_argument('--main', action='store_true', help="Print entry point and stack size.") + parser.add_argument('--strings_section', action='store_true', help="Print strings from __cstring section.") + parser.add_argument('--all_strings', action='store_true', help="Print strings from all sections.") + parser.add_argument('--save_strings', help="Parse all sections, detect strings and save them to a file.") + parser.add_argument('--info', action='store_true', default=False , help="Print header, load commands, segments, sections, symbols and strings.") + + args = parser.parse_args() + file_path = os.path.abspath(args.path) + + ### --- I. MACH-O --- ### + try: # Check if the file is in a valid Mach-O format + if os.path.exists(file_path): + binaries = lief.MachO.parse(file_path) + snake_instance = SnakeI(binaries) + else: + print(f'The file {file_path} does not exist.') + exit() + except Exception as e: # Exit if not + print(f"An error occurred: {e}") + exit() + + if args.file_type: # Print binary file type + print(f'File type: {snake_instance.getFileType()}') + + if args.header_flags: # Print binary header flags + header_flag_list = snake_instance.getHeaderFlags() + print("Header flags:", " ".join(header_flag.name for header_flag in header_flag_list)) + + if args.endian: # Print binary endianess + print(f'Endianess: {snake_instance.getEndianess()}') + + if args.header: # Print binary header + print(snake_instance.getBinaryHeader()) + + if args.load_commands: # Print binary load commands + load_commands_list = snake_instance.getLoadCommands() + print("Load Commands:", " ".join(load_command.command.name for load_command in load_commands_list)) + + if args.segments: # Print binary segments in human friendly form + for segment in snake_instance.getSegments(): + print(segment) + + if args.sections: # Print binary sections in human friendly form + for section in snake_instance.getSections(): + print(section) + + if args.symbols: # Print symbols + for symbol in snake_instance.getSymbols(): + print(symbol.name) + + if args.chained_fixups: # Print Chained Fixups information + print(snake_instance.getChainedFixups()) + + if args.exports_trie: # Print Exports Trie information + print(snake_instance.getExportTrie()) + + if args.uuid: # Print UUID + print(f'UUID: {snake_instance.getUUID()}') + + if args.main: # Print entry point and stack size + print(f'Entry point: {hex(snake_instance.getMain().entrypoint)}') + print(f'Stack size: {hex(snake_instance.getMain().stack_size)}') + + if args.strings_section: # Print strings from __cstring section + print('Strings from __cstring section:') + print('-------------------------------') + for string in (snake_instance.getStringSection()): + print(string) + + if args.all_strings: # Print strings from all sections. + print(snake_instance.findAllStringsInBinary()) + + if args.save_strings: # Parse all sections, detect strings and save them to a file + extracted_strings = snake_instance.findAllStringsInBinary() + with open(args.save_strings, 'a') as f: + for s in extracted_strings: + f.write(s) + + if args.info: # Print all info about the binary + print('\n<=== HEADER ===>') + print(snake_instance.getBinaryHeader()) + print('\n<=== LOAD COMMANDS ===>') + for lcd in snake_instance.getLoadCommands(): + print(lcd) + print("="*50) + print('\n<=== SEGMENTS ===>') + for segment in snake_instance.getSegments(): + print(segment) + print('\n<=== SECTIONS ===>') + for section in snake_instance.getSections(): + print(section) + print('\n<=== SYMBOLS ===>') + for symbol in snake_instance.getSymbols(): + print(symbol.name) + print('\n<=== STRINGS ===>') + print('Strings from __cstring section:') + print('-------------------------------') + for string in (snake_instance.getStringSection()): + print(string) + print('\n<=== UUID ===>') + print(f'{snake_instance.getUUID()}') + print('\n<=== ENDIANESS ===>') + print(snake_instance.getEndianess()) + print('\n<=== ENTRYPOINT ===>') + print(f'{hex(snake_instance.getMain().entrypoint)}') \ No newline at end of file diff --git a/I. Mach-O/python/MachOFileFinder.py b/I. Mach-O/python/MachOFileFinder.py new file mode 100755 index 0000000..3382a5d --- /dev/null +++ b/I. Mach-O/python/MachOFileFinder.py @@ -0,0 +1,57 @@ +#!/usr/bin/env python3 +import os +import lief +import sys +import argparse + +class MachOFileFinder: + '''Class for finding ARM64 Mach-O binaries in a given directory.''' + + def __init__(self, directory_path, recursive=False): + '''Constructor to initialize the directory path and recursive flag.''' + self.directory_path = directory_path + self.recursive = recursive + + def parse_fat_binary(self, binaries): + '''Function to parse Mach-O file, whether compiled for multiple architectures or just for a single one. + It returns the ARM64 binary if it exists. If not, it exits the program.''' + arm64_bin = None + for binary in binaries: + if binary.header.cpu_type == lief.MachO.CPU_TYPES.ARM64: + arm64_bin = binary + return arm64_bin + + def process_directory(self, root, files): + '''Method to process all files in the specified directory.''' + for file_name in files: + file_path = os.path.abspath(os.path.join(root, file_name)) + try: + binaries = lief.MachO.parse(file_path) + binary = self.parse_fat_binary(binaries) + if binary is not None: + print(f"{binary.header.file_type.name}:{file_path}") + except: + pass # Ignore parsing errors or non-Mach-O files + + def process_files(self): + '''Method to process files based on the specified search type.''' + for root, dirs, files in os.walk(self.directory_path): + self.process_directory(root, files) + + if not self.recursive: + break # Break the loop if not searching recursively + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description='Find ARM64 Mach-O binaries in a directory.') + parser.add_argument('path', metavar='PATH', type=str, help='the directory path to search for Mach-O binaries') + parser.add_argument('-r', '--recursive', action='store_true', help='search recursively (default: false)') + + args = parser.parse_args() + directory_path = args.path + + if not os.path.isdir(directory_path): + print(f"Error: {directory_path} is not a valid directory.") + sys.exit(1) + + macho_finder = MachOFileFinder(directory_path, recursive=args.recursive) + macho_finder.process_files() diff --git a/LICENSE b/LICENSE index 261eeb9..e72bfdd 100644 --- a/LICENSE +++ b/LICENSE @@ -1,201 +1,674 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. - 1. Definitions. + Preamble - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. + The GNU General Public License is a free, copyleft license for +software and other kinds of works. - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. + The precise terms and conditions for copying, distribution and +modification follow. - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. + TERMS AND CONDITIONS - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. + 0. Definitions. - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: + "This License" refers to version 3 of the GNU General Public License. - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. + A "covered work" means either the unmodified Program or a work based +on the Program. - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. + 1. Source Code. - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. - END OF TERMS AND CONDITIONS + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. - APPENDIX: How to apply the Apache License to your work. + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. - Copyright [yyyy] [name of copyright owner] + The Corresponding Source for a work in source code form is that +same work. - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at + 2. Basic Permissions. - http://www.apache.org/licenses/LICENSE-2.0 + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. \ No newline at end of file diff --git a/README.md b/README.md index a84589b..7c19f94 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,60 @@ # Snake_Apple The code repository for the Snake&Apple article series. + +## ARTICLES +![alt](img/Snake_Apple.jpg) +* ☑ [I. Mach-O](https://medium.com/p/a8eda4b87263) +* ☐ [II. Code Signing]() +* ☐ [III. Checksec]() +* ☐ [IV. Dylibs]() + +## TOOLS +![alt](img/CrimsonUroboros.jpg) +[CrimsonUroboros](I.%20Mach-O/python/CrimsonUroboros.py) - core program resulting from the Snake&Apple article series for binary analysis. You may find older versions of this script in each article directory in this repository. +* Usage +```console +usage: CrimsonUroboros.py [-h] -p PATH [--file_type] [--header_flags] [--endian] [--header] [--load_commands] [--segments] [--sections] [--symbols] [--chained_fixups] [--exports_trie] + [--uuid] [--main] [--strings_section] [--all_strings] [--save_strings SAVE_STRINGS] [--info] + +Mach-O files parser for binary analysis. + +options: + -h, --help show this help message and exit + -p PATH, --path PATH Path to the Mach-O file. + --file_type Print binary file type. + --header_flags Print binary header flags. + --endian Print binary endianess. + --header Print binary header. + --load_commands Print binary load commands names. + --segments Print binary segments in human friendly form. + --sections Print binary sections in human friendly form. + --symbols Print all binary symbols. + --chained_fixups Print Chained Fixups information. + --exports_trie Print Export Trie information. + --uuid Print UUID. + --main Print entry point and stack size. + --strings_section Print strings from __cstring section. + --all_strings Print strings from all sections. + --save_strings SAVE_STRINGS + Parse all sections, detect strings and save them to a file. + --info Print header, load commands, segments, sections, symbols and strings. +``` +* Example: +```bash +CrimsonUroboros.py -p PATH --info +``` +[MachOFileFinder](I.%20Mach-O/python/MachOFileFinder.py) - designed to find ARM64 Mach-O binaries within a specified directory and print their file type. +* Usage: +```bash +python MachOFileFinder.py PATH +``` +* Example: +```bash +python MachOFileFinder.py . -r 2>/dev/null +EXECUTE:/Users/karmaz95/t/pingsender +DYLIB:/Users/karmaz95/t/dylibs/use_dylib_app/customs/custom.dylib +BUNDLE:/Users/karmaz95/t/bundles/MyBundle +``` + +## WHY UROBOROS? +I will write the code for each article as a class SnakeX, where X will be the article number. To make it easier for the audience to follow. Each Snake class will be a child of the previous one and infinitely "eat itself" (inherit methods of the previous class), like Uroboros. diff --git a/img/CrimsonUroboros.jpg b/img/CrimsonUroboros.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cf4ac184afcdb866a5dd6f8ebaf042352780c541 GIT binary patch literal 140440 zcmbTdbyOSCyZ0MPffg-VoZ>Ep;8vhO@dCwyJHg$ZV!<5(#T^30o#O89?yiMmebe7L z=RIrPzwW)0m7U3KnR!++Yd-t?eD~jlzZ-yevQjcq00aa800I62{9Oh}0Nx-YqaY)_ zK|w)z`}PegIvxf(8X7tg4lWiR88HPp88Ip82O2i|4^%AFq@)bIj4T`1mx!7<>MES_$(P#+yZRrP}u;FpNdi@&lHOjxZ5MH^#--y_+ktjbR6OYTO>U>Mh zrE-C99m_z!luFG0i3S>Ai6ZWAshnE{tSEiZWP3 zd{x?VtfhsWQvRm2vD|Wa>&NGK0wW|-9laG@p2Gq&k-ai=V6Z>wRHGIeO^f6=GZv2m z*A>rcMaHw1}H^)n;63o=}|JlM>28Bio6{7It^`7Q%N66cAT@N zYnHuPs+y-+_us4ZvOwPM2U>}oZ?cZCKK_uA@_dT|O6bbM-i+yvu_g0R z0%Evz9gm&lC&fc|G{-~*CTnGzU@jNS`VH3oJ0qftmU;96Pg4H-imngDqxF}*mDWQ> zGxUTfqj9=yS(o~tx(|v}jrtBja;s!JhU}rOV#Wf47zI6?B?HWz6%mS;S<%4yp2>0h zh*?wld9?y>?a8w*3W_5=N|(k|&5ycrU7ja~IgRzkhZ)$Cu@xTS_j#ptTP>h+cRrVj zzW~KqzfIcdWGjC0@o2HzGU6itC&5zb#$ah-GEC-I^PQky!IeVKbf@OuGg3`9;!eQf z>9}N$iyU*ubb=)n+CAhnGtT}r@rwz<9b0V#-5R`acUQGraiZTisI|)EgRBI;#o?<9 zDl)F93;hMi%%8jDQyiAO5q6ksu@RIA`4Xh$dA;Li%e>#Fzy`FDwK9pD$a4rlO+DpU442wYV%m@&+fsWY2a)(QC0RLMT)?N&0puRW5f$|m-zIdx~Y!sw%d zZ(O9ohLg@q(`LjQYr2$EWbF_#nIrH5n}=!7se}Dh)9}Z^;u;k>8z75BU-t?GQe_s@ zVAO`PIUj!OUI(1cYf+*Mefx3yfO#B4fM1Uuiv-_=|1~MLxGS!PNO^>Eqd3xPlhW_` zB;aG2AO;AL^fJHL3tNwVGY0Yyl3HR@%D!|ON)og7s!c*}{zeJ=GtIPJGST=2ZnSSw zu8CIc$`kj+(@s**F#Tg;wXF!QCTU&WaGsA7`%Xb<9D-tfIs%o;s(fywtOLDlsjV%tG#dSCz{4qczO6ma>A5 zfKqbd)Nvxm)Yvkh59ibe!dzVsW+@&t4u@8Ce*wF>S4?v)8w#TO(@wOp!vSDJy9c&ZM_V%*}FXZ6{3~(F5xRL{m@OX8rh` zYo*48@UKwkW7-hHNpr(%+sD~u?$zK9wd;-4EPE#{fzaTS%H@&Z&p6Q%l)bcuEr~+X z8#Y)y*aYtQbp1H&$gO_b7gPrcBFFI;(f5aX19MA#DMYG|_x>Bvb=~gqN7`uGCA7N7 zyyh>&UVnQJ`hJ&Bq?w@>1XStT@W(KVev6-I$!{?>qDTz% z(4lo6PJVw!Y_sF0K82Uel|MD(fqaNo%CzxQpJ91 z4dH9udu3xEqNd5htA(rg{Hl6xejBHDGFf-^qrv=`twHd+AM=H3_3+N&5E}V-nsF*a z`n+!W`@9aMn~hm~&>b{GT(WSF%g=s#A&!z(OEjC=Mct;0zFX|{vE)#$ zk2}=iIa;2rEn7vM(-v$TKwpk)A?`%Zm85dfBD0O7@^LLER#BQ81IPv(C;#y&qOvE#MnO z!REAAPS9(80(S`&u*gDnT~DO1=}mdM6^0M2y?3Wk>b9scc!pa+xKj5l=Q^_5dkjlV z*SZ~X%Fg+ooyB&EZ%-$WTtg(Jby}}BL8(O>oM0W`DCtUp-m0EFufHG=hh^$$pZ+VL zL|<37KG;XQqq#35L<}qI{axN(lNP}jow5>jvM3))JFrXsh@p`!3(47jeAct&=p~AO zEzB2@kH0BRRVBpDxCVOFn!KCbvbWX*v*nPN*!7$mvwejt_rU>V489ltsSxkksDk{NIO;>8+50QBSGT+^UY{9AO#JnHD25ax*|gsn+G-i7lW zWQl1v&l7LyjdWJanPw>*Yg1i|YA>X9)h@B3kbZ6_&B;ojTwmZ3C$g_bKXT2rit^IE zw!XsF*vYOE0D8bJiqKn%>trPUMauoaYA7hlVCV~V4*roS){|NJp`qu7sHE{4Oz=QX z`hBT|Ku8>;TrnZLIbx7jVLP;O+Pcn4x4JL7T$p*(Tj8QNZ{4Bra^2iA-IeSyQy0pm zs;8y1Fk;jgo@aQ(gepM>)tN?CV8})>OHP-A0zf*`aAE-HOzovhejvwS0Cp;la*#n? z!D$8AC}(-Vk*Nv9fFj%CLkon*5;s*YNq{J@sn9HP;&mFlauSLx3N%ZDa(xQtRk1BJ zO9A@(f}NE2{#ECXaskc!DWF^mqeR&#dy&&zQWgk*{?o}o6bP@TgY!n73op>s1FlT{t5ukRcl+=j_sMQ)-hpdddNjzfqvTNy@iQnIlkiMn{XOU>eDa7+r6%!M%e*P=3HBjrNikOYSJ z0fTF60kyS>r~nsMo@9SGO~C=kVidkh1_fFCyC_A{3{^(0dPX~0K$HFDvKDS!BV?B* zu_k$3RfFw}CJl4D*DSMECQ#yO?lyllvoK9@!BUC{FRfq!{Q2_)BA1k|pUuN0FgU>65C!biOq-68DR7mF!!x!=^l{Se&;Qa%A0o z%W;cJr5S2|eaWdLU+>d3g2nrbSCGgW=BvF0?_!J7B3vpS-3_!wIw%;LIRSRuFig zUHR=)eEShv>WGPj982~RbSbAX{Y}g(VnE>CvxDM%tFe{yp<7;ga?0zcqhHQ1`1>0( zYdQx_90Lev-)0#^2uk{wVcNc7r{FoGqCMHL^ zlgL7&T221~-oAENmPiW5bU4;AvFT%AhJtk*nY0_Hs%Z<*#RiP9s*1bKj}@~`hkaBY zX1hB*fYt)|PP*zTm(o3+wiEMc_Cd8lS!0dx`?;|^#&YU~@AHC!oRWcHtvOY*af!Rc z7D49ka3L!$O#F6r=Sc{%vQ zRa?z1zwp4k0m7MSjIX%KjW@36SHE^9XS?r^E$~G9l?N$1tAUTy!&mP z$*yu<>r1SSggBisu$!v9y0G8p`zpM#Docxrk3w=p15Z|y2D3Zuby~1O$kl47py&K> zHzW60u!RBKfbjTGIYm`Wo*%x2tj<&z*1Qe2PMVaZYI?y=2Dr8n;*3`ZRD;ko> z{AS0rx*wB<&EXf-2gsr!<_nd1@ zH(s{MTWylIU^l2<(st$RF+vdcYP7HWmd%P6>Q%Z|8jN1%bjM;>BFU8R!+e`J|9v_^ z9WmImrBt7x>x(5A0hfDmlsWWkGY zHEu({1_IyEW(f#P6Z0U_DvBf>tubA^68oVftHjB2=I(!}vszzQ5RSuK_UYAy7@lKH z>YlTc19_S4+-B?OHeqFPZ8)94H#&>4(>(6(ds`(;of9w34IIoMMDF!oPwGgv$%dr} zElrIUj@xH?rMV3YTO)+3PO8={wR=Aw>)n$Dxwk?lSIo;5rgcr?20Y5eC9A8w?kkyUp)jhcwD_|YY{vmkr?)ac7EWQ1iU1Jrfa?h^ePQ1a3&tGEgl z8a^oRevGnS))sr{l6iRTWcj_rq)D9HiGK6?vnR-z>3JvDvK6<_>r&S*w4KH>nZ&?_t5PhwwgF3GzEy0K83RPHj&pX~ z&%M(e8f~^IX7fEVJGf&EOLo6iW6F1nn;;`hlLPC(%TeTTIej$aa^+!&ZgonzmsqqnMK$gE&>m%)WOgjzGq z-W@SGqnA%^7GW=pLn&G08C5-H09^U2O!}kenrM-{inc8sZ1cq{o@fyJk?jTvHC)`72o?wV+{f# zHCXb4;#4D=0&UhDG{5EVOv~S1@JDjo6eudU^(mIta8}AsGmI$#)%)XDSG(Y_k{Spv z;1@3o0)QBD{|ih&Ah@!-bl^2}V~%e&drou#=y zL`O`$d(J+B=E-Y@gog@jTaG7=#N{8m`Zzqw1DSRQlV!AaP-yN-d&~+FLlA;gY`6T= z_z&tao;O~~S}MtAOEUHUl3%a~2R;_mCt&LS^_ z(|6vCle=G4HP>&bVCrebNEWY&y;SU(+$`{ha#oPN4`?{VJT4xRQE%XNp$^UQOMMDmM!Je7rBR(2hG z-S4zbY8f>mI)sWct4_#ddTfrrwGcQ>1>g48w9r4RR^pqh-^;+XI&7W)P|X-1@_)aM zDRAJD=7x25GbJYTFm>F%R-X&sX0;Pb(i{7&kXLT&SaeY`0aNtcTGG~nGUmDOs0NmE zNJ{E;lQ(Vpg*l+J{Jb$_#J60zXqL_krP{4E2;iZXefUjcdA@{VUbd zfpyOoJ978WRu7i?OM%nbW73{2y4W>Bz%K&CBw!-seCTLyQl7oq%toNVH&!%u(6~y! zBrsOC`twP25oO{A2Ro<8M9@B)_omr1C(s> z#u#^A++R=?x40pJseZZ-&KG)fjQ>!ftYa8Z$rPj9ezE&h#bQAh_0z4wQ={_Ut>*>n zvNgikqp;u5?=OI5(Y{FZgCqgts z7AL-x_u~ECQRqvKjpDx6839Tczj~Ox`0}dfobM}a<^w(`H=+hvf!cSBd2amE1LpK##?yYhFN{jZQigU1?K135v~H zAIJL6^=g>c^p;Yx#2Q1yMFVEy9_DFTJcAQQM*V2`g(RJ@^`E>7)DrNQgygzD9VlQ7RW8N34u$@K{FyGW zwD7z=3-Dz-$zNI}Qj#JMff`x-+7`yBjk2_fOA5|7{av9Of@w8*-l|q~-#mGG`=+;U zY(4G~_qI}`DIhy(+uBr-Q*b)P8T*8jX9>Iy@&5*SGMGu^o6d{NjWdyAI&vf=eFsj< z!$Uas#kp^DFvN59TmoJ)bo}tWAb+V_x6~7!Ful0#U2Qv2@jcn(8Wc&bgm!Kat2iVuu*OrUW+@WIZBlEG0`GkRyEt50k+ECz?)vX`S zbH@{B(cIG|nA)Lf=F}7PlYXw1Vfy=bgd@QzvY2Y2g;m!K&Yy48*=YLkx5MZiEZNOg%1d6Ai$|9Ck$1_uJWazNesiBRqeS0eVaL#+eaGxZCUU30 zE~QOowX-?5rkrK{Nc&?b@QA<9%K!4bd$w76w$_E@GL2gA_NcyDvhauPp($!UrX0{} zntnpf7!4G{c)i?UcQ&oKweZJMu&hnQscMb!-IajByl(E3;!HV_am(|QM4;Ea`F0FI ztW4_e!KhTn#gw8~CnorX%+Fd|H=>D{BsKaKG0Owe^vaC_eJ`@=RiXXtsyo^i#(FS2 z0g+b0^vcs^!ktgA{aITtZ^kz~9|@nr0}=k|ytev}f^o6kL{C-(!(Fbf8Yn!LG^#VG zm!eqrdCC{J1My?7YV>>Z7gqDu?R34*sVTe@B@{iwqac%7{W)*`!lNVnNI8asHx=S{ z9j8U1Nj7SeVm8C0E}Tl6=kI&S$G^VQ#lDJNR|hn@5;mN81~NWWtWgu3%QVke?^sXk@Ags=`md0!F3F9Jmig&6vjd-%=%TpW_^Of+J4u2o6XH zcQg>T^bv(Cj-!NS^jeV2iRw=#CshI=dyy6P@RS>MUe7L#O1VHFBLWQ5@XtTBYtR2Z z5RQ2huO^kEiRi|YNZJKXi3;C|eF%JWgh3erWrRyuqj2neUDY$?obSwFZ)stoOwJXg z{N*teCTsg!fL0M&2=$DcgvxTMJE1`lIt%w8fH_@xpM)Xiv5#6kJJU$4@&+E=KI3_yS~yrI#g zBp#qvS?&{Dax2Jw^pd_W1;zE_hf!n?r=jHj_eD(>AE_) zyGin@9JyTZhW90d{#!G|&yTEmKMT!09TsX~sf+#)F;F(2b$wx;I@9>5 z)3+Wa!&8M;IUwP~yxT&u-{74_ie;>=PR{tSGg3p&>M{ha;H{sLS1$Je*fiz!h(j@Lt(wxp>%O%c)_U?d!QQnZlxyWr8B8#@3 zj@ICwwi1ofQ50mZ;Zm`QG(APF3Egj*?q?Lyx#S5mfvst>M-cWudVT(6U3DPkqYmo?8I-|Jhf7ozNO&( zI!)auC6sxr$tA|!8p5AvvFcfdPHYCIn^=;+bHA}+?^Tamz4z7JN;F6!HC})mIa}G7 zbqb{~o5WLhGFa`MGHcBMt>PRE9WNS1yWB;U^%4rat!E6vq>GpG?+MpJkt?A)R|_Xk zau@50b7t@3jMh|#@wd4L^q=TsdnxN$)eS@r&$W}+ah=<2yc3w0##UcvAl}cStr}f* z?Z{WxbBzmOt0zsS+i>->+t60EB`=vS(^!9l_-lx5BjH%FJD0yn-`i?Bv!W{>O=zYK z0e?uN4PT^@XwoEoXLW!D@RqBcXUUy*0jn_Ik~luoR%VvE?=MN%bdm00$6?<vBQYozUQwLZEQ$hGJ}|yxbQJ`zt;G<{A7{w z^F1+$^KR)@zt_$8-KA^v-NetIGut|+hW;-z+zxB~ar8PGKAYnZP(vuIVNJ-=lD1|a z59dZ!Un8ALwGElqR}!iMLCkrPpvf2RgLyAi<@(IgadirTc{f8CnE1Kfh7DG+Z8)@p z`$uB{vcT;)^{_Q$3Z3(yj8l}5>LD(J^iK=?3aGV_<$3$2-u2~ZS7}zkBP+}oUk`+w zJhd}kYExi2txXY z=Ak-sQ`Pu_i5n%aIUa((5ur99qB9@C{JNT@!!{VbY;&!>Yx+2jeA|wDgw!^KmAa>E zMs4qsMLS*I>|p&4wNxiILl@z_L@IaaXeciu?26Pd-uw%Qz@cU#-pzO8AV&|7lC;-w z<*~8ZTV6XiaM&Ga(e#TljT-7zcyGaycGFuQzDYp7At>d7JhRkA`Lm#;j?f9lLxo(vC zkzKR7R{YU8Hh7K0VJYP1&6y@VLskK{#waWhKzO39X0Dii;dBpNKx&FcOCm1|(zC|I z#8Orql^kX9(k<#!pgR?}Z06j!rIbLewi6+;dTM>wv0q8T+>KBG&pQ~e%y<97$npMj z@$)W$+x!LlJfwlzXxO%BM%bNh`^aKNS{!_hmUt%^^Zn)hjD~AkskQOMTLk=(V+s`R zmM@DZYl1yw06y-0j`dY-4hvh;$mpXT_1%~rES$p~58~Q;vWzo4U8J<|lEe28@_Wq7 zS_Te_^F*cGtNKs!Gq(}cR%MG?dN~vxdEHn&8t?fbGHBw#cyQUBzgLbC+Zw@2%&Q$1roUw;+%sh(-;Y1G=ce0waZzX0O*8U9S+bs zN1(8hYE|u}Vnl>X$l;s604?&jmE0+td7};v%_L>MqHb3vxav=Wn>Jq3jatq>WRKL& z;+7jF{sMfAS}f|YC_XGXM|dQ8tYd!GYyT@u$ikw5OMJQQiw_jNNJ;=e>Qy!`VoA?VDrt*rh{C#TGBUk7yW#cCI z*5%DocP4=T^$Y%0V4g9F_Ekl9mxw^)#cf+(iVvFZAuof9CgD}n8Dsps@!E&UTU{wW zwzDkhw)!N*YDol%aefqG%gIS#L;;748FnbSHabODt7!LMz&jzeoWpoci;H35?ATiQ zi}wueN$c){TeZHFt)Wu$r=K|Fae#yHWozUl@4|5V|2&jEF66Mn$=xjgs$cKP~#5T`~++7A5 zB4Jg+_#sONE+mWF{ws@b&hiii5z(QSFsIFm8e5`MGnp+tF(Hm}G#lw&a?-?d8~azc zs>!PI(p3k40ob+a%jZA!dggewmh1ZXE1H$~K6rugC$9J_ai_VXaC_|j0&v|W+csV} zK8||Qr4)>N;Fm2}UeSQN0b(nRwGBv4(qAu)4+(kIr>w`&iU;s%DgkHAt#*T`>WA5ZL3Pq~Y`bBM^WJX5u#;{G@Rq)W;L z(HL)r?F|#W=+(wSp=y_CYg#gPh=dh0&W1ryUFic*%SC;h3uWACuGwuzg=$Yb$`n%G z@T+o8gjfy8UQA?No4{^Pi**uk_=oSERssg)H=%b7iHT~9&K5(pGt@17i+LO)mkB?L zh>EX4OYJGNY1bZ1o^w91jJtRbdnw(vQfgXmXI)FqJQ0~Qsq88MdY0u(&Ba-Pr*w+# z2CulJn+VEUI7a+4BG#%Xe?pUyqy@0j;w1uV)8Lvp{3{+H zQCa2_+;S7*kIImrjqZtrhx$KK_kRoDjQ=w97Vz1{|K#hz{>t!vswK6x{{KXARE84D zK<)6)_I+dfxy6HpuRm{?)jx4<5#EFkempbsoSRFy7}lEUs_W3!jJa##J|JfAdM1%q z1J92qy09uxX*Z3pxDRQ!(Y_4hg*bBHF;?=Ycl%P!+GhHlEDrOJed+a~w#z&G-SGyN z_f@!b0fI-tRQ$x0nG2!-(s%#DZ5)^$c=(yqPUil@^RWNIQ2&dP8&bIf%~(}m9&PFd zYESKDf2f`9Xt_Y7l>ByPNK)+CI3TOj_d}h^)M0fnSwDB=r4nff7kWUba_#&a@0yM) zr=qcz^0$T=jWDZU@5)u~VIfJ_o!vDR{J8^c;{qm4e*u}Ce(Q8$n~7xu2i*=3kg zf0taXxl+q%kR&X&RnVK8(1ZyV1Fq~r;u0hsXgE>A7YRuNi|`MKm3qSRe-itJIp3cf zBEI^XXOF)RY${dA0j3=j)Qe(qORvPIYW)frWA@$eXeXGh9j{p$d}l8rqueLyu6UG* z_84J?fzeYH_dG|H#ZeBvPw9fjgs=;>B(5V;td8XE8oqFc5t7$UVi8(8E!0I_qYax8 zE;9^LNa#FGzH_rS6?Y%VKb^1|F{erauHF+Kt7>cO=nYZT2k$s7N-0oA_IXYjVBXfD ze6I_4Eva{QWiOk4y6TeqHBi zH5=Of3(eiq0wv6ah+IZ#AeE`;s$!07Qwd|4C9K|cFfzzr6H;=FsD0vkAuq;Ti7jjf*Q@m?>el9QKn1ZpAGjK?UsH7 zwGljwc4?^&yFR*&Ip3WrpXzO;5a%oZX`ag|&}3I>c^RdpDXnqasF6I2JM^2QiY=zs>5{Nz^fxWA8L!=)jEr! zqa@LM!1{mqpzII{?iF3PXW|F3-SLw%4BS@S`r=r1n0Z*k!>dRLQ2%f*<9_nGc`P}o zogO)YL+IFp>}|zxM{{V1HCukuCAx|ZA7Qj`OQIL___Q5Wf+}#0vSIuYE$dj7x1+;v z_P8pmT>se<45TkfDm!Y&Z2nXJCEz;tGd1;1g&Zj8%dh9>sG)-O%M#r(`d?KQTl*Vk z`6cN#>T6Orrc_NZ=}kMx%|`zTvjEmsaLt37bKQ4%1^`_Q1tmyP>cnz)FU`wnm+jOn zIMiI6DFWS*AOAEF{iH2w|AN}n%gpHX(#$CGq z!7Y3P`;6eORK%V1_KrNaxx|(VLg2AVz#(F^5BWp)cBdiDG(;-;GrxvJAhVLnrAS>_ zX~9_zFf0$jDc}!k0j1^*+=dg{p%q6pW!T<6&i-a0`!Q~=wOga1HuzT-#%1}RS+6h}#rCB<+Y5icc z{UOm!-S@pe=(@j7QO@05<0f@-O8H(vFAc23*T1!ejLFe7`qjwX<->WwkDjOjD{vb!6W<+5j=@UP+hCqGbGkO^6{$+j7&nc zb!O+9tzgYJ=?e_qA_C7SQ#}FCUlufX@fQ$!<}K;%dRr;XqV)MjfR0Sn>36+C>iVI~GkYn{WBqs^=C)a4qr6OKt%o zkcr7>c*J1YQQ#!{VG2t^L5NrYo;vw{o41kLJ`%EUK2Mr3fw1MLDC}_MXd#(eDTRSB0H`%two zqGIgakg|tsz|m0T`(J?DAB|%7@vfp?0s1)eViGq|PR@+{povF~VeR2jnbFm0 z24;6Ej!l)uQ@1T-Dqt4kE5RJ14y+KZJZkDo{H-i(=Q1+-zLffUrmF5>`-sW6q!3&s zW7$Mglyi2`*511L^P6?-@nT6wjOm)tSb#*rd~_=J(qR_<+TttSLx*NKUIvQ8@AD2t z_11d%GVB#ni0_rJ;lwST6VTkm>qlrW7TUm(X^6J^t<^V&2Pa*05w?roDI&^W6Zr_at_2QQodEUU942=f@5g+5=T=)`5A=E#$71h=(*R()n1B3L#C@fT7EZ{!%)Banu72ya&MM9;fXv+@gCp0x;hL=U2%V?m{^E+-UgQLH&|Y$sSN;I6 zf~|-#p>RiO)Nij8T~+lY;jE2E-23!T7ke$ap|#l3p2Mjl=C7gGR%FIKBA7EcZ)xli zI#ztuE5AlaPrHz@DX5Ak3OVj6F^f7sdJkqn30JTLZx_x>Ba8T z$ObfB7@%uru{Yi#KVW3gthy7p$r&brcP zddUm6uyB?w)RARONc=a<6ZA~|U{N3kw+xdD;j)lfm&a3EC)#c<e!Q9%1}vaaB>7`~=`D z>fbF{jU50w|VX7zBnfZ~%+~jnsJPBniFf}peA98d|Xfc$7n_p-^jQ?D_ z7XLgo|FHd^9fbk#&-3yR=Mf3w;YOJNG=+lv>{sv#L@LOCJ8La+App2n1qAp9@c)}0 zK!qPNfF}fM;WGl233#I5t0J-jfVxp~P)N1*9D5b~p3X{A;W+|*tHzd&^CRLJq*8XX zX<7PGwWs8RT`eWWDzobFrBjb1IwI;bK_d>BODQdsNs#wGeM<}L$tU0jkG>}hhjFk4 z<%l^7Ijc!YmaS{x&?Sr13bdPD*PMmz_O|aF=5*OYjjSR@8ps%!91&dZ)-2l7Ce<&Q zrO-rYKcLP}cvZJQ-Q=+vLz6Lm=jc<4S*}3WNqJ>bn1W26m&T& zyXLm>{xA#MsmYQvm28YWS6vOLR5lDq@E2B4`I5e}1vlY^WRgvP<62HnL-D|(NYegw zvD#jOx~KrQBdhp$MfV2As?qa67yW&0y@$~6RlVlRtJd)zef)w(R?HZRalS#90i7@n{EbOnRbs+y{a>x}d6s#{V~RzlN9RbT81t!ozs5GOoQ&o}Oa zHoe`x6Sv!3;Ypv%UoA&|)XynzYxc^k(6ae*GH!I4)$@bX0QgA4$4*u)w5UNT z-0LBEq?;z@3Jy3Nmo0=$)=LY`m5!lXVwkG8Ca5o*ckIqsiYu4pwiMK&ep=`ft3|7cR&!L;NldUpkqCcDy_(l7j7!YrPSZ{^=F8`DrCck8l zw!S237*$1h6zia!>xi5|4Pc3&)PhS09;0huVeWku~pj ziryah^<|ssw!?}+KRNVu`lRnnxF_J^ANG@+VZiTe0j$k5H{ZH3oo;gyqou>$zW`6x zUvt?Di>P=wJ{a$ftA(xP?#GUUXIN4_TUoOv=Isi+cu#aco1^7m#L6}tuTz)LC@v~# zs%LJagu6kyI+8JGO}#cc_m4dqAd_TXjr~ExkdE%3H>02oEzTka+j2)YjyBj#Z2RhE zm1^ydi6=37z|T*e`DUC|d>yCq_^E?QhZ}p@c&9yX*`H^~CAnpP4vGdd9Lpnzt$~w) zNIwR?qBw!($?@jPr=1@Zrr34jV{2*RpnE2gCS%*#diCDb zJsVg1CsgFo6VhwSwEX2mbYE@lvzeDPiOzPTFjHTZ2iP;5#=cbU>9bq;VN(&9Y@yj* zOJZrl^~x_Nd}6P~4)7OXV(Hm2RhRzFy+UeX=RmnEqGQa`%d4oNHF^t2Z8C_FJhxst zaV)Dp6C=HgxFI<>zd9w=M08-D;Z0?J@Q;)pKR}l$^@#I;@4;5P@7xXZD56U8&~G|v zaeIeucs8O-er%Lz)Y+FJw5x`LxUF|Y;iOf=4gTlh|1vvw#rqfFQBu6ZA4C07Wc0}> zj~f4Yo`(X{ zBVATM1~mLih#qs&yi=bBDPHJEsYvpDm?6W$7sMR=k@ySyNx|OHZs;$dxv_lIs;A*$ z$DzMCF)86}umMA}OY=JbNyN;9e=ChdZHo7%Vz9fIQM%gIeNHuWd6($C7LOVMf z$<`yk0CjX?!xIWtS3UlO76)GlfC{x9+WCjbyJV=Sb!7(xySW#!* zAB$JRwzbMDNP!bsd%~Bx{Shb5e)#S-x6gpAQ)Z+w+|b2UO*b;DUSKlQnbV4su2g!d z?qLEjSpx&DvD-KgOG0P--KJWJwGR?$E@3&TxsuHBHOI|xomC*45tbcI(1`p-)>r1~ zRw1?zQH2+ez}UWZ;h=iQ&`Qu%8cRj;Q$zANas6+@=>*-okXwG>AEYUP>}VpQg$&mX zHN_e=>Y+OVTm&M+GO1P@hNJe++dWvDrw;U!-%`(Zx|hfU26s?zaowBe5`J6#;FL3O z)Gdcm0OrT$JZpwbueLRsaMJQC9W#%~J4N zk^XMG*t%2rnUqK}5c4R?3AuKyo4Fy0Jx7l#7Q$gZh=Ql4qOg4oK2^!CH@Pp{_qXZH z-@w>aYPHN8WDJBpDo?K!3`Wt!WU_OcL#=#d2^fWRzf=q&&4<-~pS7u2X_dH(BiIb4 zhdd!+CLXf}h16wb-&DvBz1($6c}co1e%Nr$Ic{?Bu9T>rXw@y$lzr8sHrP$a40c(z za5-Sd{)k?V-zR{2rTLMohRY^_A7uOTKx+!S28G9 z=RxOe>gV1A?T2qo)G;WRM+!Yv2w-cnZ;^@X@-Vw=LEQ(Kax3&LmSQ4m8=nS<8S@S^ z>%fH-X(_X&3WMK3d0tmBW~rPf@;VV~CM+ z`X0OTRq9XPhS`?4k2(%%!)=M*9`oXrcU{fL%?w`$6Y>1y`w*QpY4LDy^)lXvgY^2@nrMi%Go6xcgrYq|wK)YXO zGL;X*-Y#{Tvk^vuTgFqkbNcX_3Mapyz#Z0b$r`R*qk|aXmKL}#<^%fFe-6=Ez@0aA z;D7!bxYZoKSj|aB@;@cqlLHtf`iI6}EdHB^nf}AW|8a4{+rt;8{c~|A!&Phe4&*<> z!WY@YoDbPl-NfXZYrNDu4?&*l1?XR2Cj>IpmwAwN2T;iFMji>&TS=_KzIRH$DwWdv zlO~C$p}dKvtWytP@1s_!NR|D6XgbTVDA+FC4x)ghba!`m2}nzKs`Sv^At2oiLn$!y zfOI3>%`kL#cO#y8zjMxSxVVNtu%CUedu>$Wt>nZ!=5}bTOYuHly*fgQVze-y=g)V# z-==0q`Q?PRa*R>(s{MJ{1aEqfLA`i`tA?+NQzAf-2_-W-4Ft)4;UW?WMg zO1GO{jeszQmU6ZtbpN+Y%cfb22CP!w+f5r9XagZPCxicRKy^X210Olbn(|*IR-2xy znc>))YJ$tAK5Ll437`8jM;;~`LU;-s2-W(fNS3=paA6#yzl*uCnM0Yu?@5jcBm>la z#!{mp@P8F52dPEytJqo?i7J|)p|=oG<_6$aKfsrSog@ujVJ0ws*-u@={bnn{>rYrG;X8+%$eDL=J=j*ogtfzU_?T5-54ruvf(B- z@U4sCx1-)%Ue31&jRq0BYx)Q!ke_nfvb$%<0wSxY@lENsBm?Dbq~g$L<&*2BrTUQf zmwN>__U_{tHWyO4C5UDHm?osC?nU`x)E4cLd7p1eV?a^87CDz1gp&YRG%|*83vwTMmjZi}z4OgYZvuvwkhvfaBl9TG3i>^GsPs=DsdOAh+txKY9 ztjuL0m1pr@ti{yZ8swy&@}0c72FJT}8j8J!PUebK?dc z!>*sOW#O^2rBC^I#TQAVEJ>t(4Mx7ymdukF3?JUVhs1x@%xrmC^Zo%6i#4s%2EX;C zKtT=+Kpw@d@02;H+USG3FNe`Zoft;a$hT z$Y(8k6(H5S=C3tL5Ycq?O5xTH?kf7Wf_h`;6q-kyipbm;BT)@%66`kdF=NM{D~kKO zlBC*ad^MJ|R2=gDtO&asZD_yX=P+c|x(5XNzGExmU&HxwgO(~8S=pSm-vu$V;e_bFCXnojcDI@6e)U(LfRis9eC*= z+wIZn*%QM=&b>{1OS)6IUeL2nOz$##e!}T9@bbIvRc!MvC$)hNwf;5q-{LLPIb-DDW@Onl`g-Gwa0 zrHZE*tQ?U_LdS8+ek3t?vpCD@TC(1j5Fi5OgwI12irw{aM?1{tso7H>$q@1b)Y96u&9cGf|U!7`c7SUev+DqUxSU;CGy8aBE z4^@()*lN9>;)|(-G!}O{$r_}5b^2B5pxi4`m6YCAlWQ(k`OCE^K$dBQ_d#E`cdp=6 zQ-G)CE8qyI;M6KVCTR$KD=4M~t?7yHh$`o%z2}?a)rHtsHK2hT8zM(}tx-fk@(rMg z&4SjZBnvXUuTpsW?{{Z+8=u+g%ulYXc3g(;@hxoAot)n;Szw@SJo@NL-0Z-V9()5R z6mUKP-zK(5@~Ny-8ulZTtB5X}X?E@hfla+X%0Fj!$f#ugJDYwYK7QsW3qk=?LL@kMOZC%-yE8tjD0ef)e# zM-u}OHeT_;Q z+-&YKez5@++R^<+nLBwr8h$5d829nnSN!ukvI zq=%Z34}3``S4c&@@8Eo=s5b0`?)Mk$UdVz`FjJfv25bBg(FNAFX+W9HlKrrYSIH{M zOXJ_&!q7e0<-9(tvpwSxM}W|-=Nsh3DvN~!9YITypTj!@k3dF8qgIs z6HXQi^@X*-sJkc(=sakCHxG!;h5|N1$E`&)Qrbi>TH^f0e5h_jIvD%DeC@RR5p1jw zE})3C8G3lG$+{w6v|_TnIP6lK<=-+&*>-wrT+1scT61b5|HEIs6~BK>FfpLwbDK#9 zS5l&UHB>|Cy}~?Ue3^*ppJ=YCpGKld{FOg?2HmX-Icq93ZCzIjhSBw#H6oZ_Om}qR zbkPVpn?ojo1jY?4LNuNGv9xJnjklc0i``%u$b*}4)JSYY(GJ~#yfJ2YtA`=&kc#8r zgL!`(c>G<*2G7C@dF`)PEEki(C4Q&(W*+Sh@^Y>8iRSe3C7Y%yF6A;lsN;9k|x$I6>$yLAEO{quSnjnR|#MylM3F#4~LB zS;}!)GR{ltn`+T!kM{bjYTVJ*gcdT;VmO>K@(7@~$X4vMYI@zTL){mX3gqB0J=Al& zPDmfVIC1hF|29`_7P8P0eyNDg0b>x~JS_3Kh(IWBA1FGu0$ldoCmq5fs(rU8Fj z#N&E;X>&^o^%Obcf&z-zZ^9ftg*p@R_*hfQ7_|QBJ#|uVYHXf;9ftoQ*=g38+%|!p zJE+AEvM7R)s|qGf#~G-P|(C% zWx2=XMob~*k5ujB$D7)xvmWXgDDeBt=f>#l4!1^EL{vY%XS6}=OwBJjPX8NG10sp>K zjsKt&b%g%`EB{qHb>P?v;E4Gh`+xZQ|Eiq`Hb2p4HlmTg!hI4b{})677bC#UTmRd5 z%QJi@C|#GNw!QvPu2`A1>>pOfMLmvhej-S-VqA|&&4@6x0hM}huSrB_S#BBWt2O7+ z1tI7BoUhdpzqH14#l3;GXPb;``R+#}z_jC?z5~N9&9!CBsA~VixG!G%lH?B>{m;s! zc0A~B5vehF);G_i#5B0tp}7ubj?xsp3p!T?!dd$m7GT#(teJ{TR7r8xwVV7OtvWwq z*vG0xIn8HUCZqERW^azYIZx7s6h%q+wj961=@v}1O;3)mGhYKS(whf1P>$o73X3X?i`BT_(b7`KJ<6E zD#8;< zzfj)JEa{Yz!yCWnfa|bn-b;|=rk0XhQ4>q|wvseAX_7{+zYtwIWkpw`vS>+O=QF*M zdYmFV@zfCstYKUEYTk>gbhx*3Vaj)IRp1Nifp_{vXPIXQ4tHet6a1rOy(c0b1XHaq z<%`InVx0Jr@AtER?E5zB@Uu43Ss-54l_b5T^tiU-i;1F;YIee#I!<~&o`rCN#-alETMRK8^1+HU99X?xXpK)>RP zm)&Jd+A+)^QXhkYqY&}mn~~Dwvn1Cs=tn5oI#1`aiG+pKN9yW{FTW|ZCFyQKBFeA; z>>xs6ik@P#3XElCaVRC8KqCQ&CRx(750(!CQR(+L`E`6@D3J7s3_)hwfs|Z6x#gACu5W~HiU70g5I(n$7>8<K&%T2var${--)O!i0237g{mnRpd|C~eEHFGyk1t7U8YONvL##+~wZ z;ZnlLAgq>R0C$qo$3at@-z}?^%-v*~2nv`IsU0F(beTArXag)uwizQ*gef5+W-{8X zGuz0JHzEO|gMl=&&eYIdOUhpA6-mP*wm@Fn3jl}1w~Q4RQww1*V9q3Z=q^%%L#-;%-t9+P~eQp8^!r~)E+Q?xi)tq|{8rmXcUbxR8cK&N1 z=R=4nU1Jjy5eEq{(3IJ{*A>?DDE>0?Ama&7>1L$U)aT6)KSg!84sYg$vWi!$laBLhK zMBuMMfX^6gPL6E`K#hLh%8ztn2Zw>)UTar~3{GJ1TQH7|+vStlEO|D$Am#qjH$GI1 zoVG~Vv-hxnhC!O5I?0cI1T=jLkkEQ@ai>i4zR!Jtm>GSaOjc;W28R z@Clx+RY^jJMzmkQ&*yj-c8N@eCFJs%+3^G#W%{TM&iqc7hkKEVypWMvtI;2>{sH9j zhdQk~XLcX08#B*H1LXXs{X%qwk{6G=OM2b->w~wFwq2%^e%nop*=>k=pWybHl1T)n z39V`Pa9ckGv0S?rxj?ns;Jn$~;X1aza&Z{8tr`v1W~w8;)0c;=GVd690YaE(iR9Is z9y)6Ti=URF_`#mp?x)2`zF#f)Bm#2c%!_#8wuh}?SiWJ z7vO!DHDd8LtY+q8<$E%(A|D+vdkEogxUtZKgz<&;$#OHh4_i%OGc}rjo1(a>fm~~| z<3zHprll!m4i|r)$GAQdBN-X;X{;oX`5Je`0sJ>FtD^GBT-*0-e1uUefH#huK$eC_jJj zR+KY&)lj7TfRp|CjC999An24|*GF51-?&*Fcxcy>m$#Q~G zm$Y{nuDk=zR?XH&_V3*6sz85%(@y>Y#x}*~qdh=`OdDtKR8jaVytY)-v?DC%ZsI=< zj>qN?Ld@ai=gU{VnG)ims^xr63*uvtX0Id4@NMZh@u2EW^zW0KSMA%VY@#!lLA8NM zD65q$dSRn4G)~k<3ZVxxB$#k`_LTY?$8mOH2+F43MX|A+U`kJoPYBWX0oq5e02hPo zKW&d7M_2FtmDxR#xMB346bK9;3-j4Gxn%6LUs2a;FOElXMz&E`#g9?bpn~FJ6naK@ zr*GYs*O#wK*iLe#C^qH`1bc@~hdCS~v%KCp|LM)kD*LmkVW*dlw6}(k`z*k{q+(5` z##<||mo0D83(J zLHaD;DQ`cIKxf5+$%SEO^Yrp$Ki!&p5Wzy4_~Th;`7f8TQNs>TKOOJLcmvircDGo3 z*K8{xt;?R_YXtAPavsxHjo)(2%vmur8NyF+8`sQt3P?QZb(yXYEvfbfNhsg0c!H7{ z#aLhZ?XhlgyIp1>j`Q)rCN#Rr@+yW35V{uQLl^Ji9egbXH<<8s9XOsr_`OdGgLN2W zuXa)~+6L_t3}K)_=dW=+CS} zEUCaALqK(W4ID(|xAQBJ#Z&XbA60vMpo#DBGxkdHh;>PS;UP$=2?}nkC-mxS&+{3P z7A5myjCQBlT23;E=YYcwVN54C0eT*X0SW944-Q)~6&H=^*$_2Jpyx6X#SW}vFkFm( z)0&VZ4_?oLZ!Q)W(K!N^XWATC`+PmC{Tr9k`cI)+Tslmh#)!*}c7J}?OgWg*OpMHZ z6r!VIl-MilXYeVn2i1y2Pxi0Tv^IvX_mYVD`hP%|69cOwSBPE>F6I9Npou*7$XG%K zdB@bw=|b?r{sE8%k4?^Fzh10%CJBzjkLb$^aYwWYqe%YnW>2bmt$u2G zxhG5%h&ah|KPWue1I01zX2A$3=oVLa;W#IPVd5dmS{)9LT`l=cd>MyE`h_0fnvW|Fq;r(UAzPnDQ8ISi?^OdK!xn#+PvXPeZby!(ghYDb{ zlS!e1Rt%$$k-*Di5!PY1qA`V0tUM%goqvFVmXoQECo`HFppP6j*bi>K>)l(3uk8jiwxi|3&y(QAqpIzNf(NVy(_pQiAkxY1(ysH zj9BuW3Cs2`CNnDeVe)D)_X{P7 zKR7^@=}mnt@BLP8i46WgnFIRz(V8sA&A8X$#gk|*x`{m3b@UmcxZOk%j=n82Espd* zKxy&ZkK9S;%e5>ArwucjFioK;2Y_D0Ksy2d`4hZ-=KT-Q?YfYm-S*+sJ8I{H$b9Ie z{auFZvf_P#Ys3W~H#Huao^qjGuXJsu!2rfesZ{Fi7qFXMvNM9D5{P$ldmM%MG#~SY z9#25A>PUJ2i*ek+m)!6F0ERa-a~VH}YHbM6^Sy?R19kjCzm2d>R|hSv*~i8Rgi`Bp z4_L!5R_iIaI#Uehz5=^l*?)bzk_+t=S22A^5-Zyz-ujU^^IKIU&sUefBvv)1&|uN9 ztEQG}HEE^*qCXS29Pqr&6H z(d^~ea(4OHrlaYMC26}=MI8{?5;dOohj`osrC~%j3s_?zdI)VYA$gsFdD!u|3Rd{` zc-3)fgGFLHJD>2)R^sh&5wX}E92}*m^2C%dz+< z1`>ypx{9c_Qi#i25~!?mX4MQmRk@=91)C#xq#)rEe7u}!4n~3>VtJ`=0&Io~Av`h= zYH&Z(7p;#Ncpbn8qT-}Uymy0r&mz&f{yRyrP@_18_eVej)4jYI`a*utRjP|G2~$scMN!1N(F@>uOH#Vw_wYItz+Oq8>;4?e~Av7F7DfQ@(zmJ|>~ zb*1-L!B&k;B9dZ1*Fu(6+s%+TU9i_%sV`3?S;sOGWL*OqA7L_-apFeoR3ydi?+E^k;L#8 zIR2=d>uO{N1QR3B?b;1Hs8XWE4F>Dx8WQ%!H9uM9n1p;N6Z;+1hM5plg=1gwY4pO+LeujK#KVV)xIg}Gu1ae z1a~ln_XqkOmH2P-xsSBROGHd3mTK!4T`d9c#6Ol)1?|Tr2CitI#N1vC!k2 zaL_L_ZQ&vDR2LKIxj(VKD&tS{9uB-2>2GLEwY;jgioM*<^Ls zq`Wj~@?SOU{Q@f+T7yMzEt`GBle{^;q$<_MrXZQn1242ZS?uAGd7@a!2Eulno z@eK!p)8j6}$_bq!(R&`F`Ws0GNC-!)BKmo@=~j>FiX{4`Hf`XiKT~@MEUv6-Dp1qu zVXa<_5`K_8ot6x~F#bV9z+~i)T~*_0K@U4293cv5U0H$~?!rBO!s(-KSllsPq#Ue^ z3i*JyU$;53;y064etMbdQgmTV+E!(xIMXEY&$#AEUo}Guv~yKt29P*V>dXdFPhoC% zrb_JKTT=?1g~|t)r}etx!27-%mgLtTJlR*T_f zc=so|6TGdT1!fiwe*SgQ&BDN|IUkxOF%1U810^#kdzTZ- zk$4oXM~~3ZB&^O~X-VbA#Z-S~QhY4OS;&RYvrlRQpnx}$*yDO?cy`JtA>?v9$VZ6q z|GPb!T*?9gVYUY#%)%{EXnjqLZAwJe!zYUUC+%yV77fpVJ?3iabtj4HQeOWW9HpSB zY6YXwXA`mEt%MIMK+?20_i;g6{4ZzegJiy1R1q>4m|-+^{7Mm}5*m;EU%N9(0oai6GZvNPKKB5|YiBa1y8LiuE zpvq32EH)tji?O95LU-PuxRei+7rSXe1UwnGp{G3MRNIx2S(j;;ZpcS}NJkk+uu3W< zpMkVsw>vDPov{p*I8+|$)^=19EJ30)>1*9lPb8YVpY+nbW7HawxwrlSP)69TKl87~ zstx@E*dQ!J^`tfvqF`Pmo~OE-Tj@N=7~wCxP)*#=P*AG6B?Ut0$)|p~P zdzJNSr5gsAnA{V~n&P`cOP-6qPr<42S>oQO#u9B?L0HG9VvQ%T)?_*PoS|aYup5u# zeBZ8%pr|vx2g6}qu48J;WNAfha$NF$OeK~p4m_}~apGz&bz9a(Qytt`EpkMtMO>iM zQ~0CX*mLJKZGWjT%cby$XVC;eAA4QDL;0&($3*ROU9wHJ(KFAs{>Oo>l^j`GPOOAp z;z|so?)NU65zy0HMWUBUlEM9A!(z$Xez?*5?qBM)T8=7v(2y?9MDB@Y>4_ne zZ2$A%z_B3ETfG0YI86W1@bJt40B7Ujoz_%MtMBOl>2o|Mx6Q?Cd+Er6Lu6e+&`T3a zZe)H{=D7?yD4}MAkl}X0QH!BGbWizhshf<~0z_FBf64!MAq2S8V}Oh=jWU)DU@fVu z?=$BgjjH^aP%z|rXlAu{Cuh>1@@Nq~LRIlWo~BK(=?$+jAXF|?fIN!sHO$wJE#%X%)(j)|lYx-WX)H0f(*wMOfHI9!VmJn12O z%M8~bD_zz!r)es29|XYf7FecnO{LkEkDo+ahN62QmzEbQ)ea}-1l4IybSk{%T0Jyq z@(R=+IH@_+pNU=XIq?-bYWA+O|AYrw$=ljO^H}-`U==ai=aw=b%8rehwY-bk=@Vt%1tUCo3me#k2Ysr0FmivFy5 z2_qOQtV^=UNdnOe-36vX> zR_0pAU!t5V==#A2OqW;R!{uE_r`3`j`NW)ECNF*%#TraBTzp&NfY?DAaEMWX4&IAT z{b`l?qx&Zg^C}Y+_Ben+g}mcX+TsGZE6t&1sFFcsVr=uI5ep4#>OnEh1(soZ_T+>4 z%Xk#Uk+xy+;27AY~`dAofPwxH!)?MZgO~xou>PztgiZ55&Ub^L57FGpmi2oA}CcnvoSSKmuDMQ5Kf%ebwiLJ%%l zOt&r(O=cqBcq1R(lO~gIYreVKTWu^SK6&(5W(1FuAncC>sfpXj$gpIqg=Ie|&DKY* z4*@Qp(Z?SB_hN$A7mfpwl3}!^2N~~OBM~zvbQ0h;hzYP=K%iW{!<`+Ta6HF9fY!MI z=AZ|iHGNqlUDUlrvaRgOPwowp>X{r&mlOqyqIegbD$ISvP8Jy|)dqmD*+AkOoOmoX z-v&Ha6V)0iQbpPvmf&O+oe4QC!Cu3&i zq|eMevHr=X?{<~U9gSuzPbnNI8CsX12I1crh3A*LfR$38!O|ks;!nDsvgWByXRz=J z*V$6S=#V=qv6g~?MfpD+D)lT+S;ywMaD)uwSHPRoWn~U1qaNi0Ui7xTjIFKVdU}uF{ zm!dF4To$NS5>PxK7ipR173)^RRpPoPbGCU%FLY>mcq+<12w7p zzaGPIl#~WiZAG*+<&{#LOoqP$_Udkx37Rw2?AsO+a^XhCmZL^iMjJvhocKN`#0?)6@EIY5hj^y~ln1N1J z-({^mC0XJX`HM+H_xFUZ+t(y@@3v3X!)%5ivVS8)hDsX*ZyO&?Iel(lyN2=GHiJq$3T>1ltXT+P6a$T!? zu(YICEFD+g#afgVQ---)>i}5Ijpe{|###sDlOs(N;#Rq$gcYLVCGj;cIcw|5!uzT( zibb*nVB2KVkAV0S=Z71{=BIgyoPX$uF9pTLK0bIIt?8cYt;cZj*$4+18zE4sH@_6{okdV zX^)?F0yPg-6IY~h;sxfsLyH#n{*aV&-LxUcv3zwMYy z%}?zEQzK9PK0bUPS)6M(D6&b{ZEQ?eCX*tt*@*Jol9`lL(=ws4iz@RMYYYFF%(ImI zJBk;0f-S+n;0LSsAk6Sfoxs zBty`T{Rik^tmgklro>=c0(>NuxSjG&kP~Q?%P8v+G%}{v zl)q>e$8giHOwDN!snF5}g|)K#tz?Y*?~h4_iCYh9g&yl%%Nm4-Jyh+){ypt_p0Du6 z-LhLOI9$5Pb4Yn9V+-}1w7RP%!_);U3g6w7YtmQbD;-H-%-ouMR4JCcGj{7!p0uOM z+}9=NUYIAW_9t#{h#W68g{)1dpv4MqnmXB4n;0$xfLO~uvY{X}!^aW`TtQ`A?eMM< z!m$(k&FYo@=_&fZ>qttRNK3|tDJupht+tIy60_#c0(BI-;(=+SS)Jp)7H?!T^RpDh zKzDyWEa-b@f#>*U>vZY>L(PMrh!XK*M&;T1bzE7WATI!6I%~*>Q{KUN-h@HMlSW|rW;F*31YOTifiv*PeNS2*iW6*zm4uWs4OoUT6`X)D}VJ! z-5p9cN>fVdhq|S&I?V2vJr^nQ*zuIQHNbllA&@aRfKX~9_Oxk!&X z0#>RE-5n>bOTm?2fV!w2|J0DBH<*A+JwtQ3@Eqi?pXf0d|oyk*y_uqx9$mB?L z=-mT6RdT0#zWvQrAratgz+%S4aH}1$N~}3oq?=^5jFUH-E+{J;80S^oF8Mq6`-zze zGRb79Gq9PLy2SMES9@LeoyNUOd|C`O1}**}$kDr>-Wt_ELzLTl(G1UQD-G_9hnE=o z02a`TB28qyOgX@@PEkNi@O_-|wEO)WzmXkLH#_V1z}!Pf-yJ;#e*5c4fO>6=<-z#C z(V(f_q6FO_3_R{AS6D%EEkUr?o|A5}Xu2)1+@Y3VZW2FY*!05Y#QhrXXL*Eq&lhY!t zUzFa#FUMUH3=cAD7XxLuz~oT$mQ@0`-?Li}X5x)2!0IMaDnKN3AE#hV#PRrBoJ8 z4R7oI0lf3(xL3;T{a&Yd=+sC2NVff*z}+Q$gn81DboN52-mM%a^g`fBIJh90?#E0xJ$hIpBETMkpa z!F$<510E%-#GLsQ)wI>cdk+_ho_rdw#N@H@ba55S(d6ajWM7@bcqsp;H-iivs2U27 zpGS&{pb9@e?=zNwX?v+R5Q25Nqm#uX16c#D5*Uvz(-T~iIg=MH$Hj}#QQoVjH7N!! zC2pW2jDO*tIH+i||AgC8;t3X0uSiKz+E#CjOkPvOyXfNtE3^GX3>_{FUc$uSrO(th zJUP;Gj$k2?noum>s#I~J(_d>w{#E>TkO9K`UK6-jz(ykQ1YOw5RG)S=5yjq$PH_+s zx^lH?W^rhvE{}kSI*RK2EPrR%)D)sA*o>c&wMxeMX{_KK-*;A1Ka_C)CS-giBYBPF z5{i20EN@wOjxS#PJHDht&3e-`VrfinL)v&H1$-}ocdXQM-FPguIni_}E<4wsRSZm` z`Z=b2wV0)7LbQ-%6fi|*n<#FafyIn?1NpYhp3&U0!#kwW0(k?u(W^%;S#i1B^j3bqym$K=l?c!>@@C z46izRa+x__dvkOoam+kKQ}=p4Q#@|dqp9g7FYmA|?mIK?@D)m@kopy2scgkNRJWCG zywq4AXql$g?NCldw3aO;7)d9Ql$p~CR@SJ+cp&vxUL9Tp=jm9?e|DJFhs z;S=?nk>S_TaS&tF=5?mtS0lL zpL_pp+R+SCl6&0Km#{B@Q}3G-M8=v}%%^lS@vqd57XIS(B{D2?@l9tQ)E{9}5_g#| zu^V7T$p$NWBgt~9M&d6vCq~Ph8tPV(ay3zS_RMvv0L;lYfTN_u^4sc572eDf-n6AIG?EONwGk znEEKqql@M>_?{@1x7H&JapW?Ni;o()N3U^hLv+;2Lz9f@=X;MEV&?Yw2Jy?mS_S~9@iP8FrOaOTl%BWkE7@}6PM{26ur3z1ho_`7)UYueZmiN{@9 z(9XCMeQpn+M_6smkZA5Hi~R~GxQWA+Nb^0Hl%v9ttWhR-+Gl<=TJ;iPa8p|!VfGTA ztq6Ds8sAHDuU%G9#oQoGlhjyiJtp^3f}PUTK+V(yxUfxMf(w}~Rl>=9txlfmFoD=Ks>plR0 zB>w=hObo4rv+dl($fuf;wO#Vpwl%g(WUi;RGiz7sywCeRuhO-58l8h)cVR|Gxq*^9 zZUUgd!U|RDrlw?RwN=@14+0Q=M)-nq*~%%H*Cx{%(*73V(@e4~G`kB}Dn(c~>1 zrg|L<#GYM-%T>6U->iL_TH^SEc3Uw)e_gg=eK=2WDI7rrvWX&@Q^l!Li*kL&t zK;N2b@HvA`b$@bo^4qx%669ByjnK&Wk)3U8_Qb%%XwbqoRVyQH-r_BPc7TB7ro3`SB&oh}Hu>YB9>z@+x+Qfu7Z2iFVu|)ycI%Et7xBi;3DxODwVA|` zEHnL`{SFCc9G>^PYUr%G+nT?jG&E=3RIQR%YwNqi{{TSWAePD2?}kc|r+8hZUoRV_ zD5s{swzw(Q)wRsgGBA8vdiw<}Da-&^;pf^7c~2u*d7bEcClh1UzUcu5C{rFsEaW8!>ls zmSg7JP2RgR%A&q9wBpd_m`*vs(8H?VCq@oc{&r^C+Ui$Fc2xt^Mp;eJME(qY<3&&n zkfgQ`Rwo=>H4la5SYW;>Jv^0t3X88(zO=scNQ}3!NW{Au(h6?s(1W#0Xku3YnfHM4 z?cbV2p3)IZW?CLrrB5v z<|dB=DcYy$wOAh0YuzwLT;s(PZpvLgEKqHe7<2)f(9==e3dPVwOgri5-B9^hONeo{P*Ub0EzfAji(PDm7ZPq*m5p6-8+ zNjOmR|M~s@2`5wk8`k0aNw@Y~&z))pZRGVu=zJU-ubRByl|KXjYk2 zcm*K%9q}MTw8fx(kRc$Jd_w;f|A-R#M#HUivRt7>KfI4|zQgCMkTGV%jdgDaA29Dj zz45nQ(&fwY1Xs(2<0`7?v(=3(8M$pBQoCN?AM|s+EE}STy_VO_}-q&eXV?r$t;y!j^UqO zAzy^n4UB>Fvj!^znl}0s%)frh5;BuDFDaC5ab4|cHXopralma7B}7zKb@YMK@oDrR z5r0EFJN3?Dx@TOjYxDs5jsV8O#RVWtxADo0#gHe2$cv)k8ijiEO^2x3rN?T1$ce+; zz^+NldGtWT7faIIMbCHJc7A-P(A!nDzB>{&H5{I-@3-)4Yy?db4S}-?sw)@b@2s=; zJIq<@c$+j;)S(3#bioXa86}^uJF$tj-G}fO2R$s11eh&x>AM5TEIJ5Ax z`c1ka{Dj}9K&>Wo7(#00{19YiAjf{Pb8Rt5N79?Hn~(&n;&CwEgD9a^vzeT>kbL@p z;|q0|e^cVtkKI3@Vi=$blrhy$to)P*Jf#5a6?vhGv(%|d)Zbcp{oupzI$$pM#Ft3z z+D%YOq;^cbqnEIDclcY*+QuIRB_PMpNFMm;T1eAMi3Y!^#JtyWB#nHLGVVT~hf_am zwl+WX;>yEHD)h(wwq?_lS$9Sr1TLy_jvNaBfc*>-Hw(T7^n12?)`5X3Y3W=mw}|{D z91VqE2F8AuZv<>{Yv+zx%A_p~f*?5)@AZcfA$rzJO2I=_@z;I2cPeZGL$yff@o6K& z!pU;3T#A$U1#uIo4d%!;wVEe>v;G6*L{JG!im&Cn!hfr?gg~;w=-v=fhp%`aR;ZY# zepkv+fzdIPL;OH9{i@mb2GeW6yHk|r`b?g@3IhkqCVoxfoyeEik2h7-pEEu;&k|cx zc8aqyo1(QGXu4l=3>)O^Cr;*|7944e{O+!b9dNLq&e&xPHSo=`okdo?b>H_gN4LV3 z%jfYel=%Ky|3O|u!OncR?bG*AWerRWC1K*C=^{(#qH&HTfhmE^EIz9cW-L71(qALc zLm^tE3Jn=O7G4*Q??f)q(s-9^6-8m*Wr)!+yuVcVXp7h8h~Ija#e~8@3p5}aMRyvZ zq5)t(kV~o@ZWBk5NZo=ggNXLN@1UC19tpaT1H1eA%EV@!nG=;k#!v&=1`eBMT!sEb zN4o7|6|P^7x*$YJL{J`+rPWd)h$9VnGv?oX{Qzo0|6s_N#rmH9 zq$5nq%X5aT<%tulQ>ijB+dJ(qtlu>kx0r~KbHmVZTPi_1S}^`Mk>lNhaZj(L-#Y)! za*Sq{fgb6EI6}!7>)ZIAow^T3V%r^@QA3dfya9 z2Sn9>*XsnLCuth2($aDa+Ll5fb}A{-dEyd>G@jZx&Jy2}reGptUz3GT*U=&H3-$aTK0Yl(Mic4j+`;wX8COgX0Bd$**8&% z<9P-FI@-=%721iDY`7dS>IiA(U*xceEz;@;lIaL{k+9UCyg!77?<5MEUc9!dQ6ENo z<-9Y7=BTL)tc(R)Qw~joiVibOndZ!9%|T0RR>;Fa?D zY7$~v+9Q@9Zd3#NI0+n5)898{$p}{Z<;idw{to~%LCn5xSs4&o+`>U0b%?5`^(6s4Gn`NxcLZQksZ4yzN6^uckPhGq+=|5@k6;uN2zE!o;Ed&x_Iz`VNgEs z;Gf2-{i1!N0|0jdqcc0@WO8%ZRO)P%1-;+kX$h_E2r^0bi9q3d15i(Sb*Ml;Ju^jFEnf2W=`5j4Z88kI=eSijB%p8 zv)moA=Z)C(Cypyfq;odeH1`$|sW8GzZpdj)=Oeaz55k*ir_Zc3vW7rcmJ&_0$^OdI zPMHOUqYPS{;6_jHgakV#4M&SZ>$h@8y5dqI z41aln{8;QgDFK`(YkAjovc~Ji9eVw9Rvo9mnIV-UL_vVDN0ayka zq=|raWjJLy8Le1v?&fnFS{tcbm1m5*V!Ayq!HeQs6Ll1}F}i|eF-#HS$M@rJ<|!!l z3yI;s6|9$SZQ?fjZJVhICqUsz_v#1Iw)GDKXj;OVG%J|xZ!x)Hc@)JbusO<_;#b1D z#PUis+i5izVr&_$RI=4Mt?zW%gm-XVSj*6PsL4+K#mm(e&4r@HAia@dx<@g|3w*4k zcN}2WWY%v0c@&8t4YWwTkD;wyGf9=yO4A2mfJ9;`EpHW4wg7!Rs9lU-Z)X~e37uTq*PZ4-)Q1I31wY`WKOA!?5%x*o6 zVz4pxBz9p_v1fVV9}>rC4v(yapH7sJyOa>5jB`+Uqr!S-n*_HyMxrk5)bqqre~U>FWCYRp%c9$b+^B|hSawKAbyvLr`qdmQ@IutQ-i%M|e@T#qGY0a)jzPfy0Dn#$|@y8OB*Ow!BfG{HP($n$6vKeUl1plakeYi{{Ys<_5Ses)i6tvvk#1FD8oiQya!UP=AV-G-@k7%auB~XMNNAn9X;?w^|j#hha6Wyu)yxc0v6Q zwPWM+uSU}DVZE`E%I!?Lbia96{LwdOUrOV3y&hd2{M)++jfUuDUXm|jDJIk9kgC&! zqwQ&J)pmd7*viLxl}9XnvrHqkSh9%RT&yZGScM;nt4A@{=o?v+Z~D|xA;``^=WpZE zrqZrnZC?IG8+T`qP7NebHH1^mmr}nfuPaNlR-0(|cWDwSC5|hrn@+RT@1{$sys4JlNeKgnAabNttvgOl z7fp^vP1pC|yS9vV3VOA4C3DT5lWmo5;rlzs80qD%D!yx`@urO0P0f(O!@vPP|4xi;tIeQmYXThN5oB>BB>sc0K#UNd&fN zS82$tJx@rtxVB)(4n=tfhP+)al*<&vn8$xg^jLgnWp!#w$_dA!@JkPUJ*tX0#Cg?7>_E9;zjN^3i_Wz$MzkG0|3IOABA`uXffR1sg~9q9w|O}+V10O zF!ngFUek3gN*gO+Rc~!kLV3DmMrGsF(@Mf_?CVT{K_uV`ul=cIyKmay&!?Cx4`0%* zJWb*2h_vhbyIX*ygpwm3{C^3^&3y39A~{xO3=R)H>E6J7PA;Nhktz|_A%%Gt#W{2v ztH`9an|`LhEWTGNSN)^wUV4`oVlCoXyu9rsImUe|BE^nLrE%DP^O2sOm78@CNeeG3 zOQQ%Ho=7=AP^crcgFCiYdmLaZM2P3UD;qQN;`sBn$}VjlPu7b4m^=8eZZY(qz<} z5lkYBiJ>~sMHr%)00|sWaC>t`Xs2;^L;52Zxd4ed^jSt4ws5kMMtmX;;I(wr)H+Igm5TWP_`)9#&@`?9VN=TzR~ z&Bo+Wj-(E?7VMMQQxI{|lc#zPKN@k4Nb$J{&rH&|(tCn}=KxdNVkiLRyVFMUI{`|d z1CFME5y0C_Ko2Ih=De_d4l7Tx?YoW1GXvCmRzS*-NnP5YO3|oxV zW-HWnrtYCJG;BlS4N}`peLmj);u}dDbHt87V^l*K7?#N%rl3$yCxKEIJrGkBfz+=J zf)7f7@ObG{s=Kxur@bSf1)p(3Cjn?b>^J=zCc{VGU=&d14xoPm?Ib57*6nd|!R#9s+` z(@B=YS<#K1$WQcZyKoPd!=`)Uyrt4LhjA$=Q!L7&e&atK1 zL#kisHv+vz|PiWgX{AjWZh>(I0n=aBnhczNhE!X#OuJUub zPNV5XwYBB+;u{-jC6T%WUCe8xZwr6IGM3l=A+{GuAu4TSm;#NDls-A8mteWdiCRoZ9F?It4XP9*NZa!*dVqTIUc0?`&8q_HxXDpy{cG46N08Dv{u0OBxbU- zy(0Hnnn7h{HOWD_k`(Aar6-^YhQ{B|U50W`?pd3a_ami5*B27Th_lNfT!_&}37(); zkTf6}Cb!fem;yH$l&ZJ7?an_MV#%dL3;8hJ&n`Y$noWwQ*8}`$0jUL?OS1CP{VoSo z1Sxa)jHvwT{{Z$)wcPT3yBZRO%n-{IjL-Eau7Aj?9%a&mzJ^zpNQift`NL<9y=vsG zta!5H&A!wTj7U$JbvD&e=s&A?0+5XiF z$uHXGDUL@dgVg^3g=j;4sc7!7PDosC3pgc6J-|F4twW~klW9wR3=zj9SBO!Rjy;VY zKv%U8xmd2QXO7UEkry~VxbIF$;jzB+Y?tjQgM&O=eQ`;1r_W@ueV{75qjI2dNFJxs zyWb6bJ=3-QEoQdyGKt@;3b@*R2s9+vHj$a4`1iyOt6N5wHnE33Slh9rUp5D}3^PWj<*vHnm9}#Ht_`iCl3pjNPKf3b9JmemYwYdZNSAA#TKMY4>1-$w#lW`ia4{u7*@V283)K8=8Gku!r z5dDp=24l}t9Ex}<-=}JltTxl)1QOWIWvS_@cNFAr5@moG{vYoC70=$;*~c-HO1OKA zH~E?g6o-%4{{VPQjw>$MleQ4n{KWIpm!(_-o;NhhG2az<5tpjNNz3Q zd^8gLlc@FE(Eb%ct=`N1BTu{&MYI=XICLl5`qLzy)@`i|G*2hXFdYc>rJ(f^3!`s3 z%wj%U956i%bha1va@pMJ*U`kR<9)R3Ib3uZtZ8hL8@r7?=2wq{9D}Dk(=8OkaACQ_ zJV)dwkbMZQdB)na*TU45)OSzrzf-TanmfB#p}Tk?iN@bKdV~EdH&pQ9xwS#(E8M8e z5^XAEKxz6^x^>Il*geLFBc2jB`HQjkI3wj#?rU>huvoOqVRIr&Vc?RZD z>07|*`bB}av50-151S_dx&HB|%+l1w(^HaE`kcp%is^Pn)VxhAlEkN69+k*=dhA82 zrg|PewBHhHPk*ShA6$`HHuE$SEQ9z?Y9k(KJM}s$)l{p+Luh_4spu2gTOD4~NyCw_ zGL${`{{UQKx-AC6`TRgNO;X){-y#LDu>=Aaw;ih{&ee5|DI^YeM7_H0&UmZ3Mx`D8 zsC4Z@dEu3QOFd7#cwi-26w9&55%hdC_DJZU^#ukc7T0j(1Q9uhtB@_U(lu}aw z%^9SwhAB`cN1*YAto!9S^%(jqhozkRH8x9ARkIsl^lEiz6OhC6Xn5x5arP(x)u zhbFj?k$DuMN4nI@MRR;THBzF3cDaQNJ2^dTPTz&iRSSW*)r)pA3@AU9aMZkytH7#s z8i?DV;D#zfo`jCHinvi-v(2TqgbX(bzIw07d*-;}K0!p6Dn|5|Jf|i^AR*x2NZ;HPuoC4*0#CjdpEIN2}v=YwKATg)|A^BK4l#$PblpibfcLL z6lWE##%0Oz93syWRV=QQnN8*f%8K|lu?#T{wk$X%pR3f)Fxj8m~!G}~)yi?vIcgi-p_ z5uQZ@rF2@nRzeN1n1D_fXIA>xJVq#L!%Uvla@}gh%;YM@4^H(#O9RD8vB=zcthsLP z&XrxNe31hybf&YDPBE}t;-jlpFm6k5qcmocnIL(f5-6nr&;srhW{|BWDOj#%88n8M zG;u*AdQ{1^$Gt~MoOGhaMcA8e)7F-u+)rAO4n-!7BP8@4iVYM1v=?M#-F>L55i z)a~AfB9P#YC`1k3oyEy_WDd&M;}p!An8r`NAyosuXu4u>YjPoyY1q#KlnQ)Isu(v~ z8_=jlH)c6iBl(!*`cvNMy6wjvhN~Uf&sujSbHJ(PTeDAVB)MUt9ruU|y!61Xn@#X+ z^FX&3)1|CukQu&XSlU(0R&#x(MGout6!ZtytX^w(7fee`dH1a6Dvk2Ne9qi03@WGX zaWeEs+q%%SNaENv7A`#p70q8*#{`7IAdx%bt4T9C`{eyiHaXfb!<;a|6;X`Vu2&+p zd?fwYQ|0r%q)e-j7dbw?smOyF#~;pyjn$WME1z0jzz?9{R;cr&n$WjpXt!4h=gH*T z?g6ADAw_oZMeyrSKqt7=wFv;^MIOcdYl4dINZ~Pt`5Th7qI5sQkEK#*&8Bsl?EVqd zp;+`iH&L~`$W-4VvcItvh}u2Hq;f~7X}8eG56d8o`Kw3t_OJr!5OU@T+%jYm+eMsq9>aA@e$`2XoMZ(uF>b6$47p!cq zq@$mXTUZaAvv6TdQ*vXXjz)JwCP3TzJx3 zD???XLmruIMhLh609gM3?>|#Tg>waM2A`@mzOfvrAtXrx95#J3+O=oZ{65hbpzz!% zn8x;*%l&hnwav|N^Geb?66|tGIW-9_-j_ADA1(JaEcJP`rkSiIk|vdQ^udVEnlIypAYMvFK#! z+C`_FKeXqOPH-))*L1FZGtgGf zaXq?6GA<%9C|n%mlYz;s5R=_GV3J73lEF)UCWg}3Nj7@~+IPcvE#RKw>E?xDB>C8B zT#?2|uR6Tfr_`Z`M}-;m(nRF-shUatZXMeMe(T@hlZBZ*=)xWNu}*ljic6dLH7Wk6AYJM{#cuhV2e~=)PS3 z9V;AynH@){r=)J-nFq=`=9fK+RNS;jL7?4f?W;beuEQnxB)5`Z9%K5k^sh?Nz99H> zPQqGf?P`OljS&948u3iys^of(w5uUk1sL(`RHTWq^`4oiTI$viUs=BRW?jm9etz|! z6ob!7`KQAEKGeKBG;y<;tUw{H!Q<)=V_uu5{8G}d5pi}QbJZ>vX&;Y6PU(uw!}z!0 z(`6~~HkO-J&MuL7!T$H--nk3t+gR|WuAz4v{)K{c^KRQy(&QVJ@FVyt>n`E%)hn z#52I(^30#(Q`m#vwEQCloOimumvRBRMP##_u?i0(1a}9DB`Yhk;RjM&t8!l#cyCYe z#;q2kZ)`4fZ9#Je=PTtm_emYAkGi+Eu(~Vq%M*;|7u*N9KhW2q>Y9PL@H^-_rM}6n zKxAy?mPH<&!5)>v+Fe|wvOTH-ZCi0TY*k89rqY*HbZ1-6jVX@dh(-Vh z?zrh!y#3Y-ZX*wI6s3|u)s*(DcaJxTRxh#Xph*zS!UWFI>yJ-rt*L3(8V%GEM>5=7 z$OFSV4iBg!u^qvtuBmV6cSGl2R26I@b{DfF}|x`{Wt*Vfu; z=iO{-Dbq#G+q{yco#bXn2>XHif-9cYboq3~iuNS=91Y4xC`kUb)WsZ9Y13URN95T6 zv)B>yu78bBahjUq7_U4umr|jT7-7^8nNS`-5lv5(p;p7JLX;lr_Wrwh9JP+LW*cXg zK_MS2t79I5CL6=jyR^Y6xKU%KCX&F2bn(y^b23>fFrlX>W<(-rZt9Ed# ztT@~=*!8DqzYOjWJ?DsJTUa6ayp>?hC$>jQaBG(4Rq0Jtlv>v3QSk3h+oxKz?4aC4 z*bF%Y43FhW;#(->Fe}%_fRFi8~b{4Q+BABGLjDVlQdf?;eaZvb1?R9+~ z>GcIgS#Ar&NXF873gVQ#=O~{+3Tab~D*Ls!lK!+VcxLEok*=8{MRl&*=g4_nDBIlb z>%i?@2lj(p*xh)4TZS0)=@hC-8sh|WxPCRxUE88t!zIyZtF~72w#^IxN zVwpQ6DnN0bqN>-Tc*b9}cx|S+o)ED}u-e3c5&-LxJN2(R&2-b3G;Ys77e+LyS`O=U zEfkbytmX(pomv&rch~y#IzJuTX;;?|tLZ>Ty}x}HFfx1B4_caq z=573qz_~em9xE!kD7m;^d!9aJPK7K(h8^A^NlQsuoB>Hi6bLCOG?V~R(`je}KQ(U7 z##^?+4n1m}c6tnH9kQM>YaB&yWecO$$@1lnugNE()aP#W$?U*qQ@7Ts*Pv@c2h&@2 zGm793Q&WYm>cZ^2=P!l|vQT<3rKF{Wtb>#C=M`l@iR(7P#YUvuBH{PyQ6**Y?8C0u;qUsH6s4n#+`(rxVmcx`8WnXIQ z$HME2`yqX!YPOefGVV}L*7|*GgOSU~SoJ47S7q?$#Vw#~s|4~9WpcqB9*TQ4cEZa; z<>x6)^Eaz8wT}qvnha|#{e!G5G9^!$e=*Xryv%h|Us*`8$q@}2OB0Wo7-TT7F!8U$ z3tO0E)Vw@`IYwFS2iy3XrLE1Y zg`GeXz)#H^e}}z%w&>AF(YlpoI3b1zK8Cb3U1s}0)T6)C<}pl%@L}jjaZ_@dKC}&9 zckzZ~UkqDBe*4@4zkscu2YAxU#kK*VA}i>}@2!dCdyi3AUl&wK;rm9$OjF?dWK|M) zmi?{B;;kmad3=5qRzbn1+WhjWb5c=hV+D`SFh5$GN{-%XuB~pS5hI~xW7BZyTDn() zHH~9Tn^U%r5GgxDaL@FtE2v)1K^)MsxZ#!81RAY@J3R=d=wd=?LK|2Wl0K1yzsV4`a@8!69IHcuW>P@KV`jxyY@+f$R z-q>@B%wd%ku?DX+7X|m0NBhco1XNd+u{FX=4-h%ze|ET>`I+?#2^vspp2lbdjCZLD zZ9(f(TtbmtutSyYP20MrPf^01;#Mk7G1ip}E8*&68I7~)OlI>Kk}0NRDpr1FE23S_ zI#otMaaV4BP6a>{jMq#ahlz=&%~hsNZrdU%4K4`>H4+V{HEmQfaZxQ9(@8p!QGEz@ z;7}I=rPy&zafPLEx^~r)SvsuY8yGdEKAn-6`OR~VT_p@VR^6to4Zaxs!j$7BsxJwM zr!?tQ)3HM8#g0|i2C~}DRBQ#!ZCq+iD|3pfZi(tESWZbEelHD%sVk;YODP=XszYL` zxn}04HwV{>p*6!Z5IR<|l%&r-tt>q#_h3;Y2PZWbGB*O7^Et&{wX>DsX_hu>+CT#!RM>YJ9NhzS zsZF?(l&CzS&6QJ+VN>O!$CPvGDqLRZ+BGAz_9JKtADWSoNaCkr(yr$qVym-u6w-Z2 zl%upr_TbW%;{u#BNsQAo3=Za+M?6qzGeE!!N;#$5KnO$+`0>r4Lmk!nWCMEPQ%Hj=94sLm5Oo~G_=svp@jgN95O0Ild+})nhN(6 zjT38BNg^wXtjbi>>P|VPwi<*?(t44p;}r0|l+0k$#(Pr~e8eov-jKOHY0NX$n}8?> za4dZ&4hiW=jM8HVBAGX1$jvZ}cd6Cma084VS{fz(78I^qr+s2UgYQNvXw|U8a)Iwn zASu8g)fqKy#sPy<+Y}C3L6ACAtaR(GO6XhKLek26DCj*;psgG223;xu_Y=Zo&OEd^ zsFb3;*3ODFD@i)AjnsGS63cCO0rPlpK1Lm@GD~$r3Z3~J;9)&DOHs_dFZeAn97l!qXvT-4E6jf-R-pN5DX)b z4w5BM%P$$NqburpwW&H!mPmF~4hJ=*r}%$U)mL?ujPoz|m3aK>-ihJ!bGGjHDQXTv ze-xknZ+h*b)}F=%j@gplD8>;70Y!7x#i)C+)t~(>0qvFH*LJ*m35@aNkgC&MthBJFGjJ zFvKgjTvnKTN3`8oQY}I?4X>6_@3DBgdaLZi{bv(=TEA#v(8K)@SG zRi_3aeq*`20nk!;j^~s33e?lIRJe>>Uf)4wYC4xYq;L0Be_T_w_7is8$iX~r#ZPZ& zZf=qYPV#ZMo&fdcrPQ9#+!V4_5Fo;r`_1lZl9mVMV!uOEEi^6-T{e#4yf>!mmU}En zx4MjBcOD%3{e5ean$mqbc82cVl5{_H$8T?1TPy2}36@yoJRW)LU6fkJpRU=9eNF)2 ze5)`YG-UhrAIiBeQj6DB_@3*I7cp0+l{%feGmCjaV$rc&{{RbAV`~keOUh0L4;8OA zhY$9h-HdlXyoZ>H84Nm{`}0;b{XW{oo_Cr#W>NCTxYRnpp*4MG! zMC8bW0Jm}IYL;`|f0Zc4ITWqbr#98BYF+9P>N3RAt04e}3OjZJn_+O!UNgkalij)e z>of!WEt;Mi$zqW`RfA^~rkh5%dBze==+V||cDk^&wbo72+z`MsCsfBx)f~5jS<$X; zM7FlNj3efaS7+K2zv3%z!&CgmM^FsZF>{FvG@rQn-`$3s@3p3)sTmg3#yMqtSK$wBG#sDoQXi^z}4?bjWF^%Z(Kr*k?RlW7E`EyQ61 zsBXuuN7Ppx1kW6R$8bqbj0pq}O0{oxCAf8KhL_J9T%IeD({XL5q3o<>I*^4o8%t~7 z?)-N>5zILM08BvEvjUA8afZhveQTM#(;$u+7R}|J(lf&{;#3}o)C!|zcdA*;EGN2- z;xGATvo~*J+NZPB+S^nv_lq2(f|K&BJvR^MPAx5nnyEkHtu}qrC%4q#vbsnF?YYze zEN!&?4QXl(daG?3eDO^CeAj&7`_qQ2re9vH7go`x;CKW!53%&CT6Nx+ZtZ9By5Q|jw1*LNSdwIj?x2;#J@^o>94h+<}r z!zHcoah6`E`C_&#JVy8SMg>nTp?u7napxyYny0E!?A>n#{G!;cOCOq zpSZf7T-2qBYFc0VTCxEI+JVjX65=89pHK7NvSiidvbwvu)Aos@K(dY7OsUgoJ#cGJ zQ`C{$RfL|E3}3y zm~NvI2pO_hsbR{n`gN>d7U|_KV$@>u<%)FzX{18GzQ$XxsKNZ}zJ*?UqruE@FAU<= zss8|0Im#(0u7k`Lib^N}Xr!W$3rR&3z$tj9(Ll#!QJP990HTtLLJBCPpai6+VAD+l z3MnX{MGDih)nv6my@yK8r4=)TX00Qq4U4OVpFJmLXx-|QU5%uWwMLLq(~KhpXp@M< z)x=MptGgDIQc~3z3q>U@04VEPHtaYRn^qxnxoRe^j;t+TXFHqF?ZB>2RGZJ#rEKsH z2jN{yLnIbWGlB-*D~xlQ3H7WgTbbDP^I6SMgk{y-XYo?!1K%{A=^L$dA3l4>!yg$g zv!;eMNZ(Bdh`7kE=yi%^+f{R&(t3yi9a99Nn=e`aC1!y_)`Wj#e-(Qj`d)gXHahV9!)bA=%A zK_`F+q`MTxKPI{#2Ssde)>#yJmh;6gJ=1p9AE-5V#6APobk}RO(_~vV0fR)sWnBBO zYUZr2n@-dtmp>poWXE+qXj(BnkEx-G7$8{UjZ!rjRZ)NibDk{GygxpjE#9vjaja@j zm^d}3;q5^+Ee_h`IARbhA94P3UNz&t5OHb01trkIWgQ+S^7+SyoJ zh9W)Ql(5Pi0iH!&)TWB%3^uS8i4V%eV4BE)GF$*b8La9;=hH4(a2~`CByTZdxV>Ju8NE@2Wn#3z&Nq=+nd;w`ad6fz@G+$a6vmGjn zNZHQgS~iT6#B$#-?OhHIDDo-dpI^)Yowsz&zBVd+JQ7Cim zQ(IkK+uJ-TAy{7jGS5l& ziEkvxRYYEJqk&emttRtb)Dq6qZbs*-8Fg)rgrIpIWg|ISl+L}Q8Yq-~ZKMsQf!KGirHs!?3SZ@3)ie&@v zq}72ld&36KLnXZE42{a>q1Wvqw7Ckgg)Qk=@LavE%yS{ZQ<}Z2>f=$GDGL4EW}0fj zVH-t}U=qyXRk;;bZ8|9MM8JxhRMpz~V~IXk&|`|rB>I|7p`yvOQa)D(s?4G@v>FxJ z8-qyaamnjQ2&e*=8KCef3^Ur3CW=Y`Ii#gMDJTG^3QABhNTea_NlJRsQzeBcIHbiC z0KI7_#V#lS;)*dv04kc1Td}A|2A(N2Tv;O=@G3r3(t}EQq*K>W$TSWp3ra-;)G?Yu zv~np&B7o6}#wn(k9MDJtfiW>lOfG3R8f5b%Jo8JC7ml=wz>aBljPPi<`ERN^yKP<_ z14E7*Pz~JUe6BkC52a+wI%rH3sbt18tvz)WDA9GGSn3g#t@=Yev2TIluQC3HviN#dJ zP0CDkQ^^VWSmV;J*ufp$^ncvWSXO>2YkQ`(EKqVrK9o)_&zEuGt0g$9y2U%4Mx(5y zs%!@=I0`yfGj)4C+1(_B^V2*EtnSh|W;tV1+WnoR+i{Smxb0a}qZ&&4v$GeOR>xH2 zPnJCwPni-2A%Hj-=}GhBt}COr()5`ElW{IRgDeIDbe?N<;+tqzWa3?s>_rMsRy}FZ zLp|NX!2&drHvj`wjEy1W)`gtEWViDb$~$Ck9dTLCO)U-RQ&XL!?7E#DzlL-zHs8+I zHB&XlGA!)*!SrW8(y;ZNM%v+)3mZ7Ct=FQU_Yzz- zWR;2Uk=Cl0C#f`?npTfu)aPcd?8$coRu~(PL!Olplb$)CE`91~t=dNlIHcJsBwOFG zrQIi90rjqi+rrlqAZ?_B(zMgTbFSUd9!6^?T0PB`2^?M-xxqhPlylv%J*!_=w-zJH z0|cB_HE9=hb2+6KVNTxJq{!?kD5|m|>|By5gjJh#5(Zz!oh7MJoK!cdqKj(fA}Yjj z?jZY9S|SHZvuZb@xY$9)+;<+88PhL>USPLpkJUzMnHx?SFntddpCn}Nbw?Fe zoOyq*>#?GBKeReM()pzqXn*3zzpXKK0~Y0tK#ZJ)#b@W(3S1t%)pA9X99>xIp1t~( z8hJ=yr)sy}9RaAx$;&@J)gNB0Ptu;Svwhgfr*w>)l=swCkyU{XRfj`P69Xpw!CTaE zN%mQYBtTEmX^j)0%S1r;6kRa1kux}E-16>kUDR$+d47JiTLb%p^PmLJDo5i^=uOG$ z**Td3;g8``CC1%I@YCSD$5M=5~m|`~d4RD@RnZOU9rAUHgKRm31&}7le0@Yf*bvw&X7extM zOGv>}@&=f2p!f9xx+^Oicej^ry>C3RgF8$x8QgSG4{GvLbbP&=q$9XqGxapc=2)9@ zqbc>=Yd>Wbv9rchl$52q+sO4BPcBB2%Z6rEIpNTH5<_-NfR<${$xYQ<|Vhoas{xa~!NcvSvi+OEkF-(ORb~IR$Iw>g402!sG^`d|sMI{sfv}T)Ljp2U` z=rZZ?PpP){kYxPW#b;8iX{*TT!(l4oTU6G^o#vA@*Lds0+IEL~5z}Se46B{F&MT3s zjFgqpm0D7zE?I6FqLPYcW5M}pjm;)$4Fz97qLP+^N;styQquuxX(*%u($Y~t4x)iY zFczn^aF+DiADK&IdWy>Wc(A(Fwb(+yF;=mZ^70S3CP(8yDR%Q%XU}mW~Jc`1c zIUSEvAB+0TBPKNRX%F8ts0k&z3QQ8%9dlbAP?Y#5mfmEV2^u+2?pH&C53!^XyFSHI z&C?6bI(td&h!UeABO`K^{$hYVQ^WrN7GjdjT6l^kGAO{hiF3RC;p^@zknshk_AY|Bp|Bhb{8rZEEf*rBhs|zyAqi=-*wfFN;h@)9-h?Djwer#Uify> z>H3U+Xws$yBD;@}hqiq`8soIR9^lC=ayW=g-ebNpSRR-^jeQR~Lvw8;7YMRK>Q&W- zK^5b^8iEaXPk2O!Hq*QabIDM0x%@wsMQO?~ZabaXbt+Xc3N^kG%pL{Mi~z}WcahoZ zjsF0{?ISADUVukIx}B+bdV3Pg_azW|wR4vjMO$oAyJPsXTt8Z<<8nLFxjN(vXIx(;Smho?1C zLU!V;uu&KTtwAsY29$RlYx0n7@7|aAYRpivg`{ZPXZNwiR#o2nL9J2d%_Xr~NtJV+ zwMJW|0P~tnNR^*p$i-2v%5>GPe6BMeK6eQ8CywaG%-&kIf4xj;nU@#?=}}USMQ>xt za&K|DCZ80o6oHiDjhX4zo~Q>=lSPD^PUz5kxXdBDp0!1toa71?F`SyaZ)EbJbA*X{ zv85Vz*w(HhRX!r11&AAYr%7ukmd=V;4!G@F`YhJ4>M0+TZdyaJMmyH7zo&m;Pjhb} z#M3BZfPLR;(Z@ps+c_&$V5UYK_NmDXy!D~*k%3;L;NONey0(#Ns^3iPvkm@G&T_+p{HciO$j8#WhvHX`rSqRh z(@-e|kp9{-(Zfncit$Nf@)a%M;wt*di}6ixSMlo}`*W z=QSaS0g`c1l~p;-K|^FX6w$XFnwAS|jY8#Z?P6&pZi=G1?K|Ps^xJ;g$patZW6$MH zCc@_vpGq4esKt6*z7f)NSd6!lhAKK5;I(^*ZZBD_(`-Y9p{oVV;%ie#(WTViIK*SA ztiq&_E2fWDO(#nbLIIV>C(?+e)EQG%wzaSxQV?FTqCqUmq~H@vJkLCaNf?$j5F{`o zsHE5=YhUS+!4kA?3lY+>$ROa<{{U&1Ic6v8P_u41G&=$tNlT2-Mkx$Ra6Yu!DGuYv z28B%ZrUQz4H)Bbc8#k$-meKhHoM#oBKnz7(g~K6MHA#jTicvPiS*2tpEhQCaC{of< zKnqF_YHn$10?>UgN@z5oibjc{+o^IXl;F9fQfyKMCrUyHq^2hI6q-smQPzQ8;1n8D z7^E2nr2`^?q?r%OC@eiHM~D%TP_hwCSeYh=p$F?ocW%uyp{IhzivpF^nC!Q$8DUH$ zj?jWm||(_`X0uR zFB^{@f~OZ!fK-8xdWD#?633dQce#Z{NoxmiNhFVya;MnU_~-j%EgOB}G5FST$>~cR zjTC`}DZ=`#&2ZS6Q+%!auW^l#ae@e`Sw;W@Clz``w75Yxm{wE4OmKbag5P40ROELe zj(r2_txC=4SB(({Tna-JW9H-OQao$boB`=fc7yl>6HO64It_MH7*H^CMoS`scms-N zeFx`Aa(bG2BNryg0YE+JtV!>IO~!gsgvtK^3U?BSZpR8a^`I#ylg(I;*^WIAVN+Z| z_Ips+!E=F9<T&AX3)Gubq2TN9($!y0+goEHi*e;U>C3)>)e6ZJLbFM6es-6d$usiK z#gF4r*RK_2W6G1exKT!ErXqVb+j66`aaz(9k~C00W7e?Mwz{zFb6W;viW4zCe(3cz zl-8$3DI}U@Th>^YV*TUS+M%<3k|&|!tH|vmmu^X^Vc;SE0BaRZSrN?TE1j-~bR)Wk zKt}`$_A5PPn|PZ%U~ntKY+uTrHXQ-U73n$ztvg#r>_B6mz*iM%@}tnFO-SDHR;pss z=ZS_lKGC1+ki=ch3+s;r4;{()J7Xkg|KfV0x(0nJT`B8|;`Ba07=B(N~ zaQ0~FEqoMUy0n=xVrTh*9V-vwPMIE)Vo?w;nB%p2-IR-QU|94*7+02jYPt<|r`svy zgCQTKb5WC>L~T{_!JbWuco_hSZYl9{O8WHr*P|oOhW0dU^z(Co2U_YE;oaTEx1R=h zUB?xj;gYW^t9L)vzJ>6_G0UVeWgIRKy?OYGvxBrxPK`Knb4gtJw);ZVbkYN}fJI@n zva2$&OkxMF`-49y%%5UCXO2hb^pVq4hUDi(PVsVt!G@M)1V43sN zH1Rn8AV<=l97nY_<|7j*Ba$;+XBw22q>537aHrgGYVMP{Z%{{YVI{G+jNo_Tv!RH) z06LoLG|vrc7dDH0ilW9+7HPa1&XvBi3Q_N!}aXw0kz1$cjrJV4sL@rfLrV|X0g7Dm&gVdKWOZL_g$ zdt%$RHL;yE$;3(9*tTsujlMg*f9L1SdFJf1_q*3ZxtduN^Bcmvxk_0$Y?ic!NP##5 zJ0k_lU-;!Ba5+1O?rw+V<(}2nq8H+Xs2GIMTS?c_986wJ_a&R-3sl?Kv3Pc@F!I^v z>>l1$4jaiwvppgBwVGC^cLXJ&=jWzqz6QC=2Y>~%k}s~#72s0^IL)Lw8x#Hw&udOp zvY?5Yems#MS*1f`;vcTf$=M3VM)nF6$H*V3F01T98?`LfGw$7mqK6hv%T9AxmMh0C zmd4+_0NcIq=hCwso<4n-VYH~N|9}VmN0}T8s+vDEYWSL6bGl5x#^J&VS}+hO94rft zaRYA%K&b7DlZO+^46>ECQCesc#v@kNbP6x$9G$*4tWp=QrH6GcY`LXhM~F*L@a%DcB%v zIE}PV_eb^V?~>kMO}jJqsL~w;?AahF3|;815~LJb+!84(5af;b(p1?XJBap+s<}m| z{1vPr;r|>gS*%}YRXz?xdZ?{S*Sxe_~IKq&QS3VY4r(y_*e($YzhRP|z> z5y9V1@I@&hzciBdfN~B(_IAZFs2c^Huh+VN64AaHvef3y+Dcq=ckP1^I0iuCZ3hJIV57WR#I? z`YrU?drgQn0dvK4N$!fOc zQcuw?+RUX_$wN%^1If2OwQ{i51`8Mm%ewJ{f@t*&OnkX3h+1O+V#hN2$vFHzX_H6y z3;ebZE3EQf4UhsNk^50f$aYgbDWJW?e9FCXq;Ze=#4Y2~6YOX%6}4mc{-q}@HkI>e zzdxB>B%-2uDh@vdU`2ve4&oh7t*TJX~Qp^^2W@X zm})7qPe$;arCG(FX_(gdmGLESm^!9`n$2~tA}x)lG8?x;MOJWF_vuh_XJJnP|Dunz zi_kXP29KKoNl{g~qjz0dIy|_}I8pdJqu`=R$}r)daWkHC?YrS7v6k`~X>EHuM&%B% z#AVJ^g$E%cVyur(J@52WDVTJY$w_3E#m2(~WuN&QO#joH0csJ{-QE*`QR9d?oQ~-0 z{7=l~9tGkYUTx(rl&hH8MDa}rO4}qhCkR5@%I1`Q(H2oh0#|*OaemjBp?WfohcllS z#Ef6e+W{B8|3M^2@19(NHg)-vP494`N!Xt2Lk({0>MJZb>y~oMZ-)@u-+nFH%HQg1 z&M7&&LrV7|4-VtjW4)=$RXI?*eK~aLC#<&CbjRatYni=8)x2uS+<0mw zz%#q89;)Bt2#6-I`36fVGrn8qWh(w`gN;mUe24Z{Os>e&(rjx&X9%!0?s8MvST6Ik zO|^T~513dytRW5ajv6$=`KtVkhpiz^vOpEFrpCb9sF4JI8S^hW+Z6zkKQARiCz3VG z;vRm7b!yu>p*+{04gq2)BwyiexaORa!A&P5_aIY-Nv)9I~txL2E+=>DiEO_bRTJWR*9N~f}ocv&(I`*H#3ukNFpg6zq&9> ziK~z5j18zZ%Q$tC8Zzx*rri?4vv}`k+6D4|5J_e939zz0Qd7>dI}FO8JQ!%Bkby%N z9?q%~8_PTP;O&AkJ3`XkXi=jaul0x8JPBX?p^Qw{j0rkqp<4vHf@qIkU(D)<7}kQS z`m|CPTdoY-#MGm}I%nYJ@LJ3GsOZ?=GOZJy;v5H0geB!hC6XAMVSqj6jB}(o@RTDP zMyUvMa%m}Lbv;pbtm#>?mi~EKYlhlaP;iwEF*^9MLGZS`e%kdT6W=d6cTDP*yUcUV zu8$F8;=n#y?o+JW^vt8P3%EO_E5#7_U7v@?RXwdh{5K0Qo@daVtT={#UciK=tT+fg z-`qn(llR+IVY)K$@0fFae1Gmy;~xpV(B4_G{6C&p#^sv74Pw_(YZ!GKaa*+N07 zg6#cTLtFeo_+KGm_ca7;z52yMHgk?L>^>nh1JYTgjQOxI3--Y(XV4j|NX21@Kmc{B zK3XIfsW(xbYz&W>)l-e zB8S4w{bBZlaQM~xCXvcA0*vdWA?Gcz3SVUGvB9dIn|9<5Z-exW{qnnXnf*4EDCb^h z-fZ`x!^$ac}+Mb^+0mlAf$l*2!?XC zVN=Y7{>k0$y8o2rKwv3#;ZcvP`0tSM{v{7&n0sR2>SI7)2K^YvfejU0$&o3Bzs#Wf zbLOm!w>zF+G4@@F@I~dCa5`qH!^ruVx`y0%@a4wRUPU& z1z<@tVOJc{vb_RV%Jq_Ek#->=ViDvC>`6tM@M_>)tfl(7KoMa<+C1dDT>D}eNEw2; zSM4V@v)|o*gkRGq7*j|riu z=$VpjRTQLYsVHK%w(plWrL6)mYz zy4$iDG^ZjBh!aZ-;R_K0S7NPlIXm@|5K|~V=Tvib4iBr}Dpg~o9c2&dV&iEmIefJl zfL^s6jR=~p;~jk}qUSOOR&ij=rYfrHQH}(JMsY@rF;uEnVeB_x1QsSAukVNs`u!mlQ4CE;Ct8PReoi zf`eKi3Kcd2MCthaY|ny@yN(GZ^LT<#YR0W8yl(;n|3TE4y;H9Mp9rlaTb4O;;`uJc z#rgJyHwB|!wZ^^~7VQMaq}s?3<3KxC@Jn-`?h93C&Ap8n#L)uX){oYrW~FqJcZ9jA2zJ-MhE0yAXc& zUDnKZ+trr8q@RB}x|4(M(&NmQaT=h2$ALNI`7&h&zNe%IExc8VuA5yc06vBI9P%}Q z)5ajp6f9!oOiX1_(K`N(=>Ar-C1nQz!BTu_-w`WD#SyXFtA>n?Q~yFDH`#U(LkydY zz*B`t6$#BGC_jx4^-V8?u5?wCLR00!2b0obLdW_b3?%<2VNr^lLepULea{a|KqE&E zlm(%P*O^X@>3Up|HD9B(TE`$&IdMaxvehgwWPRuTT&G|!8p8$CoK~^g_^vUlv@3tp z*yetS_3*4mf)nPQYR~;$Zq()Pto>Gy<#CKsq%QMTFEzUl{lb9$BE6SKzF}FJo{e$ zmBG;QqOfxJ)tyoBypjAxLDO`?2^N#G{JBH9k}!COD5BEuS+wDN$FWR8e^upg@(4EmV2_0Wd z0FN?Z@%*Q%;)S+qO-BI^_^nWz!=(?-O($x4IBTt2`} zc)@pBRhskeaya5$VR!r}o8g+w3prpGfeZGRZS&3X5dFGxl5NH|AkO)C@UHzeAtI}l zC4ek&h2@-ZkRr9w7}VWyJturtojjkf-kl?Wf@H`4%IzUuESR(S_|2 zrd&xXov5NUzflD2w$K;A*S?Wb$DeH9s?VF!p*R#YuLhOdA2Y3$Xok=$McBmpOFWtm z5L5Kqem1)WNPsQE9Q~HIu#wRos@S*>XG2u&KBXQgTDcWPeNKwAvwf$bD+zHL zd~pO3U#b3h)irxa1uhwgcKx7Vh07V|KmYO_Zg~CCQP8_FtnRdIZ63d;>SMi*DXZLQ z`79HhM>cn{X>(&L!}_yVq?YAzQgu^MG+^NE?4Df<%>y z(O$xV2zG|c03p1R!vB=3NRYN}?SfGUaJsUzv_X$9FtqR#2lK9Svi)5v;F{YMfd;HG zm(>Ml0{Hi;mL5yw+%l!XS=SNl={1vFJaRtr@t8kq!# z^Tt_JR40ue8_APZ9x?4!8lxH=Y&kMC$pvX8woT8f)Y{lKByj-tJohrX1Rx~l2L zH3xQyuVkGK?}Pi+OY2j{C0(Y~B!36pw(y$SHj0MC@`gF5b^Ve%)+5TM>DgVyn(yAD zAV{J~-D zY!%zo^|QIHN<=*psP(y~>{wQ_gcB@nNBcF z)-DhV%%-owR`g4ee-L!k))W4g<8CMC#6<(!=4$Av`G`O7>qKBKS<`~?gsIwGqM#NZ z&x)C+vt0-tI_QC8hv4Sa{~h$Y`D3DlYglg;hr;4u2@zF&Eyu-`JD&GC8$H)N?(nW= zOOHVcwDI30rh(UI;c(X*fNUX0^^gS4$R~51dV5F8nGu`#1;hz#nafc4@g#YtS83JV zunU>%XlZfGxxfv0;i?d6Q|Qf($ix^DrGTpOirO|Onkt}vV8NiWDh}NqC|i=IZY0{5 zrY2f}(98<3wOnU`E!ry@q@f^)Q83W{-rR8lWCAS_p)O>#!inRdJgo=6PdYJTL2KtI z+t{l@NE>XKC2F3227nff`-;OUzrIg4a^^{PCo9*}4C-VExX>ZB)WtE`oEY7{hJkbN zRu2t&^Nv`{{cIc3PDP%0x0_r_bSF<^xmwQk03oArnGr)l{^h)w@?(xfJ!m0a z`&{VD{>?1~r(;I)3{I}Ju4{qjcd?prv;?tI^;Ra+-{C#yzieD|2r#bk#tVGUd|)Fk z-zSZf+Em8n+CMS1_BP;tF|&zZC6E!!^*Qe>7*BozTrZ{dD>*9(0pSX74irzRIBritj(@T~$J;Qe?=Xm<5>F@b70$=)z7fVuPkRsj@;fG>+~g~lCrjXxusDff9oz0KCmow zz@{qxar=(F=5!$U&Z4Zq$Y}|+n5UAY&#Te8-kNtKTCOJLam?pj-8aO9^a-1_uoRN$ zjU=zSmu_l~$~Mwwd>4^ge4G3*>p5GX!!z$&4UYpsR%81U26fP*f-E!F770ofPyMvg z3`xvioj;`BgN93w|3O^%>X5hn;rUaCMW@*;F!ooHNP}7S^m>(u*Sl=y zk>fq5{uLE41NqB;%E?1m<|r=x(#^HmW)gP<(;z80gucp6lOSfSCl~{(9;ls3ZRw(f z^fkAnXi}c#sB*K);;To^G6P}-<`;$kAeifXXMWQOGY-4d%K!D~$P!hX6eQRu=Os#K z*OPV-2r6v@gh=OanPJ3+AaOFF*biCKy{&CK3aBT^!?*hU;L#jUf?IJe!_!#if+?Qd!XHh=5f*n7{Q`K zfzI@0gN`Yb@XUMf?vMnkP2jt7aBBM}2DQIRT;a}N?P}g(6TMILTcqI#&NqKqf^^A& z=#K|M3F{Z`-X^bn!XL~im|Yy&!guqP^~yC;WZ2FAo!kE&7^h`y3tlXBs34UhLgM!73SXkcb9I7;tCaOV#l4I)Bc0-B|awW z*7c%jY4@VUvEY0V>e}t-rmPI?Q`of)O#A-yAt-cF>61=8*Pcl5Vmhrew|~nVx$Iw? z3o>^7?x{)xII&r|udxvrIKD=1sm5A<6T}{;+8IrG>trq$u5+E0o*6^tbCR$V=et1U zg(<@$O1`<*&N`i6xhAqNEvyfW;kx|0TxFxVw*qi!SFIHPA^lbs3AmYt;OCCI!W8ZA zA0alR-&S22u2|E~r|NK~_*JNdA79^nGF{{`p_dwLZjkWn~ifI zaI4TSU&h$*16{kRMN&%I*5><($seYRZ469`n&;i_bopudNn0 z%AN+a9`Qm2_tqYoM$$RiR`i4^!GHCq2d1#&rwhh=&SY}fO~+4G`qEuFuO_B=Q;F2N zK#PK*iQ2pO+F$f^D7-z>wmp7C-4W2G_*Y-{B+UOZ1No?f11}L{f{m4IK1+UW=<);2 z0hrh>E87`)%&}T4{_|2tNV&nvS?eCYc-r9Bl)7Q9vmUpu#vqV3nOmxjbh%8`Mo9CK zbiRtGvk|#(zVbq#TDC5v_yG#oDotnkg_e_h0$*cd6F_O8m&G% zBCCPfb_T-HSf~Lv2v=^(jG)?mbm6h`_Ac{Hr=Ztm^PE;_@uZ+HiE8>ddG_CzdnIS> zJQ}K~23w=sMMG>u7wSKk-E;yM8^#KhblYmTsHQDQP$m zWocI?ss7d5G^nbfU?egMOpLX_e59-~O$9@^bh(NM)+65r9#g^*pnjA5adyu5(C-Oz@|Sb!?53sXLZ$61Cm(y~&t?H;N+m$62j2(T z$(om^UKats>U z`bVpx3k#b2y4fvjBQ%qI%8-Xkv))PfR2!_$!HPUvPzLTu15`d_q{~BnTdyI1LH{y6 z;iwIxOfT$M^E6KTE2r)TiymN|Sn=d;c6T#e@rw8qh={?wS+Y+vCvf9g6q ztxMk(xm$O+l(DQL^Y(`gRuSZG)ydE5Xh>J7jK$ zKoK|erU3Vbg!~4MZ9CXn`wFx1>C%*&Q(}P9AktK1M8L;O8e!odp6=gy>aeMt1W3Zu zpX&Xzy=8kphUxI3&#%YIGtd?EL-vmCW76)bpExHr2tr1-rFz!1jSI)YOru@I_~};F zRcaf%hiFM9ka=h*mcct(mnT^J@W%DKD{;d34~5iA4T9ua*sHp&J7sSIZ^5%{Al-%H za5%;4%*6J}Yqu*7x2RL_zA0bTL#@4o^c5#Dn{cP3t6|OVG_2H~(YIBF%3o&Et$o;) zxB|yZ?SVL6eE0oYaCoAOwF7@uJ@*@n-BJtqHnwoaVo@GFZ?=xfVt?sBVOrA4JI3Xe z-mz=!^Si*REQL&s$1GM<4k42 zzn?AfCQeJsPxDp12^vm;cq_MqdqywA%I$H7azVnRdfZ;Q8K5|6DlZEeGt(w=7)`>c zQzLaRGaZA#eoek8a<|6#9S`T;4++20ZmrgLti=JK!ByJjy*Nqw7va9mK;5jclx+%1IbwoQ}+1@eRW~1cO}=d)%8;>^P%S`T^(5E?4emO z&f{h{o)ZP7BgE9vts_9^l9E4IZP~#Gubd*%>$uNJ?{b+#6B|!sc>w% ztt+v90_)gT?KS*HaYosnJ+2g7ehJ<}_`1)Nn%ol?5T%c67KiEQA2$d0$$i)5D7yK~ zQ^ejQ>LQLpRFlFQj7xuw*?ZvG=Zjra2x^w>#d&gK`&~J_ud7?ykyodc6#7_eoSlp! z#tXaEVLf@xR581Mlk{vRrDzb%^p|9Ter7Q`t?8&ZUdWGITm!pMD^|mCBj~a28@y?D z2JaL^wabulfox>*2oI-%D|rehA@0UTXE2;abQ6mBiETj_XiM585)-iXDouQJpc&oX z)T1wR*H&2_>cl#r7C~wA%%0@6#?_CIvE|5^VC&&8#4W(q^tu2mAMDdk9PfBpyqLZJ zAB3f5SVytxgeR}bR@N868cS)05;4S}0>HQ-g>k48HH0SUpw!vaS~hjDeC5Xwwv3dr ztqJGQ-Gt&`v14~d8NfOK)^-K`>hsh%EcdV3HJV;$M*MD6UH^I&JjCBoVXr03j{>$| z$5ol)xQeMxbIcuoHpNksWZ?R^C2DjXG8qr+7N_P&+Vs2jJ5K0Y9@jQD*^4g{c_awK zbwdq0+vbQB!ongXH>qH^Uzg>%7H%7n*(x`%!o4;mHR4Qv2(abH(aAiha9Hlkr%uNq zf~Y^t10$WU=%8UNr5A&g;iWC4fnzxlpgmJ=}eXs8zk~?ul)_>bqCJwcy60_ z$xzH2{Pu-{#AE+BoK~vvNgQ|`xh0NqxMs-f?#hNNB*%p?R@*R83|MzHqA}{$JA8d= zD7w zd6Fka`u;Cl7J~ZOjQnuZzloScTnWBl*JWBAp9Cyq5KW58OU2)y`>i}@A~=(|;%}3riK7B@C_YZO zb{aW)*zIZNChSY8DY6%xZilM+janA+s?|qrkAh5d^r$!7Q?Q)VC9W~bz?4po0h41f z{bsaCj`^ih=LDNvWI){46Pjm^usO>h!q8;`Rn4-lb$l@bq?OvCq5Xt(+Kr_$%CA7r z_Ovt=b#n~0pu)W%^presH&2!pTjVWD~WAdo!+Kb?m*)YNTVY~&- zrIS$KG1AT;Q$>&^rm6C8^yjKyfH4KRVBd{ek|+V17R90iW#||WE{-LkboFQi!5oLdpqxyPLMEHx`E0xe zgt@x8t6G8@%5_3*cUTT!XQPToisfOc z)aAM$GQE~|PpabF4?1UtgCO7Ft&+Lj?`I=BPG^3ke10|w46xc|En=$ur`ha{a@qY|9UxastcO#5iE$Nyi_1d`YvgW znpI&%7U%r$&V7`04JViz{hI9mK)w}3KFMT518%p)sDP_tNm>m#f-k8e@QP}a^x|Z3 z={%*PsUmB(&O<4=8}l|%n>T#}&x7VC5`e8!NZWnTu5Bu)!&WamS&`M?2VZ7x&ixd9 zezDCa(G;Y5h0^MD2SMv^ldlew7L#6sH%NNj?M%oDW?Y`BYB<}P?ph5ObMb-+)BW6^ zTHxZA*=O`te|E!`RluK~j`kq-3Z0I&+@=C?m_jX%;mRs{usY35;o8mZHE{JkE91zt z5?PYp666T#$>`f#QsVmls`dS;3SvED?HXqcIWcr-pvy?=oGbwQFoCeKzOVp z{?nO;jW$f9(e_Ewa>xaYe=H5ItEUK0EmVtnN{lq*w>J^$tz>zVO-%pYqs>(!W41RynF1SS(Q#@>%5=@z z_Hl8qHy3;4ShTwjUc21I=sB)2qouW>FTI0Inghyy1s@71@Sy-NgmZw>f@r|!fqrf; zN$oT(DNR{|5fXu>tWZ=AT%)5YeO4~&S0+MLoohPuq9*WARe69d8rK52w^Y}CH+6Xf zFlU2`>QE6%Wz_NSCd4tElo=RawO~czrpz!^yY-EZIB}-HLX*(b6Q-(-Y@vg6{jLAYenM@=9hD4!hE;mIbt0Ny<`dXWK9@m zNmCfyP2Q#b|AVOWQg<-TJR%4UL301~<#u8V>-U`%BULtkz>`oJ%5&yx!lNhn5Bu`6 z-s~1RWt1s9@cujQh?elbj#1Aex~2#JH)gm||C<`cm$u?Rk{b}86 z&il5wP`4d+)Vk`Ixh&E^rHtggRAhq`cKjwJgB0G+BE6jvA9?esakSW?;8^vzf-??J z)su7RW4QEi_V5;i&W`&&#LJ)njcLALp`vKc0G77cs5>Yxq|RI%c6mOc{b3OMn4c@5 zz1#W3G=tz4M8Q~+N0#6i)XdwvQne((bdaz<&Byz_RODS}Dx``66rXFR9P4=CJlR5B z-Vg27;vzpxHy;AG>e^{mJBazU)?{mK`fD1GJ=gq}RPC~zPd4L~=|(q})%Ns2Sowx9 zcNdL~S3j1KyB#lpRrZdVXlV##~ zr#1KRqOP{i*{k>YuQ_W|``>7Wl~E)cz^OaTTgSd68y^r~OPVQ=rWx9lr8t_J)07Lijp>%MJS)Xlf9I(;BHVkkv8bDYQrGG>*C&erj`n<)q@u8m zgrY^Bur1NxeziT3S847o%?7k;OH0Cq>@-=S#>li!Ku^QQc_x~`WH5S|%0ul%O3Be5 z;yOHi&YziZUj=>eYC}0KrHq>2fc3dhs(PAuiLJ6*Em?5hBnZ8$Q?80^(vs|hW~w>a zt6_t+{0_?;Erg==RZ=9R}Bs8UqvfL%;Xa}&evn(2J;0|A7nd0-YGJ1XtpOaQ2h z3BHxVJ6+}aie6%{RYmmCP3gQUi9B_l^Qxp>b$u#@wrzTbU2)VTtEbQeyM%n6dfkKq5|nf` zX{XLbWnjxV;?!DaL--bPlV?@aVX`D?pek-2-<{~j$x$|j_6sJoI2j^r3?+H3OowmF zL!|a)bcPTZe;qYfA7f(A&=kjMMuZ=Hq`gBXi#@2dA_I|RkTLPWiQbT=_EkIeT|>6Pu4YkzI2Au70Az{ zFKK-7b!U)c><>cW!R)Zu9VZlgYJ%+VsKd}fmV)8HrATziB^KAo#7bH3(7{Obd7|a0 zu}$j>Lgpd+$tjGmiIZa&VEQC@+77SOag?@$WW8ylrehG62PgknKQ2G-=3B!OhwZ_? zq;PlTHdjX1b|~=F;ufpko^)j_1nN9W<2Y|c%NivP zcMC(hk>H(8f@+lyxSAZ^pGikH8%1QPLv+>}b&Vvu)oyX5n32C60wuy6C=BE8&Y@LX>ir()!K@6%`spFNC;h6l-Cm7wY=qwzc;YP zN|m8Ch!5L|Q7G$h3M;=zE~v2vMnpRw0I((z!_1+!nrjvWY|Zv2)kI^iwPtb6BQrA4 ziJ>}pP7RG@I2MOhk&*xHb7X%3XCwYEfXKoe6fnaW(}moxEX4pp{1ZxlQHmCquJ-vZ zUr0a@L)0HCE7KDT+(5`+O(S-%foyZ2e$$8@*!DwA^wWet*MGn$!Nzs)=>VOo*WiHy zurhaem4xF3m8eRHJ%t_$pX(B7^6+h4XCCWg`-RB6Zl=mJQF&P!A+_)O5sqBd25IP9 zy4*NrRuqU85>Zz-y$tO&v5;`1Zm+zc9vh%;C9}xFnRbZD2x|q|0M}uU%>-;VDT;n= z#$)j_$+~N$q@bDwV>s*RI=j-iNBMg(*B7-O6hKr6gvnOWyRQ}S&q79;Wp+2B?>rcG z36B|)o9|zvCBIb9Xq+-7Wy4^J3?PtP2#%ek>0&#QG(1KiJL!>r_5ZFdb^PHsp3zwprz4G6iV&1cST@+$QOgvaw=p{^48-gM`fJ6>`splj zTU{y^d}59%;&jjWJs}JC$=mBI1sSGu2dVM$=b-7&tC+5IR&Mj5HAYog)uz8murr%_ zRo~G=bIzsck{_QbsyeuAn72D8YlxD}XNc8Z%F)xKiqxsLMj{@SUAt4?vlSvpChbEO zCsuIOia5~O0jgW;=?Ut7^urV^-E0e zj!02KIkAemus%%hBS%b|+3l3{K4&84-XRdBjAzhQKU+ODB-Do-(n)i7xTridUqa6H zYqHQ&Kkdo*%%b1UtvD%`N#0(vdHgDcTDm(A$?I~17yI5@VXV?EEmJ5$X0?z7c*?qb zZpcyLxl}K1;>+Q?2g;ZJ52Cv#^?^uZJv|w!uv0EKC z15t^1(dRR}0sdw=j`KIn)>jphpn@$u`BHimV;{VSzX3G8-h?%)Yu-yKRdORruOrb{ zf?Al;sY3@O>3%N$^j3N|51klTsvAnUz%yZvJ`|dYazH{Or0y9vTHn|#LrzlFNbiB> za`c1ksJ&gwLtaBsSFo-sFH7>!{N*50S%*qk#Z5`tT^l?c&lTObn)BFJQD@RXMvp2% zk(#8W_1jf;EpW55Hz40vAGMYpX*BFr46BT z1PXpFOe=a)f>zqUkiejPSO%LoT>Xfzc+AGlfW5}iQbKDEH;f>hdxZ)$Ylzaa(n9!4 zb2PfY*SJEz|BSGfNATD#x|Z~Oec>YG6w0K-!|u2VTIB& zCbSRc&}BwTD;*9gO=zwEt)E52K+s8KNa(|o_~IqRK&TEpQp{P#xD){(+(aBkYnWNS zwE$|6%H!tS!>OsM{>}ANBzVoJg79S&!KDU7+DmbYcM6V5Y4Qpkc;Q^hM6vbmb1uSy z5r@|T7C-3Hz|5;b!I~WPB%?L;kLUWh4X%_VY+S3$B3pVVHqJdeiq6ebQ6Wg|FFBF% z{&A}kNDwklR#P;#Hd=Y*Ns2q6z&4_i)n&5$kcDZI&=6XBF{=oR5eU5EG0~^e z87j7z05;k(8$|YhfD9E0rhoF$7-L>!yz*ohc8y`(E*uyEptXFtwHoLscgKOJd=9tG z%9(ILNG%vx;%j@*LE@~jlQc|YqRTx+5k?HC*+gq*tJd?*hu4&z!c~-zkZqwPoXXrk zj}jYnPbrC8R)eWOuxGY^jHjQVuyW))0@lVcZ(@#WIPliw*jQsMcrSAeJNlyobZye}2&1Ok z>uENWY{=<&aX1Nl(rzK3S_Rov6u5KWx|UeefQQ+eQSlfbWw4Iqz87uSKxd$SJNaD4 zC`k$zuO!r|!EsoNoQ{3KsC%N_;-&6Tua0bWx=?y-)!4;US%k(8&?n#2tE8&FOZ{eT z6dt&o|2Q7&8DpP9`_*T$sysorU1vTemcwnmqLsX!-kvjx=}W}!m#=12Ka-QytuVkO z<@lC_tK;gjQ3X-Z3@{^~G{=vewM_{i$L}GYstfmNheOR%ea$1Hj)>=XS%dy_!Df1m zG0I^*PJ`z-<$Etr6_x2KRWS)hP0ZXdCm?VS{vL@!rK z9$lRUY}IRO61ihR-~%qS%{vq)L&iB=*-9zSCp*kSK_viM+bXfTSbwbl@N?F`t2}1X z&YxsJWC0NZ{)520sP*ts>i>|vTeb4um(DWJf2r|l>!$(#I(y$P=V(T836|kuV;(E* zB|x52WKj673P$K>&Q-(!Kca4+BBNcfR@f)4&DyYisaG-MclpmLuQnpbMoXMZgn(K|K&*SzO_$J?=-QJ^*2{p5?7G$i`5#1|+IekfH+Qmx2@Q04 zhacwa>(Y1KyFsEY^e*LiKvR=VL*9Q7{6y{){FyP~3}s2^$z5hC8Zz~;>9 z+^)zo{db?{Oa7Tr%#8Y!wSySWKh0pz&y})EdHeFDj=&Z&q$O}VK{Un5xoxTLC2=^D z$owhZk;0<6Kh9asWS=`^<9ZI%&vQt5Ct|lW0o)4RkLRotkihWpoDDrR7-+|I1N6#i zI$L_lYsd;+aOxU)I*O0zjCYuA9F@05PNzb*79Qph(gU7*fno5+I&#n-9sV&l!sKTa zWvcB^3Q=nz4YWs6u;fA^oo8Aq2|3NjPC5p%Ek-R0lKkLZK?}z^w~?pyzB(pvPh3vM zirDKqO3fILxGy27J9tM2E(57D2-m5M&k`;!ynwBWSphrix3uCkt>g417Ezc#)P%a_fc}0v;-(3+RpS1NnEmMjjwSy z#s0G~ZdSt9#jWJ*{U&9h?gwe+kD9)}#fiY)upX$rzJGtR;3hZ={T#Sx{68V*8#qA$ z`OiuQq0(EO$#qQi1D9}6uL3~8(*Dx|!8iw{# z78ywrNw~5QK5I9$UXPuX; z5t3ItaZ0u1;DvdhLLp5hjO(!OZ!4=KVlJi5o~Uz~NeO_xI11mrO0=)2MT`_%)!JTx zx0h*W?8Swq^g3y0lCN6n#|D}-Hf)MedY&yFfvw~)ixSroCyS47 ziGsHNx9|PPJQf@yz`ZT8#@!N!!lwp}g?A`NpHS6VCbJA$n4R#ZT0vklsNqZYn#7_d zR$>Y|3)=*&->X*MMR^`jsOwD&UbO&p)NH`_s=eEt?ky=Pj-0;sqPDwkpxBvF{YxPR zX-h8-SLjzr=Nln*KOdTmN!Z2)^Ja=!d+6obPXYgZ6PR?$_}W4xntnTBciSIDN_(FE ziCp!3txSgFNZ1(9sh0-{X2V-FtxL?BLrZX~W77vA5=L1>xx`9yJiU$D4bL6s zZp217XVcusA{`j{5qd?-qEwXOur@#&vb6~RpfG&Tx#q`rJ9Yw0-+rn|Z_K6Pm((C$ zCZ6gZWjaJN&Ku!*#@KbK3#UflL#Q|5DbO;odBu(f9dctWwJkL@j8lDi&vKz3ez&=q zI`5ZgF@Qe={&BfIW`_H$(I!H^1(TJ-nIife+)h!h?MF|qens@WNi4g41S;xv!Dsk- z;#df(KWh?JT`{WM<14mNz(Ytq5+b<^VJu5#Ge6ny2bPR~R!bg=3MRIA{9=7kBU~R3 zEQC&w92czG`TjXwG1pzKXIsbS*|>0Nkq8TIAZ;O3++3xgo=DI4v%SjXj4laGAK)WK z^K!RmGW?trp52sA;rxX3O#~}qTfWu6tqh22@EmmsLg`!m2NC^001-j%zGd5nkT33J zKgPa>v%E*5TK$@PyEfSIk>^3_?kkNyd)d`Kf}|wreRBfrx~01AWT%WZM1`YQP^Ydd z3TKji(z9iW$u!vU=50LZ>-SFLS~v#e?|NueP(Vk>w1Je#r2 zMJ$ahh1lep)7EtMuw(>daIBhdO#y4DPz3-Ia4GDCM>K$s70~H=4ZYpBn>D~*I#)lM zu^sG@rqILzQ8ewL)r53Z?^#_7s9B3UlNz?=>}sV;G|e+*j%kWA!l_=`nALD|ZW{@M zMh#jaLexYGb~6~Olg&t2D5mEW!gD|db44vKF+j%Bigp1M2-u9`ffsG8)#KhssO~U_ zXf)WRkymbTDUa$+S3z|mG?b*$QW&6>AcKMqL915Ug!a>kQGg?i0g9_dONx7y8Okp4 zX5Fs4bq1#$^l!9=82|yFt~%6SA-0YURi%Jp-sB16_RmrH9M)Pl1$}uRTHcvt)pQ$w zEN+_J@qyH-{{ZXOR^*yByQvnAe9~6T9vIZ_F}4yuwWn|39ZF^a$V}GPMt;s+j!u&m z>Gr<|?&gd;-UZLKSw9A(#~0)BqT=LdllP}rsY&o=^bg(Mq56u;y7*15Knabbkb4>~ z9E{)yq^^qd!CLi}e9I?bJFhi~HI>!5B3pS7`>hv1<0ZN)(LthuLXwt@P%$YfXrKa? zn?(RP(ovcy0HTtL09@3c03fRO)D30E!Tq6ATkbI@9F)#+g9JQql@215VRep3>Q&jfe)QJC|b2a!JiFQ;`}& zwMI=l>8O-$^a64{>F6-L(`1R_IAMyK+6nHPWHB?hqKXqta)gt!LPsQ!$Qc-e?OQgQ z+=PUjl0EA-YYVtImfBVNsjZD0!gso(tFoBl&r&H)DXmTL^=i|XxN2GIdm9_G8SPQ( zR(AJlWQ+jb)zDmcKHA#VRyn_Yk6P!ht!``_q@aP=_BF=+*P--rUe=xDj&9=CScx3s zstl`FMK;%7aBDJXS9Wn)#%G^j31@h)g{4Tt6=0{KBZ@~|&6@R1H$<@4{0Zmp-VxO;nu%1DO<8XD??4(pa(3Nnr{RkBwit~VyCP4}wea#vPd$d5eMg|n=2 z^}(tNxnWOyuK?4UzJ^$8j+6G5I^Pen%QTG5$Ww}ar+{^xZDqT)R4cfg6UnSiGUefJ z4_fK;j~8F*8bvZ6ny!ba=(iqC^}ED-9>%ByVtKE1 z6Iyul!*j)P8jGmcf;#5Bee7P|cZNm7qZKu*YV#w^tCzS>l&c!yYQ?Rjm$xYdE0=SQ zdJ1ubuWC^|mOpTncN~$_3LW|#5QJjVp2*me+4OL2yy&FoacJ8h(Q&TawU61BX*`8I zN1vBJO2vwD{aBx^O^gg<-nra0ypL|4C--VJwnR(|0`K>Us8pEb+z&Nil15EJ%6P3K z*z@bg%}OS{wZM@8ahlirWKCoCb%6sC331fdIT0!aT!uq~o|Vf|p1L1JgvE13DVEye zYh_@BsUw}I99AUEWO7N(S-81i8FTfhO}wy#X%Uln%I+A*^{b~FYR)`uUu!N%>_Z*9 z%^;0^c{KTB5V4FL?dofL!>MAIQcHS&cN|XYJy;Bi=bg*3W;rC}*IpamlYNh!&Xj0U zj2Fc%eqDsz!+=dRoYE6XU8l_5y~U!Zw6eLsoIz;>lS+CjE=@^)rQd0D2(PVVfzKd1 z;+59Jv$e{Ul(duxN?ItO3e};ch(6dF;y*D5@Osq>aydhlBp*>zB-~m?v?mx;jHa%a zLt|fx&1a5FNW7rql=Q4>l3Apgw@Ag0Oq!0BIJm_oRw|`Bm1Qbw$@B_ZN|xRSxS3-? z$*XN8c4HX1H5l&5>1%T1!#6P5`Qd@U$rXjr)Iy|YuNH5J!dAmHs>atHPUtgC&1lCx zq`EuCV**v`-Rnyn#x3VDqj$|m44crz-G7ABt^+hGdjnON805!sQuirrK1j;**wZS; z?=~{W{sr~*s0xvhNsJYadh<_XxpEE&sHtU(RMpjmvG3~b|R zE7Xrn_Nd^-!vUU$e!oTz#7!L2r{Dgl3;hlhpN3hJG-%)MFkO*U2JN{*7`R ztCRi0-F}tcU-%s0}SzwT>w0@4HuHpxAn)$6+qLEz~tEmjE4hTM?zKi&I z<3;gaiS~P^AKF%`7G?hco{QPX_4leldmek^e}-?QZPfI$_MJQLZUg2)?~bG1xrl7+ z<49$@mHej+N}%hGgEj2a>XLXrTNb*H?>srExe?04BGOaUTm6IjRtJi_4w`(;sOiyp zx^$U$g*o!c{w4KV#=R!h;(Ga3HWcT{Q)krk38D>cBW}jl`4if*Wjls3TX(QZj>Xi4 zOm8E&JqWC;sC=@3bYY*Ra>3a4F_Ch+TN&VB^Hau1ITafM8yKgd#|F2S$B{vD%Ez>P z9q~g(^JrHxWgK~s20agP{cEA|rnL4RB(ZP{NA_|yb|*a7hUl7vx@M(sc?)6TaKrGg zan~*3@h^tgRJQr0fduLYU8ku0Ij#z~<#9*7Mx7;yg?X=bT0d8%{$~rS>(`Tiss>ZrHKDn=MrTdZj| zHg`f8?u!zk_XXnwX0g7-0!UeB3{7=Ht4ha*h|84Zrxm%E8W{4VdG^y39ye>+QRp8XvU0&->x#CzPDA?$6-l!E7+W4~Nd`MqiNIbIcLn!U+ea98Zc{~D# zc1Ceh(BkwWMv^w%j6wFTtq;W-mVWBt|t02&fwb~Mk%e-f|}Lt$eZ?fc~z0nscu?;V z#Hy^h`U>|gGvVijw9q`gDmk2g9lpmj*ZDXKCHnXE^M@mHH z(&y%k=eBzP06OyhM$hdxO2TV)n3CRQyMl~=r_!dSH9dNrIBZo)7mQwybD6kLE>Zx& z9jitgGc<9|ql47diEPtUjf`Vu>_ZJ1;8ot_~?zgHB)p;+l#}Ln@UgQQmIjTcry}S~^oR5r=whJ&r{(fs;fq zGhNq$^b>Ob0Bn_hQPVZSp*aA0*QV(A7g~0PCXj_dxdN^Rb25B>Vp*e&K-?>bRA+6f zGEHe~8k_2O&oiDgfmLm0SR~%VG^Fmw6=Yk2!^=(Y*WRgIurgqFsqQrwm|$=!i8PyC z281+%ihO9&I8_-YkwPl&H6{Yqgqn1g_Tkxjiq3Ad+OapdZZw3_QW`}C6qK|8QAIfr zvBd%(3}xHeuAPylIH>X=PkOBKmNi=oanB&n6%k@-q|=f&kl|FHr6Hx*Z7p4gO1YQ# za4Pg#8!s=DQ0EkM)4|rMv`lo3F3^2y^j7iPbWxhx(>y}9E&~n) zPqemc?UuZtv{ZIDUb-2h+WJrN4`<=Z9`bBNgOQ0S38t zi;cc(W9Usp-!e0mKV>A*=%>Um!6%fe1`Z7*{w|It9$q-E2J+>+)o^;K%~dnA9Fl6) zO%8_`o{uMwu3Q9-_K#fFg|CbxSc5#I=ia=OO53{CueLrm?l`NBLz;AxdLFc%J=^?w z6zM)7q-&QwdJ6I%wle(L>C&q`%#%OfB$_>?$@Xzaun&lK(jATg%`$yoO4L;DhB8mJ zd1M=78Do|;+IVA5j^KweJh|(ENlm>Cy_!npU0Y1j<;h6Z57N1djTStgEx#jPiLL37 z!VWFvQ|`6N$rEJY999))D7_C)34*0wH<~$VwE3a!xK&aJI3otS#!z@_r*UH(qdQ08 zN*IokBNLIdxu`q&9Q74y;>qD8jzv|jl+#y7g;JcU%a&@)N=jNOkR=r0IiQLFZ4^;J z3)Yg9b)e7!W|SIAC<0L6bridoH4QFkxU5MbQaI~TQqoW`98{6WV{qzu6&(XP#Q=7? zSB?#w0x99&f!48g{b_Y+{KbqYtoXFM>7(-^w|8GqDzuTw6K#=g6e-!F6&Lt9% zLCtjt1}zk(xwyjl-iAVaOt{*~I5q`uDqcJAF^X*H&y^0Az=; z6^i)eFv0h&{{Rg5$2)BG511YUn%MClhatMO`)!CDv62URnNsSGsyOSrNanN+e)C1T z{{Tl~(XsiHHGjnykZRGb&d)AvbH#HiS}8plPeW7Q-y4`hk%j`YPg@;zAs$|3xtL8> zny107WRh&3t$A;m-odb4K0O@rR4>|srFNkx{e*J5PTi6%gKr?wZR z0C8Nc>vQPiPSH^8bY2(MC)2OPMIj1!aqU_c`h1#}sU+6%77`rrE0xpPqL`8oHN6Lm zZnU_{+p4i03l5cU?zj7S%=hC=4tA@C^l4k11IP|Of z=A)?UH!C)wBa*`^4?sPuAd=0B-7D&N_?oWVr1s>4y00eY9_FjtMtI|j(vBiQZM+J` zq?ON80Y+SjGPc9J+L&Wuf_-Z4)m($r_NFu-Fd5Ej6pos-E<}LhwsdU@^IEw`p&}@W z`RA8}QQw~QlIh8(X$yIEku|~p07r}cp6-3S4_dQtt(CWp6^Q|MsO&!q&T_W4I&k!T zqH$8O*Iejc8quxQE$!1#yh004EAB@607vUyf8tGEO;1>oR~RS)DuIBYb_1}khSyR> zLkWdne^)1w^sJqJ$~&8La|&W;hFkri{xvYDob@!sU}Z*waMiB8*Oy}+)@H*6P+WY# z9-LRXczeR$3-JbrWvPEtjg>e(E809M~U~`(*_<W&RUc&^dRAZNK}9VkcAqRI6tqwUYFa3u0+y1NfD*JcnU)KZ z#;8(*j+HZyJX}q%)!hoQs+Pw=f8q&>c`5f#70etJ!$d* zoCEZx+(6dTG;NHj>O0UFn8&C!C5^+;O?~*f+s(B8++3Gu2mR(sqN)tK41_!ebYV<2xjZ5K{wwiXT8tcQihib}s z5$E|IQCZ$8&{D%y`xH-`Nk`f&r3WKpbGPZ5<-|jm-(NG`%JDwa{hp)r{{SP;9Wp)X z6*ptnwB@yLGjk&*;gP$i=T*czBp`x5wUVf;cf1=@yV!~ov9_A_Z--jVq*^kh^ARL+ zn4LO?iMyYnuO5|fna3lgcRvla2z1$QF0MpwrxERt;dvkv{c8%U=}7ERv?W2N^t!RB z;>{fC`o+bf3_~K9i1uabFeGkys#KmSKM$vhv<7( zja*xsY1n6K=Y?U=_Z5WU%KVQ{FUI?Ne3ST=j{Exj%$JNIRs)Cq4I}gNk-@Deh(CNO z9FId)9y7egNXQumoL$YTLzO!Y)bn+w+Fiy;aHc6ftJCzX0Y2^z718N$7&BN+k1pT? z8@EM}bo}~$HI=Jr?`I(_g-&q8(AQl%Jr4sHDaJhUdM(VGh}vRG6US<#K?ej7eJgWI zw>MWlSa7GYJu7{5d6GpE+C=Y;7<4tds-vSknP46vdq}%n=JcH!OScnD3P8M)d)G^A ze;hJ0huVw6)VCH_iD=C!jyQ)!2d#29@{N(B>I`x_#>&`%a%vn{27U`>wpJ4`W)=)7?DW!Md~d z(bg~e)TfeCLNnCsDVIZjn$*qtvO- z^38nGt>s7xk^^@Y^k@7mFAL8D71dyLBMiLfA4>3DejPqNV&Qb#sOPk2FB=2U6VUxB zfavX(^4@9Va~<8N3|Mq^{{R|puc=#V5Wpn0jx9nZ+VjS6CLM_$zV%Mp3#+?(kF#Zw zMqGx+0+Q9z^3knkP$phte*XYUPAc~|RUfl(zn}HyXGb7X>Uhuds9m>_n!d1klZ0#s z>6)P=P9!mfC4t5TO|7Y)HPwbPW14(%`IOX`Yi)5>Aq%@IX{07rka=yknUZSc@NWgh zQs{9>s{#W+qLfksYfZmtLf>>6>2>{o?G`avTbv*tHY*Y>HdnJZ0B|awUbRU0k1zNCpFXf%JJw4a^{J>LK_xrEZX|%VO{||pFv&LpK+wls#8v`@owmVMAG4n>;8sPQBPc@l%HGYR2uP1pJ>vbeA!yHw4WZ$SXnfur@ z*J4c(LnFCxj6&nJ2;r{uOU%4&+IUMS$wSRiY^lK&(P%)6wn<`dE!UH@({+6vmO}Q* z&JSRwvyAn#I#d*?rnfoa*EI3>bL&=rvoA>h0FP-0)K!SIE9t-+7BTAWiqW)0Xw;L^ zEXZ~&a4JZF$W;Wf>;-go-W7>{YnzhC(lN*9T9Iki)+?A`=lk1t8ktstI_PBhnZ9W& z89GLeWRYdN2X1&kGEH~-ez2NkVko0qbsZSSNv?4Xr!Wm7riYulu`loo#``5X^2rvO%${NX39Yo(mCi3Yo^wGN-uQuv_ZfaHOP)B z;MFH#Gz=-7YHV>+>Bc0yR+ItxlD$QhCx%*cCShBHok75Ha9Pl zybSjhgRlLcP}34vBSd(IAa|~FPQH@D@h6PngUu>c6ytNF9fXz=ud{Ccea_RydN{JV zH&73e`r^4w+l6oHo+*z~vJp7v7_M1n!9JBWAg^>?3|5@7*qE+r?vs&Y7soX?n6mNIfboD`;&QP<0}wv0CZ|wVC06yoVIaL7Bx{)!ff~To0M)wsx-^ zo1{{_cdBytF3jOa{i~KcCR-`I)Pg;uCbsk&3pSZ(~-Kp5-Zo1L^Vh6~zBN$w;NNa0c>XLH#`O>`P&k3HK% z5t0bnM%(4fCd0?Cr{h`H8okzub0n5hta3Qn<^jka)Jw0;Jms4*%Krd)+;Y{7qS@)f zq$%BVCHVdy@J`kbhFX-9nJ(@uEiH#8M!8lP{0%biPw=*caUIdtZzDT`M!R7j?;fOm zD!!TF+bFcrsQ8alYf$4c*;}YGxcAQjxvfU_-YCpg=p&ENa?R1 z$^7+iJ+e# zy{x@RmO$8yNAnZGHK}gzZpkEURn&r{b~Tq~tn=lLc8b$qewFIQSp5E^+_yU8;ud=~ zo@p~Ha1eJsrn95*MA}{N+SvKCbx8BT`j1a)=cSmU?jLyYzST{RTO{Q5CaKMtsG8F1 zmzuTB&F$p7<#YHb^aHS}WK(Te2qYcL3Q}t*t=ZLDcZ4C)FV%%56qRQ%QAH&HK}8f$ z0?|bj0JI7*OF#t_v`_*OkVR%Xm1a}e)}>LrOgM4gl!k^b7EXF%oF5tVG|2{A@}La3 zT;L9-kP>Y-8%w@9#^dQ-m7SM>t?kt>Zgo4ENcpCQAgZV6PHT-M=cWMYDd{PVvOg-M z>?W>sUMKK+={9g`x>exRbZdizxKYYC_gr>0&Omn~#s+teKBBt+00(Qf_E!?=+JgC- zE}{Fon9n|29*#bhlj7eEU3gPkFfsEjU-y>Nj*=&1pIR-{6X;+PcM5y3k~JCmfud|N z-lGAz9^Rsu4tb<8nf%30jgTrAAH+J)j41(R)b>}mI(_68VV^m`&!9as??jh6u~cU1R8x-V*Spis z{{SN3d3npGMnazIeT`&lHn?CA0IT;2Jy-t#tzG`FG+Kmn-bMr|aDmn$Ms}Wu{{Yoo zrTVD1ayj4k0PKIlyco}xO((JXO)FQY%+;GmFFJt}hd5>96<*r??9Rveq9>=NSh`*t zJxKzxX3GMnw@U7&l$Dv{V`|Qf)kr%ucN#vocc)C3x>WlmTxCb`4?;VN==Cd$Zxcq^ zlo1G|as|X#$Vol@k7Hg(Yj-WXf{sBI*Z60|OKqtu%67*v^5z4hDev_iYdO+!)1lFa z%qe18sFy88_?Fh))~b?|Q%NA$aG|mVbOW(;0sd&*ZIOSxr>%EZhb(U%hsou*mpaa!SMhi5S930#deOc{ z4^iBD)%CxcMFnPjdo^3}6@u*>GT~QzQe*F-{{RZ*M2{ccVkso5B_v%+)i5<3DSRgU zm+Y~A_Eux)O=4Wm)4oqm)e&}cmN}#bwS_ekhZT*TeL4*X1an;$k*KR;&iO>P&&NGi z+*dl?0IA`WFC_9Q&NoJQYR;Uzi+at9>G$sn9nl_8`&MptoOKm);^FTAE^<&{RZ=+j zs*UZbm2OUV$*|mvQe^bzjjcyMl+1}>IGKMc-nP?MRj^qtzvJ#BvP36_9gTDGf)3-y zrCqbXxYO>0_VN^d`0rH_F_)H&XK-Pa9w}GvMm54caq5Z3=UTJ)FITZcE&Zfcs5+Uh6$tz@n#8r$FKp!V zEpDfUzu0msM@zN4@h$sDCGE5<7jsQ_F42##b5B78I!2u)eBEZ&5}P!oA1NRPw}TB0j_FE zUJXE8M!sCga#e>Rhhi(M)iro+FN64SY8re?!zf*+I@iA9k2=yL@ zlTg!==GpZdE>Iue#g1bqztXUbTr}u+Rg`fno+{H@uKsKFUowEZ{oW5+t(=_GaZ6fU z;;^QaQ*%zB4!cZ|X3*X|41rv{gKMz&uCKyY!t&B+yW+4lD>t;%nim8O)ufh*nWw8p zu7htqy}Mp*i%MA{vXR65S7AsPSzh-h_ zJb@!0Ry_rBRH)?nVtqCP0SXZIwRas1Z6twJOUQaCuBS}!?Zc>+XnJ;Ig&*Th(ybz} z0$v6_^rUirm9BMFBMm7?N2%*q1sJa~tHz~QyThSXtHF3h;6?EABpc*#AYj|h+9 zpNQsgro&+!+IqbQ!T$gd%71*;Xb<<~EJx{H$~8-K^BD$Dy(4PSs3&^kwLfJOH;bzF zOYS_v+u*hL{I%7sqyGSMB5_)fd>avrzPTaK_hK0Sb=?hW1ArKQH5=&7rtVyemTrel-+w$Jrn{=IfbT8x5nGCK26%dbNchAcLoIH_=n z(MqN%Xul+K_MZvuhz&lcEB^qvD_Y;-j*A%^o<}45&DO0qh*eRfiv%y;9XP5J_{(H~ zjCp6?vuc{$?1IP5`>flx@NSD{yH*4_{_xE*_rv}k^2wgk3}cd`2lTFf>%|kY4=K1j zgP!$;HlcreJ37eAo~jK*s#A|cqLv32QS(ltUo$hsx@Dz|#Oczk*6r3d8Du|SO6TFW zSumMZJwdL%A4HzfS!9gmc??HW>0DK!-mzLAOM|Hx!;(_FMR+tz znM1miJ34^bCYT|0$RN6Bl_L~KJdjQbGb!pud)3i$l1aIM0lJRW#Zk0&r%^q1MFEAB zjDMzr?{$-d8!T+;ZI)Tvs1pP(M>gUVa)*q?i_X_ zwNzxs2kV*0raYCiNh(u6?aj!+I-X;9<`mC^&=%EbbJOP zgs9YTk<{30ki1@1!VKf7s<+m#-7$M`0rsp6)th_SZO_VhtG{!e-H7FZ;e0Tw5z7&` zD9iJD)N|dn!)1j-nqGt4SC1Tugw=rA7&RNOr6G~gMmesQKMmT+p&P?|i#Qqb^HV9P z?rTnz>R*vw$2d8qD@^1ZQ`Nm{jK*}Lq+yJ?SY26s$gHZNPxJW?9t#bFbA85RiU+)~&czINn`HsBb4Ti(0`zLlWqZ@K4wc_DEwCFi- zr0{sIi%#(B`GV=+_d}dk(~^qR^RU=i;v}6lw&ZPYo?=XRAaPahE{u|#-~c;T#o3PO zia@_A4ozW52KM}`1nzrPVeH?!5zN347=U|J@Wjl)P!^H93V~wSo2yet)DE3+v!@dR zHZd8&sh*1H-wNF7Mim*grhGr~4zn3}ESqTl`P+}qs_Q-r*R%-tUf9Ty_mO^O{Krc4 z&kFoZyS>$I>@JetIA4OwG0&}Uc&Ei*xp*x$Y&l2s7a-=Nnmo6;tmBDTg-z2|eQy5% zKllgFvBJ_}LXv$kRu(_At47E7jo1B=T6g+{kj(HyZ5&c(k^s$CwbN&wDP$m!qxX^? zgFU{r7jIU2KF%r~sAf%G_}#)%Pw0Im1C8cspQMh!f+?z8~(kfUUD?km$gDXeM!C(=iSyhVnL z0@imV;iLA=d51$w=SdLx7=xY&?M*ugtD3$g(LdoG)!xl+W4X3tx+$YM1b>ZVbU3EG zlFRqmpT8$GZpi1T>r-*qeKCd(MLRv{paCQx0$OCu<)+{0(F4Wq^{{Yu2U8Xu@fXDD9 z%`6u-n%$DkB9LNIBt`0{(!O&Vy@n!Ej?Z7b`>dN3<%W!wZf_dr1b5{}aPftqkp*x{wR5_bwRyMyCZrOr1YB?go=|pRW z#dS$@Bj@PejZ@hCH*p_|d^|MSTn$3e3dE%U0IrYI>MNbrY$Z(=`WKH9U}O>V06QAO z(XXbnmMe%PDJmSR1Jb=)PStdu7ec9g$!Dp7x6S?;KBBnk&z62`@jj0ihjYWX9bqkW z-Y@k>&zPl&wn`7ZdS{A06<^!QCDxj%@e`eZ{HOiX+vsc0?=)Rbz@N2PTt+{tZl z(C3VmkCAw4)MTWU((1KGQDbl~bYlbZ@SV}0Kz{K4wasceYeM2=<_A1Cq4YJ?d_S;z z{eI5gNb?)YJjElbj!kZOsWh8ydh*`J&?UHSuO2~Cd*F7i3Uxh`eXe~@D-9fdI7Zf= zE${ei>UmQ}u|65I^r!8PL4+7Jp|0s^X*Zv3yX?+*4b^?CCO0VH*L)_Vu8)(iLUbnS z)K+6%N;cElg1lr^r?Z*R%eNr%2=7%#9CxiObBGSpPEJ~rtvWu9NC^t&oFg1yj%i~m z8F%MyMse2_zpEyQ)=>>IHxn-<*^evl?^KZ{GTDafCfs_d&1u@fqrict7grMZRT~%c zJpPqJE2dQ*W90U!KGu?)1I;yLCv(vJ7vTLT$2ONyeWnWws87pmv6psU%vhhpisXD> z;B8OBw`APJ1Z4b51GaM+-@HeNiuU->m0yzheMSOX`71ZcH zJJ<9Ot804C0RI4%Gkoj%^!zBWkEaBtm(0&OuPM>KGFi+PJzB-#Zt}o)FXVZy?@aMV zi>s(MT9v$ve}KN${EaIC!u&$`e}?%Etk2pQOWgm9=@Wyjn^ZO#CliNfxC+H ze;@omiux(Fts*s!?E!hl zrVB<=&l$=eytSpG7=_I7s{G{xMo(g-5vz%qx%)W;df~L7r zw^D*R-hZ7%O&Lj9*z3Fpa3j==WboC~c-upQYfrUDfiM{u?_PhP-hGQwNeRHNp8Ld7 zOM0%~G;7cvl~byrPhCxLm^X>7%X==Y;^$e{9&$SRZWyZOy*e#xOw?_f-u~7mLO5VK z70o|{{@7)E2}S`WQIBfnh9)vz_J^g4$!pSoyZ4uo%F$1nDJ|w`q+PD31XHb`Yl)UL z9Gd9d@!GbGSf`Q``?o9fqt4zc6k(6wYNKZlnJ(k^ zR<#t8!ykoXR$US4;3%gqd3=kJjqD>F6V&=v)woM*VY`ISKCM|6$ID>k4XSzfscx>` zcl7K9V67B;(wm#|H73=3)ZD~`U%G;`*aeR`UnUld+kpY@v}9kX0I%*l)qk0DHoEh86W%Nmg-V#||^Q*~LKDAR9aus$likespG)2~XF$Hh}y zvqdP(ZQnJFZwEtXRi$5je>e=Gumr_I7pI_kUG2#fYGu zsQRq4Gxo4ip6JZ7xg}IF1!`ICP`RBlGr<*{k+r?SP&gd@N3CpI$YnqV4myKgHCQ-1 zqtvVJzG(F^Cy3h1xejA$nHniz*(uzoq4cYFP^(7DMsryiXyn-3cFj0TnR%PV`$+kt zI{M7pN=P3sW9?LBj2=50=r;+Gpp<9(rm?4l#Kjm8bH#R3oywQIxnyI@5Id2F2D$5q z8VQ*XPSw@iN0FZOlYa-97?6GCuTu?ETQlQxtPeC?qP1Utw>i#<$U~pt%lE=_jH(M}VNp7)(Y$nh}V_H&C_jfz8`ZTK5 z{rAJB}aiZqR>ra*{usQ9wZ zpmoi4jd3(OY9`_`DwdC;l_Gig#~>QHe8NZAKI)3(t2HSkkEP4-v%}GqN$B3l9Hp+7 z9UJ$L*0NCytN_V1t7&TYF@qwogntnnR+f)`yfgcsL0B5y^p{sk#yFu=7)aw73M%%itIvCLEyV6xMm%St zk3m=$4ZX5kB=b`SAKs;MZlN>N0qa>J2VwWoMbNzF5l> zjs|TpzD(OdgX5{+hywHB#Z$H2*&`^lov8)cx+uqO{DsD?s^U1gKn%K7yc!l z&r7#O2&ypCNTZ+%I-hcDmb%nnmVK5{yjCjNL}QZ2`^GfVwXBZJx^llgM|*bJe_hSV^%8ByPip7qn9nKTl^N!wnWT^^Cqv1p z77fX?ewBqdsA_j&s!qG)j>yjYKK#D}+r2s~eDRLF3eb+-bB^MyEw)O=6o=|hpsl^3 z#IOlFvVgS;nB5+y-IK!nb1wm}U0({{RR6Mi!@LmbTH%P?;uTOP_ASux=s% zd5SQ5*4C~4pv@dta7_S(NQos}asD-m?o4Db=C}4!jFUVn_}o2OQi5KZ430du<~a-7 z)Ya3F!B1gOT0&%z5l77I1$JH~@RT}Tj92!zODZ~z>z+Zbl(alHa+Fa;AQFmNN&reI zqJSZyidq0EX(?y`rJ{-eS}3A{3q~?AMJT2+mE2-AQlkW#fm}RJr-Rg1h0G>MvcJR0 ztgqtyYFN;{sX@;agkbwo(vZjJAX8hVC^U`Ifegk@JC2lXJd$~!aKfBu7}1f?R; zMUlSo01PkS1#N2UCX0B}+aQe{PnZXDUVq^jZtb;;O-Fx`3=)Sf-N$eTdhEUXaXDPwkrkX$Lj9qg$sT;OY+U7eO8!<>A9GqPtvh?ItT0NqsHXj#;|w;)4nA%vj|o!BMjcIgwGwjF`z$X# zDrrYlb=qHx^*bOCPR}3rSmaizd>Gi6wMP2-78YY^@I@gv#U zKZ(?!`gg8tQMs1UH%E-KV<)w1N-laFb=5o+WmfI4#L(498eDsb<%q>{GA74i=xWrr z_ZL_bIbff34lz}vB#QK?QgB+I8=7P3;^%lPSk=?643;kj;l3liGx~~x?kJ{Fa|RbY zI(izZ63ByknpGzRXOmqw(#MZ&Za~=wr8#=_#YotA_w;4p`_yNpNXNEtDpruPga@Zu zgLfIBPS)qWJAmRy9<;!F)38S?`BQrIq%y>J2cz}%t$iC;xzaT#uWY6<&l%6udK%~R z>r+Q3AzP-dN0Hqh&)rGTKI;8W_C7yDe+f^ zZUkRyx{GP%3zaOtk*`3|{w~^ILnW@U0J6Af*d@edn9E?}BdYWDuPbjFYL|9q&i>?H zLPh|&P|UvJx{9ETvUEA8ptU!x?6p4-U7Kw_*xb$($lC`v>Pa>ruIA9y^Fz45p`8CV9*Y6Pa_3nC7IK(pxzi3)^X6kn*b{6+cm$ zEqw}7acQC2m4v#6nGM~wsU|Rd#!<=VJl8U7sM7UYohsvpEE}pnDo3SiYFZYZ;s_1i zl*?~=243B`4fL)^Pm)}c`5wJ|I>b|0id*$wea;LqQ;>P9i+Q~QziO{>Z8faT4Dqyb zF9ldsc&()sEzdrcY0`Izt#5RQMonFZSvInnQOM(_Yn-DwteptAsozgGtxh(HE#1Ri zT}d-_W16|4?mDDOy;$P2YTlc3_B;5e#zMADZyhXobCZ*Dd$Z6r-3ZNNxTnpG=Dg-e z%rdetI}*_V_HpJT*@z@jHG#ho|&t6mm*lz2SH4+ zv}?O z`qP-_Cp8{={c56)dbJyN97q`YRM8F3)O4s2g_%n(;hvtgBwu^do7hyP?~<>taZ(OC z9Oj}NFsW2v=g`({?WL}SfQP~44D(ysKB?t6g_sSWaGv$gt6`5EQ@3qkM_#m|?9R8W zH9dz()Rs`Bu=f?RvW8+u1Fd;RjjKA#wnoM|uJXfDS%hOFC-ts~%IBMi!`bsh-1D&^ z8ODE|U$MH&jGDrhQP=68YLeP^5`ob7rrFNvb42TmnNjK~Qsk~ZYNfQ>qa4!9)R1Xh z;P!gimt~kdd9G_&wpj<6>DINDQ;tngy&%NP-jjDX!zWI99(}055yL9vjz9XonD$}*HE7{EX_G4j!>i!1N(i`Sr^d^ z7RFe9wIq^kOd;ve3Qss(LxMo`_BH3Y^1Gv^oOv}yVU&ZP;s^7m&Z6oP-57E{wOZpV zDaTRz(_oy3@3inmbfu-ywAIQ|jt+Vn&Tt7Td)Bqgdn8~7%G|AHOr$k-QfHfuh1W69 zTn2`APTAtCl1*u9v3=P`<5{DvdeE0NQ$IS!Q1&&Y4uVqVl#J6&Sl#_h~l($CK6n;fr3vW zsG62iWt}EFc`sC4eZktd_3OPQ?1jC(vMh=?an`v}m288Gb1`wr$*i0kmF{-Z#KxT` zPn9KME-BsnhQ`G8b@eSso zbY+@m3OH2<0Y|krS=OeTM01mM7M<^oup$=gZTuHD1q7 zo^u?mghIsaZ(Mb*h-uTbKtmZSI+5D5#8zJdXKqiH&VTI_S}lcZ)o@Zi)xV&49`9JQ zeL*IUWl^6ZGnO@t;uO(sbgNXbxRvjAgE#kU3ddc%)8z9lCzd7$?;{ad#x^}l_0x8f zv-4k}+G_fDh;FlL|}k%pTt%WS8`doG&rE8UQ&G4SLti$G2NYxd8+O)R?K{J`PFGh7^{iPh>Nw^ z0`S<)F5=x!8Kh%|$n8g7dsdb_-hPOBovn~-TG_;rhEdN-%0Naq>smHtqFw>Za4QPR z==JisIL}>;B#FGFD}osFj-sdXRh>}}-Z&Wbr`tm#!{tT+f37Oz1!8xC4YJL`nK8n8 z*CyxFSw(q>5nynO9Aoig)?%dKwkha%<`Vx zb``8Ni@RXbO>6#@Ap7z#SncD^GJOxAt>I1ELyEQ{F?yb5tV<*XC4`hjkgBrrh8*Ub zZ?EeL>PD-053ioz<5v7tr!+T3)Jf#XHv-2YoBP7KxTM14Jc{q2?HeQE^JvN9Whr$! z)$wM%6nPre_ptMgOQ&nv&atgo*vxkW%V5NEt^N+%k^BFILe1+CS+(*4o90Sue z)cCheQ>L4kE`C6AW6u?XrXYgkW-lzfNZ9(0zl}kyUrO^B1c%G+D}}m}#M&=JeJY`c zro=acjuYB@4Fs}|Eq6K+Wv7>*fE4Khtje+X)_ zL+7=W%^&+X{#|ObSPNHpr?+UO13M%HH|s=th1&GFlz+g@ddGovy)(v|Y4G2Pp^j^) zSN#^@xR9@)Zn+=IotD6zozFcQxSvjV6+~p=g8|4RpsWkYG@u>7U4enZG^)lnv7kaBQ38rRe!^6re00w8nK(E3(Q(h%gR zJ5O9!nFoCju*5~f-;YAmNE%=RW*vb(wZ>iATv*Q5 z_c1h5uT^1+^r+QUBj$WAW0zFH)M@J;jD=Z&$TdHcJ4NS+pUT~|zCK*~W}6+Q!`n%6 zkvl~h!!Q{G>s@3%bY23wi8xl+>_6aLYNb9~BN`Z2RZdS!CeB7c5Re-=9McCN)20|~ zckfJ7gI00~xh9<4sPz=n!Kn&-fq~DcplLQDzsdpa-i8434K;DxQ_?ne!j7jN)CghE z){q}VTYATaHC+iJmiFKG6DVlsjPH%J{?M$L*D@$0y%r0XEbLZYt#KnFu><89IPYED z9}FkebmMp7y-wRyiAGx9Pu)zO*gRJjj0z^xl?%u9{cB4})~~c{)Vi>_cx6-7PhY6- zR7pov&~G%$g9YuRw$l&!XF6;r=z1E+Xn-UT%HD>)h0wkr=sqvB8dr*KZR45#Q1UKg zbM^icT(6Hl6~2oL>bf55n+$G}20M&n)E?r72=YHI$K5%jYXS2o>snUgz+A@HD>#R% zq(p8$z@C-aSorfq(xX`HJRf6){{WVk4rF%sB#KrGo_B%YBAl$sa*|-ztXup`@a@wC z)jS_%<(>;ds&V)cTeg}n!rvDzEfs988~7GO6MjdEb_<>-9rFwa86KjnL#X|pWt!G` zAebM#go^cjQ{XymX>`3{g~meMrx^bLcvq3?dTZ%7@>_Y)Ok->bVmVg&8ZN^_q&_X1 zQ;lu)dmC*+JYY+=%bk70j=zp;ChGJ_D1mP7CA3WWVs^_Xur-KXk5)gOC=9XzpT>@6 z9H&OGO4gCgVrGPriy>YMcL3BXC5f_U$d9 z@i%}kG`I$(q{;oKq)0a;(G0Q=_JIC$N-A5Tsnwl7f!N^h9$WCD?oTslz-_oA@vM8B zM}y`cG<};DxN<=lr^6FnMdSj4X!2K#Zy((>DD*;<+jnO#N#3+IJ0-P|9xdKfgCH=$ zQ`}a4CI~4HY5)|-8QE%dwOH3RjgRNSBnPeD>dq(3zH*eIo37s#oX!f8cbX%pv=Dpovo>rgM> zKGiQ%p4HDI*QeA_eqmDyIpe2ltWP4Gq~jG08$xzurH z6RFySXRSOO1Db#mYE1N6O&Uge4><}}qhCW#W6nXSLCa8(r#(?2AU;P*nGQb3aKw6wZcjP-QXUu@%X83AmE98h;(*yWq*L;rS_sZ6PNv&R z#L-FRzVV!j>9pNcM&Xz4U=g0ixlG}(PAc83{#&Rg@%G1RwNl|z3(KlIn>&ogp!XGZoHTy*%<0!- zYW&$;ay=_@IfJM<9V)JQ6{xt#vJc7|wmB6__dZ!+j+H7(0~IHO&>F3F;KbPA8doL| zYDXcexLMmj#50QLWRwyxdK?gIcUT~yVbx7?w^D;}PenD&Q&Z`1`b8Ql+oSD~(x|(6 zP6%!fZ%RmJ`A1Me;-7Y*kV?JyKU(5(vpeGKR=9n@IQ|n=WG8mz=z9u~Ns@EW@I^qt z@;y3MkXF!gmtuKOn*eU>S=S>gx~|)}0g%;M&<)G^R2~>x!Oa-MX54IjHknLXIfuP9qeQ50iyKzGy@uIXDUpEOdk{MhvpXBxxF`_^-n{UaMt$BH6>IYIgCNQQ;d>U^yVKuf1_cA5G0gt^{DWa-9xoH%@CY(4#yt#b9{{{Y%2^CCeQ z_Ns-;F(;{}W{RY&tc+^Zm03BkqF5lPn*tcO6 zaGNVvm;j-YM?D5kbNCudyUVDWNMoN0I6FEuP>Nl@F&WKUwX>3EGPpZ?3gwpk(mm=4 zdo@aqi}Eub7oGP%090RQ1&9NR+`EBej|YY|oW){{WaN`tLT#-MY(@?cm%sOsM{cW* zI#h)~TpaH2MkJFVQ1<80Rj4hQ;cbcuA9;!CO}^w)rlhR|Q75(uBym-)7s?w+`OoQE zj>&Hx*vNPO_hDI6A?29ln$iyJ;>JgoHr@V3Om(M5yO=M2)Zm1ifmW@pkD3{IBay{# zCXzgg6lFQB2g7K^!ZFA6t%xnvRx)|d3I#SOi;&Na?0)F#YVd^G#pgcLJDfzI^!Kg` zlX7R*;c)P!8>BAZAc&45a5F5Ob}e^47SXhMwD@lhqo+e_C@wtt0g<`JO6LQma5{=4 zR&8n|W|`2mt@Y?DleM@u#iE)#h8!PC>B7Pf;yir!8;GEysc4<<&!RuId<&wN&bQ`D z+_#d%l7HYLv30*4cs}wW3)Zog|Xrue6dT&gJQrGJMN<~NWvrOPWR9gTE$@@o2E7w|=K6eou}2uB|M zs{Xg4CERh{+Q!WU@%f5+?Hvd|Ls&{Yj_YI6RaQEeEVP>ZPCglS9m1?Eo7*gMYNXba z+Do%(Wi;`+EM$&Ht!kamCU9_@-!KsYYmC?Q<4LTC#k`{_eTBDpOpaM<+&1l+a*H999OoZT5XiL5v3ES9@s^!43un1#(*O7gI=A?26dr-Q=N zlK7U7%;&-RNTxR&cNFf~rDQBg$2iS(v*uFKjTj@PCec9RoM;f-a(yaAZgGw)Tf;gm zULe-u(&W4rjW9l3g?A13;2*6?;tve!J{Q!Dj-wa^jK?Z+k`GX6*jF-fOdJv^*elkM z@N+;2=W4D#ZNrg{lq2AKgT)ylqv}bZ3wycap{eaIXS2GB=GsP%XqYlOoM9kO7y2-Fubx z?OsV|c|DEPcUF@;Gsbr$h;Tu#Y4A_Qn6A}q^`!|p7&0jNWcSCfs1)9)QIw%BXr2dk z14A!8I}uC`keCJ$=kMSEn{6LssMBK z72o(yOMOp7z0&R^*)or`TEC;OQTUJLUVDNoOGv(ZJC%`J8%}=;#=JS>q3C6Jg+{fd zvomd638cTB!d3(1-P{&ktGu0AxWu$hk=`9d<^M=lx$+Kgzp53NME5bo+a= zacM32C(O6IaH_*S0qk*BZu~uGdvSF7daaWq0wZ!7C(lBzGm6GetEI}>>C>KF9A`RB zS^U1^i=CmmhX8F^bDw6<1XeVVNZAAvAmG*Nrmft5me89tfF&1Bx% zNxCKsM7u}?AHF?4wdbqHL+mdKiRxELXQ`&EWf<_>TV^Ql(f%(Qt) zEEDB__B{{Mv`@LsC|UcV9m=p(a&W(N`c>I)?e8r`zNK#+)Jia}!w$bgSdAMY$8TDR zq;R`QJ!!>jbj4D%TzP87=GK?4TIh0wg3b{U>XNST`Sq>Y=F)YG3#(|X{>gDYy9Ee; zb)KN(w@Toy*K-4&n5+68spZHako?2$=C${grj8D3RVOSxMar78wx2G?FC;CnzxPho z9n{r}QEfb4M5+<{IPY4Qx+5jj(%aldyMbknQ;p-e&q~6$hD&*hyloo}sKW$TpqiX+ zkBq5CrV^`-NdExA3!8SgeXYpseQ6>)lLn>pyy&(+By=>$Q}>uB1J;(d)Rd#ocx=d+ zV1xJ?l_VuLjD0EhF(gm&$gUfy6Lk9>--ouC zWC8xqr6#4L={K>qp`cuCLGwvvDf#2|+v+Qq1Rt0hnj40KXy%WGL!Yf(%A ze(M^TNH=3V)oBXFeel^Ii!=xOUFe!i3l=)8BM*xO&OsiQi+m3^5a+y4M8+xU?BeJhUy9`)AfZw=+G z?w5Hgq!LDCMq|P{^fky!8Amwv!TQj_56P!2jHD1qBCGCUOT5y!>~>xq_=B!!QmQT6 z&uP)^=3>f07^Jn2{t~@v;?Sx?HPUal0d}a7M+!Xy43DlWkKOERX3qJbYdNANZXs>R z%k9#dVzEZ+O}MtWF+6Op8wFfosrRU^E#|eK%8+G~xanT^Z*Sr6iFOHdB8xp?PzI53 z8NJBEi(f7L7S>Ydu8oz}k^5Bq9 zXiv{=DaxOxp{{o7!R?tPNfhqoanXmhQ<6q!W-Es71se}@+~H3G{6t;QIMOwC9H$Go z{W>@Eu2)|8Z?5Q4wCNDKfPc$aMsPjHQC@Ey!z%(Z2;>peSE2Y@;>N3^#9?kwVTvj=WOpc~0z;y@iy7a0;OSinbjwB)y*&BiRMS9iuioP58jxhJ@b!#d6 z!|dyy%|&xp(EKli7Pr)O*$?+(jena{Y!T<9NS!WxtA0mO^_ z2<|IAzU6HhCa#Vel;uuNGgfGUskGzIG};Lr+Mf^Jre>cJ=B9faVg58uKJ`4D3W-n6 zN=|DAk4iGN#m{PyNZpcn6$+fTY2f_Snj9t6bGOU&G@Z$&Ipk7@m z&0oSpF)_I$_oOeJHhJkwbVCw*lT{VYFnd<9jn&S7Yi3$ZB%_`UEyxT5flMv(D|eyW zC`U?NZfx3dXwGqo2&^m7w&|;WZXU4p0sfI*jveZJes>SuC)t%lVzo5wcIQrP$AT*@ zMoubUvpzC8uGHGt`FC!oQ~v-7-R|6ZYgxD6C%wHwu0T`Tu?n)B5lNbEau+Heyt8EY zt9I_E3Qj7HD9Ih_QyWKWx-GTFpS%?;M{4A5?V8qhL(m=#O>3%L+VHX+zJ{if@;krv zgXXOtERhK~vrogi)7e`X;g`ykHbKoh#U3D=ScVwxoJ%Z6hdpsvucwDy@V7pdPDtd8 z{OW6!;gYHC4_o_Ma>D&t#df%ql`XBU&FsP}TX|=Y{{RGNSpJn}>qgZqS9RWU0BwQM^2<>x-+b>yq3=CW>d%a2p=A1>MB6IP)7IbRC6oEE985mqY5R@eL^9i3t z6XZ=DBSF;l*~~h1t4z!Hj{#TePXe^0@SN6-w(jZ;`N57B^AF}YuTl7UYolr&7?VNV zZFL63qGdnpy^r$zs`i_rL#O?+HG}V~`o-Lp zwA+5S?0Ir%vROi}_I8LjM|I@XZ4n1&T-QabTu*y&%{ABBB+tu^nD!NpVwZ6WrKI#6 z*C#WRKAmBy(x#MEmywq;0D5B;8WSK00WF@GtM6d(vwfk!KivoBt!)#-_jjMYiUtTW za7RCh>?>RQz0WmLa;@1EH0?4;WDPG0r|#D2^59UM7CZnd=&_ks1!IL&;JdI2KN_{6 zXw9n2aF)^}Lpe*ymkM#$Xf?~pI+8u#X+sA|yPW0hKW8o3ROBbu-m%i(&66jb z@w9c#bb8N+uKYQ7O~}Q%OrrJZUkT)bg5Eo-c+Ln%8cn@>Z7ezj@hJc z7moF~bo?gyr1`VRAIg~|sTzoqKQX$1r;o<9jGoBhtwI;PjJ2^clJA5;+n}p(1i(n6 zB(EEY;C(56%X2)NrB?P(rxmMfrd&K>L~<@VVGTLSiw#OC-77E0{sA4Gj&sIbg3QOY zSVf8$B)+*(oCJY$%X^CHG>-=AcPxyyrK0{fl@nOnK_5X}5Z30imUyBD zJ87GLlNj8CJ%)Q%I5`z6+`kA&7~p27LZaGwI~K36C73%Rgcv#F1lCTUBr7bfI)dAN zO!UoPxpYfMP}`mR);y?VkdIIeDIxP(S9+QVVk0r1s6DCW)TjXGHJlD{in5~-z{U{zUf)ShW2 z%Y8Q>rkZsn0vc*~;RQiG>Kd9U_AUs`Oq1wqNySUvB9%5iDU|nO>`A86L`v7t-?>yp zU`2CskY#Li&0f9K{?I;N^_yInN>YSxBk4Gc9Y(z4PL{UnI)Oz1^IeC`op*-xh+GM# z8=JOks+JgIi?V<^R}H7@2G$S({1l(4d?yELJn(ZZ&q z8=IG!s-#6D>T928W^%;yNJ%G}E3SM9cDaD4_V zLE{f9sqe*ST}R~1V$N`C+C22g$irjSo!W*OjaYpRCr~L2k|`b;R%o4((1uo1f)A~F zhL_@-FC1wrpm>X9cf*T&uA7^;(Ek8B^1=5=rBmD-5#E}1C99hn&W&}U>M~f~p#^zX z9T;{ZvYBvppTfIsKV7u(MwFT+y(-6d7{#6Yc0HBPr@eAF){|J>OKEb2C5f;{zo_=6 z!4(On8L6a{mClKZU>AAB}4G%SY0@Nn|`hqNul(n{C~p9LFXz+p}|n z(AOnnZKB^mu}^a?jn*;dFy9lO<|_177y3Ml9mnr%E=QD?P(D->_fAJ(alxl+lAWH1 zBG9s&V4PDFGO@rsR`uF`{{VZ%<;l3DiH?pqH3XK1J5w|L=jba5OO@H4wHzn5kF<$W zD6%(3_&vi_%R9UK89d8-iDDzEM>zaPdd*20Gmb~SUeoXX%XtmRMPn0&*ux=*aD9zz ztj{goGr!Zkewv-Q)BHsm?qw0je;WM2dN-)6+J>ICk*xIJ)5>ucW@8zkb74@;iP?|bdY{V^gl}T8k8NReWWVVuN68@=((tAw(?so z<%_FA-+DgkYn+lD#EkMQUd~CEbaBb$y9_eth7|?mK2+%Zayj;*GP5ppxuJKdh{JJp zKD}z3kg`7YBoW9WwJzcaW>E(M(wF|9|o@KyDlJEhxL!b#S^fiUsHPyNE@{6Z89>be!@(vHBFcXibN-@O&OL74qQcA*<`L`S! zY1}$@6)L!HoYX4793GW2vVp+>Q$}QR0vJ=3_Y8Lwl91pKbBd2R=7EPdsDXqifk;Q*tpKq$MmKK&6j|@Q-2c6Z=v2a zY%&<8(0@9XW{1o~C=xFz6iqp4nT_4KO2oj3)D(!JWt;x~kRQML~f=?QH+a4ryZ{{Vpu z5m5Mx;Y>HyEvWcv<~#U^+!JsTehfH2h|LxYo;zc!Usy=3Z!-c8N3r&=N3-~i;(L8L zt@Vu{-q^^vBJSO=N7ohSvk9y(3~U-HqHa~!42&zi(f%^{hQ=j>P!Q@6jtHH8Y<)!l z(aqdm>0fFOYijFfBLyF(MaS}m$%v*-pKYkF}JmNuu+R z!7a3{6wy3#DZy7#2>cBU5g8vUkbYy@t=rrfNC5D9gH=M3tU&43kTCV)rNv2En$oK} zQ&WSpM@bH|8MJE~^z&@wAniR={{VSUV^|lE8+nRyP>smP_>}ZCu}))<9@VnsYWi|S z7k$JZ>XCRXr>Oe(0-~K23-Y}VtY$h`q@75vW!L=9Z#5a~T0+Jd1{PLU?i;bF8f%m7}T4mWSKfQ%tvaIaK%S|zfkWaltk=IJ4)rnB>Ds^mP zs;gnRs|vuU(zB8~XiuRsoQ z$GH`(QRmf`rI_FML>|VJx5?J4MEyRr_il08la8jbt#~F!H!WD2hx+>3ex|Xt5B2re zhxm^JI@XJRWln~yMRHez(yLKjw?0g~&m61JW~s;kZYeTHN%JTDSBA7*HI^H7wUI^@VoqP&p7nfq=G#<90aI^6 zlJ^zji*S19nzIGr0EIQjFKKPhr=w2>>M7Vn7WSfYd8XW0G(?aou}LHnWC9PR zX~iR5E(B~((y4OWQ7Fy3MO?^FldVG`%Np5}MZB4_99a6CRFHUH;zRrC0*^)H))TEw zX>-1gSBt3hrv7?N`oyUn#oRY7Scnqa7Z;8go97e+{l zyVjysE%POp%*XMsQ`Rg7v!q>FGHqFquOpCq5nd^O;6D;s%F(5pOpDRu*-WA3yVuA4YjHhF+VhndJ0_AYS*z&of=;IP1~!~yKmxG zg600v95bqsu_aPhJ-DY_YZv;Y-hB76632jtXi?|@;16o!-N`#wr+T+%bkL^O&If-= ziPL<#5roWPDz>Vx=6XkoQhU*+Z@9RU#h^xxBL4s=BahCr{@NmDg>9K*AOV%#lUqI! z)imvIN*Xq$Ac{mex0g7_wQipU>PdxLs3nj1TR1qZrwPyATArO6_ zT4+)@fXG|`&H29V_8zs+>ed=|ijl#4zfshrd_!jhg}*;RT<^pU zD*nSpw7b?WP+r|WBD09%J9vQT2d}BEXyGL-WwGaGS^YXol8&rGn4c+*;+%6{gku=1Bz$#DMQV=olV`QJ#*H0E z?zATM&f19lZnp>I(7+$>3h|2QydUA{JWZ^9f_vd;N)|@joyX8sXk~ZY^?g6%E`fiW zZC6f~-Z?lfzcT(HR)z0}G|Rm_>fRQ&vA#wb^4W>U`?&AyYly%2F{ng^tTiZSBce#9 z3H*7ke%3!1{65qL(%alys6ReFXrvza;-XaJG<0F{RVX{b{JWh+{hU`2&;6+L>DMtY z$^=KtlpcU%y?K7I5L=IwmyBcvuS3&3PcMq~>y_1SB)5j_ZHo*x#UbDm{>ZFP66hBi zJ>%)u>I~{Pq>0MNhocJR<#gT8f7;W=Qgqa{-~Jf$<#QAMm2F*0j1h{C^4!BI0DQGj z@m(rcS3Y*FH%?A6G{;I@163fn*fzI5l`%3g>9l**8H(957sTNLzOB z@7o=zmuzM+;ADZ?h6E_MT=&Nnb_D(8ag)OQ#;GVgXQ@3ZSj2e3IY1pB%p%l>p6qO^2 zW+)}AF({?Q6cSYemWn7Cw3JayL(z)V=_OXB1d7UZl#fFTkDVWN>|O*BL0r{%rRNoH zF}T+(qTtV>p@@bi8W*&`58dkSL>L(EX_}vgwM{IOHM11{@{Ee?ya#&(HwFm^R&JTE zQWj9%N43#iPpGcgHOh~i#?o=EB-M|Z3a~gJgY=`HO8P!e1ZkH9v9*sU{hG(sya%Si zZqf)9a6Ky1M<26ifLw;y88eYoWp*+KAZ{y)^eOZ^7rT@O0Y-SP6H|ymsml=is@N5W zwv49Wj_TQMd_4%)n$ksBn;VeyG<2pO9Q|rm`G9r&MOnll7-A_p8Z(>_XeNOU%}+Jl z*9#b#%b3?{vvtQ|nyx$u(2OW(A4%nd51A~s@m*2Gl9F2p6 zQgsypsTH%=tpHCG=jA;`ZD_j8`bF$hCLRF8&4KwxUilS)(ByTg;*)n3NrBw_K!V!C zSZkYL8rxD>?;s*R#D2z>k`Xt5pJqi4hDVtS1|;o z35d28{cAeVzNqvt7{6rQH?t!OBf-#( z=1&W1g5KqeX}1gntN#Ez&-aJ*uXxn-{WHW?3mxP!+(6@Wat@fGhOB0i4^fo_FMVB(E%#aJ{CkH z_EVZDYzOrxv%s~6ddm8Ga zMs7DeT*EZO!nd-NU$1YGti9fX!{${6ztj#Jnk;*NpTq7KuVlrSSAq9B4n7&L$oIH?(B9ItGHO^v^J<2`CE z#16EmaVY$$+$>q#bHzWNw8-}D=c%RSeJO}=Vmge9=zKHc{a3@6OC^QVgwM?jAC;?| z%^~BZFtO>rEVC zq19tVxJ!sYRGD{_2ktj<`TmqJL}9V?tsOI4zS5^ztnOurf&K;}vXS=+aX6qywRm6S z9nfg)^=SUmhl3(;az5;y%qdDd%G(;zsHx3Or0vn{Y`2Faw{>exLE@G(#^cJLsN_|< z-Fo8QB)0Khn{BIDH_Eq*{oP(01CNbAiKA1HdX4Pi}s!)wok{i zemwitsASS?nP!&q=Jf#tTdaOw?`CYA52a#71hW>{rwjL(@E7W7q!PhEEPG;$g^ev= zP>)n(y8A3psLFY8j073rbIIemtmT=bBg+AOz~}R;$qe?|eZi50TfhP)UzxeiN1zp+ zbB;|H2Ntwqv&eAen2)bYQ5!n5j0Nsk;-eBW9uE{u?I0OE3YL>9GI4qf%C-o>6!36p zl$O|ffPe#vW@{-cGp?OWtB*9Jsip%;O(RtLlW=+Vrjy>0TO3j`>q^DBXgi_nO(&kc z=-tI4p0pC(^dwWoD;_C;^G@wb#*vlPg#__aA;{;_tBm5LQ^ib?y&2h)XQ#DHjkSeA zntGqRgITn8)0LSi;FC{Q%Jrn+@#-otNH{ecoj2rnTQY3Z(Xeya)C$I>Mj6LymW}Dk z_AW&E;Pn+N5XyZ;RarWAIO|dgK3vy4qp9lBs=0Ys(%1(bdei*SKyHT>UPkUIkx7h> z)u%1h&SzVee5I}9aRX{ERX^%RA_oe2tc3jv7(9SFq^cn2M-IN0qO^`&Bb zydJeJYIH_-jmR9G;C85sVEY3~=jN!G@J4HRqs*;6SgP1_^{Lsjf-0DAoK)qwz^5qc zXG*WS(C0kXMd;l*$E9kq&1KBM+_r0MI`@w^IG^r*Wi!PUB%lW3t!dg+`iq^ISjXOT z&{tHNin~5~l_}Peg*A4{G*@G7qiI&y6U5gCxhEBi;u{-FOWbDZNm0>i2 zj&iG!Te@e%-xAFtymnH?J$MyjUl?l6Tm3A?81zB6`BixQSFA+gmhxUYe8#2Xo7o$z zj*K;OzxCx~r5_Hp^-nSM)n@+ycoJ%z#(}BX9kOY+Nsggotz8G=wxee29p+|E`L9#a zylbQD5h?SdjnD8sXYN#f^J)2=UegnVjp@@)J>&YGC~fW$LHiWo`js^+Y5J_P2-Yak zh|XKEuYWfhb6~%blhYtm!PCzHZT|rA+NFk%b17$)TKF3Ny$=Po@Q$IXFlV>Am=3`< zr{Ya^+7H9YS%d1bM;s#?ZR2c{^)=|iJ5=E!j~;`iMK9RUZjuyL_dF9@!jxip^|Kna zZkCt(!rHzbu^BvQgs+U?!3&yvGGopYL&hkbKuPPyVY zl~~|I5{T6MamlA?dOSKkt4F6nIrA~O*^lX(l_z^x=~SSh&CRc-pL;nk6=}MjpB&nZ zR&hofE2cuVe8A-kqn$qgcNv?aErk^GM%? zb9Wkz&a1L5H$a9s*Y3-9OCS5>P^ij!qe$B)~J{|F&_8FS+#rBK&32!mZPq#gVWNV%wzt^NmukIRG1mGTv z^sG4N^4DW8Ip&_yBPa-ST^!n2@*2ClGzOg$`F>UWA=yhhw*d#%t4AnyC{H7}?^Ngq zX#{l?HVGO9MmVW0t|qj&j(8l$EN61CJcCfIs>%;ac0uV(51_mU<9K{YWVY8Xsi?#- z%6Q&AMRro6NgE`H9S;RqWE%NK(&~FFnC>m5Xr_$iT}}wEXz*Xe*fmiepRBS$dC?~5 zvVVc4U@<--_$Dng8rGE=jve2=jX2nQF!ZcH4(l3zv39n8C%KVAuGpqO!}K}edsnt< z32$?0HMHeSQXy6Z_BHcXv1XPUl-BMrlZM z+_SddEH(fqsji<#hC4k9`&E`eZW)y=kfV;$v#l;zowWEp*0GN) zQaP(s_LU_*?Xj4nnsp^I6B=nL#+yLIqLzvTRHBM008-LXKnq0_P%%f|2DI%4aanb% zV!@Lg>zfk2+n(-2CGDJ9eG9_kNZ6|mgjZ|f{{SD&WELCXT}J`MabWR-Na>!H!wT|) zvGw@8wvHwjYg67d-x_I`NH)x%p2XFE6zi}_q)p_=rHY(j*N7mIFjSCzsz=l=f)r^O zuc0;D3f#xb;&S?UXL~=m!2Z^rJBdV$bGX)3N3X93N`2v2G{a$7m;v(j1PX@uee*RXJQ9qO>@guz-%#zVy~n)KIz3I@1v2 zLmYudayX=*1a6?yzLbZhASRFtj^py8jDymSzgl2Qjk|-^my~RZhd#9NA;u3h0k3PQ z#x$GDDTx7!&j}r*UNQKoKai~1IRUfYpl0YrJT_2MxPn8=u| z3jpq1)vZ4EeLDIJ%V#SzE*%K<6-GA0W7ekWK#!?(9cCSSM7GpnBNC=a{_A%iomTNS zjUR}#D~lE(Wybhl`>r|~^3R1nCl(rm=+`o03!}OcPYWlf<6RfTj}}Q{@o3f)G;_+n zWbTKRPQ&r5Op6yhHFs;`FAUCa{G+T|{^Dlb729t^p8k~+X|g(l3x8=_sM^p-aXcsK z-yXH+-V>G+;$@0)@>~y;XZXh>{41#O&X~Gw&90*q_e&M%3j?E(HT#19)IIItC_XtTaK`(MdzKpv+r5fH*?uf9nGxI6sUJAp}_{Azw>_7 z=6&8~dEM5ciT2Z^trU(-bk$1ol2+9AT^q-GKa4En(fnr$t-u>$)DU5T_dUOrVfe4W zT8D>N-NHrQp8Uso2+tqwV!ZbtjEe2N9q}Ij0K=qNUVo-(Z^OeUJ4d!_T^@|(gyjc# zvzwAW7e6a?57^dK^hIQBcw&vAtBI~npQa*%LIjtTy zJ3-^OaZ#ZpVSx-iYU3o%N|dDy&5PvISwz-xlnv4sY_j97Po-5u6K-d>;111-svL^$ zd>7*@O+Hw(?Q+WA^Gsua(nJ}c&v1P`MONlV8eq1R6BMNh=pX!P1+2D`g4X6%1QpLH ze=fD{o-_DwXQ*kv+TI$9FyS}-nlbWBy>h;Wym_aQZVKCpEu~%>Joo%)vI3RGth-uy zetpL*%6b#)RXnCv{$BOJ7Nd0Gfe^^}=gg0v&Z^GqxFptsAbRXPeL$hb0%lI$s@xxX zPJ~tOvMa}u;IC!}k@Xb>_U{kg#t%X})HvHx)RR_VkH!yLlR2u?qDB-5v6>A=B^~&s z+z&&=F%Ltvvr~B{<{6n+?%;~m@Xm{GtVw{TJy*R#B&gyw?Dy2Vb2sWAIs@qLl2(1p~Z=1NTqsD#$y726V_SR_c^vMtU z_&ErD76P=ZfMNDRl`3IaKqH zL+f6TuJ}U#09}eLPCYZvSQbHegTI}@ihv}@qqHSAD z)Rj~!PY3$YJq~*QHKpR?t60V*)b#eXn{Ls2Zg)i|vk}wruPmFy7qLpSDT;OP=0*b{ z^xU{Vty<-^(=&Y6vqyEP{3o8+k!Y6F0nkhtbNN;k&xJK@HCuL(Y(PKq!}p(~9Mn30 z#EnwWfG)0LUqJq1{!P#8T^wH)FQt!V!)fQgu34p%C~8R4TBV^ zuzO$%vh!VeTW#+&*nj|eiZIRWIL&q!UMA6Xr5|e1tyS@j(O!lB0MM(IzLv(?;Q1&O zN#R(lbcnpY-M zvb!Cg^z7E}_5>QOo80JAG_pp!rm>eEYWuJE$Lm-esVcyNI3V=~l%mme>M3kJP7l_k z=zXdXeJW6Lm76-C$0m=Vw6StY68 zIjKYg@lRPWPob*&uxJf~nx`9?LbHo4tKi_&oBDH9_xH^`W#bvF+zz^Un`lh!#&go6 zSHpW!Gi7s{X75UAXiZAK^~*tq4K6{>YO=W)J-gGDhjYQD%4n-xw2jmnkg(aF`Kqe? zgZNX6jQ!RO_`{Oiy(--K6}@x^hj>XzDag~r5S?~i`Mop>oV z&9OOdCU|(w(q8+rPS^E3?KL}@W#o(=!lKmO+2dvh1aM7z8hkMDZH5|6Zt`hI@gjgL zFHrbvqhCx8o#Ft^&+hKVIrhawJ(8W%M@4Dlt6|({89Tk~c~zv+T9=(1q1sR|>(8Zk zKMt;Rtz*S@b~?R+Pb(=%COqM~<$>!|wNHnd-kgP|vU#Cg?UDxEfO_C_So(B_!@9M$ zp#;osZQpQ0gb&ubUyO3>z=zK?|Np-0f(%?ckjRN`k>T`_#RoiK{*3E2}HZcexk#dYv3`egu zl%k}2H1SUixs~6~PssVoZ8KR`G2H2I8xHRt(^;C9i+f~|z1pm8FDSddY<(-}&3f-j z@co6w_m;EXD&#bWaV=gUdnEe3^ItkNlgLRq91me!^*L$nx#{6$Qy842tsl(eE-fAg z3c!*^dR25S49d%p>OmgHyGDWsyM_y?6=jfxAMA=x9NB0(bav2b()pJle)WN;2IRFl z@pNHIYn7g#;XjD_MyaDi7Nc^u*Rdd14saVC#ZRdGNATvHr^=j9Ct(=PeC!F&2a101 zqnfKTo<7aC+Wb#M@h`;fOIMAcwf_J_w;+SG{KS20f;UIzIV7Iusx*Z6q%DETrOAEG zKD3~%Pee>zo04b}u$2^+7YkKjVi3lFXv4oWMmlYDFbai3# z9!Ya1dajT0E^AFaY_4tLxrs&rkaJdJ_=Om6-B{WuJP{vC@igHnl@oP&c{%8a@* zx}G}?Cfla2_dVZA_<+-$mrz9Ne~Lepir9Y`S=*|FyN7Z98>Ay2@F8D5+G;XH!{#80 z*==cVAo8c=c0QE~t!jF1bu1PG6Yode@;$|TLveQ*`zQ8$oN>0}sr;%bHO+3`0rr?I zt-;_s+!oK!0bUOVtu2fElCV;EHGY2--CczeOjxMG=Ct?eyda2iy z7(3nun>@5pfsdwhQ(o(7dt@TF*KX{kVa&>?=O2$x!n|^Aa#c__bKas&X~7J~f$vH+ zs;6{sTQ9&k@=2Y2w}?C`quj|im2-b|Tj#jBId?x^)oOo>YZC3#bePl8isaWx;XjA^ zBsx8<=Ame}H zE19~~uddv+&CJeE_t@9d-`Un3KF0_B@G3Xa^tlEe!r8vDikptd%Pvcfwbp4`bRI9$ z1Ze(Vw`Q1D{{WuJ@9rzwu6!5ayTvOmlW)&;U8H_h;l3%;4}?5pEE;s~sJzD6etd^ zb?w6fyGSw~l}_?R7Rw&}&c`OH8HoG6Y8RN3oaFk^agUMAV5noyQB&L~jbbV|b>^x> zhG|tf%E`B9$3RUP*qxfkDFWH z+{}BLsi|sLTD{v{T(`0y=%dh8xEFL#TMxYCarm0n>*R7MHqz?D7*S0%rFCRt?OCia zY9Tcxbadjdv%}ApLQ#q+%~8xD6w^;8n?MbsiYNl56j4ZFMHEmWXrhV$DrSsZCA~RBc6ejym&Jk;4k-0VAQsPZiXWp1BppJRSZPeO42RoNTK^>0;V= zH0Oa>bgY|wMOy*5HK`oI#zC(-tvS+X*5NTYY-}$JGdESRXS07OWwFw^J&haTfm7&f z(6TDD`hBg>`pA^~*7$s9BDB%uX52inQdKC*&$mN{QbEN%UPpa_h{)o)Jxf7>EZ%Ey zL!izpnO)-&VC~KUuR@&RRdYo7EN&YUftsUL{oRPbBoKOvKyY*EQp*{NOylK#L8y-v zqIXB1QVtSvV~^8=NCq3NAS40lPB`P!*V3rWMjaS+9cb#ihH>jaJ8}(Z=~s5va!QwW z{(Yp$wUi!I_F?Zr)rsh5b)_mc`xS{yBNbKvG=MO^r5Q))Irvc z^rQpG{HYBghJ9&&8cb490`)kj_B9@HPaP-$%EuJe>z~e*bI{OwQxKW-sgd*7twE0B zfY|Fm7ZOHCS4JwzatP`TT)5P(Z}n%ryOhZ^gl=Qsj8oEsI3v^?*R^YK$KtO6Us}dNni!V$+>W3gc>HoJ$j+Z&JU9KK`kX@KzSOkFTOG;t zr;itEx^<43_A7%JfgUEu@r?b}^%ymMH8a({4r=a6Cfh8JxsOv-l;G5oF>=SINjUVV zma;c;a@CV8n_JqYKBB8|deww*!-{BwsqjCFZ#*}xM$pU_2@WKU&&uE7Ui&q!jpIEz zUSw8$aO=d8pRIhfYkNlVj;o=n{gz|7e(7RQ9*5LZxE`0{F9O=z$K`4*<*POz)Z<(M z=(3ONUU#neM^Mr3nmO&7WE_cM8k}IwIK}%{_j0%T2j>B6=zLy+fK)k-CH%Rfl11+%D1Th02+uKSEFk(cvo7I z;&?BT66=1lG|ZapdauHN9(|Tn@cySS?p)&9 zM*b81(tnk8-aPniY2qN))*EegGBO-+vi|_R@9$qas}*3%O0YQucCTdc55(he@M${y z`&eONxjheH8~kdK4D!qSOYI|3dt3M(8<>t5Fzfyzy1x#1a?@C~ZD&xtSajQG*vdg- z2^ksouT}BCge^Q%WOo4->|-|f7~#E%?kmQ$eM;xTTD8`hs#=*XB_37PyMGe)BiwZc zt6<#grPBN*ZDV(J_NcB_7>fvyfW-FgURiJhlFFe}oP`~QdQXht@a?aH>=RA1c6MyR ze1~$#x%rjPVmRQ}n-iWXOHhu5HU&;Qded{oTriTkILE1`eU*5_5>H`Sq|If^(UpKL z(wuNQbRVr)lFgthCJ!EaI^g1~y5dcvIPIEEG$pCmXj6TUPXRC_KQT3V^${ey%Y4VE zt};96Vi*VLYEQPi0oaQ3=Z12VlRnc8ozbI4G~%{Lpy@s$dnx?3ZT9jIvc}x2DeJ+m z8^lX#9=&*$G5J=)Pn9#AeJHlNc79DJtr3;Q;`6(S2ch-+YfL;{IdZbLa&0Dxu#oR0LM(l8~r0Y)ph`C&=LbXqR2abpy31dNQI-8imwRI%yDda)ZAPX~&| zv=rlJdRbm7SZciS+h%)jhQ1^<#3sj83p_Fnj3gPz_w}wn$9@!tPI)z5ALg)-=14*R z09Bv;m-$yA4a-Ez>T9{t^?`e*n`w^qAgNR7>0BK3C^Yv+(#r#e%pmy}EdKxxU-LLC zs}CyHJID{2Z6^edvA6eI(y0SmH*j6(SF)gt8)=CEH!C9g8l^S5NFHktSqCi%<&*qJ zy?V*1E@XU6;VN@*n$>7Vl0>%68H+NO1U`BSOy;YJSFcK%0xl+4k&#)B0e0FyGeC(W zlgn%$x_Z>cJ~F2u^s9~G%}qcn98!bOMKZBJhH8Y6-dMRwpq3%rI+0GzZY!s-qbhj^ z6=EIN4z{Jwmnp_G(E5s45pH8+4b*B!RFq(vsKMgIojTxy#%Qoy==A>p>{|&--oV#v z;~rWz#2Dk8b*U!Pyf3IoMY~+-?%g*xn4jZZiII?i**WA?>TUvgixitZLY!A5p;Gru z_bArFawyIT{$`c;gmnve{OfI(u>Syl1Cx)ZTEkej&9YL_5!WM;_*Tu1w>7kYq^yV3 zR`TCiYRVThg1oT+SZIk|2YmvdTNM?4a= zQlZMaoDp7wZ3c_+4$sPYA=5lii}E@7V!g*>=-=m>^FV4?<|x4WQhK4L)4C_Tw7Ju- zWwg76p}2*Lx-h{6Qx&UL>i&ItIR4i;n&Kr2vdPSwM?g>U53eQPg=>r zosh&uD~!%*Rq$zWk`k(g9CR7ZY9W%_LXz3W0Opf}MzF6LYKtoPrxV39$T9OXtY7S& zTk;gXY)it%&V5|qenOYCY}Ml-6=uX^^6^Lx;s$A4nP6>+8oqlTK=i7BF+w>Q>J3t* z+`@R(_ECNth+&ahMDv1>O5=m=UWuh^b~?77HMW~;VHAuqY~COy_t@PZ>A|lo+6S#T z2Ug0l1ab~}6|^l4k-=7TsP86j>Nfscys<>-9__A-Fj2h-?ODOP;Fh^;!m_DJd{I3NHZ|LltJ|quH%f4BG3iY) z%7c_)_)~Dhlk$&x$JxuV-SwCyt0mvi=A2~7AbM0mp&2FjA8rK=I}8Y$Dtn^htx)b^ zJk2d2t`cs^B~Ct-7U6?h9#WNGHuYmC?+wMO)N^R|BQV=bdvH25qiO^6>T3OuW^?}l zXkP82g{GHxcBRrikq)v*cCB5G*2384SSibeX$&^;cKJqXt6$rq?h{JS>@X_|d1R6Ivlc$} z8%X41HK#R>TQ{pWS6{qd67p2`4P6bEw|ej?lIXY8*PmdXYE-zMF@Pi@YRX@X#OJ<-W~A)(Hv!0G5$}8oaPxzHyUN#i`sxeo0&Nqmrz4 zVs-E}TXKT?k9g8`9T4dj*5Ye;1PT#SbO)zO($k~VBf66Ad+GHEn~36tm19BdGhaPE zrzFG|W06-ayicgvVB22J5FM4PqBW=Xk-=XDhiUsM>Div?s@uVS>*r}VQn2Va1Nqk_ zszq(2q>p&bCPlndQ}-DcR6M(eN7{=b|ljY#cLSZ9z}ZYa&My)Ia+vP)em}- zF;vmd3AXGwoxN(*8g$nx83AncRT(tfS)zhM^1`x?%EyY|w(+g)ghD$TYg=$Ts$~9k zafeoAQogoDNc=6T%%jNDE}Wj_F;*k+ABko-T_RDRTnc;m{{X~pc+?qx-2#aGf8to! z71ZSXYWZSwxyhCX!w(e^pX|o}0KSDWz8ZL?IsVF*@FKbmBjX2%Vv%B=-YeYkfVgA% zSFLDXAiCBqR$279?8zM@BA+T3J4es6_!q=h$XZP*=mFOYpXFHc>DQLbM6k&j^mHTn z*VYC{?OC^?)ve}zO5O&6RFYjmrR>uxHKd)-mcx~7Fd)>TQnjb6>NYpp?bnlS92TX> zgdpizQbV?$i;b8~YXS;pgn$Dkgy)LhA? z#T0h77A3AwVWf@s2C0;!w2C^gv}w-rsU(v8OsFklgf_#MVaqr471ZfkWu}{8nx3*i zi~e2h+wV_~T45F)ULHVr?|P4ySH=D4?sH# z+MIo!vemOJRaI4}Q_?8!bsvgXlK6V(N`errKg;KC#?|x+ItufoB1@F)E zawc%t$GxTk7Y?|XDxe5N3NMUl&GAB_p!YF$MYXAhsL4nNh! zkF9NJ2rhNN*!dt*-_TYT^1GxxdJ5<~Ha^W|CBuE`jt9_IRp-l1+o|1@Q1;l!UuCQL z8+w9<1lKh(;zL@uH<`%IWXk)Pnv66YW2x7k;%U{ZXmlf@iYuh>M5Lw7A)o}JiUj~t zrKF;e3q=%AFr}k3v7cnu zlOWXUdBt+@%<#BnKZR{uUnHsy>@cq%5rdUCcmIU2U5IqOjy~y z2f3oc5N+zsj@a&K+m+m>BBe0Ggcg&3(ywXIM|XD>x=Rc}&NoPQsQS}LO_@Mbr;lQ$ z8CxrpxA=XHdQ_hYH5-V$+Z)>(jEw&7UbUG&!#@*RXF73_f7ozo@`cgCi3k|#Dn*cE zis-JqAF4nPpQT+!M{t>}iF8|-n*)RW*5J{~(C(QWH*F79S042F?pEd!7BL>voDP|* zcAgm4wFud*Y$Tg!BuB~os!Kl#>vvZz2(X$Rqb}1aMN#fe8jC|1oRd-HhQ(ggEDeRr zz-37pdXzaIom5}Gr?pE%0FHZNjjp)nto0O(GPLXi72EiQJGMn2JWve)j`PAEDwj+u zyCRVf43aKE71~R0;O`Vow(7<^YnJ~2mXVADn( z-H)}weOoc4y{3~|9T$jx5MJ8uxzT1@xKAQ7dHgHSo(sJq`)$R$M}Tv-7H;V&0V`d3%>-3MJEuI(VYh>fki0bo5rt!ZMDX-M;N`4w7e%9_8YU-&1P zL*R>V6zM}$@XV;PjwjRQeq(R;Thr4u%W6Iv*0iEc=9zU6UaVs!e=%P1rT808(6v#j zXp_qnatu5>wa`rIh1Fn7sI}BwtMR z9@WzLjWj=qHqjj;=F}8?vkWfJX9tiy`d3k{{50_PvAN#Q?DHS_Yj5(O%cXGFe+#v} z7Jsy8_k!hDl?;5jSLnil9NZ_wJ_~oYztjB73xl#)Ctc9YJ&!e^D5QA-r#rsbt!m40B@ zJ-bq*hB*VN!zsu+9hdfbZ7MJ3CD|ER4 zBFxLf{ymLJu6!7@yNujuSGxfjSmZmD{SA1~HP(1%;s&$fw^WW}J*YgxA;`zE?N0aH zNn2wdTkw{%;rUAHHc}!ElBmib#l$gn=aKCG-JDnQ2- zt)t#F7lY>cUy90+MmlmSZQE>$Ivnt7DnU*y6@=lwteZa#S?ZU0(l5n}vHt*5dULS*IPLYQ;gN(<$k{5x6$QrlWb-0&4_t#>*nC8( z`;7W5+bN-nUs#ThubI*69}PS~6jDmMeWs#8!cA*1%MRqPdgE@i?N>#SzSX4|2JSrQ zIM3AAPo;Ry`oV&At{-(HdK15v z%<(sxR+*%1hGUboV;@Xbg{Hfx+l_+dW(0D;tFvK5QGXe_DN&u8i({t#WeM z`Ax)oRDNfHTH3~)tay6ebuSO!$*O6~{<0~tBgOr3RJ3mxTx}cXP@>VIET+ zr21Ce(0d$nr&gQglCwFF64_eY&W@OIIa9?VozaiYvGm%!r3i_D+9F_xXMm z>9;^i(Zg=;K4{|vf%w-qsr)IP$Vl2v(>#mL!x(k?9C9jU7_zBWsZHK4%;9`9s9sNb zw$)`5FW(E$k8#{ltid>IsRglO%eMsM2iCS{@L!8jnn^UgfIjpG%i_6dE!pmcqZ@^p zn{LLO5D(V5)*1?2$n_~-Xk^?-Mk-GS6owgB zlN%4hzJa*-apBJ^V0}U$Iu(54vrogl9R@$Q?}BYl4*4NyMlU4B4qwusO1i0p10yv zVhIPnaa-0}RQi?5t*Cn`r3dfuj6IvRXQhqG9L)rw)vyB$0DhE`N>)v+BS|NGw*s2e zaXm{{o*&d~Cv}l6ozv0 zKXzupqQP?#Z7ww<4YYsPWi<g+?#q;@-oMR)hV3@mJ5X(jPxfZNnp4XD`1Wq4qU z>N|x8@25jWg5)vjwxEGE=mWmh$rWX7vKgPW)HI82DrSOv_~w{>=OT!_w6|EUHC@he^2V8O%AI%dXHvO7UAz&%4}9d*nlFrCfo7ig39g*ydva@* zc*sTBBizGeHL5|*a@(TZ$?;EwH0?Vejt%Sv461A8G`Ij@c57ZqjORDY2YUv3BpW>EjVy7Qh8)HJ5+AP zB*^Ji7j{iZxIwY~sXEhlgWjcCm18UAf_-aKgt1|#TxwTKZ*COG-`;Er>+L=t+gq}} zv#r{|gO-jb+||RYl{r=*`h$u_c4L-eex{mf0qfR!=Yu>k9^E$GZYLk|)$vi>d|Q|k zDh&uMO1HnDOSe#(03}ja;noQE>W3fHF zCg$omg9I$t+(c;}M((U3{?;txR3(>vnh+&aR z)_M+g9MWt915Q(tF;H?T>e>3xW?EJUj`ZrR3C`eZb&*KtgG@uHqZEadccul1?qp01 zk_Tf~VZDfu9ECphj9i|a3P5RG4y6h>+@v3+W@@$|kF-QE>(qMIY;#Ew$~jZ)YQ&e* zOrSGy?cSZlS7in;jr+pAnylGbi_5!vMmt23s*~(Z3sH{I^tQjb zQ7af=&oU9m;aWP+hA%Yl-$xrwXnyQ~XCk$=okAn2J*~2=R(7Mwf;H#>@9s(GHG56* zPuMKp3*sfRWgw#roc6_V)TuR7-Prn^CSQh@6Ze`+d-gaeEhV^cu*B|t6-lj;;cKf~ zadD|K*uvdB&SY=*SFL(<+U16c;iztgoo{b@DrN{12WbBD9;DZm>N`~@O^a8qUgh2AY2;&>BxCoRzu{ENmLv`btuQgh-lX=XI}&y; z;(cj00L{GZU%Q^Zw1xJ7tHIAEhQclfT3{XN0HftRdep!cf2~5il^w~e$`&?e&Oj6( zAeZKKjeBujEQ~F!;(>Z10a%(fr`z>=ct`Qb3m-vU?}_|59AD`+Z@EC_Ybm(7q|Z|X z>eIv2ohaSAEBST(4nf?piBa#yIIlNaRxs9Ruk0 zx6GqQxOpWYlWTCHWEk`#hW>ulk0q?IO6u#fXxIZ3ib4FSisivmxQAYh4lvd(-TM1dN+!+ z&2|vh_Xt?^jrxkab);#x>Q?5;83FE8SIm%H&21o(30^lH3Y=GGqWn(QH0`n6k#!LM z_gZO^(dje%KCxMR{VM9?Pn>cLZO7$R?(O_-XKf@7Ep=OFU8FLA#Cy~9Ux`{SrL`rH z+e&|h`d4LdcMZg0;gwxabvdfItay)$^yazIA(lT6OJj9vaWf)(jJ~z!47pN4`?d9j z;YlHQrazJ?@ixC)aP;;F{Obm}VF zIB}l!2%;t%T7Y@0Ef|q;-m7gY_&sO>GH~Qot82210Vb-;_wz|nI4LVLrw@sp33EW` z;=WeE&sx*A)FrkdqmY4~#<--BkmM6ume-}m(rbdQ8pqdQGsRckp69gqN5yJcY_1>o zZ}$oQ6X{*EfKEaDMST6EUE+PEuzMdvUcupQdM!rOTFWw1;<*FH2GP-gjQ=}p5r5KK9wlu zt7mMab~P$DV?tojvu&pb(wh1^t+xvJSd{$VTIjStiC!Vl0!46s)owW3FI;_VjE+K` z2_H(gZ+y^7tjMyUJjVQjD(;9qeLQ{PKNnhkk5_~2&f^2j90Tm#tC`jO7bcok=E`ri z*%SM@(B}iuvHa=!XM_Ab<4Y4Jk8svHf{&iv&R0I()t4kbEcktLR#a!RCk#IHPCunh zN@{A%>%rqEhN;aTxKsi=pDN}eI~~J{S+vLuZ<&IF$On;KC6=wAc&gBVKFM~Y1xWk9 z;wq)zhA*sscuLI&Rbn>-`1Y?dr5Qo!eZChlp^1ubMseZ~DOlrro+~=&25b?v!RTvt z`dg9=5=Rmh`=AUO!@6l@a2Y;+{Bmlk-RjP4ZKAniXE4heXhIx&RknoVaTJRYEC?J{ z{Ktr>HzRLLxDs0!9PoJ+W#d;uJu5cW5`;JhBDU=1w^j{2CE-0voEr0Lt4iqmj0~Hi zqcyVo(a+pM%EyX^Ii|O8$i!DeeGQ`m_RQpeb;lyIj3~#ETEeB(nZb#`xX+rKv0~d< z+%``cKH{tDZ4;*Tb&-7?eqs3cr>qgE%~ZHe=y8Ou~3ytJhjr3>D-@Byi@=o z+6QXubp2{m2#trBF~xbXc8$&rYw23UTO1yKwKeeX;)ywSZB9v0tgLocI`z$k!w8!h z;Ez#N;nlSt3u;p9Iv&$aJX@|?+!nUgXNbuAn{)6_y-TcVUPx=J zQTwO+>FMuWqxoci200&5 zT!Ed-?`9>5&U4Obk_HF49Orx@V2G{VWBw)aM94g`05wYq;>&#SazV-X*kl z3#lLCRZI{*wd7f^K=8h>+Gd&|wmw^vxVYexSk|uTM)tYr<(Y5Ss<9_tRZB3i84 zmX~p7k&;<=DEvh^d`F_PZx?p^f8G_qX`c~qVNW9LiDNt++}A1NdsuV*tEI-COuy?; zakTp4v!jiK-I>>o;rvD#E_!Lw9LhY>Qy_Mx@9f{5D}g%5 zRPaq$hU#Q-i3T5gA$9id( z(wmYJiP>p>AH01YKM_X)-9Z%FObN?z+=1Gi6T3deznguqGc|l60bP* zry7cC=$g2B(U&aKOxN)mXfbLqK7lmvYU}eX!wjwIRVBi&U@JD};7-c>0x%yo-h|Uk zjNMq86Em@B&a2;=W8IQAf%w&2(q@xoM@Mv9N%rzh4SyhSm!(tOX#mLFdR8u!Th#Ox zV_8Pgb|>8>#H*Z=#{drIwf_L&5Ag#jWYZ^Q#&QR0tEB+iibw~`AI)BcVdBfxJWkjH z7^tgNQg%r0z-5mg2Uc>kx#jm3cNVR-cwRR2VTy+=J6F0}!=w1h*X+8A#}w=LSw;!2 z8^vD^H9Y{d&?&mJ>KR8MRnx5*qmLPu)Wge_YH*wVsdp35RO@c?KE#dLy#UFsi%IYX zzpFBsY+Vrl034qvt*p;9<*-jvQbwMOlU}{1{1cFcZ9`B*^;p+6)Y*I~@ZF#WUpC>t z+H4AHBDwR~hF0xPSZ+4$36b=#r)~Tj;k#jk(%?SqGgnhY(c>Q`pKL$i0-q`s+48s9 zZcqHPZ_1PGcPIW?zvW+6{{Uv`gQbGU7st#Zo#(7tfSP5 zx|ZA(UWUGxeHTfTeAX7{{s1c*Rqzgpsz!E0_GxkQyj)=YD>>1=v1fJ{85(}=NZohp zcne!djkmQipexq8PZ0QLSkZMBw{-Ji&&x8e8279zt1IXU^M}dV$4bMNOX58hR*bc# zn<_sFayhK|3D455&kWIHcPe@srpVQBIWaQk(!^P%$rOYYIHavlICk?&Bt7YrW`PrV zf|M{d1rz~dlA>25uS%0}^`-*RNt!7LUB_cCcp{j;bY_(FsS*p&9GQSUTw zK9m6^F5oH>=9VOqSydxa&c_M|b3hhiw|QfE6_;|6@@Ja#i+>H+>mC8OytTNF9ahUO zMsQoc4MV5=A=cjB8_TCi7De1aJg>2=KN6+Che^}y@7imo7@VQ`K=k_7saa}f?%swa z#q4h*O2_6Wk?-D}rrj357Zad#i0)KwMt+r64K``*Uf^_7(xp{cA`81Lc{P-2^1frP zrYfZ2$$bmDmZx*7T{N@4N&JBHss->iui|M7XQ{R&I+NYDbz?Lt6T zfG*=Be-A-Z+(@F>05HsXsqVC!n*@ewz!A&|kFor!joJCt2k?q-Ku2BR>n|cUzK~&< zVLp}7U0xq4l(s(Dd#-P2lVIQ8O?)~qjYeyJ3;;%;vG8JV6 z5rbScF?_Da*J1c+Ri@i^b~s5F4W7oG!>G>;IM1zJ)U1t_(?WjXU)hp3>8 zigRF{!keCHnTQyJPS0^oE1#_+4aIpK4*? z&;+bKDYUBD;L|EQJh`jx%AXA7C`qhof=p7g`o`hG2 zTzK{FE!r zBy_Bed7Z5h$lRz-N7Q1qM2jMaQs>k)ANd>GgC{|F0`BI z?(F4g~5cG zPnsK;`}-Q^aZz@f`JVJ@I@G!FvekW;`W(c55!5G9BvzL)p*aL0=|lKd>Jm)0^2R+G z2(5VhUwdz+$}I05-u~PDb*!zB!~4mf57ZF?B$K6?LNnzslXP-+psR?`0 zOo}ZoSpI#xfb^*r8;v@2ngvsyOisD|E2h)Dd*MxZtXhqq_I=6zH2b;w*FiUiV$>oN zSlrv)$JKM!^A*QD9Fw{|{5KHLlI5DWslYAr-$^uS9lflMf7PNdBJBMX^sC0|uM8s;wHe=w_^syYEz2=_U$RoaibjH!P4 zBBN8Z)UJdv9YsV%cCC+)tIVfz^fNI72Cmx9(MS$>tcaUw#c5iQNCvs;#Uy)~b|O=1 z&s23V%9BJDj$>iXXB!PX+?#DcGQh|8bEj1L`ih>?FDlttTr!jSQ?9nUuNn2PKAlHO ze(Cl2yd*KWZ{96PX83=qg=w_siuT;{jE%_^k#pg_Ufr=al{dLn&2Lz0+Mb6d>kE>o zc`>&te+uXm;$8S$Po}{s^#>K}!xITB?0gO{BdyQ zHr(-D7l^!1d#(QL!yUXm(L2{CDBAfHs&drOj65n}z5cg4WVjBXgUx7JT$z>aT>O#@ z5NnmSxFC*eQr_ci%Ha2}GNm3?eV!9ARpPn2?q=OV6}8*jJgkLS_U%xMOJa`V?Q)|b z2;|qR>DoSlsKU3`wre}G;J2aoscv-N1?eS!v@~alT=5`M%lX%_hLWvL>FRt2X@r&& z5h&Z;zK4xWK2Sia>@wBYc*9N8>~#m1NxF{W!r*UBontBP>7yt;GVwH#aBJhSJ=qLCx6=w70~`Bd^L1aC_HtXL}@(fxG1c zisD{o$OD0%m91;5C9*2LdDyygsFO$7WEh$_S13){b!UC1>jn(Nb^F_Q;gPunR|(>s zC;J~$`%SEDEN%|y^V{0CEj0*ka8bb{wRG1yg{HZte`a4>#v;ecz;dV7xv=%6MplvQ zX8CnIbsl;O@44hRMn5>1v$Tx!P;TP1wJkPHHugvy7EJt(2Lx3OqP?W~mC^ak;VN=) zlGO~{O)fLmml&rimOKp6Vn&6{JgLVWD*lmM!C(5@lY~_t~bd4hdW^A+f#Yq&*oM#nPNLc<}0PRsctVU~sOP)=i zSw>%0r5LTzzYeM`S9o%aIRsZ#WARrSOqSPhiO)qXURf;6&9`<%Gc~muF^;F5nC8_h zdy&%JdYz(p=vqwjS?PAj%yYSyCZ=zSejp5c?nql~r;vzre>3{E!qSLo_7c1H6zB8K*b*Z!<_DHuH-n7&8C_ppc-b_dP0A{iO0O4$D$M_`ts2>$H z#_PO(6z+v~bnSI_3SnWHvEHDQS(+;u=axb#(q{k7*<@Mx!k-~<({fM zhO*Rwk_P*d{{R$c{3|x<&8;PnBL|PDVbF@_aplzXV^LOCW>Mhbg)x`Xtw|n6YPnJk z37Afsi?bu6BAiswimRCNjnB0vY5gfW_Mj{`tsMTI60H}AHvDZng zGUt}9^esbc1@@$tsUT4#ffd`J&wBQoKY^N5c2Qj1-b*`e%iw@9?OqV9Rf8$R1CVRe zw7-jYR+>asw+hlUYq#rL#aSE`Cg&@&6UE;SZuFTXy3@B@*$#O7%UlB?-?W3Cn6FE} z_^o{^vRc|iirshf`c`(0d1K;R_OsM1ZQ_zqm7YJBZ@o8WN^hycv`# zlwfcv38ki*qdT#tid<2O0Bs?sVvx`SX~`Qoz!cijv_KRZ&ZPNO&fFFk>lHajQp+Qn z9>f8VYe342)KpSRtPay$@vSD$UlEqlrw5_T(M1*1eBiXS+EG9YOG!p(0cmM7OH2i# zlQd8POF$W^QXSptIV5QcQlG+zsI3UCf}VL5r=@Au(rU070NJ}F9+fI_eNK<4SGD;@ z>7Ew3ySEd{jH-U>U4Tz8Eofo)2H0ivX>7h|&lg*xOf1jh_jfgMFyXvFE} z$M?I6fR9mw-k$`9HzPa{Yo<%8K6-@Wy~>*~Af#)a`N*b`#^KVX;h|MOc=Mlnh#qOD zb2-PAhz%(jpn;5zo&BjPkT(=_N`0uL0%X$XJQ{RLuP6>kUij->HlN|GD_FE5%UW2k z)MxDXNwr^&io?AQNp4(e%1Y@RvH49nHbp+-2`#30W zKobsVsMWDjbri&E=-wdIG%JBEob01NG86Ke^<5{#x<8GqjfSHVCCL~78$sm0+TH!Z zuNA2wnoD_BSe&Gaau^&DRHb1xbF1-hgD!kOIhr74vt#nV_kOj?1|Wh7$n>vg@Q;b? zyi=wfGf)8Bh1$XY0E~Ky^UoRhY5X^rygP%`mT}I2_T^m=T_|?ih1TkdMZc zawq}0VcwG@_os3y#jU5>CrH{wh%x)k&{1LYKIAA)ewEbdTFjbu3|mfmh8Yy;JOim4 ze?G!kFI0^F<+5u6dwb0`PcG&OA!R)sNUZA7Z61zYj#MXUE2etpnd3B%Yf3;v!zOxt zE2Fvb92T}odVtGl$L3|{Wq3MWnFkGnT|b01#c`-) z)uQU*m7i{p{Eu9>yn_BEp4LT@Hsx7QN@lO6L#^qLYj&%a7+3BMaoV4SwT&sB^TQW} zTgmenGmt)&%iUUd+C~>s8B|VoO3L(heiynG6=7fbI^lc zkKk{JFJjT@+MAYy@RAeL>sJ@hmU|W5rM>mLL3I+#8w?d;n)97w!MFY&c`tMpX{^c2 zwrq2O{>^$c7ctyKvc%z$hCvka;2a)?sif7JRO(8cxuERNo;*}yyGS)S6r+Eum3yi8 ztPMWoSn5z*6%LBP;kg7?u=u-1vs?KgFa?iL1w$|J$U1&?<5I?L-fLM0&l?e+r9xb~ z8daCH{pWrCPi;?!`VWgV*zeK9~byyQ#OIBi-^~sDUJ#JI#zeX zpC2`pmik5M{n0y7&u>chw3TE~%0UEVRkwXkeO8B@S$s#;w6+%hC(&n%92u4}R=OD5 z!d@8Loc+0KnQ6?1pIVzR7XaOKjU1AHt=@GT}Kz z-Y&)#q44(L25mD`B~M7M21nB(xcyVZ8r_&8<4P{QvfL=YC2T8cnd@iGDpZG=~Vv!u@*@1rwqptlg4Wbl50kKm|Qep? z3bt1*9y^27R?vbgxPw~fem-c=^sHGl`->S&a<5L{@mFH=BEzG8RmD;&=hNWpROPcE zmNrK_fgYl&N#Ac3)oJ!~YJtfp(eLOtxhw1v6iPP zC^*X+%$RkpySQCJ8xPj8q(@EsZsW}b6QRcNb|6m znNpRR-gs+W7OrjOKf8Xl)km(ZI*MDDj!S0a_k(a5^&XYv@XkX54IgP>Y2lTEJQPAw#c9%uG zj^f?9@}xUmeXGCHJWXkLqm3h3iDtLP71=`+{QFlqu6RZZOx;?-@>-rmwz6&m>JK8l zIAY;A-Jc_h$niLOjxp7AeahG<@HYuNu}Lyy^2P)ZbZF^bMYV^DK~Yk$PE+5Z4&AG27jL!9Heu69LrIW^tw6V)FpQx8&`ahlk- z1@+CO!fScnIR{2lgHFEG?{z7J*OxL+AQ%PPIIQjFjpl~$qce@-?u!Cu{`DhHNam}O zXw63=I#w#Bt#Uwf%{Us4GtMdFty(!-yCfBNP1GMvyGxkSU6kYo85KlvONyjP-CX=h z)h-|riP|%aVl@f{a~GPu?emtN;z!S`R%oXeKnR zni5unF|h_V%CM*%RmN0tU45s6FZFE( z3BFHuHa=In;aUM(`!_8Qm&u7GJ{4%H(||K-M<5AB=i`qSbR0B z&v6_pV<2e;K_iS-YUZvGweO*XBR$1EVaUi8+C}i|S7eaN$c29B>zbi|;VoxQRA#m< zyQa=*wJySfrrnb;BDXRyR9v-6_LIc>S`(jPT8p9Tr5OF0l&>YRR2J&(BqMWfQ;tPL zZ0(FG?8v^wDO~wZJAK-=x;*hjC3w!$$TgvB;!CJvYj=(pM($UTYALl>x3z4^xRJv8 zR&B|<9dM^cF>`$ki_NOSH2RvaQTfdB7H+I^Y5C7e>Vi>LK7PGNR-=%#gwhj0re-f% zaxp`=5)Z9L(kj$U?Ee5tE(Eg9T;nAB)2+lzB=cOZ6qO^n^r#dPKm#P#ZQ-AX+P1o? z%L$4D)<+c5Y)zzb+4ifJdS&(Ofo*K1l%AMViuJe9d==n`RrOgu+j=<>4svS)QTUm6 zF6cCC8+|?wft3M#eQLQ^QC#Q8!|xM324=Bfl@j@;JCE7q5IJ*rt^3o9TYfH=tSO!B}y)Qo2)qyqwz z9OKf0aYzB118C}MTX`B4B`^u&II8*Nx8+j~6bfKS)5*`xjMPUs=9=e`MoFLrOm5CP zRk)+v!C2sRbLc7vlc7AE@F~|aY+or4URe6j2F;$P(#`&k3K*Aak=#{=B=SyAb68qS z5p{riirX~clDi#Bl9W^)$Z4d-Efr=$Qc}`T0#j+!(?AV1X5Qmq!K&t(YGoBAW^ISB zIuqxKc58sbqK(c?R|Jz%slcq2B#!FYjO!yVmXeCp^8%MOa@S3g=VsSYySKG;R-P2M zbqy@8-n(lGxT;jXHhNfGrx%G_(1xAfh~%?IYo*sbFqSrg^2%c*L+_(?TIO?CMzku& znhxmZ#bGMpXYA^$F~XLRa&b>6RrrXxb7iN8;^H z7`(0g4l5f_)b4NJbk0p%xU$bGD?Ug{oDp4A>c(qx%f;a<)00JXkfTGD?(W~rm#mbuHsIL;`&4Uk_ITe>QZn+0FzioPja>Qf4YNhq%t-;w0B%bZiRl=j% zNaV%gAd-~{Z_voPvo8p_LC!v5>shC+Yp1qT<#}g?#yPADyLPvo<6(>*J;gdxyKynh z@M@ePUMkn$*Zv5lSIbsDoMNGsc96rNrH*13V{*N{s3bC#&lO7XXDsCku+wpX_Z?_B z>NxhMa;Bf#Baz%zrvQ`=xco&QLrI)skPF`;oU)Z*K`O(zru7t^X*8K|sVF@QH+N5S zv86kt9B%GvvtWUaz3Dj=ze*CauMJGPvQG&cSy*(>dXH9nc`xRBHg<)N%3NU4Z7vtq#x@NmYCsP;q$^NRio|rM z@7+;g(}xrQ0&YfXCr+*clvKN*{zyg{9kfwfi{3>v2-m9m!lc`H$>>1*~ zVm)e|Rjf_!Ua{2gH0eZ^moh}d`>kDdr;n2EFSBdGW+{V$~}{h z_0ccgn178}zVPjji=$S#wP^gr&zX!eHCmHay|G=orLUa`{{WWp43ETB`z>P5>M{09 zh{*ovJc?pGFU1}U)O;~=L#dM3pORoW$Gvkdx%$`Bw}vao{Hv%ISdV5IuRQU0fGlRT zlK%im9!#mrL)iT*IY7}!@+D%Yik%!d_o!t?ibh5oSxyKvfa3&KTNGLc98%L%?ir<~ zBhh{y_`-Wz$n@K}3qt%MC#8Dp%a8~)^9&O`yy+}w42K}sviMuaHd?F^+TA#Y=m0)r z!&Z@GG;|&+uzg2GW{3TJL`fO+VO|sBDCAvG+{qD)&NmQ8@prGH)a5%BHRazGtRPEU zdC)4jd|-RilG5cx?vF2yR)%Gf4jD*bee38y19+w_Ye|a^Jov`h6FmKE=ZxfLwDdh{ z>q68cytQ%&KQi`V=~>0t8oBjCOc-!!;j5DH=ZP)6L8m3nyMZ7dJbC3!Zmr7>wRRxV z4Mss6;MFC%9mPm46!)NH8it9c>QOXzRG4)pqa zS862(y)T$4fxyY)jdx5_4~TRZc)A(whV?%9th=c6EoKLsO1g|lK4Wg@Y0t1dE7bQZ z3@`+G8o|~)6`^ZDw6=>B=cKUwtPkN)C`M|`>BC~`;pfjyo>wNG(w2Xj)OA)oilycG zZbG*nmDFm!3DsazlX>n~N@kf$A`VsRX?_OPeJEyAH`>eA# zrHWR1NTa4}I&?bNwAA-UY(T`QNGg5nzdjPt^*999I?!y4kKSgyTUrWk#HezvDx?>e zHpeheB!BL)7282WkzOatW>}m|adYLU(!X=mb)Sd2#k5T|jH`7R9H)BVrn8vJ(8&wO zGX3b-V2ZV;c<00#YXcShj0f%f1lTu=+9ad z=-2nDvlJ`F!#yh0ZrBW`rCWPq;Hi&hKfT33wvwW=3>6-gFH~zzoT<*y)emd=QNdQm zD_cwPTiUkAVxaIx@S4GqK3vsF7cEez!bsMxVThvdd#=p%h;-{cdDL4%k0Wz{a79+V z@SK*rgW5=edY;w8S!y?WeCs8&%#05hHR%2q@lK(x`IfqYGTVWN{`F-lGlsX&=%blZ z#59x@`!%o0{{WfFNd>*T5x%KB(FVdUJ|Fb;Q%M*71L=`l^$070zGTal17QQA;GPyEo7(yOokonhPEB= z6YDa}>JnbgzK^-DuEQL%ss;JM>IYiqr$sqV;=K#QvuS$2`W~XYOOKLHoYyt4Xp&g! zGQ{1F$ljuz8EIx2r8O#!Nod#La&kws;}sofJV$X>>MFZNGDUVNT={yqXBTu=&op#3 zA&R4A#Z}H{2DcO3Q`S#fZ6O#r6v-#^1t^ers^HUu15V#Jq**%}VkD%a zBAR4TKn|j#GWrT{nABV>PfcP1oYW=Q_ok9fD}{-3`>)2MH1uEw4Kd#*fk4FXQoy0^ zBSX-z2BFR>)vR3ZZ@hX65Hsjgr=`z^?4q!oBgTqBUi?z6ieFlNpHj9-TNosY@tbcE z>UvR8ZFt}T_esd9?*1fe(?{i`$sZUjqng{DBQ92VdXIs;H)4L%HPE$CbGLmpJYQ>X z8ro>qlj;&6+9e|c^RGP7nCmz1b*){yTSPZD=KJ2&e^&96C^nijNo{VtZc)jnb!(4Z zj)PIv{7o>-_m;YRf87TxD;rVPu5C2^(RhMusq^=E$KhOM#pL%6UU{BIKBqMr$ip}s z`_wri;+i^(ZyQ~unYXzm)cxb!)f>%WE`VET0suMptSlCBp60b8M2$cr8TGDNs~)}< zrAn7cq`UPZNZ9=Dd8)TE@0T3lR+E%oOL1A3BQkDY^i$s9jY>56V#sPlaI1=lf;ptz z1#NT5w{mjed(#?1YCY5dT7Va=IYv$eDy2vO9VkI_cfiLPWcKY^v=}gyiG?IF;=BYf{;YI~ONj#I9 zGm1@&c4>w4z@{@3^rWd7C^+fXmm|M59T}hrGfi$rX}LWGAz)U34uY7+w{uSSH0yhL zF6IdumS#8rQUWwqb_p65J%AZCVePIVV6!2Ov7N2g@~*1iLDVecVD}cbp;shFGVlF4 zu4+FZNFh*WL+$L{-k(ir)11Bg_Hlm1!} z(0dAP{m{8+u^OpF3U-WUnGAVS=Q%w+>QvLGcFPT*o~E6Ja$P1P<}{>m1_f&qQ9}~J z5Jl)a)ALr9h-_TaW|ESC7c`lqqL2YJnWB<_5Yif2Oi%)5oEn>oF+j>RQAt1-wCn!> zu}Dc>!2Xrg+v|}CHle{Iy>T?)>^d>797Y12XLq^u8GjL1!c$ab6)3HalTp<{wURY_ zml(x!AXAGI)Y4|R!{OsXJh3=)Owy)dRaBa_v`FZr(X{wQ_-VZRjN{a(33|? zr`;vgSU-4m6*TrMAjlQW!86;+9y5X~q_EW@x&c^)lhD_ViNem5x#{eFhm>b@F|^ej zL$v<@Gdf#FLU^i@pioI13hN#eka8=Y*De0d0b$VbQHR8H$wlsU<``H~qbjRpVl>6R zQNXF~`wE~9O%(eLdQw^+8-}cu`J{9(L<-eSas-maCIoMdw&U2;acYYkXV(>%HRO`B zs~?e$YZ_GL&&+yxjy8kCI%`(Zp2G%%(=_G>y-Piu*2;!NBYFp4p|01V@(L}c*FwH& zLB%$dP$B#tl#SCgnIn-;1xU%J0|BKyX<2YH)Oyob+m5=V^^r>!K%G(=7Q}%M^__`VHImo2P6uYQE&US&4dJ3Zfg>osKII9I2 zMoN+EQI!UZ4&w!B=-2aUSFzq(w%Jpmtj?7rQW3%FLUt3>y?H#BS5jO`#iWsoF+I&! z-HK5lJQ|I@^)@0kz#KDx;wfK8n(fn(t`B%2leX#}| zNE!Ny@XXb%KTx>R?_;~Qkff+{$A4<1>?W>zRn~#1=-Z~zZVa%FO{}Lsk*d}nE3~+n z+guj2yiES2<_#4^*;+pfSfh zIlvMO;CfaTt9@;(Tp8oFTX|333DDH@E`?ZTucc}jd-DJC|HIHg8pV9H9c=tpX5uwlhJ z6vTR8fqZc(nKaEw_lDv*4_~3GpA=%4YPQp}6K>0lcFk~5NYKoZAt9B42EA9sDHf&R zNUo=4^A!Ur^);e*Rwmk>K`MDpNaam5AIhfO2r5Sgpk*j=+OuUFo*VH6&xiFixrK?0 zoJgIRSH5Xlt+ugY9o@5rM;wnsUo@%6u9w1|EV%IH-+3)u{PE}cRYlmDBj3YQgVsio zu2}1KqI)@mdaij|&?dAXwzAZsL0RGPPg!YL4FM%QNmK-s@g)N^1eL+~!@_%vnzodI zXU1lTbdZ0Ib_*>(enAJJq|$24(w#|Dl9XMVK5p?1m_$pMqbm_@q#xmLO2c26SEqbe z(@m6dPj0(lnf`ShH+t8X2HHU#4Pv3mp}r!&x1T+=>S$?pBU031v@)z-V{P8u1$COI z!p{-ufKO+#@-fJ0TMhYF60B8&DIktP73n?>_@8m6`F2{VGTU?#cVDe&taH1WnqQ54 zN8yC$Hh~MdxU2wJH*Pk@J5|HA}trS;?I~-)zGN7Kvr9(EY5078#xz0C(H7Vl_3~3-g z-8|M+?}YU$R>YRF5BLpw5ZAS0+0;BYcLbf~w&tym5L__w_Xz_I7I^lsteqDfPfj@c zc%2$wJsITvf#RYE2O!|rL*;v;#)Vq2_+-)O+P{MJD>#~HqD#1s zNgz4mxQU2`+9yUw9Yc&7>HIHe;#uu})1&HH3)Uj}{Ka0?Q(2uz*1SBk5&r-!;Y>H_ zOW4KiZ~dWPX*-^N<0Fo0xftpzUh>Y>82K+OE&l*K2CkBZ2%6sTk zE1E&U9@S;w+JW=ewL;6qO^4=FK;;Bt3U1-m#z~bdPJhS(r^tWPLyLhMl7(f-5gb^sLI_8wuOgIMMTN~_p5Fl2~o&3S(h2lTGca#r8Kr9jun}(PAb*L zlF>otqlO-pR2{A=&)Q@tV=eO4S+}8rbYljlwdiMbG`(tPK*NrrpyV36SmE4uaYktY z%`Gq;lSxUMGe`xZlQ^U%fE`FpH<~CIxuSpx=qc)ea%chY#y19jo|R}!iVi;YRxR?> zB=@I#6S+Lo?%{trfk9@)BC9$1N8?swj3DdH8;p^7geKw#aZPq-U7>;Y`-{{{U&%FQc_U zGGk6ncUOKe(KO3ZYo&;7Vo`ul4A&*7_}@-sU{&s9JY|k*)js6=PR1?M_)|r8TRS(s znSYK(;<@c-SbbJiW`ZbHcvXyIpt*0gUObVgja{+)QJ=}Q~3FUrImb~MM!v1&kgpiG!b;j$fp_010<1Gy%cGm(LkdJ4S_ zm+snW88O%lpxlRXr0qtI5qkEP9alDue2#Ji+E zo}XGYO6+lrrzIGxwpp;XSP^b!jY{JPr1$lwGj1f4$>yhhD*iPL&`4174l27Np~EQ$ z+*LPw1Dsg7>!_8W~0yAIwxN zp{uPl)zS0Qrzp1|WQBq8= z+-{!L6L4^AUsAJ<-u1VFA(J~u{u5c!+q^6iLDXeiu@$5yq><&~FqJ6Dr_tH}0A76v zGfPN82L_IYv^hltsl_P(^!%wfG;$9#0Ah+WPFE^&I{VN96(a3P3b^vCp2?QMF0ShYFMF?;y{bk^r*niOowUX zifB!pJ&%B|E-g&+Us=F0kgXuiPTm34ZP6}mq=xBKZzd+r0IpoSo~+05t9F{Ep=gY@ z_cF$;FhFC2RIEj$GWq<=$rz!GH{M@*rqP8t3>X^K)NXC3)1lcBTa`aMde%8$-6&&2 zBvP%O)Gu0ehbc{7l_d_%Ei_WlA#+PjrOg01F%iUD~nv~aWNiKNLVN?Mt^r5{*kfmxQJ0{1iO3nc0tGg20s#wuxMOPW8Q6Txa&b^Pds1UV70U7|VK~P< zYQ89?aItM=QhL^v_P2F=X%(lKMZ91Qx$9V9W~YuRSYcF}q}Z%UETUNf3$y`>Yat_= z>Jz|P!|4N3R8oXwAUvARItHtNe!(&NEjuw?7$gYG z%9TEZQniL}cxzpgL)6w##6-sq0k2@v_2#&h5>^sJD9lqYPob{?R?h~vG(Qnu=(B?p zd654A6ivuAQI(05PoOhO4SD^C#Oo;tTf29U+;d$WuZ#3crOIBQ_G5~>kz;%{NE)&Z zzoe?}H_+q#>gF}?h_-fW(P{qxzL)#mg#$-(axP?x7Obl$V%1S5*J2xFw~9gikDmk?}KEuqwAWxQu%6Y266-e1q2&R_e~q_A?d4NI~N` zA4>A?5O37<=eN}(5bD-EZX^9- z)^ev8dmS;xRrgbONa7ilTPk>`WM?$VEo4X*Y=W$D$7+oqv8Y;TXE}4bod<_JL382# zQahMf`FX^N*oyiSO4RN3Z9Xfw7&17{JuBt~Z2fD|J{kC*>^I-pmoJEBKOrZftz!Ba zHPrRH?GsDXkgeU6GH1C_n&WkEg;q0elS{aJXX+4~t#^VGsCG_N3Z0An>yHZfIs zovu@pAk&fg29{n|r9d(bS~+T~NV41<_B9-c7-V&&j!;I{=~J6_@)}S^(O0>PRw(i* zcY9FTB#}x5NXF9h=}SpKf{bUS0A`*A05@-~H~>3QMF1HzZpT__Z%RsFDQx{I@y2B2 zkCaqkZfsSwI9;Qq2niX1z*P#Pu%u8k&q{7-YKbLjNnL;dzSM$80|D3%tw%){0!_sA zB>ia`P@d+YX?qHYoYJ_-URHC-;+hRdnhRi33j?<_iUG+d7^^lKW!|MJOITV)11A*u zY+BvfCk-1f@R3E<#qvtr*3hWqjMPT9?YuvzUD>_NR?KbGa^|t5Qya3LqK32yZX%o- zcJF#-Ge!*}N9K&vKqjY-(n&iIJ!ydsXsd=8Vq5}Q{{Tv62YM_QD^h?-;(`E^Zg475 zfxw|45mOy`sQ{ry<_nNAag$fCw7ac6BYBa0xkgdZgDL!Jq$`ykP26@A#FdeoNqDT6EsJtX`0b?(`p6%(HYznC!SbXd={^(o5R z%-RG61Hh)Ws^{xe(}ddAKev|TCtD1+1-M}Rh+$~dUZS7j}BTo5#_EvmC0*947Qb6 ztV^Gzc1^3rx92Yw4@c2A}!JoRa-8gb1Y zcpy~MO)JI23@o=h=xdUXe-PVlI&AEy7q|JH@ zW8^1pXKja3nr$rvi<(+)Xw3jSG_=gp&;rzvO3=t14hX2TN(~JrtjdJtPD*fgXxnwS z)$PE3C0>Me6@zzYHIwa-WqUB_YIx*m+j0^OYD0Y$%zjPUf)8`jyy;S@LEak2w`1z* z<8Zm0RBQW{zni1=Ilw{dO)1Y6t$m`rK+9@;$hzQl6_OZ(gIm+78LPzeF<4rddGb|O z{GXtzD^AY#c!t%G?esO9Rv|RzlUk1nQdH_*F2#(r8s z{;=YZ98zu~Ku1~xOS+oFH6tNzKJbYi=R>?h=u50$GWU6!Y9 z%HLwvI=Ag7FVh%-2lJU(~ zsTUh@Ko)nettXhiwFM!kaTZoUPY0UlbRQRLS}np9ndE>TV`Gtu@aIDB$)zYhT44C6mNf z_Nz2yUL_!(db`~dZBAKOnD*rD&q|5Y2O^}593Nv!d92GJR>9_{j#iFEkr=C~$ReR+ z^rov7JoKOsZtz!+Ak{6Su+$_G-Jsg8PYqq!EWGyhua_f{k;9`EVaOo#uR`$e#QVKA z&|7K{o1{^NY~ia#F620#y(QAa8%ZMtRT(7LGjZ`7!_ZIVJgnp#5~GUq?-2Y&yw)IV zYj{PpEy2ObBDlTW^G(aJSoFUhw}&O7vWD`=J5NJV2-w=KS3g3jUQZaO zBr-@(mB}5eu)bX%#88Rs;}&;-V8@;sux@mXM@+<%TfAWMt~my+z`;n&kz`Sc5UaHn2khQXJLaRo6cNU01@sUSDQPI6O}&DODLR?} zdX6c23QU1TF$4K|f=nqnl)Ei)9QfE2)S zI298rJard9Fs^} zu&%$sHyU=8GwK(y8KoRXxan6FeGYn+B`su8i@>_{!3DoF zBFF8MV+Q8qr{F7=p6*GQ?l=VJ1A$e`W|F1K<49c5nohN;rFeH%*5?q|S;-?F_`n}i zNnMX)8ehB(D!xa(celR^^=lg@lIrrpIX3PQnSeh^;3SQrk&(KCgF{UMcO>0Y3(0=Z z_H!c`vyi0l4O9ai=p)}WuE%0b=aWqzGxJkf+O_SG3Rho>kqCxW1>?@cwli5q+_hoPOpW3C}KS z<_>aezKkU;WPIKtbh+W`x>yj`c<06fJ9+}4bG zg}uip>&<-Q2Dn!niLJdm#j;zt+cC$XH9XT_5*ww2n!P#M`JViNSZ9My@=*2_=Xy7f zB5nR!+t=xMp4hLhZJoTBd+ zV!~eBr`?&c^{C!Qk+(Y%eQG)>Mx0Z+Mzt|j>PMDyZF-KS%`-G+sK9<`%{Meq1M^Fo zW@ya-KQy_fW{l7S^G0d8qci~g(&m|(T+jpaP6ngRC^QJWZ+R>S!e-TI!`W3_@a+EpN6=-)opEe)w|akhYAA`$FmqZFUP~Vt z$n-U4JGhHwkOS+A$*QqhtNI<(zq9K}N);SDn*B=fTTd@UIQ2D^sN0CHPCobX3hSYn zTn(%$E8RNY^lo9cLD7YB!xG~^eOUIfSv+gue{n8n{cLgejS#s-xEY9?Fdmfa%SW}7 zb_s=#$o{n@?v-RD85(a^8h?%Px)g?dZ(x z?;igE&YMA89w~Ahal?N))bqr~dRCM-5b7~4wd)AyQHZV&{(|1#^_%?Y``=m?f+U^^ zZD(j^Qm((Ry+>LQT}O2S+21w-@eKV;e#g~+l~cI4meykwqXcpY=trpbp{}SC?lYwd zdBOZCC_O0v>`{tnZ18&0nqV2F%^CSX^rWBxhIt)m2Q+6Cp7elzXw5fu8598gicr|^ zQPGNEE1cxh6w|TqP3Y8sbrexR3Z|TCo$1|afZp_=;L@-Ir8a;h>qu#!;+Hv~2dTy> z?&BC8>Jn%jaX=33MFxXFg`{3&9@Lq|DjlaJP%~RgzB+aES3)F|DdsmB3_U9Ei1kfB zRlQm4H085ge9EV(u6xco;-pzab?a5lrHQvuNUGm;h^r=`nSY2+oNTeTn>a1+9H7yuh=@x<^)>kLykk)1L>K2LQYBr7X@Eou8 ztL4z1V+W->G^_^Wj+F6fIg8Cmn5U=}p2mtUTMY*^RAIUFr{}=6tT&8>y z;GWdGjQ~u~jt5#`=L$NWw2`C9BBG45906XT;ctg9C`-+1bvYSWRQ~`vaf^_fNb|Aw zmWW%f@|n)n8Lb;14C^;-{*9;1`R-R0?v}RN4w|4tZ*G|GaZj7YI#r^a-9UhL1XijD zhcn67;qJVa$+;qh!QeCC*2S0nB;FrDnvR|J`w`S*b_ca?U--|%UupB?e>zdnjGBae zQPNX^426D`S|W94CF39LjZ!$T^qBmahs!m&7$Ug0f<@~a55m1aQSnEEwSZ04gU2cV z0G5%i(_CHk)tomc`#yJ;1JFu26_mMmHK!R#XkcyQp0v^{bw!229(f7s%T%Yak0q_8 z5-9E7rCID;>CPV#GRVQBsN_`6gk%weQGx49#El>UKscptl+j2BQWHs<0+ZT+4Ej=m z+|sOMkN_l~O4X0UdYfso>J4n^Zy4pAV>Ij+GEYp>$JUXC1}H|wASI%caHArah0PS* z!jp9a6w#V)X=nhX%?FA=Gs&a@nldTCQHlU)!88r0P^%!?~ zH*&|juErv>vq_qK%vMF2uWoKzGu%rd{{U@?s`3!ZG1`h4VQCC%^u{@(I5-@dO~-E0 z#URL}QnylIgkbK$_NTNUjO20Gnt&6YNvH1IFgQ{A)Y+RU(@E$tfWQELG^(YW+JFl+ zJjt+a9eruDI3@8*VpA`YyHoEU(u*r=yW4{mq;Dgz!)+PjqPMq_=1_>Fg{~&!9WzAK0gc(PKON5FKJ!bBPQA??S@I_oi?HrVS3hN zv%3;A#Y38vh3A(&M|NXdJ@z#Hh7LTdxn^6*WIuR;?NAvQ{{RvE>A9rMbtt8>K7Mto zRD9EuY<~9jG@FUF+Q8ORrkc9k>%(GYPDx8xnbcErMrzJs)KX@Q&;rp-%^9X5 z?W0?Cm3jBAIN`Bwv5M#OP7*ToVm}(fr8zfv%EzmO$55pnO4O9R`kJ>oS!Ue;P(3qM z4xe;8DPJ#?)>)UsL3z;)WW zrj1hlxI#(x8Lho09~tNET6MMN06#E720t35DxYa1nx!ls{JWH!^f}jxNWa!b>HhG= zH#KVF_fxr+OM9z^b}mb#otmbPMw!N1XcOx7Zlq)JI~?)C)TsXebes7Z`K8TmLE*QZ zg01boPi)nhyb-F$ADJG>SN)omh^F1HYb>`H81pzg9PVjBtyS=*yzPY3XK!${v-nqD zwoUVCcPhT2Gg_QhW>#rIqo}wOa_-Uz<8z2Gc>uNM2hT(D#TUW zeMUq$ljdL6v$IMKMCn4Jw2{|^$6_$Dy(u;MeaAqTG0Hwx2iVsqsSTIXfB*ry4@$lq zj)tmVF7f7dIKixGVU;G@XMSOu%NDGfXxFlx=r8?BDzZdes<`NgG1@P6#}!4un!|&q{Ps4W=1>;pl(5eQB;?~2U>R3^`?(XQ9uUKM$t<}AQNxBCJjid zxZ^maWn?^xb^(-xW}m^Pkw^p-QXaH(K*gm86x`C#A#<833B@NqlmO~8ib0xsDb7s* zAl!NaY09iRsn6284-I&iOVfhGf2Bhr^fCdHUWsETgf+;=lLfxx{3Kx2sNbnBM}?C> zY#v5y-7fqEpxpvi6CQi1u6F+b;ao%(vbyK6YJ7}2k>&s(AcMP(nCU|f4QlHCAHUG& z+j9xo*~d!DBOsca4&*0;Mrp^9?@gpJ;mDz+%8`m?27nn(R-`>?DGZl1Qvs#TF%l^% zb5;S!%~ao0B%`GWOp`Rbu}#Q5=%yk;AsuQ(kRJG|^qHmv^A{lw&0dzJX=b>1OcNhM)|ZE&4Wj@+LT8 zSQpwI?TcdO)=2*V+Q%QAR!N>V2bE#maBFtM#k!56h~7oHhx?Na!k&+DYK~>0W%m>* zAdWI?x&GJizM_QRX>V&c_wCOgm2x+x)Lp;XLwQ;GOLa9eNotCVzJ-e$%|;1R>~cu0 z*eR~Q+Uv$QaqMj&?vU}BBG2nwD!CXTh$GO}t(S@Qoi`t4)MrHnj8ikx%b-En3I-kOq#Pir_R*R?D1bhGsd)6erKG$wxG2C7=DfjDK<<;c3 za+xGzO=C4GlGkI@p<0d-llE@%WOp$JK4OkfTC5H#&z?5m)pr1#t!o?gJlg6F^F&;V zUMfALjDbmlDvn}dfO+Xc%Bb9POh}qfrC5&LP~`Gy>IQ~`qF?xfQ(JpD*uPTUm)^Y| z+u-pSd+Xv{oSn5-K=Hnh;e8z-v9f7y*k)N6VcnH+F14!fiJ> zj%VqE%~hA-6`|!WBo&?i01H;=@@*GB%}RbO-l)RbFXCz5BD9Ci@PUu|tG4`Bv+lkV zUt7e|8_0r=?lDie_^+$FkrG6n{cD)i{9UW+nHM*b6+gnK0+Zz$Ovb;kHg^(5<|~vq zB~C%AiZXfaQ@o8M0vC?;5dm0%Su(&992LkTp%r{;`j}n6Yn%`FjaP^&k9wDX(wYGt z`u1PHaVvdT)I`YLOCPOE=8@@1=O1bWG$VQ%TwlSce?pc}a))3YZyC)T1kDm`h1i=0%kMhP3q1KN$n zu^-l^x3ajoby#3`EN}v?TeOl3SvUDBG3+0ptIx0B9C>mqKy(qPTvaHpq_+ARRv!&K zMR=i&s=$Z5jf&s5_+x2kyY+2WH3O=l#c}WAooi;(soZ1JeP&$hS63vNt|gHF0JOx@ zyilzsdT_n)SBBRX@ukGe-y4l{-Xih*`n9WB+d{D0Fu@+8xN_vu7R3&Ifka6-Ak$A? zC?vV1=qobD=9e^53IJS+H&KC0z@P*Hs~J@01kuUwOGan_MdzB66vZG^i7%GnfCP_P zXbU!)ZPn`m3`|%1#BeGrh`!AuL`Y^F5-NFhi`ioGyyB7n0ChMOK%DYvyL1w`DaL8_ z9Vl;FLmf>bmm-Xc0Bsp2kaB1}c%%cfMK>ahngD$+DFQxminVQOvJz#G06&Cxsg%@J z&8bkGNpi&%vJ_?wqnIW;xQ0?Mif$}z=3?M^Q0^B7@V<#0PFgwT;DP}zs zR^(PKZ4Max?bjW>t2&d67N>3#2U{5{L1?#q5u>GB-pd3Jbs#AmK_HDl04e7u9Z%M@ zjjMIVRncTviB@h8OxEw28+R4tVkap|=ji!f8kQdq7)5&enC$}!f_TcrNv*jyV>uOv zt6iW^Ee|G^9x|Ooky)L3ID9ncC(yZ+unF z1udTKeDX1#_3U~jm7I|$l&Oq*Qn_)1dY&rU9;Blt(of2($*0~$_wD2#@EZDR9U9%# zW;H*BB>o$-kw`Eh{3yB~B0gU#LBRwcdMnp_Y2fP^?Vfm}5xR`zSCK!;<#W*Dorr48 zD5T99q#YINW_HT~iHlK`9ofugjMaU6&wUFk3^cJ?+Ulw*5D38}CCBY2ZgwKmdU z7~wo^i9+%CS0kDzvL7_Nk~0=!%tajkUJ8y|`E{VUl^6;3R93Yu^4Ed^ESvBL3L%2#nsi{oE~rA|C$rg=#RU zwLKgLVOtG7HH+PJXJ6qRRBF0tl1n#%hxgYRu7%PkTrw#h;w4W z#7#cJ2Xt-B2Nx3Hv`t|cPiY?G{6R)*%sfl*ep_{U z^p`B7pDflz*Tx-WU+=a^{D6MzcdqL|_`##z+Xd8**`@=K!-HF<&I*x9+V?yj>e_27 zm$$f$qm>RBSX4mQWAP(d(lxDdE;PIxDGtD38sjrmVm~ywre>EkggTcr%+ltV4$UKB zfd`?a%^9E!*%ZSm7|8x&hmQ)c83kMO2hz7?@aCa)pi8X50ee^dWQI zeqP7A)HD&A(BmG;Q1j6AKC}npo<%+v45l{cJ&$^8$Fq@=zWqnml4VL3T+3kK^faG% zW4$+}E^3GnQ-SrQJoDa@tsoyoHzZPnng%XvMU;*YBBP?1iONSOAni39MCjxA!L)!h<1Lp-{_t>u+>OMZz5ktuNKWo z6s9)>55YTC9w16pdNksz}G`XhHKv;g`OT7BjbWkf2Z$7k}kF5xW-Bfia z6}i({oG-2@RU_Obg{+pae{osmFO1U($0M~jJkm3E6{XI59V+UYCFY7^xv_XP7{|#p zE%M3r70)@&2^A8Px}m$)r=+sznRj)L7c-jN~3^#l|oyP^j&K!AGgC z>%&?Ph9tLHZtpzV`>8xrP;6e&Lt~A%(C_Z7-tjHm+ovq};;FO@ob?s$y0)7w{+M+A zF7n#m*_RmZYlGE%4S%BBnQkvFOn>ilS~yt6PUj_U3d#ryJ%upJ$GtbL zB>+2l9qD(I)YNp80R7mbbueU{0ZW1pJt(-;TOCwV-l4lbVX_ z#@-gNLM?3)MjZmBTBf?PdAlA*9-Df^Y_yrah-zlgwIIG@*~+Wx%ZlqYKZuu?IZGRO zt&sE~d9GgPRlU1%)7;AB`nMFCi1jI*I&+>B5!*FUl*YwK!4++?c~U{|P)Z3Kk6MO` zL}2koX|%M4E@;g+y)P61XEbJ%alsX(rRcXBwCfZFS3TI`l%%4r%_&lyS#m*LnZVFZ zY-_$BZ57o_>nS~P+Ocs;6H`}-Rq*vN^Y(QWn7N~xD9urbVEWP0lmf>b3YsK_HVq&$ zWB5k`n1%#0;3RFk{gIlSX?LY}eUe?irEyljwr){2TZFeyNY@ARs&if3PID~MH`S@= zEl8dhi|>Fx8jSN!G}=QP9fuU5n>-v*v9X<}6y8q)m5}-6+zH9Rp+b{}I25?zkPbxx z6|hgrIHwJ<;E|W~^rYMscq8jg-Tl$esi0%FyseUP?rO|7p}{dW=3l(s0H`8{S<3_j zkTPm}cpVq!IL~TpS72$Scd@f!C8d&Zcg%kCk<;l~B&^ZoS3IJ(EkRpRp17_YWf;cO zzNgu6?ml%>!#JfBx)F`a4%31vA%8j^9<9WInC7TnLSdKK)5A&EbC;jv|bj zOGjbPsa!b5`l`-Y<&I4>noQSxVHo@<`3l&o)&BsCCdJJersl5cx>eSza3Z!$wQ(pNR&*A|gRPU1MMi-{pt!qwBP z=g`kE$|>QOH#$8N#vVO`QMY(3^4o?pUSdhyNvkUHm8fMao-1`W^gL>~bfe6e%3RYk zMrzJM`J~M^G@#G|@_SO1VcM-*gxk$aDlRB0Fml+=rOiyxd^bNUo;Q!d8~i zHWJb8<`T@0EP(JN9DY@1?(XjQ9&EV-fVtp(2Wqb$#9duDmMdA8xOj&(X*_#jFZ_P^ za@o&w6BRY)&kI%cKF)@Jfsfg1^ZveOY>^VDBB;q{8=SOCew-TVf8j3hqmW<2_dxdx zKNQpAuLx)UMeDQw0B{?7ySH)fp&&}bxtbf1(B4qRk<%*XoIOL&I2N0k|6F_rmSUaR$H zW!;a3W?Wlow~(Jvas3T*cRDCWV+_A9VEE7JUDJ5i!CC#^hEE^fn9{G0yefy~@T>>@ z>1q?Mx0m2=CzaHXyG8#1;7k7il04YhPCtYnr6<^@{{Wt5y*Yj%cwjgu!q%XBH~#=y zuP2QDA6|eiw03}=raV@j)}rnAGl}5vZS5uK;{O0s$o|DY_YEkqxIe-_I`&BHejn=x z7J9eY-1JF_AI_U|@U`YsCY^h4Ivz$C^Z3&C^|~a@qnBmRdC7X|`W`~MZ0vd3J@Z@o zUXP(gwe=aUZY2Kzo=7$)=hW7&vEe)22!nqFks;|PRs6+d#}Jz$5Lgf5CyJMfsJBO4 zGCU)*jGOdn{)cU4;(HAi0Gef$t)K&jRr!zORPVfRHQ7FG+=P8_D~Y|jhR-OBC7Zbi zg{*02d6=}0Skq9eTUom!I=H+RUioOjN?(1xf8=$So-6>74qd%XbC-IB#p~{xLVdHv zQ_UHz>ClBemZyu1%`q6gChWT{hh~aOD`U?cOPXyh06R3frc%%YsdG%t8K4Kznr>-x zKpx-li^O_Nz8{yv*XA{lyJ2MMBAVlVB>XM7&~7EwbZFXrG0x{i7_VIJd$=i+v!V!!zR0}Z9F5d>v7!K zNhXmLieBY*ZcyLsisZFRYimpAipu4#ZHL^IlWuJRVoUYP3bTpz#BO7y- z?kT6GJzFDdboHjvdy^STF7XkRFx;IzDV-_%N*%~}sR&udR|_X`*wpJC%`B>G9s3X; zQBs+ACJ5)IeQGQfIK~YEs>zV2DBU4w#T{tP1P3&G(Le;8ckMvJica*j0HTc2W|xsb z3q>}UGyt?_lQd8R_qH*bW-~<{^FV~6m8mEg1B!QAZ5hP?NUe^wAUUXWkxB^$n2Bj9 z3=I?rktJmMRKj&(%~hhE!o`AA(m^W2C=xE{$>~t!iZ^G2Nu}i&s%cBNmB3 zN}$M8@lpmOE1sPwEDDSanuMCr)^d#9(yT!Mh z3CH{Z(PkG#LK7SlngbO-D-rZGNffahNgJv3VTz9|KZcOYNqu!5HeAfO^m9b_*Ecxx z?j@HUH?cKWeH(=r3l7Z~&lKFzngC9eQkp3M1B!M@rqMtS!J`0orqN6X2HJ8d3ucov zl!td~4$U@~r&>cmgA|nfWM-R=d7uWsnp->$1vl$O02F4DoCYZX0h)dkFCA&PrKSKlrOhQ20O04=oDOO#GC`mT>1rV_ z9Ew9BJvgG^Ojs`@)G|K*0HrXJdeNRSMZio^iUw#reQ5xMQAHfkG4T*wX0#%_Xb339 zNc1(C&T~%$o~Me5M*E#ud_<{yJDOMbuYUk}U76Q`S)FJuNWeH0(tRj|c~y}(tV6Fp zd1}QxQATMqR&xtRRX^^1$WX3V69#*KAR! zJ=~0wRq>ur0)+sz7wi@vmTsh+)8mFm8-T#|Jt+*X7$`h1018Htii8B8Z15-nNl5$o zjrt0RlE*Y-o;mlY;Z=I`NMiz$d!Ip8;IqjMHw*pI)YY9RO?h^<(IO4qTO6nr-^1|b zuj~@zPq-!V%D;M?z@WvyG&7q2ejQU9(y_PA;^RBNH~#*`<(i^48dkY};PjfiS<;zZ!WyE+i+3m?BimkRpJXOZd%{@+fvz$4p)Q#fG^FYxzsIA`! z*y%d1sFqrb7|Wb1XBn*AJB%>msoX^HIFSil9D+Mnp-&Ng8S;3{p+fa3d_R%yqu~CH zvwUTnjEtJ*wQmb+J|3ByO|;Ady7jE@2mDsQ(u{U`qZ^A+fFwV8MSF&usafkbOLJ*5 zO&g5xb6e>pW66&_33DUCTgQ5xkT5)3WF2>KYa0Im#rl=*Lp}lYuXynnfb@S5MBZ!y zDf>vA8u9-C5d1LKw1;Q5Pqo{Qg?{iADvS*!kHmC#^hXml)YB4O$*6PdQ`}kITM{R? zmNGi-QYyY{M3UI!oaZ-ryN?E!G|bZGnFF&%X_=!m0PNA4ZfMN_NV2+gJX4zK$fz?$ zX*F`=Hyw$RcP(8Gk6`!G1l$2N%z{N)wbU+c95hZwD;dyI*!1wZoT=#}D>P=3lC?ac z)KXEJ1}zksqcp&E8K&lzfeV^SDJU4Dir3QoO|0nB2C&p_A;<8CB~Rg4`J*(fnM!hw z%=L{c<2}KP?7kq<;J$$H%%B2C(D7ULqv4l{qGhwZI!(l#V~~^?`gHuO!ZSu`IH$Q$ ztvLKH$EWI_2DM~%mr1{{zJQ#mNkBNReqV-uEQyHz%P)@UBA@GAymyx|f2+8aKizUF zb=7qd()Q>6{u-k)ZC}IMu7uI9r)4F%lkRTsS+#0w$?lX3i6)aBH#s=`>boKS93N@~ zH#E7V;2aQC()|u;0J)@>>g*!p)Atsn6xN{r(K0KeDPm_M1drKyYc<7@!99q^Dyvm?D4-(}B$}&G=NTNGfRU<;XnlxxT1g(iaJq1$pILrtbh=D5#FE& znsqT7x_^l7>~4~M=3<=$ha$R__^qjdkF&r(3iFyds^(U6rQM!3(N9>N`V0?K zLJ-fIlNDpg0Q|>4N^p$_K~I&1%DYW2!&hVSbBPq=)lFFzcJu!L$Gy_-{_KMWnuwgN zWcg;C5&LGfCDQL<8;nfL>b%qoA&JKH&O0!t$}Ve^wmGF(8IAxX`U>mx`=1NmAdgYB zmfB2X%!uSvxBd~gcum%csYh~vXJKqGr|kO+oh{BWpk-_@Dt!p1n3#Kt(}w)p-0i-# zTY#qoHwK$~C8V>KvyG#Sj#0ZBn<3oG1Dw-^47*s0N|J@m6qHZ_N;#yWm=dg687=^) zY=wHcW9%vn(UV2Mc`5uVe;R8sKEv9Zf@s=(XaJ&(qLeKl6DPGM4L<`EZpT4D48;U- zPAt@%ng9j|P-rYq9jS0T(UtU~!{&Cd+FX0lyFCUe2M0LK0vw@F@c}^~4XQZxJxv9J z0fooXlN11$B9}P>fuC9c=h~A#pPc{)Jx*pU)*ecd7O-3rbjj zs?+yZL*MS~Ga2Pb$6E7`5oyrHBROTwbH~Jbqo&b&Ha$00DXy+=TQf@Tea$+x<27p; z;4-?{XRh9;#U~1ypIqF6)a-@>SZUKJv(CNAk zldkCUGV0L5b_Wp3ahm4utlHs21A;4{@E3#T@lEXZ^2H2R=(#sCXCb`?2+evFDXFWi z&zH=xm2mTLo{)WQbBw&Rmd54alnu&pk;pZrpm?8D@a59YV{pp3`J*Q)--UXtzYIJj zVi@XvBW$l#RvdpbSr=B{3$%9s09ku{EWh zfFJ_kKeUKRh>PJM|1Xd8fB>lY-*#~^F`SD3i}>Gv003^q|3y@O7>f75JnBLGf9StW zfEs}Cfrto+h>3|v$sQ6FB{?}I6(cpxLt^A%U}1Q8csRkF><<|V;p2lqm82x3l=Rir z^`F{4jf$%M9}t}X&mjE(8e%*Yp)wv04*-`22ag8lzhMCT!^;!k;QWsQ{+9>-oL#GN202dec|4xEOKuAFF zup(Rzy2;aB(;P}t;g&bCM%v3Ja_zxeP~Y{A-e1H>krc@a@jr^_+Y2;a{Lh4$qx$WV%(DXbqgnNkztZICFPl@=CBa15Xuc>7ja z3u;$F$y1CiSioPyBJdNB#iFYQWYrEUW zUZlR>mWziTwaE-o_i7kW)>J(B=gjy|X`lREmL)aWX!)EcD_6=&4E2wFTT0}c)NPN% z9esoYUhfFsRxdRsurLZeFe#xFn^}?exN(Z|1Na%?SeMj&`b{%T zaBuEB@$${t2Z?>`x@T@yRFSw|N^uijHSd&vzN7L{{-wR7(SVBz&kg|{rOLt(X%j}|aq9&X6rq|7yR@FV22 z)YHS0VY3YlEvj>t>|Rj~JdSmF9wwXhLf-_1gMma<-oPp3)M?4WbQSV{+9i$GjnFAI zj6Lbi9DG-OG@B~Y*59`XM)9Zn;+ADZ8YIOv9tL)^r93a};TackZ$BQxMwSYr-gHcV z<=uQ5_vS!JjDor{{oPw$ZOnabw2aebW_$IGL;ud9k>OGwQM7)`yRI^$S}0$~b+7fO zWHLFq8t-&Q#%_g48U6902r4)*!em7FyFgj~nEmW1*1L~QM8Vo7!+8=gXREQL6YgBA ztF8%;ZHJ#vg|DH~-*d{bv=WP|6J)R17BdP3*6!#0?+Frs{*`>RX9mCZX4-{RWwz+O{kyM;Oyl~Fd=qKYTP*c z@p9X>WwU3JWQa_sb=Zpc1ljTf4(bY5o&*w9%y@|^JC0fZ((N5oW+Vl#xqwO49fwi} zQ|L`wg?*;`RtGE{%dTT}FC9vm^@{!?JQSz#sSDq~7B%35HXO}~s=H2(l_k)1laZWJ z`z=kC4aKFUtiUO!GoV_b*Io#?0zuSPjP3i>v_-52i^XIN-#(&ytK(SLH7;hGV0w{@ z0O<;32gk<#n8?cvni)`L>l3=Wq~N(zu54B}8p|cSkZM4vR0=djDhe{o_L#Sc?S;z& z%-1n3{{VBvm8lvCTMh1KF0Z3G=^MjAd73)&Z_)*`9q}8AgfnM=5h^9z>2{v!^p~$_K{J=@hErRKbT`;Ahkcg!e}rOrc9W(_H7owQuand zrH?)gWVjwKnLP%yZ6u$JVDYGW1ZV(pVCuc`{AiwLPDavI&&;OH2ywNvq;(P_3kI1WmlGfk6qx z283ipq|k16Xo?1Pn*wFO_VUW`(rd3Yvx=>6;{B@vcI(@_Vv56+#$vJ-e&{!AL||7= zQjeNn9~S@SBlgJfJLpFTGcUH|5JuJfAo?-JvJoB{S4L#d+#$Shm=(ZK_=;n$H?~W; zI9F}$zT#Z>g;6z#s)S6Q4GYw4orIdQA0s@FRoKqPQq3*D|z;y=!*j z$xO|P_P-;%m&C#usEhuJ2Ov^ic{@iEc=41_fGAm&h~Zt1 z)EYSG{lkvYsKtKM{JP8eiX-Ny7@6sg9$DGOFG^y9EQtA3vmtxeCHJ)SWeIU5>DEyv zNkycd#+`NCXM;=lm2sSLhP68po^l{&Ez1Y_{F$_KKBwGoc7Y~Qs2UeD_hzDUp`^v) zcB(kCa>GKPI;bw2OeYVqRhZ6B5UU5#NjwPGFF1HC8CeM^=Jt}xbl{We)FQ?6T`g7o zJ2*OV1Z)!-`(5WXk%2~gK7RFx(|KVG_nGh9mYBM7$CB5ogg=`A{^Qwg@j{zciFH?Q zFN(=X;&#}?sI)6}>dud->&YKiFD&^ijX=NkJb&|udD^sVZOsoFsDpAI4YW-!Vg4E> zB;dZVeECS@`^)sKFPxK-3K6pH<}quE!Ju+-7O~!`dRySg5DiuS(BJ8^n;B zx9#hHuimKQrGT?U+@w04^>4;Egnz%0`xU(5J$(0!w=_R4w&tHo&zSZkPSAC%$Wgwb zy$n>skBRk`vCmHbtk(u~J`Rxe@g-f7Zjv>O79%qPQXu%5@3ji$vf-5rR9FLt!qHQk zy*gYASb0wBP7jmCwFZy0M>#tE$g{f(y-9+HRn-R0v(@MfqjZ4OTlEQ4{w?$d2cW`C zd@_>xe4DN~L#c|VUXH25%Oc_~;nfD$7&>K0m2^>CF7sxb$scXyiX@`YaCPw;YvMKr zUOKsMiBE8!0O5qMlmXmc(kxX`?CI6n{DD>cU5mJT9m4mgQGY&< zlY~Ok6kGiVfY^rX%`0JFD}0WL$VlX{63D4)O0hUd_a=TlCUOr!Bk4`G*NPV~le)`A z#$R+-X-Tq@@ptG{{gspMEo}zh9@?f@ljXZ&T{HO;sn8~3lUL>3cXnzU-dvtS^AOL9 zN?{(QOwrpI8YLc&ym7Udazc4xCY|;03_w{P48AqgYBnuj%0%>*7ozZWkDtYuWe#9C zKEIz%>cO#Cc(IZ$oVgNFurun5t9s-huV+A@Kp6nw5gGddXz5IvI>|VgVqcrVM=hau>nNdq26v1L{04LqtuPp8Qo)4n*y&+V`>~?pfPOem=5L?^&UvDju@3%r0vXOvoLwkEX&5LSSbFx4v8P3&H z1KaaKq4}S`5m;j7)W7~2YY8Rx6F6Kjy&`s_>UmH9T_DCHs*%0XR6XNK2>ml9vm2>H zCXG}NFtsd%@av)Y0d0@$Ix%~*#$EXl86{*!a_vu2!6lArv@WT&g9=7c<5B!-aB53} z?^gi6LqrQ0?(LbKx8JzLp8;Tp!{RN*ceY_( ze+SDZXmTW7U;0<0Lp6iuZ;Zd+t^>6QfTmCVHnBG0%F=DJyCCHT8VxDaBK`r+oa(#vVE0(@)i< z;H)Hvb@`{!J;yE$6m6&o-sg-+QuRzp1X3_~thP=R3mOWuNdl0|gPsATHnw|z6PuaA zcwH?ERXo}^TrBvsZ^`F&wQ||l4uQH4vfAB8(670HafwiR=_ev@}g9ln{;~5Pj@>YgxP4&$yjNd)p&pLJ~pLMmi#-L2EG&;#3g+ zT=z8u6v(O2P+>;wCLv=_DqunnH}nuav=VJIRxh=#tCY?872;+>0rp{{3g5C-HLP~} zR!CfF-gW8nNyI(ciqZlr0RV+a`Lg$I6&D4p9bNCbe-p>k5h2bAvbP9jP$)X5N1>## zy8`hQh*8h0O!cE)A77mJ5YNM4SH|3vQHhEvg!Im)aZ!bM$ur^vo2el9V0KRuoK*#| zrV6p`aGblTaZTVzYuq)IDy4vkYs}s3>xS-QN+7v@mCc>Lxy6us(tVdv?*v1bry4QP zuRUV|6t8PmzCYQ>lhzgggIsg;^2k3~$}i1G7C~J{qd7?av@0(Q;MY8a04coI80KTj zQ!}knKHt1yDD^d3l+v!wrvlgGW%m>dExUj4Sv&B}Oq)HxvKw61r@{yvCKI=Z4(au) zTi(YA?tTx2)L#++_v+F~hYDSI=EJ4^76cHM#tgs!;>uifW|n6CnZ)GupSQ6T{9|;0kQ8-&frv_qYEm2Fcz>Tdsr7KFV@S?TyN8Wp zQGz&5PulX+OzVj{UK)~jc6VsyRW5X-*id_8$;j&T@8xyizY$e&FKaT3HLL}fGDCZ| zqVfx%=^q%u1Coa4+>E1>o?)xOR0QmDccx-eqmRxDVxCXtNK-0#xV6yIw|cQyCwFR6 zE18`8=IUqnV_i^jOX)NcqzW9+gQk_EVaCVzW-VAU-v_j81N;^^>Q=qw%u8qBxZ;0>rNm zfO1tKoV7*l>uv|zWy_7BY9QMqg{N(5mf=i4o;_K`y#u9gzAH_xsSC8|D0or6hUP) z!E-jxpo$10508Ou_GiD6mdx~%KJpPp$+aGwBNNz6+ljkuSFrZQM8`mJl&6lJZ4O9n zVk8yS+IRilf49p(w(wx&aaZBDBwJP9OuCYvx*kfB?@9B?3&$BX8nh@4{^^vDF{s>9 z5zj@r2GUbzX2~~Hf`Gzr*G+!FC`TBkQk&R-*%hJ2>+@Mf3ORk#l@^AfdV!^L&k|no zjho1(%n8n-iZ-g@8@bOMh43$7g@Ukd2tfD5$t-E!Uc`32woYZuO1YB6%ygGAFFkO| zM&uc{9cw&bmqf&%I@A#1G+#HYL0vA%&67&@M2BbOq<`+`=q0gfN}_dj36=lO8>GAT z24j7&Uk!$>E1^}3@m$*3#yg@*ht^5w36JB^1fcP|yT1*SYOq<8% zt7Su)OJA&&Xl=-1OdGFt2cT6!zR=VtMB7(4*UVfWUj|R;;LW!t_lWM-W`d0CMy{@G z)neHp@-}TJBU#JE`^oqSYo7T+UI3YD;f5JgQu+rbTl3&%Jcswh+v@jKZ^=ZE^(nWM z7A$po;x)JyjJZYi1w3LDrqgGvnbz>FdUcjS1mx{D)PPeK8`TyjUu@#JB3nZ`8nxmU zq?a9Ian0#&9wt?maclI0nb?I*S#(lqAQLVs51{oq$uPY!eZeTty#Gl@tw_>I6ffkZ zBx`u(WzjDBYR=evo-TSz{d;-t+|$M!;Woz6?bTYXJT$!NyLhGK1hgi7JHpD)V>Yu^ zdsW+Z(Gh3dOr`lOyzDZWtpk0&CnHoIP>OzT9psz<`jvU9`DRIimd7>x{7JWR^(eNm zZ@v5Q(*GYQgL-$t|LnZA=Rbh4(}DQBvnumI3&gp)wb?3D zIbD6_KY*~Jz}CvEpj}Visi@({zS>sb<9ZuN_FPI~n~*KDeFG6~J)&)2fv5b03g7E~ z$c2=W`@C2=NPgVQa9o`5p*IVGQc*Hb{wpeb1}*5lYIY1>X|4atCJ(wdMx}T93eJMz z>e)nA>7)_>{JORuN3JpRE&L%?u+zqA@y|A*M5qD-_}YDhQ#jLpU)>!7IJl&2`E;8mQpVB0w z@kc=Lw^$#0M;;|7dc7@R7`ck? zLs~03jhs%W_+iq2sHoDu)19%N&3~TI{WWt~4juI=H@co}l@4po68N1qumm-D)RuAR$@#VRnAz8o%JHVeoBZ3dVQZ6!^Of_gj z1rSr?HH5#{?f%M67B##F;Eg~dafD*lY=xA98k*i}KX!tq*4ZcYEGLEbJ3T6=TPe;n-GO2+v3l8K-s4dFzGhGVpai%5lU-Ftb;W1Kiv zpcJ{m`K>7J-zrT@@3b_P$`0KPHDx&lNUo(W+&E`PJ>Wn;YO%9*l64mUUqLlblb{8Z zG>FlZ6AX2GCMs*h!QFcU@SfNcBv8qI9zM1-pe;uaXDSZ>N(q{|I+iW-@J@9JCD97w z9~H}2p2t>DYFn06!#1Mp%ztaqbQU^IMJc}THEsWAky`K)R1PC~&#Sd1W zafN)^Gu2HxZe^jj5>ebt=og+dSH8Zf$r97u=jP9o=Rualw&5^>GJC1f!M;0*_U-eZ zoqGaBG_==sc_VgkvF60UN~-+9I*o3V+>SfmBpnifUuvm`_H5m}`D;%&9PNaX9&)Dk zCU~KYa?xW^(i)7L|C!bjrWVM}A6L3 z2^g@%ZGTjAw2W`lmN-0(Qn9C{MwgYL8KftEKKzb!ND%c21Gj=Fq`W#KRgZ=5-lSb$l|z z1(1fYnueOfrD9}B2#n}+HLl(`oc34X=@&I!0MDC?*6bWF+wG4!1qZco>_;GihUwiB z(*3W|`~|e#c6@rFYIbjEBqk!cTiu?tw7(=K<@44YKiuwxj4IRVqtO=mf1j<@vlIz% z^bIE{$Vv6#wIt+(rSmOYnUHoxkQ!d8I=^QdfPEE2U*?~Zj^((7Q2ATBB+lL$zM#P! zP(IT~!+O}Qp3)V1UNve^OU3f?vtR38_(1yy7vLu2!zGlet7M#{E(V!tFElvU z1D~@IzCvcN9YMe3Wno9t*b6!(eXr^yA)&Zap8E(H5|I#E88jWs z_uujxm0YML2^}YNlcA7ng81|n7csq0<}Bdci1eH#JI#Ig*iL1g-gM_N8Jo~S1>ivV z(;FoH&AZkrmmR^5(p2%!-%GqlUW;*6bY1EeU$R$w8#jZTI^`!;-y4qQGb&*GTf62T zKV1-LA{6zx=2G>e?0=m`*_+p4Sl%_&O2$Pdl1jE;+S1#Sc-nS6l3v@Z5J$YRTBv(G zD}-jV*+3*pGXPVT+FB(Dl=^QN<3ubKHKu6gJBE@Y$ix{XGdW+J4UC3!PZ7?65B!2c zI4k05x~>kljC_eKx~O`_G}4RkleAD*23_SADL>%WEOeJiE0*mvUH9VFK$NU*+HP*} zUkBi-%hc!x5SAOh(;sQgzi{}2S>}b%blQIauL+|n*@6$^>fsix(!$#kcA~ruuootc z9#_+hnk6-7Z8|4nBSJ4>>Lvuv9h{}b{0c3M$iMlYzugtrxjV=Y%gryZ462-4#sQ}4 z_2tBqbWet2o=hnYW}?&bnRWSRzvl3B9A@KFquqmg^G=>$CelQnViX9DZJq~reFX(F z)_;zV=OcdI?ply#p|r5qL)23gLtyT9amA;0S?gn9QV>(ji^g8MWgBKqY=vuTS|3u< z<+_lGphMRP++PQB*NdtI_TP=Sz*RAl-LajXaS1)LTLug=Z^_XY40IOBgS(@rHPqyWKZIOl+b38bTIE7j-U+-6 zV5iS$HXLqU6==JSV^H0ItcO?I%rI8+jyVD7V`AR?1Up#Rgt#?d(doao0Oz78Ox$WF z1OdN{Q@V+#@J?atQ-SnHg=0J&jLJa2WcM@#=KQHW@F|%m80t8V~O!3yisol z5G1%O2?=E886l!laZFzMW+N;SJSOQkx{6CNiFVz=vIz^#Buno;0nBToP|+gxk^PJ? z+}L{`@6ba@>wTo5K0qrtd)+dbPXS(EIoNqz6nh!)8$zqa@whltf8$NR9=|yvl(8(g z)%6M3u1q$UK#IZf9Zd9!zoC1J-IVeQOBTl@} zxc{rPDwNE6kah5w?pK-uUZC5Q2o*@S)8^Hd;ddj_FgW#ypf?Yd|GxqAp_Qk}kE$iH zoN!O^Z=Xy5ZD|5N9|cZ#gR1DA1pWhvgJlZ~tFv;GWv}MwiwbY1`tMmm8UCOB)A!+V z)V$%35LZTtLFLeULT-=1NQMLAD)}UN+cw)`k4JM&h0u!q671{Gcb5d*F=R9y#ij^IvSkB!;+D+ z-`V>HxW=!;LpaPhn#7&O0MHgjK6v@*`_xbKnUl6mHt68UFg6aQC$LWaQytGwsT$v; z&pn;Rc1GOa^yIT27Kry9AQbTX;0}WE7~#XLL!a;dKjz2M^~fSY zGn=^`RZ)G03mLHYs^N!sNt3Zk6R=D(-YK3KF49;DosW5VWAI;PUcu=Fe5f-IVsDCl znzzLfo#2JGPe(1$y0q|^nAcIG4J*yi04<5pgF~e~ozI^;Hl9>^kUs%NuQ+A3HDb!% znO~2LW?YAuW<9fD8~+jBW_$D@d)qP4nR47e!tM;bjs#^-(L8-M6t^?JDk z{OeRxnCzasMv6;&b=@oyjgN_=YP+?1VYK+n#a4yWlC3Vl(N`|dqu+vMy}<1IsnbXs z5(Nien#Wcyj)F%zabvotdC}As<d z8_7}Nh4GUo(M*VHc&AVmWH><=os2I9KImuq^IVXMm}kM#ATWxD04rj2TotY5rK(8g zn&wf8sk)}3bqmXEYU!rgY)?Z#eL|}=}b8F3{zGsr*ps##X4n2oq zCQ!)fF|Hu&HUP=#idyQAF(OpC83PiY1kwK**cps5UPv|te^h2Tr68-e=D z+{%=jLeViuazNkmyC?6q~zQMOo zI0`h?#`p$zUq)=3VQxPl6pQ=;g?mJh*4%_K9Z!b*b);sKb|8U|@yx}lS`Jq|&(J3a zpN0cJG$nnpF?Vj4>Zwq|c`U_E4=G%}+7svRIBpT#7J$f`G{7_glvYW79~uV?7wCb_ zaR|mxZq-{WvWnaQ}qRCHetNb1q{xnAq9WJoba1@F=I|+;%1)cFq*dF$2SZ| z(4;?*oS0R+aP7DF=l%rxuK3&zZwk~eaS;xO^`7xw#IM#~(2*zH6vE;j^$fKf4%?{D z8z0EZ`g|dN5{N_@SDI+_HeJnVlNn$ZJh9Q2Rt~?7X%2v82fa*$Dm-a#x%n1xjQCwC z4sx=2UqUoH#$wPujwJ#gqymgv=&2YLw{hy?)lDO9eObrH60bKksN<7E&!hOvuTLRv zNu-q&)YG+-dX%NCBd*83KieggDw};8ZtDZTnv{plf6Pm!C~a*cq*Xxf+NFib zcT_Kxkvx_*T5NH@B-r}{u@((|m8%mVOnA1;KN?wR^Jqy6(7=*0tJvRF!k|JR^QUIW z?Ce~-d{!j}wc&5GRpzJADfJk*=*<`K`LiKDSFR?t%P)sHtv-n4hW_H-Y34Y2sKRzO zyI)89X|xWKviukUjwxTq*?PD3R%t8>fdwZX(Dd1EIERFKxHuK2aZNFrrbksp1?nYH zEIp6sVgITJ1?op~<*pu{Y{dA!UqBQyLM^4)VFm{O9>Pgx4$3W`@N1*w$UtGCzfIwf zVs*`)PE%jjF0^$%aeyX|{q=#iw(T5R(i2OL9$%iT;9U33mD`5VclbLxc^7`2 z7zR%;A(d=FSXorBl!Ikdct(t^5yQ`_y|)FlsVqZm1?d{c)$hsrVlAaKQCe zgwSLMkyvlillRdR^7ZZ?w3Zg4iz%^=?qZn-l*cqJr27L|9%ue3n4hh$Otuo=#+&nS zpY`5SvQh{~G21AIrHm8BRAbYX_`*IAb$mGRsqvEVurfkfi-)PN{s%Zy7>j2IYYwzc zd9lzQOlTBw{9P$PKlc!_M!tnCD>^v!dgyXGNn8rz(@gv=~%nR z4#|VP?O7=K9aYzNzu&f&Fa^cB0DA6B&U%_b9n74gxY%v?xXrBYEbS6P%11%zo+v1p zm7FZQUaj#NFY}}$VfI3x7YkMDR~ikL+V|sTAzGTJYqFW4ygf#ImkX?=g-Yl}1H*{6 zIj@x<^Rv?4kFWDrDCzm3caPf~Pj{)l^^IDF>Sd`1LQ{4P(itsnC>*5^RLS+uXG~VkF%3^DR6RE2ed&){lK}t{>gZmb78kLHIGpR$%a)qe=py=tc1$ExBI_$C zjkGX;Hu9~(@^=nN7L>N6?LOAqlF4Am-LPVX$xQwo|GIe~KO3m=*9#w;78ldY+|gv6 z%_suPno zbbB-}K>a0{BSXc^o~Q`yg=W{%VZP^A_^-V~&Hmi4$YOdT7WFS zYI6LhAmXP9Mbaq~FrD|keD1?#dh)Zjwi%5I?Vx~3EawTv*3~UvrNdGNprW~pb#kMv z?q(aLxyNxm{Zyh?7=D#dAj>LbkOT6JiBJK1>&Ww^lsZ=r7|U;mb&Kz%xz)J2t;kYW z``91vT4bbI?S|q9cE-~F6fC@Au(PLBCa?i1E}3D8fe`LfCR+fU ztyvV+J>e*%*DY3TfWdhbQiCe;?u=pYB0cj0_$y8Jji=fILYi$YyJBc{M1hpeU=-lQ zP`_hSnbJUa0TUB0R8e;!q)eME`cuGHNC4OGm-dGxq1OO~%O18iPr?2LfJS|?>&?O9 zgd@zL=;fqW8K~UAs{S@$V26}QeVNiSKuY?mFG=LamDGTO>Pt&mAK(VYN zM3(rDWq(374VEGXS(8Faj6T91aisY)od@70;smI$87sSWr9pZt9%B!!DD6ctj5pm{ z$dbfa!4cplL_b-)qF6(`7{r!NKu!USYa%hQs90rt%RRa)VJRECi&M<6B8czn*~tfY ztPC|dqtyc9_n*#I_IaRz9i6Vsx*Sebju@&QWK~v9IVO{?L{-{S{{FHBP zY(n@RhjwF#rF3ym7WFFfsjWrIwXf=3J!dnLB_<75G9A5zlUcq-4#jYx%Pr0+g0v=o z0Fk?igPR`7f|o)a()RvBLbJ zT4oMd_&gj;NoqhS$g5;z*}vTCnmT`=%H^EWjO*H?b}$z8OXtA|t!PxBlMTg=u?qPv z{@T9^v_7V)IN#lAEJi(UxYsa{x2M63X8F!M)rkY2Jau+|nTprsd#N%>9(# zc5Nu~fSUl#ach{t>Yb!}8z*8eQrXn8BB%v=76Klbx7Qtq4Yit>`V+qqnKP8zxHiGvPUtGy`z~!R_)YJr}?s!ck<(>_g?-#ew;Y~v2 zLCn+b>OPgTBc2>X&h1t=!V#V2jf`#`tJHR0E%3f2bk>m9$!T*q_hoyFkvG}99>WwV z#KO+z#w_U{B1WFe<2bu_pU)fDHL;bk%fGx2ZT$q;y8ays2031IzJKXuvVW+44?9Qg ztw1*h{>)sF%4gEX1>52BiFI#EMJTVkI@Q0{<-nrRD*?e~oTQmt;{n+d`)w7t%jy??&T%I@GlTPRgHF`OnqM z(`7ho6lAj_7Xbi@ElWeo4wPKQ8mCEV>3HBLo>;V$Z(HwQK4D+QZ~7#WosKuKqSEdw zl7*YXaXa=||CACStDQ{{W}l8{Bn9Vi_|oc?>)vc8&~-{U0B0!*_f@(O>*Z=e=qqPL z<$cxjsVU|)@`bqFy$jQcRkVxtXiU;_7>%v~VF7#eVMR|PZSv7sBO+9D0OnJ9a1e6J zJi3+S;+|3PaW&vlUh0wE9A-;DTJCLrEYFY@Z@660CNN+v-h1U&q|ML^0Tdi?PH(Fl znE7B7`}?hDQo<;BD`iVQK4bc+DtSYw$B~-Sue?6PPGEfC?$vyeI4Z0%nKd%B`!szq zo8@{BKw%O%J5YIWvmK`UCu1s9a=f5`W@7rI5R@k}75_%}hhQ}G(1tCz@MgaU`^DIK zgo2j5Ht4Fj;9xoU+p3$0%5$Xx*YOVRXozYeOo%w^V#%KCx*^4^J4E#I( zLGijD^!L>xUxTx*WW6nee6c^C>&w1Q68W8}_xbgyQo`FvFks!2v8~T+S!C&Tu=U+^ z7THl^UePOv46b`XWUrJz^|)J96A-bIh0Bw2#>++cS@kTcS3x{GZMNZ~Ra?5r(oLXR zSy`?_6m&(44ywH`J_`7t>(gn_Ju(A<$!A{wczK}t9<7xp3DfrWw0##}#wSUfLAifO z6v4Z!tJ%Hp)V8Tne>7H)nifo`DV@-(j^JOXLh1I<({cE2)uq4BnyA84_^V$1cVtU5 z?l(BQO_9^wpYu5Dn?-kz&1hJQZ(C8~f_$KbE~EG258APYjL7u+=jq3t9Tm7miD#<6 zMS+~2b*{p0#%+bC>~_<_OU}z24w$Nf<F7A#jM|Vb+%&J${;A%{m$v~N z06G!FyYc~b0fjfR)&19kxCQu07wT5H#Gh2O+qML7t6!*Xx2g=KYzc{d$U2d-;kyf@ za8Vs3xG`Vc6>G^eRY(HRRnKh1+WfRR;ZJm~rzQ`@7+avTdIbqJP=)utrfd7-0^S2A z^XG5!OR9rQNI5qlGny#?;JPK=a@TdSvgl2Tk^t@+V#%!@rmGr`4c}={M}+D1iNn(U z%7!n^$S$ld?FkpiIPIeNn6aiUm(^0Lc;n_i<(#T6w}SaaysykxAxw`KA5JR(e~QHv z7+Gfw+kg=jw^+>vAh)+BC#uHQGKL0Ly*w8qr&r~+2@_zxIy3xgY-@>NlpiN~=Oudh z=>TV;&@2_R5F-b-Jp`jEe~NB+>BfW$?lu6cy%D$~_yT&`kO9G(G(aNn;=~@nG7pV% z1V8-jKzjny1`^dY#~}r9>P4%yao)U!=m5Y4W;xWuISbl^=u#BGQ@a)%n+midJ;N8$ zUBx~7pMd~y6Bt1hiMkX@1yZ6)yz7DZq!-QL7!G)C?#`n;pj$$cDvnTx?xZ#DuBSfn z8jiZNV-w=K)wIp@6KMf<&YWOci|K(^*S>BonVCzvRyVhw-!uuUYDa&Jsy{f zRA{DzGB}sP2RaeG$Rt!XHHy9oH?PiiA#R@yslDGzR;4rLzLK7lR;8QKcn;2@UwD$&CMlYxP2Dwi zr(Dn1V?FDepi3vnx!L86PA&MG*5F&=%c$zrZdFs2;&8V&8EVWuu5?)oS0u(p)vmj} zT~gg2c8${^)(-3>WEQc_cm_qW(+V2}ZK6+x4lkNGjhI>x3-jBD8;(1Ze+tii$E;}tFo8L!}c~^NMbT-Ma+B~yn z;B47#P0estSBX^rBOaNujR-GY*dp5i6Gs(DktkdI+o#EVG5ns}I#<}WGKfX~tFwU@i zBEpks9{jmyda`SEA*pt{i!ynM&+vt1{&#^r*KBN5Hn>2QMeSm%O+#;1PwL{+j2C7tA8mGj_y$)^M zcbunH6^;)H&as5Eqcr1<{i4FPm|YcH^bAFycptuqVV`o`a{Nhb9e%~zuZ8#5@+DMi z$>2W#roMVE+LH^JF~~V7;nHQcp*Ys1H(=m9L2$BBaLC8m8#>h5>f{ypy;MKtRZ;Ex zK#?f|cSjU|%vf8$)b0TB61BSv(`1TX1?bFkE8$I7^+aXv^Q02$F`ur%01F|ol**kF zeT3p8&S0a7g|+c2whv_gKuVuZlxk~rS2Mcw&`!{6n2_xYLrckoJ6h_a%OgDX=$!f} zGS3g|!_!9SUMAv3*&wz~0r@6$GA{92T;B(h;PSc{sI&MF!t5Gl`N-_weJdcFxkI`q zT-)|8LTvawiW@lcyY^cRnQYH3dv4HTU3?S|n zPHf6qNCp@#1aO}wI0AyM+{XoSEP(PZmfgm$bWs?NCtztlH3wEe~*PO*`xdlBFs;lzv8c{T+aF{#uHiyiVG1H!p%gtWXDxc-(8bTdUC$O2eoj5N8l4+*SsYntK6Hi&1P>F&8n zw*Yo%_F68R=&apzHRCrA5+@QG{E0(*kFXr1+FnUea+O3X-DmQ6xKd=}wav(cx;i4q zY3FEue(2 zWB&kMn|WGoD;g>S966%0IMZc2%(9b99p$mu`dDdNn5llI z2Q-id#Cs;O%@tg$nU4;dKv>ovA-jYz-R(RPd@Z8w92p~|td@5JL&{j0FUFaYGy(wx zwD3_ZEh1^hsVC7NB$cSa>E}$xmqpnDAE=GU_(N$K>nS@y?Ki4%wI;R-5W2T-0R5G$ zoY$9_adsR%!-ePizKI?rjW}`=dF{Qzix*hTY%axfgMH7Ep{3;N!7lw|X!RXNJaA)# z_sB=o?p8k{a!ZVkw;yy@2T#n@XY{eyT;s{+mvv5;)Nn_1!ih8olBG4bC#RY@UN7?C z1Bz#sRnQ&>lt4)LN7`H%(cp4bcHm7MWzT7Ca0pSfI-Fby_6T~Bi`0Z;v_{J`ZP|_A z+^XTPkP=dFX?e6y7fsZ2TH%k5_W{YRg09qH-b~WtyZK@bh25^DJLe4)1)p`Q!02sL zA_q?TjicX^fMwwfOpwm*;@5w4oZ!u))Ae}q+m59l%Vag8M@H_`sUAwNbHD#?l;|5v{^D~Y~;!G z{*GO2Asqhz-e+de^;nu-{AUJ@_(49QFKGlDs$W2AeP^M+9nE9~#Eqy@@cf*Jay3IB zXKM@h3FFH-ZDZ?t95_8E4878sDaRr(LkT|ggXBHn_K{28bmnNT)7lSh*7r-vI-Wdl z^#?Z|h`$PPY*pee>WHqT;J@6GYFAoszazakki5;7DEenpo@|+)2GQhKpAly z(r7A$q#7Y<=5$Bd36>z|SftZAGvJJ6+ENSzDBbj(kui)rRT*I|KI-hoQIbSqa7wLo;PQdYTW0VI{AfD%b08soqyuo6l^45x+@`zf1+l126qJ<{$K z#Hx}oG+dC@xa1L%I?-MlkBX2q2_vlg_KXa^vLpX@Po@@xvGe*)d+INR$=wpVqx+{C!#0Sk&yoY z({r`#4tGAtoSh!{;u0A_+l8;q%+qC!xY$5CZUMdRQ#d-VH)Po|x3# z(*j`N_ZA-(D$}z1Tw^tYNBvIyAbDCnS3fgQiZgtexLt&t-$8urVoWqE~Oczm@kd6 z#CCJST88p4PtdcP3!2X6gI&XLxju)eW3iG*z#4crYu6u*p_phP&e+9t|f3uIDb|V}(qjosB{-xSNkJ4eHp-c?+UR8|S+Wfxzb9gd6Ge7t zdrgG!?$Qdg-p8_!DorXiMR+m`2scC`lH|dW5D%;OS@||`t`iH-f{F3x+jLr%I(4Lrn0~W zjkFJID-(>tHcmcPIid#j;S%e4r^)Hq+|C&w5`dxWvAg0DJdP-YZ3WHTiv?PIQ5afS zcPLTFc?|^Y6aN4(Xi!#isYEY}laq*Tlt-}}BiP!WICzz@hCBJ#N78=F8r+P7vsz8< zu(f57Y7P!?h=4i0kQaUrQI|;>I(s#2AFeQJK-2ZcN19z{RpJb1L7L}!;g^q+1rUFw z-r-=e=ISjdI%p((Z6cl8ZKNM?n%y%})UqUr)5J0l*2vs@eM0T&hl}__I8a-?mcd(1E3m|L~2q2C@ zRGplX$0)jElZOeZjlsBm>AnadZ@OBajCf z0kibR4?ic^C&2@*p&S1IG>2jK2t!)(2>{UCsRZ(ki_IN~v=z7VhnqBT5gc^+51#|& zRi1W1WIMiN%Z~Jiu*oC+I2vu<2IQ;b2+1UPu*K?RJ9oGn0{nYz?vDd_c7ZpX|Fbgqm%78_$)cxd)YI_zta%Uk8Jhg*!@I8*0j>0L$DS-N7{tiQjz*A6yMIU~z*=wh?1z9drX{0c z8#W3h`x;=5(x=*N=Vlw6G4SCNOT(OhNd4EE>zZ`fd5#Y)?k4_|!X+-hl0`xUZTRQ= zpmJnMkuZ`%U0a(fW4dQ#@$~v?y~f{0)Mn7|nL9&6RmAAJmbIv ztJ;FW;^H@XD6$6EkO)FnOJ8qMLOo(;avSE$S{=cDCc^xCS*|0;doTe{+w@XJbQb@}dNjvT8B-7EYrqr58TnxB8sWj@C$P+SN$% z9O?Z@H~XqXV`Vrxj>&p)_!H}MN>SQfu{MzFQnn!0nhJ!|H!e^f>p%pLB8Lg$Lc$0p z($OQ(m(*vHH7{wu$Cn-$8opIODvMDLCYlXBSoUyb#53nT}us zo>PrdxN*at;uJFDxuDY7Gr@S|ilFYCUGk&c6KkZaGuVH2>Q>6?`?V0FntMXaUQfS1llSNMwKtTrCukdf{>aVoSS|va<#p^E@@JqDAhf`URD( zAPLw4O4#A_(~C=`V091(C$sx|trS{T6g{mt(GbCIA>H@w!o4Iz$rH_D!pV@+V?VmF z{+E^**SaT$y2A}0sE+}A1_qU?1oiH!$5vn=64%!uG`t&qn7 zQ6GbK}P{J!hhvUSZPL)3Kkj97BZ zp%0h>B#w^Y9(VZgr__3{qcu#=&gSV)$AGibbWo9fz#aDC0c`POp-jh?$j3Foz&WH4 zTYOrvKTTxgN*OFt3IMvrSKWG)9Z{faaZLR~3>f=FZF3DvOcdAi%>+|H()xz7-99KW zXGi}4!pS%V#i#V%^c`F8$~X&=;?K|?8u*fLec->`;02W@!?!{{ZTmepv+88$+DYVy({oB!r5y%Fcy9 zr0GLmV`-;63jq5j$)IM&80SRr9%-bGSD|EeRL#ZwmL`{r9C8oi79Qa8eeBTvknF8< zQEU-GG(qLA`UySdyLhDNHZjiW?Mb19(6|RWhR1TDIwqnf^uI3t?`m53wM@4_Ui_H- zOC$pNas8F^lQc0!kaMDZu4VSHces7ZG$(Tn2Ty7fIqhpVZz=x(`g=4N0@n)Pg{^)@ zpC&Pu45=ZLw%#5MJ>%!uTz+m$(PGUGemRg=@PlZ9^X?Hrw2V7?e=X6y;e>{oBn56R zo1C$Za}7Lz3ffDPsz%1Y7bhS1r}&Yu179?W!=-DHjC`zFvGZ63x)OUFJ-`Xl70AQ8 zrsaZmM(C_MsQV&vblAavbj$^$SRomi`mU>*_d^k6u?u!F9kMigf&9blg67McB<&Mq z3Lne3qwGRty^C5_kLvof7(av!i}pk0nkVKMVt|%3{Ztj%bzNHn7&PON8-~uUsXt5V z91LilWQZ3X$*(Dp6q7qi#>H%oj2E|nRV_PE)AbD3NjVY5-{l(usKqW0t(fBS7~8sC z*0A)*Vys8pp3U-_5L;Kt)3OKU^yYyl78EexWoh`2k@*0~Mb)g{4xOC@CnP(xj|Y`S z`i7&EIqq>S9y}`m*R8GPu$Oms1IN0yIQt~XF)buh()({yIW+$gcKF>~kj zrCDQ9&A%%^Me^&^0qmPT3Fp3Ij9FVKKNOmI(uu4mZ zfKVJ4GBmIBz%m(W-IO7P(d-WrH3J>Bs{k4wD44#W^6Dx`t7sg)x7COq<@6K8a$wW4H(z4vSBb` zVUF@Dz@?eW(=}Mntu?S+iaa6Ac21cqWMSW%ME?NPvh`vaG~ulrjx9-EJQwt>QW>Wa zX3pm{3Kn)(^xjv1srwJfYZ{lsMBi zNg^f8Hqd;pK!Z`6s<9slY;eaPB=S}ZQ+u@sdhla*uyeO6jxMV%9IbO2C?Bc31NTe7 z*Cq3*~A&~RUo)mmteFEbtp!?*(9e{!-Kwq`zdp4lVPgl;41kOTup z)aSv;0yZ`M#;N=y$K@I+T<((9WD&iYEqiH>J{I;@^=7-FMltd+fbH(4AFjQ=77wU& zhPNHLb7n^8yMD%zL*OX-KdE&+KPU3o%xu18!4w&%|~M@s3tpjXk98+T;UV#?&wz%w10iM$mqV2K#tfOuURN4PIZ#K4!$p zewPDI?Oww^qo!-UDKvOE88c)CQFF(4Y5S&t$;qJMYdBHGrfJeYC9SgY!C8Fnj?crz ze3QcVNYnK;xL3MQRLjNG7}+%=iWur};Qs)X>0N82{$mlD&}*$M?FL4I4|V;LUf}LL zBPT-CV8>+U2YP34X$T?1kVo7vXV7yr%*g)$A)l!qOzgq}?^EeG8dftK9vi2M=t^5f zClusAQKiY^*1ES}`ZqH!2V`T%+QKcM`B>TT@-g1_J%kWwtlU~OQ;RC64c9*D4p31r z8!1@oDjV5!6b!x|2vEG(P=_R3f~<+cxJ|Vqw^0TXxYBo|WCDawxVY{~NR1T+FxA~$P04N+Z`-sdkUvFxKxYC!qy7K2_Mhh|{Be*zs0p)CU zEmCOo137C$r>NNL+Yu=ds(1`BE{uToabLlNiVy zlUCsQww;KyHYwz6&6%?iDB;B2tHV9g5ghCkd=WzZ)udw;6(dI6sj*uerxzbD7=TQW ziY@;D+&mw;)8J!iI{W2r9O5aYj^c=m9qk*i{rnY&fM@A5$Csx}Nv*&gz>i`M#4QE` zw0(Oa^EP<2ZAF6E=G$PE;BZIs5`6HJ+u-O=;g6mTLr#>(G$Kd|?R!YDNaeo=!s{_2 zk?}-GIP$l<9$)8;!}&@0DExVvhL}bNP~*BM%=78wJL-y7Jnln=$J`ZHFCEy@{%Z~! zju&1;9EWU2dp*G$?1dpX{tCL5hW?<(%5-stYZxs4G1WOk(R@?gv7F%JPlyTF|ntd zvKGtUALWPPYT$z#T69t5ut6+^&5Izn=$qKQc>Av?u-PrZhM#4p!OoU{M;J;$YhBpz zcROs=n^np>@#Kz3>mv4Ujh&)oyfKahZs^Id;r&fMLN^1kbuB%|A%;i=G@t%tPWSsG z`d(yOmLbNI4r!r=KI!2fRJgu9NZrY4^3)e67F`2ThGsrFF>*yVKz@lDd^mqAlTzFJ zhKzy4MaCOoYkSsNS4f#$c~k2U`Q*=L-Gl0T-#s+cYoj_!7D1VH@wqD*C)VI z1~A#OK;-`b;UeNi3u`aOm2xJvp`^#&^R#i*{^bUV5}a7QD4!&)jjk8k1-Oq3zmjx} z^*cQ%2b0P9D%+xq96C&i1M)n#mc~Ex@P|*9?5Fn0A#802v{(I*X)RZh2gn*6*hvf= zlgUgG8RP;cl1Sg!ebkt^v*oyk3S&jN=Vr8flC-dC(8B|rB#nn0^E86rFT)w_@{2P` z$cqt@{#m$iGB$@eiLzKbpCJC0`JwU3F)K9PJ)VJS?ls#4X5^6j$l>~a!BoY_n1{iq zG0;HcPMC|4!`OR%%1ENd#gMU~&zS!J@|Zj1arbk)EZaJvijit2HN~>#!q>7f{48dk z*rUHMcap11nU|jT3`Yo~79S}3BLmneazkVQ=e#fv(T5S(pZ63$D>>jbu47pc{V_LY zkNl~#eG3?Pu}0Y&6ve=TT_Le&;bk*(GG~?ISGmL*1e+ia3f@kl_c$^zM~VrL!5)L$ zPT*ahNlq)e*_L*t4Po|$v^L?$1Z-h*&*~>@KPSLevh@iWlieX?leN8&wWH`@_W=Xb z@nxC0CI@ypIJ=|-(~Er2MR4%FSwnG{T;khwkKw-Lt-DSYw}e^6j%UatiN2;>$9EI@ zN4Y59{+`9gjoEVB;)sy>2L7a#`bWB-OT>adR0&Hl+q~ICQGd8^{36<>sT^32?vJsN z#ZW=zz56xp{{V6JSxQaHk>7_DV;!Hk@!Y&gTbyF-A2ku&9% zK;H84^);aKJ%Xk+&2J-3!H)(wurRTpF*7?RgPzjv;#*^zKgt#(QOMKfke6iT>RBFT zaV=o`1HFG`gOr;+6^3WTp142Rd0sOA=5a&IkhM(PP`cEGdCtk;9 zTv7S}IK8evNC0^&S*~i`FA#J%8fF!%MbGxbYcg`Xz$?Cw>b=D4=dAfx;q*D zIx`Hd5;=f?4(MaLXG(4dbosyhMOkRzd?o9_%8fDoH>g-{C!9lN)Hfwv{ILx#Cv@iN z?-`;fo*YZ45Vm=pEjB(EsQH0+ZIBhqBvF@3&~-T@HR=0LJ&q#hn(&U}K@X$}t6b8s zq@N|wfmUdhuGD&Z3|v0uzv=?Y%O+UuM^{1g{N9xEtX-xLE+M%d5YP{VM&+5_lUru# z5pIQ))^|Cy3g}X(@_CtXWX(BC91QD=u8C7d&!*L^jXHScYih|vhJ~Bx_krVudqn4t zP1HHcu}`$l9o<1Ywzp4`C&ejifdnSJkT+Cw)oo*gtA)bt)0r6{l9*fdQbk+Td3mZ* zMDcK2eQ~puJSVaoTE1{(D6`_tpsG<<# zx5!UHYy~Yo#VS6_PB0qbvs7-=+BP8?3u8JOPXQvw4+Uu8w<;* za+h%Ih;FaJfh>e~TU%FTE13B3MTsQxJ*CzI8b#jwtFz`rahr>e1B8+^dX91D?d%n( z{z-ED3Jgq4QhiAWs9S8U&g0o?bf)9R$4crmk2kRPptErkAc?+AL+ z$wd96S@fD3dG}f)CKnS-_r6K)R(~sAf4HPm11d=70ya#>ynStjjdlM3_WLMw{X0v@ zEf2uRloPR+C%3oey_ckEKZkuOlaD;|7}tY~!|G7}q` zJEfX7w8t4gQ-A<>I=BnYHSFB7W^SFU7U>gY$jJ9B0lfbJ61TJLd@pJ0o{Q6Q`YTz3 zNXe5fU?R(ZsC(oMfbP-kDBAhYMAYTMe3BR$HY=U=!13O~d>Z%Pm7CboN^vsA;g|M>9>bM+dRO_oBnGMGlLq=RudK z=-PDn_?^eT809W?H{1_)12ge*^4SC7 zf*f-4T3RT!_yydM6};_7A?z5i<>bkY2?fEDIm{l^cnBl0qIqM31abEo7xkZE`+K9& zX3HiEa7&595A_|6!WhEg{LUkCe{|J}>WcY!ab?EVfE!c?bGzhu_b%{06fnTbd}1IC zSqE@`b#6Qz75@PBV3IHmIqZ___9^Vqa3(Em8iqpwbq778v+uI5Nw}4z7|)C{HaHPo zBw8*^c?LMOY;&>Q;P(FIPBiYJ06CwPm$POT$N_i$ z(0M=)o_X@+CTJs(jicIPYhF*WuXPA?QO5qv9E^D#WOj>dNBpTG!0IUFbf-*no=7fu zk*3f0{{RZ)dXBA(OLBCKl3shHaba<<6jK6BN&BOGa%!0J#sGJ0v6g}FW|90%4Eey% z$J6nqXl~{z4lF*+JgD@eK1}r7XXHfa$ZjX3BP5S<>JG1A%G2rJ=mnmZMoGcS2Y9laUcZZ=mm8;gQz{&syh&OK4rGzNraI zR`qPUZgy6VbnFPN<>sF>)&*E^>2ICaqDj$uZgvNx=>}8}WdR}Y0C=O~k_tX$*JISQ z>>NyarH>*B*>Pk>d!uuH55K`w;?p##G~(ePGM)hBmFRkz&*&{z8y71KW$2_xV1`rN z$lUS0I*omb4b+_#pM|Bt)LLtpaq?Q(9TZ!(KT~iTe1XEG{uwoVqs(W(&%=zku(Td4 zl*}Waiz9L$5p#L7x-Ax~o0SWvnlSj|H1C3-{{UVjn1o=k?YQAl7DK3Oxfviewj03# z71FgGIAcAsMgyyopMj>~M8{1#+8XV^_EfX<8B1N00R}U`9#sgcSj|Hv%!#49?5*Z# z^5I2s%efp6b;vYK+-OEqTtk4q)G^tbmQzx=^#cO z5&FG?0hIFKW=y0)+5^Z?GD+}lj^L?rrhX%fC2f3_*Abm51k*x8Uyrn4Co*TJ!A`buUjexv&wO?v{FlMkfxM!$4^<6dacYU5PRV{$Tb1DZH(@%t(| zR&FkxsAA;?`hqut=8?$qnFf3V5z#s#=?@OHC$s`ffd`NjzsT3&n|`j;w7jiCJiH7; z7?Fd#5kR}#EeAns+MXldi5^5TMdKX4&oiRR%k%O0t`6g>gt;u)UdG}I{5zfZQ z!k4(X4^f`QTIkJj`gXF{V`7O6j4doae{_ArUeXBlDDkxhyAuGk#Wl63o_H(V^<7U` z)p}dik4XfW_uu@l0M|3~CDroeFgG4UC6*1TdWMUW)mgngCNz2R#?ZPTVD)MSmKPvRE4mFT~S zxH^1rV&&rMl5zoIeUh5@lGg{C&C(fNlD*6T0!s)yg^b9;o(DJ<8V0VH)qO9g=o-&W zzZB&E031ethz{WVuRVjM#L?zsyCxY7Pc7tGq?}^M8Oa_R9J&h9>ODU+UaXO@hPC7$ zWtnqa!b5=sESzN%c*-nza#o|Xtw}_dnp15&Zm0%^+MXs_jBHe_brcN}x;>N}6>Gl0 zRo}`BXyGY^I+7z~2xpbm&@8D7Hd08&0byIKZpxnuc0B`&Bx8$Ry18w82t1+hK2&02 zHndTqm2fgvQ^@d|8)-fES6XcbeY+AjZIo3`Dnri6trqGiD3Uk1uJ}Zt&6g44NM1lc zskh1$UD|0i@7rWG7v#9)lsQAPCH3cghhpP&n#PVDx5|t+xLxj~Wt(Z|!V)LTwkP-4 zZP-Mh$^bQl(eQ-=TH|}x%60}h!p&NAI5{I*4s`GsL+m&DhZMAqz|nQ69oz(RfwZG* zKP%50n=~(F)7m%)^D;5r1Lek-)03A*cq&|P!PSp1#QUOWwH-4nPnFGhCAYJO1yz$X zB3R*$N0P|zwWolzll2J6#t}~lByHT86Y;V!pB#AX6fNHW0C1JdZOP` zv2*e;BxRoH&g0I?)X+ng*Ub~acj`B_pkee2AG=Qnno$WPiNrO;f8AA!df}UlF0jpR z7CxD(MlPma9GA_d`i&6DC(||~q#HHgYe=100nO~SoGthIzuorw%o$g z=Igiq>XsaMc~eIgU@bWzvCFpYkp6>S=xlLP1iPs-VC;4lM3BnpT^!Od_LsDt5U5|A z!r8l?8h9=?5A1nS9B~$7;F-og$sE`1WKko8>7*bQHP0;YPXr{CLU|`Qa*^no7gZcl z6dCcCLg>tIk*B-qKh)oap=K^7qRgCpXEtVjTG;!sc0dRI7mdX~1Gtbj7s4qXM6r4aOB*^2 zk3qerUGi{7?05U)2ZQhsx9U&L$T^J2FlG9FoUdT9AgVs2JlN!m`z+Jo$j0o;fxv+6 z-5Idc{{Uh4NvjCt(pJ5pO`|F0O{2DN7t(;pe%dwYRye_#Y@5 zRuRU;YcWn{Kp~e=H~#>r@B9T$c_+wsttF6615`f2J^7BBNIh_09AGps8Xcp+Q@(MN zKk%B^V{YteJ1~3vl#Ai2LWU<7F`=Q-pU}a>eoDUCTY=uzJ+77C^(Ctf_;1Rj`B?;R zY$VgRG98@%0JpGG;$cZSYvmoWjsgu*_>Z{eJ{+0S04=fKCvsKIb4h~^3~6C?hZ5Hg zXsr%BF)||J@e2Ul{{S<-%Q>p*Op*`D!a<3y?j-Jez3m7xMJSNzI^_5fx&j#ZT;kxz z0Oqzzp!)M(#Y-dKHbbYG&&rhU2>n0*0A-s}HScc@BK?gaqc~*OhHFdaEMcD`v789v z{a<2L$fYqiwjbcN#=BYdO8)@4@Ul_kX1#^rI5w`ytNSU&Jkdq!Nsw54G!xuZG<8EW zej;pgax}~gAyn*{KUJRY-@nSqV@;htUvvyFkn9g{aBb~>3Z7&cQ2J(e7WcN=4&EE)7NeWrzIckg99Vq=icv|T_S!Rejfcm?SBD{Uk z{4SWrg^kP9rD!Y`$jPQQxB8EjXzCcanK>Sxer}~BiF50V=j=WZ`QBMMmsyz2A#Ze8 ztTx}VS=rI2ZF^#7I>GG8$%|CO!!TpW1byRXz3dyB_A1s6sg06ZK1gIZjA#-=7^`?5 ze9`4m*1s{C6XnQ}n9+^lgWuQz?y`8fQsU%CD*z>~1hk6=y~5dZ9!?p*PcH|s&6w#K z7G6XFybK&6wVw}o{{Sl_XF1tYIq&a^2Y1Nwc9M7O(fc^ZToMc3wcqWUh(11+H_N*>{XM{{S!LnR5X_qv?&G?H?ZiAoFBQ=Jwc)z8cX=D|c`3*+73W zP{z>dM{}%RrUVN~gDfHqblF)W8`1Vjukmt090@iz;O5>$$(gwNR zv9N3hpZ@?Vl#ebnE{FI;W8G}iH&WCzjJspo{lt()W|%Y(1@7W#0q#-bG-ZOlOouma z_ny`dfDoK>6mhxFZ+CXh7yeR~X=GsTaBBw)8xQQNO5G8Hev~h6>3`SsB$qOITv!|c zJl4P~@@C5IF}N|fn1sHeKJKct38cJ=8xIP1O6IhIutt&aiiUYVQgfHMHG`D)#6g&} z4XWu6&&o2IZP4VZSm3?KxRq{aM#c~Z>J~JoXH)93<>>Wt)*p($8+;*? z=Sz_18z2&d#UFK&XeUcAXrPZqDt3y0Qq1~z!d|49*(`Rn9Iu zp>*o)n`QduSoHpmF!qs?1Tz^V-13iQ^#G6t#@&L&v7ioDA0-+KM~ydUCNHRD!-rHG zZlYh5*E+UZ=(U*rF4s^Lyy1=m>L+!_PV#6t(x(eF>HeniY~Oaqov>r(X1IVUH&M|* z0I-BR6Cl7Y_f{RNIz!q{${x$X(BDOqANi2(kux-h`Zs>re@hOb*2)TX<7-f){xBB&?iro9Ndm(-n|_NuZ?=yzmOQjR26l>540Zv!swTiuW6|9aWNZ!Jl=&lQ29y!Fmr*F8 zS;ylw#=^G_HGo%0AZ(o!&y3Lk|tmC%LX9gi9M#$i_Xg0tNDhg8u*^O;12A4s!*Mg_<}m zVW&4`wHn(eiKDo2y1{i8tqiia6B)p7{8=um;3akBdf$Lvdtx)TDBjR0m%N>a!V!%- zpzkELq2rpjSI4r6#qML;$NvBct|g@MQ*s^L=3Ks~&;cM-4`q{oCaFjUagWIpvHSA^%^IFP$X&olFQh8+PnDIfuvz+T71|!@5hpP zEAmW#@ZT90UKlu|`z+aOlf!f_v)6iiA@9STt$Eqaa1Uud^r+|O#{mDW=-4ze!8uD^6rQ6AA6s$uoIX$K2gOX1F z0J1VQY{oPO|=-d3b_+@26jX)4QpHg;D9MvWY-&*!rB93 zPQZL3f1bjaJ+IO*obKx`5f&Qu`bbW3>6Zq%`cv3=K8){azuwcbY9P_t^Vrz|Gz*RY z0E9t|dxIu9C55i^*lc$lxC8tvBTwmR7}pGqLmkD`)`v1cK23mCmvr73Fw2dv9``r~ zHcWEkcg?iyiwX*97@4^bF=I&o08%nsSbm^3w-P?f)B1NsmUyL_Y}~kGlXuS09~}X+ zMews&y(`rEd*LwkCW_M|doAp9UObx|o)E6E>8`qqL7Oq%O3ci79dCmamNYb-+yLge zDLIWq-)pbXAjihjbqw4rd~qwJmn$LSNr)T>*xlOW^09fD{Wq!OWn*alE30d+EbL}h zL2ztfaoB3Y+Vl@h^d44$gR5iUHzOiQz{ry%`p#_4{bHT4-~2B`k?)0oK)}E@0000V zV3(4+QQ*IZS{6r8VP;_Ebryaru;wA!d`HtQ9Cta~^Ro3E-@;y%%hGePBf~Asd`HvE zl1Iq!`qpxv*E(?OnZ5X0_D*EEjF=PO7?9f|c>8be71+A(tU5U2>3vP2 zOPwU3vkxm3!Ooq`{!%^v0MEjQ`4S}jTGy}{(^;BMuZ`&E${Or9GwWo9t`^|#TSJgg z8MUmwo9Rrw0!#wPC&qL1tk_@b2RPHI_rV_Ok45!HkE-=1w(hCNXwS}frxaOirb7>i znjgpA5b6C1xSe;C(%P9B`eDO-*llym+XGJFzkR7v{lxF!&h?HjOylVqUb&`Eid~zH z8P39Ez%SeCk*)q$1Ioier)c>yM%;Npjz-%_8;@{Tu1kZ{eG}GM__~Ib8}zMT92g!V zGCC(S^+pFYdD(ef%orc)c-mZqV@)Z{(x!80%N%63NP#=p9zDXi%88UOkQS$7RniOH6zl=S?BWrfaA?^vG6=g1j>5buEa*`DLn9sos>bT9e@4U|PETsLWxY0^+9ZbkQ^OSm^sI$=O$K6tIt4fdg_CF3BMxLfw%lvkb$v z&ZhYY{-dh!A(-jFi~s`b@EZ#Rfyu)X_=;qkV^cWnf{#D5!i4-u^uDxT4ZzR`zw><;l~h>js%f) zXk2-7G?vCTJ`(<;T=*r%mON=lb8K;Hwp^w1xQ+^Y;FGzpmcVh|mB%*{7XV0eNZ9)$ z_8*63OlMCk9SdGS_ElWhMI}4I-8jFpQs~VK*-11r5$Zc|e5v>^!!GB^gkXq5+I4SA zzL}ja9$a$9KA?6{W0*&9lmZV0K=RhU<0gUFp}&wziU?|XSvh%BN)B1xA}qP35lcAx;s|sn6V@o4w5H! zkzkSjRbHOV>4^30fi%(>oh`BCnj__Bx@TO|adGB@D*(+IX}T6dsio?=PBy1An}%Hr ziR@_>TC}q_6We-%ZkWcy@4?84(aJ+#8;CofE6uutqE0TF%*dX}Sn*@D?iP-Ir0ESy zrzOV9!t9baTV2~u=WWqvVQ3njfrRZhKht%9VlO8C2r6tVL(fTqOnA@ajmq)O@b^K_rYcRipYa3z3#8g%K`iNU zDTFQqx{$WQ1>}r0lBV>?q8Ayl-ChNSp-FL3WiiOKi%EE;EUg1@qK;122OkJ!RCcCV z{FJX20;*t;Kd=q>MBAvAiX1AB%5$X-8x*^Zq`H5J9DW{5J*Dxu1Ll_;#)jDC9>vzo zZeW>#&GsP~p8&`}H@^!;)iK`uX#`V&eZCy0dh&Efro}kzj(_f$2HVSl`=xcU8*nv7k07lq;&GDlPSe}kPVMrWE9u0>>IFu27Sp$~X4FaLF*oo#Vh6gj z9J0bJ8ojMnYitE6E)5nfx55fvlTW2;xmeGRTuGl4;=yxIBiOAue@|=CwVI1Y7Fn>| z$iNY~-~RwLzxNBzBXbx8(YS&D81(ke=i^5wbZjH^pESD=VDD=u5imIVau)LNHw5x6 z3B7qSl7pXbv<5aHt1N$y2f{z6>Ke0)+l=EUro!jMV{DC~{?ZMERyJswj1n|p7Rmv6 z$b^>G+5za>VHYk+GW$JG2qOrG8CdyCBM1=aVRuypSAT(e$0T+^dHGLIic`x>p}Y zVr&!UHy#K+3b7768BFx#g|N+zE$l4-1ALL?r^xZ)Q5wl`W*GL*Jg=R^zCuYS%Zaj{ z!uYALZ+v6Vuu|%HFU6VPLzoHOq!3ttr2hcO_)x(!URucr9sx}mJ|7`QVM9D7NL&H_ zpM?up=>GtRGYB3C@Sp-*X-nfHZQKFakA!<0D<3hPrJy|RN6HFLED<~oaBG@=vAbj& zcYGg}V-|l=!_opQwu*B|`X(O4d;b8+zWhhy!t99I>f@7AH1gB$@T<*%`MBEnUHnnI z2sPXXgYpn)llUWcCwO*VoE;po8=D^frXMA~?f(FTN(rIW!H^LiYa32!{W7$8KPY}A z(_~5=88PY*@X{;Q1Cjp#yW`5YCNncwbMPJLLzxW4}Ym6yQzSorb#hkMO8{#5Zo(mUO=M~`(a zcaZlAjDD2DUEWApf?n4;`$vmZ%O4rNwmhO`@=X5LY|*u=%*AAEA>a^3_KyIu?clG4 zjTFuG4+HLlO2)?bHYbn|AzXtPz98MhPbb|?e3YlEqMl}@ zk&D?~W8O&)0l!A7l&ibBaxr5KsSS9u51i|y{Elw#n6E8fYa zJNFTF_6n5xt70yL2oBS*+QROirDSBhODOKM=Z2-PXGkpcawIiJ6WE8OGzecdL%O& zRnL@8SrmBh51ftL8T~|i5;j{1GbDW2+Q;R?vLz-B3k2~SI5WI^dA}uM`gS{P_*2IJ z07>(;`5}VeBP0DWH~#>0xmz)VnV+akBAu+C(*rLhhM~fSw#SU{U0WJTZ<8z$mXSpn zbVxIsoar(Hv2j@E=I0at09PQ24PiWhc3x*D6X2d`o@vpuyK%_z{uivu{7j5y#yg?V zur~ng?3r1>9`<~!NXnZ#SZvLO(@Q*3vCzcZcI_ZEd(cT862}^K2N z%Xv59dKNY}Mq}wreo4xgFtGPWVU1(`y~@vFWohixvF3g_bP-C|IxD{RgSaQ<3U}fr zvgq2B9J9l_>;=8XC_s)d2_I9=jtJQBORu@_cOO%~?3V8RrkOe{Np0)m^>CxwGexQ4as#?c1BzgTu(|U;V`=b*+(df4Ps*=p-9#(>V8zHa>N!qOf zj}~cW>|;qc;Wa2eOf%r>amE<*oOU?R(`7I;mu!mUX}M5D3z$IrD%g0_O5y`a{grPT zvOk2)>cS5c_A9uSwO6+jx+|N7G)=P8!lw>Ajs}`lDMhO%J`C~8>9|aXx`L803AD*r z;OZiZ>p^JUJ1|Yge3HHUP%Dv;4X7^4ao8Y!thU&&`EP=!f@iQ;avCnw!PF6~M!KAv z>|dWUM+z=9nH=;vL(7RNz>tk%C)DMXt;n@3f!3?`f|yEgc~o=GdrH~IwzyF#i>*XP z=rU&#T@5F~U8HiDgaz=V3~&}gzlV+AMv+s6^b%T{LTt?Mbc^C+cTp;=kW{-PSd1Z} z_)Q`kC4L-Xpx)|)xa^{fJg_&FMeb=lDkQCk0T0;hkC%3_4P#m;j#Yy95$+HcQOR?O zGz#Pqk}QqX?mfncR$>eu5EeCoBF!HLgn zwBG4ev{jEhHA*R^<6AN-p8!K`B18g}3@Z7D)G6tVe11kR&z?qH zf;N^01~H+n4IT>6V4Oe%z23G%PjU4L>>j`Y$`OO0;jvrx~o5_^~{Y^GTP_Rjv!BLakuoeU;OzfOmh*vkUm0`QwqOA)a8%? zk&gFr7#v4F+bEr-YS_+mdmsdI((!-gHM)$AdjNB+5!ylW7KX39Ic%<#rv>2JB@t@blN2=zBI2Vv@1 zfST?ZCBT37n^g5Ki0OSUQ6bNK`c_Hw+o(roTq&#R60mIMA8?BjN0+-MaQ2xbc_ViH zNBe|NP1dyxNr{go;j}~AO@h)Wf)6Mu%Z=EwEAX-5U}(4r1o?BF?oQ=bkn!ZjVSX#?x)jaC>pc=k zXn->zWwpoLjz6-arE9~l{{R*6a&SR*o1;8d$HmjxOcRBDh}zcsgFS)fx_?BO<`gm-6kI-S3tN zHgI=@Z&&x+B z!#ZD3*7R&?-1sx_B5U7v94rui^|hglz&jTfN8?T;VUBxqnl|ip?%G?S(z9uzk_2JgsL3wbb}4U8L>~HYS3l<9mbE+Dk(zic7L1aR-Z51T(W&>9>x_4{MgQrS<$gp&-v7$b6L^CaHt1 zKmP!Vt+oK5I^K>MIerb-ut)A6uwSS&oJ_g<@ESXg=9VSVWnjI{orD9yD3+P5v^tJn4x^?Q8ubXpI%o0aJK3O;WcM(Xu`QSMWOd79*mv*+u&TmP=a4hcEyYHxlQUH(;&) zU8XML@?GqN!LO0hWxi(wav0$IBw6-SG^>KnZZt8q zu8r0Ygxr4lVslKC2LV?S+Y4xw6iqI81kfqpBd$3eOk|`xa1)FVHug03t2ubk#Kx9B z&y`+0nIma$Aoxgs(Bvj-b0cvV$X$junY(0l4=Is0N50vyTzg#EYD)(9C;~?^81g$w zC4i}=ej%{dc-W>(3~ViTb+q!CID|Q-Kixk93h4T=(_ZHogW7f=jf%I4t7FHW`OY&# zTx&Y{%!BV^!*zR;lOa2EgRfkrqhl#UL4wAcz*36mQj5xRp|_z zIADG=@#SO1xq#i@J1kCtt!F^z7_fxS4X!sK6wtMt_Gyj|rAy<-U^uDjv zVhzE=i&bRUlY!j#SE$NFak?)bQ0eI=)AE@k%fNe08*jSvEbVVX)ph(~mxSnG52-A6 z@AAEW7f;ar9K3#?)J!wJA=uFSU_LfeTyP)M`P-^`Ze1%;k_Ir6-Q3Z=eZCe$aA>ck z`irIYoNOrd9QK@yrc)&J#rHRh3&i!^4p?L}F@y&j?IMbo8|4)ld^0SN3A=(p6jOmy zX2)qXic*dfTo5sVIdC_1IAx1K(jiU>q)|={uz`pj)01k7e}n+g-PFCiCO2ZNc;N#` ztad3EkOd_EQ!dRQf^So}ZlEW6Pa7214eTJMFA2ZQoOoPjH76T3$DVQi zV^gbi%b5OBo57OhwY{pDi81f@ON$_uC*Lx#anRt(M(BwkqW4ZS;7ze43C;tFaFCZs0s2%nTsgh(0MKsK!~ZglOG6q=}+zXlIRry-3A8ed~YjtigvH+3M-p zWrPbXc@=;D-r;9rpCc9Rdr4{SG)Bm-E3xvc)RaLb5@m0b?BG0nstEGvF^@Em$RWzd zYfF#Uk0;X{pDcF`a=)E``OFT)aWcgnvCrA%qnM-~Yr*mqaq2Qbj}9)cjM;IY{{Tj6 z?r-dQ2%LDiT6sCTQ;tq4VGo3m_qCpTPmqyqSnT*6t!aPiL_6tgAEePXW}>=DE9vF!15}>{@oB-{o?%m!mRBSnOvB zB6xKAY@paJtCJc2#<)S8qqirHvUy`8ea9E!akDr)xNL6r*=uIR#w}nBxaMhoJBZ%L z>WH6kctT%-Ae6VT7Q1#Ac^<_x9ZNVG<09@e2N!W;a7V~cV(LtTGFLOaKwL{e8@Jk( zMz$!6#IaD^gXaB{aq^tP52*3xfCM18>}sYOX0q14JcdJ>E49by4?jM~<3debE^6 zWVXkfkk`d5ev~<#wj9s?oW4jOJGAe@&CJZ5BT;ipcW(gh*&{yw;DrK{u1>w;N0)Zg zW5R^GOqYn`u^20nG5H3#XScdHj}$Pr_@Jq}2*u7vao}b<0ida6tcKAcXd&`MCl+$nJ~aCJc(Ib*U=DTl#IU}MP`@-Vf7 ziWD4ziLoO9mc-vt$NvDBd?8xa9zke3y~C0?3tJXAjxhNMWL$s_T)Z z{FJ`pz7IT$A}n^vB=Nf=BVgA^ZH*sqB@W5XnrD|if3)7ugT5bbk9cV3C44BG3Cu>699DCna(#UjBFVgJRh>wcjM;i&T||7ozs}ci6{7( zPxtq8ity`vQV>S%G)IG8>vbL(z|IMTu;vnxkfPK=`@D; zCzJA_wuXY^Wcc<;BTTs^w3hz>`WB;nkTg@d@RU=&OqSWBcWIFx){^0O?yJQA0OR)r zX&1?&&p7%Ee%<}1mr~Aru`#9O(AfvUo$*fDK{nH1rq3}gC$&e8_KPJbXxT z-?TF>w~+XRXMibM(eq=5Pf^VTpLLi!xm#rbH%;PINY5A4x}R1vl(y8}YI?*O5cbn} z_FU501UUYo0?zxaAF5p|MVhpE`E8B>)}IRr;-yIX52yW78FFRKnlS$WEFr4qblEwXn$797dUudeedVMM( z7Qk?WK`Dk?zugs+Qn<(kCbF*vm~!+JhFN8Ybb$@Q9q#y5G9WBFE79apaXwXfWe;)o zT@l#u^RAoI?T9#n3gJ5`UPbJqAX3!wSitHj-N}Z5O()p~c082AQ*BJhUhV5-39>6v z#KR+~Cq5T2ZVJ1B87~9`(i3Fuz<+0TDziXau?t^ako`?r{I`cbfLBIaGHeERfKh4X z?TcaI48}CjtxDqd*MtBVTcsqAD9$-=Z)sG-2KH8&8-U>eO89}}by!5wYLw1?IY^jz=Mfg)dNq1@G z09+1WJM33`t<(*L$)OHz#)=*!d=Bk*9_f-^nS^fMRe0raeK=B>KF4*aB^~>>kbnuc zKw3c?A-NEc{^qC|kme54%AK=V-~6P6$X@3F0UN9MZ!|A;6N6sc3MNbGoscl3@-zyh zI&lbz@)9-#rtHdM*fN{YDw%gGMn$+DV8)=1rT&h8-46f0%e`wQ9M zeYf>jG`Y@$U83}x^Wl>xGf~CB#cM;oNuE2NJ($6{KiL9~7+ou)1QrLM;#bs1iXIoK zX%Oj$q%~PFbXg^w##-!y7jsxEp7(kCFEoQqrgzUP7(b@TclHX>BVfc&(=nXFBWvG# zmwiNj$kR29*JAf ztcDWOvhrJ!$s3UiUO!LL=>_<&mF*oc{LES7W@J)RhSEKqfVl3m8XraK62}`ItYiZr z1(9R2IQRFuBoCEmukkXvGapUPk6g{k$}_Zj84~)9b3pot01bkc!9?2rD0MtKPf29Q z7C?0Q7YJZA`oX{01@b1DGc*4;XcEE# zk&bIaK_Kr$dwigaka`Z6#hO6KGp32ctjTIxkmj&k$-@voJihuWY@R zej4r7j7YNOYa@w(Fc9K*6nN!&cTQ=#E*qPXoabap2>L+!8-9LDS3sHPT7HL-jU!G@ zi6&`jHYS)hB7OT?SNoOkeL1bV7$R(#@Ix4A?TQu%7!Qgxg5qN~eE7ssmc=ZGwAXMA zy@^_#Ir#1wF=ArmYC!Dc1Y^(+1laXtA-DFmEsboz5(P?aS1(Qd6o{7tmc;fQ%%X1$1IH3_gZKn*K`?i-Kpu> zSnxhUW>%3LgZfF}t?=p$`CdnTwEqAv03v5m{{T?L$xNr=82NOmWPXI{k_nwR@s(fbGxL5;(7j~ z86Y3r1znT4kV)UbNhs`U_SE{Hr#}(@04WqvFh*mbT-pM?z@*Nu(|->2-6uO(o-fPf zLdQNsjzb<#fm}Mt_Fq5YHOz>~>V~}00G-ow^D-P_fXd>@Bmv+b)B&{IVnUR*qt!I8 z!fvI)()9gbO4Y_bd*BjDj`CtH?%Xsyd9FbmqWIs5Jz1bWTuz|Cbk2pL&upYJLd&k^ zyN88eMC%(S!z8al_r$f%PqL&FyYOLe=n=#xW-wA@>w)zVn`Lf z_41M`{{RK~dT&nrMC#3RD-t&1Y50(sB9<@*uaUVAKI7lvXK*?XH&Dsdbcg0i23`av zL5%mABal^xGWZ2+`ZuVw%|EBH^yo3&6!2Nd4?VB-PwFlluRQCHppPf3Bg<@(hR28^ znb^br!kPT8~ZX`1rUYEk_xx?<{9Ev%8(=-DI_ivEDJCjXUIFggL&U zw=|wx`xSdnhY}nJvZ8m@C#f63H*N8MD=_-{fE#cX39-&_WbAq5n9ctH%JywbQ_#)` zjfI85fExFu=2*Qyot4wNro6`g00RPeBOr~OUU&Z9SES_hj-3{rjVsSA>U+M1` zNKd#L?KApkNMmXYe8IpHZMESB%+vKPD>Jqixz)f05`ntL3m$QvOl|RMrY5;B=Pxam zZ*x|t%(15HnHc$3oWcPc5)tg(Lr&HrZai&iaW#I*o~4(h=EY2+^RT1=`W{{kVpRvT-16|`g~rr67N@5q0%*zic4~sK|V@~4Sys|#^w@Q4G>XXO`3kE3mc9=cajqy z^(*G$;%hROvV{&p#%JQ>VMykO64C9#AYYNDIn86q3Nxs)C64tf{!$vW2yRnb9UaN# zRxNvpc;QPdEOW_c3xTg_BKA}LN+r{Woc^B)<4u1Tp^fliXZwPr%6@#|DC3VMxZY z@%DlBD)iz!&{D@MSkqst-BpNdUnDQvVieLvku!Z#HYr6AlsJ=a@R;eRYkLVG1OX&4 zf=gv_8(2+=u(nqT4S~XYEwA}}&y3RqSXTK90(+_iFJ+3YX`EP}U(KUR0EO}p_iQg1}h|O38txrnmx+Z=e zcB2lY{0ztgpBtLs+V8*XSm|sozv)alb$M9a$Y+erJYnV1Rahi@*Rs1FwV-|~ zW#Z}ni|{3Y86?O7t(d!k9B13fQT+;|=Z>i9{EQ5jxU=c*a1H{4z%|_8aIw5{zK-iX zD?bk>2d4D~39&G{ByOi1WzLQX2^AxQFJ}^Y2XS_5~OLcfv4O!jnti+CsK5o`17{Blu{X-H zVYb?989>^R>maz%ZW$NfZ0auheU-0qxp(L*#iaXel$i&~E<#0VNotS!c;P_jewF zrF49nu>(ca@$zSAF8s8k(UboGv_EHl#R1hctxHNH6FU-IdEiL zyOz1TwZN9RSFsD!KlO0dbP4pGUmRx0$ce(r4h@z!*1^Q`64j%#8^e+`yJUGh*)M#K zb3th(t{`po4=L}=drRew)$0DBHUZw@R&ykC%w2@YT~+4&m1!fAHr{{ShiX*-R`@TF*Dxi#!-%4oqOz0yasfFO;paHWxv7O=wdOSxx| zR3-HKaqa+8Z)=Ct-MsU-K|$R=Sep`|oq|Y=dk|(FdyAud&Am8#kh@}N}n4eBN9f-8@Fi=1Rf8%mW}bx;zyuJ=;ab?8f0yA z57VEBMOZxjDs4L~MUEiDmBSW!+b$c)-VA_0L%t6PGd0i5X1h_vYhuf5ZfL5RJAa#R z>i+8ABUYL+be{kdP|&Jc1K*7}jLU)|&ywkHV55*Rp}94hOnu zi2IAcLm?gZ$9Q{IhZ8m<>0@f7nC_y@VD5Zpz<2dGG@Z#y8}g;`yL&ek7m$SdQhN zw;+DYL!xUK(6DKmlbq}c4Z|-l#gqD*{@dgxYMnis9#&2?RA!ePmm7b zXLRX`SpNV9NrkKeh@~s%5*qHLCK%_K({7fBOwgv8;JVV2OO{p)bIU4>O2a9zwt)Wt z3J2;`K?jAV)O3bH1rPxr3mH5D%_om0#dSR-@qNVd>TY=y5xpl7*^UMLa}_{(vVtrTlPip%ZmPw3hO2PzA#L>idmA!0V`P9$QzRpGn8@jkLfrVFac_-~DKYXf-`M84hW^Rz7Gpl2 zG(FHgE)48^DGOwOtm0{c{4F*IPEVTlWMx|;JGL>x@sp302xQ^pk+@#H(LGq~pmB2C zJA;0LN}27gqfVYFWvN8Ds*xMw({Ne@k{WRXhWnz>;)o-MOvI20WFN+O`9mIA#B6?;Yp@}wh&J318-0M6y!sBfEEO;ZYCR46@WM$w7V89HRQG)UY<-SMB z^1NNxPiC6Tx-@4o{{UbL`o}|T&(dd-U>tJirjPcWhxlG+)%`Jvref+kWCqy=GxDP+ zbF;;d^0dd9_M?NV=u?!YzeK;%c+<kw(HuyQ`-iks6>5ykN*J0X@u<@bzZ!q z=a96?DMwm3dQ2Fy?4)=c-wy@L6=zCFHHqf*FW ze4xzSjHhprl0~*L{VezU{=q?@>p1wCua_$tIpcI>cFDc_6mKnWQ+V{)y-!W&_ZaiJ zH?kw?lZM$E9PZOr2h!iUMRiQgD=fX(*er+GG?ZIJ)uM+(%E6t7(2`;5Iknwh$d*T? z>TlEZP<=$PJn-&>yNpQ=_B--@)c6p(Y`EiSvg1H6PsNj_GenQb?}?_Og@K*ShA=sG za^hAu0(^ZVsM$MDd~i%lNb)=tD<<1^nq>NS@bkepl}a+0D?1M@l3cMptp~JNBB=~$ z?wB-RK3A|w)q_}L;mmAKV~OoOfD!wzK95de);$Ku(B9)tCWR@-mG>!qrk!uoDp;~% zmeI*Ftnr4$dtD*8%`SNWSzelYUIB*LW}Y_}*l20oERH6W_UgWiUG$$m!8qoFQY)$Y zS5~uh^7Q*Q_`iz00U~4ShJpgP3j>D%Uz=oE;~z} zN_^z^27<1|hbtoPsw$Hh^DC{kLaU2rQ^S`QD8<9vG!lNF0X#pkaly=SwyN?v_*LZM za+H6#wAXhVDLvqAYM^-mF8e8@H=nbQac8?_8FJtt1sk1Z1~bWHOSdV7#;J6b8B}9u zM&&%WWiB*b?%fv{ZSA_l`Z?k8G}>7crqBF?<9j$#G>;6X`kfTE6{(u%dW{r zsaBoMJRk^ScqesqIkn*qiKMuiQy0;qm=j1ELE%*qG@X|o{{Uj28^r{~JjO#wv@QMS zPz97mX@F@_VL655y176OY)|aI6?e{92qkGA*b6ozg_OpZn^3{Hvoarp$(z%sz~t@!+}-CeKZFyMn+7b zz7P~#en@Zx8dT+Ykbrp$M$H61F5v3fWpiPEG^M22zENb+XgR;Ef&z=iF!BwBa56I&v03=?+|ynav5{kAx-4{GiKmNE%+L)g(9H06R$p!aloLci z(i4{1WGsGyo7Bz~g<+Fr};?r1xU@ndD^TJ9c)o1@97=}i&o`6IFn zQf>H?vvV>j?`1zesyrHO&g7k#60LWHZ3O(>2?8UYd!dvCJM8Z%8cvo=OH zHY9F*cyWMz5b|2*`FS7qPlGB~7qT`q4>mX+>EVK~hXrpt4-WLNq}^}S+nG^|#>JJ+TFk}Nvd=p;VI$caq>sK{{V&Z zA60c$M^o#$I+Vn{{Ul} zf9{Au26Icvz{oz-%l`nnVh#R73^k2~rG}`Oa~rGSMb~Vc|YJSME?MXoibwd@jACE833?m zmN^;wf(QJpE}!^!)*6e>p_{0-JgMAWGeg?<5PZ-yc3TE?hM5R~nfZRCj3oEV5hd5| z&}(HQx-s2dgVowDkk>v;9Q`Iq;}d4$lGlbc!r0+|NIViOcwUVcS$=N^9k?bucm!ZI zjG!6@zyLfVFlc&i7A{s9W8}un1~;?-AuJ+~Yj>mazIv>_nAWuo4=Kc$WVoDm?~Lx( z54%tINpcUz2dw`9>Kx5KHPXIEosG1cYlqLm@I7jApmjb>m}CC{gq(?67}$16xoH0Y z+I9cPOp5i`{E8pAz{{V1mswF?jIA*st zHcu1DYlRxxkFi!@nG@ex2U*Vp$EF&vU)L9+4fg9RL+uZ*E_)XM0cdjwB z@$~$uFxvc>ohPi)4`g6~Tx)U8+it4GrT9FnR-LozS&|MNGl>5Hg;pn!K?2W!7ttDL z;b%y<6tg!_$de(>Kg4T;8q-{X{{WO{qA_$$9(=7UCldtaVgUaD%`~)$;(7XHv%&CN z;HXLLYTDHK=hM`l8sUSGKokgx_5T10hpge4!!Ru^*oOir{fhgG{{UQQm`ot%wZMNX zMUU>h-#@K?59HT#v$Axoe5{u;IN<^zERG->p~srOQ+6ex;PL7)I;s476Eo}AHi>HTd(qctrf6zuG*X@s%0$AU)U zzAPuOv@tBto)g_0$Rmx@8Lj2!>v8HbJGt1542T`TBhUF-DZdT1x$y>GfvDr^u(_SV zfEcF({{Un5Ke1Rx;p#d(kHpk4rpBJ^vQ`#2{EOu~vUQS1(_88cZC4eq%Y+Pw!2)>x zi7L1xaz5&&KBa|$qa83{vF9=-$&)kpd2!vX9>4{PFLbgtGHeIY+>Gae^thK^$IsQb?6G}A z9;1z#_8W{gHU=}gzyY9t*%s;d=XI}M;T>}(70W8#F6(tW#}cRo;$#BAsx z>TK+MK~O~g#tXWoFe+-n*quitQMwsf@oHwvfhH_KG~N z$VnColzf z59tb#ESDEj$-~Qh%#MqN07lBj46)?oyk@wzCpeQqMs)_{<}k?xMmC@~SEPIyY;GPa z2XQ-^;ZY^m#@3Mp41QJ%TnvBdk1`4WiTfb-riUtQ|` zIn>=piPTJPV`hxUD~8~fG=_kGrj1e?uk;2ECr0VI=9QZKj9D7fksI6(rs)pepRfec zZ|=08gu0G}lb@<#>ln@d08z+)b4E*SydGOl;NSODdhexly&tM{Tr7P~TwOC%$^$D1 zJc#3HBHrHs5`SWo@-KtuEkgPH5LSwm4 zV{9O$q1jGToT38$3I+@wm!)2!|h0|Ya*os=9+A&mD=W85Cn2?P|H zFC6vaQQ9M>YvFsNaNKQbv9fqX@}&|6xPjf|s!VtXgw?gkO+`+WyGZ*U8-1p}$$=9Y zU9pz(4}}&yk#~^j+CkfN2C;IA*oqecwOAsETz&S}G-xdbJ}!|f17?zJcldpGv;P1p zrm3T3Y34V%%#tZLWQ;b~1qy2D>7PxJV%c{``9SYKSL~eDgS%b0@O-Glsl<_LS^!yT zqIN#ZL~|}l7}m-3xR$%!aK1>xm`S6@$V|WLvfpr#FOapDV0lb;{{RtlPj)Y=@65Hu zr-BVQA8@u4VqQC4ml?~&eG!)!{xn0+aP#}Djx^B{Bb|V>ZMMXI=*E?+hP`6wcI6_gi+If9Ai=#u$E{70!v|c9w#`?fW)_*Sm1wU|s%>kk@ zBWw>QO4s6MVZXKvk@3H3a{{X_! zv5gHl(-0g*vRk&h_wb?0NbASb!hSNIVAwMl@Zl7#aNHi!DH%GDFk!f{tdkyQmoyI2 z>OZURwH4?X6G@LeO_9_YAn&n%N!r#6tFQ(Jxs=8mjpx*i`?dS1jP{iko2T?}?4__y zZBHI7oo*NiFv*kaL@!~+T@g$NaAT|9k(k>vBMvPOV@(*(E&D6bn2S5&X?sBWz}iNC zqh$q1XYP5X(ocvblvPjV`G;%u~<=v&xSJw^ww*dfVh}lPWK39XY zg;5?4$`ohG#F6p3yPEENgYZU z1Z@C|SjskZVd|rc!536zTbvuPSSC8jwV>8>Vw8$-HnVP#q=3P?))CewS^Ak}mm(1t z%+dzdw-HRtY$kz0)Uvqj3;^;`MlxAQFC-5ECbkwlnkiS@J(Bv;mq!JHW&06Onw=h?I5VoF>bK_`Ty)~At; zCEJgcE;2`{gQ>+h$w-i70}G;%07lA=8=H-v1ii#GJas>>;Ri;l#qP1kPKq~@ z`5eGp(mzX8-kZ;K+TK=6A#;NVr4@~Xk0o$QNyz$)I9zet_h@=VxbQzVEO;InkA)a~ zlzDYiS{If6BI;RKnuL?a)*8WXJb}W+Oi4HWk&Q=Hk^N7DgN1HmWpCySKbgetPuXI> z6SYVu&eU5A!<#llU=iRz(hvD6u|200bM=_zgQm+T{{V7%ag~w@q%LbndrM;ghV#99 zEmpOyJ5kNa$c|#^CIHPb*hb2s6Fq<%e5_n9a~kuvYnobb{>kl??uo3bV@=TVeai2Y zZ23GHWgVC5Cz@6kb~F&dxCfUXa-jq~IJ;^Cg~x)yWPL_fLQS+1K9R5k$xeaqXnUGAB8m32*x@>yM~S3t zgfYg6_g8VCjqa7tdF%t9a)vmIrk~whYs)c@%aqA}4vw25bGi3MJ;j4?w2*4|r0gK+ zB{I12?uVDVvfY0HS;mv;B4hnzc|T78 zEA*n39E<8bL(7*mviEynUY9yti9?+0Aw`v&F>Mzel_-rkk+@8hlVq(HIHQvxBpRaMlgBp>b%E@Sq z0Yha|1~xpo&hmvw_e&@iX%}y7F#rze*HmvlvOPv=H|@qln;c}40tWcSnnY)s%@V2Y zOK2%0!0YltbKs`-QjBb@NZ_mTb_-N_Puw`2lL@lA=C}>QQ8brAvqdkgPE&7G6A$)C%jp+l#XKD9Wr+bSi1ko&{>U`JojWm%E9o`UV z8cVkxQTQT_zyebMM3GypA~?VREGrL!AURVpj0~_+5d{93Zxn{IHiy_&@?0p_3XD$r zlMql3rjYr;2V$-l9^aZn-t*nc0?D9p18|)4R##(i1AUZpJ)mrDFtWdRbEvB!tpj4A ziGjw-bnPt`3JED?KDGwaahmf)TB{?8eH2R>?P#Jx3TI`WMi10N6kPcqe=7EAuxP3f z5FNT0N7^06pVMaHRLGsO$Qn+{Q9C_4+k_qF-bg60NIJn7Wqc}PAm@`-hkj;8inVVa zFjXE=aSddSWWoUdKmfncHrRzi3EvEX!@{$bKXKVn2i+#iitXgr!_w27m#gnjv-l@Pa5EkmBiFZ;g>XFH&|ha&cVq`FxgvAog=NW5=-v z{A{YT5z;`}`-M7k%JMb_{{YHl*#4N{h0f(2j_iFlSz>cu*p;TgRphpf@CORUGe8B$ zlftU^x$d_TO#x+0#}Pxck?^V}3@;l2?Jjo1!Sac~&?o{o@!@A%KKosGwR$YV1Gn7! z`z;ZZM&|-42@W(!HXB=&rR!~KEjvJiPJx0fy+y5?Ev>(z0s0yL0Nh7$9?L1AzD7qT zr8jWK#&3JcG#+p1jC{E4vHGT|ld9+BW@Nm&SzcUEx3fpU8w8&qkyWpdG=TC4kQA}F zgWPOh!ju8P9l-%k+1Wr39A5}1zXPVRZ+B_nEgp^<{D*qk1~@?8LQOP#*PpV>MU!?Y zx`j{+Q!YNErr_gABQfJ~{v#uK22p>d&u9DsfgYtEepD>c0LYNVIW5ADXP9Gik26XJ zNY_UG*v*bP{nQO}z-t}y!ov%kNgqpFW{&>L5!L-J?y%~!=w`=_CI*`fbI4oV z4nZZsocL+q*=+S5k?QahNT?BZOO4dJ8j^u1?e%-~qkL z942F7VmQMchD#%dsUwc=k?r{?8~V2k@;MkYhGb*8qBYh!8MvHqzE@&iKor(Ww^%~xK})Zzj* zN*fdnCjB^L;C;^}VDj}0tgDkEN690Nx$h;;KXOp;=eSjpJ(S%RqHAaBESI0+WXMSH z(rFH6rJXG9{If`L6=3gQDwZ}p9+TfGB=(-rI0xlj!I`WL00CRlTgoBOBQ!sL%-=)Sr-E`a<2*d)ftk`XBYxzU4c7xpMGT=j!`mq~s;L~L}B zpHc~H>uDT-eTeY9h-XM9%A#q~cOShe@#impYl)%_gt!LfV7R5CWcF#Vx`aDoe52hv z(%R2bWXpx7M#sq*?s#*<1ziow^w|FZ2EQgSBh|I+NOL5~Z>@&UthNs)xPLe8Unw~h zplA9&p(oU_*{*8m^4c6S11yd`u9yS6SUtR7_FG=F(_hh=cC|i>n%K0Ra77+ID@iT` zv^meSxD~fIx{L8+tgxhooj;~V8HtY8umQ08IN4(QI|ESby?;*A^({r;mBGd?qqz{n zM6sjX`}-(t(JDP>@Z+V1CWDU#UNhQt#ycW;L&JS2F}I1Q$nSBr^TxT7GBsScmtDx= zXU!V5^bV`7A5c$)K0F$XZN$?lz_u}qvrT_5b$DMgy~0O1*SXzX36S?QYiZqa znGa#3x_~*%JMf%b96nVNT638o`BjUb8Q7Xp0$O(ANFE$0pk#tT?TU@N0O6l^YsZAB{rOR$<9Mv86HN8uJ#9d^dY z2@(iR1uhb>p8Wy6`E@_F%M=)8`r{bIzP*keuAf0esE}z$cBkD6vuKQ}ri8=5(A` zzm*b8+u4td!Tf(z@LG8W_q0Dr(0>xN9Ni;d)v%@1;DMw&7{An;9zSr?w{>r|tGcJ* z){~fUbsmh)V>99*&1Zjbkd4d9KcxHkTFo2rTm2=|Y29T6n0c^AW>Cv)qu>uG!5bBu z;GpKQr}S@M=x06**x<>9z47KWhE0s|y+}4SV{m_E^Ztzt{duisX`0@=$L2wZVbkZY zqEAW3aCWkJzG-W^pP)L6s$tanpG?C1i*lIPvrP^ylO`Z6$of5@?&LSm-D)~wUX<&O zlWv$X;M4Vd2r0dc^ySBqn>I!rjac9OpbR^7ZlTuoM|8(h<@ROidVAleP#2TF-&gYr zA9dsUo(tX`6PiS^-2>0de`38ySk-k$YY=IjWf_M*4+-qV&5ZUsPVLz4;my^5`B((Cc1yA9hWxGAdW{ingh*R)kfwb3hJ&F{wd={OP z6KTvls6&&1-32CCdqEbs!AYU}F0i1}w_!=biHcW?3MK-AUy<({Cd4eKJB`;OJE|Al zOzo5f)>QAJ3ars?KugIX;YRJ0rod4h%^+-e*d~)i5Tz6a6$AD(fj$WdBnwQhAvkUq z2F8#vg~xE51q%moxyzH@&?=885?>_HWJ?(!5l4_kg01FcMEKw_hctkDqbAxN?mp_9 zyImV^VmzwOy8xS|EgJfhjB3lUK+K0l8)OWT#;wMi@xO&@D+fCTy}1w&*B_728Ue#@ep9#u`J4X$3qvdB!;PCOOmim3o|;`?Ue2#7hGu?7 zZd>xQUQCa5lkBQ`goeiFlNdG!vS_B=i)rAg2J9flnTv}67r$vckf$RZzL$GkV=nrK zmXC!FHb1E=8pn_g3$5&d2@8~+*vy%#+V;P&p$!GXMZV9(K048{zS+lovtSyLTk0()A9;9=R=boOcG)C zZ&_I5aLFtFt39vC33(}gPy%g5@HoXNb4WeCuRl{k@K2HKRSj*;pA)f_Br}Um?x#LGlWh3gsGq5ho8$Wkwf6 zAT_x6@KwQ(C2wq^$Ajd3il--Wlen~iO^Y5AHwR=G#p}n~9rdzfjyG6)8f(6+hWik& z#}saJB*c9^#P*TJ{{TzA3IzsJ*hcmRZT|pc?u|s!=E;?U-G}{XIic}W;vl0_&oLILh5lh@~=S)Kn~=qIrwg9?y4aVhH}$Kg`tOl z4Uc1p9-#C960%{^#{@&^-}dcE&6=;k^V`|YvUl*b4oMp zqrutq=*Ko&$uDS6CssNxnILu}Mnl`!#~s~A+$Z9OXk9-ZQJfr!T3qIiL4O~*1pMqx zUt4xYpw~Aa8atAOg7Luq>KA3P?>dG{3B!&50KkNw`i~qBuv{Jwv%w3Eu`#T`n%vIJ&y}&4IjwWOF<;AT(RD3J_?mq3I!2t$KwO{?`f+$* zSstDIo;Ou#&(uSXF)lL!$!nN)TXg(6Khk->TVLeEAN}OxxAvKFfhex#xRb+2DTXPr z=Pa5s$5-hhi1uEesp}$0%e4JI4J!ze1dbi~5)XoR{>uw4R-R1lY%)ssu+-AN-W)uD z7gQ%Hc|LbPO^X(;8^`;<>cEe2Ewg3B?o;7!baPjR@BP;4&*?w(m;*2+IR-DS=1sf2 z{gn=ugGF|v_v#KmmW`#wo@672-+-5@nwM$1`ff#=0`*}pQXlyk*Bkf)fUM(z>C4>e zZorkS)--)DB6;W2vSMUnGa-q_i+|b=l+Kyb^z7zpF=ai?k+BCtK>?$E$tT4j<%X6* z`hI*}XQwGcyKQCm_%W{S2k9h_dZljv0Qh#A{$*=Ziw+sz7Bh?34SJpry?iI);LDSU zL}0o7;(+q2c-6BUT|Qq|E+}_PPqZH+NsK(6cnW9-@W1Szn~9SEYh+<X(`J2NrRh&?0FS=#30KK@gaN?{rc5u6e%AsBG_>*P`4ixJts;Qo zDddV#Y}cgex{1%IgdyD%CfoHWD>5^+mQLk93@MICkF?#Z`i`44ENLLpJxJYbXAY04 z{vRyXDfWXP0E#KHuy@c>v4^zKvK4Y(AGj-PJn1@&QzdaBfF{#}Y;vP}?1e9=2mu88 zg!qD;+~sE`VZb{oLH(neROOVDu|to^YpIkm>WQ4<=X0`7Z~;QcZMtL0Dv~&yq~&6J ztk71Vhif5KiG;jb(7@IPiwe>rOdTv#IN3!Ee_hhKlPDyHg#-L$0L}^0Z^Q| z>PRU%sMKSpS*Scfg4$717!a+lw z+DR*g?r#dWalO;Sg;G{k5}B`JqjeEsL`CqM+(ImA5_h};EYfIw6~f>`VNyCJc?50B zi*Q!~q~dHKuLnD?l(<|-A9M)lHWvt^vgZlcVE}cGqq>m&K|oW3sXGRQb}7NjgxF0; zbUf}8nBom6?RBScorsbNOC$pJ?!Vm|%?*4&k83MBc5(ZnfW?Rn1RO$ka3Pb0>Lxv&iWl}Gb5=_Y6{G-@dR zsU7`=1xr@TmpdmXD8Ah^j+1@JX*&QBoI0nBvqvAE@;g(Yoh~IXynv9L>wg#-Ae?yf_10 zz~0_B`yq2=89P8=Yex+nebZ)$vR=!wHnO20fCq0BT5(vG* zj9sVl1(@AdJ=a+N(_bpMBo*5##X-n2s(~e0%$Pp{c7wO@I1by%{@V=X5{3( z@{-^lPc7k~e#~M*Kw> zc$4YcR71La7+lHb;7IqIC;R#Gyx<+TP9kIbffRX7J8+tQ61wGCG(0#RifP!`O(|M- z6i6R?6w)ZB+E$g0hj%VoX-d&yL#=a!+g-G*XKgE7waZ8cUg=tDNCTv$Tj@2Sx49)$1+5LC zZU)t&+acxPx!V9dAWX2yWyfP#BW^Rza#1`+W6Hc49$F@G8xCn% zWG$4Oxt`A8;oA@#{8FGM#mE>>Gv{MJAUkN>@Iw#V-E43=R~h&Z)+E&;$A9Z&ZKpM( zz^{L@tBt5>nw$MSU)6lfrsHD7-q3#k04bT;4sTAs6H$%vK0_!mVVjWq-*1{g3kRvS z?w!jSd3aJu>NJR*C@lngfVL3F()~$^CZVk6x%z~{qsN3?fd2q17}3d1(Yo6YQ;qRw z>1Qulo!*>&sB2*jCuWQNBj3qXvp)@bn?;G*_BKpDv@SBb7)cI^yxR%py^^x1n@WqV z{{RjpX0el`m*Pm@O~LL2wWRFVSLrL!`cJ3yU&Ln5uWQ-kFCoCj+z8xQ%qHH$-N()F zhje#ZOV$jFL)J2(jw0HWyi@Xr{{T!L8}fNR6;7?`Y`?>-n6>=}Ff$a%+UTC)-yNUR zNAF{`5ptVpl7v?PYQ+< z89#&_Oa@G6Cq>Tpj;YuU*h&r&B@Ehz&d6ygV1O%mD0O% z_XEQT{{X_xWWhF@7Csa>m8$7EPL<9Mr#KDB1IQzF>m7HdKSrM)uliWVet_)g~&--9wY6Yg#rYL^HA)%8<5zBZ0Ry#rr0oz?wYUH!dAdBQ?S? z7?I{c!Th9~rIUM09OjX@G`(A;VZzjLdY&wYwX)9xWr5TO@tER6N44LD=NZv)AQVQ< z3A6|ryK9LBnM18Thjkk0 z#|o58?sfYVU6VX=Q=y}3u$tm8WL)FM_H#uEnj*(hLXu;iHwf6qZsjDDNZyKT8s?Bo zO({uaj^A&T3M;mUhX4y)-TW0z->8q3VZ;j#H|$ko${40eL;>U}Ss`F>6nlkl;d8jO zSgrOy3NqUkKe7ko!6bwhv;%u@_fUCGXeGc6i8P-qFNx)@1Q3KKAIWwn%Zym|l3GoI zIS9ng%F1Ih<0bBl?&H1uDi~PKnwVv4So2>|^1AlVre&C(@23141x>3v92_BTKjq8) zGB4#sW`Zq706=T1Pj;VgvNr~}BslqoPyQkwreRx2AG!BHV#<#XCG3CIjgZf&x5fEc z`A=-J2;FVmSn?Gko^M`JvemVW3Cz(%%Z=7*><=LP5Q4?1jOJouWUxHM@FSG|pxgZ? z+$``l$0)WABiuXti#&&a;Zc^-l&s(N9GVwqGcZ^kBO(G@uF~a@Fllm%k*|g4$la=( zj6MCZ2R;0`-T+o%?)@#fPnM9gP^H1p^S1ecPcuoI9loSwNgwqz-70wbGD7y2xPlLY zw9v84dyGyjKg}88RLa4FBf0Va01i>PY1kCImyxP{(CwG$CXQcFoUAfgFy2T8HV{!ME5GnmhGvIj_ZL}o2`rj8J?Ozm$7 zi)3pVx*rD=dEf)6!BM)_A?+dMZ!?RgX#oWP08Q_VxDGi~rTG)VDLxGQC36U(jp1i^ z5Z4-2Wz%KtC9UBNr$+t31QltR$}@+PbaDVJWP6gfS|>|Sk=rc0-rz4d({f^vuonQ} zcD3yNJFogJYb9u)HY3VXQrCk_QjXompB2&Rk$O*$#?%yS#BO1dSL_b~Ir`3@mV2B) z0Puw7>Q8T|F|4+iKc_9ZJDzB$+9}HTu(F7-M+%Jj26wo|HYj@}Gsxp9HcGtT^r4L9_!t8EiWHC8N`8fygOOb{{SVD=7Y7W zPUA$kEK`i4Z?Ur^IBkTvk-?iUsUwKr=<$BZn6p71P|3-NzZyQ_3~u4a!LRbN+Fnx~ zj$M%JY)m1Iza>uja;Jta@w2{&ujvJO*)hw054`ER%ul6@{KIem0Mf+yrfi4g6TU0^ab>f9a zkC*y~TP)MJ_J*_M%g>fskI>+SZZb9Jyt@qu*Dy5adW?!-U0Rs{)pUToq1i(fC1jt8ZI8l zB$7H)^onTkI9D-?!=&`bbvDg-0YszQBcrCvAL4O2NBp?|0I1UIM*?YO{GL z{a)oWLe$@j41t7Gj^O!OX`>(;MDWYk~W5bD};J!#xXPh0JQT%HeR7h5s*_($Z5+n z5qqM#u45*Or~tDVTQ_ZqT*#Hj=_H-jZx?y$nhtCvNLkpj<*9 zjqY~MMFS;Z1hZts*;XuhNdl1ri70LRDIm$GZqM+n%bdZnZ4a^uD&rZ!Eec8GnSj_% zhaw{D37JzggT1CArZzz@+$)(A$Jl+;7|mr9vWqc|E!dz6Yz%YnLCF(or8dwyI+di71aO7a)Q~f`Yl$R_ z0m&v>>Q+$X)RMFS;8IPrg`I%3SWxB5qO7wADd0FpX!$DKT0TsJz)IO5r*3cEOz-+b zbGhLh9X*ox&uhVVfKXS%Ae6%WiyT3td!*5%W|U+^#*%j3UXK;-0G9#qrG^j89wEfO$ni~TZTi}|551VU!VxT0J|>^y)5>g*X(GZ#Av(g75YXQ<|# z-RY7*`&qTz+~!W`AZ-X>1&sh#bFb=o`6v7+b8sIlZI>N~y1u53$sXzX6_i}~!(0Oz z05mLeqh#%COKR-ye1!{`_6m4&N7+{-0!VQxN(r@v?-UJ<#S~gt%b>?;lmR4wANI6< zqJm?LiJaKsh3x|l`#WA6+_r)l_DPISGc z#iSBO_uvKZ{{V))Qr!!t+EK@mnuIe@20H}!SUoOK{X)ZN5byX#AC_Zwc?Q3MKo2C) z{{Xtmc&chB_I{DpEPqN;m$oyMfAF(CJE4`%CC6(Zs;3%CYk&k6-z#+NxI_9|fni?fWfT zI!~vy7We7e<6?0?^s*br?hr5ac;|1SKA8?jcj+J&$Ue>qkZ3(X;OQ~+%!3=ZXadb3 zT!nJ~01kSl7J86kvo1dl$9R+ca=0-?Bky^7gsFiX;`L$HmOjjxM8_ zj9S+lfInhShj#Nz(A}!^e@;Lq(=?_@lnr;x?^NH#@VvKJ)-yGH*)nouE-rB(9tXfn z!0yjMgRL^;ECyE-S9i+G>JjQ)N37O6OpQ--8isTNfXw zlgd|POY(Y`O@0yKA$({W6conVtx>pLnJ)q7ar0a{oH?Kfcb;0 zvm2MxS?*-Mq-~S3H&uNDg_yM@(ivrvL;TJz{^dlSi0!3iaU@s@(zKFAfUPS@Bmk00 zBnU|al0eR`F0LR)Qb{F1B$7!;2_?jk2T}`*s(?u(l6C?}B)SlQa!ZAAGDYP$0!;-=`dM2 zW&@q|$OqKsj{vFwtMry?Y;3q05@l)xhfOIxk;VSe?p5xX>Iph~RhkW9g|fVW{HKE? ztc(xRz;+kztI4NoAU{8+ak3eP*3^=bVc#HmrK#zzn(1wSPsx{2)P^+e{Zl>Q$miET zR^6l9l$g-9ex8G>WoA!HbpC8k7GIMg>}0<*PRHid{Vmja`cAEnqV-&ow-z_k*)G)Y z$CKSR%djsT&7Jv zc?riZJa_Kj?l!M<49Rsa4mLg(4ymSQ_X6fQ(Xa-FunHV`3(e$ob4xe|!Ery`ZhE!Y z+D5sl>DZHp;>hzOS`CQH`CS@lntES z(8VmHsm(C>l+x4>lA` z8=y^hh?85X8QjrfM)01;5D><=ku&lOnMF1tM*bC7`>QaJ=5~|1UJ6o_r^x3_;A|4A zz2)xRO7YrF@T-Al(=ovM~3dSx@L=Gky z3s1r2Ort98I&kKN#bu7sD$2*P<*oz}Xo8plBv$J7M6zW_T;`7Y-212@l))fyXe1s8 zwC+X{j6F|xX&bN>P^4E8^kHmgCyyf=zB}%04ik0cI{tC5|;slk}gKyTZzgZtWy3Hk;IP zz|jU|P07bQ7C&-7_MZzmsrg4wM=q1wKG}Y+a{mC>rb&SQvpG1T|__E~o0w4OrT>NqlDPSKr?$42)4rj5!I znbWw_LTA%*JN&vQY~l7%eDZB9c_oYdxq6HJMm)&k&_SCjIBjJap1+5q-)F{eHFZ@HOw{OLAYSKyhA^^a~yG0ps^ z!BNP=8SRvB{I2j;q(h6H9g+{*kWi`dCdT?mGQ@rP2_{>Ko5;b6Zhn`4P(gAqGI5+u z5(eSHY9)xr^~QUn@;rp-Cu#ac5PTmgwfHmP`+*vEzmtqz9M>dIX=~bfEj}%7wA`$0 zc=Xw$%M!xC;SoQoClkC*9F`w-mdMhvGMMK@^vF3JAZ{-Rd9+9?^PRN9Mdszd+ znMC`dm=Fg}#*ttmI_QchgIhq6;b7)^II%?-s9}hguz|V{k<-FS9zgj-F^Mxc-r%XS zGUkckfwIyrN=8{RLQv$yW$80xKj1%GsP8KqUy&AdX7`p>)Nb zK1fANfW{WP46hx|t2>3S#?2BB;hSk2uN-cjJD>bJ{g#6RH#bl1610~4rrm22AU>;EEGe$piUB`u)cT(Tf9aInn(RD+J4gWTt7UrAM9$Fj6fFQB4YU6Ma+6z1EbGIPaOtu` z{-yr_u|UZy-?h2i4<$t_C2NS0q#t4^t-nj-X%I*=b*ALA2XNQI2dL>hHMis3qB-+^ zA7ojB{ZWLxl4UG;4e?dwJ*oRl9u+wEWbXd}!1MM-Oi{d#q!I~AX`Jt-h;M+3LflCq z&yF|9SkfI0fC=8dui00I7?~HTBdz4nZ^yYqnny%>dCC~{mu#WkFYVx@-rm+1Ue2TT zQ)GuecQ7BNn<(VmxPe=Re=aA*KF#j$4RG6=2y*s|9w|6vOWPU8Z~RJfICeFoX7loX zO71-GiJ1k4i`&`z6S|i#2QwY9Ns$wo>WgS_qDQ@ZB04UIovGvIyB;=?3qzzO!L&bg zHx&yUG3B3As*bYL{{SEn4&;Sl&v0a8k15$$xlp{d?cmjeVGzdBa`PBp3}m&9`j4_w zoEI)em^yBza>)o{p1_%0T&;affE(EOOv=N^h5e2j+LmZ$5HuE$DH4=kv{oD)MmcBO z6yqqIh3sxTh0)n2gR6y1&~M7Ta;pWH-~cR}*+R{{Sj;kP8O(Q2AcccR&^dqqfScE5QXZ&!It9B={(>qrKgxmmc*Q zcKfCmSx9t0y!k7I>M~PHlCr3Ia%mu_$y~IDLL#_Jx|a)+Nk9%J(^m;xB^EQbkxjM4 ztg1U{TH;Aq9kiDhPy$ILkOE0`G`N5PC)gu;c8NY*fIGRM@Bp_TuuJ*?4H3lBvvSB0 z#Ax{;Y%_XyCq;po5@0wr#+vCrQ9os|>CTVUvvlK{az;OP>;!TZYxxs@gU({<;T-YB zHM#CJLtwO8u7fs;=$tW_;O2w2^q+&H>RH`F{9~AIH`ApaKFd|qeKVgM@v*UWC(QYF zdtQG?_f(@3Cn*86$no-FGD^V0Mc1-7i=*lCMECll`~X$RzYnwF!J&{`Lw7#tPL+u4 z9G6Fy31~c?6R*IoUm)#b7<9ceBPp-?$?S|DEaw;#Pvuz^-sDXn4*viFXCBKWlU{4t1pTC^4-#VLpP|443xDvd z&!y%0M8yk66oD5o!)Dm^;B>r9o+8(_Nn#WKJHl ze@jUKIC&TDnmSisFYP*Xqk6IcZ};I;B^_wz>pE_tT|}gzIc?l`K*e;DNhgZ!2jrvB zX}!7eGIkQ#52)Zq#x@)O03~QNo|}gP0PNh5#x!?G8AZk38b9*ASMcwqBGvNqH9bfH zh}gp#)3aQCuh(U(wp|4uU(r5OZ1!_B!Am`r~JDa9XB60B*!_7`X}@dDXkuR zz7~rYpz(T#6w1~XVll)#MrqPG9mqZ#{{Sm%FG=A}%*`uF%W=evhf6b$b6b1*0mGki zd<~Xc{{UXc(wN!!I*SRFl6EnX3LT(q8}L_ieW%FPNb}#s9+T4gOCJL}0G7KY<}(Y8 z_Vx=d9#%h1>pZ+tJ74y{2yaRnGJfAlx{*zvox&gY1lUF<~IU zb~g7o2e^ilxn9T9l5|u!PsPa7+c1y<_egETk7MKZTRneV=|j`mSh!kdFl>;Pf*9Lr z@J80YYh>lS0&IMsJRY&t`oB!!=YzSj??j7y`Il;XCqh)zcCI((xh=wOP4aoyw ztH|>ASw(TPGQki=$ve#kwV>HPHc22OZ>NS{$2R0U6a67=x^t%W-lm_sko)aUKT%uRQ!->r8z~n3&jr zG0uvo?L40&ZbyYSuhm$3ZYCa7ITCu3GE+V?eu&*8{{TrX^V+-zFDgu_-zyJY~NgTmt#CKr+ZlzBf$>7oUrjg`U_l z*jUiu;=pzQtwy(vKCPv*BTUoZ`Ajy{*%eK*;CrE3!`YpsMX6-u_vXzpXQTxNv5Rfd zlIz;;jhWMWVTw526Q!P4@)$V)e3XKP(OqQyHZRFO2{I%!*kWnh?4X~fr#)AL7ON4$ z#nfhTVsa)SN1_Dzx$t4-uqbPG;DLD;ztXkiHyw8$=*2Suc$>EcX{(>g7O};=_xvYFB4zW<&!DV z&Lzrx(X_NmU19xzP-#0?g(Vt}tobqtS77Twno_owG0<*&{zw zPuTJByesh^Ny_NHsnfcnO8Oz6Ai3=uHM4T&ANIU|l*tbMEA(6RpUHJ^Ped`N)85Zr zkhC-g57Qt6+lPCF>N+=4X?z4<5uGM(SL@!%na2sWWDbaW0U9 zWv$!vkG}r^3)`XmKIq*$O~`gW3nw`+_P-`)deTV8j(gq3^R+BCA6?Ihqvz;3Quk(Q z(}@bxxI&Q2eBL9x);=$7&*NS z(^+sajmX1%m{}kI3I1l2?_pNW>IrmCr2ha`$0Ws)*F~8SG$d&hZ{&^s>lc>nh@i-V zMm{#k_RQGM)D8BZ>{3g(ciIh=;!JSgBXlLgiY<)L^BYOo&h01ehRDL#y{C}k5A3ap z5Tp_*DH!WcXX;U|gIl0zxay%xk%8U1h(6K|qhSWSM{6v~(MmQmYYUHkjnuKeoA8l+ zvYB1>3YD~5L~fI)l_`$fW0VA9_LD_P8Udu{Hi#>avOx1{*Jsc@(`-?O(vw6In+hg0 zfpob028x-7=^&t=Ga@I#nkI^)=YpaF&3IQ@z|q?74+SR5#T%88J>88U?0gkW8a8(Y zPdOr*cdsfI)f+-5C%%XML7>*hh1reO0yg13M!Ae=YptYRdleM2x#SWC!jL!H8744Y za-{@=xChxr(khCO3Zr`hm_V~6v9YnfB3k~^9uF7p6-GXR9#53{+}B9=4liXKY%bg+ zkmo5m@J<7mKm^g{9m1AqhjeeF_d%iu)B(c4MO@I>yT-v;kV8LQ$C@rv;LLysyWFe}JVD*>FQPB{WPo9hje6Q#Feu} zeUdGa+mNGaqr#ZX;48x1F0w$TVR=;i{=A0c`BXOX*i6~QBe`-O}4MFY$DJu+C~oO+NvHcH*T9Dq*= zw>g8giWI3^VZ)gr2 zf`FNbb7zlYKTrzau0dqX^Uul}vBqBn8bn4%FrCM;^ekrjaqimLV)Otlm*sjPhtzCr zXC{{}N6G1Q%d*W5iKll(>XEtJEcZ~g;#mPV+7|l_uEfM>aG)Bz^IgengwMWhVExB* zA7q;_Skt&p>%LJOxtityThh+{X^oVSceGKDWS|m4>rp&>x#>wF8Z88ax=e}B=gN2h z$N=FViv_-rK31*K#JQ1sOVXGa#}EiV3eK^nLg-C2ZWe<|#cQz1CvY}YW_WvF89R-s za=A-m=x}4jEHrqYek8ES{@bfWdTT}h08-6kWGA#caqhI)xN*JjX#&+PA0z!cI>Di9 zZLT~XS5eaXbHB9ro}SY2blj+-V*mxb($=ylWYuPZf$oaemTB7D*}3@5i1Eo@j~t^D zJ(82$;@Vu&UEG^u=Y)AbT<9N`$dSR84cMiL>5VT&%hfcoe@k)Cd=97OTb)+9{6`vHAzotf;t96JqZAyHnF|p!A zeLNgy0M@oY1cBtNB(p^+`eFsgW`V#_zGu#Uvp{Wr08zc*v^w{C8k5b1RJ$#S^He*V0UvGYrG0B`BRcT_H=YTQjbpBl4F_Opc|_R}{#o%lFk~bU``mmY5Na}h zP8?_(+GzTY9G~4p<0pzIUrV2+k6n?=+bBo2KdbOw*Pdo{Wz(4^C+Z~G{^)L>s5=f5 z+S~OByZs~&1S+#j36Pe8Ls&rHmmeyj^&3%#P;VpUX$*IdR&w>7bN)VA@yB1cx46GP zd{P$=MXe{m6pi5Oj=;nKT}jAUM>xwYdkY&A?ucp+J<&yAhO}^^SYs_>ZPNWmHWi$I)t&m5uJd3nkyba5;TNW&vTl_abzWv1#4evw@dX|XXH}*`4u|p$hi$`V2 zf$)G^^#w?l&awG2LI8}A0XR%jm zu4D}&>{}fE4zNOv!jpTcBI`itX>~3VktwAE6|OE4xJpG)(o=0E#8}R*B$7ZRl1WGjbtIJl zl3f6j00fj@{Uz~ZiSk|;59wvw&+Mka5E|zY03@FQ7>7rj(Dmm9k%PY5qkS~&ICUt5 z*m6uRXxCe0^DbXFFxfsvLnTMTj7vH@`* zS-)f_rTT9_P}gNR+LvT-NPmboI~}%Ha5{Hin@E!(nE4Tz8cAypXs;VA)`6L-;pNGX zrbj54*pQLI9_pxzvq9G|Ytd^k;LDnFyP6DOR@dT!H5@y+nrBsHOY7oBS>L~^ z{jdK3D)XS~d`)b!V(9?sKo-AeG(&;eYH`03aIo~IwoDhZBu7kOA4xy>L3(?v;mFkA zk*d9{dymp;fN!u=iDtVmt93kBSsa+oVIT(&0aBAx)279I(*O%tT=IT5R<#{xNYv$Q zQN6Ag`nKI>y4N2AOzEj4iQvnU_QKls<;VL4J|Z4vM~!4^GRvJlRX4rwBo{P0w0NL) z;Z>6(B4X(zmCig_Hn|hyFOE4H13R~HA5|3rpj-yv9hOHxe^bvh;$UO$1TcYCg)o{T z_E47-Wb#v^cIw4N@Bty)wD_W~L}zIZIS&*zB$BAa;dXaF@TPUU^&4p3hm}MJ@E?yH zt(PY{SmQoeEyv!MyJ%XkOBTl6H&x3GBC;jRXmc9ce;~ll0H=0Y<1dwA+3HKY5KkvZbp{&!;v#8IsviDN7UXpvc7e87JD0#*W*6% zoLe}nbYvPm!;mk^`d_Ct+zd=?7&3DmE2FaSMd8h8JPP*+KU?BnKl~W zPY;sj`5g<-5WV~$s+&C@+K)Yxs*^m&dP@*mNnnWJcVSqy2!{IF|w9qy0{?E~%={BDxz=jF>JnDLpUWiS!mKs?y@`B)mM zNgpg@>)MmHP}qY;mwTtAu4_CCQaAo*uhI{vR5b&g5KCz|xPPivh~krZr+;}kdlK&>Pd*e4-ak7o^t#-P`?Ed=u`3<#pdo^yG45VaE}W0vgsH*uWnv!SlZq zbD5K$Bp^Nc5|=dp0Q7+rLw*$_mU5isZ@NdQ>m6qvfuuu)2pG}8&cP5p&T$)CkCJ&_ zKc5`>hMSqyI^5l+MwqnRZ|0Hz0R2P$){pK`$TS|K>PAhNUL=vA%3*Q(+|Mrd{_8of z>v?*VkVhUf|Z#NjF6cdxUNxHPLS8JIZSV4m z987r_3?K&%M}m`P>J7xDjh7Q+k||(~?RNddeL(ykQf3n;7Yo35hLg|kpp}KsAhw7# zRGl00F^zyW{{RRkh-b&12X@NB)8f}6o$-)G&{K&{O!qU19@eZs4j~(y*})fnpOgZO zpMirvDr$wVuH##p37J@*mvdn|%xIc61^8SHaeG8?U*CI18X?A!rSKQZM=n41Nt#C$ z`36HH@F#I}412)g5$)Z3$P?AYDN_7$?lKd9)GiS`1(n{hXoVn!<6%U^Wh)BekLBFix#7b;T%(UWi%hH?dP-M zQ^3a$$b-55oL;*a`H1>iWLdv~x}RK&37Y1h%p9lWV~N}%o!rPjtM@1*G1Qt?exI8J zPR0?(m_2-WgRC{Oa6a^jbS|LH4_50tUScg>bS4T)p8-kjJFmT?qve+MDd5Aey}mXE4+jXPB6tsg5ER(^W|PfhI&pxDT-w|Nkan8*-q!yB@aw5`?0p_Qtjy?Ojvbt2 zcxVUDJpRcvG%Oe!(tnB>+DNuw>g*HaH-@%N{*n8F7pdzqXtCgAw^MvA#(ZvUrQ|iG zq;9+y@k6U&*JRQ4EgJ_dvFX`6YL1MtguIGtLEL~v*ONBUdwu_+XIKSgWW{)^Ok+9ys)6wvB2_TtHw9UCZLY@i=Cx0_z*KMCKhNZgLB z*YdRojmA7A!vhb%=lcM%KZ|$(V(Gm_r?5wnr%b@&(N!6Bjy;|J7RL*%CC<~aGg%=G zmLVYDgXO=mN`+;A!^V!0>YZDorz6sq^7Q!#0LaI3+wwpk-Dy7+aqzW1lGLyq_8fs9 ztpKrM@$Nsk*?EWJZnxQq(;ZKW_Ke&d?#jAzqkC+M@+=@)c6U>C?pxWUKw7{*kCiR9 zDEqu$^E==pfal;X(EW8R-2ljPWVv+gk3cw`{U@}T@9p|miuF#u%$%bw_jZK zPgZGp-6eor=$Qsq3Hk>OC6z!AW3u^M112Zwy2hU)0reW$;eVD%0XP2u>oky*T%RE* z&=xlq#L^E2{{YHa)%m$d72JEjxU^?c(H)Fl>}mf1Gm6$g=Sc{V>~WWn0Rr~2Qzo0?9BXfc?Yk?@sq(P0 z@Z8ZfPGKU&jfnROm6TjxD5r3BDC;A&;ZDZ6yei=DYIeVId>~QOu@lQ*WOApHZsN$n z*p(9;(g{DZmXN@Szez!7xKL*;$v8TuY#)w$V+?LOGlLik-xlACXqODA`zB7 zyZoi#-YPPmJ)vDMIABZb(D%Jv4UlY?!t z0TfmBjSsMV6cn77EYxT- z0QNV{uV2z*W2KGfdR`nGCJsv-y#l>6M%G){)7`auu1wMSJsyuO$5Yd_T!#Kp!K4qS zmy2t2xv@yw+}hFVdg$ye4%_aq8Tr1uhz9pjiZXILGvO-e*7NG-8MjC8bn+Z+i@mCC)D5 zmru#&s@C7Qua7e!%8F9kYhDR&xV}HKzcj34eJGeg4kSAHY21H=A?$NpLz-H7qA3-L z<&Z^?DaF4-nn(8k013$v(`1sAm$ZgfMkBH}ExnD=`BLL#mSM{qT05NJFUSfjG6~$) zQ+syJsfq;QP(J=eHYxM;<-JaUv{_x}K-n@ogBmMn@K+KVa7c1(qY z*LJ|E^yagal} zbWalx3QTsFJQoj@Okn3f5VStP@`YkyXGfA6UTFNLNJ;v3Aj@qy0cuTGNq|PzHN*Bo zwOm}tCS%%32jxC_^A0V&q>4a`hXszr9j>!T6cNuHuV^Ne_&SS(PGKg-%A4~$Wh5Qa z0z8M!9J_^HT&EGf%6X>}kV>m3V}&3HPDPGXCBT%Q7_Ew|Lx&1VM2@1NAces44(p}p z9S!awF8!AY1x8RY#HJM9<-+7x&XSr+;VC6$32`Kn0VI-00VI;@07)c}1eyZLQU@(s zgBnSk16oa*01G7h1)=H93Qbc}gAI_GCXoFx-)lhkarOwCI(JcTSB(~2h~bs9hPmu_ z($F`ypMZp$3nS0zJzGW7BFxTYc2ID@rO7Sud6!IeG#VDF%|ZAgVp!nD16`lQIm@#Sl)v%0U@N>EG;x(ND(`wE_8*rck;HqYpwLOngm#|$rzGA*2WoD zK6dc1`1)5)903t{G7t%IG(vPn{{YH!skMy@skMw)G0S6(hj~xZKFe1VIyxLyVNWa~ zR<^{P5`OE)@^Elr%YHi^9O6J>2VwU|CFr;QS+X}Exx`<>YhqhP?DpX58UFy4#B)nn zXg}Q#)_Q%IF#3i-;yD2a{{TzX^zbHbz-}BAF4m`+;kj-k1pff3HTWyz%REkLYlt2` z6#Dj~Hcl2CPms7V?mM0h0H?^v#WAx`Qa|}5z?WcibegRN=@(sI)9>ZXu7D~IB5No25rrRW8*Ym+2-A#^yT4t@4 ziu#UH&~`powRG20h$D&5VP?b@{-(Hmub!CdJ1rI#ds~Xg*y$N4c_rQ7OPlRqb#`Sa zo1J;=>D^{MOGd~r;bxE~g@hi*a^M`s%J&b3Hk#jx z;dwTxn=V5b*SwGoiz*i6xvc;=`*M;|E1gZIfz_YsugAdDy;tI5$oIh$4Si2M6U{GO z(|;Cpyf`Bm_)tRTIGG;N-1!@PS==w0vKu~6eC>tqjerL{G?tIK;4KD^(A`z5wm0Hw za~PZ~O8)?&I`^~TX7wp1&vVs38zzzo4iF3k5Yw=)*?HmWZn5hesIhRv=pU|5;?@tB zJHSV}OYrMQ#>$!65{{T`UDIZUHsxAKj7QGV>rJUNb+2KdoDG^3M3D? zrCrj((tf)?8>F^6U!xvhxZuSDa!ns0SdJLlM{SUKwORSbfNMz~C02e+&i;BH!(`59 zmJ7r~Oqk=y93B816Uu^pLL&b0ZhyH!NhH}jq?wz`C&6w^$)Ehx6;kIDWRiYY5(qL9 z=xHh8n_6=S2X#pb#sNolWsC$T`b}`#mC+m8cv>VwXBmw5yXkGCSorN=9qq5#T+<+U z0G1Q`DKpE!+A;z2N|GV4bnrFL0j;s{kLlVwCJnNR^yU^WNdfi0x+kpR{zZk@?xH*e zbW3J;QPEo%{ul(0WD|HtYuiWVZS*PqS!*O3K1w^Pbmk^$4u*iFP+8_tG8q9TfkU$3 zB-3~JT1@>R_@&Kh+#&e5()WWSO(KH8@xoZ&skQqmGk{$|dTG;OlNgc!G`#ya8`8*g zM&K0`Qg#ZGAy%o8MHP{TkjIK8M3Jgv5=kYILP;c(0VI-10Fp^00Fp^`0(cgf97##( zKgcRZz)CxWK$5s{-UZR6QOzLIeaI}}-4w=+k;3_00VMXe&-n_JF|hZ!&!Ev@RoV7h z?Jp7;x?5k#{Djj_8{h(PEs#arONl-SJAIIV5s4hKV=>c9Sgput>?dbD@wZ|I} zW8}Gw`XhPWtaG^THFT+S5qy<;16R}VX34^z4YJFaL}Ev{HL*oRyxHMk^5B@{pI8ds}Z~{gG~;hYlT1338swiQ+@wU4%1o2=n$@PsAN#Pt>!t%});kXjv{G21m2C zvpJ3|WxckQxvkshI!C~IEG*&(NRBqBXgpyKHrLy;6LdB%Kk%Z^@qiDnk7zCOp&3h|d2c>BeF}YI4*(44jrQ^H;J)6KQN%(iG>H1!K zq|{`NEHjMY_q$*=@;t1Lg`N2xq||Zrh$Pf7ThJg@rqEg0I1=8OYhM2;Yjw+S+nJq9kE{5;cV zY;$SDDpu|4`o4BH zoX=6xx$+WEYeQHGCeOfLxvpq>K9`r1hpA@2QJzSCf-X2>lm7r{HsiOFuo-wt`spC)0Gy|Bjv-s0F=LqR+XvMcVY<3`qMIK(&x%Kpb+ z06cd80NoSn9CqUBStXzJr21Y*>M!_wtz~vE+^vtgyh~p_SLVUvZ<=K!lred9VN>F`(Ur zW#kdY>6xW*vL;Alcp*_epF$1u2plp!5 z{;K+$@)m9~S@l(`VqnaMN*hDSQIb0W@^$e+VO9x|}WB`=fb`-G#45U2m+E%Jmqj5Opg5{S<_Q%)<#h3>Y z;bBjZ=%jG$+R;XIwxuLp(6Bgju|sFlbv$EIW4L_Mdqw@k>6$R7kF?>ANZ1HG&EH}YH9=fl8eo(=buLRInVqG-P($F# zdq`n%q-@5+8(thNBx^u;9oq90gX~Itrq5$Q7v*;;f@b#(oE1nPWVOfY2q*S0Km=g5 z?fQn`p*qVOEJ5uXgi=@cwXYnFim8yn={O(KLO}Uc6V-9pSnYz#L76Ty%WTrr>N40Z zwUn9*HjdZBF-~e$hva9zP5X&ZMDpWhG~<#sPl_@P5Sme52Px#2kfa0veabD35Cgc5 zP>5Jb6~ZYK$SrB%DFjQyAH3NcET}avvmsSmM^UWZb+OIIyDAnFCteajT{4x-(*r4Wzf~BZcSMUPhmp zkR_Gko4_S$=GLLbuS9ov04{8t$n?5cMMl|kJ~<(C@+5U%0{B_?Hz!jhJ>`*)ltv7E z{Y}PM+(S7HRkLA!EUYegY(tUmvqw%`yF~Jiw9@e)baF&N?KI*%h3h&Tojam*yc(7u z$C@FGN2`#)WNtzIL9MUZV0yPJOvuHNkhFJKA!Kp2Z%;|XjnVpyf>*dkN$oFnQ6tX? z%d>=0Jr*oka?5#ZuW@@?F=v)#X0^ER*>f6b%`Ngzu=YbRAEQ0e#&H92=5TG77df4u z%n!}1{#?^$OzE;DJDVi?d<8Bnk$NSq2H7Y#b#bf^*ZIBD{{Ybk zHEkzJ)1M#Zb-!LIjY=6A4r_jIVx#HYO(08?k(Bq!*oh2?eI`JBli(mZzN@T~D0>vN z?54u+s1gq}olW8QcM%D6c>b#$v1^V$tNy2Er=uhl!P{kcF0_~_RBn@vYLh_0k~)-P-pQc4e%9VZK*PTrH2xDqp#QlEOchb zS8=7YXPQ>?VQ4i-P(7FIx>LBHJ(YS{X$0Fi1@1J1&nKwzd@ephcD<8Y+uW+7no_Yf zwynh14UY?vM|4$*dzuGm+$uzpxq>=z;c_WjB%#4d1M3dgs|N@+H#i-}>WLXCbBzY< zq{L*VUc+M3@iHN&HT;eh+2>;e9~(Cx2ooOIvLT(FjW$lyjAS=acxWsjfnt<6nu}i6 z%Of{#_e%a(QLw%zF_zJ@f}(7xhpT5rA%)F9Vwsn!&mKbvVQuqj_GY1g;~qmA0rIb8 zjXOIGNw9Dm6v-*esWwPJlCG>31~#P=;(SkNHNuuCaWe7Db~~H02K+WKyfNfBAPxfu zs`>+!N@&>UxPk(z_DUpiyD9@S!^j~a(JSM4x;rX`?-zEg3GT(H%fTC|0wXTQ`AuWN zyIn158z@U@1&()VDk9q8t`b6NaseZjxJuzEq@-Ai;z=X|NhFX55?x6EaV6A{0$g2I zA%nPwJodNT`BE|#M(3S|-s@$Jr(j}evS$|=r!Nu4)`CM_$tUa*enyFpq!#1cxl#%t z%%;Wi50mn=eLMJp9*5J}8g@2|9GPz}F3Eq^H}YFv0&DjM59pctnq6!S3mJzX#9H^g zwgY^)lftMvXQ_2At$v-7*Ec#z3*~!_Q2x6f5gw82jblXhW7F_ilPvNXW&w^aKOaYd z${gOP>O8)uI>as`P<(-miL55Ww(Je|RmP-qVV<`9J=QvQOnisS`IsdlHoTi~eQ-y& z%F{>qF)R9bXB}8KC`0NPoZq91tK@ywL#}lmx5~-GmtDo1AGSW&8UbrB$=k|1sPzxx zTzxB#22LD}#Fjq6KV`_~9s%+;^GdkCX+72MInm#TSsL-nIY-luCib>Q8@GSmEHA?u zhf&R?&z~EkYduFfhwClyE8SA*U0ba*Tp5Ox{{UUCcYK)rh2^K*pC4o|O4N1s>lqrv zbKY@#i{l`dIG$VE;Zm>CXD0suP-k8IGsx3(U~4BYf>(yLk+>&-scQWPs^H^(Vi!6_ zjzN71z{5^QJ5Gvf{-?1ksuNu))ckomB(TJ{gp(Ym_) z5qIRjKDUZ+yE}uN?S}sAE2`-@tb^5LfVhi0`9mSm^Fi*(bD@YG+~pLa<@DpqGDg$2 zgSu8V8u20wJwGmT3mSV?jgg!{*2xcb>_@sIfvUlS0|Vm)#BD)(Cr)AM+LN0mLmOv$ zJ`~jr%1%dx>ew-2WjV1pn4SaMV{v{zWFN_;^jG3HOJE%YWNGXMTxa*VHOn^m_J&HFk_&t2Y6k0*GATmfB7zEKhpbJ(V z2^=oO=R)x2Y~kfqobu_VWt?pbS;-d$pOGN{0BZ?VC4(ytV;u0w6oZz%rLG^bN3nJ6 z>~n0H?LQ77YIRPa!`C`><4|dKUNhPGc`NEIC+cZFMIlM-XFL>u9Vyb8-ASAyX))uC zSKW+l?ybi5?4m%>oA&mmNM}Uapb%ts0?F5tj z#MLDx$ykqm*Yh-JdV4=jhZ+c=n;r4f8X66aj^8W7`hW2QGfvVQ0hn7DBO%7bZTf5Qw_EC12BV*;!-E6cY%jOSeZG-YKII$J`g^4`Oe~19VP;gbLRk3;vdbK| z*n+W7>m6qSt-+2?_QWVSJ7-q}qj>xqe+w@%HaI_onq)b0vsdbjav_s=p#(YX=Irrf z?w_vc{Vk`1FHTE2fvrE7h3_N>H_yuR7&UD7WKEGYrSeE@(i<*ht&(RyB(O+r?FPyH zlJYl;93yA7^ylKs^t?CY%M4SoqM-$&=pWLv9Yy$ym#i_zGByeXM?{X%@Vu4zj9{oE zq3(AogXDY7xx}B8^*Q&7@E^fNwvm^E>by1nl!I_MR%A<^(hZhRnXojrW7+WBt@|ei6 ziwul#2bCs?&?hSZG9vFQEh{O+EjD&}0I<@|_L&?=3K^tIg{g}3;UI1mHwr5$BSgle zl1d5^Nhh*5ywh4r0Ah1m=NbT%Qy)%qi0?$s17jX7Qi(26K#W~E^E?Bx&zyyJX}V+?(M6)4Up zK)ttKfunT(t<;)ct?Fby^D$$Y;Q-rSBjtpBxGA9-Z9g{}6B&`=t-2s?PuOy_eQ~bl z>X@1)K+=Q|W8;2WIf)K@mA}*n>EmEl2LduB5<8pP*Sz83X<5AqtzzZmW5X+>^>Lje zgGrJJ5#IbDTqk006W7m#Ial^;c5#=1zl&i!6}>%!f-e=)~B_{T@f#*#NdZuR_a` zXgLM0Xf5|xM|B>P)7?$gF=b^i!>M4!ENzeYjyVjr7IwG!ia(`vHbXEWcTsgC#yo8R z#&-5FTbk1sTx#iH0)lo)gg)4 z+Dv+U1Og|{f7C~~jhp`fdRShi&@=igUB%Yp)mxU__n5Qid{oHYAsd!7{+irx$X=JJ z^<23n&F-f70Mg25^N~{#xv^C<;N_2{+ulI z*hje_l0o*cvb|xOCZp4*4mjeDCwX^l-Zi&d+cd$ z`YWO*)w6Q(wOM4q#>RkTybuJ2HbzN^y!Wj4yN^v4FNh3wHi?)mVETiwVf(Seiz4sPabkD+OWjGegnVTqz zwmWPO+hyYTSd7lk#>aG`HqAR2=?@I=a2?0{sf&HZ%|S*jOS|qb>u^j44nw0NIdP&b zBvp{m9bdRXr#BlO2H??NsraX=XwS*gbUh{FOkE=!!e$hE1&)@M`dOkaC)wg?5OeD=wuERWu;!1R>qoG z;mCvoU=vFZg{b6WLG--Ua8%khs|IeW)?|PIJ72oXBqObzJwH*Gc*kzj(z5zzP0hu& zF}sfecxO=P&(m_8+WJY^eJ6{ATEOU^^w$8dCHzB=waofxgSy8Pl9AojL$^jMh6~uzfv^22-CIcx;38-<9ZEd%q?f6wNJl?ee-?Jda9R*fUYXiVU|n z*J)YI{BXxMSpNV?=9b4%i}Q{RX6CNYGaEx644jRUG=ya0XSQ&$%9<><3TZqhNePNl zJQWnN5x6_1T0w^PIi0}K8=<)^-_&O#kP{+%h@j-dIE*|ya6$q~`6M}vY($bb8-y-> zNEqC}Z`lcz}%^DDODaj;*6_!(ppiN_eROP$E-hA?=*F5qsOaGb(H zYS&|9fXmd)0uW%wa3IPxj zJ|Wx4QBMbh%2(_t+=`dc9b?v$~q4jHA6N7GsTSB0m? z+Y^BRY`phZ>N&MGI5hUOtYb1FpBc`4guCRbIIPXdc#1piz0a^vp%iT_vXP;d95!M& znG572f#GH`AN1t1xcY!2$Xa}dVQF~u=Lg6|8(A2#L$f=>Kx>Hvd=(N_q;&LIRz9O0 z%iY`m02c*GjPuFgCe1!-hwQtFLRZEOhqQry{Ezrum(_HFIV2&hBn#jL2dKtM$25MD z4g0N^F)+yW%e1}Q{l)om4B?FpV+Uvi*CczYnDUt0DC}vyi6f7)vm{RLmJk{$UKm|qZqfy$mlRe^t>uiIi;R`07(^qDt`e6CKbYt?ETj8@OYW!wn;OtjJ2W1%8`QD zyEDv$0l-`hB9@52m5y+)WM3KZmLB@GTN)to#_0$Tt{Q9tm=1eBv+0fg6QGiK-b31G z?Ygl408bKD5J5KAXQ#FHENasUXix(|t^O!!|IlAO(}-A4`{6YzqNi>)w~!nlz_ zTuCH=NhFmf0s_>6GI>sows%(pHb`X>%1AUTFJg!=f`B>NxLIm&+Z-;E#yP$BSG{vc z1F%5S_V?8i00gbHJt2`dQt4VmnRwu4HLfzT*4Wx?xLMl8DtO&9t?N-qnWbq`zYaSB zLt6%JNjzV@Y_#1K(s_M(nVCMNtH~5tjB9&<4t<-Zv~UK=Au~y#=l&V=?w_w?%PGyv zj(4@5tTx%&!%Yl3fG?CQpt`H1G@MO;CpQ_4$d%>Mz+2uQ8QetETL5{#3pcCuZl9xd zE^eQfsz&T=XavRJfcY$aF@gPL?0vajjhpyy(;5bg9=V+{CMX*um{L3zNaq1eX&c>@ zO38IbJMi>&(`}Mt4fa0jwpZc=ZtGF5<7vzo(U!DAS{h47 z^H|t8oz~az<3{ODqsYkAvN54%Mm*#<34jI&&*^b#{a)6m&BFXX{{ZxXkA)0C5J{E> z0q8p*QEPp^3x?%jd^04T3f<8(HQpkqgo zjf-KRW3&dkN4~b)Z%4^HD(CeO+WjVbqCXI{T`NwT3tW;ovRX^bjAwtSAH5RaKL|#b z*1A)=o?T7)dvS1xaAdus=|+!vr=Mnm`~k8w zZBHI%V@6BlkkeQRBqG?Ey1z_3oSaa0+WaPIy6&-wnC()0N4ycUs(^38mQ8V;N2rg^ zkq$FA4L*JeRoW_lF$HQJL6NRX!IS(r8f-C*OCY|wdKi>LJ-oWXE`=jd;fYaI@^tLJJ1^Ne$%4xvKAL1nEARn?!A zBFkY6ajQFm5Kge@c`)U6ZkbZ!$ZgR#^+r!LJdgNZ$&CFO@HK_45)rlRL0B%OZf>8J z$zaMRGIwd*Eai?eHp8BHrExqvX1KNBw2ndAktij`Yg|ig_!qMF*ffn3Tf+5oaiesE zZ1MEE{^5D1e@WsERk*nM!WO&|43_4P+%8%4@?H;Pr~0fuVrEQ@Cin-yOmm|Ioyhi7 zXSgyYi?}Wp11SpNChv; z$rv`m2=@q#a6;%io@vL5O6V0%HVAxiw{qe86 zA2rP&nRxijl(q+#x7>&smr?B+42jQ-j19d4UIg&QZ1kI-h4*{P40Cj@R*0Uwl^K;zs z7@kKE(r7iL><8E^oZ8!3-q<6*_aFQqljTj2>y_?xa1Vq@IsX7D&Zmc`l$>SiNYrI& z@Hn`fi5yQYZwL25U#Wp&EOrl0g2e8= zvD9}*aZWsp?R8okJ`Azh0>Y}tmKz3$RJig>O9apf>(6R z+-ER0TH#gIaoFSEj?zcMzvyTCGum|iqto*sWG)~QDGAr~oG}xofYtSaQj2>!0?D!v<_Yd4})8M=$|Nxl%y=Qil2V@g%Y ze>PSZ5ZXfswbJW5?z#x2FOt%t5-6@KF+nWv4UL47w;E4KO(R5;FrSK9>t#1aI}ZX( zhYQ)h>uH6cKhtTAmObfF)fpxxOJI$aXTtPN6AN0%#ELj!09E%DqKz5KKy03x^l`mu zCZZd3JS_H&E*rAm+1v|97PMVmi>+bfpH@&CLK~K zugqv2tdC+GPTU=pU4B`$Z8Hl{hZEDs!((wA^6*QIlGEGZR^N0ZMt|k9;K&u<8^IUu z6ZsFcv99T|>H4&>-2SIg4CXuQ|JwG6ZJ*OHVUimD3kOtfPm5l1`H(hq42B)m# zMKRPZ?4B2i81BQ`S=`O7yem2eP}B4A%pfo|!*Dm}l}qps@@BJg-8Ozm#m6}Ddhab^ z-OL5V_LK3#)M(l}b=eLOWYcBJ$2JFdpZb7U_@#TUbeS+U;gra0A5vhRHv#mQk^DjT zz12>f>IdkWmOf4!4n{;Twnouy-}zdp8pw>U90>-Z?L3w0S$9Wt8fjL#Q=Qpk`*L3^=H}1qP-8K;nVP9Yhs88k@Y*5AGt|#fx0%@Hi?~+3nkQF+DqK_$J}4(*(bCUumg>d zZ^Z2|L!;^Xwi6m8(=r3z7&kFVO?Liw0c~+IB$ArYYzwYb6VIpWf0@zyAD1lgJ~<$U zpV%JKE=T^B0C(Kq!j>d?J~p|9lZeUNGkZw4S==9DwR%TSYZ|K?kz)f3la-Jtk^cbl z<1}6OG!UMh>HeJQA#=7JOIMBLJ?=f&`0fU&jX$Zw`j704XY~eNbIa$Q&+|m=KEYMV zkF^+o#VrS?F*N)c^s|vJLnbWB%9X{&Q1SGiVMJ^I3Qxn4iKldqv#Lplj_G5cwmgTB zUBLPPZdq zp+07Ok>yGolk~`Yjk%X}elNnI1aFbygOU&YCfg1_aFWhj12s|8U0*opBu{@ z!sePiuM|i2N%#fsADNozG~9eD0yrg=%{R%Ai$CFKkpkdic<>4yq_I-vE~J4}l2Hu>G2?4en+yP`Nhk?$O9AaRLQ=RAYma2+ z5E>LOA6Cfwit!2_*4qn*AvLZb5}Z$9uW*_+Vxc|>Unwzxdn%`Lp6%+BYKXNy0!_%7 z%^{5XPX1FKN59=@pqCM$qGkt27`pc=hC~?IIVIS`v4rq^ER_EMCuUBOs6$D@TYaF$ z?L>}LtOT%-i{)rpu)-t}xyX=wMNRl)Ms;Q z#BFI-k;N%Wa^#t;F>IY`HlzXjokI!K`Rim4DS%s($*AYR-%H{j59=E4h^^xFV)8XXzG?uxpUZ19G82Y9& zBgmmEMPHOZtU7)uUi^%A0@819D-nkI@uy?RAb-l<_Kl;-sbR~j_MWAVXU560EvH~g z9jL@VHXL30j_R4#!{Tdd&$=5vWYRbiNdtt|%qNx+@LbDebwGkgl~Op#6q?Bc%{!HO zkrBAzRT(_Zy9bY`1!)@yc==51-?ig(6SSFymj&&*1ywlj2XMUw*sUja zid84m+g2J8W^_Xvz^bH18NnfDSw8%t5KlxbTu!LuH+XXjqP3b^qa@iByyFul{H-n) zSp#P-d1E~cIgM-E7pn3qhRSSg2<8rX19g~gpiA5j1!^?x#)!b~3o4R2)ZrqQUXIr~ zgMY%J{Vq&q_cFm-Y-h(S#nPKE6c8u^6)8y>PYfA=idhA=R?zoR&yneaM`E=ZI1GCT z4gJIQ<=GDj9%6OVu zLz9&rCNpHma0HFlrb(njmxMrIy5^UjWa%x6XF)d2cj+r1Qr)w*Ju*;|iHDmaT$h(f z;%ugp=Jt@n0Nfg0r>5wd9vj%~k{k~EsJfbdo_t-HtpJAY!b_-&l_(AUHzXjZEV{_f z>76~5u4cyAk7Q1azFA1Nv8)#2R2ld>J}gokX3HV%rpYZ0{liE7(F_cUap5pWJHsCf zUG$PIujQxQS{m$kY7)pjX2lF`B)$6rNAizyvsov;zSzX~GW2~H@PEW8`kAu(f4k@Z z0FoDu{I_xTRil%(R=TRTT1fk3(sICX4s5J& z6}bk%Lg&U|F_t!o8;_LZJK>Ym^tyNB_Q$w>OTY{R$W3J6Rh|`TdxL;HwNrb|kPgdq zl8NSI$tO88v&dwT&b_U22A9azk2@%l4J^jowi!4Zpv0Ri7-NQm$?&QM$VGu_{-Zl` za@q**dTXoaQJACCPu7D&Jne=!`YjMLjOB({%it9`8^I0Qd5*Xqg&Y82o&I2^K7%e3dZu%-M0>2Vo+p z72Q8y&>4-oioPA~+e^W+r5?xHPrjq1D2cOr0W0o=rAb&9wgjP(dL0waKwEiJBrB zPZXfY)Ul?_FAV{%=Fz2CP?17wfq+tZw>6*^!!=;Wu&}!9r;uT<^2EVYKl}EOY%cPc&qjQNU z8beKl%T6hkxka3o{#>T?71JPyoj3wu4tm}`8!Wz zcH@65Nz=V0uXQ#EIM0okShJS8NgqvXq@qoE<9bu%Mu!uudW#oB*7Q9+xLBBAy~Msj z-pJp~ak& z#g(z-Nds9U>5cUHb={JDC^`?Xx__p%9-xW1@iPi(yRoD#bEGT|AU41zt9{i7#>3EE zN7NEeou;x}+;brg%bWN`@_#xPSW+ zf{(=hqSN&qUTq(;94yR-z9=5f@f)AZnZ-Es?eMI0-&XaukEG`5?49gn%s-ZHL=w6{ z`8o868*_W?nnbo9!~7l8Bg$+TTKi*~DBRrX<3B`X{+P#U4kV4pDUJLnFiQrSa$}QI zndX1Y2awp{28j*wNhoJb=)Z|QJB^jBH7EqNO}e&VRw?oZ(B zouR`kb6)L5tPgN|zlBwOyYXJ=UsdCNAx)Ekr|TJ@#P)j4lNpEWb3N*ba3}uhy30Qk zu{w4(1)Qvf_Pc% zEhDTnfs}O9G%s)sk}z%VuQlvF(fvQFdfQEf`B7oJHyp?5<4G%ATN_97HMjd&RJ4A* z&chjz!*2Ysy;ms-%ZzfViXjALT7`jgKgr%7Hu_JU++xVrwP%v~A)*deCLI2#oC z_zL`nay1ybl6K-nP~gCA?gG2M0@}r-^p2gS`uUxWh&IDbcRT+8C1>~%kW?Z=B76{yoQbg1z}g^aV{ ztqzHzbokSn+?KGO-Q6t*6Ygz!k5<8_VC0YV?6x=uZyQf=Qu0PVWNVA2&zJp{8OT4M zr%$Opxj2sW%XqIV&vh)#O}c|2)Cn=P(078g+J9IaSQ^0rajG_GA)2PD{Y)P0W;Xu- za=GW#^zr+TXQclC4El4u;Q3yE)H;4_F-eu`6W9*+tU(;m zG>Cx*os%`Wa?X)CmB(;Au4nZKPFlt%vi|_V-9`)z;a0}^< zo6-h0oPLqmV;la<=B#-Pay7#CBGVF}jqrJ6%0s(0Rk%s)`e zV4*X>`>9#sFA+O`?2fMlf6ULX_MW$!)15z}_D_YYv1$WS!pw}TsM`*{mQInknCJf?yX86q{Z~}QvU$=GY@2G?Q;)qZvFxRCKT;)0EbtQ zQ-rVgDpt(kE0k>?(o*Tvz1e3Xfr4N~u%;N^Ibr_DvnL?#o+Yz%3O9)V0D!*|0v3_r z{{Usm_*!__2<~%56)Rwg;FBJ~FIEWEeIu!tw8^BkuG4WOtop&oq(W!F(zbZpq{i2H!@5a-7D%{i_I=zi2w2;XD~KFvY0McVK!3z7#tnqE*7?NI2Z3!xGsI(=~jY8AF4O1+N`OH3G<_pbxslNdN$z6;9_y@LFhu z)1Yxo^bJEv!F*lqaPIe6Cq~S2LEL+&Td8Ca0eK_YLo9|($+cSvMnff?#nuU>at&iH z7IwAd1T3bN7b2=9x$>sSe{_!}S1Ewfa5j*|bd}gh&5xyT>Jb)U z;|4}HFDuMCQ%-iRnCHzuXa~yoO*;lAO3YT~0MOmQBGq^x@Sdr{n@-eVl4*O%HhveQ z=^b&6iKelU#oYR>f(7`WqTyqDGsBWz^7?Ql_EPl5HjfqqT`^&BZSGSBXL_$x)b(Gf z>@AG&6-@^VT#h2_b`aC%l$}qn$0V65C zk%8jdZ9E@@W2$tfW91y|Ush}kmt1*Xk&Y)yM|6x~JchW?_*s-3=;@oPULN*1wwObjNHzMszRCz&Bg<{wtUFLOVQxCRNYlob zqU!o?Gh>2C{S1aMk{dHO1pff;ZujLD1*}HueM6u>PZDc>0%A=vlgU zPPRn&%sDt%L5*y0YZ^>|I=hJgacd!@IvC4Z#(+n%GS|tYV`FNKm8{ew$zaETn|!Qz zB1>oV(d4Kww0&Y6sbprGj?hUg{KUP@XeVG;-bnT;mjuhfx7PHQ>K!1>M6k8`c2h}t zpbS&}E*J1<(#>evtrG?YJh`&neLqBF<GqnwNe8G>A7?TJy(#K;T zU>39;=G)b^c5rFdwO0s@56R(^3{~v;KU@C* zxC>ntr-!CvHy;WpvEgRyWMDP7{{VCHcV1BsP&l@)Vmy@hYGuHV;z1h(IK-Wqiq>=H z#p+#MoyWD=PL;dz**>xV04t+fkc#d$hV^dw`1wFrsTZc>^24|IC;*+q$`MbKLq4SW zJDOdw1QG7Cm=6v7^hD5fB#)B92v*qKnS_ptDJ1M|yRoIzJ$F zb~J=P7!Rn&UsLY*7L=tGG&F5h(nUB>G})7?Fvuj(=4V=#t~s(Fsg zh9SG2rl8;@2TK^!6JfR|SnQv-=Eq=B3(iOHz}&`9At8zDxz4+=($&jYX(R1<1a z`)w#q+DO)KlH?6zfd`)oyo_^QeiN8WNFhE~_cMM`UBz(WL^8U|RMB>xMT%8PR^S_M zn-m?)jIxJtJ6{SHUD}cN+(qn}BfGnH;3R@oM830(VZJ=3vO?EvNc$+wP+e~3)2NBg zdndW*dRBgRMg*)mB*zRyhMmXRdF-z*dyf`LrJ=%>Mqp%y8t!cr2hk=n^X{TCigKf; zsLz`$F-B6@g{=hctO&1zx@=$(y6@BpAgejjiiyvxI0Lu}{yfbD_k}@{68+Wk*vxxX zl&rjQzEI&CCXkV`BFHi!r!d&|LgI!-eN8qINHeI0yir+Ao!vYVcP`l$*{E2lT0u}x zGf4zH?MmauJdqMWC1vtS5*D$>uZ0nfon1y}jvd{`pC4Ez2_le}f+@Cckg23H2DQLY z;SY(yln*F_DdBAx>UjCHJcC+D`zc!{;?qE_k}R>Z(Hy1V(BKH=TZbpKc9b$13r!Uy zqRz*3=qxbIgWa;Zw4-xHXCRP++D_<*$n7_19fc#6pq9Ut$y@-jxI>=rPzN;bq>6hz zuH-48vkuqSm3Aq28=*F)W4KC+vr&taL~gV&&u^R-^0UV_5dm=4+Omwl9GqWCBHn>aCJ61HoQp1+|t^88gOvn&Uw5 zve4;Sk; zLIo@177Z)ey1a5V+lyG7tny?uc3LP%UbZskOig?2Bbt2e^qU#wWto{{a*64Zcg{ER zhOE|jV3yI5>3EqehZ(^8EM~LWk{ssMjwu_+1i~8A;b*67n9>T0CiRV;d!Lz>*+X38 zLuEo(!^fy(vPZhpYFI*6xxj9+uVppOqudJG8l!`$c^kJaqFu+#Bha(@M`ipKcRE-4 zSnLPrWq>|hY?J}4k&Sn7G)1GaU7z#N?OW2 z(Ek9;8=sH)OsuFR0Jv9a2Vrz?`zR!iMm?SEb8UdPyU6!bYK)n=Z!)*F?g7Q0(hmds zC?4zdXgb3;B;Ea%%i4KTb(%~0{{ZtedQ4Hz2BOEiv~C2Rhii)pQOb0Gy^N|yUhh2T-h3g3~*p1 z4pTxOs=FRw*W&<9Udpx>e4zR{5)jfWbj>>&cRAE+wAlq{^DuPmj4>k~1b}Wl+GK#A zgz+eJFD5c~BZN|I0#8Yk$GHA#Q)$|+Bsh+OSivLBTB8QHmdPZF5M0L^4L%d86UWG4 zbkO{~c`R^qf17nSqth{%;h!DWHtqnR(CQkbZZKH^$MmV)k*r|bPjF+n2ZU1{!}OAB zS}~3$$&T`N+yb*tn<@|*;!9C6sOG{S-U(^{00?=^iclKir*dh@|WT2Kr0fEkO00Cs5WQJz) zGNZ+axbEZnN4Z&X>t$qld)!I?0QUG#&Bz%U50ie-X`|swgNc=q4s?)^8w?(#rt9eL z0*CHY`4bCiPSA#vu8h_>`Ok_mgFuiS-Sr)|8+-U#PMy_yhf3*vO_TE}4$0ShW65$-u8*836B7wequSV#f z!rq(7i%^GK)M3iXfR?%#Chh#V28k!m{&-l8Bd_P_ZBJOi(ISf@27HGMQ6V9%B-30z zH}lUbcz+Cf*z1u;sAEkR`iq_)JTkYiIpDkNBa!~!J{19`&+7dLrZwDM8cjYOS4`6! z*TFjjOsplf+T;3MT2JnZ^?&0opP8jLJqHSZUFD_OGejEL2q20(+1u=<>7T;A6G?V{ zpVawLx=fPa$Vw$Ku=WC6TV}h#-j9THr!~LB{+Gqnx@%OQ7CB**`qMd`?95~LYwQ9p zjTZPkCv1vFV+-+js=v`P1l>M!XOFq9&4eF7?fRSmAd&EC3+X?^POHR&GX>gV)#M}9 zh0we>MSsfT(0-qeM+;HYABw#nry2B#FkOSE$0UOee!^KKWyXt}Rtfh)p!`tizMs{z zTcqf&lMUwGlMoCg=X#^dZ{0LYOar5SB5U{$ox1i5^%jzUF6I{ZK`B3=n%G{{cM0GA zlXYf(WOXK)EReVZjRP1M&hfbKC-nqpU+a#K#?ZuAkjIxcZb#-Mj4+PZ7XnEn3$6l> zRO+6FhepDay_qu^1dW6@xy&WjLBGaLi{up5!e#6QQ z7QfRtIuVXO$uj0?F9EhpkN5T;3ht?kgANoqaWW5IJ;F!45FEiF8v)=8RpjU`Cs5T! z9u8As^x*YfA$NHs{*m`i+7gT(kPc>pqiLEWW}ZPdWbL-b4&l$>0r02MbWWtxG{?;z zW1(!q{Qx_Q&w=nz99=6@{{Uaef$n_I!*TkzA=GxSy7b(xvWHF>McAfkTK?xo=9bkB ztN#EgcKIzSZLC(?8Pl(I966X8R;2IAV$d!O`b(NT6Y{;gA6DrYbeM$sIPk~YVC~#~ z-br2!)LPlsGMzu=gf~@Y+y}L+{{W;m-0imJ*CuYe6gZD@^c@HIW31|98Rq{0CO_&u zYgYV2(_M`w4lGm418uG1HoSNz&-h+b>$S78Y;1V(-rv&Z*?-)Vc}+fu<@9`P zxMkMnp9)%^ON0D9^!}A?EPH=+i*C)%oBpmuj=o88Hl>RmN4N?m)i`B~faf<^ufi`5mE6X;uW2M~Jfc{$;IuK)JQ&_8 zhd*MBV9%q6Hb|Ze!LHNnwEh|>7uM^+LmN#2fS3uPzq+-mbePn1sbOTHuX{VACtzGS z1!~_UBu4g*&h9IPMoAylyJGH6)q-iQlX>P0kd#A}|$ zmwhb^?sJd5sK5|4(ank9+}a)Bhk@=EYc5FgrgclE>9a#zm?1CaJo_s_#gn+k3~u<{ zzu9MUw2Zu9Tv^=D>Tcur_FlaU@TF*uXys{ZNN->c1bo`A>^Nj&-)0v!si0UR-{Ey) z`i4mRyN{gf{{X^$4t<^<^5y=M#gkX0>b*41(IcZV7yg-AEsp!w{gxj)PRhb?60_+) zrQ>#=v0knorxsP)BjG-y^j^21lXHgH{{UQlpyZNCbXnvHB9h{(0WN});siN!f|aCz z9v*y?O4|f(8}g{G*&Gzp5qPzXB8r@3F`!o{S#dm++bLL3P5C|JWkJp)rUF7&Y1mNf z-A>nvRf^~|iy0%_3T38~YG|OEX8{`tKLHj=8B)arvphA7B%fq@4xY#?50rL~m9Wup zaB<{la0HJjjk+>8{W+HY((yytY2b~RkqFsA{4EBnm*~b_1Vn&51?FQ=$(K-R4J7w$ z)kzt*XRPSmJDsQox=Dx!*)FZ<*zq*i%pOT-y~-u0>N?YKqcGzTXnyElRqA@6)7moj zYxW=~_Y-Dgp)^dK*&g8|n9yp$rRw-yB4W!fIWIm*wdEZ@o2}r)=`gX2qdyB`HSVO2 z2hRAzY+V$@1^htKgn2maj&kDTL=$waX#EiB@OzF!fvy2wajk2bhIVhR_nQY{?5|*T zzORM@d+noYC><4b?H40W%X3IB7tJjD-UDcCSE<9*npU9${{T9`B&~_w)>XPrE`Ceh z8^CEh1cqcIbd5dDaRpBOLm;=byp(rS(7!6%WA^*3tJpyxrTqrAWQ>rI@_D6i4+=b- zO-5&A#>ZpC*RnExsV(88H{=6?WYnydRa-DqJvLq z*=_V}yzNs=et^-Fmo7w+vj-SE_;EkF%%9t8{mRel8hjX&wfK*cTsc}D1kYh_cEh>9 zc9TU?#m&gXm9jxAqmid)w3fJEJA{)49@KPP{TDiHEXDx#6H)_gk+=Go?<3_XwY<0K z*?Lq>YvRZ)E-x3_SZq1I$Hn_CN92F?4@rXzaL1FTwevmF%;(RQ-fhieJT;(R>l>!} zeWjp_JEoU3NM|2LnB&IzW)6xrieMBs_pX0+A5m$)mWxl$WI?QV@ZCazb2t9JRN~Wu>hG%!2;_NFGX$H&e^kW1AVVGapYgi6ejjUI-KkcaPayUkIPwmUPUG z6AvAk8F>Zob1j(h4*3tk@IK{I)padLQ0fg+Ex4mkbmlVn{{UOtOaKvnNZ!@VEi)Gr zvCUuB1x6>VtBPH**0sE`sjNZ&N8r_x8? z9=;|_*trcYmKT;iza#$u+Sjl+gY`3J`1lA0rPAZ6I*S}fpN)o26lW$$i56Poz*^Dz zjRlhnpfeUMMl{&9PL{? zZqXnGq2Cek2g$XG>OaIyYh4b25sip8ZaiN|Bjox20EL>A=j}DpG4~zH>8!nF*&242 zG+Fb(JbltI7DmCibGx6*d|#Ao{vP!2PGgL|q}7Ck3vN6%-s9{)ncuY`y$!BGqQR+T z&FTPL(p)^#O*i)|39f4yn$C2&c@HF#ds}-oz5qf~Z&Lds3;T_3qxg?J7&$t3PvAqR zVa(FUmNXe&(kR=!ZTqI``lB>1j>FJnYesHlVqC%i?qqL0&0#+0+rVCR+hhewS4inz z=^R|*Y`B{z_f6tmv?%6lZ`5phTcc*y82tRq$Z#~MWbL0WR{^-(wTsga9v`6#cCu)nag@Ub%LITL2TEcW__UsC8-a5u;7nLb>O#)}oEqif6D2bZ0! z{@W@+2~)6g;*CF0^**n!zZP9XAV}!q?QIUwH?y$W1jfdfFDoA!A#zP4V`%w#q5l9X zv9iV=*%i|>Tc>0@C^qF}P7r^#LMT7>yZfrDjUjn_mO8R%q}O#L6MlOlafFUTq)@wWNV{hkz7y&*I_VoNz8Bn+CXo95;T13 zJenbK?gRzGZNLMNyBWVNODH`@w zT_#)D;2hE`-B~gRw0ohk#U_cdG6s z`=U#d@d+(s$wP-d$CSe7J=RxCye**`JnZ?mm9J^iY^zYo+Crud>Tqm)ttjNMy8w_b zpPu(W0w4^l3D-kzr_NUwQ7_a=RRa>{Kv34T^ik z8wnI&iT$U36_>W@?K`3Dcp+JeY8|BPkQmEPY28I>z^NH}C(D zy3e_?H*?_{&DAB&)N(SUV+4~txc0CyyZbb36EY)wurz=y0(jig6r5#DtereMh)Xnm z@%<$z8zgOib4c!Gi}UiWv^qCOe0Hi3xy}Wo@Gj4?nVBW=_PCFyg{oc04Ch#4kw+oL z(!8I2lptA7koP#0)n^fR0~Ogh0x)Z0Z9^+0Y_A)V4O%Utw6x?+b?L@baKY+*MDBM? z3Xo)$I0phk)8V@sXx>ABAaJOiI2K!(W84Kx^8SqM5j@#7+L~eDHsK+fC^Fha4{flY z3Y#)pr)HSX*Ad|SEe@}#VB}z6KpRrV$|u;Y?07OrL6{N`1zPY+bt3L-+cQMCmI)MT z4%6{6Cdm=G<)z2TT8swcX-#pMi6M|x`2_;a%#KOi>|$&mq=YZnPxlGGM0O5K9Xpz1 zajUdLHxEt2bXhRGI*28ptniyr&VB(?S%0r?*%o5G%i6X`sFuXm4S);;^!T0`$lU6V=E z@;ZAPB01#9)$?+`h$8x_g24r&%JlA?>ODV6(6wC$t1;gOP{t9$!xg#F7MdG*1l_6; zqa6*=8f)jtGeItasK&-alJnegXZ};_avJY*!Puaf{{V?SPp@eiJwJ=2%aNNHY;fn| zIPK`TcF09gJ9BF-_-mt{r^=H+)HR%lwCL|8xIp&$&i4fW0CK%A16$L73AId}7d5ia zr{%O|V@(@FrD6RpW5tUbY*2|anjcMdFJBE$PwHKJDm;xkR`%n`8+I=Sq~LAgY`SOg z5+C(EN4h-8Or@{)WUVCZ*EHDi;R)4sPPFPRMoy~e{W%6_MtpeX?0Xv=Pir}bnYiM<6$sGu&R0Wgx=h_S zm5~Ni_$_`ge1W0TM#4j7jpyUrf`;f)^ah2AnbW$Cqlov%F(OxhM67@5J;KF~3WHbt zH|d>gr?Iu3nZ}MeSivEQj&(>FKDeE}&lO*FR|D|NrnNXRG9o^<9z+f>%*RxbKEFf2 z*wOz0JfRZki%RMKlEQ;MnHgBpWLw zlcnKBha5RGN0j)3-;CFHHah}|BZKkE2?Rx~YfGHq-_i*tzTV51KT`}}%_G|SXVJQj zzE|zX`oHuIvsceDc6!w8!uCvEUC!-C+Xiq=z2KZF)hDbxnQ2gk>xeewD~J-fuZAM20QapK_=%f{kr!8xM+q`~sEIK+A8|tfu9tYI_hO$)*dadwzwUvBe>ZnM={;h zNV^;%nVMY9cWjYcPR)=H`9pDMn*%4(l%CVU_gY!Pr>wa>e^1urk-wIlkU;uRg>GF= z%i+Dp4)<7$Y~dq&1s^RW@T8Y5-II6iBM2aSp}RJ2xki!GcRYadM-Fd=;u_W;D1TiFu^OuW-l@J{{XV2cT&vjc_Bi&Os4KfQV9hlY;(vBX(!kriYnxE4~1qo zkSKXm#iz(z-%;(1A0*%S2&7tW1v|egLt75kY=5~}PH;V5m!|3)?SV!)4+NqyJUg^( zC|2H8$n^XG(gArR`i)=qMA@ZE&1Fbxlq$?!Qqw)}@{{X3B##t;+r@HI9 zh(6=l9L4HPjCk0`Nh@lFI-Jq_trw!WeWp2IR^_%WBnvn>5rY(w%G$ktBS0OUwr-}?i~^ejH6#>s1h(M0Ms+|$}s4M$7TbK!i!#x{p;^3Z!v%`F}n zIQHoy41I2B&a%RI{{Wgj(LCYUx$KA*+}MTA3~4_}1Cw45X<>=Xm8@uzBl_WRvHN|! z)~h=TY*)GXnI5xQv%61&{?sLdA0h0y1~h;WNd}xh^0``+W!u{$*w+?pQd5r6m-7Dr z_eYxQx&eu<$iwb@Ld%$Ubbt9DD=p=FS;mk?ByF-${G?DU_xV`;Yp2^YWXZx{4`{hz zZ~p+)-}{B>be(FO(`fC-(=F4nwm02oH7wR=X8Jf#fY52q2vHWmEG+_AsE|*pOh~(#ifj%@ zTP+2UW8*Qb!7q}xJg(~UYmdi~u<7N3xuvBMwVqR%sORP7j8-s$4G;qKEi()9m`yWa zNL^RlLdJCS=Yv`FPuv!jO@RQiSB0A>)99N1JbGqkhnI%T zynKfL006wu#+;BnW)LrqN0pz|^nCpnQGOm|L9(z13O&tpNVd7B$RRW|3ebfDNK*f9d&n`F-FR-W&(p!5%?V zXUh&=c6Ot$lGc9|P4k=1gg#%9-L~PuABBoWd#1AF)~nhT_Qh%Y&LIu#e_p-LCz@z)3z+ zWqflNcd(YZuKrRD5Q}5vyyLUF`=Axh<}!Bv#ad)EYbDIFK+y1+nD^&s*;wwP_5n0r z;nDN`+E!A0*AZ=Y$(Y)_nDeqiYy)Qek0bjbyA)z~8#uXu2T@vlESJ0!9hZT)0?NYX zMlo|_YYnpPgn4P)e}ao?x{R?-$3z_Gk^pD~mwW-`5s=(XwkD?b&)GGB{J`w9T~(-h zy1ZVDgcvc}!r*A#mw(-Dr^3?U%YIh5Bk<#vFj=Rm7aW+X-BX|TMA>b+7Hyf%~&oyUdEMmU;U=-g@SYlh$4e#J04 zujM{h_u(~!kKw$Qk2L;&ZIp=u0a5`#5G<7y(zk;Y*%@%f6lO^t>SF-1;(P=YSDB@+ zqwQ)tRx?2vFKOkw5%LvkK}Ci!?}hFH#BOhK`|KBFX%FpiqB#ie4l#p5&CQrpb59%) z6a3Ofd)!CB9Q>34&MthCIFd;ul?jfD@*8>f8zv>>l$8iefpsJRL4Z&bt^1M4a@YK09uS6tluF> zTz7CaK~`xc#Q92%ZYl6c*9XcwxCL?SZ+pvl94};z$*|7bAj-qhyeDJzs-RYe{GzEfjZQ}ecd2bnTdYJtju(@J9 zZz~fwO_awxWu$rVhRZRL{{Rcwy3N=bxJG7y+(m*Hjzx{!;w@_je6!B#RG}>tyG{zN zlPKDrNFL7{DB6A2)^W(-3RWH000)G-NGX|mJ`pSVnD(qlL@Z^|YmA-nlOB5)*b ziH8CJ2X&i9(PL+eyjm9WV+Y|LEvA4%9hDt|px7GCL$J|WJu_HiT-$J1nc*SHu{LJ9 z*h;3N;wWXDWO`<&sK+B3LxCs+*=%!p7P9l?|M>)13lK%j}q!=T7?e+vJq&2YL zl8HuReo^lIE<63HP|2WN2LaUIvfc-q)N9*CMZmhc)|U_fvYE_Yj#ov9@Yhj!0H@<* zwV-!c`z1aU@#94I?cPslQ8N}`JG%)7*)TO2dYc&D(BSr+i%PEi7f-3iaRG7Ux5z=F z#%sZ+7Pun)Ig>0J%tg-@4O!t;3h#opTOvAyvAmIIW9(Lg6EV1Ox-6E5G>@g#%AuOb zGPCCoARkoyK|d}Z%Q7hDaC~R}DWHs|hRDHSpD1)$ zBTtc%Lg4uB$UE$aYljO^V=^%r>B(PM;>sU90{oORwPxdLKBhc$zL*4b$*3BFV#cK2t*+1+n$Y>^N}f?qsqS%Ngdkr92d_ikRBAc4P+`{m&{LUEErD4)BWQYFa>ZGO*ekAl$ThS0B_`W~TvWMmt$6N7Cf)`9Uw{?mX@JIWWxP z;AoWiGh=jwH~IYh9K4&ZrBB6uV< zWCd_f9MG1#^?alSXShnhe6BJ&3L*<#K@rD^@&U4z%Ze$6InSVqM}S_@vgf87D^|ly zfs!?#fRSk#mT9kL9?}-GNXC$sw6vnqVMaT4*=aP)26lo4B-v^`!0B){7C8t8P8~=< z3wNJUiuOQQ*2^ihCN_ZhqEJHsBqDO-yfVn$9K^$mcWk?uBMcx`!6zV5?K7}FvGR9M z$;u980)c1D_Pq8X?8%YDSt_WT_$u`T{*D`nbvfGw=Ux_@sV6U*DDPm~ua%ns5NnWv z87vbROUM>n!r!%{{XLn5rsm4**bC#65=MbQ(R+3)I}2LrSl1c^(JN1&=>uBUAk$`; zMoV1AKirNGi4JHQRql*rxFu{MILrih70>bxj+T0LP&X4JRE2;F&TQ{jCl5KO zeNPKc&xgAXRv%51x)1}qy~!KW2@cKI?$TU!T^|BW_yl7gR(J+DhD2wwIa>Y=`L7(R zlIWdv9BX z5@Rvh5{aDSG)2_*`;rOZrh$;h(RxSvV>L|^U&@CpwXsQ)B(}*PFa+;gdv^1CFF(r5 z&FSdoz&eYvvgN0^5=&saHgA`ZZoGL?YjI)pylut8)uzjQq{|c~!?GiE*__e0eQ-Z@ ziikbWbdor^?j*Uy*(CWTVV^dUrS3gHrSu=f<+*>eEyEMu;`g|@&Nk;0WS^8y9@dt% zt+x|H$-lCP3mYRUW#bMQlnid1qvUDmJ({ zlgO>c>kFytIa#?4pC(r1PuLpiJ3z2Fy*dvPT?kcw=Z5#@glo03YR5J!RC>%*e4a zvnDwX{tKMeu-kc{Hb32Y{!HLQ5y zRAfZiarM`>0Pe@lkQ&B=?Pke8Wre`VmkG?56~;`*7qP^!J*@|B=9A~=!qvs2dyw0PJ_t&Lgu2zbiT@Lt?qI;5sot5;^XApO;x4LS*I_m|2y zcX7Hu3Dk~koj*$98OsK-{{V+?{$B$!w9c2yXK{jf-5{!M?fWcNv(S2eNQ_0OO2-e< z*T;4Hh3-0biY6iN@HREK?26@d{y(DnA5m{8tiDu_2QE*g$0m}F$IFMKvoU)FdV~-6 zu;vv*FH6;lEo^Lg8xkHjUgNCk566k(9CsHGH@+8|z6oC|#H}H%JPnCl**c8Sl{3@9 z^nQb?hS=vgn2daFUJlkj4q|=4?jPZEEuN!ZCXLMw*w`Y9-s8eYcx+MvH)~qrO?<24 z3sf-3^4A!w0@5yz*r{D^Z~LPh-{HJ#h1CB5#C-BE8!Ev+L-rwh26W>$LxrS*=+ARq z=YBz2$#iU7+`iecAoVM^zp%7livqv895kGWUgkv}JYxGvXzmt0t!b01hD{`+-4oBn z{ub(CIVYYPo>1IOnVx+pUg3Yr(ovj#nARtik(gT-aK7nY)&M=q^)~2}`eIK~XT!tV z4`2@cyeoQshmDgn8s5j%p7ja>5p-r&zJbWzN-8(cdds^BzL>_io&o@)@ zdL19qzKoodUvZKhDT>$qI;;c^32T5qZIcd*AaD`BH;~d@+r0thZKKd8n+{1L4k9Oj z`Wx9BY@o%{XNAPRGDttBs=-)FbNM}fpQq@tsjPDLnHJ&p{Uw3Gi|!ljrpI^X%by$U zgKgwd`!89_>Fj*1J{j;J9-~D_!LbM=8X3rjP%#LVgJO0Pd{??|6HkL&U4KU?N&9u} zoIu%n-bSf~*^`SLvIc<3Lutaj&y+SOT*k#CrE3{6A=FRM;r&4z#?cubL@~@?8)Saq z8ZATeG+jhKKw9^9%39%9_T%AaHw!t29|Svy~} z`QNJjN*yBgAwKKo9@E7?(y`?RNXYJK5+mm>nDLylvOxQ(**ZPMJ z_*5tSmRn;P0K+Q@4j=$Z*J}MQpQb)XY0Z1_&hCtzf%37^v6=8l;K1CNi4KgK?q|69 z3zkum;l%phld8p@5R@|Z{;#?})E$=&PCTKKz0PcHwwt?@V#DxuHXEr z`;X2)#UJ6{;pHx`rjPl5d_Pa`{S1Oi-ZmtYzqO#P3|&53PJbUO)=9JA+@g$~A7ZAD z9$5`Fq^(@oII)n>Mf)TAKTPFi0%M>SiUjUqpwefNz*gwgT|FBMeP`ACqPnaZx*VXq z0trDfH5{Eo^a2R>RFp_^kb4`Y@ns{^cqiFg%F~&qGUUcJ?@At@hdUlv0z!F7h2krpYH*)~An9#%W1^bJ=!Ug$|^{-vtxoeNgMV@t9O zkq$vt`ZucJ(-<2*IiNWKFtbmkL9J+=;qaL(a+|9DB8+I=k2Wc6l|T{7)M9mx9<1>U zQ2^t%;bJ<|r3}(HFVq${ppPJomWiolH&uRnu}N#qjksQ)FJI$F2WgAys_mrh3kwn* zF@|O|{VOT2zekQK9~+t-?4OYqb&jpkGH@In8#~K*t=3OLIzf4R-$b2&G_W~g(@f&P zX;u!J6Jf-D=p9+^8O+nhBb?lW-CJ(FzF0G+mG5I-_Jhg>bu6<%(h@zbZ!}J)!Gjyp z$c$Z8(pDPLlbU}_7Rbs!AqAP?$7QV49f_#qmq$%$C{|vb6eDMXld-Mdf{chY*1uIc&Hn&fU}@(ey5^6z4rHzl zj=M}V^5)m{o=5gryl2QHWQ}oYX#_YO!5&fV3QR}3d|gs^w;Lip((rH5fAUC2nmqg< zaJ0ja_}xzJCdlB|pR#H95^Q?28Vy4W52&!&Ubpad2*>{bFD1Xv{{Xg8xcS**B4La+ zSHEMiZ<;FPnUfz<3~)jhndq6TnWt1F#Mb2BD~B zvlj;%Oo`lSvBc8%AJ{Gb0RI4^xOB){KT`Du7Myk`7Bl&rqw(1u%|CL5XX@GdRC43# z88YJGWfEN+W}Y2XT3`CB&059+;^W>)B<@MFe{`r}twJq3BUNiK_26$lU>vFzW6$G4B@o5vH7x*CR~Gq^>G+J&EMr((=CLWVFqgH2@qKprI=_ps(XR=;Ot1|4Ak2@!sF6kB5G<uj}dctX64yelu`1 zcnI|IV*m$N1@+1JLb@xYBkC-inR9ca!P7ASc2-l!9lhK!x3O`r*$Kwm(^6<1HqBd8YvIk!b4Hm5ab%2WHu>B+0=8&8-K~~qT68x{K-@l*(V)!AV~IMR zV*}mY;mibo;4dQ9b-hzu&zCz<%6$0`JGsY!-~qrN0V|UgQOvC;Dm^b7RB>;klRS~P zf2+DWCvR=kniiJ^p_m3%TXAtC9oZ9+eT*N{-{x`P4|IR3as(PDOlfT+=)^fvQM2k~ zIP8D>Ld3dx9L7csHM@X4{mN(>G~H3J!Kq1!i-nK*eLD&>793yA+D*DgpD%ITpV?*J zX^kFE>8x##KXli+-cODKX;6lQl3k@hada+2Dbsiim+0En=-8%e=*pa{xoPa!c3 z1UXWNY@$l`P*QX~zpB%~x9pTH1n!<0Pb0z&65`GiK!p-{8Wb7d+i70?qo zi6R6%5{n1ZKpdgaiy>VNqhTH*ZH_h(fzq&t1W@X33~+b1lomXr9RfB{<<8j!jf%x9 zk?1+Bc({>wKRQ`3!+VJzb)JfH$5~b$;^=@r6?mc&5*Ez!T;(Yi234K+3Guc!lWMG( za>uw96is`Wce_av_FhZIDsiN{Tn^zy7Dv^(BOBwBVwib36F~{GHn>l8WrMgKm02X& zP{tVxN^7U?8dt*;rsh*zM6MNF@cpw#Hq1sl6|SBuoaC(7-~LY>|dZ zB$GK#f~I4X3GFnP7ntr5C>>OTG0OB$KpGgO-;`S(UE6Cn3;0E0e&JDQ)CaY|1s+5r zv{InSsESwLC9!1DvS3;92_VwFfv5V1cI-YC%y8Kn;CWh|8xl7}@@m#?mmPL8uhB$> z-$ua;%jw64_XaOt$H0xu*b60Jn@D5B8UoGANZu+B$@AQr8{-#8Wkkm$CwpGgs_9|2 z131}YH60-Kk{YwxPs!1w6njh-NiG&SLQ9D>R*r0EM&bxXG_H_tsv9Tzz7{pVw6d;TkTxbVLH_`hHSVcdC~bqie6L2=I!8#- zw4&#AMjlM@JeFg`9P2Kt-^U9T7DQ07vPM3ppSVgn6Xq!Dhe+oMESX^+yZ->7A?|dK zER}(cIX=A<{f>Sl0FHZD1)$jsW3FZ}GzU=uX}gyaj;4RZLko^v zS>cmk`A0XlIT^PRU+z$u97&>hD6Fk7C9K+-5ON449#+fRd6`|vN=TeT+xJnY#x3pp zgc%35xd}K;2lT==OvB5X64F{82O(9}9eFGO-A2%+#dX%{jN56jXquUKs_#ZpHYh|| zL|^MO;<8{%K`e0coq?w_Bt50YkL9if4bmqVy33!C@_R`RB=Up}#H0+^*)sREy}jf) zX#=3iia3YV(meQ7qzuV3ON=|M<&0D|57cnTdmKMO7?p_UJ=&E)t#=oC$SIiZhfbYa{5kzCmCiZ0>Jk(~*F z&kT3+lAwkswpU_gyq)Q$_F4^h3rvp^46F$Wc_X=ll@^(srbtUO;-``HJaP&z$=9_^68v9LkH>b+BwomTZ`GlAo(UWp z{q{RrPkQ$cu|H@(P|_a^uV)Ww+#n_SFu!{wBU#zG?8x;p7(=|+;%wya{fL$ox3rTyJf3lKXc%?2ZARmQT8F8Fi?ZHe$xY3y;Xe)Jrr?ACzvN+|X z%y3?Xr#+$;-EOjyENr+^i8g7aNX`3= z{w8S1p=)P@H>S<~mzikMO2@Xr<$5C+;|=^NXwodNsZJ@xm7I$=w73Jksr4sHLz)WC zz{v!g-zt~1mivv?HdDkVxm2ghk;k;%6;>I`Sw_HJGsg2V%UkR*%@;B*o391C}+CCN^KTgNV z)ulQUCCSDNY|o9Lp5G3tW2lIiq(*T<0N2KPw}UE|el{{TS!OLf(lxqUCDX}vq5Ni?TW%dIS#KD;?tLyqV5 zM@IfQSbxJjy(?A8&Tg%q{C#1S`7EO9?T!#f@X6WR@(#ozy*(dR>RI_cbsX6F%*1?{ z@nQhx`mjf|kA}$%apVstWPm)*l+-$nng0Om*>0a*(()MmR*)HvS+kg0%H6Wn5_l@) z-C2w^y&qHQ{861gqm3p$Zl4hhk~c&3HO?F~wA)Sc5S>r|08n-FCD*!hCHR=wupD+U zlN{Nbhf5hC{Vf$j{GwU=sAp;V4yBcqiK|bMq{VV$!279ko(;96 zjoJyacwWV?;J+WJaHcx<=CdJex!8EJhB7mavt@?B+!mVzp9|%lu<9uF-C{$D7on%Z z_cs$9AEk}*e}DK=v~y3ri4^WCRZ`6 zgB6cs%qR0M4(|@5b}RIST5N{6MAn9Y$ipq8w*F7K`Be zRc`Nfl$XLiTsi4m_Xe>404__PlqC^%JU6fn^L1Sg9Tp|%e+;)w> z1BILtIMB00fqMjE4Ms??rNv_y1dawr_JZSFHvA8=&9BMmbouT7DV>O$2ikLvO7=*@_uO({q4MCJ%djage*B#H8pWJ;5q;(W>wXNFta2^(pZCeqsySR^}Up%i1(scn8J(4(wJbIyB7nd=lnzA|jtKLdBe7{lj3{&d3?TwoqU#hX@dzl1X@&SFd;bpU< zhbJB&$XX@_-(GEIx_(!>StonwfIuGLjupX>;gItgJ?#f?cC4RzwtD!w7HR=kf6os=v>eYWH`FoN!a`?Yl(BAFQP%K z_*d|nC6pHs8)P(le60Tfhl7!vzM<4Z7q|r75z;`&oCq!M?rn0d>AFO1$qpy9*BmW; z(X$lEA!+VluulXa@Jh)t9XPrMtHRmgjAawdU4DGn^4GLJ?Ki!wa~c5yaDr!OF|tO? zS}c#LY;dP!gKe!}nik0!X#lQ=juMICF1tPqwP&2^x+@~o35}txbAGR4tLuFx;O5H% zsNLWFmg%^KuAtgH+P>JWy^d{;R(^~eHD><+_P0@wJaWc=)bsrd3nv?AfP0SnR?AiX zhm7y5v;)nLbY+;af@!1SSYtavxMJ2ca&&EfTKs#s--&x$#Xq+&!%qhJ@h zDI9HJpapy=m|Posd#R(5uLijbWvS)m$(CN}xeo%8ARbpzRAL6s)1#C*!J~GNN4oPa zq3H}P*qbB(LzKbvyb8a#UcD`VPmg2{W-?M-8Y~shmmFooJ)fs_-9`yUQJd{PP}QQ! zW<#K#97OoGcpN|d!B8^f;JRo_his96@JDbU@JGt`zO2w-)iH=*4VQAq*5Laeh2a?t zlTONGCyW=wNO&T_YrWTtpBu+J{{T_?uhM$_eQ!@%_eb3ljILyImqPyLhg)4r42Ox! z-1dTA(jF^f4?8QF0toU8y(8$qa4+B3{2|@WW5^D=HDlRwH7HADdbu%U&56Qs+h}TK zLm#K+dS$i_>_61g!CH)bO+!%xM%n;TrAt=FbeP4=ZOM&qX&kyU&-UeaK7}qZULsOqcS_BD`|5TCOCJ z=e_YnS}ykrKm9|P$iyxLfwCy8vd%VsejZTCYYPA(apr)r-~zJQ zA*NDe;XJ0{YBBPna3j^BoS6xO7ZM$`SG1?aRhrK4C=j9 z0^eMad=jL3(IoL4LRlj~AqmQwHxHx>M)7M?c{4m(8LDZ`#*(9bf~aW#i+8k&n8hF# zLV?8akzx|PpQXek?1`Pr$x#&2p^XkNzE>?Yt|etq;+m34SQ0a8KP#Zq?0c?w04XPD zWUd{gSA)s`(PhVxsOWh4q_(g_F<#IXGM{N0pc(5=zh-z-`TF z;Jeur19j~m{Wmio9vqR7UkhJt924S{_!=N|*wX4V7PeUoeSrO7mY&j2f!(rZ9z=25 zfw>5x_*_L()lyn;Fc%F3p-b(`vxHI(IR-JUUog0E_F>cgl2bSd9oJec+2A1n@_SkG zR3Il8cRJ4thm^qTK`ODba1>AjXp)>p%cP~+OKku*#V!Dx*4?fhiU8=?Qgv*Y4(Z3? z05qm4D$__n4O}a$g&-dprwUS%KsKX^wo|3&btu_!0yjA(a#ssT0F?OZkGcq6 zL{%B}8FzGxKBz41R&nDs+!Yqa;x<=cd*dKD8dP&9K{(uOHQR+G*pN!yfCVVs8^+wE z@gom#+$nMV8^cLotg6LH4vk&y>u0INkarH|5ekakj~XVy#UJsdDvj>nAU;W{S}hZc}` z3tOnUrc<~m4DAG1R(!Wn(?&9ur2ti^pF}E$Vw@dCGl@EpqsNzE5lEg0rI&(gG)gTL z{BE;nR9%^K%1T*STICY6j7bENKoYge)NWKkqO8W`0Ad$#io|S$5(jP(n0N`VSGFWbk8HCVZOG}N81K8p2p~$t2F^ems zk)VyP(Z*)C)fPokpfJhpaPk#gxFn2%F4Xq1)RD~D<9w0>SIAl7$mB0;sXHvn9tp5e zr%Lup9C%Ao)Z~n=yM`fob4JS@^khib?wr$Y`S@OstV;~Ak>;0}&kpGxd)m3;5Z|=030$&7DI;r0A!~9tlJK^ zo(tP30Wu4k_WeX#LH_^>kvo#FWtKQZ>L8X;{goBDIgX+|tu;-L3#XZpf&nIl zpo6&*dXqW+>i#A}8a}oH6HbdZ*KE z=!>JKN_{7k>2%DtNtVJZ ze$qA}cOi#b%5$(`9pBOoU)dv&{dRaU-awY=hr+d+hV2(Etd3C0*}rf+qyAz40Lm27 zbWCv^`1;$7G~c7R(FIR~g^b-hB;#i=z86@H$Mpg1g=Fe^y60q4FuqoeyGHH{uyn4o zE-aZ?kr@PLp4OUse(mK$=gfw`Xpm~!wl1gG$sz1}MG~?T;lw-3Tr7JpMI9*IogLZj zm7+#pd}n70UUQd+JY>0~mYMn| zy_FJLiLPszTw2t#Fvk-@rKDmrDU1j84pIF574b2&4+|@~9SKwk@TD^v+}_JTG=bP0 zS@XioX>yEbwXzDM<$8`h@J)-gT_(YDW^wVO2VemO8t?i$LJace5j^haXZQP{F zMtd!mU3{+MX@Wx6A1ZxK%xmm$6j=I`W39kL_KUY-O#A^9M2O704=(8qS{7bsm^7YS_V& zLy{cV#&_6SC9Y`jh_uaLK-C{4x{QvBSXl1a8zcD?JR7anM@^R_8JP1pnXuUK9AG7UR^w4^#oZk<3h)`wZh%? zN+10_yrV78*1rnz-=k){WofyLfBJq?X{H&-q8<KQxT-*?@6-@U6$G!5PI zR#H7)mBV0^&n=O}5pEW1fKRf!qUT~@Y8d%hIR5~cjw9Xa6SJH+2jb8YT;~RhE+&8* z*-e$?9@_1#h(7*SRo!QN`iQv6Ft&cBK6ZXiWTbkN$mhGXPz3lM!@|9TknCm|nAVq@ zXe3<%EBmbD4#4}Pj1Y(+0zzeRw+GaOERGT4}ZPj~ec7cOT{Gu#>)3%-yz1KCqm6V+Mgyq2A@{{T=& z8!e8?#S*>VkaIy7{I|GU4LD=!SsBiforjAQo|{Ra*E||O-FcfFclxT8=w_BS5XX?o zIRNZy-6&7;Mp%05iEAT8gxr|ea-#v!#X-WhvaLv8j`*Da0Q!;(uz3YG4O8+OW11mj zo07uQdyq$z5B)}YWr5EinCLfe3a)`HlAPS5+In^?;l$EdOT)XqpgAo*%Rv^U7vvn+ zTzg*8Vyd0ymz`qfnX#PG0Bc`vH@HOq0My>xM!JA$1%`+DTc;z&&(ZHLe_6Z2&Vw%= zq;P4E&$_XXm05AMgn|Gj_&;UmT5hC7Q}(vo$-UKxHLqJP0O<&;&SJ-;U&Pp3-q z*R=L+PcgH^V{zZGcGr@DV+TOa=RfFqsy-ZsGg)DXJev)+{Hb54vP@<<%>}G*AYVTv zUEe2*9+M_0XrtO~FtXba02>3ET8MKabbZ9t4cC-GocAz3CZ5~9mWi5!TLYN$+DNf$ zNY0NltmrnE^BY#>K=*9n_g2_Lg@Ow6D6=vnoHfAq-p(8qufok8pcihfO!NAlf>`5f zMu{Xa=dppM!~jiS%CjC+a&T6OqtAGzmFinjxucrhNSNVZrb6;lnZ<(IKIyQ7+$0BM z$nd&k8?oQzOv1q06-zUB#C#S(wZc^)kk-11Q<+)~53VrM?!CWoJ5k9WsJC(mEIS{# zUOCi|KqeUhzN-$;BlQ98@K>hllX{LZ$m@}U#`Rxyf}6i844f%LL);76=N{ise0;An zsP5qVuc9wQNw4?6w8KOs%fT@E2eucI$-RO8SAW@3$j5nz<+32w0wa(E!>gM1Dtv6W z;AK8J8s{^(i6SJlJI3gyMof`my9LmCPIw-*kJbUUAH6R>hOS4~xlS{zaraMe{Y=b_ znisLoZ4l7rgTZP40J8J#TO8tMJV#0-~wWdqmqwe}nU;=&$BBrhqJZ_Li}AzBV?;iSyMwk@`yrk!-?$qpPs7Zo0>WB6(j4=IUA|bOf=C?yrUA zx$MF(ds^CYJ5tVI<~_1Cu6Ygnt$>eDmLUG{95>}sWHm-%-9M-hWNQg;C}fe%1N&aW z3fm5&ml&9U4{reg)iT|Z{{H|-3-(B*umSGB6q5iYb;EtaRa_)lFrDy=jpQGM!I?9k z-1igrP&nTypl+3oAh^tl?WZ*k$aG}=DiUjj0XBxgA;hjG+Da_3B$7%-B!?j-*7ATK z=j^WLwa+Y`oLcsPTt>yfZWS^dJ4qA|2i6|aWQ>!&!h47xc7z)~5s#AY z$M>_w z*q%JA%$^K=lS#+CWHP)9{|x*Oewi10*%U+$!~Id;x8eQP``{OrsY2zuL zpzH$YYpb}57s`y1N-Pcy%IP#aLgycK)Bx1_u$xL&G?PFk0~@x<_k6CsovDGs!T@vH zK(%5vk56?V>@3|yega@d2x%%O@@Yz2M|9V-f{+pTT^p{3kS?}O8x#Q`Z3AhfY@A(x zWY-h`#L}FaQeaHS0k}~;)>j+KT)9bi#TF^9hVOCVCPoW+s@+6IY&cy9bH9X9qI~i+ zp684EE0RPT3uI}s3a1$z;FMYTvO5X$MfEYR9sd9dS$LMw$_FHpN#vv(X#r-GfvzNh z%A+K#h;vFnOLjg}2rWEO3d~)v*or`+uYt{touu6r2dF`-Qc1BO6^-&t3XI8Oj1mGW+;)%w0H~mVIP6gvVsl;%*a?AHY0@-zGU-{3wmV)a z9f{2??Exp_F~fmsEYdNvF_VZ#)ZM}fG!jPc;d`xw%q%rl6%2+(M#J_=n?rz3HmNKX zxdmO9UY17DaZyR9i5dtLp=O#cji})5U4K^?dV6-1Wy&u$RdVt|JT#`C3U+C%0DURh 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

e`>n54=JfQK&2FAt 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