From 61a803140210a96880f86a0126bd58458ea451ca Mon Sep 17 00:00:00 2001 From: Natalia Portillo Date: Tue, 14 Apr 2026 23:32:38 +0100 Subject: [PATCH] Add ARJ and ARJZ decompression methods and corresponding tests - Introduced arjz.h header file with function declaration for buffer decompression. - Updated library.h to include ARJ and ARJZ decompression method declarations. - Added test cases for ARJ decompression methods (Method 1 to Method 4) in arj.cpp. - Implemented test cases for ARJZ decompression methods in arjz.cpp, including default and custom extended DEFLATE. - Copied necessary binary test data files for ARJ and ARJZ methods into the tests/data directory. --- CMakeLists.txt | 7 +- arj/arj.c | 257 ++++++++ arj/arj.h | 47 ++ arj/arj_fastest.c | 118 ++++ arjz/arjz.c | 1123 +++++++++++++++++++++++++++++++++++ arjz/arjz.h | 29 + library.h | 25 + tests/CMakeLists.txt | 22 +- tests/arj/arj.cpp | 175 ++++++ tests/arjz/arjz.cpp | 101 ++++ tests/data/arj_m1.bin | Bin 0 -> 55125 bytes tests/data/arj_m2.bin | Bin 0 -> 55721 bytes tests/data/arj_m3.bin | Bin 0 -> 59190 bytes tests/data/arj_m4.bin | Bin 0 -> 66519 bytes tests/data/arjz_default.bin | Bin 0 -> 52577 bytes tests/data/arjz_v55_new.bin | Bin 0 -> 52010 bytes tests/data/arjz_v55_old.bin | Bin 0 -> 53053 bytes 17 files changed, 1902 insertions(+), 2 deletions(-) create mode 100644 arj/arj.c create mode 100644 arj/arj.h create mode 100644 arj/arj_fastest.c create mode 100644 arjz/arjz.c create mode 100644 arjz/arjz.h create mode 100644 tests/arj/arj.cpp create mode 100644 tests/arjz/arjz.cpp create mode 100644 tests/data/arj_m1.bin create mode 100644 tests/data/arj_m2.bin create mode 100644 tests/data/arj_m3.bin create mode 100644 tests/data/arj_m4.bin create mode 100644 tests/data/arjz_default.bin create mode 100644 tests/data/arjz_v55_new.bin create mode 100644 tests/data/arjz_v55_old.bin diff --git a/CMakeLists.txt b/CMakeLists.txt index 8abe34a..03c3461 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -171,7 +171,12 @@ add_library("Aaru.Compression.Native" SHARED library.c apple_rle.c apple_rle.h a ace/sound.c ace/pic.c ace/v1.c - ace/v2.c) + ace/v2.c + arj/arj.c + arj/arj.h + arj/arj_fastest.c + arjz/arjz.c + arjz/arjz.h) include(3rdparty/bzip2.cmake) include(3rdparty/flac.cmake) diff --git a/arj/arj.c b/arj/arj.c new file mode 100644 index 0000000..c61c5b8 --- /dev/null +++ b/arj/arj.c @@ -0,0 +1,257 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include "arj.h" +#include "../lha/bitio.h" +#include "../lha/huffman.h" +#include "../lha/lzss.h" + +#include +#include + +/* + * Parse a generic Huffman code from the bitstream. + * width = number of bits for the symbol count. + * specialindex = index at which to insert extra zero-run bits (-1 for none). + */ +static lha_prefix_code *arj_parse_code(lha_bitio *bitio, int width, int specialindex) +{ + int num = (int)lha_bitio_next_bits(bitio, width); + + if(num == 0) + { + int val = (int)lha_bitio_next_bits(bitio, width); + lha_prefix_code *code = lha_prefix_code_new(); + + if(!code) return NULL; + + lha_prefix_code_add(code, val, 0, 0); + return code; + } + else + { + int *codelengths = (int *)calloc((size_t)num, sizeof(int)); + int n = 0; + lha_prefix_code *code; + + if(!codelengths) return NULL; + + while(n < num) + { + int len = (int)lha_bitio_next_bits(bitio, 3); + + if(len == 7) + while(lha_bitio_next_bit(bitio)) len++; + + codelengths[n++] = len; + + if(n == specialindex) + { + int zeroes = (int)lha_bitio_next_bits(bitio, 2); + int i; + + for(i = 0; i < zeroes && n < num; i++) codelengths[n++] = 0; + } + } + + code = lha_prefix_code_from_lengths(codelengths, num, 16, true); + free(codelengths); + return code; + } +} + +/* + * Parse the literal/length Huffman code (uses metacode compression). + */ +static lha_prefix_code *arj_parse_literal_code(lha_bitio *bitio) +{ + lha_prefix_code *metacode = arj_parse_code(bitio, 5, 3); + lha_prefix_code *code; + int num, n; + int *codelengths; + + if(!metacode) return NULL; + + num = (int)lha_bitio_next_bits(bitio, 9); + + if(num == 0) + { + int val = (int)lha_bitio_next_bits(bitio, 9); + + lha_prefix_code_free(metacode); + code = lha_prefix_code_new(); + + if(!code) return NULL; + + lha_prefix_code_add(code, val, 0, 0); + return code; + } + + codelengths = (int *)calloc((size_t)num, sizeof(int)); + + if(!codelengths) + { + lha_prefix_code_free(metacode); + return NULL; + } + + n = 0; + + while(n < num) + { + int c = lha_prefix_code_decode(bitio, metacode); + + if(c < 0) break; + + if(c <= 2) + { + int zeros = 0, i; + + switch(c) + { + case 0: + zeros = 1; + break; + case 1: + zeros = (int)lha_bitio_next_bits(bitio, 4) + 3; + break; + case 2: + zeros = (int)lha_bitio_next_bits(bitio, 9) + 20; + break; + } + + if(n + zeros > num) zeros = num - n; + + for(i = 0; i < zeros; i++) codelengths[n++] = 0; + } + else + { + codelengths[n++] = c - 2; + } + } + + lha_prefix_code_free(metacode); + code = lha_prefix_code_from_lengths(codelengths, num, 16, true); + free(codelengths); + return code; +} + +/* + * Block-based static Huffman + LZSS decompression for ARJ methods 1-3. + * window_bits: 15 for standard ARJ, 16 for ARJZ version 51. + */ +static int arj_decompress_lzh(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len, int window_bits) +{ + lha_bitio bitio; + lha_lzss lzss; + lha_prefix_code *literalcode = NULL; + lha_prefix_code *distancecode = NULL; + int blocksize = 0; + int blockpos = 0; + size_t expected; + int dist_width; + + if(!in_buf || !out_buf || !out_len || in_len == 0) return -1; + + expected = *out_len; + dist_width = window_bits < 15 ? 4 : 5; + + if(!lha_lzss_init(&lzss, (size_t)1 << window_bits, out_buf, expected)) return -1; + + lha_bitio_init(&bitio, in_buf, in_len); + + while(lzss.out_pos < expected && !lha_bitio_at_eof(&bitio)) + { + if(blockpos >= blocksize) + { + blocksize = (int)lha_bitio_next_bits(&bitio, 16); + blockpos = 0; + + lha_prefix_code_free(literalcode); + lha_prefix_code_free(distancecode); + + literalcode = arj_parse_literal_code(&bitio); + distancecode = arj_parse_code(&bitio, dist_width, -1); + + if(!literalcode || !distancecode) + { + lha_prefix_code_free(literalcode); + lha_prefix_code_free(distancecode); + lha_lzss_cleanup(&lzss); + return -1; + } + } + + blockpos++; + + { + int lit = lha_prefix_code_decode(&bitio, literalcode); + + if(lit < 0) break; + + if(lit < 0x100) { lha_lzss_emit_literal(&lzss, (uint8_t)lit); } + else + { + int length = lit - 0x100 + 3; + int bit = lha_prefix_code_decode(&bitio, distancecode); + int offset; + + if(bit < 0) break; + + if(bit == 0) + offset = 1; + else if(bit == 1) + offset = 2; + else + offset = (1 << (bit - 1)) + (int)lha_bitio_next_bits(&bitio, bit - 1) + 1; + + lha_lzss_emit_match(&lzss, offset, length); + } + } + } + + *out_len = lzss.out_pos; + lha_prefix_code_free(literalcode); + lha_prefix_code_free(distancecode); + lha_lzss_cleanup(&lzss); + return 0; +} + +AARU_EXPORT int AARU_CALL arj_decompress_method1(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len) +{ return arj_decompress_lzh(in_buf, in_len, out_buf, out_len, 15); } + +AARU_EXPORT int AARU_CALL arj_decompress_method2(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len) +{ return arj_decompress_lzh(in_buf, in_len, out_buf, out_len, 15); } + +AARU_EXPORT int AARU_CALL arj_decompress_method3(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len) +{ return arj_decompress_lzh(in_buf, in_len, out_buf, out_len, 15); } + +AARU_EXPORT int AARU_CALL arjz_decompress_method1(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len) +{ return arj_decompress_lzh(in_buf, in_len, out_buf, out_len, 16); } + +AARU_EXPORT int AARU_CALL arjz_decompress_method2(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len) +{ return arj_decompress_lzh(in_buf, in_len, out_buf, out_len, 16); } + +AARU_EXPORT int AARU_CALL arjz_decompress_method3(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len) +{ return arj_decompress_lzh(in_buf, in_len, out_buf, out_len, 16); } diff --git a/arj/arj.h b/arj/arj.h new file mode 100644 index 0000000..41cb46c --- /dev/null +++ b/arj/arj.h @@ -0,0 +1,47 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef AARU_COMPRESSION_NATIVE__ARJ_ARJ_H_ +#define AARU_COMPRESSION_NATIVE__ARJ_ARJ_H_ + +#include +#include +#include "../library.h" + +AARU_EXPORT int AARU_CALL arj_decompress_method1(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len); + +AARU_EXPORT int AARU_CALL arj_decompress_method2(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len); + +AARU_EXPORT int AARU_CALL arj_decompress_method3(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len); + +AARU_EXPORT int AARU_CALL arj_decompress_fastest(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len); + +AARU_EXPORT int AARU_CALL arjz_decompress_method1(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len); + +AARU_EXPORT int AARU_CALL arjz_decompress_method2(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len); + +AARU_EXPORT int AARU_CALL arjz_decompress_method3(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len); + +#endif /* AARU_COMPRESSION_NATIVE__ARJ_ARJ_H_ */ diff --git a/arj/arj_fastest.c b/arj/arj_fastest.c new file mode 100644 index 0000000..7fd215d --- /dev/null +++ b/arj/arj_fastest.c @@ -0,0 +1,118 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include "../lha/bitio.h" +#include "../lha/lzss.h" +#include "arj.h" + +#include + +#define ARJ_FASTEST_WINDOW_SIZE 32768 +#define ARJ_FASTEST_LEN_START 0 +#define ARJ_FASTEST_LEN_STOP 7 +#define ARJ_FASTEST_PTR_START 9 +#define ARJ_FASTEST_PTR_STOP 13 + +/* + * Decode a variable-width length value. + * Reads continuation bits from width LEN_START to LEN_STOP. + * Returns 0 for literal, >0 for match length component. + */ +static int arj_decode_len(lha_bitio *bitio) +{ + int val = 0; + int w = ARJ_FASTEST_LEN_START; + + while(w < ARJ_FASTEST_LEN_STOP) + { + if(!lha_bitio_next_bit(bitio)) break; + + val += 1 << w; + w++; + } + + if(w > ARJ_FASTEST_LEN_START) val += (int)lha_bitio_next_bits(bitio, w); + + return val; +} + +/* + * Decode a variable-width distance/pointer value. + * Reads continuation bits from width PTR_START to PTR_STOP. + */ +static int arj_decode_ptr(lha_bitio *bitio) +{ + int val = 0; + int w = ARJ_FASTEST_PTR_START; + + while(w < ARJ_FASTEST_PTR_STOP) + { + if(!lha_bitio_next_bit(bitio)) break; + + val += 1 << w; + w++; + } + + val += (int)lha_bitio_next_bits(bitio, w); + return val; +} + +/* + * ARJ method 4 ("Fastest") decompression. + * LZSS with variable-width Golomb-Rice codes for length and distance. + * 32KB sliding window, MSB-first bit extraction. + */ +AARU_EXPORT int AARU_CALL arj_decompress_fastest(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len) +{ + lha_bitio bitio; + lha_lzss lzss; + size_t expected; + + if(!in_buf || !out_buf || !out_len || in_len == 0) return -1; + + expected = *out_len; + + if(!lha_lzss_init(&lzss, ARJ_FASTEST_WINDOW_SIZE, out_buf, expected)) return -1; + + lha_bitio_init(&bitio, in_buf, in_len); + + while(lzss.out_pos < expected && !lha_bitio_at_eof(&bitio)) + { + int c = arj_decode_len(&bitio); + + if(c == 0) + { + /* Literal byte */ + uint8_t byte = (uint8_t)lha_bitio_next_bits(&bitio, 8); + lha_lzss_emit_literal(&lzss, byte); + } + else + { + /* Match: length = c - 1 + threshold(3) = c + 2 */ + int length = c + 2; + int offset = arj_decode_ptr(&bitio) + 1; + + lha_lzss_emit_match(&lzss, offset, length); + } + } + + *out_len = lzss.out_pos; + lha_lzss_cleanup(&lzss); + return 0; +} diff --git a/arjz/arjz.c b/arjz/arjz.c new file mode 100644 index 0000000..aedcd61 --- /dev/null +++ b/arjz/arjz.c @@ -0,0 +1,1123 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include "arjz.h" + +#include +#include + +/* Constants */ +#define ARJZ_MIN_WINDOW_SIZE 65536 + +#define LENGTH_CODES 29 +#define LITERALS 256 +#define REP_BOTH_LIT 256 +#define MMBLOCK_LIT 257 +#define STR2_LIT 258 +#define STR2_LAST_LIT 265 +#define STR3_LIT 266 +#define STR3_LAST_LIT 301 +#define END_BLOCK_LIT 302 + +#define SPEC_CODES (END_BLOCK_LIT - LITERALS + 1) +#define L_CODES (LITERALS + SPEC_CODES + LENGTH_CODES) + +#define REPDIST_CODES 4 +#define D_CODES_LB 6 +#define D_CODES (REPDIST_CODES + 60) + +#define BL_CODES 19 + +/* Huffman table entry types (stored in e field) */ +#define LIT_CODE 36 +#define EOB_CODE 37 +#define REPB_CODE 38 +#define MM_CODE 39 +#define STR2_CODE 40 +#define STR2_LASTCODE 49 +#define STR3_CODE 50 +#define STR3_LASTCODE 89 +#define REPDIST_CODE 90 +#define REPDIST_LASTCODE 99 +#define TABLE_BASECODE 100 +#define NONSENSE_CODE 119 + +#define BMAX 16 +#define N_MAX 512 + +#define MAX_MMDIST 4 + +/* Huffman table entry */ +typedef struct arjz_huft +{ + uint8_t e; /* extra bits or operation */ + uint8_t b; /* bits in this code */ + + union + { + uint32_t n; /* literal, length base, or distance base */ + struct arjz_huft *t; /* pointer to next level of table */ + } v; +} arjz_huft; + +/* Decompression context */ +typedef struct +{ + /* Input */ + const uint8_t *in_buf; + size_t in_len; + size_t in_pos; + + /* Bit buffer */ + uint32_t bb; + unsigned bk; + + /* Output */ + uint8_t *out_buf; + size_t out_len; + size_t out_pos; + + /* Sliding window */ + uint8_t *window; + size_t window_size; + size_t window_mask; + size_t wp; + size_t lastwp; + + /* MM block state */ + size_t mmstart; + unsigned mmdist; + unsigned mmcount; + unsigned mmtype; + char mmvalue[MAX_MMDIST]; + + /* E8/E9 state */ + unsigned exediff; + size_t filesize; + size_t filepos; + char hold[5]; + int bytes_on_hold; + + /* Stream parameters */ + uint32_t md4; + + /* Huffman table memory pool */ + uint8_t *pool; + size_t pool_size; + size_t pool_used; + + /* Literal/distance code lengths (persistent for DIFF_TREES) */ + unsigned ll[L_CODES + D_CODES]; +} arjz_ctx; + +/* Bit length code order */ +static const unsigned arjz_border[19] = {16, 17, 18, 0, 1, 15, 2, 14, 3, 13, 4, 12, 5, 11, 6, 10, 7, 9, 8}; + +/* Base distances for literal codes (2-byte strings, 3-byte strings, lengths) */ +/* Padded to 256 entries for static block table builder (codes 256-511 need indices 0-255) */ +static const uint32_t arjz_cplens[256] = { + 0, 0, /* 2-byte: */ 1, 5, 9, 17, 33, 65, 129, 193, + /* 3-byte: */ 0, 0, 0, 0, 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, + 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0x8001, 0xC001, 0, + /* Length bases: */ + 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 24, 28, 32, 36, 44, 52, 60, 68, 84, 100, 116, 132, 164, 196, 228, 260, + 0, 0 + /* remaining entries are zero-initialized */ +}; + +/* Extra bits/codes for literal codes */ +/* Padded to 256 entries; extra entries set to NONSENSE_CODE for safety */ +static const uint32_t arjz_cplext[256] = { + REPB_CODE, MM_CODE, + /* 2-byte strings: */ + STR2_CODE + 2, STR2_CODE + 2, STR2_CODE + 3, STR2_CODE + 4, STR2_CODE + 5, STR2_CODE + 6, STR2_CODE + 6, + STR2_CODE + 6, + /* 3-byte strings: */ + REPDIST_CODE, REPDIST_CODE + 1, REPDIST_CODE + 2, REPDIST_CODE + 3, STR3_CODE + 0, STR3_CODE + 0, STR3_CODE + 0, + STR3_CODE + 0, STR3_CODE + 1, STR3_CODE + 1, STR3_CODE + 2, STR3_CODE + 2, STR3_CODE + 3, STR3_CODE + 3, + STR3_CODE + 4, STR3_CODE + 4, STR3_CODE + 5, STR3_CODE + 5, STR3_CODE + 6, STR3_CODE + 6, STR3_CODE + 7, + STR3_CODE + 7, STR3_CODE + 8, STR3_CODE + 8, STR3_CODE + 9, STR3_CODE + 9, STR3_CODE + 10, STR3_CODE + 10, + STR3_CODE + 11, STR3_CODE + 11, STR3_CODE + 12, STR3_CODE + 12, STR3_CODE + 13, STR3_CODE + 13, STR3_CODE + 14, + STR3_CODE + 14, EOB_CODE, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 14, + /* Padding: unused code slots filled with NONSENSE_CODE */ + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, + NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE, NONSENSE_CODE}; + +/* Distance base values */ +static const uint32_t arjz_cpdist[] = { + 0, 0, 0, 0, 1, 2, 3, 4, 5, + 7, 9, 13, 17, 25, 33, 49, 65, 97, + 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, + 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0x8001, 0xC001, + 0x00010001, 0x00018001, 0x00020001, 0x00030001, 0x00040001, 0x00060001, 0x00080001, 0x000C0001, 0x00100001, + 0x00180001, 0x00200001, 0x00300001, 0x00400001, 0x00600001, 0x00800001, 0x00C00001, 0x01000001, 0x01800001, + 0x02000001, 0x03000001, 0x04000001, 0x06000001, 0x08000001, 0x0C000001, 0x10000001, 0x18000001, 0x20000001, + 0x30000001, 0x40000001, 0x60000001, 0x80000001U, 0xC0000001U}; + +/* Distance extra bits */ +static const uint32_t arjz_cpdext[] = {REPDIST_CODE, + REPDIST_CODE + 1, + REPDIST_CODE + 2, + REPDIST_CODE + 3, + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 5, + 6, + 6, + 7, + 7, + 8, + 8, + 9, + 9, + 10, + 10, + 11, + 11, + 12, + 12, + 13, + 13, + 14, + 14, + 15, + 15, + 16, + 16, + 17, + 17, + 18, + 18, + 19, + 19, + 20, + 20, + 21, + 21, + 22, + 22, + 23, + 23, + 24, + 24, + 25, + 25, + 26, + 26, + 27, + 27, + 28, + 28, + 29, + 29, + 30, + 30}; + +/* Bit masks */ +static const uint32_t arjz_mask[] = {0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, + 0x007f, 0x00ff, 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, + 0x3fff, 0x7fff, 0xffff, 0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff, + 0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff, + 0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff}; + +/* ---- Bit I/O ---- */ + +static int arjz_nextbyte(arjz_ctx *ctx) +{ + if(ctx->in_pos >= ctx->in_len) return -1; + return ctx->in_buf[ctx->in_pos++]; +} + +static int arjz_needbits(arjz_ctx *ctx, unsigned n) +{ + while(ctx->bk < n) + { + int c = arjz_nextbyte(ctx); + if(c < 0) return -1; + ctx->bb |= (uint32_t)c << ctx->bk; + ctx->bk += 8; + } + return 0; +} + +static unsigned arjz_readbits(arjz_ctx *ctx, unsigned n) +{ + unsigned val; + arjz_needbits(ctx, n); + val = (unsigned)(ctx->bb & arjz_mask[n]); + ctx->bb >>= n; + ctx->bk -= n; + return val; +} + +/* ---- Memory pool for Huffman tables ---- */ + +#define ARJZ_POOL_SIZE (256 * 1024) + +static arjz_huft *arjz_pool_alloc(arjz_ctx *ctx, size_t count) +{ + size_t need = count * sizeof(arjz_huft); + arjz_huft *ptr; + + if(ctx->pool_used + need > ctx->pool_size) return NULL; + + ptr = (arjz_huft *)(ctx->pool + ctx->pool_used); + ctx->pool_used += need; + return ptr; +} + +static void arjz_pool_reset(arjz_ctx *ctx) { ctx->pool_used = 0; } + +/* ---- Huffman table builder ---- */ + +static int arjz_huft_build(arjz_ctx *ctx, unsigned *b, unsigned n, unsigned s, const uint32_t *d, const uint32_t *e, + arjz_huft **t, int *m) +{ + unsigned a; + unsigned c[BMAX + 1]; + unsigned el; + unsigned f; + int g; + int h; + unsigned i, j; + int k; + int lx[BMAX + 1]; + int *l = lx + 1; + unsigned *p; + arjz_huft *q; + arjz_huft r; + arjz_huft *u[BMAX]; + unsigned v[N_MAX]; + int w; + unsigned x[BMAX + 1]; + unsigned *xp; + int y; + unsigned z; + + el = n >= END_BLOCK_LIT ? b[END_BLOCK_LIT] : BMAX; + memset(c, 0, sizeof(c)); + p = b; + i = n; + do + { + c[*p]++; + p++; + } while(--i); + + if(c[0] == n) + { + *t = NULL; + *m = 0; + return 0; + } + + for(j = 1; j <= BMAX; j++) + if(c[j]) break; + k = (int)j; + if((unsigned)*m < j) *m = (int)j; + + for(i = BMAX; i; i--) + if(c[i]) break; + g = (int)i; + if((unsigned)*m > i) *m = (int)i; + + for(y = 1 << j; (int)j < (int)i; j++, y <<= 1) + if((y -= (int)c[j]) < 0) return 2; + if((y -= (int)c[i]) < 0) return 2; + c[i] += (unsigned)y; + + x[1] = j = 0; + p = c + 1; + xp = x + 2; + { + unsigned ii = i; + while(--ii) *xp++ = (j += *p++); + } + + p = b; + i = 0; + do + { + if((j = *p++) != 0) v[x[j]++] = i; + } while(++i < n); + + x[0] = i = 0; + p = v; + h = -1; + w = l[-1] = 0; + u[0] = NULL; + q = NULL; + z = 0; + + for(; k <= g; k++) + { + a = c[k]; + while(a--) + { + while(k > w + l[h]) + { + w += l[h++]; + z = (unsigned)(g - w); + if(z > (unsigned)*m) z = (unsigned)*m; + if((f = 1 << (j = (unsigned)(k - w))) > a + 1) + { + f -= a + 1; + xp = c + k; + while(++j < z) + { + if((f <<= 1) <= *++xp) break; + f -= *xp; + } + } + if((unsigned)w + j > el && (unsigned)w < el) j = el - (unsigned)w; + z = 1 << j; + l[h] = (int)j; + + q = arjz_pool_alloc(ctx, z + 1); + if(!q) return 3; + + *t = q + 1; + *(t = &(q->v.t)) = NULL; + u[h] = ++q; + + if(h) + { + x[h] = i; + r.b = (uint8_t)l[h - 1]; + r.e = (uint8_t)(TABLE_BASECODE + j); + r.v.t = q; + j = (i & ((1 << w) - 1)) >> (w - l[h - 1]); + u[h - 1][j] = r; + } + } + + r.b = (uint8_t)(k - w); + if(p >= v + n) + r.e = NONSENSE_CODE; + else if(*p < s) + { + r.e = LIT_CODE; + r.v.n = *p++; + } + else + { + r.e = (uint8_t)e[*p - s]; + r.v.n = d[*p++ - s]; + } + + f = 1 << (k - w); + for(j = i >> w; j < z; j += f) q[j] = r; + + for(j = 1 << (k - 1); i & j; j >>= 1) i ^= j; + i ^= j; + + while((i & ((1 << w) - 1)) != x[h]) w -= l[--h]; + } + } + + *m = l[0]; + return y != 0 && g != 1; +} + +/* ---- Delta encoding (multimedia) ---- */ + +static void arjz_undiff1(uint8_t *buf, unsigned items, unsigned step) +{ + uint8_t prev = 0; + unsigned i; + for(i = 0; i < items; i++) + { + prev += buf[i * step]; + buf[i * step] = prev; + } +} + +static void arjz_undiff2(uint8_t *buf, unsigned items, unsigned step) +{ + int16_t prev = 0; + unsigned i; + for(i = 0; i < items; i++) + { + int16_t val; + memcpy(&val, buf + i * step, 2); + prev += val; + memcpy(buf + i * step, &prev, 2); + } +} + +static void arjz_undiff4(uint8_t *buf, unsigned items, unsigned step) +{ + int32_t prev = 0; + unsigned i; + for(i = 0; i < items; i++) + { + int32_t val; + memcpy(&val, buf + i * step, 4); + prev += val; + memcpy(buf + i * step, &prev, 4); + } +} + +static void arjz_diff1(uint8_t *buf, unsigned items, unsigned step) +{ + uint8_t cur, prev = 0; + unsigned i; + for(i = 0; i < items; i++) + { + cur = buf[i * step]; + buf[i * step] = cur - prev; + prev = cur; + } +} + +static void arjz_diff2(uint8_t *buf, unsigned items, unsigned step) +{ + int16_t cur, prev = 0; + unsigned i; + for(i = 0; i < items; i++) + { + memcpy(&cur, buf + i * step, 2); + int16_t diff = cur - prev; + memcpy(buf + i * step, &diff, 2); + prev = cur; + } +} + +static void arjz_diff4(uint8_t *buf, unsigned items, unsigned step) +{ + int32_t cur, prev = 0; + unsigned i; + for(i = 0; i < items; i++) + { + memcpy(&cur, buf + i * step, 4); + int32_t diff = cur - prev; + memcpy(buf + i * step, &diff, 4); + prev = cur; + } +} + +/* ---- E8/E9 post-processing ---- */ + +static int32_t arjz_untranslate(int32_t n, int32_t pos, int32_t fsize) +{ + if(n > 0 && n < fsize) + n -= pos; + else if(n <= 0 && n > -pos) + n += fsize - 1; + return n; +} + +static void arjz_e8_process(arjz_ctx *ctx, uint8_t *buf, size_t len) +{ + size_t i = 0; + + while(i < len) + { + if(buf[i] == 0xE8 || buf[i] == 0xE9) + { + if(i + 5 <= len) + { + int32_t pos = (int32_t)(ctx->filepos + i + 5); + int32_t val; + memcpy(&val, buf + i + 1, 4); + val = arjz_untranslate(val, pos, (int32_t)ctx->filesize); + memcpy(buf + i + 1, &val, 4); + i += 5; + continue; + } + } + i++; + } +} + +/* ---- MM block write-out ---- */ + +static void arjz_apply_mm(arjz_ctx *ctx, uint8_t *buf, size_t start, size_t bytes) +{ + if(ctx->mmcount > 0 && start < bytes) + { + uint8_t *mm_start = buf + start; + unsigned cnt = (bytes - start) / ctx->mmdist + 1; + + if(cnt <= 1) return; + if(cnt > ctx->mmcount) cnt = ctx->mmcount; + + /* Save delta values before undiff */ + char mmtmp[MAX_MMDIST]; + memcpy(mmtmp, mm_start, ctx->mmdist); + + if(ctx->mmtype == 2) memcpy(mm_start, ctx->mmvalue, ctx->mmdist); + + switch(ctx->mmdist) + { + case 1: + arjz_undiff1(mm_start, cnt, ctx->mmdist); + break; + case 2: + arjz_undiff2(mm_start, cnt, ctx->mmdist); + break; + case 3: + arjz_undiff1(mm_start, cnt, ctx->mmdist); + arjz_undiff1(mm_start + 1, cnt, ctx->mmdist); + arjz_undiff1(mm_start + 2, cnt, ctx->mmdist); + break; + case 4: + arjz_undiff4(mm_start, cnt, ctx->mmdist); + break; + } + + /* Save partial sum for continuation */ + memcpy(ctx->mmvalue, mm_start + (cnt - 2) * ctx->mmdist, ctx->mmdist); + + /* Re-apply diff for continued processing */ + switch(ctx->mmdist) + { + case 1: + arjz_diff1(mm_start, cnt, ctx->mmdist); + break; + case 2: + arjz_diff2(mm_start, cnt, ctx->mmdist); + break; + case 3: + arjz_diff1(mm_start, cnt, ctx->mmdist); + arjz_diff1(mm_start + 1, cnt, ctx->mmdist); + arjz_diff1(mm_start + 2, cnt, ctx->mmdist); + break; + case 4: + arjz_diff4(mm_start, cnt, ctx->mmdist); + break; + } + + memcpy(mm_start, mmtmp, ctx->mmdist); + + if((bytes - start) / ctx->mmdist >= ctx->mmcount) + ctx->mmcount = 0; + else + { + ctx->mmcount -= cnt - 2; + ctx->mmstart += (cnt - 2) * ctx->mmdist; + ctx->mmtype = 2; + } + } +} + +/* ---- Flush window to output ---- */ + +static void arjz_flush(arjz_ctx *ctx, size_t end) +{ + size_t count = end - ctx->lastwp; + uint8_t *src = ctx->window + ctx->lastwp; + + /* Apply MM block processing */ + if(ctx->mmcount) + { + unsigned mm_rel = 0; + if(ctx->mmstart >= ctx->lastwp) mm_rel = ctx->mmstart - ctx->lastwp; + arjz_apply_mm(ctx, src, mm_rel, count); + } + + /* Apply E8/E9 processing */ + if(ctx->exediff) arjz_e8_process(ctx, src, count); + + /* Copy to output */ + if(ctx->out_pos + count > ctx->out_len) count = ctx->out_len - ctx->out_pos; + + memcpy(ctx->out_buf + ctx->out_pos, src, count); + ctx->out_pos += count; + ctx->filepos += count; + ctx->lastwp = end; +} + +/* ---- Window management ---- */ + +static void arjz_output_char(arjz_ctx *ctx, size_t *wp, uint8_t c) +{ + ctx->window[*wp & ctx->window_mask] = c; + (*wp)++; + + if(*wp >= ctx->window_size) + { + arjz_flush(ctx, ctx->window_size); + *wp = 0; + ctx->lastwp = 0; + ctx->mmstart = 0; + } +} + +static void arjz_output_string(arjz_ctx *ctx, size_t *wp, uint32_t dist, unsigned len) +{ + unsigned i; + + for(i = 0; i < len; i++) + { + size_t src = (*wp - (size_t)dist) & ctx->window_mask; + uint8_t byte = ctx->window[src]; + ctx->window[*wp & ctx->window_mask] = byte; + (*wp)++; + + if(*wp >= ctx->window_size) + { + arjz_flush(ctx, ctx->window_size); + *wp = 0; + ctx->lastwp = 0; + ctx->mmstart = 0; + } + } +} + +/* ---- Inflate stored block ---- */ + +static int arjz_inflate_stored(arjz_ctx *ctx) +{ + unsigned n; + size_t w; + + arjz_readbits(ctx, ctx->bk & 7); /* align to byte boundary */ + n = arjz_readbits(ctx, 16); + + if(n != (arjz_readbits(ctx, 16) ^ 0xffff)) return -1; + + w = ctx->wp; + + while(n--) { arjz_output_char(ctx, &w, (uint8_t)arjz_readbits(ctx, 8)); } + + ctx->wp = w; + return 0; +} + +/* ---- Inflate coded block ---- */ + +static int arjz_inflate_codes(arjz_ctx *ctx, arjz_huft *tl, arjz_huft *td, int bl, int bd) +{ + unsigned e; + unsigned n; + uint32_t o; + size_t w; + arjz_huft *t; + unsigned ml, md; + + uint32_t lastdist[REPDIST_CODES]; + unsigned lastptr; + + w = ctx->wp; + ml = arjz_mask[bl]; + md = arjz_mask[bd]; + + lastptr = 0; + for(n = 0; n < REPDIST_CODES; n++) lastdist[n] = 1; + n = 1; + o = 1; + + for(;;) + { + if(arjz_needbits(ctx, (unsigned)bl) < 0) return -1; + t = tl + ((unsigned)ctx->bb & ml); + e = t->e; + + while(e > TABLE_BASECODE) + { + if(e == NONSENSE_CODE) return -1; + ctx->bb >>= t->b; + ctx->bk -= t->b; + e -= TABLE_BASECODE; + if(arjz_needbits(ctx, e) < 0) return -1; + t = t->v.t + ((unsigned)ctx->bb & arjz_mask[e]); + e = t->e; + } + + ctx->bb >>= t->b; + ctx->bk -= t->b; + + if(e == LIT_CODE) { arjz_output_char(ctx, &w, (uint8_t)t->v.n); } + else if(e == EOB_CODE) { break; } + else if(e == MM_CODE) + { + /* Flush before MM block */ + if(ctx->mmcount || ctx->exediff) arjz_flush(ctx, w); + + if(arjz_needbits(ctx, 2) < 0) return -1; + ctx->mmdist = 1 + ((unsigned)ctx->bb & 3); + ctx->bb >>= 2; + ctx->bk -= 2; + ctx->mmstart = w - ctx->mmdist; + + /* Decode MM count using distance table */ + if(arjz_needbits(ctx, (unsigned)bd) < 0) return -1; + t = td + ((unsigned)ctx->bb & md); + e = t->e; + while(e > TABLE_BASECODE) + { + if(e == NONSENSE_CODE) return -1; + ctx->bb >>= t->b; + ctx->bk -= t->b; + e -= TABLE_BASECODE; + if(arjz_needbits(ctx, e) < 0) return -1; + t = t->v.t + ((unsigned)ctx->bb & arjz_mask[e]); + e = t->e; + } + ctx->bb >>= t->b; + ctx->bk -= t->b; + + if(arjz_needbits(ctx, e) < 0) return -1; + ctx->mmcount = t->v.n + ((unsigned)ctx->bb & arjz_mask[e]); + ctx->bb >>= e; + ctx->bk -= e; + + ctx->mmtype = 1; + } + else + { + /* String/match codes */ + if(e >= STR2_CODE && e <= STR2_LASTCODE) + { + e -= STR2_CODE; + if(e > 0) + { + if(arjz_needbits(ctx, e) < 0) return -1; + } + o = t->v.n + (e > 0 ? ((unsigned)ctx->bb & arjz_mask[e]) : 0); + if(e > 0) + { + ctx->bb >>= e; + ctx->bk -= e; + } + n = 2; + } + else if(e >= REPDIST_CODE && e <= REPDIST_LASTCODE) + { + e -= REPDIST_CODE; + o = lastdist[(lastptr - e) % REPDIST_CODES]; + n = 3; + if(!e) goto skip_save; + } + else if(e >= STR3_CODE && e <= STR3_LASTCODE) + { + e -= STR3_CODE; + if(e > 0) + { + if(arjz_needbits(ctx, e) < 0) return -1; + } + o = t->v.n + (e > 0 ? ((unsigned)ctx->bb & arjz_mask[e]) : 0); + if(e > 0) + { + ctx->bb >>= e; + ctx->bk -= e; + } + n = 3; + } + else if(e == REPB_CODE) + { + /* Repeat both last length and offset */ + goto skip_save; + } + else + { + /* Standard length+distance */ + if(arjz_needbits(ctx, e) < 0) return -1; + n = t->v.n + ((unsigned)ctx->bb & arjz_mask[e]); + ctx->bb >>= e; + ctx->bk -= e; + + /* Decode distance */ + if(arjz_needbits(ctx, (unsigned)bd) < 0) return -1; + t = td + ((unsigned)ctx->bb & md); + e = t->e; + while(e > TABLE_BASECODE) + { + if(e == NONSENSE_CODE) return -1; + ctx->bb >>= t->b; + ctx->bk -= t->b; + e -= TABLE_BASECODE; + if(arjz_needbits(ctx, e) < 0) return -1; + t = t->v.t + ((unsigned)ctx->bb & arjz_mask[e]); + e = t->e; + } + ctx->bb >>= t->b; + ctx->bk -= t->b; + + if(e >= REPDIST_CODE) + { + e -= REPDIST_CODE; + o = lastdist[(lastptr - e) % REPDIST_CODES]; + if(!e) goto skip_save; + } + else + { + o = t->v.n; + if(e > 25) + { + if(arjz_needbits(ctx, 16) < 0) return -1; + o += ((unsigned)ctx->bb & 0xFFFF); + ctx->bb >>= 16; + ctx->bk -= 16; + e -= 16; + } + if(e > 0) + { + if(arjz_needbits(ctx, e) < 0) return -1; + if(e <= 16) + o += ((unsigned)ctx->bb & arjz_mask[e]); + else + o += ((uint32_t)ctx->bb & arjz_mask[e]); + ctx->bb >>= e; + ctx->bk -= e; + } + } + } + + lastptr = (lastptr + 1) % REPDIST_CODES; + lastdist[lastptr] = o; + + skip_save: + { + unsigned cnt = n; + if(o > ctx->md4) cnt++; + arjz_output_string(ctx, &w, o, cnt); + } + } + } + + ctx->wp = w; + return 0; +} + +/* ---- Inflate packed (dynamic or static Huffman) block ---- */ + +static int arjz_inflate_packed(arjz_ctx *ctx, int is_static) +{ + unsigned i, j, l, n; + unsigned m; + arjz_huft *tl = NULL; + arjz_huft *td = NULL; + unsigned lll[BL_CODES]; + int bl, bd; + unsigned nb, nl, nd; + int ret; + + arjz_pool_reset(ctx); + + if(is_static) + { + unsigned sl[512]; + for(i = 0; i < 512; i++) sl[i] = 9; + bl = 9; + ret = arjz_huft_build(ctx, sl, 512, LITERALS, arjz_cplens, arjz_cplext, &tl, &bl); + if(ret != 0 && ret != 1) return -1; + + for(i = 0; i < D_CODES; i++) sl[i] = D_CODES_LB; + bd = D_CODES_LB; + ret = arjz_huft_build(ctx, sl, D_CODES, 0, arjz_cpdist, arjz_cpdext, &td, &bd); + if(ret > 1) return -1; + + ret = arjz_inflate_codes(ctx, tl, td, bl, bd); + return ret; + } + + nl = LITERALS + SPEC_CODES + arjz_readbits(ctx, 5); + nd = 1 + arjz_readbits(ctx, D_CODES_LB); + nb = 4 + arjz_readbits(ctx, 4); + + if(nl > L_CODES || nd > D_CODES) return -1; + + memset(lll, 0, sizeof(lll)); + for(j = 0; j < nb; j++) lll[arjz_border[j]] = arjz_readbits(ctx, 3); + + bl = 7; + ret = arjz_huft_build(ctx, lll, BL_CODES, BL_CODES, NULL, NULL, &tl, &bl); + if(ret != 0 && ret != 1) return -1; + + n = L_CODES + nd; + m = arjz_mask[bl]; + i = 0; + l = 0; + + while(i < n) + { + if(i == nl) + { + while(i < L_CODES) ctx->ll[i++] = 0; + } + + if(arjz_needbits(ctx, (unsigned)bl) < 0) return -1; + td = tl + ((unsigned)ctx->bb & m); + j = td->b; + ctx->bb >>= j; + ctx->bk -= j; + j = td->v.n; + + if(j < 16) { ctx->ll[i++] += l = j; } + else if(j == 16) + { + j = 3 + arjz_readbits(ctx, 2); + if(i + j > n) return -1; + while(j--) ctx->ll[i++] += l; + } + else if(j == 17) + { + j = 3 + arjz_readbits(ctx, 3); + if(i + j > n) return -1; + while(j--) ctx->ll[i++] += 0; + l = 0; + } + else + { + j = 11 + arjz_readbits(ctx, 7); + if(i + j > n) return -1; + while(j--) ctx->ll[i++] += 0; + l = 0; + } + } + + while(i < L_CODES + D_CODES) ctx->ll[i++] = 0; + + for(i = 0; i < L_CODES + D_CODES; i++) ctx->ll[i] &= 15; + + arjz_pool_reset(ctx); + + bl = 10; + ret = arjz_huft_build(ctx, ctx->ll, nl, LITERALS, arjz_cplens, arjz_cplext, &tl, &bl); + if(ret != 0 && ret != 1) return -1; + + bd = D_CODES_LB; + ret = arjz_huft_build(ctx, ctx->ll + L_CODES, nd, 0, arjz_cpdist, arjz_cpdext, &td, &bd); + if(ret != 0 && ret != 1) return -1; + + ret = arjz_inflate_codes(ctx, tl, td, bl, bd); + return ret; +} + +/* ---- Main inflate entry point ---- */ + +AARU_EXPORT int AARU_CALL arjz_decompress_buffer(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len, size_t orig_size) +{ + arjz_ctx ctx; + int last_block; + int byte0, byte1; + + if(!in_buf || !out_buf || !out_len || in_len == 0) return -1; + + memset(&ctx, 0, sizeof(ctx)); + ctx.in_buf = in_buf; + ctx.in_len = in_len; + ctx.out_buf = out_buf; + ctx.out_len = *out_len; + ctx.filesize = orig_size; + + /* Compute window size: smallest power-of-2 >= orig_size, minimum 64KB */ + { + size_t ws = ARJZ_MIN_WINDOW_SIZE; + while(ws < orig_size && ws < (size_t)1 << 30) ws <<= 1; + ctx.window_size = ws; + ctx.window_mask = ws - 1; + } + + ctx.window = (uint8_t *)calloc(ctx.window_size + MAX_MMDIST * 2, 1); + if(!ctx.window) return -1; + + ctx.pool_size = ARJZ_POOL_SIZE; + ctx.pool = (uint8_t *)malloc(ctx.pool_size); + if(!ctx.pool) + { + free(ctx.window); + return -1; + } + + /* Read stream header: md4 parameter and exediff flag */ + byte0 = (int)arjz_readbits(&ctx, 8); + byte1 = (int)arjz_readbits(&ctx, 8); + + if(--byte0 < 0) + ctx.md4 = (uint32_t)byte1; + else + ctx.md4 = (uint32_t)(byte1 + 256) << byte0; + + ctx.exediff = arjz_readbits(&ctx, 1); + + memset(ctx.ll, 0, sizeof(ctx.ll)); + + do + { + last_block = (int)arjz_readbits(&ctx, 1); + unsigned block_type = arjz_readbits(&ctx, 2); + int ret; + + switch(block_type) + { + case 0: + ret = arjz_inflate_stored(&ctx); + break; + case 1: + ret = arjz_inflate_packed(&ctx, 1); + break; + case 2: + ret = arjz_inflate_packed(&ctx, 0); + break; + default: + ret = -1; + break; + } + + if(ret != 0) + { + free(ctx.pool); + free(ctx.window); + return -1; + } + } while(!last_block); + + /* Flush remaining data */ + if(ctx.wp != ctx.lastwp) arjz_flush(&ctx, ctx.wp); + + *out_len = ctx.out_pos; + free(ctx.pool); + free(ctx.window); + return 0; +} diff --git a/arjz/arjz.h b/arjz/arjz.h new file mode 100644 index 0000000..5fc7b80 --- /dev/null +++ b/arjz/arjz.h @@ -0,0 +1,29 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef AARU_COMPRESSION_NATIVE__ARJZ_ARJZ_H_ +#define AARU_COMPRESSION_NATIVE__ARJZ_ARJZ_H_ + +#include +#include +#include "../library.h" + +AARU_EXPORT int AARU_CALL arjz_decompress_buffer(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, + size_t *out_len, size_t orig_size); + +#endif /* AARU_COMPRESSION_NATIVE__ARJZ_ARJZ_H_ */ diff --git a/library.h b/library.h index 2130d4e..3cd7d57 100644 --- a/library.h +++ b/library.h @@ -240,4 +240,29 @@ AARU_EXPORT int AARU_CALL ace_decompress_lz77(const uint8_t *in_buf, size_t in_l // ACE v2 (Blocked) decompression AARU_EXPORT int AARU_CALL ace_decompress_blocked(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len, int dic_bits); +// ARJ Method 1 (LZH, most compression) +AARU_EXPORT int AARU_CALL arj_decompress_method1(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// ARJ Method 2 (LZH, medium compression) +AARU_EXPORT int AARU_CALL arj_decompress_method2(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// ARJ Method 3 (LZH, fast compression) +AARU_EXPORT int AARU_CALL arj_decompress_method3(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// ARJ Method 4 (Fastest, variable-width LZSS) +AARU_EXPORT int AARU_CALL arj_decompress_fastest(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// ARJZ Method 1 (LZH, 64KB window) +AARU_EXPORT int AARU_CALL arjz_decompress_method1(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// ARJZ Method 2 (LZH, 64KB window) +AARU_EXPORT int AARU_CALL arjz_decompress_method2(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// ARJZ Method 3 (LZH, 64KB window) +AARU_EXPORT int AARU_CALL arjz_decompress_method3(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len); + +// ARJZ custom extended DEFLATE decompression +AARU_EXPORT int AARU_CALL arjz_decompress_buffer(const uint8_t *in_buf, size_t in_len, uint8_t *out_buf, size_t *out_len, + size_t orig_size); + #endif // AARU_COMPRESSION_NATIVE_LIBRARY_H diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index abb0848..53997d8 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -96,11 +96,31 @@ file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/ace_v1_lz77.bin file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/ace_v2_blocked.bin DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/data/) +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/arj_m1.bin + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/data/) + +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/arj_m2.bin + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/data/) + +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/arj_m3.bin + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/data/) + +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/arj_m4.bin + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/data/) + +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/arjz_default.bin + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/data/) + +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/arjz_v55_new.bin + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/data/) + # 'Google_Tests_run' is the target name # 'test1.cpp tests2.cpp' are source files with tests add_executable(tests_run apple_rle.cpp crc32.c crc32.h adc.cpp bzip2.cpp lzip.cpp lzfse.cpp zstd.cpp lzma.cpp flac.cpp lz4.cpp zoo/lzd.cpp arc/pack.cpp lh5.cpp arc/squeeze.cpp arc/crunch.cpp arc/squash.cpp pak/crush.cpp pak/distill.cpp ha.cpp xz.cpp lha/lh_static.cpp lha/lh1.cpp lha/larc.cpp lha/lh_old.cpp - ace/ace.cpp) + ace/ace.cpp + arj/arj.cpp + arjz/arjz.cpp) target_link_libraries(tests_run gtest gtest_main "Aaru.Compression.Native") diff --git a/tests/arj/arj.cpp b/tests/arj/arj.cpp new file mode 100644 index 0000000..af0fd08 --- /dev/null +++ b/tests/arj/arj.cpp @@ -0,0 +1,175 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include +#include +#include +#include +#include +#include + +#include "../../library.h" +#include "../crc32.h" +#include "gtest/gtest.h" + +#define EXPECTED_CRC32 0x66007DBA +#define EXPECTED_ORIGSIZE 152089 + +/* ---- Method 1 ---- */ + +static const uint8_t *buffer_m1; + +class arj_m1Fixture : public ::testing::Test +{ +protected: + void SetUp() + { + char path[PATH_MAX]; + char filename[PATH_MAX]; + getcwd(path, PATH_MAX); + snprintf(filename, PATH_MAX, "%s/data/arj_m1.bin", path); + FILE *file = fopen(filename, "rb"); + buffer_m1 = (const uint8_t *)malloc(55125); + fread((void *)buffer_m1, 1, 55125, file); + fclose(file); + } + void TearDown() { free((void *)buffer_m1); } +}; + +TEST_F(arj_m1Fixture, arj_method1) +{ + size_t destLen = EXPECTED_ORIGSIZE; + auto *outBuf = (uint8_t *)malloc(EXPECTED_ORIGSIZE); + + auto err = arj_decompress_method1(buffer_m1, 55125, outBuf, &destLen); + + EXPECT_EQ(err, 0); + EXPECT_EQ(destLen, (size_t)EXPECTED_ORIGSIZE); + + auto crc = crc32_data(outBuf, EXPECTED_ORIGSIZE); + free(outBuf); + EXPECT_EQ(crc, EXPECTED_CRC32); +} + +/* ---- Method 2 ---- */ + +static const uint8_t *buffer_m2; + +class arj_m2Fixture : public ::testing::Test +{ +protected: + void SetUp() + { + char path[PATH_MAX]; + char filename[PATH_MAX]; + getcwd(path, PATH_MAX); + snprintf(filename, PATH_MAX, "%s/data/arj_m2.bin", path); + FILE *file = fopen(filename, "rb"); + buffer_m2 = (const uint8_t *)malloc(55721); + fread((void *)buffer_m2, 1, 55721, file); + fclose(file); + } + void TearDown() { free((void *)buffer_m2); } +}; + +TEST_F(arj_m2Fixture, arj_method2) +{ + size_t destLen = EXPECTED_ORIGSIZE; + auto *outBuf = (uint8_t *)malloc(EXPECTED_ORIGSIZE); + + auto err = arj_decompress_method2(buffer_m2, 55721, outBuf, &destLen); + + EXPECT_EQ(err, 0); + EXPECT_EQ(destLen, (size_t)EXPECTED_ORIGSIZE); + + auto crc = crc32_data(outBuf, EXPECTED_ORIGSIZE); + free(outBuf); + EXPECT_EQ(crc, EXPECTED_CRC32); +} + +/* ---- Method 3 ---- */ + +static const uint8_t *buffer_m3; + +class arj_m3Fixture : public ::testing::Test +{ +protected: + void SetUp() + { + char path[PATH_MAX]; + char filename[PATH_MAX]; + getcwd(path, PATH_MAX); + snprintf(filename, PATH_MAX, "%s/data/arj_m3.bin", path); + FILE *file = fopen(filename, "rb"); + buffer_m3 = (const uint8_t *)malloc(59190); + fread((void *)buffer_m3, 1, 59190, file); + fclose(file); + } + void TearDown() { free((void *)buffer_m3); } +}; + +TEST_F(arj_m3Fixture, arj_method3) +{ + size_t destLen = EXPECTED_ORIGSIZE; + auto *outBuf = (uint8_t *)malloc(EXPECTED_ORIGSIZE); + + auto err = arj_decompress_method3(buffer_m3, 59190, outBuf, &destLen); + + EXPECT_EQ(err, 0); + EXPECT_EQ(destLen, (size_t)EXPECTED_ORIGSIZE); + + auto crc = crc32_data(outBuf, EXPECTED_ORIGSIZE); + free(outBuf); + EXPECT_EQ(crc, EXPECTED_CRC32); +} + +/* ---- Method 4 (Fastest) ---- */ + +static const uint8_t *buffer_m4; + +class arj_m4Fixture : public ::testing::Test +{ +protected: + void SetUp() + { + char path[PATH_MAX]; + char filename[PATH_MAX]; + getcwd(path, PATH_MAX); + snprintf(filename, PATH_MAX, "%s/data/arj_m4.bin", path); + FILE *file = fopen(filename, "rb"); + buffer_m4 = (const uint8_t *)malloc(66519); + fread((void *)buffer_m4, 1, 66519, file); + fclose(file); + } + void TearDown() { free((void *)buffer_m4); } +}; + +TEST_F(arj_m4Fixture, arj_method4_fastest) +{ + size_t destLen = EXPECTED_ORIGSIZE; + auto *outBuf = (uint8_t *)malloc(EXPECTED_ORIGSIZE); + + auto err = arj_decompress_fastest(buffer_m4, 66519, outBuf, &destLen); + + EXPECT_EQ(err, 0); + EXPECT_EQ(destLen, (size_t)EXPECTED_ORIGSIZE); + + auto crc = crc32_data(outBuf, EXPECTED_ORIGSIZE); + free(outBuf); + EXPECT_EQ(crc, EXPECTED_CRC32); +} diff --git a/tests/arjz/arjz.cpp b/tests/arjz/arjz.cpp new file mode 100644 index 0000000..795e551 --- /dev/null +++ b/tests/arjz/arjz.cpp @@ -0,0 +1,101 @@ +/* + * This file is part of the Aaru Data Preservation Suite. + * Copyright (c) 2019-2026 Natalia Portillo. + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of the + * License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include +#include +#include +#include +#include +#include + +#include "../../library.h" +#include "../crc32.h" +#include "gtest/gtest.h" + +#define EXPECTED_CRC32 0x66007DBA +#define EXPECTED_ORIGSIZE 152089 + +static const uint8_t *buffer_arjz; + +class arjz_defaultFixture : public ::testing::Test +{ +protected: + void SetUp() + { + char path[PATH_MAX]; + char filename[PATH_MAX]; + getcwd(path, PATH_MAX); + snprintf(filename, PATH_MAX, "%s/data/arjz_default.bin", path); + FILE *file = fopen(filename, "rb"); + buffer_arjz = (const uint8_t *)malloc(52577); + fread((void *)buffer_arjz, 1, 52577, file); + fclose(file); + } + void TearDown() { free((void *)buffer_arjz); } +}; + +TEST_F(arjz_defaultFixture, arjz_default) +{ + size_t destLen = EXPECTED_ORIGSIZE; + auto *outBuf = (uint8_t *)malloc(EXPECTED_ORIGSIZE); + + auto err = arjz_decompress_method1(buffer_arjz, 52577, outBuf, &destLen); + + EXPECT_EQ(err, 0); + EXPECT_EQ(destLen, (size_t)EXPECTED_ORIGSIZE); + + auto crc = crc32_data(outBuf, EXPECTED_ORIGSIZE); + free(outBuf); + EXPECT_EQ(crc, EXPECTED_CRC32); +} + +/* ---- ARJZ v55 (custom extended DEFLATE) ---- */ + +static const uint8_t *buffer_arjz_v55; + +class arjz_v55Fixture : public ::testing::Test +{ +protected: + void SetUp() + { + char path[PATH_MAX]; + char filename[PATH_MAX]; + getcwd(path, PATH_MAX); + snprintf(filename, PATH_MAX, "%s/data/arjz_v55_new.bin", path); + FILE *file = fopen(filename, "rb"); + buffer_arjz_v55 = (const uint8_t *)malloc(52010); + fread((void *)buffer_arjz_v55, 1, 52010, file); + fclose(file); + } + void TearDown() { free((void *)buffer_arjz_v55); } +}; + +TEST_F(arjz_v55Fixture, arjz_v55_deflatez) +{ + size_t destLen = EXPECTED_ORIGSIZE; + auto *outBuf = (uint8_t *)malloc(EXPECTED_ORIGSIZE); + + auto err = arjz_decompress_buffer(buffer_arjz_v55, 52010, outBuf, &destLen, EXPECTED_ORIGSIZE); + + EXPECT_EQ(err, 0); + EXPECT_EQ(destLen, (size_t)EXPECTED_ORIGSIZE); + + auto crc = crc32_data(outBuf, EXPECTED_ORIGSIZE); + free(outBuf); + EXPECT_EQ(crc, EXPECTED_CRC32); +} diff --git a/tests/data/arj_m1.bin b/tests/data/arj_m1.bin new file mode 100644 index 0000000000000000000000000000000000000000..3bb048694132fa2b95b5f5fef51f252f82d29561 GIT binary patch literal 55125 zcmb2T&@yYg*`2AcbFT*N=e@C}s54CH{H-^#x|wOlrrS1|ZH`UZ_=%&zQ=*aK2Sa4K zoyF%l@2h{PEcj(~J)J_Y}$R-@osBwsNlJ`7`%_<*)yH_3hc$Z(jU3 zd-eL?YTLi}ryt(@*et*1zTW-%`1HfKufBi%@4mnM@7sQ_*3Z6fdp$a~{`jeP-^zU7 zoqhZ5TlL?c`}Iri*FSyx^$+{+H?Pm$oxT0O`JZ3)mkjp*sft|o^|#f2xp(JVZtg#S z;`R2@$%(6G?i2n|5!x1?y7jVL@~T~%FPpu5Kl{*J)5z4Y%-P&&m;HomUhb~B5n5{E zo7cI1H4p!r5BJSh<;marqq%$jtZSd`gl|5cl=&uJJLJFdr=0D){*PB||LJSGjXyZ| za^jBP+Q+Y6wUzmETXT8Bm(U11tB+x~A0NJ`V_s@}!6wXekJ&@h2>A^*AAXmnAI`mU zuV!0yj>NH_A6DJgm$Rs;nOr_cb$7_)SNHb3yZzFltMuijlH$*atM2Y9P532vf7jw4 z2DAVDOTT*IR{qDWDZ=gS@Aj?I-0^JV+deC+hwB!;+xPJI_u$xK{%>`4)n(V+{OWSq z9nUq~Zn@&WFSq!j*KaG$W!tXLel2CVH*4;X+?%0tJmp<-Cs_=lrkR zcYeRzFB$s#)AOqq2d(?pNUyVRy^$5SpL^}?2jyRC4fkZ1l)Z_YkS_Y*{4qPRRrzs; zPOiW0DsnU8U~$dX(1zb@I)!C*gAi+wq?DEDJm~>wcg2}+_Fr-?RVP0 zz4Q6cz4Bm$~ftk7v^A7B>$r2|eFxm)E)M_iT%~S}78CT-k0X z&e}ChyuEx^HKF&_R?)EGV(HY4=3lR9ErbB<+b%v zP2z#=m;E+=+K@;BG3K#JKkvNP`Fqo!%)NBMWQ$0zsl=~|U)lSYRAn9#eAI5z z|DiM{Pa{-;f4Zx8JXpG9<>Hz@cOoXQx_f3(XMUS) zo4IwmU)%X5`es_EPxGvgtP}SS^tf;<>y=cy&0)(M5=Y9FKDM2j-{yXjNn>?lPR{fb zj~iE&J^m5)ahq$}VIKbTXMWB#=ULnHk6j?Xb+?($EU7v%xeSMc-6l~cpX?oODa<_n zWZzb`#sDd%Sv5cVH%>U1F*9r7g_kugZQW<&ue^2IURr%q*Zn2u1jB~Rtuyj{?5r=n zopD!psU*irrY=0BcAnU@LZglRx>G8D{VTcu(uZxCM9S~Zn%`|cH)||e=cTXC zD%#-gJLTn`jOj;SKVuJ#FW>KQ>#lh88kM7lUGZ1kPQ01-`{m+Gzj)7|jrk|CCh-34 z53j!eV-mi%zJ2%V+gGpOyl^Y-ZTlq!9qFl|k5kz$But81aHn|Xl-D=gKC(o9VLh`{ zKd47SQ*V3HL2f=4qYE+144(ITsh)N7~7>a3Y}}K>QTPD;z8(c76XznHa`E;GNV|4HEUlLg1@6w~+D zCp5^cjJgzXuPbLk(z`#GqL?l(+`LFMYBk6F*^8gu&q%80eeEaow`!NHK@;=&*xeb@ z%J*kD95AbJP!{Ny{c>mWp%ab$7OvV$_Z(V6|^co9}6Mx<&lmoTH-i#N=J>{w(U4#MU_1_Ql?dGoDmW-q`f& zp+#j_%s$?qZ#&CZur z(@LH{d-tuzx?cbA%`P*m$1nI#Syf*6C@1UZrME!(dbazF)Wj{;7caS0{fXS`{53>m zjn}4=B1tztn{fOMOAI@CNbu5`q@x;%SHu103oqOG@Zf&E^*svG`M;*^S#0t9VRVpq zNIB<>S@VBeyMFHbAZz2nQ#$jD&c55vPT#EW{8@E7+yCmO+KR0^Ds`AeyIoH$oU)R8 z>5rM7?fbs_U$hADnz=l<`sH2ozbof$HJy98l=Umu){uwn|DI~kvHP*>!I6C`9{2fX z?@y?%i`m8G`hNEHpEcI|Z0FC*uYXWq@ZDD2So(6$hpWY_JF=d-xyS7elS|tv|7e*= zxq7eC*D5B?uQu17Nv>RVNmX>-p;v1Rq$e+1z1l*4ad)2AHC_d|3sv^DJ0;ne|AzR8 zMEz=zG~G0NtN6`Brh8(o*U6P=bboI;XiNJn)!hzcD)k3%F{7NZ|S2$ceaTLl^5=AIF=oBY5j%^{jxvj^G#khv$<}Y z=WVsrSEWD1x)g+$-<~(+&xh;pMLA=QpK6*Icvt+b{x~Crxq4;J%h>O2FE@7vANeG9 zLGsjp4(7g`vR%B-C2lW{=%3;C-zjmid3=;#%q!mp7MV}ec#U`Yi^{K$tX!^g;$Nam z+hhJ63dbdW)ZYH&IsfUbzrIqf`s@AIbvga3OOIA#jNH4a`+~EVWT0Tm5x!=X24NOW zXP3*<-(E;`luzEj{&mA&Pm?|S#hn@R1SMXxzJArh+TT8RpJaK>rSftCk8Y0Tn?A13 zyWUrq|LwL%k>{*tF{LG%*X=lz${P!39l3DQ#NUmxNAgrr@4D{#@Uqnzfd%m|&i}l; zHFMGVNwZxS+1+{BxZDP?_}%Qsy`P3H^j&MUuvU|hu|bK-Vo(6;gkQ-TibyzpK4M=xP9 z)9U^yx0Qrm{TEnoDH86Yu}FADLi16!$fqAWJ0;AxoSjxgbt|mCeQEiR<0~pWD_;Ca z4ZJeh%ING7$?{vOHeH!X^VS-0{Mpm|=N;#@G>_KQJ-c+?pKlb1dieWrnD+d*)2Cmz zs5Qrk?BV=fc6;#&hr|Cgw%wk|kQczF$u)gRP0ok4^P3|%;`+TA12#`Hcvzt@EsiC5 z+v+MFLAHX{HPU5f-Ag>V3Qj0`Gn5&axhL#R)mT5To%vyr{g+RfZJ$14S+vs?@&oTY4AxtN3-b ze00luZTw21xYwf8x}eIh#m1!QM#0W9Z;!dtZ5mcB+q!`zw3vriE>E}KO6Xte1}CA{ zIb1jFmKJ!vdAr)lo+DH9tml*LYnIncQQUgC-{SiWMjn=9wa+bd_kxM)%QIjttQZtcp| z7j)Mu)z&;@x)Pi#Kl{&`Uc;>md;a`6rnL0&<#Oi4D(Aj^{{l7}gh!t{_H?^j;DX3N zjSN;Zkkrz^U93H4WQnAtAFQ7in zQ&MeJk@OBD%^q2e*JYP@y_xv8Ht|=m;UvfKUa_!xh zFB2z!S?0e};HdVsuH9<8B(&Jv@}2x^;$l-R{{&X%WFGo_=JeUgZwzKm^!emf_nj$! z|N4is@BdZ%URENRrhdCM%53hu8?rl_Gz44D7FoYua%_K%;PxJK?wSc7`S|SXW6zo- z9NWlz!8hafzPfykDN8JWOb*|D^Xi=o7AvyP9B#|8xy$*#rTEC}KQr3Xp1qS?FLN<- zidxE1#fdf#;txo;&v|#_>s+~Mrk7+m`~oLrelxM*_HTQTn30#l@^gM@XeU#Xd)C$| zB`tkkH5G@L3uYBNO!>Xahk@yXu|}j+*^S;+!VjGKjDPOYJa6f@l|B6Q_D|owt`+NC zJEvxEs&tU^@|G*^7ArWPSDpCb&*<`6_pGzvz1IoS7kwG`vQD+rGI=a<@wjK>!nWgo z*;&-9)Ni%z{*`LdQzP@(vHiCkgBD|vk-&~g&w|b@y7TZvX~t4-({103QgkeGuP+M{ zQ~oW%ad0DZpg>FV<&=JZXT_H%vXoaoG?`t}uzBsSL`E+EDJ|EO*UY@isN^Ak!#4E! zQn`Q)D;(z+HK}a2Qn@>Yb7jsB&HMYe?-Jyfk5@2mZts-I5m?7urFrBi!_lh_Y;Soq zR*BDCp*`i56~ny4PghV)Y}1>WgFKtIcCK9fxJ^Q~D(Ns=^BgysGld^T&%3y5*}wm3E13Ro z|9vgB|Nm;^|5yF{KUwXR`QhAGEqj+L9$j+qXGDLm+U>VD+-82N%3DON5y^b6)*5*J(S)OO80zfYoT_H7+8@TxcuTcMc#rIB zf&KhE3+wNF*vEUgSZ1qJ=JsVPwi|Nj#2ff8yxnSk;_Y6+=E|Q-Zp{9w+N{rcLD@_) zO-_K2|^<##W0osS|YVQ20#DC{; zWD8qyt^1oZAC~k!tG%VdaUfBqw>~i|#c)HoY`zEIy&OX`fl{#>hqU&;&rJ{Cghhyi}3r!l@TlM&I^Y zDieL2$?oR@mxnr^j#eCXe-=D@OR|qg$fAEIPyA$gTBp0{*U4o{smoX#8szPd7`%6h zJ$^p!fWO;38^_YU-ojjjdbi7>yb&l_%SJxkG zT6iqi(Yj~Z<%%A=S919I1`tQD2&$0jW29b5Mg&#iqwMwONPxkpguYYFiQ-RCb?Dw9X zZMl%fTG?#x;dRT&_|E+FC4VALYaUy%>+_?_o9<2)cxvn@AItdFiq%~r`DUa1#mOh) zm$mJ;be>ak>8s-u8^JW~z|0>CVFiwzOKw{_T-G)_sMUPbeaovm^I1!{EbHXk6lTzOw!&L9!o4hvVw!B9Td6UY@x}z5V zPQB7QPxzQ4WUy=58yzt0S~pu4^I@1EfKPK$&+3e4ZM=KFSM z^l-OXujO}T^I0mH)|gH{(&8hr;*idVNz*rYD5)&YoKSJn@58yNNOBwaPv*Sh{liPOp+nV(nGp0sR?Wd6$bs_cWPL^!vsrm*%n~tfzne?N@7RV%_eC zTXbG+>{Uy;!OL?aTBTJ==LRU*sFI>`)C_HS@?c4|}_( z4z}G1{ZGpDTZ^V!FO(pTQxPbce*HW_P`h8>{(A#*4KXCwCVg z`+V<3Q*?cY2Lvv&5udxNWVJ%2ZGvv{@>-kK0_&IR3i!JV6o2pA7LwI&`v0G`{-5g!r*<=&|EXzq z)crBxm)nDKu@A?mzyG>9dEUJFHuV9Yu6zr3j0}j`#m#Pi$lvDa#%PtNZ1VGNAGy%# zkhO66=O23|<5Oq3vd67=sBY|cnEfd7y3&ZQGf!W76DSwVf+VjICaL5%->`VqDA7t)gZV1DAMq9rk#hEKqX$S;)a)uNkVdUk3;8 z6fn&ZI+i2Cl95!P>?gi6Fm9vv+aKBU{sns<$v(E!A}~DiNo|;_TVQXWF}O-gkai*RM}sXzKfh^^?hwYdi%qH@&>m7wu?2Tz}!!4QTl>Te$bDY2G(>d7-Ra5pp4*I7i+%~n}Cf=fr4IeXrEt{3b5PqKxH zo!b$*YOkt5S<>As9fiX?tS21WuJtW~smmoJ+dvnA3+W3UACWAP zEYS;bvuR0C$$#H9*)VRy;`6S*BgBk;7uBv6X<8-oVztFrhmOpcB3A*Ax(G+ZRr9SQ z12!9c`z^J!WkcNK5U+)6x+BWBxc$7Eo3(~nX?^;QkAJbe=GISYc2|9U@o2NA*{t9fyqC5f+8xcm@ZNX+ ziY|3cO&h({JGKNVm498XVe7QeCWPTyh``Tp6W`2;&x;b~@4j%TpCv^8p4$@lX(7GN zyo(|%x+FQGRva>(Wq#G-wP9+=qN=4Vlgy5&E1sFTaq3rvv{cPqmy$FJa!#IoCOxCm z&)r7zh91 zG3WEbO1_j6M^>v^W>1n`-77kKS5aV%TT^ME{lu9ZT32l(Qvc14oF=|fbF$oNNyZK5 z)crOynle9{CiBuNUcce%Djn7hUr+gEMdwrrD*k(B;qhDMMCG;})vO*zo0=u^U!Akk{5==Q~J$a|=ZshvdF*Wz_w20cjZULr} zPHPWdJkGo9oK@>Hr9O?SXo8aQoC~{zE@6eOVY|U;DLIZij|Z6=UP$ z-?uuHekRu&a?~zam~3dW<=f*6(kUbI-a29ns`jGW&^NPjI8+f7vxv>oxa0oqZ*`U1;s6r=P!=@AJyb zOOazp`Z4=ip-i@DNXzzeE!RNK4I9>{&ict0I!m1UvHGqvZNdM^1hDDQR;+^eoZXPv!HLtzVz@WdH2l8MWQK-N(MJV`*L5HosAmHzKRpQ1I2# zN!`)g)DFFtJFaM77|PjxwjpEc>yYRJzhYl6>{)Yn%4R0<^i_w9Bvw{dNr-OOtX(mw z%<^&eueomB4(Cj7$`yq&Sv$N6J~;dN5owl+vxO#CX2`@(iZ45MilbFE_KI^(@*1U& zH&<@Bb3>jhC8Jx=>8HPSLb8=vQ}h0uE8j!7w*OVCzH@E0X1x{r6@g1{&puIjXQW_S z^>DHBemne@>fqYUk&M8HKF;+CSL%X7^s{cGtXEGwJ%bDGO!wdp}3JPQLWU=X8qH+f#7?rtU_mmfT^-&DQ%m*lISr$_S-W{1o&Dl9?8<5`$w>x(`|lX)_$)8l z7ICJ`&1r>U4CB3fye=oY>$bgqc|_wKGq=azuSyv%eBXNYPRN^v`ei??_SJe8`e9yN z!BHvatLwVu7MYv3d~iuxcK<(*EYra~5?T}QT?!9cu(nz=YUx2c*Ew7)XV{dVO>&=E zapRkiK+?nwO1m9iW#7t7yTD_z?%1OP>m)WrZEDlbzUt|(UTb`C&6`h3i_7=)pU5!Y zd$5Rg$J(@;#;tGolrz43+`Yis*>`gC3(>w=BBnpec3pKo67}%thkX(kve)s(+g9g? z9q-le%zk+55$m_v5xJ~i?#xwuc=oU6-=lU-CTG*GnrG(uym$9&_F67|ZS(x;Y%4Wq zX{`2}5zN6v1xpzF;ygR5t+nKCl8 zY~?&s%(Zi)uFl!F-!}TJkT^awU!8g0j?;}#c!Qa14%{gDcZBVcX40a6S@tdKV=RR2 zq`q4=AAL2?{BfbUuCm_sY}fmG0tfr6c~z`eT&wyc&$2@6?g!R3&X7zpUt1LI3~YFRBvB8@ROimAjH29`u+aJ@>u#v`tVg2wsoYJLIFvc63K8hu!)5oO{nEM0KYIiEC%2nKhoU*N}fz(YJ3;_OVx6UmxYa zt!O_(PqA$3qnD4IU%&s(>3^&FZRX?E)o=Yjr7%txPFi^DX<(^({Eys2`J2R6g_$J! zPPi%0J$ZiHqFH#-@1SJ%wu((yNBDJ z+s$3M*LT$iyG0)?+0RCX**2`(ClhnA@7;MBuZb~1W`<2O`<4c<%uM*=Y%pbh_w0Z9 zaxv1W?w35?Es{z9=Jnp|p~`_PU$(OztI+wm@5963%Cr+YcX+cJ?mS#S@!>4d#|sY4 z+wB&%>_P0peILRqidw!;XBSxUDztUoKN-cD4}Z@TDxNv%>h@079hWMiR&IZLy!G7U z^cOLcPWFp`J0%t}^U(E)a=Vf=SZY_F)Y!!zSh-p02w%zO7g3eV&-I#p3r^d9`FLrl z^O}z$vRR)_#pE;E*0Y2y*S#kFnCZ>qD^L-JS&78_>9Gt9JmwN$) zv(HU`aDLX^TMI7Qb%tBSotyjA#c7SftzU`8OYRpP?qr>o&wpA+uq8uz(uw3Z3Xam{ zf?H3_EfG8KGb{Axw|@~oIyPE4&YUOh-7c_lQi#~GqI03{y|3O*S9VMk`M!7Md|!@^ z2_o&A9vGG!6t?hH|8{h%hRfsk=Qj4pUB7j(%W~s`?YnrVDy==1b;C#ZX*` zQohB8tU;0+&L@;Eo2JC;FmAx%i|@-)YdEweBDWMt9vn;LIeP-*nj zPxs~8msyv;9u(7x%cGk2j&A?0(X}LBCz3D!;nCDR z)r%Qc?O~mMB(a^XR3)rV>*9vqP3znC=eNJmSmLk3yyb0#kW7;1nT+jc*oEJ`_B0St zJ8-b~r^I>rdAGi-Q@^o((Zl?p_Z#_+$sO07*=4T0;7hW^sh>q>WRkgl%gmY*>G$hQ zNlnCBmLEm^r;TD(XgSGl{}9^G`pWawmFQ)k4&+4bWiByin}4`mPgXiTihV zMs6;Ao6082+oHyOY<{)s*Kk?JIvY=)w*|X9gX6q^-I0E9irM-2a^HI=4sW#HC2&e$ zN5>8|@79Wtr;(nm5=Z_eIfs4bEWhzR{lSg}-@~sjf4X?)HJ--pSs}?o{{L$W;gKP@CCq)LR%cIcLqms7`~$QQM@CZHZ4%Ta>?ZXYsarGoQ-5 ztAf98EIbl8(dqBOg@VpZKL2i4&lG!Lm^Gbo(Va{ty@f9oc^(OMtofsKbFwGrA)U9k zw(mXlbAB*;TgcKe$!ztTj@tRDT#!5^?S79bJbgutHEdAZap(mFuKgoU#O!`>iyDnPYgF6)NQbt zI^8EwdTbCjS(M@DzRMVmvq0Hwqi#{#%hzvfvx)1Mf;@t_AIWEZHms}j;SoS{2Bk>rY&d@ zv)_AzUOhWL?O3k-iz5GW8h+pUX0Wm7^ugC}s;(5V2~-@OzWUVTf1y9zyMiB{**ZT^ zyNl1c!d)_Nf$>U#YbA**DvJuNUOW`KUoB%5K5a#(OU4_qTPeqGs!7>hIuW}(YhC4} zp5H;2W;ptupD1K|fnJKXAa?0mu`D8u^0?r9ariryZJ4i0(N`o$Mt_Ql`P z4?du*UD+JSxGP3<;jfK{YivIj7pcT#`U~xCcr>q~;d8G*l~(e{jG%|A6(4T$3re?r zle{gm?c>v$XRrI;HSfpA8(#Xl5-+aVOznDH zW?WKTyYz*I-n3QX9)GT_&SRPOt>Ip12yeK%$kVok<@0AfQ982San9^;ImI}iimCR2 zOa`xxL_W<3Kazh?D&zQ!#|Qfjj%|M}XBl$GVC}Mtr>DJWb)7nyg>mndbKjaIl$=7C zbGw_ja_0!87T)^%QFzm;5>uXgi-q${{GTmf_ha&MlfWxAj$Ka}Eki>+Kkx?BD17|< zf%#u1y>~#76%=(&bFBC0%p2c!@horsP z;x6y)e*W5@VkrUpt4FwO?&okbOiq5kKrftmzxwU_lA0_TOb7Pe`LeRJ=KtS|Zze=a z^S{u#Q9s$}WYD>qg4JHhzY9g2-oN>1)wts4*9zWO**W@=_f|Lld_9Nl)+O$(Hy)O_ z^EUjxVtHTDzv;F3r3%&jwa-`cTUuA0 zagwddd%yl&*7I-4>pWI2&XX2$Xqgjq;g3v6?e34q4a=8XI-J!%zv6b;cHY;$-YXZd z$K0HqZYR}Lo1*ajy-{~z#+oNQm6A`rm9CbRzMo){aH-Il?YqMtGu9W^g-X5!q-VX7 z;M>kJJyLV$4V~LxQnq=BT)A6rZ{l{Jdtpi8mfUkYjxKA=G>DJT-O%6gHHiH!w^ViH zBtIqv_eOUv)nA{tY8Y>x6XvrgLfKnnSN6<`F;ZCo;#Btxe}lE(*SVfA)IQ??x`=OJ=F~B9hO{$IhEV$bA_UC0G(%kVP`$g&+4c{EI-DuEi60&ZQ#`YBFy!Z+1-W=~t z4(K?}dDQS=VT{U;@<*M!%8nK$Tf2uGT4^w0lgg46&Jm`oxqSJ3oE92oCAzIWc<0V4 z!2>Nu9Kt#}_s`yMP{_`#TeM-ne36|?@&Ds4a<9)QtmVjTK70MY+VlEFy{bz*GAv??qJ~M2Wz#za z)(I&lNpl^TFRy?5)u)Hvv*xY}V_*5Wx5(pbuEZx#Z3!*clUJ;J#qUN`7Rd4qsL}7ihV3-jzQWjh=DOlVwcxjgDi#eR^KT@u2;=W@>C7x8IjfiG6eJQN*gR zNzq$9+|KV_`Dn%Q=`9Uwe8Z#*wmc7eni2I^;^m_wc`A>#+ewB?UixYks4LvpU{Uq` z*`Mp&8rP3={n}eFd$MfZsdM6ue{N5Yn{6A;l+`a`uyoz>7uSw5_3OD>nd@G;*f1V|+Sya3x;O*_G zBT+h&Z(NCz^L%>1VRpv(?e7#@5<7499>09P?#J5OdXozh^&0%I>slW8xu<5%PKSzv zOIy8XTVL5Rb@tThlUZy_V&8bB%FK~+mzg`+qbQh}MPqY9)NCeOwRM6D+KsCoa!R~1 z^NZ14`bBi-&YIo>|0EW;Xr*Yy#BDwJ!s5Z1ilFjmPLCq~g{SZoNrm+>N(qa z)XO91uRr=&X1em#lT&AuR=vA5<^2Agi^Ghb8kF_K8~S@Z`rc_eU)H@*h0%r^1j5@Dmp2@jIuzTIfsC~3=|{w!juRB8ur(YmFAxv}A| z{S1~J+q9Wc>Fuku9}DLf3B~xNZcS>Ds+@Z3zf47B>&1p{UY!|@+P^mmmh{xje|3O2 zd9B?1cS1HXFMldt6iVp%aMvPwYFxwP%uBatH~tCp`0Vrl{o>x`;cqWw*;^}o*|hA& zo|{JQX6~Y1tMeyDvro?~@wmB7-8LpC{^Az-xQ5omDOWpYpUisexz5Yb?aJw?$!eVz z<#8QTd*>c-lrHqoubukRC1SV2WV=qE#{thzZ(3DxCjau`O3|}EYqZt##e3&&zui?Q zVbC&b*R|Ud&*pwxoqsS)b*F=LTaKvOr9jC}m5-`3Ufx_U#HeD#z}CPx$MWOxf5mhD z?|t8(vgEe6;kzf3mYrH@b}qH2{egY$yK5e|LMOHUk>7N4y|2xgDh&^YRP8e%%I7oH zSGz8Ek$CfzYns8sGnrK%&&qz}y!!(#q2vv_@9?8SnaFt zez}vW&&cG)LfLhXkH4SV7A&x5?t@Z?<;R{BSZt58iFxY|CE?g#@~tj=eK?_o>D5My)>%dM@_iV~RD=9`Pq~h z&hzehr}g$vjM5Ti`21GXTH=`W{`ez_$+oZG?u&1ocYMe1{VRpP-T!k>H7|Vsr=O0= zOop2ue+dY!e{$&rfY=D%`GdRZ9Q<=dB#;Sh{XWnf$K~-6;Mo zda+eK|NN`>Z?~WRkTl2iAonVLmGA$vS*luYzdQbQtzlKv{}+i5b^o~W?9&%}fA_oX zgzvR^RRyu1PDkuuY-jJjllJJt7wPE>|J~?wa{ayO)!&QaC-d&l|L$UJKPAig%fB0a z+dtiA{JbyT*hcaDf1e!dv_A^=g4++vRl2n9wY^bb|6cIIeEpYmy$|#C+Q<9!nY1rW z{8;xx$SD8Yzjvv+_LsjM?Y_8s{^sXD-dxO^A+pTr%s<;SaW6R+s!Li5N!q>k2y!dl%-TC?#;%`@`hMG8V zOxoHJukh}3dL`=@alMZCw7XC49+{B0CE<~+*QML0%rPexzj)o$SXnHT`cW!iveCf` zLCzEZq6|-LVTtID=RdytZNkFNo0-)OfA9FO8Gykodue@k{Q7vwjQ~R-BSIll}Yba#40(?Sut^ zTs~3)TMIm9T`$wQKS@OTwZ+a=GnxwOqKY<|dsUv8z5OF|y67Q~W9yi`7&FW6xeKYf zs4mC#-nXAmbgox-@FXOolke8M&T6ZdIW4gM$-X-$o0R=J z*B=e2-o9*i;R%g}$I9=ndKY!Vob~@=mjZ9^Bq#l%jT^5?oO-vWz9n|n(zb6i)}7Yq z_fif%{&JqMiML50v#9`Qb&~#?zggRBB=?`~O<5Bb->f_%;rY=W>c;8r4g9KyL+bWc zDHN76w1MdL{QGpYGhxF<;YyyAl@Uhpt(rxia79P|3+;F7|!0bKDnKt$WesG^zXg z%~ekX&zb+KeDONP_VL<9jjvmOM6G5$Y3O{>{$J&^m;GFi54sflIL)*bc$r+?T*wft z8QB$d<>=GbEtXeV&Mgyu#~*BVE9JmGkf_q{7RVKf#m+Cxc;?&!e>B0QK=gIpC<&QSDmdsl5-mqL^LP(K8 zNI=+~0IAt^YKwWRr6vU@?OSx`18tpr+;#=-r^he35 z_V48YhF`wc%9HNxlAQKq*`iJJF0Sn=xSW>9ZrR!z&YbX8?Bv>Sj~6j6_RXFcax^X> z{pCHelaJf~HyQ7r|MI7p_rLFAUd>!c9PF(*|YPUZs(5*XK#rAx71@_sS+pK+#vpkOrBR&d^RSU zybr&#GyH|2dUv&3&Gx`8ISedU8y~Bxv)SMLKl52c)~OZxf(Lzr{Wo6?D?aY>a8lz( zlV!KIrLNr)&iCwJ&aw`@)cTY!Tv>Wt?p`0ZDXH9Pd=l;U^46M`Q_bI&KPg$QWpR>q z>2D!fC;sPRZwr$)Zi^P*B_i=WQtJQR=l*c zSbgED;+}c;jW%5F>q%keSGX9yJ+Jv{AMYvOXBNsF0xzppow?>8tD21)$#;vt z^7SvlIv+l@gr>6o^ z>T`spK)!ab!xvsZ>Bwu3{MmUcpZrzWDSNMb!!A)RU8UC>BX~rQiY<B!wzzy0k~_2c)OGR*8k@0rA_-?dtHdeO(~J9k6Y zJ$qQs@pI#3wgVw`QMayJJl<~RR(WvpZ^cZ}yDz$?%{nk;x20ruuvN~&M;2=xmkV{T z_ESj@+j1dS#Q(+}-4X-gy9+`pmMA;$&g#%CecgAiboZmGz7Ll!&vLL0(A>*+>Uc$0 zvg`hW$T=SZvfWIhyi^&U?sj?dhBxWBLJ^Z5T%&gPq`|jPASbcw? zrIU#HWT!31EWOLQb!Oh}&Yo{mEO;hQ&g;NBm4C|*+%(_I%=7VY_Jpk$zo$5fRc&gB zeLlG)!dl0r_5O`)4}qUrTK%l^E?oC7ee)%s`IC2H|Adg!T4lv@J?o}iG&VFmxQ{a} zVz2H@k78l@+FtSg8;_LxryViNl;Qo}eCdoZyKaxjgNqxtRo3pAxBp@D)n|t#rL5PR z2s6xRSarm9gW!IjyxS6to0+;_o14XLD{*Ds&Ddc3ug^dJuUq8tW~nPLZZy4rx?$D7 zJr5_`pV;VTv(DKhL%U4Kab+3L#~0 zzhb|o+1^<6)!loiK39NSTU&nm;|D7PCssDu)N3n0=-Ag1dZSUyj!6Ico^(jl- zf`1hr@Hw}vIDc93$CBpQ?pd*S^E#RJ1P(6#oTB;GB7b+BN%pn%32JpK&dun}nSRY~ zkI$~JDHnceO`XFy_tKW=c+P!O7sdB!2L3VjF$~gVZaQaQWcoj~-&p6FPMovsiZ^9# zvGKyeMFM4Fc2dEKnWj;P%uYPuRGX3>x!6OfKlb^DN&BkxZo1s*-c}I3;m2*;H!~-0 zslI8p>bS;7<<$0-Erir8&_aq@Or)@|oZ5uV>N>c@5^u?Dnz%P~glUy#0>Qlppd z@ot5@+%zHod8=H+`nTKO6)=kZV9^v@CjVb?zgg!pF{^OpNBnt5PyQ+J311qN{_K>l zaKfGF^vXcnNb@Nh`#ToQyEl7D@$D#q*~}-LXCF0Qlz!w*-Rp(-y@YR<@JPPh`oHdE z{0Y-Dp8S`(;`Dj03N?K-k#E_&eAbP_S$#{dEWfwDIzok!_2lK!6NT^V)ht(T71Q=@QxBdtXSo)@XBhO@EOj_B`;K+@0CF|5)12Ow4dAc*CyP(mE%B^{$1y z{gjjgJ)FWzXHH8MJ~;K;|M)L|1jRUYGeYevAMZJL$AS65qmsinr#a3SbFOUPl)eA_ zsT1ec9p!tduf1daiN7)@34Uk)J{eDxx;Z&wKT41z)AO zwsh6485jOO6q9p1`BXNe|G))vwS%>JtW)n*Tv313!naK=Daej*$*E0@zfKiTWMA{= z-hH!&221^mA5HFAd9^6vYoqn?d7HN72a8R-VBz)u^3BJdWqp>DDm8Lfb3XiM>fJ4> zQ_cTAENZvOfg3kk)J2vSxlOpXWm(hulc7tMB{fZ!igU4eIXe7`aFuVF5Mwgsk*l2a zks!TxHEZ>xrR7J`xHNY2FJFE~QFl>IvHhAyFYK1^%=LGkm@ZZ_QCil9b?Ii#nCwkf zb6r_@uVmg^`*5TDM3*C7{)~#-mHRdGL{DcwsApOc;HmQIRKUyrykobLcZB7x`lfs} zM#;2qCci)DZdskRI%jy9x^_-@th(}F*si%Qh4MBRUUuc3GFyH?X_3sCD=&g~)V+xi zD(UpSA8eFZ(XE>mWM!YXif2>(*4xJ!SG^aUTeUog>&aJDg~KV$?TMc<)~)U=4OzG2 z&4(4zOHWQr<8)20?+TN1UNqzGq#Z_P8qFRu+omP3s4wi^Ge0auHC43kg1YwS32xWd zbe?={BpBe#89e#YPOsC8H@#F>+bCqZV!^z)3pr*2j) z4V-RvH`L72G@JL*zgJt{GB023J0Zvh(R3MZ8ULd>0XO88FbGsd+q{c9%8_C#Z+NXZ4?=XO1dgU(s9X}!6%RqNFE zu9>TH#Y@{2rmUa5YRdo3X_JHnlOMf!tm3&N`CF)W!AcgbB`Q-c6h1k=Z&Tp68H?)I zYtDWAs5x8So>i7f^P9#Mjn@nlyGkGS>fT(G^VRe<(}A$p&sKcAU*xcJY7bAuKKY8i zAO9b(^9T)kZ2YHGd+(w-*6;luMOeGW?=Om}v|U*6eClR>?cm)uTT8#rV5oL~m)U8W zU0wX;PwtCSOvj zFJ;w8oiXaBjGd{9EQ^rg4t zQrVVZjtAK3tabp*G0jNCmMDgI6PTUSx@KA|A%k+52rN_){-0f( ze+=wx+Qkzsk{0JR{%&kxV$z-ee!hKRvRq4b+*##l!_O;fIGJh=1xfb)oogfhqU`w9 ziWdco4vM(6YabJzv&6LX?V2BNVw?Mx)bnhbuDaxk?2bhB)q0)VB4-q-i*Go|{891Y zBikc2H@IzCThFK|a~IqXc-WrdykGWoZQ*tEHOnTtYgOE2_4uW3Z}9Qvtl%vv@8*d_ zANES<+Sk3OZv9%R!yylLa80rjoZl_Jcg{))v2^#7iyKq-{OSDkCVE4}*(sb7uRN#n zICC&8`)~K3Vatj+jQY#|ikj?M_y5u%@1I{zp1S6Ixay$~>#v~s3Vy7;v-3`0%k?c0 zex_8!#eU1!&3j@+B~ z527WO%y+%r)H!qY;d|yHvPIhagkLK4m)LNs9cI7kf6XMkfnjOA#oGT|%39Lv*R$=o z%+1r4+SUK9#`ImV`g}o6+mAc%#cFNb01g*?4J0H#(oyE((@#G&f+bO;x>6(dyYPV2OuxdE_ z9k-ivmOf$#JiK9xsK8yW5Er(;nK2x@Z)@GVqRZyF#cyt{*-N{~m!DExzbU=Sn!j+l z`rqKVpQ%^*w0FAv+u0gFDI=s*-u~;ZZEU^wLyDdsYkIr;1^b6*Q&>+tU9evE{Or6f zO@*qNLDM!aFbT{3!Bj znJ%mzyJ0 zaJ=9#uHZNp?YIAdz=Wt(pR64Dj$hb#XoBFO+(~;>nKZNyyDnG_qcvNW z-xP_4;)u_@7Y?LevcIp!^)IC2wELBJ(Q}tP^?6#Q7g23}`}C$2bC;Z%%{8$w@{vne9@J+K&|`6D5zGKXuP|nNzv6|M80|QfmV> z(wS63YYM8)gh?@mbp2l$bi~6ku`24?`I&#OanIajKTn_k;H|3e$n~{8nT_;xltBRCfEwbd5Yi`)~eo{ja?r5)0!a zC)q}dA9|~ORN(VDfBj6C&JJUx>IV(d7uPO(H1FG{c|x0R_&xdMd+xs12Q`z-;Fu2f zel6h>?>z7QTtE3*z?Qrt-H~ZoI6uD=wIa}mo?|fP>DW@;U-WIR<(tID! z?t?eorG9s`12Z+-^4icPX)*M%O-2>Cz+(OW^w5# z|JfqRTPd^b;?=<3mE7ODjyaZ}ElGR*vd>&tQ}N#48jn|e!7gnSXm;i>E7`CrtV-`la6b;-0#g)&8~b7F+I+^x@!c4_nD? zbNPFf+u2pOKHfU*D$$k1wlvd#Rr{6sP38MRc|(g=-6Niu+Y1h4PS@Qo^Hi{oZ)%{}HuhRk;~vKy z>G8S35;OHCJL!d~O$uJTBo4SF34}Gj*j^U+SDF9Yo0n78%+2?I z+`C0aJKpcs1p$WY7rc!#%;L){r!mTT?_K1$ExYNJ($eC69#*^?-hBP;to}-*uC07R z!zSStrnjbB58gCi*||cY=$2BEE&KWSzV~y|Spz07nV&A&6T%kOe0X!pubEPOP19Ca zpR2K8O<`i4|8C~<4cGrm{K6mhU%Ht`X zT=X)Bi|wjZ#kG@s4E+ZxT9`L{oiwwtJW8x~9iRlv>kr zt}NQ3vW4YW%4M}<2X1X#@F#HRzXM&&)5>`+Kd&k8{q*FZL!L&kfZ8^Ni(5Rcril^BobTZO@}--ZRu(o6Bie<)QJD$HUFV zz(ZzpVsONh|H~DBJBMq$T$EUNGB9CMbZdo3!?_+?jb+V?oZk!oc%bpzziCf&ZrpZLN@@7$~a|u)Hu8P$$9Tukyf{aS-gVLi!tW5K~esRwK{~@8R zjbs1(%b#p!{5Ra7%=p7>qJP0=_T2wxvs{cf=XS42WsListHiL}S>bm0s!zH9RW~ho z>c&%R)t0^>tnq1ilhuAhj%U3L*11z1d@gxEcAchuZPMHC=3g6?Sz8uYF_n~_-l(zq zxC7VkrUNGo9`MhZ*Kk%v66KW8?vth#=aac$tXNoVZVAHVzT%g+xFR-1o3aQ5%~KMF|^ws{TzdwR~_ z4rS4JuV*XBX;@OhOgUNZsrG+u6i3&apC;WAKXTlp3Yak zAHsR9AVsTW^+Bbg8PA!W-d>&Ee@y*uvccT$h$(#Y&aofwZruO)rf9Te$&YBwQwkz^km6pBU#lrpQh|?vBq_c;zC*^*M4RU6m zI>U_3>h0tYS^WQM?rs&{@*?WA`5t!(w`Z4P7DYC5?GnjZcWR>AFI_ouXQO@Ei4U)QW%H#U%4~`a$^EeU z(v#~Rrr(rw&3%{e@Koq*^K)Nnm7E+Xw%00riH*<#Hj8`W`De-+ z<@>AqC5z9ko?iXMGNn?|X!h<^C1PmPrL`8!i{^yV)VIN$9)go@3wsAHVT_TldG# zl&~)gAGinpnlN4TN@RG`Jk}eRo_K23Bwm$#FE+{ksFXl*YKz_@%~z`@cuF1O+nU=a z999*e%o-BHuPZiha$c*Ts*=g!--oyx4sm?iwB+4}OE2G6`doGX8WCR=>iuH>hS{4} zC|mF1pSQ!AaUqXF0dwT3CvKj_7u^^?E|&5*lICOf`tgFygDW|rJ=pfW{qLm5wSU>i z|HrM|lTD<=*c>YM%AG&VKKkEcH$U3N|M}<7X5W1I>EY({Px^O#o4xJNJpV9x z@qb%;KL2xJ%wDwG_mYr!6vk zIN{5ex#@bnjMrRdq__mSFoh;fTKZEibgJ*3!r*Xw?XDkz7pKbn-zsqV_Ig$3Yb+WI zTOu|J#mia-EVz=b{ww^_pXS9288x>!-Kb<)AD#TXrvCG!;PvlMy*tu9hq0{8-AMSW zT#4VOjKl6;Q!F&MtJir(=A2fNI-TOXFKDx_my6+->Q5QBK8UoRS>rZCRdZK;&n%DF zmIV`A1HQN|;yf!h;r(TvfK9i89n;Q4etcNS#CI$UGQw>oogL0WF>1lViJF>75pN4QrWz5FSM?O{*NH z&6uU3|2Fq#{3FKf>zAvyKVvD|v)e>R(b%$M%Ml^N-9Lkq3<4vWx1GtD9oaWI?nLAE zYS(rQn;UgyXy?R^_vXYTLd)eb(#Xlk{2Ze;>Y~TK>=e^yK@`>Sx#d zw0`)fi|1#u>EqjLcxS|jYM$C|bvz*I!Fs*C*~@sQawWgJmU8lf)`Ssi;%Jm}ZwZ?)o=VgY!j5oV(R&%B6%cfIT_wqd6 z*ty`c`@cs_vpBkTHJgV#{4t^F+3c|3{okuRmaj^^xIgsKsZICRIDWpQd}>jDd-9q$ zwwrbNxXQDR9*Ifwsqg)$@pgCUo5c?T`CQ~zEJ|FJa#ke!*MSxJEANUC4Yg z3vAn8@9k46d8+RBFY98LUSjPZhWj_BC_I(5N{tJhr=`?8ae704rJm1e^WGyIcAe2~ z-EVBf7U^rQyZW&?_qAUAQtNl-g%5;GZ`LeYJ6ZFTdc>L6v3-{_uFUjVx^m*2En!nS z5|i_r4_Efq@4Ua%PI$6=#T5O|Q6GNF=iY5q{jk7{zhgDyoYgZGU)p^;?kh8K_l`v` z<{vwz!>6ImxGe3P;N4pj&V@~D%}iT%cc-2G!#9)rj?IhY%kh?(Fy*U5c$nWRhUzbW z9(&9(pYOyq`E!u^)}qt-EkC>1_C!pb*;-z`{q3U8b#p=_<0Tk*P6eJgu=o3tQ+;v? zY)^aqPP5jYIxTrw)};AIUD^VjDRXviXUP#bdENWqyE(?5vzHpOD^GfpX?E?(v#A@l zeK=I_Gkw{UwJ*-OnX(_g%5)%zv*L@F;qSBTwzc0biLP2398o)wIjJQ@PThG?oVV2K z&ugT0b2rVHIn%yY;{Cp+H7PTuZe9Q3M(e;`4Yy~fbt+6E zx3~y>Y~h-8dlmc7r~?zg_owIZi*Cw}ENKHQ7UbD!~kbAFnM8+90$<;Q6Y~|K~p0 zE-bDte`+3V%YQrHhQZEaQsCL!4x*cUg89p*EjYEQNmG4c*k$EDKilgE+a|v`b4=Sn z`akLRHbK`&aqQ(FB|KIi8|L5QM|9>l29|}FrDpbMp{G38? z1^3=uR~=sk8z${164#s;?Jiq&@=D>s`HzntlZxLuu~{T_bwCe;=<~MRS2gXQj@~Ha zwYgfuB3u;yB<nfvGWnPW)kB=jHC|DR*ewRmX;1myJ{c z0{d4uY?&c=x~b|(!8h-H8x^+po>3O@JX-#Hng3PkqlM93-Q7>F)-OK!=g*O%QUgb( z4Ii)O#o2E;r1o-u$!y!j;U!-GvLzV4g?!*RF-zKbOV}H?uZwxF-ZW|c79pVB9O%E# zwwhDyakqJ5%vZxN9v4=*xr$wUw&=8zuT3_uU*d{IyV&PWOySre z**x9;L`CMhjw{#Z&GAY-()sD4vQvy>dU)*CkjaOG8UydKWNUTK{&A~_?_OR;&&Lh6 zZ?7s(?eAXO*>X@r*^N`HK4!1{wRc@VZH2#V?7Xq*-p&gf#dd94pXo0Us*uTXkfGG{ zys%2Lv_P?o#KseKrkYYR9L;M~_>LHfS&3W^?6Y_z&6;n^*Q4a__E^GZh1}wa%d#8# zqO@FB2u)nS@u=#RsW$d2ziywsZNUQ9=~1G(-*r-D>^t6m-eo?&^4IS76RZBt`}Jgb zz37ckUouQv+;05U>@!&x8?sL8Z?n$TyIWKbuDGsq_gi<0Zc50!S+`I3XI}B?Iq9jW z<8QO%-RsMzTW^a+?M$lddV9%z)~ch2=FZR;?M=SHvgE#4mEgpSfBPoSG%M6;T$*sd zaJ|*T)*MHrb+^U3C0-obwbK94)25Hp{spZ2XFp@c$!o74u905lXmiV9u~GCrmiwC= zwdRFqPg#9rie8@2d6828mZ_~q%(nvALN6c8*i^l5#l2q#ec61z&RuTov%7!#74Q7} zxe2?LZs{-!XOv32cB1o+Qs}0ny+%1ahgV*_xbEV&`t`r`r^kJ5Yd)s6EV}}3M(&YulG`-ht06tjXR7B(YsD;nhqMV7eVS7n&8w=5 z$}cmk9Ai zwZ5F_y(0Per>;d2nn&zQxz66PPTVA=&R$>bwz!1VpKXis|MxBllDqVjVpmnKU2>Ga zuai^J_C>*~lT|m&BA6N%9o1Vs@A(_;yYX(Zk-Il9ZT+Nj?zXr|58LcH{!Q768zm}U zSIu6ibpB+bf|%I?zM4s{EE~9MR_fXAju%?pD8VVrE*qhKsv+EJ$H5RS>#A>C;v|Jw z3eu$-@12jIIioz}xPRSuje^GtPJ(Q`hW~hHm8d7Jx%PN%Wa?2y^Z3c`Sy$~vA2SO$ zd^#axB6N}4XScPyN&ew&+Ja8|r@L-C%-DYSf8s;61y1{OFYdh9*8Iq)kZEO#T#b3& z!AUl3c7EQ6x5_Co>s3@RNYsU{GDsNl0#JbrNrvE!_U*I z1s^RDI`O*Cr2Oz5<)oSEH+FrP_~l0V)sOkpjzJy{{_#Zfa+{(hPDcH73l)(YFlTceJC zh<<)dvA}%#v(hK(%N`!Cvedo*eATSQp+Y4yc3#(-J;k82DYikqe*4{T3HK)KtBmVt zv!3K*89SG$gZcCQ5RbiAb;NRR`UHseuoXVizFD#=R$Rj@z~GIP{jE&q^(WW#Yw4|O zUb5%ZZ~uhoALb3q+-4l>c9T+`-u zH&)uV2Q%&78C12y>!8be$1iq!c3Ms~wF;i)$x_~!{(e!{4yLBAnerBGQ*uMHZl2@n zc(Tdr+SjhuONL_CRxP{mxm%oJ)y#*b^Iis>E}5???|Ql;htFrzlb!$eZci(dw%Bg; z&{gK!G~-1l*YvNe~swQE0W;@dB?*7v#Lo@KmVyi=qk9OddviXHy)tYF*8d0l4zo#3vs{ah1?`pU8HQ~mxY?qGsIwayhep-di9owF)7 zFOu$!nIMs7!eU&*m+X=J=E&8T8$N#9vC*V^F4K{n;clnrO^=X2#%ap&D~FFcs^&@h z$y+AH&2r&CbB|RV>U#WwL*2+Gxizr%&B~lM9fsPNTD_oYkGlVfW)`M%ZHvCFQ+eIu zXWm-DxYI@n31!8*p6%Ik)%3%G82tx&W%jRKTLZgQ+2?9?JlMUke3w^~eD?{>lsxB2 zhe~!{U%v6-2EHfdN3PepivX8|8l=y-VdXB9TD|Ag*SB=?6{?1(Zy6>m-=f@ zuZ;KPWtPd(qVDgK&mWP}Xb%-U)fU4)>rvLnP&4-Is_Tk@A7@&v>n(VCv9NDJ&Y5}Dbv47TPza2Lw9f$XawqNt{(3b`_3-7BOJ)BoP`TDyjpMJJ+DXOi#xb4oS z-{m3i4~D7kTHt#)jB859iJn}QuS*`U-K;RNVZsGvULIBv_2Y7&Gui+DY!DLkJidEV zXjR0oTh1T;e%~FboNLN(F!6HZJ;UU8#j01Xh45-dZ4f(XutsCj?Olc@Oa+g31b4k& zGGWq`D{qz7Dqe0lrSqTX>8|)E%2tlTPFFm;IyBiNa+xi!;C<^+e6=iEd6 zrT6j=X@0Uv$us@h7!%+=qi_Xh+k)xuO#K(VzwchLO!$E#qfhl3uY)g3LLJK9SFxqo ztvBjjn;*I1sE<3p-Ja0(IhSklm)x`#F!Xk*v_7=rk6fZm)%Pt|*;9WgH!iv*adp@G zgEiVN0-P7cPMrGw@9Ct1ZjOaD3dX^gX3n1&#l%=2Vw~f5-RRX~=ZKuJC3BqOO}o24 ze}B<)Ed5|QYnqPu(Zk+)&yUOyys%`w9z9@aUx5|9g?Su%U%U(Rqf|*Lk z-ma}QTPmmBv*S*<(CT?y*CpziEHd}Wyvn#WWrDyp4Ns{|pZT+mfD;YzB%(7K^xC`z|cH7`)>B=RtM=Re?Oi^ib+q?DiujV=}#^~9M9?ajLGsc%332~V5 zkaKI0&adNz%UJHtiZ8x9nZ4oOTh;HIYBFc%-t*Jt70NLFab7Xw{j%pT6VGuqa-N?& zKWXWMFVbco5~Q7`s(W#9tlr+@$LyZfSW+ZysJU2gb<*UQHdP#PJ+pW`%E~t#4U^X` zTlSm#;cMXu(_{Be3Uj?OJ8GtTk7ua<#T&Jc->*FRXYZsS zULQ`&jQmsP?n8ya3&$>j39UufspW^`tw-mM>% zKVm+$Bz5d6xM#)TD&1yZ*cFw(ya9A*6HH?Awhq> z@!q|XU%4z??Ox#$lOwHxz4MeNwQDWDxBJ#dEpd;2bHN$M{wNk&PR`tOmebQX$mqdw zahDRA>BpZ6IThBv-LcpA^utf@ot)qOKFe0A&il;b%rooP&Y!<@Oy2PRY-;U}Iuq9S z3t#2?J8?zM4HkSUav&n%dsp4{>falkZtDvNcfVs!i^?rzU`bxIFvvl13B${?LY^&x zny)RTJ>O4yZ2say!}>eIB^6?Zvy;l2WYmr^OqAYt@t4|ugSvLv=mf9JX>E2q$ zlWyf+ln~r}`;zk`8n0rkLOHkDO?rUy7$;TiRv5D1>0laMAyaltIxlE!qex0kh1Qo#osSDiCaZA zi3RV?wDXgRxtS=%ZFhK9PP$GnqgbS<>5ioH?N5Jxs{OO?{N-E9v+t&Jr%zIE-|jhC z=~T0qQ*Tbf#a#869u+~(&(~Ji-D9<$bm^?0l5*>l+V6U)hvcdw_8vGr%|+*6&!RIt z@61l!bB~{6@pE~(5YI2g&E2Ku-U%hAkM6E|=9iktq?X@yuJgF)LM_oY`3;Pgd^^mS zoc@p@sibNy$-*+=a z&G@Rpro#E;(rmN7?Hw(r9KtxXKZ*3L=V8&vD`okc^T?i);6_gyC&8iq7hh}ds2D)*jQUXW0_>ip})!a>3h1?Mr^eO+4QT6A-Z zcdX{_fGZOp3bMX=>o9%3q$t1i-&>WXeT*;I%mW*@yjCskTt4k!Tz{#_io(V%>t!N( zY8G$Si2t0`*5BGR*V9)|*0aDO(@2CNcdP53^*R$xZ70uNu(W-_F6TV~kFwv(i7t7O zS9-$hMezkE&*XDlCk-{W80Q=md6oTno17?r@x*mY(=2yQWU)VRtaH_C%Z*3*R!+Q_ zez#_gTz+Qio6}mM(VI?R35{HPv+rl@Vok=NWqyo3W@bya`sv&Z{J7UJ!l1y)u~@LXO%fyo>AC+<5{X0|ZTk7v@$CUm5p8a)s z_V2}ik;P{-HWz6nPx9JaB(7`_BW2+4H9Li2a$niql6kKs_?q6{>+5RY?xz0c{TfET zut|FlS7cnS{y6o-nXfLz%}UG5;`yJ;UNJfFeD#U1Z$8{P7yr0u&z2we&usT`GTSV< z@ldwOziV&yA8kEhy{GWeWs^y&>Hlxf{P!(;Mi7gI%&&8YuT+a_YR|c%X6(ai$NMT< zqod?^+QoU3>iRD2cqe`QgN8DThq&)L_PbN`BBb9>6?S<#(}kz$2g@h6zt5{hWI{9< zwAzyejf2j=D3|PiIG0ah$Ic}JC!Lb|m=khC{9M%Y*V_c2ESO|*H?pu=@3_eg!OZBx z4YN*I99&xTQQ9zbw!k;$?X9U%r@7WX-0S?~tougWzU=!&_CGXz9!Uu)T|J`qqr9Q8 zmP3|((!q6?1I|Z9Dl-4_Z%e!#6UMuD)1>9{=ILE$8aY!GKfE|_d(lnzZnl+w^MAce z7BkH!+lTFu03sOWm)mdOsDaK zTR;^1ZG+>vCb#8p{rc_JYF&ECqLq<49(fT7OphuBfac zI}`sWZ`AXALp?HIq;e$+9Blfi7X4O=_k|S0Kkj{#72ex~KI56aLpc4&^s^RX8eUW9 zY}tKPqWaM3Q%|eC8Lp)L^%FAP6f;-M*}^zyGrkUqDs-1lz3)0w)c`ZdXPCl*oH8{m5#bz{P%5v*-$_s^;vrH&We0?&wXMX&P z86U6+4b9(MPUC-3H3x3gWUMy!$5O`9k0JbN%^xAh6n zWsT}wlT<5Z8RcdkoX~lE$HuD7i!1lYnE33IWv~*Ki9h;{x4O>K%c&+_B_-h$&#-Pnv<0zUmg_Ld7)iAtmSI7PRxcJrW3;N znm=i4_?k)X6xDeg!u8c>{)On5uMAEcv0P}p_INE*b=4kyVt1g==7XCcT(lFjWJz0XN$9q9o8&n-*;t27mt(~hs^e!S*Cvn+4PiJpm9J}`c^n%lO&nm;mtPvlS9 zqfg5=9d%wCdHTUVDZ{Ii(C0CfFTTz?=h9-M z4eqQ)b+_Za+Id+XDgCW|);rtNgXe+8jC;OUCiSkle7O2;+d*#+tM%^25si-}{XJOn zBGSH3%bwR{_uHg($%jq6wo9gT8Bg0DyW_sm!cE4^iyfEV3Of49Uy-GMQ=#hLKbCt< z-JBEOxykld%uHT%#MIPc#s&S;TMpIDeKx7GSXpfSnxzM{nxxxjE$NB6xadHjTj#8s z>8sdO(xYO8l(y_^d~;x$rxeG11uv0`8*6857P;q>^kUMDKeI}vNo|U6nfd+0l^K^e zDBmmToU_YV%1JhhXM%fC=HXpMZ z`p2HMf3Cu(G-WRwy7G9jOaA*+ycgJH_`a%cX%qkU+cswY`sI^9KbgsX;?ktfE7?I& z1rx*+-tD@g_qMfRp3b{(-CJB_k~XMjWIR&8r}<4fg*V>u3s+j#7RNPq#=Y(fuU&bQ zeM*6IVU?WErFpS?5&5ykl=yEz;le zA;dyhP2cl|!pTF6=2TR=f4IWG@J8m*;0Lymre^o5qU)j+>vJA3Nw2yl-y6KeyQ0N? zw>mQe+r=ZAk6YJyE!^k)!Zf>Vh3vMs=l7_ZpDt!`lzYwTBJ6fke@35I!#8Jk&z#dA zZm>@JazLq}{pWlGsYAMxXRW(`q&uwj^yCv60U?;(EXCk4O=-X~+LX zDIQuOn>+FI%1aW-wxtu!6y7OQ`}IujPtxhQ?Mv_U&XpHwkJa3D>ukrQU*^&M$K3+` z%K3X`7EYdj=X~sY;c2sPYBEfBn#G!RBvO#M z$h2$y@8^d&61RMCIltq}gl89)6&?E)mU`X!8o#x*PgYF2JO8Q`i_aKezxUrwl&aPa)W!{E^7cQutJ+?6->tIav%JRfH z5?QkkH$4kz^WpmuxQqGFR-5bL35)ns7o5~cx+QyfNAr$=r*gXvG;}DOT(#-@w)C<` zDo18$uFrV2Ng`CTV4YZt>+NH+HuZ_FzyEZD&-6#nZzk`EU_EfDZ-$)b=lok?)`>=k zwA0lDyllT;?wYrHX?RAW_~aB7&G~D!O_M*G?|of*itS;l>U7h@~DcyVRps2GmKpZ(G!V z#a=xBi)J}_J+Ez@Y<9dw!MNQ;`-PW%nH%#)V{LZj{ z#pzV(eSJJta%-N+=jjzT{+{`(=Du6d&hV!(bGpt2;81jn?Ssu3wwgH`$!(+8s4De?`@@MJwku%2e89l}xBz(>iIw0r#tU zoh!8JZ9f0b{%pnh^!4#xpt)P%av#Oob$eZIO>pT^C?|i)Sy&5 z$wyy8H$U*dmCj?6&3SJ&U*%raUa|1>g-f?|Go6k;i>daCyqtEtz1m33_F36nMv*NO z?p$=5cVgwW^sFeB^KxvvCwg$`*&8Ir3Z3`JTiBTN?yC>GtL4Se_G2yYmbshRhP?Z` zRs5lIdQilo(?4eSa=e(VeRfHbrSbg3tL#r|&U^IhcICP6bN49ln6uTcJ5>;7a^a;$ zdsl=JJJ;;L^MvMI6AjQ3=H0~b*L>gY8`;`|5z_yE_U-?Yy!qT6mDAmK)BN;L?l`*1 zW-rUBO&UcU4U2>-E~`XtR=H>?`Est+2e}2G3e45H?1i6fKJssQQPi0kn{153Jl-$5 z8=F33dnaF$NfMWv5y#KT0U8JXKGm9CGP70id39drtHnxR%vm^|vIjOd-QDbNF*na) zmw#6tql4K0#)eE4>&pEb(mJj;M{neIOWAn(aUltoz5(VlzZ$RJ>>2F2(?&H= zJ$hPAX;YDPkYdF?!7BD={6*_lrduDoul03i==Zl5BIPDC^qMnOpN~~Gl~qg@TPsv} zG;?p#;lAFq`tL2fG`DV8BUdW;^G@vli0K)tuBTiHI2Rwd-CNe?_XT_ItMP(q!2&Bi zPQ6mlXjU>Uc72oN#B|zm>RS!|{oG45K28V=c*N0sR?pP6pFK1}UTa>_orT3~7yQ-= zofvYV@j|i1)bZ<5Yns>171|9i%I%U)J`-TnOESA7qArBjxu?(U`gimlcdTwCNEAjbG~ zmes1o^@b*{DyFBsXPG#@S?kSg{W`%U|6cox?#mIY>yK9aoV~nUA?r!J)>-DuCb|dTH0;pOa(Y_gr2H?W zdtv6g<+M`PvwcRc|X-*=0wDt-Ou`0tXVXJ$Qi$vbT5a(C~GuMJfllipoC z+pAl4(Q)F6tcLS~(XWjW9C3&HN!$}Vz=Is4#t>YgXHxP^@=(r*40#=Y_)>#?I@P$Z!Qk z9{a#zJxl-D&WUb^4(GbQ?d`o%?riT9xg+zgUP$tun^By-S~r4|mK||RVT`^TsJg1S zDdC;s`FSV*)`xL_TA*tG^yJ&`_Dk+fh}*66{i3YU<_QiWlhe5TUtGO?{d`fC+LDIH zTk@ZZMJs4j9p2x#`jnbm^3gKQV}5_4I@r|pK30FZcJ|@B+ns3#q;{w}IO^|@)%{!b zd4^(hI@eXB=O%tR??k4Y(o#u2>{RjnhlS)E<4tb`Udi-D&e|3_(buSC-x4#uZbwbF z>rb53_s9Pc5$4J-{$jX?edkh%{>Y3Kt(hsZL6S$b5A0XCw&LPF-m}>@L2b9X7gX>Z zXtkYNWc%*f#+lcGo%6W`76`hx_PGUqkXTT^KUl=DIU8cIt`Ly!emqiCG z3_lAUE8lFW^|g>KH!>hgvMTlJ4!`ZwXPSQyyXm3G_$M}bz0u6%m)%}m&HK_c_g0j? zsM+n2mR`WIVqWOE%l}tTzkc#lw)&xzr4EyABiQ@CEc|fLTl#9=LoT(H;H!qAnw2@% zPOEHd<=Oiw^JU^^w<*{8@-*sQ|2H~{o#yJAva9Q>^wj6GW)(g+jdYv3VcNn;2SozU zKaA>q%D~|uk(8ODdVQ+5kIAR9nop~O=ewI(rADhK%-opbQobXqlSmYzIvt>8AB z)rZ@Xs~G1$eHz{I#`u2Jp>EmF&S&@7bycl7FYq?>k16jCGbz*GXR9psh_>=Ce5ibf zEj`V;H|KaH+vDxC)G|$_bbVVZ_f4H@J+)x&Ypwssm7;IHI(qtF99Ox;q$SnOleo70 zJstLPiFC}>yjZ!Z)BMHKEFWDr^zhCO+pQ2-$EPWGEqLx~^MFM`d|w*RRre%T$xJJI zR%7u)WOwMSSwD6qFG)xiXTQt-&(>z&`h^qwzH^%I*y`f_rdhg1&W5i@aH4aO&c|6B z*)s(UJ}8Fp_fB24Q|Nh1g+|bV^OL6SKlx;G+(b6_u*~we+IZqb`dDOI`;SPG!F8$2W=Tg|>%`(cS+F zduG2cy)$W+23ziu7)8GX`HNjEC+}+voz}xY)mck_npR* zR{0FW(g`vCy^P;)&ePwqDsn^SvHs<0O`L< z@g%37L+96}!`uGs_jHO{(e)sgb)Wx)%KqOA^eeQ@e*bk%=I~Jx-xsyg@W7%!mu{R5 znYa4BTj0T?zXH!WB>Nf)h^L>}ynphSH(dNxrzV-6vYD4F?RECi(H|>v)^3jR@j9Mz z@yS^e>0>_mb&CrNEBT7P9Od|3EhFrI%uP+<@VAl^KU3%Kc(_0P_x}d|n^7!ht}Yk4 ze)0O#1AGUA%gVQ(@mIR>ckgT`F|Hq%r@icE`WpXS_5MHanw(G}S@{X4nk`xWRelnB z^=z{6lP{h8D<-m4uIXegesuIrl11>vMLF6h8xp0=7MA%pm-p^=PCwe3Y<~B{;?h-_ z!dG9$srm_R3Y%fuGqL=Wre4h5fVE}G_f^g@q^KNuLWb7#eIcem!*D-Lmt%8QTpN8E!%_#Ed)T2*7f3I2bP-3BQ ze#}PJjjOkB@N7&I+*EE6a#eQjq5T`L&6bPgD-I1f`eA$2XWs567m4Fq>(6wZM=RvP^pt)Ojc0FrmxbSlq`}pm|!+ zugTR9URVBX<>`xZ_WJE4x%8sb)1SLvIBI@BspC7r#>0HpXRnA`Z#ON7d(6OeD!ZKh=d`A(8!fqJ2hC5*pV#kF_<6!Y zucJugTiV3+OHXgnni-KAZ?@AwBQfOLp0EwiC4MuRiDuP(ihl30S$O(_Rtx*|mABm1 z{AyXg=F3VM<}_=yZVC0xjc?9zicfaEdC2X*%v{O4ta8toPtH59%ca|J+%mCe+Wosp z(=ISgXV2G8@$d4E`Rn%J`RrPb+Dj)Azk70N@KhNdxuVHgW$IgCu)b8uGxWJg;z7>^ zBEfGZwB;rVK2YJF)SY(q1K+{+i7yVRg@vXhoLtYQb+5T2A<2d9u_njq!lJBa^2u2# z@9uBAp&hyUdFSo-lPtde%Dd+%dqm?h&x>uRn(leZ2JAC=x5`D8iHm*Kf=utWmdM2& ztsN10!Lorl1q+$FqW<62?7q3XqP~vnLdFKCvrGc74b1AxZSS{ab(F{*$zu+yyqP(Z zwZ~s6a-R|x!zJ}&TAGX2bhGaJwBxN%L`uRw8&xmPnklkx>eL^feEaRMXrXaOo7#>y zmA~xPr$0ZjSZts2>J@C=(^i=+)9hU{)y2X7iFx~~3#XD+M}0qcn8)L7Ye>zCjSlH) z>AN~)-`Puf8+DX=C>csuO#iWiZEEx@_Fw#p0b8_cBREX5(hk`L*UM@2J~Z-?i4BT5 zDyZ>(rEOr$$Mu;~`O8ITF`s{bv_|C0q(v|MZ|OYp$@0n)*|>7@?!J^oPg)c{@&{JS zUygX@wEL=J*5b?;hkwuEHp)F85%lbF=J(bP-SE%VQ9N%C+0ChuIPG+F%Vp~xh0Im! z_L!uen)a@crK|H$YNxp7zVMkZL_fvfes6g!DSp=;347ID73P33B)?Vt)LL5*HgmUjS{(l*yY-yr$D@UU&${nARL0BE6Jw$#d0z6} zFP)T2r@mP;J(E~`rswp^&K}ek|AeTFSt;s;t)2`kIdPyjKiM{y%kgu&tQ! z>a*$9U>9Fr?vD$&4*C6^lPRjks2#g!X;jahPG2##e_z;MoOKC3{<2rU=IF}}{|;^X z)3#A6$@B4t$450g&hjgI7ySCS`kBU}41+8_yNxQPW{m7U7qj*RST#IuJEyf|`TK?J zzK>2+{7LuP>%Jhh;E=&gJK4ZlA)(s0JNJfbv-(|bm@_FZb(X!-v(G9wEI#P?J(*h^ z5InI(@b=Bp{<~~5dEaL^?=_k6Ds$C-lU+0F{3P1-~yg6;&!D&;Js$aB} zuym#IwjC~Zbg9|)znY^;CiSg1w{G5d=cCo_MV#77KY6TcKEy8cll8gte?Qlvgtx1B zf_HmKYTUTHn=zIvr%TDbEY{`V*W1}m`x2_n4puF=vt#+Mjs-zUMx6fFg!(6GeXUe~ zS!uCj(@ve^iZ@PcS3aF2VyyUBBzWucx979|8%M8{t&Y1ntK@#z*-6ieFEt#kxw!HW z?`nUyTk=+_@9Tx_{F8dimh{|9G@g~TdA?(q_@!^RLbokfx_(I@DdSh)k7Y66OE#4% zw{WbwmUA!mG;6SW@OQ3|HRrZ=2?ekE(Dz|i*Ud>Y{ezvgnQdB+eM)_=ndTiRwXiYk z!K*}_-YYWdhx8AXOU$&M6}I@=jxM_{iAU>-+Ao~4b#9s9(!6wL8=W0P6!fsa;U@@ztLA24rEc2p|+-OI+lI%wUQ`%YUYYN|RrF>rL|H20bF z`LC{2^_r%B&#(X2j+R+syC)sujt`CEKD2+uidX$9?gCXJZ#vi6%(6KXemLmKMdx`u z8rPhHIKpg&Y_!V+0{gD93q&h;8$H$SIr2X3igJ7pPmYn>J?Xw$qu-a`2)3wRXO-G4 zIa%P%?Gs0h*j;SDp4=Kz(w-PAvc|xJ`>yi)LR;~acTLkaE8426_ZjdX>ZtXUVN`kf zDz;=%-j@ye#@>pt8a#hqggJ=_Wn@?0loj97dg;QqHJ4`oSk^G}j@t4oUS?OWmWTu& z{pRTL*-Begz^Nf%-tLK9m36m7_S*#NbEcT={GsvuUf`Dg-u;16sef;(F5UKme|>j% z-Kn0Plin7kEuAQI<~gUJw{ddu#}^g{AJ0p;UA9iI+UUYMf7fjrLOwogxqH>)&VN^_ zRe{U@h-7_tnRD%_{k^{4kM+*-b~exFo@9EpWmSR3#))eLAAJ>ayV;O(scPP)B^Ew* zTaUc6nYhd+eM@U^wa4=ywM8EsHPjUH_7sL3eskh;IFr%LxdqL!i;l`2POZiy;(tl z%e>4TTgzm3@Pr*IGU9)HJym=C9Z@@JL)n#SQnHnDfp4mt7}5@N2hQB`ZGu<*)zA?>z)7+%}*mL8m)`FJY#cmV(ZQg5qcB(fPw`(d__Fmo8T(o!oa{fgEX&yVb z`&4N6{CF*QYO;W{=&J4|XRdC)b?U*%nf7K`A^naF&*z<6Ec?2d{n^bm-M5U|o80TU zZ~O{5%Vjp{%LCSJ$E3Gh^Owr|y0N=&;zI>-OX*J*8|9swdHdYHH2HH(SynT_|FTna zbMD!@ULi+Bz5KVk)tysw?Kbs$#&=9)iwn!l-0p1S451z_xjx1#CtekNxbP)PdBNv$ zXEO%x17B-*#kgI{yZBP3U-id6!;6BGTqaIboTu@4x~;~R?`yuaS-n+axViDjUYWnC zGG8t2<}dJRvX_qAa&nQ@>qyb=mM_2O9EeG&Jlz!k=}@2;Z^8A=>Rlb`T)#D1+Saq( zoWr!W=4X1h(?nUvmfV8@E9_optICM%e;2gy&fJId$}XE5vPq@2J$!Y}VqKt2;9ikt zb3UaM_LQSPKUHZ=ol$URv-Cujme28)QI9Vh)vP$Dw7hbEklfNF&#hV$ou{aUPClU# z=5=Gc)a`OB?$45|_$w}}e@}kudNout@Vn(3-ANtFtD7HXpEz@^Pw&y^UGeu0>+Q0Z zof3IWOF2}B=a`$`u2ojYqRv;XTW_+ey=m224$ju@?<-D4&$M4^`s&Vnk&-uO*B2ss=dmkxd-sH48Q{csO zv(4umO9Sd(J&!tN>%4K{fuk1Ur^A?CKFJz1`ExC73#y*;BV+xu(k&uNE)#DvO8zl^ z<=mZaxo~ko%$Lbh*{Q`|tR_zD8fA2soV~Q;s6%1^*DIFz?aTfMzj@o*_rtFJwB_8w zLwCbUqAxGE;Ys=HU;5vsmo057$L&+8DYK64&dootv1!49%`&v^wC$_M4Kd&lF2+ww#h1OGlSkG)*Felx^fSGRtxAg<7o$L4>OCF85 z9H$wWFKyB>SMY@Nx^UsW&qHr+j)`yAU;iuV^RK@W`(J-~^5pBIZ}nz;2cQ4>d+$Dn zeIN6VtImfr1pRC{x;zt#?RfS7>YOQGQzIN?@&DX1*O^UIj;_#}GOzR|`;plBdoHq^ z4$o`WYML3RGuLO*hHql#df$y>xSok}sH^^xbvDm!5;ds}dhXN{p0NHjYw1=uJ)6MD zsOv4S%UovUa$J3KZ^^&#Wvke@`VYKoaxXr3^!fGm*BE7jMRd1`N#AZad}+2iCUV_@ zbfxaIOYT&yHYkc>5dC&y-4f2Z9(!J?c$&7DNV`8j<*@X!f~rAV)P=l>(Xoh94sq!J$I0Y?X?<7ye%O9BHEoh3frw-q};K1x@`U)XX{<9NuG}8{|epm;^P3Sz+na`-AQ4 z&R0_($iLLKw7;qtrud%klGE0TSIVt7r#Qd+?h|}y`nDwX@2cmGc~s`_D&~r5m)jt+ zYR@j^%O)b=N8RltJ4$B+8{Z9R#Rcp$%SA4 z`u=z+ZhtN9vcT~;!Ipzh7*BrS7dzMHsTR@I6LQ&Y%O2>xj63mbo#tN)w7?_(Kfb z<_H)6I#YAeH!k(I);Z^6tmjKgX1vvB|8Ygr=#x^^s`+_!yF^wW6jq30DtDn{Y|?lhk}Zk4s(tf6R21-hODW zSa89`DgNMN-$0dlJXiLre@Q9gwmK^^_x+C>lYM7C$iCcel2gUFO`srjY5dP8cb5je zAKO^6PxyW9(_?#^3e$x|@8y-3Ubg7f zTwz`Bow51B$#{(@nPb;QFU&gZyiW3V@S!b7{6c-$e#}~Xa@C*e3gz{;F8g`d3hX@+ z;`hUN zq+c^Q+aJBH6Z zo1U;AoS>g`ubU@LBxb3g^N?WqRcAD|sTw{KZg4KDaLVvOtZWPJ0 z5{myP7z7MlqZ|cYo_;2G`0>^LORE z+P>_`=?j~VMqJ`%f1SU1fq@P8>|lAXLYWN_P40_MKdRd^?{kue3De1vOG)BV-P0^} zYHW5!gkH_#o%w&Wan81!o4>3}On!DGNF2Xk?DR2osqy648MBhh^H{g?FPzsLv!h{R zgY3mj`}oWWyQIsGWqr^0zjov6Bb~hFmHBVqyzpHzP3m~iq-Qx1+=hr%2Q@h7T^we{hz-~6?g zcVM1hw!?hYCs)~AiwT+*0k@w@Joe$Az4`IYl{cSEI9pOJa7O=m!tGOQSE!`3D42iw zJv}Dv==r)b1KX7;^@k0WmwUK8vidslKqJ@7OQ}XGwkPvuUU>Mjy5!Xs_Y3l64ZQL# z>OHlrKl|D^o-N92w!X1Qisy*4Zt9V$&N~PB1WH4$KIsoxe40In>wxfn0RZg`;Qb&^!_ z&I7zZGu|$HbBOnzfX&yFN-KHo)~7LBAFG_5S@^FqVa=3|RDo|#*B>h_$(kbb&gw(y zvLo?V-&{;y5SnwSW9Fy5%>jXo0WEq9T`o3F`8w4k=>5z~K@79f8*X(>nyqB%en9hQ zJL~PA{KwDkx!BKfZ|9#^`po}Y7H^)bHSdnHimDl3WMo=vpRcCEnH|P+Si9cK3cq60 z-S)RjXJNPS5`hJ~H)x9IR!U8rc<;=!?ZRs#=iXg0IWRb6Z>7-9efsYNdrtO#0>i9O1 z?JG-jLw~CE*%r8Br>|Qe|z*bGy`p4t*`+m=P{_p!zp~<-?cP~z5 zx}dT6hWHJW=*EKe4^`VA{(fJ!$?aB&%M;c$TXVFw83(^R>A1CO%H-c&(SZjXXU}W& zaCxI%lvWmz;az>W`L5w#n|@Ov%`@ktGPbSqt_bjUj`5un7;&_huf)2t)@`SDwb!Ef z*OzO1+?H?VcM{i#x$yIGT;oQCmr8S0EP~3I^HwGY=uc3dyXEqO()EwymKiaeuyN4Y zr2X^S_J@l-daf!y`(oBU+4AwJU3CJQr`VZA5+^?G*kRQz#Gl-6=*f0!q2je>2gcny zOI)YjG7D8w_k3pXdQalZ+25HeoclF6IU+A_I9Z~5@&8oeb)DUYFP#{cK3*8CHt$#O zimLNz37*`}@0%LF{{COMndPW@FzYr~F0IaQhHSMLrs^lL?Tcc_*eMvTxjyFU+i&$N zK0DmLP|tX$>(rgUCU)9^D-z=z#kAUXZogRJ@nZXv-aB%fmp`evMzw5?m?V(L6ngVe z*}oTjAMV>ktgxukdVTXMzfEK4t<;W)5G~PfqVd7zhN31qdQ5k8MO6Epr*nzPotrJ2 zD0zNqNR&&}l=;bG;YSQrf7ixNTFq&jHMQ%+zK<(zURf;ndh3@>mK8IcUtJa}^bl2C zaQ1WSvmK4KB`wUQHKO{C8A~P#NQs=-=EqTP!>?mDZ2?D8v6R4d{SqrT(Zm+c?6SR6X``Ol?Y7Z(*D(>7qyQT5^|H+pg>+b43?0qHraMJDc+j-8P7Q&Hg^<*<`cF z&Mo>hvqBvY{|Zm(*9Bcy*DL4ht?pl@zGqd)p2GUtTt$x8sWVKj$n@Sn%cSJa8>7)u zQ{;0w+j81Pg(F*TygB_*$z8=oQ?r{R$MLa}d*{kcrP=}0t~u5lJJ;1kvG|MW7jD1i zbL-eL-%ySn#U24JR!_G{UiOHgj<9Uc=rP_p*H87Q*-x(m z8RK@Psoi$1N>i+ZL?b62-54bIAl`8Ki4RwVM6KRhbQN1l6N=xS=&s18rxFf`$qoaA?fRUH+99g9k;yKz@fo1fs;RDdhg_o4<5x# zp0ST9sP$OP{gt?qlLb`(&Fi$+VbBky$>$?oIrn%;(j(S(> z)U^`>g;$;q;+&tqa$c(9CC~Rl_e(84$V|E+J%8bBql+&VNtpe5aMRiUIm0tvaii}) zu6T+YcSY^)D!h8lup}?#Lbvtm3yQW|(x$q2r!AWo!6LmxNKWtakrpnNjTMcd%ljNv ztRMb~`)&E6smhFZ#RZEBHu)(+x=`tft|67{B3!Q?$} zrf-_1*?)e=**EicJHM2hw0oCcc3w84f#{nH&7a*wPEXz;ZGK+ktlz~%hIL!6|B*}) z@V@eI$L;AC3Xd9nD?af3!b1*A>lvGW{w~Xkn#%J0R9e48?0nr+TmO3Ii!n=;3*8&G zh7 zXPAfwPbI_Y-2|ES@&lzI>r4hRLE!VZnqutC!b@{*~Wv&F>t{enuOmMjUe6At*I}cJ!j? zf)>O5UxJRz*j**N{-?gB>hsF_>tBB|2ir3Slqa0(nb>yKFVS^hzp03fW{Zc^Q-h6` z5hXeT6I6~09TE)P$nJ0MJzaEP*WZm_LvIU~?zXylOY>i-nd)Rt1tYnIce65Al>D1| zUH5U}OWs|oGSg;0%G$)H#Hh-3s(7O{=e_GC;gfG}U*&i>>J+2KmR_Wz(B@PQc@9fN#0tq%#vYDLlA-Xe+ad^V{+-(T}%R%STV&%DaR8 zmRVN7iCN(Z8*ZiC|8R7UOrQ*}ro^8)rCDbu=V_anPxP_9H0ge--ItD@gULpkKHJ># z&!+Y+a@F~3l$vnw*-pE*4|?ou%x%@VO9dx#O~1shc&{pmVax05qGF2^ti+Byn88ru@|c=o$_>}cJtrcHSKE-+l%&)gvc)G zvzlUAOS?b0KC84KZLkTi!PQ+or=iKOn$;;e(n@ahvL^1y?Se>T_OHAV)#_m#t8lvKHHk$CtDg zryg1v{o&2YFRzv|d+$}6qCL?mETwvz?32Y^ak3Sk!&mfr2r_R{;Y<~AI`C)nmWeiE z-&o$eFIXEU5balPn)7}K(i_0Zq6CDZfHl|C$*{rBtbTLPaIuAaHyIj=3l zH|X~{iFJv_tiJo-yRCk@#J%bF&5*=OPM2vsfwy%!AMWP0^;a;{{&3x2zN)3UPx$1T zDVwFg9f`?#nNSn4k-hWN?$7HJ-pFX{xOZga+Q}|k^0A(o?a`hG9@9Km9&lW3lP{?_ zYg5ST?n!E|U}(p>I7wKM$gyU$&Id z)s%d1!!(uCwIk^3hYzdN1CCuXy|X5gv9mUG+U3I^8yqY%_nHRt?vz~ITrGDZMR;Mh zzp?Y%y2&piw@*_(*gwm*-C-gBJHINEtf0843+>JxS9WA4MD*O@`L;xNQMu`ZXJIQ- zmH52MbUl*~ANw-J_Jl~@4EsKTV|Sgk&-|78`_!*N#Gkq2r%piXJBN=mUrn{S!8vxk*)EJDoO-hS8E z%k9Cj@|kX>Tie64>Fe*tY)i8H&-c>B=a|pT{0GN;zb@J}chd~^@Ex}ueWxSkXhYq{VmxAW9Lx2GkqJhrd)z2DrA7iSe5e{w-= zX0v}w(2Fj46)yvppvfj%jWW5fa0jm9x4P#Lx;XblB!_g}huN$$kBu@{?$cVCVY!lB zp+Q?x@&$t&=Yxkorn*gk@-m)R<=E~Bwf^^i?;beLYNE({-Heru>&(qRGdd1Ga4zTL z6s`E;nm)C*`dH7>>njBK)xJ(YD$>TF-ldb0S>3$L#^2{K=w>EB4<@xnh|9?<-)#q65 zNpBxImzE2ec3jR^-@h$Yr`uY)q5Z!2w#%tZovf3xON`D6HX7ONC_k*g-}P0x*UYki z%KHf3!juDvXFVQPJ^7Nskjm&FzA31=V|UvlwTHW;mzN!2`~ShT)oboMsiRF7*XV9+ zI~9L@X|Qtw+jXD7oO7o|guj@Z9e!|LKCJy*FWa?fj><@#ZN*Wm^3xuEJoD)J)DvH2 z+7}k?pIET+`I6kb^ESPelr$E)di+P;y!~BLo?gLU7bFx+;I!?J%Xm=yt@3(nrJ$R4 z%{G6>_quJe%bRXYJ|ipkc1~_ixZu2Mj`hp3U+?+!xWOh>x@uL4=S|`Iw-e07_deOS zd-4Gd<_-HoWWD~c4gX<1+oExnX3Ok-n!QropF3VIO8F=I-1Noo=3z#_Ee8w#H_kVV?D%k&ed+<Dj z5!pL$D?Dcf_Dqt>%s<(?ENscchB=xE_5leOCj8s>^1SwCx3HOoKVAl@%#(bmyoP5& zI^*gY?S3t5?HY?}-sC8DhaA|;bdI%Xdljczz(!vy-8pMBzATN(P8AUnSoh7N<>6F6 z<7-a>=V{N9>}OxY?6NFe`ofjW zbB|)G-FEkAAKx<_s*BTh^O{Rlh}-mNo>dVOcT@iTJ)D<$=baPkd1vL97AEuY<%chN zq7N|jaMH}|3wmef@O6TWe)ro9=bVFSj?vOfJp|rL+`YFX;{BG6x4Fjy z_N-aO6OzGG5G{Kk^xb6rGj-t)g+C?8NIF-o+LpM7Blz2E%ZJ|AWpDm87dgLT%4&rv zx0lAV3+*@_pB<_$mMU?wdfUEJUp1{%7av{{;mPngr7YAZVaAU2CRr^zY!=Qn>(gmHb!}x` zc=*@th07N2=)K4EAfe^*LV?!x(X)D#R770AZuj%NFy)G$wu&A5j|UAOV)))ha9m%w z_PWZmW**O+lE8B({Pd47=Sdm$GK-wJ+bdx!fBfPfxpQaI?Bo{OcsVnQPr9MR7y2%< zr!X}ItX8P9a~fF^(PuKzQV zBqNqQI(^aS?8!ZX5^gi!v=?sM&AlLNW7eAfMp3EB8eP7g8&_EGeRpAbtNoO@dNW_H zJZyjX)3fJ_n?ee7^`hQhtFV~1@_Er+_44o&N-vhMs7$ne@jb7*v3%K^{wU3@mYbj5 z_GVZWb@^q_(j#SJzOuH8S6?sw#;p;SS>3Jb@2-9B-X!hkYq#glzs4cv=OZoR$K*8O z!uNvWEsk?_Ih#xSm2})~IpwGPIDbBZ-{kIzPcCtW zJJwf<-+zAP2y0%iT<+Snb;%{SCFJicFbh}QSASm0p(aEZdPTuwZ+Y|PFR+4cAXSy<8rDHJb!WhVXs9iT5kQ! zYyJ3N-f7aSH5Yh)T|dij{;uxtBDvnkrEYutokYa%wkc~hP7PIl_q(a%V2#w8yh9f! zcwbq_;Wf)a_3C-uE4va}KbqJ$U;45k?BFF+^QwJ)-mhG<_U?c3-#Yf&#>8dUd5)cb zz3W7n`kT^>RZqKqR{il_vwZ7^HkNe<7B+{Rjw<}6aA3pLwdc$=p8slB-?X>;Nm>2P zpVgJqi#X1@w+Lp=Taz~L>XFU=MCTjK+PZxA=`)wB>)u54?F@?8|7l15%gU)Q{I9-l zQZ0Wk?fhq9LR$1~w&2V28UkKD`LKcCV5ZRtxv5(?)a6gMh#Wjz@N|YrK#Rbnip_yp zC$I2cwXw9lGJT0j)WR^A_0G1utLroWZeR@Dvj5H{kqH?)+Yh%*aVczE8bBQ&u!2ZVvQ@y@(+#W{#6(2^I~iE=9BaL ztr@OtdKI)s$u80JWBgZ(eTu7cR>hPE&x(%8Tej3GGy2f$FfpZt1;5NwW49^Bc==wb z2J32F87zP?Ikzii+?8Mxy?6WgB%w~Sf(v&QA)l`Y>2-X_a(_AA{;UbH=tb2GF3 z6OH%m+yC6ux^zVHx7D{JqVugUp1GahvOwbB9?7>NQv|Klg|nhtdZ*P2UtBnA*&Unt zY@dAuy&~Jw1maI^5ji&f+KTkk{(B7*)AO?b?#e!!Ud4MNv5-gjIa|l8HU4)tSS^iW z)KqIXfA!(R{G_=CW;41soSt?eO7O&wNqV=tD+S+&x~jXx9Iw82ihGMb!_qNa%6_*$esGql6b!TZ`P8F4N3CV<3Zr1YL%;4#ZY#a~E;C?e z+{~lWZGzg4{5wRxCtq;?7cc((5%lVUWsbWBO&IwM+QI{kV2%l#YN=But@ z;N5Q~oVRJ$p<`QiWL~mbn#?Y+dDq5QE3X}jdZqbGvpiDoWzB(|Cl~%XW!R+I%alL= zY+QUAe_hv!?`2mS9k15?@D5bxKW@lefB@5xW+ocNlsrCkI5Qd``;#)CwXO`X;Zx9o$dP?&p!=Wyy@1B zC6VsEN^V-dTockXH0I{4FN@KY=PqxpJ8(i|`z#G#Ho+AyX3P)2)KICp|J_}KMKk`! zebtP)DxSyv@av-^Q4gA?182$*W~2hpKenXo_5vUp87G$m{I-8&gpAs_I8TA z`1dnzXz0{JI&+yVge9B-EN7`x?`p zA==D*IZisrWy@7RCD|_r9xa@`yyWYgyKA~D*U3M>AJ2AwIxBD1;sb1|OSEjRv>pCc zbRg7C>rIjPiffLccPj0TTUMTNtPEyB6Kn^3&q!`;oB|DFnoHaja)nN@n~X8*jWuHLT=f2}ciy;hR@&))eH zdZn-a@;Byqb0_)0G41=hN3|N8ex#hMNRqoWTmRwvpa1lZRCU?hsJc~mZm)mP$!fW8 z8$83>UdK(}BKu$U=A#{Z8ZPgi+B5$$>y-KhuR82%aW6VPM^^Yr*O}<% zbq9)>E?uV?iIqCwFO|c>7A}oYmdi7egy&*Ex!@D|_Eu9-cUfwbtZ$ z@{%d@PwaLo-duEM(d37f^HQX@ITYpO_gc$M?OQ#4rCF|mPlL?rFwfN-)&*(0AE&5G zmK>0gGYG#whvCMDd5#MSMi)8C69HeAZ)ldA2X|J2TErq0nX|L;$J@qhhf+g)yjrSqmRh%7iPpnXT<_uAWw zI2Gq#ye;xu{buCblPhg@awuJvUE^ij;`b|Hz2fVRH4XERip18)wY^R$Tga>=mpUQz zXoIrmX31%@&^x0V2`+1s4|V`kl<$D4=nPF_i0Z{ z54p@F|Lw0r^W?gpX4BrD(E1@hao$bU`Zd)xdfV?>I^9cu%QNMaEU&e~y!q~R=2xfA zv)S-0f9}4I)%kM%Z~F>oyp~Kn&sF{5#f(E?Pb^>LYO2>%&0BmlC$N2vTi+$e*)ILx zTj!(%?a`9mlvTGeaaUe#w2;Cz`<$gw<-JEw&VBRZ%Aqqa#av%#)b84zck0LfB`(_> zcm3dN-}s#6+~Yf^4{Wn4F?;Z}GAf_z@NuyjO5c-SnPsbUu|1kQ`N5HEw|1A<21lLS zzG=%08(&8Ed5Vd_YWpV^-t{;ZCiv_}Dv&uq1%Ei$ZgkKgLspPywqF0Aeg7ur&6 ze@K>X$HBu3Kkr_jDj0oHz|A~pQBwNpRgZ7!h->=(xCY#ehgMHW8$ zp1d|s`TVkXn{quhD=ut)yJz+jCzqtiMS0~1r!R@U7gr-!pT2nJk_W#GD)-JiSC?$P zefE|6{gX?=X1ra+oyz;`!{T4t_nLAni#mKgC(N^oE6>)d^d`%)xHHoy%hY?*>7wgle+el+w(TN+*_8rl&7D|ab?-)$uqw; z{5R)A=Y;-;HE@c6sItW}cnD^%!hFKgtO= zk}7z@spY+1#LL$AXF`&bQP2D9aXji%dp~~M!+xIi`~{ub$*OF}HG7)(97&o{Qtv77 z`n1SX>q*o3o@`L^-}8FbYKO(`XZx&+tnN7|1pT(WVLL6TBmcZ=Wy#}o%_|AauUHBs zir5b&{^~hmQtseWopM?5rPhk8jN6uebzz)k^U*WWVA86uyI08hJt(eWTy%nGolx`D zjQP*?LINVqrWA#2G0u%EiYW8lz!M8DL>eK z?$!jsunV?TF~Xv=4}OYTh92D%bslTcXK>Tz)OWL zY3Gp4G`m|HyTZTfEGrRDoE-ivXU629btc;;_((=-RJdB}l$HlgELbf$J3*$&?n7|b z%eHw(a`$ZFSW}rIcq7H6!r3eOt-a;3##YZTyV=d5JEnv&ZQLKgRFVC?ajr<_d$olD zOw4UQ;je^$RC5`6SbH!vPfuEOEWF0on5D9zPVRjC+{HY2-mDF+O(FUxYRtPk_HRwgjNa0}=hS8M1#kX~mCD|Gd(8fH zz=is-oD0twXQcg?KO*>d*RZ~a~7WqJT15&&{$x9ZgiZN!tboT zQ$M5C{R%xu!dy~h|DHfo){L6+kx3nK&*S%MjFS$SC!mkG#Pac|K zvE%2@VE6jtH&1`t_N&VO%d@Zl;>+(o{r2-f>Cp}Mq{?4az0I|fNacSpYkkw5)bN!T zCzZ$^V1B*ni{dQdWB=W4}Pp}R9g%Abb8~n$3 zN>(*9YE>NA{*}}H@S7RSUhvyGH$O_@b}2n3yW%ig@L4y_h|XCN{zAX)f)>h744qxf zx`t!Y36Ae(%zJryQomZ>oV|sqbJi2bo&H~L9NPWGHBcpdm-p7RfVNpWN$-FEt8C)B zk)xYw_hm+v>II=#GaIcN4xim0a(GlQ-&L?KTBiM#@v*+A`477uvHh#7ZZ5Qbaj#je z?rgQF&T%JE8Jqp)v3A>M6g8=Y8hPB@EO1iCyym{*2hK?x|AVgzT{GZx5T%xhoLv7cMHSSyY1T*uL z+izh}2vNBDw(+mfX|^xx`5GqX9__K2|3%^LnXZ3@=Pz#k$~|enzys-*wU?cfJiaR? z9(CrrUS;NWK7PKP-&ZNNxTa^_FBnz#XEaOXq_!Ex9C*2Z{gqztClBgp8qU2TyJ4-- zxleC?TD)Io!23*NX^&^b>tMlNzP70(Wy|Ul7acmk6;D=Oo+R60-cj%H zL44nf6_4CZB;HLux%B756Jc$uf-DYglhmBh_&j3z=Itgcl0T+TV)x`WPUL!dDeu$^ z=EMJl{Lkl4Q(;`5!Gmqy*^t6r9sarlDI#I5dYjiM6|Z(6Bn>>RIN zlqP*eC7|1|c;@lLa{gRCmz@+Z%AMTLG}XyUa!xS!d5LQ2B|GJ!xJspdQ(C)B`rn#?7LoaS18TS zudNKYn8?d~{R@Atn9r@STQi$>tbICDw^wo;LX1}Nu=*&=hf_q|Nf^f z_g7^&^}SKV^6AS(O}x1e%*7vd7^Sg@Gj!-D9OsGW({G(}UnyhbM$dPl<;>L3`bxkGis=g)X%ZoK@--ze@!dm?m6wOq$1@ z9zSW;N?#|FGln;WywkP2&%KG)R%`1}ITZivdcje}cYiqkxqtk>|M>rZ%ae}2{Ij>h za_{`B5ZI;Lbg z_e*ea?}F&$UvWp0QXeuIuwOav`^3luRdQhi&bmVp%CTy%FYi`Lb(1dw6x9En*Z-jy!`JQZ|bj4|6S8~ zLoc@~w(VS5n|S)9hrc(cbcYmAJNj=y`Ob$MB4*vXEZlkI(pf>l>rvbpe4ozx$UZ(| z@IUV2_H9x<{=VwW&odvnH8kAo(9%lvopm}WV0UiU#-B&a&h7wWz|TZvK8J z(&0u6KQCC`1*NFnT4%Xhe9o1lKI&#&a$i5rVcYQ3QsQEi zuS~{8m9KNRDg4gva-8FwnA+JqSt3RF;Iy1Ct}XuN>(ly{1n;{QxjDB$=Z7sPWA|m@ zwfDC*#a^s?H{rF?EJa7HuKI6bfiKUOxrP}^><(R8th!s0&q{W3hwFL&B-1~exew_) zG|k?%X5Gh)KA8fyXBR%2R(n`>-t#D5C4sG+{VMi4Tc_@w;a$})u;O*0^CHb2e#7W9 z8^6swpx-)e*K1Yx%8KrY|RB zYPBY&?B>56AG#%c4)=l6j~;oI6o(Xd7GGJhN7-9RRYY;ub}f7J*?aDJ^YO2Gm348| z?C@l(1clz^TxX7&OM0xh^mr;0?=ktcXBfp;9v|L)V}0V6N{)3R&5QWYce#FuNa}l9 z7!zBfC-~=E*6nV&`7iH#-6`Iw=K5JNgXP15htt&DO%8MUyjIz~?ni&XyO{x}%ws}( zF8OL*j4N_GE4c97m+(n_YUlU;v{I>BrgiJ4vdqh?34Nw#tq+;8Oo<3-U6!(EtwT6J zcdDED!^NZdZ_a4vVUvm)biB^@!fvqqbXyd z6Tmh7bwa~5o?n)eS1=e}UK&tWeq*kJ-w!XVGOD zPj*#KVCokAIr-b9^X%2zX9zD7Tko{?3s;|J?!+rUw<&SE&e>2n?+&k9Saic-&Vbwd z_RgJpkmu$`*ZUF0H{xWf#AU?hDqi!FG~Fm#AoujtRd37fI-IvmjT~+NoSK}?=nxdT zCphwux5t}MHX-fsjSF{Ny~vPwX?5BWHmz&VOuFO}KZJTFxU(#}y14No!}W`Sn^N{R ze{-4Dro38ZC6nMh=DSBH2I(YS3b}O8;kdlt^WSgou6A6p{hsTIR~n9qLa}m1oL~Bw z9^@5zTUE_?yGB-axxL^`(cj!>> zjrLxz66wH)XAKwc(O%yjWjnd|vHQho(|QkIjByIj2yF5_uRO^Q{-?WMYOSfyY zUi%Q8X&z8oVZHUv1Tlt?Hk7vETJ$G&Xh2|E!(3?pwKBp#! zf4lHxae~r}2Y=4|WMh_2@0M5DyxraHGzV{X7t7x-Z`?OKPc^yMR2H{Ad(~@+u&I+u z7n+rN<+8O+j*>PiU#xL+RjwNMjnI;$*K=#RT;3I1^YWW7mQw!|^K!x3e5pyQvyGn% z7_Peg&HerJ>5^+dajLMdI$Bx#&!xpOByxOn=Op~pU!in`-K<7+p2OwM)*e4kc;0Lc3*T{Jaj~*b%kQTf z9{097@E-~FjoKf=VQ;U&U$xn%Gu>_dJnh|&B^;w{!hUKl(iJ{am=e3Je>9PJNx3s=xp~+~3AmcSFSU;>Xub4l?>>FL|?WV+jA1Z&hhU@!C(q zpD0~wbz8Z?(tqLXqbgHA?^a%W$?S$AOMSILf7Yhx&%t+DR4-LMT$&Kv7ZtWeGC4)p z?6Qd%cg*)HpADMxmhMeSKb09ZCOJ`z_;Mf>Ds1>BA;@YP&L(Cy)kI6=T05}mG|E~lDZS9 z7 z-{nhn7biPRY*AWyEcvSG$*V@wg1ldJz0%D&|E#7&dP?0}jeTsrPejuewj7w{b)iXQ zo%_=FnHO#^%2@a}to)+$EQ1(@%#7SOZrd~GUAy^PRwex55&pRtaV>99=yq$1$65F{$b3JZIHoUa@@%6-gp4j~bmxF|_G2Vas zJXhG)XTAeSxJD-=Se0-M^AJ&}{{&e!bWPK0I$^I2?4Y7+u z_1~IAHZwflZ4-H0?dA&Vj#?%tyO!+| zGP$>Ku~uk(7VmxYzgs24W=}c#d*SmVjqPhMiY~MB;9OAd$HkX^c}}BJ#v*gwX-Se3 zWUU?VyYH*9%f6y}clr9wqB3$*MNaSc*4z=dBT-oHDKjVYyt%IxA5S}Dc3pgD!1^Pb z-QIhbug`5_&wJkc!Svp3yO7{l&vVL^wp!ojSi8+XFHQXTlGUo;5-y&+H!JJS^=Ze; z6&AkqPA}|UU?p)Pb~~4Se0yQGKtuG6&7r?aH_xir zP?qvCVC%ezfe>| z#wFo~HJg|#UwNcgEm-k=$HlO?aEl0qb!sP~Yj(T#b&LD{2z%!m-cWwe)8IJg;T1Yh z{LWYTy=tq`*n5-jM(zdg7xm1OS4{G4n`rmBe*2$q$~)S*4<~+d`mwK`TmQ?&%MX5W zpZQRFYs-AC--cQnUO%yz@J(52`_n3sB!y4h3;C=KUS4?`o}4AUmC3}q?C!k}w--q* zKibynQqg$u$>kl~mVME$gqF;9>U7xcE0_3UZ>r`zzp#_XcdQrJxa809;_AvbPO_(- z*S#s}(wq8_<^1v81vi3sU%zltnCD2C3fZn{f8XZU1zZr=~_=&)4%I<=mc2k)=< z$XsomY11Kg#;Nb_wSN76cE+8056%?|^~wCpSh49U-1`BlY_ zi`{*3WAbg0cI&9p@hqzRglrM~%P#LSJCvG##dFQF;v@UP8j;sWE*FOLZwZSvUNYsC+Rn>7&Zj4XkENHZ58u8$&DtD?r~1_{C#F> zy4J-17YcPGg0fOW{w}wA$CWD>w6yp7)2jzL{BrFi%^#dloAzsev{+GB*7U>;p}&&^ zKF-+6%zLP|^Uj%Wqq43R$3VUxEtdplHLkpAB&qno<(j<%m(Z8bZQY9&xtB25nN)mv zz9=;{)ZpZt=c@!Kgnj!|_UFQvl>aHuuEs4ge!=0j(!S(p@}r8znr$Dar+;2Q-!II; z+xceyolDt=?RU#0$@nNN)~dg`IBlNrHs2Wv+rHVz?_RyuqnYFB*DKXEjn|J~WM`SE z(`{ptKGk~aE|r%Vg6E|F*A$uUmNtD|e@@LIXVM?xzg1`5k0$x&wOcc+x@*?6`}LmX=1hH*?AR&!@{EIFh_BS`w@<4CH&1EV@B31owOO-iTGEPEqdBK;&lX7j z^h32Qc*4b_)o-GF-h96+Am*s-Dd@g|>+{LK5i2xyHQCKcYhb%0CpuXnPe*#+$Cu07 zS7fZesQNMBiu8dN^SRFw{$H&u-*%BLgoB@R28YIRx2;T8P93ano72LBDwR|(@4P6| z9(yvX@wZ#ox?BFu%x5p$6s9Gcuf6dX&JM@rgeE&wtdOQ>5NuJ zZELFK4ym#$&wL!y5)s)G_c5)_$+Y*~oHdad-av_>hnyk+W*$IGevK+$+wfU-kiudE2#7G)fx@2NM@VIP24h% z*Y+_#GA!8>ENSD(KT9*kQ0CT>2a@XMac_^D@j9FSG<>t#l%=9k=L(pN=LgNoUGS+k zocXJksK~~6C3$`KB008qUTc?TE==!v_;C5cmlw~6U(4&BENSvsS50M&uB^w?_YW^b z?S624rro{7Y4dbAVji_S9Jsgl-&fOTNev=*RIVFu@)zUH{0cRYJ1b5OjvP{{oP>CZ->ld;WZ}yhnIaOU8uyHOHSQ`E54Ozq?jQP-iRaswq3CHneGQn)4K!>^r#Kv&leE zv3bFh7XmljBkfzx|I#r(DtuTeD7diypIt;{1-s?da+U_C4cVS@Z@Uv;JS}5b)*2hO z@tPJlOI?B84BslHDK2aWQ>rqWW70VIzWZ(WdB-`|MRWG&NUMgmKQ3NK_`CXA*^^GO z)2m;uI(U5o%cXOzW(Ryj-T$XrXI<3XH}B1TSDyO3!n<4rb8m-DJf83KOtPctoa?_O zewNbRlS4I_R&l>r6l^41Rap1h{_;*<-QA1ds_}BA9ACVT@ndrus~78=Uv-<`#F+1G z_+YjBrQPrSvG3>azIuvZ-n@76>U(@4?q_%mCg#cKE9VNv_60Srsr(b8|8f4`eP1gV z-7gX8T5`GXInxF8NE@f#1#U|wx?Pid)B8iAzh*~fYhK5!gr^Lvrd@iruCU>$S?(GC z4<@Bf$v!vwo}LLjWpl#8XtOxSn@78ZBF|^OpIf}tJYiO~_o>N(Wit)rKV=fAF+rt7@nP1e`^iETX>wdER5ShL;A`l&yu zdFdtQ3A#G{;{Gr5nG{N$P1(~}?%(?$wx)dDpNr3K|JFZbJNZNLjDv?3Y(4(K=R)%B zdm)X%777iFkt+K#&PhjI*0_6%VbyUt-F45tIImcG?ute0wqT!`-$K}HLyeY~ls4`C z^EXfOom~mY z1Uxo1F*ErrKfk}CMSo9Jy@2tL;I9geKR$dt-mxIW=(T<=@2P#uJNIu3;N8J+>AjY~ zPWH@uTEC82MWvpoeeJi|H!Q73|XaBX}sSkYO$3*Jr2Bn126xx=r(B zZ1sna(`FxD<7vmNZFeiypdg3+ZGCRAR)v3R)cy}@hgYo^IL&9$AeLyou$+L>rDp`Zd$Eg0##IWp%Sv6`gw7m3u?@in2UQs-?-+pxhrjFMIfO7jgcp zPWv2tD08#sQT_c&qPpqlZ?`{WXe|4BFkbDF*F1yjvK3)M_gEKH{hXA>(D&egyl1Yc ztoG(M&RwD&TAkAM5&L_39X&fM`ZAf^4n!&6?pGF4xlkfo`uga!|JRoM;8`jhvgVlC zlm}&N1sBg=#+yG7r`Rv!7YKUJYS6z4R*p;rPSs?&JJBJjseLi@ z+2>0YXDym1oB6t4jCky58}QTrDF5tQe#3%CvV+4%ufT-xyUaad~mc z^`p%X8jN;ol79|3YE;}1B&N`}f$3S`B$?NM4Whb_2 z{(boA&W@?mCpdbCY<4-Y@@bC8^3)pwU(P2MW*p`0STUvK&E4dl57K9jZhHCkzMP%@ z&j(N30!^QsE}Qh${qvhrYiso#B_|}Mvn9=6y1He4Q*uAvTI5^I` z-2gk<-4%HclzXU&;+b@%y@bly}^IT=)Mwi_uKCKEDTUoi{ z_=#Q0CC}HG&$*`j{JTv|$*TM6?e=*+d$(F}Kh&;Yyuj<9@@?JQd-``-4|!kZoqbQT&Nn>qiq7BZ7s^;ZR#ab@A+8uFXSv(_w~vp&>xFDg z{nH~m9L{dLd-|1j;N2UYs>}Bu{dLVkBVE5+E4Fs)JCFP~?WNNftnk|uE%$D9#itc6 zI=W_&0hV4zF0Y;7^VyWED{`vTVcXc_4r!`#++r3P*RL2Wxi$XHe6e1M`K$>etD@$f zM-vYJIT5_1>Dz-_sb{7t9=*6^OX)=qC2r|w>YWX7!tTb>>2dxyh1B*||9<%I!xE2; z5r-L>V&vAc^vsc+Vac4!Ab4ZrhUxMx(*4VoZA1C5?q9k%aR1}WW|P}~6yIK{C&0Iq zN6cx-;SlR@&2y$1SN~amw=3%->)uC#0biaLOq4R6#rRg|{_3q~7y>qaTp6&#m(6ke z$*|)`Gb`AaE}bN6y;P}rme=d1+HSGzRhhcWKYe0&Z2sgKuln4yUGs_-Gla4nc~zko zmbO*oRdjof?av1XPrf?*CdVpE%X~-0&ita94}T02{#>YUxv(L)_w#9oxocm}TKSMa zV9V9)2TP8vlA5cqF8gS2Nc)VaeWH$wbgoWsS`qg6>}S1M97_xx7bXy+3`&(OuM*WUeCcbYNUWFAkTcepzw@|1FYAKyTQYW8sunDr{jg@QhEg-To!ks3|HluW{w)0Pp<2JX z;>SMjn;$vvURe_q%l=`@)|7)XZkh9LdahLzkC=Q&dG8k1TuI{{zU?wh4kr%IVpK`5 zJ8^o|mL1Z*`6doap9}2V8It(s<+*DY?c>?EI5Tosf3MoxA^Lqgzs9A@^Y5*0af#y< zK6Byul|S2;|NT{?u=LLDPDb{p@AGVzpUiZ4z}B==uG!)7YsXIs9onaoDyFZ}KfEVE z-ip09QhuY#5!tsE>o`_jQi?Gj>!<>@}UDjb`*9!FIFMOTlwBklj%d*Bj z%T}zI+N$<-N0l?v)$Qza`6V?s=}0k!m`%}VFKOBOtF(HW`ai9+tK6k?=59;XDqSX6 z<90bB{Z^*BlH$96*E0;KNNOy<{XJYea^>zG(-qkE(wnrC zt6r_y@v{HvlTB`c3d|x^g)RXie;(fW!Xux(Z+-li59Kr1*afwn`IbJ7k&wT!<=v%LCzS+1$v7T^jQolYCC6 zc6{IMr11S~PrSp#^ESz+w`ff3ty;;b9JDM&fRkV7f6HNWW52?S0@to^3N5lbGuuLf z<;~%;4{Qy9v&&?qHAfoj%LN;^n!3*7O*alPD708|aFXpDmGZkQ zf~KEYnxQAbmd+tGaca1gK)_z>9jv*{v-%^}rrbI%rrENWZ^hR1MH*9cZ!tbUqcHFC z{(I3`3oPP4Ihg+7D$usvxo3Apy;{ocMI2&VGF+#`?Fx)}&?RHEYR(*%+^?C^A*WrI z_J(GiJ$I+<%z3dFJthnRD_>OB9%KFe*>7r-R$}+vN{)5^Ry^3`@}Q;g^VcG_b$Ms6 z-!a>>Y1U(Armh)cp)VB~ZhEbWYZmLB(^Syu)}FmLb)x1Oo1-oUAOEbK_)Ly3tM^O( zOy>zk%`u|leJyk1&z8CUWN`DYJG(>k!@l;7#=(-8E7o5+VUfexkyv;ty-YZ7LOR>OTUvsv zviqkR%>BEf`^CrOU!-QRzTVJt>52E}ht?cwn_h>xRUUOYZeSCo_BF#e`$euyu9b4~-HpPtbC#q#SsdSduxT#KtHvd1l`c0p{Pyl}`Fyf#Zqlj4(;03`cx_QU%PoAN z{|$q!pG3S!_`aiUk`?wdi&Wn_edy_6f*32Xxra`n&Q9 zqtSsQ7G9Fe4tJEyEV8`8{_gEItF05lLb$SImffq{74af6Rd7*~S&2aFrlk!cEukT^ z4R@&oPjFA!Yr^tKiEk2P9mhuHWF^#vua)~T^V-g@CLUMH^8b6*Pmox<@!D|+p}onO|v z*8V)XvMND+>R&7AUWrdxH`u>Qg_KTwA>7EQzI2ZchuT}KTiX8Dj-OxXxteoAqrgqI zi5?LVXD5FPs$Y8lXn2m0`_CoIOr}r&vuA!ZpT1f2i)-?lqbKqt%%ADc%j-n0vUA?n4!zlM znEP}>)8*4|UrJ74Q@Ad7>s|5o`)_icWRG0jD16p_M$xJ|g=f6~U-x`oK5N&aZ32^~ z&v)3gHU4)0pNpI3Rmz@ef4l9uQByJN$KyM%N3LI)c5vg)^k(*w8+=8}cP0BfK1YkYox1Q2&ASViF>3{NS02$@m?E&e`_tqb@!o|FjD0CnuKl*T z*mqT&ho##lmec(z7i*f>r^gwwH?B5(c%oJ1H{C?oH0Ar9<)_`>WiIV0-RisG=EKJ> zM}Dq&Ff-Qra`tVF9R9ghOTP;E=Jr-?G&c=Qi*(FPZOJ@q-4_w2|GwnK@5cs?5AV9RT3@vgZH* literal 0 HcmV?d00001 diff --git a/tests/data/arj_m2.bin b/tests/data/arj_m2.bin new file mode 100644 index 0000000000000000000000000000000000000000..ea670174b3a70eb8ae9f7b2b66165b6f3620de6e GIT binary patch literal 55721 zcmb2T&@yYg*`2AcbFT*N=e)7(sn8nL`CD&TMcq1+mYtiDo3`s@@)JRZNrp^}9~d^b z+gW^`^S=6r%CgVK<+Wu>(;ozM6F_~VKR{g1oeef#G7 z{_MN&Wi@t^`{irymp^{@^^g1an{UqEoxS~``JZ3=FB$CrQx>`G>+h=neDBWp+}wX& z@Xhwp$%(6G?lb;T5!x1?yY;ec^15A{FPpu5Kl{*J)5z4Y%-P&&m;HomHFwwC2rV`7 z&Ffshnuq`9!+p6SckHu2EPGd%9lhpe5ElQ*(mtJ(Q>g>L)t;f*)%U7s&}Qzzx~?(hv`pCMaOT$+A3_sYGh zZPhsv$9{fTbz5K7qTr|6dkgQfmB+QKUhmFd@<{V~+R4l3&$g{DdwI3_g?rtr{(~*| zzrVIyH|=u$)YS@eEbLytS~R;aTlU7|#p|SA$-X{k_xH;6n8Uwq>Z;4GyZP1SvOAt@ zxZQHae_w9#MXzTi!M?fc&99jxS6#LKaC_4#TS+$0B}Ln1vVCrAFRMPLY-u0!Pkq0i zRciSA)AK_fv%It2khkNH-r=CPKVtLlGw)wKS^C&^_q?Mw*$QKMJ{(_k)%W#|NYmdL zi)L#}=;hB_wL#{!lFM;#cK!68EAOR3OTPKe+wHbtlTfMI)N=llTb2p9{Z9M0cfS0I zylp$*eVmiXyj+5J*_S@Pmn&Aa-S|9i7f(Bj$N znmd24Cf1t1;1ImMDvO={qREYamTf1`nH6M;7C-cN_qkko+hVR(ii9m!w%dubb`2A6 zFW=R;==tOG^K*~7i`VWf zYYOha-I6VG%}?-G)nB=Jb;-wdv=8h136&I8KYRD~?Z3&TXFtDw_w{$$+dtLI-u_;8 z_U$k7pt#5Ds@b>F}bLXDfe6{6Uj#x;=9}BsyD^gZY zqZ{>V5@XDI)0SjudY(U@`$MJ8TE*;3GV`o$(VOSbYT6~-qO#jpf5N6$yson|?{15k zm2ug7d0*l&k=ItbdAoABk5#cf{;_S{X9+Z$=Wj!nz?=vU-Y&i(a$8Dq9%6Yww$Bi(hh1Fl@-&IwRl5&ic~Z8FzJ;N^-1J zej+kO%&6Ju$>z!ZRhP4OSBE_I)sde1EAgty{nGIGW)(ZmQ27;yl=)__6SgnWY_?R6 zF6FeIyM2$%ACs90N|Pqv+-oX*>2^}(o$!zsH(jisT>Q9jrH$p!wyV5bOP9(=_!r%r zD;gg0GdA#BMO5UGQ%9_}1zvysE4Y5Cfz*t|$?sG@zmqgh{qRJra^BjNrw+=R1uy%! zC|-H}4B61ydw&jRm&E36m@INkv+km_@}}zd%lf@vnA@8c{|MUXUY~z_{lo7a{#F0% z{_QW1-@JM0mc6(6mpDY2Ypp(Zig&?5mA#HTo(F4Q-^}}nWAhE}nO<>AB@BXM^Nu!& z$#A4D*y)paUTTsrZ!PD^hq=<1IpYTeZ3#^l9oJQzIjrM-I_OQ;Str02c%1XB&}lHxlq-4&)$Vy_r%$K zR2W_w`X-+j<>P!}tnsL>sxAG@1*OPK=L1`+N@aNVKYzxvUtsGCnV{3#UgZ1`e`X?+ zI{Wl>n@7wSCp_7?CuO{<@+-n4wzLqC=2w< zez`OG(22%=3s>!>dk#N69B|~{D<`9Dzn2_`rcMet&{igwk>M2owDq=8T5k2}DH%W9 z9al-ey;UXW$D1PXT54ZqahpPu3}!G!1Kd*63G$CdBQ?GX>>JbY@?(+~Ocj!d!G z7JWx~$>Cf!J?>@SqtmAT+QgVCxtiPU*V*TfUcYSiPXF}WPxIv07rv~?8<$>NFShVT zRo(0;;!qYbxYU%XVdt<$-;@N0<38m~4yrY(sRsZI#_&MtX zB_9|H ztJM6^+{^X1X1)%NylWm2AFw*qPoVzX(&F~};xQ7_k90~uyj=cFkH!=kHjb_dRp$%VQhUm{*Uab_PzoelzRvnd{0wR<_EXeC)9|uA!+m-*jhN zR@RnI*Ypj$R`akudAaJ#@^NIf4ZIX;!6%PbIT6`0Jelv9PD@*ZM zC#!`Mg+azmGbF`~39s^iWasnf}&C+I{cax90UthE5@}!h{gGJ7T?G_5hC4Llde=^zr zwCS%~rd;uH^J7I?|NJ?(&4+1od8+t=wkbx7lumZYvUxJ7aRjw>F4w=k;82rg-~aUM zjK3yjR@TJouxyv`UoQ~Dwxp&8ub)KR3ToLcQl5M5S zmA!v5OGWM69(S(e-z>S3g^O2c+)vlNcVpX&%xm>xeY2W+rnIe$S74Ald)#39;jgtV zQW=~)-ySfPdn@0nH@wG^px7pM`1b^sm;6bI=Dk~=EV{jU%Ix;tn&$lFdfi`+9PzHX z&hmN5wb*$nB6A(S{dmZ#$j~*<@C!Ro1$1{tHbJaF5+0}$ z3avVfHxAsCZTdQ8(Y`7f{?;p{S6xLfPg03(NPF1HnOT2F(tZk4`nSmRI*W$9Sw+|V zrW#p_$Sa-XNVu|X+cgOZ#ngTO{WWggi%XjMIrvxl@*c(X7PfLP&g;2p(aC0l>Gb+%FBMU!+!gG*AA1 zt-73*hi9{LyN74t^#=mWl9M|YcCDOdZFkA6(PpBRmhe%@-D}RTXgp`~@XFhRFRcVV zTs)n4=;=*erLve$Osi&HJ0KW(#=xYcF#G3)>92L01g1wPgdIE;&NA=Ztu4wQ+9u7p zGS6+BC9m6|Lk2DVeSaL9_{1M^%wzIR;V(#<5?tUbo4ECACwswcj|o@OGOhNoCO zGj3ftR#%rS81(Yx?#2y!9goMCYede_Ui&<`==Nfb3py*Nm@v)eaygXVyF;%lL#mSd zxrWDW7X7Vhe?{J9c9%?0VA!<9n8m4hlD5|M4g9JB>GtYuJLP#^e0ceJ>5v~(jzUD(U|8$!(+ZMG%UP$3_c%b%3#YTI-fci8~Nwrl)(mRYadt^0UmtErZ zX5!!4#9w(iKJ8du@2tJduO8|ZNO$?Z`>?g%bK6d}&)=6XZS%i0)9#70$oeR)H?v+Q ztdNx4%W3_9TTO9|{gQkC&P~=i^1EQQ z+vUx-nYSCbG8xQV=U!VfE%4X z)3kc;-rBRwU2S{LSfm|3dujd;cN@R`Cp*gW@*d9mcvfttQ<_hZr0^NmKa4GveQ*12 zUVfPzt9YR0sU+L{Wak50e&n%wo{KWt zypNRUe4sHmb?1sC>$^G3RhkRT7i?O7)NM|(l*LN}6N4N79S?He>-@HG-M^W>$})U~ z3l9I5Wzb?QG7{J^=~>X3MRy*aD9u>vZMyB7QHqX5?)7CsV#>cII1X-P4isof-kj2R z-dXYGi7e%n4^3v5G;ChGE0K}Qe@e?W?mRzEn0~!wSdwMNKN3tyJz# z;ar)sL-YRO?Yji|8 zKisZbsGsRkm}yWKru^7*+wU^LWi|6=Gv=2r&{mRPR(kr7#hEpC=IyiW3;4S;>s5Z{ z2|X?@lh2c#Ry_ack#vs1UT(3XtG4<7KxE}3}M?!E6HrT^y+ z1ntW4Z+E{MsKV>#p=QB9x1eTL`kybgJo*}Kvm@-jo8_oA8)z>u{?f8`iL&j zlBpI~#p9}?%Az+V$t=rIe!akMxx`Y7AeI8*W2(D7*>0Na<`$SgKwSSpX zVP8IfmVK4h|G#o7FVpRk`?r@`e$i4iX=koG5%%TAwvGckl6PI0A{uD^?TR%FCT-D8JEXCHb(G&qhX^^>t8)uvxN|b2%{Dw!oAvfV zzd~r+riuxj&7u;n^Mr!Fak98f$u;7a)VwEoX^E55MyZXHasw9cX%pFM_FdC&meYmz zPOk*-3i{s4bJ{+^?UUxc1IlMkOy{~d@$>JZ)$-zj+qLJoyiiCuHp6CX{H27Df)i)n zWbBnIX!MTiWQ*M{)%bb~Mky;ZaakfwQy!83%MVz_+6avKaCs>}o|2XPe zgUo9G7a`oeshrR4cPQSt^v;%L)~e3O!Tt`Oa-t=fEn7RCCd8GkytF3o7ynGgY+379 zPa|4uH8Yy3ESl%*nNn z^XA*sEquE2&AO&d3wD->@zuA?t2~{w&GQtGO?AGolPKe=w)y8DeMzmImMJ1zwU_Z7 zn=Mm*XZjx3$x1zwC42-wD(`xyFW7LXac6zSE6E!387++&vb-LWJ^Xw+lO3AoYD{zH z>0x}Xa3QWRTy*Pc)+1BiWSXA!UO4l*`+{9DokA>g9Sye@erlUhC7)5IwXWfP9lu2} zS#JcpX05o}xKwt7!AH46so$$awn(hJ-n2`DXXcwPXGOgG4LQ24mR0>^6;{7CPsQZN zv92#_x+_+0>FQPT36pZSmS|pfuhmD?WMxz2zOAO#6Pd#f>ZBcXaBEX%GI>}%RrIyc zzWZ%E-#<0k+Otwr zG`L`~(cTAVZ(Nx%eWyzjyV1mx+V>jYobz{{$?niI+dATyiiu|H#cy#Mo0ES$`~7$C z<=VS@7www8`RV_-^>-WP?w#A;v6SOa-JkgnTjn!V{UWuLyvy3l6!g}qKE16a!pf0sY+p3#T`i3jPyEX>cQd=3bv>M6 z7;wB(x@Xy?Mdyv?zkibLUjIbAC`|8Zhhk^dtxFF!O>`3c)?qp01Vfd{%9UGFoW3u6 zl3*xsd-@i}>%XKd+3HrGwkUUe74*H=`=^ATRG7$<(BM5)60cSMILqG`J@0z$h=Ny9 zme7`$@{Ykx?Ms*MWXU%3tU6l-b+2%7DZqqXRz9y|p?s>f0%6UiiO8qjDzfUZiSJ|2o^w803uj=Z3 z?)4=-R;s7kQ@l8?*&g=ftz%fM92=rIvyPdU!{>)@s9`W){!zIyX06b~rAi?&+5h*= zXJ~!epIfkdtL2HrvpS!qnJ6wZ^PBDx$Ug0DFGujP(6weZ$Z;RinVA9Z$LxCj8mZlpJa|ZPUWE#JAr}y*U&19$PWh zIZ|xH`;6W%t8QJ5U~`Q-zwz;}X;)a=a#tRk|IwRERy;{L=2XPm+7`U!zN4db zoXo9%Av3xTzPy!Je&TD{+t(Y9rUm7iEWaSVG`qEIo4oVhcXA&^{DOiiV#5nFmbkqC zrmkV@w9qDm;aZ5m*KZTw%!tp666Wu|aHyXpM1D`NN8g&2Qf<;M8wy2?1hxjYq?_cg zD!i6-YNg9pFHV)*4nOCa#>v{R9L}5yE?sgY;K9wwv(K0t3eD-O2%fw%Nd>#A)HFZ?WMc+4u>ztEp^MuOdj51$ehY9|#-MfA?D zkH5AxKVM+Vl8sfTMNX;a7yS-a`gE`PdU4}SKhvMx&Q1rd)NNkGInOjQ)H>-G^`t%P zv1{79IaA^V7tAg3f0E|Jwbh?ZvVPgM)YeyCDaSV*bI397yu9Xsufs!czLL56(;2?5 z(qY~3_LN^%bWT;E;=gYe9^Yk7RBqc*&FXQqsaewQ*1YV4&YIHRZ|~OdEL#6PDZP-KueD9S^~=(iPCIJ9U;SlU5RmePnfdtpEQRi;y}vk|->Py;b}n7M zUAE!2y5ExzVn<7g3`>&F*WEf=)sW(~$7%LXK6B{?)dg&GXL~yCU@|pcAYW_N&2n~D z2dmQ|u9n69vfoZMi=Vq%Cww>ft=FIZecX@SqH?~~>+H4kZ=0^MshBdyQE&5EmRyjrQo~pE> ztY z$_D#(o}T_zb$$KES$(nRb4A7Ke|p@X9e27}aamZYqu~@b;j8i2yp+z!_Gb9Rw`9aD zoHU>R@v3h(K1}ZBliYCd=74u&r5DrX}QJKDGGW z{vSslhKtR2V11%>`*QxDUF**rwqN?@0BiNf3;JhDHKsa?O*GY;9lrA8=AY5&f)5L2 z`rHnzm}YS&bt7k%Q(m~uvYp(GM>tKG^tZ%q^i|}(F6QsJ=J>OEjc=2gshRX_=7&DLf=L?jn$L51 z(%miul)s%d?^R>i|0Vv_v#zGI`HC+fWEuW=9wRide%J6 zEerBJ_}C%!Q1^=Ley(Tn>u(%>oE6&2b5f%2_&bSdYQa0Bb<(Vr6+ThxZwm-ZXv=4SBXte9NVEsWHN*&q*xysM>ll`HI`K5A!&B zLT>+m*t{UZyqPt~`j*$L5YhFi+97*{pF|#5;Bz3!R>vSC!QcPmhcQ&-)di- zTa0Z}Z`_FxJuJo@7H~ATYNh6r_sc3w=gxBp$@@O>Cofz14n2qMqHAue73^(1k}J2) zyo5a?b5l+=)5gnAZTs7^*M`^_-+eLl!>)VV3|>~4)_i@tH(JhQpX&Pd><;l;xrtlE z)t&t)Xe<%2bvd^{L;Ie5?&V4C)VX~@lZ?@&n3R6#?i>^^6j}$G>hS>=3ZaOZJ zyUlN@rL)@Ow28Ug(*m^OJ`~xu{GQP9t0neNN{G4qzk4S8PflH%GU3gdEc<249<&@? z=l7(zY;nbQ0h_|b_jDa4S9X>7T28s$^D*gRYQD<(u%erFXIe^5+>x`JEjhWDPsXrU zILhu=QAn4_&8=s7s?t(|Ztjx4rN72U-%<4Do5a<#*JLpSggz=zF^Ea*qFB?VSSKtQi(9_+%3-&d;h;kXOEEUDQdF2%b+%moZtrPQBsTvf##c zfraeG_ivl;T_U#VW=QLv-M{bLVpsUHpnl~et6x8^_g>Au-X*`yscu7z(_8JMmyfhx zzyD5X{#N!|myd^izcv5K31)raq=mPh29~PF|HwU*ze#LWm`S4Vgq!l*ljpZhn$NT_ z<$mqu*Vi0>zJHzfgfZlz>~Fo`rul`Ro=!h~>wdd)&z#NW{JiI?t%Iv(hd!uveNe=| zXww?cVC5sGMho(+k1H(+?{Yh45Nvp56~km5xsEiU$sdaA&ptlgoU`JWr|cEyo_{A} zU&aaf@cMgK=ovrQ{OosgtMAj<3Y#mWt}^aC9B=$^mgwUJhvw~e3tRRecHzDcVHHI! zUnAp>H+O`TY8|>>&(D!oV_&S~S8Nou?W4kWDSz%zv!AnFuN?24zp%(#%_jb~Mr2Sr zcbrSr%Z>$t-`1-vdSUDO>`b?S<)!lrGoQ`3GP!-zch>!I*{h*^n~wyPu0E}?P0M}# zgRU!2cO9-th@DgNchQY5o-;=i?=?+M$XU4T)l(OBjeAo6W}o6SuDo>juk%gYscfBJ zPVGGOt>nFyl4xSv^~;=d)qYQt@zB{^QM2iwgj(lMRa9do{VE{&g_ z|G3|yTX>1&%n!F>Y@C*P21HAqwhWas&)yd2)^teoeRZ(iEI~m9P5#saNw1pJ3TFAg z?am75JidQ!vV`sWt<54yw|agUTu${^T{vr-Fn4A0w3nR6-E!C_$DDBtY0ELbA)C3h zqv4WK^eq(!%M)kLiQLOdjI@>7`9CN{{>}FvTO4gH6Uq(+J74UXEqyq(bDwZbE^q!5 z53kG|#<(LNel31t#?Uy!!`&~E?U+!$^Ai?vb-PbW?aq``j*5EE>~b}RQ6-dL{NwgU{ch7d0d?DbmYa%|HmgiodghS6 z?$gJ<=8Gn*tbM`3^L5HX<*JQd&D=+x+SmM;9r!y>$iGH&*)z~!m>x>saHb!xN_|$*eC}xG0 zlkD~ftL3<_Ouo8eyYJJ68(XW`UgWdQKYZw{W4B1t?spEwQqIz|ju>~voGL%7Q}ENh zRppwQLEz&+#U_P}c{@Xc)J~`Jr%J1P2iYg5n7p6Lxn}pIk_XF=TAM#CYP-0{a$|~c zMc-bL^(uPL`d(EZf9$eiVa&Bp)Ax5uYT{g^l|yU zn?QYR+9JUZ|CQvOfCYKAr_8Hf1Gu-}G1u?_S8Wkh`P1DP>1^t55%r4T~k_ zpYh1Lm#Ft!?#(~$F8WG>UyiF>kLzcFR0ecnFZI{kCX@zZ51`tKd(Q|jpwf5*$w zB_Wjl?e?7$+Znq<_ONx$3hZ7{<>746vPj!TFz4iwmWN_xZ=>%$tvSE4`M`y`$;&U? zUcPvx0;`8N^ZpO=pYEw>?Y?Tht%h~dyRex;dnSKaWiz?h>3E&7Y$0cD6t8A{{2{K- zpQ}Z!yB44Q7L~bb`Ru#dGnJIKy_qvlRZzzCzIW`2eQ_vtRwco38%*TG7|Dujgm%{BZiCM#Rm4AI}dIrrG6f-W6KWU$^5y zVyaR1s#&5Pv)+G@x+1V?#`?=jTjxu6_U+VdT=eqGOB=ne;OB9Zy3DlYWr7rZ4L(k( zwOzW$#3Xc<=ZZtq=k8hG_ISOpi#E{{MW!sStEAvx+jdd7h)mmue#yKA#w!J` zl_ajHEGn>i@lfb~wTxBxv=yB$8E?dHrSz#;e|fLddaG>J^O+jwcj{`kh}`)psC>6y z+5E@x)_Zpk8Gn8Bd;*6{f%u2oQ(pu=YRR~;@Hg$h`0~r~>EF4peBd~BFX4(q-t?v| zHmf=1cct&s%U5!>=L$ZuKEY!7JO!J_E^=Kn{zQrFQCTOo@xx7iLFu+{lD9>+eVkLX zi0{+77sc!s+%wt(wP5n@leD&v<;W-{9Ex*YYx}@+8788+jdZ5LmHkQ$mCJuABERIJ0S zX&sxqfK%#KzbnbF6aLFu?RX=+{&t1vL1R8Uv*`W5y?;O5?#Ov2-PC=dVOG!GX&sMW zX8ioy|9HlQ#((P+0-ya(h+vs5_m{C~hwM+gyFX5PC_9L;etW*u$NSm;cl{|%CvMa` zh8_MhbDGz*;-{@q!Sa_F&*}X;-+6`C{ru_!`N7eNRp-9O@Sl$>kk0ndyPn*7QO1n< zUBL62BM0TyNje-je)V+Y**ncIT2)0RhR(QmFZalMwQDx9Q#F}yRKGWksO-FbElJ?@ zW%RJO8p8yj91 zc$Q9@J-6xXemC!wMsHDx$k=W#EsvbbgTJkBt4L6nd9HSQec2eu)N&suwJ*PK*m z6i_~}xK-$H<*X@^H_vIS#pwtx?TR)3)N*g#w8>Ax&)nP^t!%$w;uMZoegY?*AI2}a zwt3g8^|I%}f3xeZo0xubj?3eHj%SjLH%Fe-%4~k>rCBxaPoV5ewa#^S!eWlu8=n1j zeUc@^-+dZE{;T7XOw)GP_4%GE<@kAJzeru8;hST&8x2}bLe?$P*q-8?7e9gBo8z6y z0UgIVj~X5H1l&Lle&ZiIG}pl$Gc?nbF*Q zs*{C4n+E0FA6R&E^{<49KfdQKC|CdEMf2Ut7SV;g1~qri;n2`EAD!l5=BfRKxN_yjujnSzn)adRfn7o2q$xG|OIA)U?XZ(+{pV!m{rvqv~VX z^iF|wLW)V!TnFas>ut-<;DteyF%+ zckSQ#=eOVd$-c~W&Z1&(+m(MV8hvIx&)2YN+1mBYZ=XJ&Wq4)%ZQstuT|1)R_oc+X zx%Mbx)z_rxtsZXY?W2zd_D^qVSmPTe`I2{a(H7l$H>;Y6-Xn9uK0lmVI9ES-snA7> zFN}w`@1OlSPAqVJpXk@B53?uB)}1;h-uUPC>Gi(zRyUfuALG%?Uinw*#)817CziW? zx*KVgz_|Ql6IWdYN2L#2O~%>N2WQS#Jl)@avhU;S=?hQ&`WdL;`N>1jD=3KR#YgVX zTY0DKne$r2y6oCUv2K-bref`rDl0gIb0xq1?nsnKDod{TRr&tD=_OB-A}D=-sWF^XtlbBTi2_c+0TnsIBtR_d?lr zQT>fV+#3s>UhwDHDri-0+wbPSA~<@|>4-fp2bYv&vYc6vVj(eo?>5CXZvG43{OJ~2 z?6Z+^UFelXx~o_H%{(S@<62mPO6*>rI~wVCTBZw2=0+@Jo0nR)|F}H2!CncD4VO-K z2<_jkD83~5$^S5hY}t%2{|hEQdhUOcuVXSxdfS(Wd7)Lzz01Ax&6$7bOuT6Pzt$$# zYJa}tidno`iHmdMa%OT@mE|5=8Jhb^JK<;9beG=QNyV3qw(eh?VYio=Q(*GyTV{8P zvh%OT)^Tmr{mPIhv>_zev&hJ7@|9_?m#1x**dlO&L5i7K=l$dU|JC>Yf4|uvG%447 z?a94YgS=Kor>pj~AE@>bdv5>Q+zDKlp3?-KxT8 z(HET@Sf{LaT;V=-$H~yNsPKCR_U2C~$GVcy+wamPJSNM%{<#&sR!zGjG{e zeE73u{#u!c^A;=*4$U&QHt$aEirLSQcH-N?K$nW`6-PXNOcJPNnZ4M6O*(2$@sbe7 zokx{_9y4@z)n381Zc()7t=ld4U#{X4f6u`3{w#j8Z;x3sn|spZ1EmW2?>MX4dHmQr zLNs3_D*tD_*K_1fNx&sTQL2xt#@vn$QU+D2SJ zZp-sS%Fkwp>%LU}{AIZ>+ua?WOgf(rnQlt?)hF=jvD2D2r>AQ3TrO(dVN-N??t{q| zVXV^Czt6|iHtdV5-O|GmfBRNewUq8p#~Z7J?}nP5xZk#Aea`Ng+n-GT!DaerY2@^_ zf}=LGtU0EZoYju33BPA*+sBm2w~<#aaf{Qc$$XNrwhtM88ydHA9rOO;p>q1d@0w#~ zQV}Lv=TcZArzQo>_Ft5-LwH|b?6lhbN?U^eeXsn^F}Ej~cmDDtiOIIBZ`bS-n|;3U zd)*TM+wIRjXcq1LuRll3Kv~+(u8V8^k3w?^dmDF|^SATeUa$T6EP_K_wx};~(cd5Y z>Yo~@xLvrq{`=Hu-um=S=F8vxt&QU@_*o;-&YQ5X)aA*%|F;gxEj0U4$x^uB+_b}A z3_eW%r*te{y}ADGH@gYntL~aOmY>c|N?@~z<4>&a7O($xbi%)?J}1}T#&7;D*pU;BX9eMyNsXr#ia$b-~W}o@Or@|=11l=rqAbCL|?tTocZqq8{y}F zzOPI;eAxf8nv+SJ*YOAcOjL62pZ{K>p7}q2n@U{Yogek_jSv3ah_XNXSN<{gGy(fd zxs6fZf8|U37dyLudn2dI<<-Aym<7|H|62F=xAoLKds)r+g|U-Tw&=-Rd{t*u^y0~r zE3v*dN6x7i6=&5PUw-`fZ;#9eS1nUtxUUM_ed*Lx(@zd=CC^{BRJoYmS=J?DEBmjc z=Dz>x+do@>m+CB9d*r+b$E1BO`WmrM?>-T~5VI>_-`aC6X^5+TP^Y5{p z(`=czHpWea>CxLCeKKBccQeI4Nl)o4IoI*f>S|u}i;zMFKG}6Q_vyyiG^i__He2%N zjZ~~mYFqf*Lop|ll;c+R9}TG95gfZGh)YA+`qj;J+ZgGl{}&Hgs4gv9D84=7#%rF1 zCmDXl_|96=_T48ub&8vpa`5rX8a~eNoo61hWHC^E-L`Mb*A;g^r2Tgb-Lz4%j;AlV zdA|69IeX_yFeJs4F8=!VDsyXc@fUyf;{taByEghAm3@$%@2uR~#a9tyyZ^*ONr4JC zVIxVu@asl*cVE~ms9P@4ano0RPR6&jDfe0mN*rCzU)&{gS0af`{NvNK435SFa%q;z zKFp`0uNbuW?{=4wNtiKXhGN9D4zsoMW)voh&VJVRzRE8_WTS@Ye49)Y+Y>!2GM?B3 zue%`Zey5;d*;2(7Hd7X**06DElqXKjeay0K?#5&DEWU44^+>c&eiPHX-Z>)WduG`V z8>3ez+iz!t2LFE5<6*D!d8h14y}ZIip`Z5M`aTg^HPN=u;ssnc&&ytx>@p)^L4N3` zP~j^(f(_;vMOo+%(IG)S?)qL?f#r9#eTjT5A2V2FsXGOIy zwf`5adsRaFNUh@HSt$Z1Upg=Cd&hT#(P!Cak+~~7PhVpzUd1`rM*WW5veYdn8*8#Q zzgoQF__R(Qo~`@_Q#%7*O_ARgo7Q}pCCOpIzdAF48(ACdf5vWE;_C22=ws29O~sws z)-A~=CSQo(Sfd~$X12*j^2u}Y7im+w(%#LCvX*=qyJRWnJg;Am53G?mEV|f#U3sig zaU;ugNs~(q2X1REk$o6(X_swC^^EBfE40iugam}$agdr>r>4vsX0Eb>;rgx<-1m5U z#l(6x-RN#uwA1YC^Bc;ET&cBRCnKsq96OZrrIu^ zE#mAsOH}xUcSgw!kE7wt3Gcd7Uf1r-bTBEowo}w6>oaq`f5Eyb1^-X@2q%a}#slp!xPpg*Bc`9o2Ui}sd{VX>5$lgW& zqC0L`F)(Ev_&C|~VE>!{GkrEZotmL9&@}6^|CVd3EgvtnNV#CACUSdqTD_OUR^Xv*p&Tkzu+aE6>c87`ZrdTa@f!D-g!;zU2PoiAFG`*F$A%*E}>Y1y7xG4&76 z+HF#rH|K?_!r%MlYWnf|lTV&~+h3cvSox{%W7ki$lTYRR+91C7;`=4#W~YBFes=7P zBxB&G>tVZ`tV^QKTNu@+=qemwoZ9u7DYLA|=-RT9o6biHqniEHx>vh+oY&1fa4W?B z#vMg3fthL1Ke+lux=a{eu1K1mcO&xLbsPW0cT#IDS24ay^!-qlE&Fg~Z}{JXYQ+x& zvfWIJw{1<~i=N`=-?yTC#jOwd#}9r>zrAg0`J)S#9#t>@>`f2}i?Me7*u7oxjh{Z_ zk`rRPPgQuljmbDvYgzr{)`P>m>U*15MZ%^s@AfU2J^6rCV9R5V;G{=(Hawd;Z$6Q3 zo|4VCtwXu}^ z967%4RQK^ax0L&JCzM=F*MaW&CyXA`RIaJdAI@6j#;%GCOBr*z4EZq55Yx*ZLQ8jHExA zXl$Q)Ca#w?@2HB@ImL6XdNE`h#+SLV^f=~zv%h`&SL3(N zhYw=*I$nCW^r0_HMnO8ay}YPbPv;rI_RpK_n7vP3ZsyqJ7FQ{>Ch*$R4`-E(<}cS_ zIrDw%w=ajYQ}%5%knwD6Kz*OWi-7F*wSxgpb?mPwZli3aQU}=Tc6dir&gCyKs6~ z=gOHJVq!LCv9;$z*D9B}GkBU@oSVk0uvBj6`A3uXg~gU??i7nXT6OsGnjewI$}4_E znypTrQZ@1Y6`h5jW5qO>F02e!Dl=YkV9UAwyM9Mw+T*6gc;4dLeYGh1!pCn%BEJ-{ z{dyysy=s=_v4!{do?Nr-M)2Bn=gwW8Tkbw+I?i+K{j4~<`_~-=zjzB;WIXz##k}z2 z*WhWoc12%beemvG`F5ozi^H$Wt8OklUv8W!!1G&L{g_n}Ye2iV2-9x;3(}Ws<+&Fg zvR=#l_;sSnuk0X&z5DK(r8Q1^%iN)Ap7{TX`LhRK4qf+pQ)Bq{#-w@|=@{PRO6S-!g(B`}lug!AmH#)r~6Z~R`zUaR1rcf}-q+s}W` z_AL{*mONvU{Iae%b)IXTj;+4zcg;#ZOG}gn9@#ak_SN}pmj;EMR(X?T!uRJzc5W5Y z_3;e+AguG!z;8?Q;q5!y1*1fpRlQ%N2t5zHCU-k;{|_N)BiDtJhxhO~b8=f9;NDee z@-OIQqm+=mx4zC<;e!I{?O*JkxHfr5NiBcxqi?)jf#HXsRpguV3g>$#+>3lO^lL-V1+HJLCKv-%{~jEyM4uBGbiFoYGmB39Ciru6XbEe=S?}{*TWb#?LIHnRkvb6=|*E=j~_OZnZm@^EGkm?I)C={ zXZO^^?AEQRm+~`e4?Wv`iRHb>*I76B`b0T39@YLIpWYkvR=QZ_Q^4ymqxK(9^?asG zd}CiV>FUjOY{w2OTB=PwDdQY-X$IGRt<_$OCDl!qb+R4ro*b#AkBrxcL^I8_b@wp5?_p6Sug3Li z#`LJArR~ex7UZp-tmGqT z|C}bXy(xbF9XnhddDNDxuT|ByTX$Mz&a5jQ&lV-ENKLamA$;=Yw4OMLeQMc%a`w&O z$;(cCCF)iyy)ERX%F#8(-oF=J-o@^hTYe$USYbQw5|<-?1?{Z2EZM-m*N$U}_c5ER zW#+f?3N}AdWxhT~{FP&o%Y_j0O*$2PC-fQPTD^b0mu9=8u~DStitlq%Nq5!RMLeN5 zr)FiH`oT4Gty%Xj=Lt)-Z@*t+|5i$+<%q|RO@fnT?&$v3Si0kKljurLtyz50`GV_| zRb?&<_ix(`KpVH^lnjmE8XJgp9+rW3e+FpeSuD3NuGRt~=dUXtDxKl~apSBzJG`xBZU^+vkT=wNBfI~lNv?8h$DO0?7P~(@tmo!2p!(QZX<8;1f*RuM6hMb6w64y%! zU*!j1Qrq07<-~Y@-Y0c)ZnJ>=As4P?i&k8iVsMvh%gx6pCw%+XcaKfn&-Hl#^TNhN z^TMyk=2xpZ{;XKVmstACX1SQpyyibgSpHea&vWkHFvn1Ed%*8`6O#BCzVY9;_-on| zqI~ODrp(QLtM&sE)X%6YR@}eJz@7i#?enWOAr^rZt^yBF9p;u?50Q4uJ2%Z|U=UD8(Yrh>S=<8JWU0SHSeZEp*neQ*1xKk`WWm>7u0*4qh_s?%**n7oK(fj4$R=?>}?|<1i z>0fP7(bfqc_6hFd{xa9jVGjEn8Q*Wx9W_mj-z?8GwKsZhD%U9Z${-o>VND40czq)C$@Bjbc1!fNEKK_Sxj~G7TZKZjM$5d)7RBCKYH8=&D((f8 z?pSwWzPm{E%m*Q}dE#B|Ha6{HVAcG2kXw!8RNCv8N4HrVI;=E3Y4L9p)AuVUpA$5h z_v6ibyR8y8UOeEO_@ReQx+f&z@X0SfUatBm;o}l_@Z!%&TATLmI)3<2WTRjBp(!y3 zL@ql{dUlul+-IwE3+K;{s7Uz0-?zT}v}cK@i#ngx!>@YZp66tL-Y8?hkZrp8`)mdg zAHG#O_gWLQGQ(_U2>no7zVe3QeTi33{1$dbTsSbzr)$YFuXX%|vT1qK+Zdf>TNbQH zd*QT5!TdGX1JnCbMyaBT8AiT~DqerRx8(bw6V+$MZ*;C)`LEs2|CgHWr`xM!!t*-+ z8lBp2a$v>xIrT3Kb9kip*QlO9()4!c3-*U+G`Iy%JIYxvcYC|4sjzI9VTZ!ijH5;q z&wQ2={=lKybHc4}nrF_@e*psNYPF7zfh@wGqLrmCp80<9Pwu{dcV=_W{I%uix+yu_ zU;EkKTsWD-Q;ewbgh3H_*dFJFq`P;krV@8yf{o;BsvbMxDtyYY6Z z>9j-U{GYS@Or3S5CiAbj8949nF@MvU-RCOBk4}Cno3v&@amo5KnQN6+FK~BI*?u-Y zuIqn;lhfAFQx91z<(=HQ7ASY+PMV|2q@mT;eXH@{KkvIHA!q9X{SMBUysTM(FI(hr zT7uDw`|tI%{;W8x*T3>^^xVZyeV$h7MTC{_p7-jawdYJTQH7wSuiw;GKNHH`^YO~r zp^q!pUEs8P$suBAu~L{JEWM6tqfYQOABi6?+|Ol3PYjltv}23f zyxM2$?)vR(4~!9G4}R|d#(DS5aw&n|t`8o$c+VF1&e7cO1v zTjVy2wlRcC?fig$Uu5_MR@H8m2;MASCmikz){CfY_=l>?} zk+>axH0Fk<__3$jM+832nOAq&rL)ag@%KXq-m_aT7kYi$JViBqkKdCgvt{;8ZJ2R! zDQ}U4oMyn3zT39<4L?<#<#yKK{mj`Elb9|S!VVdK&o0m;1P8|Ahp+3cA zvzG7sWPOIRfZp0CPUhdY=NwbHTC+W?SNEDo&x^RWpt^9r(?geQ569SNcC}?=?Q1V4~j7`sJ9w z<$XICHS>BEuC7m;WS=F_QFNbqOV5jkK0yB~mV(XHj-DRL<{@o}bFB<#6?7 z-nq9)BIk{Bd36m+Z}-;)_G~Gl(5u+`!FXcXr`~Z>w(kOeu_EkSJO- zZP~<9S@m-(XSqihEY)Dyx=>zl#qO5Gn9{}GTM(@G=ji80YDp6zt~R=p&CVkE~t@>D|EVj-|eaweNiozBGY&DFaGh+?c-0?sPKD_jAu4Z zxzHG6wNFK7+5Fuqu{*uvY$HnoJK7YI!X`5W#|Iwrl;=6$FUngH$F930Ubv$>_(R{3 zv*i&@EOtnMdOyl z$dyG@xb9fBb~5*)t`dp;egEH9x%%0k)e$=R!b#OWkxei4LXyGh>Ct_k+V(R|4HVnP zUMp(c>$o95K3B8HXS!#j*o!K!7WU$n4-Xdg%Xm4L?uy8|Vz{8=h(a&>tgkoSUrN>Q zdbhN}{bWo%$8E<$+rH+lVPs(6*Kk9!IrZHKqXW_>i??`~o!t=Y;<;HN*3g|K>@bMVU@r2zc{m ze$Zpb2SHEsE6=wbSi_KfwN!2O4WW;m`7eS?d38Tmw_Ox?9O@9U>&@J^zJkFI!t-}c zlPh8Q5?qjIX{M^%=x|%PUpi9pfZz{)frc`HyYkYL#40tcT_Vvvze`*Z^FZ{vs=94 zZQPAw|D4@$cJb8JzRDK8uhuF}Jk}`Jlq20A_tN9&J>85&t)A~hIo93^SF7OhDqXwa z`T0OrdBskS6K$N#^HQ{OIqhF<`Ry#O@o`aP;kHEwRkm{-2x7J}`Et>hsgti_{)MX+ z_8X$bUD$XEChnT%l)d?~-IL>=boPqrWC|_`QWICr3vK$vsPs+LQq2GLCB(3v$lY@!I9B!>M)eZPxOKPlMhpcv4w(@;aZA^VHo|4>?zD3i=p! z=gVprKchtFFPRjbi)G`;|?#j1V zGV6lfU+n;e74~;eznOKpEK|J2Y1Nyxg@L>O$#JYza9KX7_08Pgi!9q+KQK$nXkD%h zi70kDY(^e{r59P z8eTB&6jFIME0TG8vS`ru%MwBo7w$8=1`Ey&Z>w8aGQ~Z5Lc46Vb=gfO)=w#lncRkH ziKbn%YgVuFNcfnu&*6Av$q$p`|NZ)Ib>1q_O*{LZ_n6?$E#(^15{@lvmDJu5eq8y) z^Z#pwT709jX9-?mxb=7Ijek;Fn&+oX{MMu8v*B=O-&Lgtg463xb!YxQ(pW#=r?sep zJ@`&S{HO9og%$ie_Vu3MG*wL2d~V_N_5Kof^E6G%e=hRno3?D(^Y-6*J+khL*B`D) z)R`96yH9Jc?%7hu^?N$DoHd(zNdBDlbamycelt#7ab52(`r&d?~&HA$+dmUGc@d-n%@YdEBZytLiFXHER|Kt!pr zumAlFgA=Dcm#FVq`_)&j)Mxj@gQs77QWH>g-BPCY;fv|Ue;sK*SVfd?U7oGA=uU{K z+wMIkEAQ;llw5H9q=ez#ix!jr9AOo8n`4qK|9@#_+l`*u#}DST%eGB8bvpCd#@o6~ z(u(@wT(i%V=l}jKCv>q+SEu9N6dR65_JNaL+`laDyCr6V-m&RQp5Djg0;fK@c>G7R z6Hm^D){C3(RVGhz+t9o=dLifPS`EP_X7hP#re0P3wEd-dmakCYVxRiM3Ol+L`m?qC zUdyV@yQ(=`qi(fy+|*QK|MC)cB|M&8et>l6W8;qC_zW7>uW6!?z`HL9-{@hqwbMJos z^=C(){Hr^^Uwrb}XU88TX(jtFF5|abF~3jm>u=GM>gTgv1Mgj0zD_2csjP-k{LjAq zX8PgRpC0c%e_HPKwY1xxi~i2|BmeeH`u&MH0)Q zn(x#8**q>jn!M6-!lDmiIi+S5KP>*FzWX-q^N!z}d`=Q2e`!^11wjpy4OUM3;`HrGU0@#OJeIi|mN zY%1ZN$kd?iz9HFU`NiINyQjk6R1-Y2-m39T_nmIj{C#iBl&e!NrEp}nzV9ljO;1-g z41Q5}w{ga$Uuh+4!W`dh@JxTd;mb*Dzq=C5YdQ^XbToCatU99VV`hIpKT7qloU&W3 z&D+%v+1;`%|G7B(m)*{g+Yqp*ZDPs^&zjP7r)IxLum7x`^wX)YnPpiZ7pqKc)m^#r zE7QeD?Wc)@8-7YzRT_BJ&S9U zB)-&`Wt{pT(0+Q2n}n+3uKL7IlE!ww|efs;tM8yyj^@jSy;mGl?ChN{2wm^b&?(> zi64t`==}1;L-BS)?U&6LG?m(o%DsHltu`?p?CweMhEA2<8v;R40%lW7xeHr=vI zQZ?jqGx#N;>f3S9HHAOgXi;wJF5m6Wy!$M_%6W&>e)uZDn&nchFvFnjNvL_(RiwVn^Ub%P`IpE4@(v*L&_(m?av7T%MX!*tcNofva-- zB?l)hz;k<{pGhh<@`@mIDa5_Qbl38@LYq5Y7?2{4%|$OdDP?*%VB&` zdB2Eyt-j#&d70ub{mpJ0)m-lSGU?Q-d#xXDT)B|B_@5Nh42~|VX7iAnKPEIilMXAs z|J};t@>Szk4^RC#ckk)lh~(!h%%^(ww?!n^YgZT`clgV>-b#tN6OU_JmH)cBSUBcT z^$*7VMJpUXonSG0^{MA$ph!;79+v7Ymu1Y}OLu74b*)|8m32!d{Gj-(?5za{r+uC8 z|CaCfk!LncZrc-HtZZ58?(*v9+~ke-zV&)eIjif_^K@xckYsD$J|5`{$$!t+YCg2w zTHfjOf5-K9!EZNjWa_sy+^})0x*`@EbCTb)#cP(Oj!N&@qrxu#j0_VB9oMi;pMAr< zT+7*WtuDuqbuiN1tKK^GqUz+}0Ve;aDJKmWK_epIq4-(w5NO{%q=0#_JcnbKi321od zX~;jGAIW?EoJ^SEyN2ApC4%QfKg(CnHtLnX%QI)@^o9w?MbjKNNe6iaGc3FFZd%e^ zW_Ga{33K+_O-Hki{9!M0{phuU)hAo-qq~r11ILfoJ}cu`R3%-gE__|~me8F4P19Hf za#UlO_g)N;*=z3i@l(8U^8e0t_8c}PL15*1OdsD2mr)Mph>ttc_C$O+@^4pYzgSWOCz9_rHuwEnWVek`sJ!9Ye&WpCfaPoQtS#pSv&bZ896p+y@swj6JB4k^VjT(b*qa^tYjX_ynp&{UXrENEQQ91ir3N8 z`)@@G7u?^~Gwn8>u$%rEt$J!tF5q4JJ1*_)lvI#`o@X* zvgP@rNz>hxwmebEz5QifsNwG*6K#(ZOLOItban}4x@~y!%&JR!LFG*`hwjE{mL-4M z+h)AzTejuLqs-|->Ze0`IdfU(#g<)LsouAgX<>!nnN`8&pLP}Tz3c19`RLl!;Q7fi z;$i7ULm#0glY~jjzn-7{>*lN-^QQdOS@=!oN4S;PqU+N_qk^x9a!5HDILP{L>YQZQ z+hMtsO-IFEtE88Y#qpXb^G2T5R<7I?$7MF0ZJIu>-Azz=@x~sx5dOfemrW12>xL>_ z;q|lPkQ^M2lr~1UwvrPefib5>#5ckW2f8Y zx*2r5me^32>H6|@GIQOW-KOceoCP_Cr_F!6UJ{QKRbRHf`01TWVP&IG71hq?v;5xO zt@&|hW9sQ?>NBqAb+g}k9kIiIGuOw6XSNSi)haeW=;`Z!Q!wY`=FUxQvkvb299Mdo z>qHZef7io{50hmjR3?N!EIwFq`oG5N{rzWrQr;GRxYm1Zg1^xO%{1@Y12eyQs0QD9 zyV+|`$iiZyv_SW$8kK7zC-@Va`9B!@vn)Cp`_=9H)vgSq^eta4XQke&*|#XV?)J~7 zN7F7YxVetWD(&ip%R3f@Zc5r4l*6-m4C4{yPgXsVaW0}DGyC5PUq!n%#W#l&E4KvY zC$?7^%#nQCTk)?@#9LI5|1Q(!D%p+qon0QikGt4$mofO@T8{re0wvhqb#_e4nR@Nw zqqe?IPDSktk8kFQZpit-${hMsZ}q5zj?u7k{{lOne= z;Nfv(emp_&{oADiTXt_Q_LV+(T~pA>ep>do!-DB|{~clGgbB#YV`7~7wU#brdl=wHt;efP!vb7#Mnli$30Ye1v_BdgV+ z?dN^oxpz(QRz7F(@V0`H2-SdMoI&$1;5n;+cjQ3r5HMeU|5j@ayzgx6IIEtfYMgQ9}>)*DWj;&R; zkN4>&eTb1irdVM9AujoZ*X$2{9!M#({&iccKs{W5))@)w;1UT5o< zf+0xM7XI%4yU!QMZSh(_%%%vrQ4_N2#o&E1^t^)%FzAvyWge@n>b6Q@v z?7xwDG|m0jvZ@B#zmquR`nf;fdig5(%-M|aSZ!DCD;mp1R8PG562to-Uhu3@^NcRd z{N*8cORS@Jy?N-h;%+Zz=Zfsb9J9jK?!A^`fA46bDfjlc$*jMQSWI@8TG*+h6RDj3 z`L4G?k(gj%X8wdrvrOk2UY!4NR(zg)Z^X**oM~&1T;Sfit?tPww#ojQbEV$AIuIXn zR6Aa7`3~bZs#XU>BJE9fr2FmNw`u-zB8S8o4+QRhumro&LR~pj_ z9LrMnUJ4QTvD-zb_lu=YdiUI_-*U4V-ns7yNIw$xOxLYoDZSI``}SjD;qvzEvCNI32mXa^v)OpLglE zPcd}K5}C8$QQP_>e1}*+t@zCT>5flYwmX|*ug5gTg2i<*7p3zp7ffDcu&D6#ixZ)3 zat|8I7KjCReM|Mb5gQO8ypCBU|G;zMM~8(APCV1R&J*Z6)%Sy*LGdh=bDfJr<;3SH zt+-*n>6$?zr)ggAwx`o?pIQl8d4H7&wDNwj>ygqelRs;@N2fU|Gcqo4lak=l@$a*J zZh7zf|IZ96izfHwon7_q?i)Mi_hp;hZWZXJb55%&Vz}`$h4=70llzX-1z+thb@6y{ zbMs-x-iGO%zG@mPCZ{)_3RYON+n{@|(ZYF}*JKg{Q%i%UyM0<}4;AFhx7v6d(7l>Bt9kj4z?Z?k({i4@HndkL>RP+s zE+imu?qr*Dv!|%;Dcb&?XByjwOPbtzsoDO$Ll`K(kx1w*>pfp0-^+g!A4x2wmwJ?HC<oYtJjQt!t$_=U$)D zC%0tE3zlZ<$F*uFZ!}g)PE@Z5m2W` z|6r4!V4{eA3tLuIu<<8t2M7IEZMmJdp2db_Wb<}io8003Y-3?v-(SHQXMX5BSaY=L z$BxX@J3l5fS&51Yp7?6-yWHVrTua>St8QPTbGX@}Rys~d(p8DLQ~M^m%O+g1aK}2; zaGUgH+&=^l`%4tBT$~l;;2g0~C7b);->8nP8yYjiqcV>)U)p5m;P7YB<~8TO?04RE zvftaB>G^Z*w3D{8bsk%kJTm*Uwf8Wy(CO-`FIsaKcs~EJZ=1BWyXV0|FYb%w@0}ak zoct~~nJk~j_i_KpX_qIKroXQhq$_M_6f`mRXV?>Tq?o$ z=F0E3Hw`Ly-(8BYRzEg#+ubLRE?rb>w(t2QHt$zn-7=X6ae-;IyUbR_@p}k-i(tF7 z)bmnPlh)gZ!VMR1{#vcLS!h<#>us8LlaDWGeQ|QZk@oazozTQj*R%3B?33GQ$ys{) zrfN#8=hl@|DqW@q{grLMm7{%T=g;3tvdc_T!-IF)g;@s(u3mnEUC%0_%eus(yvkS0 zx$1DB;qJ}7+s`+gKU(H?;hn8l%RwCltG;$=XX_XK6B2ti>!{yzldBWgm6@gV@^Hlq zMUgz=OLJCksn$NG`$g-)g~eS{5+}T3FnGK{ynZd4>-C+}p4Y8d`cwMAz0+6ra=hL1 z*dw!(Yq7MAt14fp``+@ck3#eo%H=5=_Wp2sRIGNn@|Mt~v?Zwr`}8_qSnBtmQfYbg zdv;;*cK!C#dpY@czc-P5GRJ(zW8)d`*Ycmgq~v#azv5}{1 zTUhHJ%wBw8W6y2jEdmeC3|Knuf9tueZS9#0b%{IdAtrJT^PGkYR)7ji%AeEXsIu$6hzYK|RqHXl}F^ZvDInOE2L`5*oo zteAPJY+bJWhW9gTKLua2DEQKP!q0ixK6m3Ke?-)GEM0X{Ln|Z5@^$PTfBt!QRx@yK zoyr-|{_nWS|M{QHn1x^N*kZ;IT5U1mSe%~Ysgo0=LVrn|;AXc>XSiMGow?m5!R>s$ zr`-IcDu**H8pW5GRX5HEJv*zf@om@s`-^#;O67#x4FbQkm2Z38cdN5%qsamJIr=-5 zI21lGFYfuNcG7L0MD-2ng6*kqqU+-O)mP7+Flpui6}N!juXXH~wCI&=Wzkt)b*W~K z#g2LW6BlfLYq{)L(TNL!sS|^v+jM@^#m`s2d;0yqJBKXyUMtvEsZ>#2Druy%!eoiY zwPUc6pO`j~wUwm=)%2dzr&GvtoOG%*iur6kN`JxOvgy(H2#w4Trxms4HG)`!ci6 zmsv%X{RqR6qm$EPOID;Y9xn`QI8<)<CS?qo;Z|68ZmhWQ*h8pQe_;NOFjcl}cD9&Eg}+I~}yuZMq&TLsJS8&gk; zo=&@{J7w8h=OFhM7xB$onc`|vLTvKCXFk1V!M;G^t{dCsHB+yt&5Qor^U_yKCLve* zxR|oM!<$p$e{L;Y{xo5EP_TD=I3hPdE$D|W|_MlP4W+tU9OhSx$&qy z_SESsR&9>nF8gV>TM*MypE=ADIk}!$b0Rk_eq61zA>lzu z(=&(SGdA&GmMmR(`RFI6ug`bR3wl`lfBv^;kNfX_D>^)R@{u>fyMJv8eRKNTwWgEx zzvq7up8b3Azo358WoKWk?DNz*dm^UiU_r(~Td&*+On#QPOE@P+@HM@?*Vom)-A(rNrijWb>?@c#C3STpXyvxbY>BoV+~U!bKRjc zA-h@5RImoTNm9#-{LA;)@Q?ArBjVyFO_CZufd_JUS9P9fdHeN6SEZhiyYy;3{nQ)J zW;5w(R}=_GvP+n(i&IY1HBOQ{Q1)TXqD6C;rgW~Tmt65pedF2cckcgLHRm`xxkUYF zxzG23Pk$lvf=>~qx3VN(2dgO5dww`$o!xbC`?jEv$IsphMov)FX|WSclDOHbE%@l* zs`}`EyCRPEM)kgwE!4d>O>?SXb45|b6%&OXiHU2tLs(g^xhz|H`PJP7tMj6#ZcJNq zIio*_H{K{Drs(}m_uouc?`W}{;9t}ysTHltv#VF`3+D?3=VzPkzCTZe*Kn=;O(g@J_4a#+{f+p@5QBPhm|o$7U-?Nv1IWI z-n$PLf3w*b$msH2`0>J^LbZ7-wka_6G*7w3GymMayIDq$R8*pL0*@ukH}C%6aZ#dI z*X80npYOrGe(uLQ|IA(T_T;LSytX_GeUu~&;#5x8E_U3T>>z(I`M&3b@_AaH*?j+S zZvLkF*^jkLXlc5x-d8ud51T&ijJtHeRC0fCOK;9}b>9i+c&=t0t1C3(^SqUHd9J~? zwiTNmoZ(BcJ#mVO*YBgb`jnoaS3eb|%AUWPrFbGccahb{pE^(DW>4t3tQi_HFTq9H zXMb7?Z|H_h!&at6rREGTZ|5(m&3Wyl=2_|N=jvrt8GqTwsJX4NXPK(zh0h(I&ukHA znNXVe`ebm={P-6)CY6;&W*y;Ad%eWx&G+cO|95!B=HHqdUEZl;cJ`~ZnZ}e8qN(q= z&iQ>eXDxd3UQulp%N#9_sZUB+s?yn<)a4!>eS0C%xxAp@qS22Mh8I4C_2M^7-~M>2 z$@!^f;>7H4=R?X)m%dVb5pqcQ6Q|9eHxCz|nyU7|b>fr8c-6~y7?$~Tq%UW2dhR3> z8zmf?v$5#l25traUHm83EHt^1_9SF;Z-Dkyqk6~u%(%ZZabCM@Hs?B}pp+LW^HSG@E6p~Jxpn4( zw#LEtrhZm|^1{oeWW8F{Z@TcVmYtC5JI-G@p4Yoh>{$_VGv&IOEUVVEkaOQYtT-vh z-m~+$rd-0*sZVAWG;W=@h~IX~%;(eGcb$G_@U==p!Qx!W^{EB#`!>~_-dw8YlG3-l zfq&+;H>Q6gs!lZ&EPre+KGk%p#|CCqt91)&Op;ft-C}U>Sw7QuJ4cM1&x?mKg}Rr@ zCUku=*gW&)E5kc8H#U3qoH{5Ya`Ja>t(J_OR?^?v!&A3TX*kE++56~QSlDn61-J0FFxh|`Q{J*G-WRwy7G9jOa6AbR|>2Qi3i>XMSCRH z<=1bY{N-CwUCm^LpHe}ARx>BFwdS`pY-BIJwy-=$hvj2>{g&883XjqSa zWfxwz^CT~xc<`@yiz)BtGV|O}!P@0b3lGdRtmZq&=4UFl<&VwcA4&H*U)U!u7xi!W z_T<{_$~U<`b6Wp?Vc^JH9Z_fMcTx9|pxm1|JPgwA0?Yfvc51c#=k_XWP&byiJ)FPI}-Hx-B8v+>xP5wp{# zt(Dbn4)1-360t;TCN<%8xbwi(}y_>6AGY zkHwDYB|DK=Kdre)}d{YpkUaLvL zos}806SJ6@gNtpKe|@?9aLbZys^58+#R=Yg#9A8v{d|kS;mik}^9x@po?YnkwD--L z(+jNL=(AZUbj1J zmf^zVTKA2!D=L>o)|l zZ@Q2&#W0ue;T^|28bxiwmkNuX^UPxSSbpZ+J(n4iS=soSR?lq>oX+(y!zFf4=4y@m zKHAU!&2~9ir`Nm9y0syOSL0>llllIAmp0z!oF;HbDf8THfz@riJ8LagzSAH+d;2euy^UuQo!i_>=Pl&_ z=j!_Xr!QaOj88cSE-oOd*WHwQZG;RoU6^9!oA^=Y`;^u z!mGDhp-V!=&bTvve5ZXRCZVotIQcY*?B6NZ%$P1ap0LUbXmDfh1ebb{JMSN>C@NzqAs;|AAgyCcGuU)tq<>=Y3=WvyWGK5SH;{UVEHDk z(wVoWH5wmpT=yi1iM#)dM7Yc5OVZms8na z_WHHW(LEj|f{O)$3@5msnbqjV{$4ZW_L4Ii{nocj{6i(hm+nw-*RbkgzmyQYE%Sx& z+7sfQAAJvKFx~%Tz^l@pZ~vX=qSS}%GR2HD(=2Q96dT_;#wkarRF*cF9DY2@?0xmi zw_@LZGHGA3QTlxOlSE%;yuUj`x$Dj4%M4croxM<_zwBDFdz6PmsrKE>nQa-3**~Uz zD_bywW5fTFX|HFvHl9~Gccw=xVUgYY_CNhb|D?9euzneM)qd*aRHjxZR@1K^OC}p~ zOBk%%B(vkH6WhE}Jl??@C9UeoLUP?)jp1D>JN*-Pig$GxYo050P?{8G6l`s&7m!=}{;N zedn%jP_QXmOr|8;_}?GZTk=T@BW$^pKkwN6f5!BJRo7Fl1e}Wx+F zX~6<3Jx-l-2xN1~de(j8NDJ$~GIvRY~7Lgod}3bS1%ZC-Bsf%D<*X`yN>I9Ek#r!82=yx@NQyWzUH-kJFb<@qPDNW>Q<_>$1GN{+iMI>R>-tb<-*J0yv zJhGS$*lczW4at9|*0H2*XJ)Zmhwapr3F);tY&|m+`&mmLO0R0y@vkX5Z>@AV@qf&r zCq;|u_wYC0sNHh!tB&Faj)VU+>N@tCc5UzfbG?7&uJR(bb*`V*T(C8Ex+8ajyQyi3 zUbu^r{d139qW^2}3o=JO`1G=>^+Dus*EI=g8_q0`{Bvi^oGE9cQ*J)%R&D*)^zh@E z`tYB;U;bRbF8unXVfe*u-MVk?uCTcBrR-DRh3cPSVfDYhA2M?OQ~2fo@B3cwc^2j# zIr*^RfXSKg*_Ylc3mMibMl6^)@%VQ)4VmiuU7=QA|0Vz3mGsQFaFKc9j753(yKEEW z7OCvsQJm}@yConcOKO4fk+5GY-Da#`D%r)Y*&Mm!GGhum*A|hBU*~RdY884Axm?dn zL~mvAj0wAsKj>Xivnj{ovCGu5E_J0Nr9m8X5AENQx`A2i@jV&8Kj)0u?%wY0W~|;( zvhvH>?T=!votwGtPw&My>@&-P;#)(?7|&#d20r-T=NkD?@c19T*>*=aSWeHpW1%9P zyzg*tlx(fS0}s34J&b(Mx_@p;3EZ&Zc3^dKa;fZvi&w?+q{_XgO1$Tgc%f#pI?=al zwxHw$*8KEN-QYRG?1g+a-~506*Aai};8lNl^6UryCLdMUTNe3ok(Fw?LW8E-8Ik#y z*Kc3H=*bsfPsZaJ_fP3;a|rm_Ue6pp#i!?Z*PGy;xj#04a~CT5SW_By_Th)SooNT8 zcBncy>hF*B{af`#La{lW>#ETU6Te(OktwINRFV%nRs5-u;W;OHv#g_(&t2ziwAP7b zGp*u-q{UqqOli*kq&WHh`hQ%Ut>!y_N!(+;bE(ID&6W_SEt~j{W%4`{eGoq(J0#;h z+qbRrG@Wyu4xZk;QsDUJb?$rbTr;*hm67`}NrXw`!^RV*?3hLPwmIL`lAdsQ_P-5A z7F&*NJ5iZZyH_uQoy{&O;@tOVs&VTS&aT$tb=LRUwVm_Yr_am&G2PZ=QLyjcQ2H!b zr`9mjF`)d+QS#YUyN;mn)kg==TLQMglH>~dCZvFpkW>;127T3)nHcyDU_k0;*MwiP?; zZy)q~E)>#VP~;dke`nTRljiJMYfmq}wCUudGskVBo@;XEX5CC)UR~VfzIDp;tg}}% zrZn$WD4x$O5!bFdcjtUQJ664`Y0LKM&3GvxarEF1$N&B5`rBWnB=0@sFD|yCvvxyr ze)H+Zb52GYd9L$}!xY{svB|M$HGbT-HC!p?Lq985h~%fB>pyKKWnWS_@#@B-$*+%0 zHGJrA>7DM|*~Y>B;^dl?AIAF1?!GE~=@0yrQeNhqli$s0a5vO@QR&}lHnWu4L|;r% zD^jrfU~#12bormAPx*VV7kOnYklZ%0pw+UW-c4(n-!Im%C(_FJnQ!@qt@qUllcP@!pb17FZT>xPF)!~NcK400-4(IRHS-NV%YSx=`w*7<{a4p9 zff+9PHCuy{8(n{?Zk)B!Hhf>t;^yuzi{~^PYu?kQpm%>}dcFC#H(dNbBl(u@Ui)*) zJ8koB@ka|cZ97|Ns4ctMeX_}gd`-i>zj}`zeP((3rik);F$=Z%Jv}~-?Qc0JemZSk zc=&kw@Ba<_H{$*m?%E(XQ@1|R>dy{_<0e(byKg^JpO{m3@9aTtsW2C@ml?%b`FG`? ztKR>YU6T_kBr8ARRI??^zbYf4SI;I3Kl{eXzhWZu$qOvUXU6>4Sbd{Uae(w{>+v=+%wdsrU-8&Y&2Aa$J{v}m;Pq(WG+im!MvWOo; zipr5k?h9VT@c*}(@xEMg-jR^ZX=zPrKV5jwNqJ4%E52&(w#*7WJ<%P18qc)+WIv^$ zq_XL1m6`CDe8K%EOIL?}602s4F9}xKwx2&->q5fUlQT0SnUxrCK98_deKo^hJl<)3 zV60Qo?T|BvLX@vfI`gmb!=9w)d4a+EO8)(DF<~^A-M!Cbf{C!`;bc{PosI-u5ALKp zPc%Av@0&AM$4%*D(%e6_^N{Sdkb<6o&OPBejyc(H-v}i{w&ct`Cu-`RUa9XU~ zoEKaTF|1j8W6$BF2NT&0PnmhxJKs|NyFIh?0`E({^w|-Ye6QHr#y-EXpoT+9AR&82 zLBg`L+fy#L6rFvsRCvd|q=O=PX?ioN6xns2epUN^@Y?6kT#_eKuv|*4wELdyg@&cCMYT9pb#;Wnr*V`;Cm#thTzVd@Zg%H(tOX z^7KJr)vUV*|24M>=?q1qqz5(esTt{3h3D?(Jt=GwzptbPVjg{eF_g*I#+} z9A%H3IC|z>ckT+^Cljx7KMwn~#3?{wLFFp8DLXP;XIXSaw6;Apyef8_OF(1k`kzk? ztIOZ>zdsnoE5;GIz)7}^?fkpvyFc^>@-^S+J&<+YTGv=%W9JiZn;MpLD!;{863FoICeJV|*SdcCNFQtLxu>|K}$@(N{h0;Q_qj zx*@qf!P1dh9S!wo^7*QrHM`bk-?!#5RNf^T_-W08*ec1HZ=Udd6KF~Zw(2PLP%@OR znEqquro-=7$iJ{@b-J+fYl6ZB_m}-s?jP?`uJD=6E*>)7(8bI8m48UMP4*qP*{_eL zHGKa4F`m^_WyLPx@7xxXr6$d4)yYorynEazu*gZEqJ72Q{+DZt6=Q$#%;)M|zL@`A zfzHY8wu#=edzXLY7KmE^{8@(ac8*_#ACh&Aj_!_1FKpp84ZYshvoq-KIfaRV7Csx5 zo|>Q9%Cq{({_XdQdyecctuUzbE-k3I%=5X^meKvrx|?@4$-FwHQ|62^Tt!9(GEc^Kst$RmXgF)@N_fOYE{a zac0+z*=^51{L4BZFJ84iJb>ZV^7Jc{_a+_OrMG~~|96N9^YzZY^~SNGCN38)?3ZF# zqw@adv57$mLR)X23SDvb#gxlQ`R_gQdak&})Xli`{Y>0x{x{nCC$a^Xsm!zIvk98f zbK#TCkLg1CGZu9&IJm;%*O7@=Zm`H2yRQ1^@QS%l+G5qDS<|olXxm=NS)eo;S_Uc+%U1+}g`Oz4z>O(Bg94n_~{OO*3W^%&g0~@U;m7aC=Amv(3Ju`evqhf05y^Z`-q`j-R>z z#RR@soW3$&T=em1_j&HAdj=+XRFN{yZ!CsgetyzDYoUwtxv>9a?VPCeNy)1Iue z_W3lAfHUnqE-YLB=T(RQoORdZ^{sDbE-&wmHuIi&-iulEv)ghGv$eL;1vM|G@BQQR z)3(d>)+FP~mUCHM=W1Ca9Bf0LhdFGVcyr!@W?}a$|Qx}rHq1W*ygk^`4L(( zt>*6tTAEh6CScOs@Rst{D`97*oVs|~t8L*E4add>5?7Ya)OE>fV_n_6vSpK5!9zR2 zI^i8hPTsk+Rp>>KU6;g_+s1O&*UJjNl2K_=k)6BS`etLv7UP<~Q&w*NwK~Dy#6Q&7 zb>ij^?46f3{4kjEowN2Nm>7`uFPo-JH-~BC>TR=SxkS!iMTI9P!ExDsyeU3Y349 z@jlB;(O$|pf3DUEr#j7RpEp_MXL7Gx_%?E-@kd`q;~l>KE2iX@oj&CmvuK|FCNB4x z7b7*AM3`E>-suQF{q4fipN~2#ycL(8Kj>~d`;^(lkK11<`|RJXvSr&{#_xrN6>nCY zo~d_JEh|z`=Ul-=k$9ZqI)7VzVySlP|ZkS^ecQeD8+zp8J^~z5lAl z<$qqLtP3P9*Pg21DJ%Wx-!i+J%JadKSg&V>JP1ryj!-`ON~L!*!^tIIZBso8X4GbP z-YHsg#pT73!{^S;PjI)IXe!>s>1fDYmfW>WKFxjB4#6pBUbjfS6Vv!6t^M0&#ksrD zFX{}Ug>LZ11XdOP%xjp8YYv!5UeVr^Wt9-~ougUyLVUk@to3u={k*1AO(9BPc_P$(v zyxYx7HG>60HSO+NSzF8$)46Ir!&)NfqJU89Hr+L6mv|XyR9Ub`E3Z6!*!f~cU-Q|! zJU1BinXi6(RVeMb+kHuq&Gbh-UT^7OPCG92rKEI9 z@s%gP>KctW{^V9&R-3VUZAzG)@a1>SjD-`Q>v7h9ZCRuv^>BTfzo>wp=(j*l-ZB+S|41iw0CZY!DSP3{=CMcMIDcNUo4T_ zQ7Eint)_o|@^zOrhuczT-04(NpY@CDy4=jkFWd@6ttUOXvcElzD{aD#^+` zyHg7XjC zEwR|vJWI-)^`wY&=Gv)eHAF6Q?P4j|Hrd?ku_$A!gZ2u+x_h%f_;21OX8quoyw0=I zFq#rFE2PbQMHLX`70r%uY2db@SM(lM@PrgJGKZpX9l@8b~(_`aI) z`Qlu*CF1t;Oij!-8kQat`(r917+`egQ_H*X2k+9dxjK!PNHDfXu+IG?8*`Jru;YZMm{Whwx3C#oS%W5@+nw;E zd-L~M3Ny3cUP=uJ*1q%M!cEo0H#&K-@6vXNo{>1a@Z_(IQl7ipI6^Ld^`6UR7~8a8 zNA%iNi5*w^zuud5ZhMMn+l85v7R>#n@Av5Wr^O$v7fihKp|JAn>n{!NB1gG%*D{=S zH+*Tf;&)N^-j;2zd_~1(&)dwdx_~YEq1hdd0M5A{dtRw{p5=d}aLe8=h*fVUqh^cI zwdRtZJu|F6-;6v~SrXki?Qz2^bGfs1EGpNHBL$^T$366sIW}wJL#6csqCA;W!aRp> zZ~2!vJ^B4@q1*gdzCHOH$z6T)rsk;)?#vf$mMTmyeDKF0Ni|0xw)3Lcqn9lcXDG8r z`j!N2=i!L;)&2TRYKPl#?~rZh6dWd)%sQX>bEmDHRkhOYM}ifvE|+f$m$PB&ZQkZA zW>qKUC0ujfA!pK>IjdAtj(xxNUMBI}jz{K+9qOy*?{T)?)tcn#X#TIzEiXQP`Q!fj znwS-qPQ5?azV3WI^@03LZA<&BieZZH`7Swat$3x}dUJ~NyYFX$4^7{er2bv?yfKf; z{9VOdG3|02L{{zDrF_{$eGA}P4e%Juwr$t_0=ueT%`R5BFRFdyB#bdu*ZrNyEq7uV`@{7nq#YV?Z^ zm-kpA)6RUIM{qgI`R%#JzvpFr*1MgVaPcwI_J+F2vP&QQw`x_3bMX!hetYq{)6@#3 z6z=o+tET^wG}wP?No>da#tY`tH?BLRz47K=-fwJkl3V{@;beRBbJ1A`#!Ozt`-&?+ zJn4C*|0^fT_4Y%)kB$pETJ|>|o3+T(Msj79|BDk(#7bvnTHpV;QEj&If$PipGH!ff z&QW-<+H3z;3*|R_l1|)rFV&0eOZrx|f4_p0MBBdG6>~NpTE6VdvH!ok*B>w~E6r-K z&S`Ap*wnmXMcLA>*qgg5&)b(c9oLz2dEt@Y=g${Dym&zHr0iphZ|83-Gwqrdcl!Ec zAN6(T?i-ZrE$GVHZMevHSLiz&rRL@ZR0%gGL5ZVR_1xj`Y(q( zTa$F=$*Ds=d}80FMJ>OV@~JU;UE|NhbgbrOd9HTqNJRmY zx6Zks1QnIHj}1N~J-b)Sdx-Jz= zv&ro2-eWS)maP5x(=qd|i%HT7znY&)PiH^YWxp*xBhT-_v85m0?y%YWyT*R!;q>@m z#yy&MO&PXG1iidhvMZ5$zA0n&rCT~bjlxffwHr>`{d{4USzCLIam)RME*ESMOZ~eq z9J|x>et$ko>91RvC)pQ?@963bKl7&8@X*>F3y-$G=MpM+^r& z<>DFAdbCyPqxGW0R5`)w507NO zO0GAaFY_k(X^mXEkijqIMv*0XYlA%gnBHStr&)5k<%Q0!&o)`zKkj>JU9|;bb;`!$&C@o&OyKicq-jZj(W?W16ty1FWT$Y}3 z`f7^v%)B#(Tw55YFWjHKjG^mus(oqXynCxB>>(bbIK?uibZU!hsKZxjwa;M~V(6 zamr0vrP2B8Q}vMyRR^8vzG{kvD|RMNI)3={)YjOr2gk$|o^89j?P>X(3YPP_2`d>? zQ`{R47w(kW^`!dRxar4JNf<9TPK-aPOE=??6z*dT-@H7vuchQ@Fc(Axv*l@rI{z!o$>j& zdppyu_G{-I*Tpz^9N>GgWq#ga#S*i(Emz;&o4mw1d>_Pc&HW}D`%Q~C9(z96l zV{33*wX=kW=+R3*t_Hrl>aaCa%Ga`djYHqYW!cArd~L5+xG-rkYtP8(T`w}%QK2cq zK>vi7)31N)%h%t2^|`_FTQu9(IFH3^mou@db4k}MmdR}VT>9TO>h3&Gw(QwA+7j!7 z+3tnrIx1TzGVWh~XV>Gq!dvyu9b?~kY2KeBeRCCsJ6>P)W8nz*o2)re@ty0g)P;vH zy}7vFqkns7s+T5q~A z=v3E_36^av>6smwea{)ppUzJCo+gm@q4DW;m98Zwzvj;1c`x}acj@t;-y9<~IZ_3_ zJ-PnaYL}@OU%70B)#WJtSKDSwybzT(n57oz=*T}{@^FSRn3-j`mogwf1uP;-`R{VYXVKlS=0_BzZ^3{PjvGTJ2X}u06|Be#MqU1}mz4 zLSN5rI8^_|ukGZ%JeqRTh!q-F&$DuHj#+ds%Ai%Z+U_ z7x{<3=i+p@E?*OQRJ14J!gJ^C)30Pt+P-C#>fc@Y8#~(D&Ps(|*lF~v{k+r{-cEK; zk(Y{xCU1}~^_FU^X_R@pY(Dea>L<&jz8X$ovpFahDf;J?`NPE?Jy#VzS4lgcob&N% ztUZUwGf$%^jl;^P1q({WROF7!B~9X;>g2qFmx1lwb6F`*)7q&XotG+mtlmph1=l_B z=O}#2sK{+qCaKrD%l^@#(zAwXwi*s1^Q=UTGRv>zI$x_cX7Y%VuMuHizy6h3!i*)a z5|&PM%34(0<2b)W)%!-{`e_YPdM;t7if-%dHL^3eu z?OM1l_e-3RmF|yU1xqgPs&naBrKodFrA4}7YFWYD{kxd=n4cHZtdI=7zIm>sUVNjo zua489g#qg~tok)`XV<)Ct*r;5TNkx#d{Ok!>F~{)$!nA?zpU!^=ntCwCh63VHkJMP zn{KK`czj(Irmgh**y41*p6XnAZ{_KoEp}H8_HU_f(Qtw z5;ptJJ8^9KeK>FSmYZ%reCwn>y;TamAF-=8xr*Qa)W+-*wGStl9oq`Lb$9h1_P!E* zJn44&?L6mCj5Ub zu~bs@^wLq>$llW_r?%|m<+V;4t`ag2E8L|&HWaJeY>s}dmYW=`8tSAcb52B%Z>KlU z>zYE@?zT8D&%4?YSC-4D&6U!g;$$`D`47oysrwU+dycGn=+Y;0qk2v2d#^2~dZHU1 zvwlByi0j16qLQw1$N} zy0M(UK!3*NCl#+ax#pJ5b@34^P5Wl3*KD)$Mu^y~p)L zwT6D!lWQ7bd6$#TA5EEX$I{?A`#me8cNxWgC!E6)kF8z*WK*ng?el(@7wKguE#7>J zpIRn((0oI^J4gOB*-cUUX`VAeA2o1juuS0O&zRmjdE%|`~@B3o8 zfQxhXBFW3ud6`Usn&)})!ooHzZ#WrSQq|@4&!@j^+n2rkbM~BNb)9tc@iVRCpDQaj z-FYD(bV`ahaLo*cAg0i2)jKbLul<{^vh}#l-Hmn=*|=hrm*^_-7`&MJVeLJR1Ir>T zx_wO&VjR}ou@UBSQVHn}Ucfx@;La_gxvcLp%$nw!Yb}^wWG~#iVMXVarz=^`Z@+Th zXu?aS>Lc6l`q{AUG-I31bY0u%;)_KRX1^ZXboPJC@Qhd7==S`_fhsZQG_&5nt17&D z&9Edd(Ntx| zyW)&R1)F?N(JyBK?gH^^&z>+x>g{{5kT2q6Mfv^R*V~mmFEdY&b22z~@zIZstE3gO ztJ|JFkKH6?;>TtJanM(rpT<@g48-cN{N#@nTcc-(Hu=`gv#9sXzJL$mJCIYsK1%u#I_h zRF8S@`ut|gi_ScU8ncgUX6PKVRGrZ7FMW|E*lTM=%7Wh$c=v^!nHgp@@G#= zyz>Ow%>QLYOzhsi@YcSL|0^r+)&Kk-Kf%=alPG%`&x(^0xgjq^qF;OtbUZXg$>F+Y zYv;Mc3lmxz)ikCFbgk{Ms@yHJW9^slxBaWu-RNF>^V+$K{vTIv)S2PQaH6WcRM^*e z`P+tSZx0){$LFL=yexH%k6caRabfb>w&9ca)~8B;in~5ln|<}L$eOcxMp@Ig2Yx%t z{xDyEv({Y3>VcN`4yC2b7-J94Qmf=Btee0a{qXarf4*(X9y{v{8$Uew&CEZEr{S*m zwB9NzWOS5bN1we)2=ROJ*Qs!T1<_1?UgT& zw@)?nd1pM^eyS$pt=uD9J#C98O-On!^N^)Kl;wJnq|QlcB|hF7qZN`$^4a?r-Iv{c zFmUECbi=5lGb$@5sR{SO}`NF3^Tkm+&!$=A^JrqzX!8~1c2zAKsbTmAbI zC1ci}6H7kbl-yUrCvToH(c9k3XI1Ld?~iwhJE{EH&c@tUo#~~lB&xrJ&w0=1C5)Nd zZmig_PT;SGzX|iNW47Umu8EP{ zO;#Q+>|_EtWIHBZO1@y`7(9KY+GCv#)l+Uu7EE_=w_By9{Nwy)Nuf7az1i6F&MjBm z)$Mvo<$9F;$D?NpT_qY#U+nm;xP*aIVQsfhn)Ckk-cn7E1=cFx-j><6|7Fa%%j{8n zJF^d(WG`2J)UeRQKYGQl1-9VnS0yYXD(0gif^By_UP*R zz~9${?yY3prFd0BEUE3YmFujPNvC*BWL@O$H92ve*qP48rKIQa@PDb${+2064c5)x zuzvL-opZkLZXezi_{y@%`PB8Rv(rwwcyio5`)tDEZgKTBLF$&dyiA)PM-&AA%yZp+ zZARp`q)RfdC1nNmCp_VJUek2BGsUR)Ow`ewqiV~0z05a0E_~|3u&nT&QjPJP#Sy(p zYdXs|76~L~3ugUtW#3u7aFX2(cD3KPUQD(z-nX&4pyB7F$`qHv%m3#4PhXn(bH%5| z+eQ-4q@OQ%xhS>mh?Lgd|AvRcisPe1jJGeSoo9UKGEYwRc9sqieXY`#8yZuc?oGOy zG}r3u*^^!N>;j7n3}!4j>CIEU{8>X@pup2b%+^_gw~uHX6^=@4mEP*y!@1~k{TqdqtF}W=2oz^zVjCSu1^JPjM-s%=DQCr?N{@bR*JKrb3ec^+eO>xVn-n`87 zXqjAQYS7F_i+EdD>&+MW9Z7Y#DO2SdlCvXJyH0lMU#pb{m!4O%6fIb*$Qe2D-Hq~D zd72fakIznzl$xN#9yUR>Cy<-@)45A7J9J-j-s^Xq8YU3!V0wP-9TmT7x$F~bcDz|_ zepykpdR4X7;^3)sQi{&4Js57YX2<QsipW)Lu zz4OLm6^{D5%M1_5d+#}aoi!=etXNH4bN~I=y)*fZcw^4~nDWKgDQoh3i=>?`XGG2Z@0D6VuTYNreQIFq z6IG!ILwC;ZvV`PYxV;-?!?gVG_Ua-pr*8R?##2PSGg4Q^--tM!*uoV6)r^>>qEjoF%SJK18&4*p)(bckWY z`WefezPj9OeDS^V=HE{Fxl5Mrs1+*lpZlY&`nHu@^?8Q5PJu}xduwd6Ixib;=`Amw zBP22X`jl<+cC+2hKN?1YG(J3QaE=q`$$^`Y2kRisDrq`BQe5g$J7Rpl>Ym0rgGxW#aL zz^TvnZu=`QFJKiu@W{4I!|1z0#hI^O^KwxpeY5)3(_b?g zzhuNFgl|^ecBiR3<$u{3@w10MTNJFw>An3fuu5!#VDOo!Pr1B@XPuAVwKL~P?LXN| z9W#4oO6EU0=JU*F+9cnJ61s9iwq@f<5mq5qr;P`NlVzKHPcI#Bf|l{KMU6ON~yphA}N@$UHUM9Rpa%E6u5x7Ac7m^3|SMa|T5`f}(> zcJsMyPZlzU^=?<#Bw+UUp&6Iuv6RcfHK9Qlii7wZ8N!T=&oI~sA3Xd~t5^NW^LSpB zW4mXl^ykRxx0(+;jPH~-A&IQ+o5oR5=hPnFWhBknHzZdt|9LFUls)Bx%vmn4)XO)Wi_hFTExC?U zC)D$$Yl`9tJHx)dPwT?>ayJIfpIWh-^~wA$r&Tryg~?qfCNA#Kn-eNl7vUFm4 zYJtEXrEeE*IxKPw*SgCybCH3X`*gk^Va$*Ax;^&d+Bo;_YsPgtQ`p3Lw>%EM^Cg2J zmC-?bQ&4lq?zTs24|ho~FFU~Y|D9>8*W7!i-K=aIwjGn!tn<~HCCy;ATd6y(EMmd@ zwL7=TvsL`sY*&(Dwkb#PY09RXXR}uBo!x%ixO-l>@|7aF)?@!%4=tZJaeG;jc*cp7 z)16mdR(tvS$HFE3u1jlUr*$-NTJ;^Pkoh~^>ce^^jg$G)j=y>o&13D)x>5CvtjKMP zTQ}Az+k6v@_t~!ce7X$dV~yLFgBSUonEl_AIkEblS9noHD?^$1spjSJUswHSFHRRQ zb~Tt>e$;TWV_l)FiO>AQ2cGS@pHsBVRNM5%qd6;9$mrahuk2J)bNN_K?B27p3iZPE zHqH9>Ph#WrJrC+Rg#z4!68`!u3OaIlMeP;iHjkN!nFr@;iMSahWL3V_)v$3qqoBv< znj+nyv}Z3v5mWfy z$LHA-=TB5;->g|@_3hOO)0F`?4cp_UMmL3Ooi^iWxSwwSV5yv(;@!i~Ke(~Wus7R= zpS~vfR@mY1zq?Ko@tSOZa_q8p zP{9E|kqz=I3^F|GqcYE1Uv>+dS@h$HeP507A@>MLg>%f|hJ155qiUI+{k(C*S!`uv zW$PTSr+Ht5d=@6nidkAYXRYH)uPxV3X{ad1zM05*SZYps_C&Xebs1?kavOMsX2#?@ z2mW4~d}&|*;mbBn_w83p9(y+yJxTP-RM@b~Q2yQ*q4_Kf3EOYx3;(_@X7J#}mtT5LD&ICfxHUQP*44SX z&dVY$=P;%hux_(>wfp5Wy{?^39A7+`r4^OV$jr_E{ZqK&k5iwuOJ0bmk;%3{Eu51A zI9zoNPsJWPA-9RS^<%A+z-bafPe@W%&)*Ci|6|zGf zp03utW2t$dAkS^qs~_IKKippIW4wRSb(xn(WgkwKypWvRC~4@drSkru^rtok-@iU38K>^Pd8T3O)9+H7wa@uDzaA?AWFfEh|#I zNx1tX!|k@5#STXe<}Ay6eDTj-`Pnyb_8dQaMZMD_LFsc4NAuL`sfK+4jqK6?W<>|B zRXoD~cscuW4yKI8=zyN^ng3cjx+7%{>c*VB-XQx))9~=_1NIj0tGRS}?{_XgB2%1t z*S5Blv8DI9Pt2KD(akyg_h0_?^^fUm5l(jDsk_&D#`EgUxFmPH^nbz;^YFl${qj6# z&mItzaGUw2?Q?FKxWk7THE#u#|0dueT**jP<>@TpnlMeO`KL-mE#sfA;Q` zRWbAGV_kYWcGr1!p{q9Ud@tp{`pFV2($F$Vy;kn+#R9$0cPGAfHCt|0bCmPQlBBPO z%Z$7`-e@mYcL|a$(Tx3O{BKsV=R2)eRhDsOU;36z+~qs}8pqMjeeaG6H%wS!VtYqc zS0LTnDPb=A)@idMZUtXCWv~8m{=5xxnY$-G>DYVy!ri}@lmyG~PI;$r{E}q%rgO4f zX_w^}W=&TR2(oVj@#)R@o$O9;D;2NZ zJ1cYeLEIww`uP#98CIXnOZPIDFFtaJKVi;7<@+HAbM|UHR{1HmBa_46_u_zqiYq^M zv&$Krp1L^k#+;q+{D8e(k9V2(rE?RJo%)uUBlj-Y1O*j~a~@Z`~NFG~u9!Ka=IJw;wJo zYmnM$9Cj-sUjNe&albn(IMw0Qs>1KJ2VD~O z@rIcvrkzlI70{yUHG$L1xAfmv#Ts9JfiL^nxNcavEqkB(`q{oE;eq;=PyYL^`+Z}> z--OEew@vytE-WFukY;p_D^Aw)l_~KI8l7^ zz?F!cZM{!-p35;2Elu>Bbz+-B{R`*A`PxtAI-4s~UmxvU*#A6%+odsl?ySkz!=wJq zyLYW5TIy}7)m>*E9JJ76?L)UOn?;X0 zJ^YdzS{~6_sA(SfFv@P>9KF8nGQ1lSVpnlS7i!hk*WfZUwwfXZ#NIX8qp zTORQ3;hjGMT#UNh+AVfRyY5%s}MlUg%vo*P%Ks)(0x zUD)|_T94Ah4~;ucMAvStp(spa7Q_ zb9`6k37Pr)QeW(B>bs-#kMvmsS50HSGYb2sW@z^6uMIdqZGN4oZT!cb>%YG|J?q>T z=?RA(NvNOW6}%cTe`i9ew-%$Ovhy6%iVFXoelw(fTyG>FcZd=^@ne$S?e0p!_r9*` zE-}Ze@15e_qR&v*zjtPH$~P`)$*U2`J1$?=%XMBK8yn#^cl+ZM8zHR0V2 zUycLIR(EX^zw%{{@w)llUM7iLdmyOzMis~Z(~tiBajZDCQ^G3ranNZm zT_shCrcHHc!s6%7U-s{yRLzwHhTMOJH)~o;TYEDtGH+NdO=cI^T$_9~cx}tpE5Toa z-mTuf^iyMTT>ED=`Hjm=IQP|?R@UCI{be-q-P@H+&8z-?61Lo4G;fWdTS}(mE$c&( zpYvE&O^b1U8}+4PdvV~We@}WCyf{n(?nZI{yH!_PCH%a$&kFUE?@+{f)g&$R%|77Iw7F)*gXru|X->$pOwB5R;r0D3utT_P>ic|A1 zt90Iz))8Iv->pu$#qc1rpUgVtx{bX#H{PC9?|pdE-9~nQ!o99-b58%v-ug~!oncH} zK8sVX!KzO-jZ3w+C8fFCeJK8XXU?nx_21N&|LuG!##tLx)s?>gbZTtV=GK_Xd3+9i z7q)2yTHTZ2+jS*6S-I5Py;XU8zTnBi!;J!-O5OWbcL@c3b#!^5)DiXU*!m@19Q@N5 zI8_#eg|i&7$iDFP>X!ef48*VaZ9ODnlzlmLzsbfOFQf%Io>lIDp!!1mp`?m_kWAub zN%;?l&mOj#er$v1$GNAgU(5Up^|IEC7O6;A)3~zAmuo_rhQ>_ExHmf@_ldpd`g?GK zrui%lUpB!NFJ{aSztK>sx&Pf=gGDp`&ikqvb5%T#`{B1oN1`4yO$*}B`y_S2>iEL1 z%dDdF`?D6POtneTv!EX}POk#k=TK4ehFgqAi(WEz`FiXjij68Y1$$FMf+5 zW7AL#Dj{on|A~s7c4*0{s z-0eKUbW5hj`(q#O?wP}5C%k3akWl&haF)lkSu2k?@0%eLVqEgBZu8=u6Z5qm z{;L!HkSAFXaBY9?GWthTnm^?qwTjowYu?AXg?IN6=8y?9x&_|e8^+3|{>KhMZg z*|#R-=bW8W8^1Bl67G{>6AetVta_Vt^7qxlR^CUN*W2`M`j&U4?eF=ny&c#5d?Z?= zQ@xYiEoW%`a!cYX>fS20mSW zUCXEDyOvg*v;3;Ve7mgQUD*2HKYoi_@7ur6XSS5(89qoB{V?s(REL8#+UF{gZR?@yG*V+>}vkb!g=-B^Z6=aNq1z+m}iL1SKqDOQt?hXC%IYT^pQ9}cd0kFE|JHh zcUNhhp1J*rU_z0}t}U;xq%_9+THbi6s{Tpu!kjmEHft>T5!XJG?d=4a+0u{gjxSAK z_4JkRY!Bg=CWd!QPpwgSdvM0~V*ztgFEbQW9E`7vDYCWs#LL>teCWCH^-ur)Pd;)cQW=(0 zFIalS*{*i+Q0Q{h!mUzZXADoO4aa__w_MshW~c5eMww zKl%0l{gd-~6X!(xdogeYBzB0t6RExS_9DxK^Do|Z)lPo1W_MARzn&Avmg8=!a);C> zy$V=w__||F!~CNnu{CmSuT#nvGAqfYP6+*x-Mi5LEE`)}_|B-{P+x;)^I__Tbm*rta#RImU($Eu;{cdfg`%4p_@9*ndw&yv9AK26LWm5Rx zc>J%3Jm#u>XyI+;;GeE-FL!?Rn8>#Acgm~F zd)DdsyibqYCYElo$$s(d@7H&ig&+O91TgZl^3FqGWnjKgtp7{08Cl{GpqNZgBw#tf>y!iJ+>Cl%%(bR1HXXTQ) zzxVKL_2k)fs&kKb=*!PfO%`0(dtAFS%F_QsyW={8f)_RSuW#yD$I+oIy*$v+`03Tc zw_@CrE{jBXFMH5o{=w?)*{uhg)J>+vRPMd;%3SdIz!$`{PXN!@e(DC~`WY z>TTCaeMjF{mzUjEm~#5&q}OW6q2@QvADj8>cF*yNwOXRaS>BfIZ{m0Z!re7&=DQmo zt@T^W|6S8=rQJ9eItN#4WtIRDM!Jqvw5^eV?6oABh^ znlpb3r)^j1J>6!Pd&_c{^7L~#E=M+cwE6E_{kLUDzzzG)PG!PJwl`ks4YLg}64>(i zj(GV2Zf-3ZUB;HDp8mE{#kLHI)9q6au9^ty)jD$p?k{t#Ect3Y<&^>BS0)P{OXi0Lf8CO#tQV-+Zp!TVGBt#Q z^Tn;{R|VM8J|B77a>#4bt#=D5&6{UG;uUi++Hs1X_xQh0PhD9jXS%C;3o{;ZtL}gL zqRE=Kcd7-e#J0fM_F#gQq zb|_L{J@jJFv*lIxvwa2a%$9rX>K9^R z-|?vEH;eFP-{uT^kyhWDDeXp4!JmS?eMFf}PtGXhVvx(~D4F2OyKt4sX8F`ur>TEB zLf7gwmWjUp+uXT%Ww=zdhZ;|D&=+%8Yn{^krAiNtezUARb)@#ea?#7YRui{C8b221CrUibvBenL(q79civ&Rva+q zx&O7sQT~$g&7+6h-fWETe$w*k*q06q&-0eb)07<+r770k`nG3^;FORMEozQ1_+*Ky0t(QKYPefeCI z@;`fP{#WNOe^9^Nef8}h|Lo$^=di~_^FCZ&H&yM{TppwL4_>PuY?rujfcC`xRLMW~WflAjRyfSwAm1bL zGL(%e%m~0O|O?z^-pZ)&QnY$e{X0CIQp7P(fM|;0Zs8D3B#-YF|ip#PkcK`kFbC5O1 zOkB%<&ojBs5|-({{ao7wY%czA5|U&1p1^l^!r}98nUBRy%KuO+p3_?aIcGiLS~a)(6q`hZmUvy3mPHNEo&tW=f{n`@ny3Bwx!(RbkH)Fl zJF>Vc4^%{~`F!t{>yfj6iY(unLy1Yjo$i-R{h@W=`4SAo`hE(j|8FhjD+K%{-Br%UYZl*-oxw)oLj*wpb=U&)`+wq-&q9M690Izq?JbXV<~5 zY{h~)DT$XaPwDirhq*fScig*`#g=RI`s^kytA9(Rq)%*5_=#lx%l!=RvYCh*Cc0!UUJGSbo0##>*fi(zUnYD-&O^ZU36ms=O)CYQ>ZK z{nyuCK51aI)1pzt@_E*>E)LV}4R_+Z6i&_%h_Ml#S8Tdq;?WPAWp{aOs~rr|H_o?w5y<9U6f^PQLD&4lCq1)^_4gL4 zum7NNXKTZcOoMYVrs-Ry_xq_=e160E{;;l>fanwED~p-WbeeB|rOw04cYW$^Gd-F@!LzR)Tug~^=tCw8}K@|Qnw|73sszrFlF zQ)@B(!?#}@y!iUte@W%)_vx#gzbejq-_h5(YkRpbZ$rnyX?auMJb0g&D>&QkT8Y4E zt;7|fX`Ia+h0Y8t-PUOnqB#RDZNFsxf1P;V-h~U^bF~_+kotWnQO4Cs(i4$Ha2a@HJ6*kv0ma9>o)tPS9*N*D7Z2Fn)z~>bV>>zgDcOzH+}J6SEk*`^XX(w zFxn=fu~61u;=Ns}i|`@K1Dl+CZ>I45cc1rDi&Z0A@zuGRuQO_Rx*FrJsH?9ywfz5Y z@&Ap#FUjvd|979m8*$fNv2Ew3wTY)svN`Z@&YFo?eML9+U*h|2W5z8U9hFpQF)MPB zlGUxITg-blt!&;?(I)@;j@h@vft_#WJg9kV<8eVi`XZ~VSIEsZTUEKY-B>L@Cp_ob zJ+2z3lRa8=ol3*` zPwS@UrwQF#d_>FYPQZ(HTs-|AP zOYpvJeXEm7v=51h-n^Aik@8{LwG->?rh06OZGU(AwwLxf)(0s+c1)Tpb5-V1%vUXa zj!SEWx&-b*mjoCf0~aEZ!LtE_QP|$KSH-+uf`EKOa6ebw{Os)~szOq8M$| zEK)lso|=(pIX7im>3!j>73E$bM!nZXlT9XjZAm@nadVN0<-M*?fk$qBzpuQ=eO1!h zwK2(at=NrKYJ(4NV|I+lV z?&Zf;+08XC5fE`s&I{U=US0J1Y)a_MmYFA>2{A^cd+@vbo?O~D|6ZBx?)Rrl^G(iw zlFc&NSun3ExIXNhUAx^%_S~<_MEYdJG+4dAZgB8stCcx=Jb+R4{X>QOYHgYgBRmBEYQ@t=eg#g z>XK5eW=_%7S1#PideUI1bRNmz0>KMm@GDF+4Ledi(lpT&-30!@w)E&q~{*!#LY43#penBOA5r9i@V&G zcu05_8S&hZ{Of0NMQiK9-t7ylq!ybsrsq8lNoTcdoN-v@=I2KjOrq@$9qRqjUg=dL z9r*RxjEnbvy?%79Px9Eu#V<~KyFGleNl|-?#zD2`wdW)+NS$%m^JM4O&XiS2(Sgk+ zJB$7WERVP3cu;lbpI4~h&N+SFepLy2v%X~*vsErUy*Ykn!FRvquX)})i%nPe{ov=T zl6di5F`K?th&8{|#us`Kd#BZ%x#<76%x&(SI{BG$Cl)&`NdL_4ZF3;#_SB{q6}nqy zudv!9d+S4p#pAbmmm|&gC$4{VJo&4w{EyvxL$2rDd7E9=BBS_e-RW@m+1gV3x3#NE zGm0E%f0lm2K;pJd#83IH3x#vGG+f)W!2j#=B#RRL;(JYHaodwuz3$QWx@mP`w$)Oz zW@pc}yfdvYPRY4yHktK});`11cl%nE%687}YoC3wSNNxX$%U}(y`DmMXMXOGxSIQC z@%NA3J=ZH)CNW=4+OwZu$w_9FSy_c$+MVVljOqLyD_wK9)NCtqop1Q+{}%2!V*L&w zw=ON-qW|FY$N5pRrq^e#D=liONm6mjD4r7hd{Ntd4Hhw>6Ni6yAKxw?mCVNU@WsXT zW#7%S{(r815GWM*eMMFAxx`mC(@l%p7^khZP3fFvvm)Jnue^g*$hkKr<{Nr{l-b_x z^9}BBXYO#w<#RM&aqf^^nCxWbmdcY$>|!;}+pUSawf}JG<}AsQj|Qh+|2WcjJ?~9` z0!!wFhtC2H<}5EQU{g`;ydHJ(%*k1jnX@vNhdyr0^wZVxIny!k-98D;-bZnb(}Y59 znElxJ+S}S;=WqA0+h4P)3JhF(4!m*Sx%K7F%G_ui5-)>qIP!VfTFkvazvS~LiT!@x^Gb^ECx#^{{aBugQQ37!+DYx=to8$AYN-cZv z)GjSwWK!^jH+|bZZYQ(|{(bYvcGb!Jv;Hvx(>-6eO>OkE%#8Yw+B;#Z4fCd(SqHP{ zz4x5PYJ6q;YROM?OI8a1YcjogQ|i}EvvBFPiyXU8|JfLDx8RME#q;~$Q+c+_Jz$@p z{VV+BrU_S%9PF(KjClC*B1=vd%cWW8&$ToylZxay`{P&kE8Sb>flGV@6Bhe2w}@mv zo_3(jggxn%N=D_C^xCH{0#3!=yc*-^?az5hs4at2bA_gNwQJt0DX;vlY_wZmzq=#5 z(51CHb78S{+ZyIZmTol}pO`o|#!%rO+!s&HdlEWBGVrYHm*w0ktGzRQS}reGb&>yu zWUys&=<}uei<2EDwkWMUmb`i6I>}z2rBf!YxZ3#gSo%kY66d1+yGz9nT-?*N=8D1e z^t<~%3OG$Y@n!GZsOS=35&K2&erXiDakud5^6u@p_SX2;yMRL;8xJo(@H(ifrQv3P zfY4r1-aT!+PMX%9!tE!s&tARbw)0V3c)XYR66+Mxl*Y}AwuqN+l;E4ZzS%hW*Q2+8 z*k(Ox^l6`)`u<R#&+@4F+_^5Av-WiNVOPH{h!`$9TqYjm4(nqw{dO*<*3 zS7|JJm!5i|XR|PaK|*u}a~FrXQlj>T%O%n*Iw=a7ds?iML|z=a%eb}JN7O*DQ$y|0 z|1Yy%hEHkURJHeX^0suQV7H1)%_T;+{7&x|T9A3UR#(J#=krp}$9KL~m_!%t*PHuU zvdZzytm*>~J}kbzH?+k2x35^r35$2<#Y&IbcwOX__t}*bE;^?OauF zpMNa3x#Re-RA|?R$PfK#=a%a-Ivlv??YHPs8rT21%MNn|bw@1|l=7=co4RGn!^Fet zi{^(MxGkV|M{0#d-><_g*F=8T*_Rp^-kogn-1qnFfBE~L{F6MJZyVRUYE$Wd-C3I# zul;y{=kFmFw#6*dc9>bT8nMqPyK>#hZT1zDRIiWk9CttaziqMB<)Rt;TWo$zF!;Jl zY0L4Gj3#_94?3RtRXjn(SH$h9TJ);z#wNFon3rc5e!KX7KL2B_V?w3P_g=cQFLgC~ zf9X`7_#z3Hr*8ucCRqM_AImSZEpgY5y+>N>RA-r2Mej|Uu=e-6iu?Te#~&W8Kh;$m z^R_=rJ9zJguG>$(Jx{Eu>e>{a#w#;t_xc<=yJ*?Bj?R~+oqH_qP_lAXuKb1FhyQ21 zG;P{=|MjMomVdtF3w}Lo-e1;or-kX>(Oc`!Z=7>^wR-5BSF?;)ZSP2sl-Ri7+NT?L zW^hLcg-J=IZV~?ZXw|V3`{J$EC^GQ9S6LHMbL9R<)fH^LiWXd_70l;tX)9mF)n9$8 zYtu)|LkC$4&75vOy>@?p-@2NDwHHr+T<7_Hl8@n`g4f)Z!kh0+-nDQ(mwst`j(LWf ziGAbAE6(RvO|<)5zx}`T#5>NdPj~!OtciE6y>ue2Z$A5lxb)_ASC{;Zz8bWeZ=Z7~ zf0E(qy6}Z=O8g4D1RihZo9h=^YPN89fU@)MviIV3cLlE6he?SFK4NE|?Ds(Dxz6@0 zs-9-8LXG9KY);weT$=ghY0jMLstIyer92vxT%JJW)`Kgu{aNA|-@UemM>b$+K(4)wi#?LPVS z!2@~T8;s|;EN-`-t)*!4-H4a%l>Aw1@i-|%2E#8-?UTA6cjtY{@qF9mJol~cZm;W0 zzGObPoA*Tf62JBm)kBfnWxLbdd)HkvVL51&vp~)G4ExSyyI0;@e0GYknEdg>w)1%p zZ|_h&YQ8RS=R+YjRey^QuBM{jwS8CJs9kjFAla< zn2+Aq#q*ENSQ|G@Nbmj~`760gDm5;M9C@&B)lvTw{#8XP;>;|5mx|xS-j`nXkx6W` z&XQ$T#nZ#$mF-SmU~T+g8~XCq*;vN&JU3<)=Chny@^_in=BXb4Z&*y{(KIz$Rd;!A zwbN{ukd?`$KT8{&glGG=`Tj8CT)J=l+oE%UzCmxyy#7t)s5leV*!Ixw$hXZ(XXY+i zC=lYjOVOl7Z9!IeBa&p(f+w%kwU$POVCuYYB#u$1k$8Ow{S#W0F4Adg?Bfml=ZR zq<`0KGutg~`nujv%pqseAK|}MzV1hp{KKYOGpxF6-u7`p{FCsV&i%*rp5^6CeU$9j zDf#k@gJFoTboASHqeC-dmZ(|fd;HLm^by%C>Y_R2S=gN$&C^fbn|jmF*3aehON2}&ic~YKx0!#ntEqd1^7Hp53}z2LteMGNm~i*|^<{JaEnKwUW%^O)fP5x_ zd*w5m|A#+0FvoGp!|;dNu7`Sxa{`o?Xf%Xmo29m@Pg07to-624`qt|T|1FcyvP(5H zA3i}2ak?FlHf_J`C8n|WH2$VNxZOrj!|ZMX2HV5ZOk`9Wu~6s zsB`&{{*LhkQ?&k>m+t?$7M=d{XYvzC?;8G@$)`Kde?4(>I(Ofvizf_T$S;~1WqMnp z<;BOTzm)XuOus7d+a!@ohvik>UZ3~{vit3W@=n}1>G}KmdM?L}e=~Rfd=SG{vt!rP zTty|OxzU#s!phFAj+eQ^xjZ}R(nY246HlIQI`Bzsp5~grla9r(yf`DZ@l`d)6q&yC z-W;VvXOg~mn-~dL6`kYQn7a7ZH2a5eAN9AioOw@KPk#dnX)Q=Zm z-2BBmDA+SpX40##^|!i(PQ<2VzMpJ*HF2>C&%!yo+_KhacttYXJZ|EadAzod`H^AC zo?uBEPySh&DTXq)mOPMDH&1%Ka>mqI=TEIqv(GL&8@71@L(h|I%VuZV%r|;_)Baei zt4{cd_A`NZ+8cMLUj1z$R&h>Fs!DFH&D0;h7mJeB=A^DTGPQN_N}0WPthmE#B~HJZLN0b}(;mgk)BPA@%l(3u zHO^ZyOQdnBlC#sa4v+RV$_cyXu6x4kSravB*>8q>QRd|pmXkR|1@2U>7SLa%Sy1q< zu1DgR({2%Em*&51_KHHKb9dLh&6v=cxP>6tYwh7O)Pl4mac#=FZ$u%VMjmhD_3 zZ%gUqKg;UR7VguSCn+>(c2E7kA5R}Wka-?@M~IPAE#||9{<77XFCHb-GAwJ2joNrM zM2zFlgIa@GUtBdhc$-dqxyZKTjDYOBxp_112wQaon?KuB${77K@Iu1h)z`|t9u(5u z5q>$edEEhFZzqx4jHaRTf2X`%@3ZVz_2ym?!(T;wFM?a%-P+P;U6pQd#zm}1|Ep5r zi96Azmm0Jd?CVlBRy3ct{$~2Ga>b?Fi))u0T<9}rSM>sU3A2Qd1##z}KeRh~xcUx1 z!;xdZ1OLi@ee|>H&mV`6pDS)!?Y;NZrRKn4PO*pIKAB$>z425->iFVU59_bhfBSv) zS$FM)Ag#%M)-v1WTI9wBn#QZ?glWefk|ID|0Ma{w1Tl{D1cTXww)<0xB`9txHgNGJuJ^sMw zLh|iz;jfUa|Dt6^qtw!67rhg|OF_ZdzXQ zrD^YQk0M-cv8neDF$;udAGv>5gY6H4 zb={rPl&gK0_k@1!DK$Ag;rF$*ZL>}ZC8srd9p~k?)jZ6x`GY&>%p*)&*sr%X$=3e; z^jN9gDYp8<$7!?Q-B6j&ICXxm-lM)pG5oire^k_5K2*7II{PO3LNjswO;&gN*f$!N z37hxcJiJ?m(MT&qX7@p+6pwi7D!pnJtOSC403Yq;;`e$Uys;2tLatSBD-#ve~iBFPTX7M#|x;r&( zsZicq;Y+~vwfO2-(Cwl>_v7Ug zz7KzVtTFmkAvbOAW{39q%D&N6oTe|rm1p#aGH@Q+a{Z}*CtHxok6jzZ>n}Y1owtJZ z=fmgQ-@M87SfOUVxMZhUujIlRi<+)TW!Xn>_o%%U?D~Z3-Tde6UlYRDNbC}_dQ@w3 z@|2YP(?_i}Y!hU)&q+K=?Khhh++mi!IkF_o;(~vOUGT4kpUW3M*5i?DcD^C}a)12e z9jlKwo{o6Iu=Qs6riYKBrUORsL`b%_@_x6~>tQlew}wofG{_D0`d+Mmd%bUY-t^KiQ(pRS3q zg5;W@wTGFk^yXH57Q88uH23h% zms1!P!|<+<(P5claG=$v()#F&oQ2Mt&Yzrm`Yy|6+1qb(OpjlTUU+#g!_k?iJH9*0 zD}0)?>aygQf(xrMjra5%$W&asB<#!63wPU}`nM^t7O%@Yu#C-8cjaXD+m9L)FV8o+ z7wo;UYv29$nLO8ahf7|ZGiQbEiiKS>8?Jn^i=Ud^bj?{Z$7SFCV{a^{ik++AjExq& zc_P;>Q%L)te)thKcTFLa=Fj{2pGIz2*6*74_t77pm)0iP?UQ8x+i!4tpnQx$VOlc( zS^uswo5Hot&($LCZs~c)D$K8ZWMxd$(`Sq2l{tDZ&)f8-g%`hXp^>O4o;Y%sYC@$Kd?-j5`-hRw}8j zttgV_efULlhoO+b!+Y7L|4e?&D~sosUA}$w(Mi#3ZC7vJe)QLa9iCMSH&-9l-yA1V z%59(eMYho+Ke3oSnOS#+9(eyEh7XhnIJM(J2Tx z7cZuG{q+v^J9GCb-c5a>CA?n=L$gt$7)~N$)OhILkC`)A3_logSJhZO@sHzEzDf?{h()Wh^duh%zD`_$CcWsRo!(!-Y|#MbVx>8LpA zJ2Byc(84_nE3B8OuD`tcPN4nAu-qVv+bO3FYX4@o#0ze@F8OVi=ZTK${X1{*1vRUR z{I2^^>0{8J#wN9%`TXsGR{i4Z9t*b`J3d?T{msrY1@T{P|E5MZUY6hgZkJo20<%a} zp-X_spNBWT@W>bMTOa@BefbPFc0p}tzNJrNX3F1Ka#3>f^$WKvCrb+iwX-+$@@`ZO zDco}|LqFx~loava4PPgHkYDeYUUPNJ%H?6@kGj++L`*i0O|pG+sl)b%oBjfi=kpAo z+!68iJ6qB)ac!^>2TOZr{X2uRXD-i+Qj+@Bs1)LUb8FXH}2xrOM+%~t?HbB{L7sqby#QQI2 z)n+VVGP*JI^JjzjnPU63X67GBoD}l+pTLR>6BC}yF%Zgpe8lRb!{HMTjudd!EV0`e z@P3}Oq1#mTM4khCL&VIMt=R0i=2=!7pSs8lBlpcMeZRMI1^t|{mh~{hnTJe4M!VCU zxWt#2GpyZE9Qayv&FqLrM-8UWyebyPw?^jeZU>v6EyCBzf1j)kVb}iW!M2~#k2T%g zesVeglQXkR9GR~5a_s89?xj6P(77!%cydGUzP-*_Gc%@aT(vgx;O)MhGaua*Y-`{W zwK=c9+)KO*1sl-UwqvE zV$Dv*Ho;jjopm+pi7eM*vo_8v3^Y8$FV?v?i|5uaX?KxRY(mm!nJT&)g=gn2Nq4e1 zzWL;&xhyXlm!ws?+~DxryTj%4$*#Lerw&hNxGCYaMe!`R@TLAY47Pp}aVyr>cJmm0 zs8@RG8#z;;QMl?k&zyp1veP+|o4Zc0J(Vn@VAXte{n@@RuNY<~B+01qTuwY<<#WyQ z2K&3W->kMy2n*rLl38}IZdc5U$W*~aNoFMit(#RFL|VdQW*Z(-37+7dve$&=;qS_o z3gWlAh0Kgp!mkT$o3HEr*Gjrq z;#1ZQ_ODVQr59faH!`X(-J{c?_SWi_w*U3x=NEde?wrslaLrd~!iJ6W&M%t$SMQ(J z?u1G9$5joN?Ad?+dqqTHom7nBt%ff(?rOQpcl+i&o+h)1XRU;nNZ$U5?&p%G%wEIJ zHb0(gmC6j0ncFfuSFt?_V|jP7YvZ}5C2tIiq}Np4pL2T2CaE`G2B|81vx3;XlXocp zso>MOZ8amZE_;EyMfDExlr#24xAt;ApZQb&+`BiL>-dDXg{@z$*d{*fA?xz#w=WrM z@HlR>-6r!qfB%(RE!LgOv(#tR8$1p9<9J4<{=DRKf736nIf|3GQJt8EL2f+fa6f`&OCOjl~-LqOx3qF3z@;jy+CKB3}c_c&S*P_ z`y4Iqc52HDf;W5nu!SrY``i)hbVAWz;;H(EebXK_Fw30O-1@C@vFs{62~M$!T|)iq zM7YlAK6{!GdnknYS4_y4Iqx!5j8Dx?{#*5ym-)PSNXE* z+X8OMTa|jhR+x2L>PyI-tFALsS(i=|TyFBtGBINR-t)_kOE&TI{rQ#Mb?m$Tg0n`d zTO)sIEvj1J70vlVt5)K2{m11QZb!_@-dygoQ93`V!w>x+isf4>%2 z?Y}&K`TB?No`1i3@pAa_)yuD*fA_7pFl zcHX(VdGq?)x2-?@@XeRs{qN^ry?FiN)yv_3>i&OPF8=@A>Cm|O@#ZhDpMSS{@xLGa zq4%U--CcBQ@6~VLZtqrK_tq>p;@RcAXsr+He(lbAw>@rm>G#lGuXeAw8-D8SKGVGI zxieSowhh0%yXd!dP1eP<%is2w&aSM~>rLObxAtGx>T4gPw14XO?cSa-*V^>{p;hay z<(lWNE^oTC-e{Nh+0!RCoi>ve-F3$L(z@OI+m8IWcU${RW?a|q@^`E5o;JunmUn0O z_P3k9u1?(@c_x2->GteBmwW6Ntvh;Tk4ac+e$~6*=h)}1x_9=)=TD#VE|&d!E4_rJ ztRiY3@74P2k$-$9vHkl!-!Z1(_xkOov%|B^Q_oE(xSF}QcKQ8>X>(2GZykTSyKc_C zzBr#3%nO*yUTqG49JcDS{KA>%Q)eaE++V^hr=xj)cirjY+I!7QZlpTA*<5XMGxoW1 ztbJ(h>$)|Ub@v}vixr)telWM;x;^jiEw=m1Zg2m#@K?&gW5@db_NQ2PU$`cjvF&E{ z9n-6Ie{Qb1zT{zPO-b~Qa|cyI8WX2qzaKhJLF;zhu1zm@@EEwvuVGrZ`BOu%livhSwfe7CLt#6Nw zjh`ATTle|Fi|=25RqfpMspwPP+_?FV&tGS^U80}yFyr|2Ls<)>WVNo;O8pf|G=H}~ z@A>u0N|j|iP1?nE=a+5XGRrJ>dwli#GrKo1RtFen^(bc`Y zJ8Whfmq)5TzK|?fxoZ{8}nc;ou5ovgpt-B74`xyb);JMS_MgQqj!F+R0x2xOhJ(MW2R z!)8v#OuKo<&$A>PnB}#I@kWxQlx<>d&=l=GCM_zzlN3tNu*}ZB`{+VVyU()3rssR- za!RUv5ewnqW94R_%;gt-z4X%Bx1tS~BaHUv-meX<3wygqnwKNzs(Ro;WvPr=FLb^y zeYB+EqS(Twoe#>p?S*`P2x)qK{jp_noq$eQx$sqoTp@|oogP1!BP)tNF|82WRI>b< z_%5Gw)g>?OB28-NZdWOE+$gopIsWpeO&Sej;QHfqT(QWnw>KZ}WB=^H zS33LBb-Rnrmlr-LTVa#=ks~?px846;3`JS%FKU#=pKzZqcFgFKeD%xc66|ha2Q}t( zn?AEFPheW|LddVt%4l`ogvq~bp65m`p4{W3P;mbB$ImAdS@`2-Z-2(ppYCv&LA{M7 znes*ZZc^LEoOk0qC8 z@5uD9yKw3|TfIx#+DU6?yXimKIZ@kN$G$XnrV+0S126M^i?la0r@P;}+9S8_)zPUb zC(a*K{wd0*Iqe(orM&wyO%HBcpL*-}{MRh3cgogYXTG+6`^oUDoVpU(pU$ldD)6%s zF^ts6oV@y|M%A_XcMRUB$~~#mHJ$q7!q)wcN(ZI5?OdK%U74{Ud#`J;U&~oBe%tB6 z@8;~8TerVF{P5?mk9;Rp{5<+pp+ZhO<0H$nq_>TG-K`>3Uh^K>tFk2f@_o)%cB`GW zWh0xqd~;?UN|c`+_qr@hP^y5#w8pEgYt^mVmAX|9tt{*xpMAg3@SuKs_C@2FA8tpA zGcWL7?UWt=@`xh;78wpXBR0ob4pFh2Tq|m)ce7q7Yts%3kImlh72WGy(3&!_BqL*$ z^QFJSOOE}0yZ(GcLhpm(A1^l_TK_9DZray*w{|vv<;}WvNd9;9x{}yWp@%YS3Kcw9 zwDSHo-TstvP9(lJZhrgj_4m*J*=1F4`d#|`T-_jva}IAxPtNX`dOEmo-|G2tEj#s( z?$OlpXB2<@okjhue)O`mRoi!zgl%Mya(~D;`EK5YiWeLCdxVSnHn6b0$f;H4$Z2E! zwQYtm&l!UTrR>z%ZaOYKo~EZ`?WBE6Oa&kO5q$pr^xgZrQkyh>S+7l-cz@ad>`0a! z{iU}qH+1YNXZdlZ+Ue)l=yiL!7rok&x8g;w)7yKx*Hf-_c!eI+3>pd;CmY*tp1H)1HoHeZo?8OD_5BF>>5{;m9l7 zpJ}hGyNr)*l3*}h{7-@}c2m#`zT(-HUwJ?C?thkH((?LM>Zzh{d-mP>P{zA>H*44Y zxFwtYR44vR>|~ZW$CEtg$GOGxrpT#eFEXj|W4_Yv_OM=GW$qM*u-=?6Z5@slU%>Av^m zx{{C2clwi>qPV^8E#rB$r58lf^BOZ=ec*G5KgN^g_3Ur7-KqM3^VSBJ19JCWo4jXc z8!ts0LL4c>8&BH?zmI#LSO_O%9 zyw715U^ZhyLgR$_BC*EVi?4SH_+Eeak12Md%7?mRGO8|B4lgF#{e2*{BjDw+3ym4; z6)*Z`-n_7_|A4+Kmw{=qD3go!>feVeEfe;pa%no13MlG2E~!*Ho-gEL#?8{o%4*OS zwOTnf`{S~UI+K1feiZdkS$=VTUO?)TK=UV2-qK%l8N9_`*w1I!b@`--S@fkv7k)|y zD!iIsF}2t9)eZd}hCxQ*CDsS7Z!f+1uaH^%pfTGu<7{ZOg_7G>ej|f3%Q@k zH8;eR>qH)UTQDuPB}F&lg^!E+A&CS_Yo<4ooGqFJ+zxD9DX^ijR%6Bb^(F^?RQ0Vc zPP?3Np+t4wgtQkeZ6*63@yy>h!ROy{UG3u%(wolA%6XTsykfyaNfi!_gKOUAT~aVe zo%Z|o-~FyTq#_h`{%*RtQOv+KPB~_m@40oqHQ6JZ8YX>SA#|*hH`eLg9EZ%11;1Wr z96$L+WqpaJ#yiL3%nR;KU@5fUG~q+|wN|d)YelL|M-OWSq%1OxJiMWCX5AWgCAWuX zj`}(a=+>-wa`dr=sur*D1ylAc(g zwv;1Ri(L1Wd+88Y|NC&gdjoSSChIIkl;MEn%T?1rx~tPA&ZsZ1?fw#iI+PL@SCry!^L z-0u@v)WjdR_ox`}L6)}z|e#xRFV z^*}(0SL$T816m!Xf0P1a4xAOOSdu6)L(}f*-P@INJqcHHoNT)Sts+D}Of?CcbS_$9 ztLCLi(}XqOuDQIZb>$TUjtO&lEs8#s_?zu_>=w-R*tU)T^-~Vrt>(Nx&uOIC+T<3r z)y27748DA;oaNBpM}7PCbT+$aFSu6z?qpd_1Jj8o3wLl8igYQZH$BwSlE{24exA+a zaf|)dZ-2hA-8WEo_TK0c<{`*E*JI80utPRe7g_#TVU|+kwD_q1f|#Z8;kjxSA51HK zi>Lij^VMtKwr7>b>qDmkogx*&V;f(>ji>&gK^+yI6k>w(4g?Qty|N)9?P{7Roqcc@25|G zc4?a6`QxTle{1d*9PUorYhy9*@C(1kM~aWF{=z(|ZuY7*Z-lQ;Hi@)-WYeXX@?u_+ z{zD$+Gi^7wRUYGe=3uO&YU$3A`HuHZmqS9{4!=}IyVQ$$6Avs{yhSrnE!4?9Xuj%( zMvH)-3qt;}>4>w$ak%mb`~A(!4fw~(QzU-&c3RZM(rs4zY~%UUS2kwZ=5jsZIrC`E z!dr(t%qq{>u90}%mbY%gqEeM-JC3C7Ip^W;IhRgys`^^r#jGB^1^nzk8MlOn86C}IyaJet%ePK1{cHvT~oc1V(9u@~d z87Jekj04ej8Om2L+;;bPIAe0-64$wn%LJ4(zXZ%`d(E-&!af#HmHNc2O@B34sfhBV z_y1n8IAPV|**gqoojct)_siGP3ll!x{?Ir_qtfGXhtuxH3o~}i>|zoR%#g{QaY{Ad z=j3Humt1-+n|f+v?pL<5TWkOJ&X_g(Q(*h~hQtW{J6+lL7x2BxQJf{%o91YgDQ%r+ z?p%AXNMz>3H)1~@Rr5|cWOZ!HWj=+2>?@{8FqED+YOGhYXy^0AMazHx6LyLGzy5u% zaQ%Oy{r_(Nwlj#<%WwN=?8;eV<=o}j`ZQTyn&tL;wa0(MW_v`R;yhrnbpDFaGn*_q z*2vr|w)>a!_srI^?_0CDo0EFiJPlaof-$%YD+PPc|jxUpU9B zqi%6?{&N*p*;abwt1`|iS#Y*D%6jd}1OKNb zJV;C1tnn>svW@A4gJHZ!PZy}w1}GJjRestNwfML6vky0}cyb+F|Ki3=JI9srCr#qr zO^(eBk}IfFouvOgO)jH*&(>#W*C~98;+HJnv_bT?hwG*rDsD5n3}t6UtIW4}rTcMB zqKCtKclld$=2*nVn!S445n{1-h27)kTSXV!FIBhx3gxi7crea(=4w98BP&^^o+C-z*_YdVC~enz@?{R=OGUdq+phdI)2)BnA+jl2^xdOA<4F(MmIN$0 zdi!GB#iCsKug`v}#l^HutmcxhIXj!%NkH@)$KUS@I)p7w7&|q#E|1JIEqZ-z+STbA zGZsy`%2GGy(5vF9GD&imIi8wo3vTKD%5(jxOL2$E-V3QxLT=i8p6VF~?--gzXRpvo z%@FWg@G&#Q?AZdR}h#PY`iw^@B>x3T53ueo#S?t=h9bKc;nQ+CE#3qukVuX4)& zd#@$=^K$*Nsm3p&opSmZzb%ZuxwcE?(4)N9)&}7&_pe?)$9(%+@ll@Y49x4yRRV7Y>`8aZ_S2@O$Zy#IJmH$p%C-TzOdV6>G#azporK zoR+vmK6t8c@u1_Wj7{^Cr#73ddO8Z$%i`>*uQm9t+pFyx=gK$-$Re|CS~or&%Zax9J0Qf*5q5BXKM1ZX=2~ES1)dHmh`n+#ARuPoDuf=a>ePI!@G&? zNgKI7G@nU`n=DZLYkPF7)S|cb|MN~wJuCn1e`0Lo|E@O@3#R=Qv73-ky5z&<@Hbx$ zB~R8`U^C@h+odPg9kdJyl|CXBoFh>2e8ckEXRW&I+b%fSiZiS2t#1uk6f?cU zZSyR(S)8T?F}@;svt4HiOK_|;>FZTy(ProkIKTOeRiux|lt7V#2J@qn=ALx8dd*sL z!vf{P&J(>_6^rftJzl^4y*0dEeCdl@pH}*5tX`Sy>SnxQs^sTIuHHgC7Xy~9_;Qfv zNJyf0V|VV1OyOJ4%pYCa5u|0c>`~8&B|EcJCAvap^eQciZ%PT zlT!{wPBn>Ec8Lg9PM80xbK~z_`T6VDtv|hb_4(+x%L`?UG;l!uG;IBraS&KSpE0gpDL@r75R4O)_-~adsfJ^1F=4j^NwX(C!G1Dow;bo zqKEsRG)=szIO*Fap$XqBp1+kcbzJK6_0zN>fuOlM3z-TV`0l-oAN@?j|r<@mPco{!YExMT}x05sQ#*`j8kwbb7$F8{8K6t~l_+(qgj#8P;%)5mkd|qhf70EebRp4`MgOocr~x9(5=Vy{~SMZ#Pd}>zQ*$I zlE;eTvI!2-2mLZ!Y;vyZJqhI2EsT0-c))RcuutXr<&Gt`Tzz$?_ByVWS*O5v{^d8J z{~SiWo(r_Ix%cg#?E6vQH8iq(uHwCZO|zBsvNysS3lF7*=lk5bxYS17 z#{A^7P?O_LpB5T!nW*7y9I`f#z37S59DAO?8$TYVB{fW5extNpUT~RJ@ro_qH6L2> zv7gbg^-&Q|xpM5Ba@zmre~$HAxPDAcHl3y`;<-(WYmVyEjmu`Xbx3w_-j4vrUUm|2cD_V0H9|B>mr$GhcP>-RX1T z+k_LoZ8PR7d0k=st?yweDwFiGVb)cN#+=-<=aMU&jvV7i{C4D_>W(iKp9>4Vc}-l} z)Z#P0VczP4E<^e4Tz%q2Fz z_S?V9F(OJ;6B26n{aD1YpD)j})LkPfO{uwWqF7%=l3B_Jm7|VdgOXmJx840^>MJIt z*hiwVc@}rs7~V3Pyp8f=X2|tr;6Hb|o8{~*5vE0lI9hbQPygBaW{cA=(fFmwtsBqD zKmGk+?mjhyPXVlZD3O*DblX=+ExlJAZ#x zY`N~uPOJUla#f}|x0ECUbmrDHFPUMm?ykMN#w3F>*M&xLLJNx)san<7hOd%VKQ#Z) zpRMiUe}8%$&Yhj4dFjpJU4a^6?FzCU5u9~`uJmBf-R&5}oZ{bJn?ok;p+-uhIgw@*hZ;?s`P zot(Lc^2}{k?c{EG#1_SiT-vIz^nUOM^0+vw+(E!wWEyB3BnaujCG+qZW&+os%T zw}i>_cfA*r5ouk1Y%$NIjUvyI-PcX?nzlXj>eQHIGfUp;z7;+(H`zMxZ4J7|vQr^D zR^T+}&2$5!x26%EhsEA&{oJ@Tp6SH0MSRZLt^Zai2VF2~U$yVN(Nu@$846Q%(td7i zPI%sPR95B(%d&KiTO_9m z-%;75HeN>A=8jD&nGV)_ZCLB%c$us=v2h;xt~>K|V{XuyO)1g6kKcc9f6i$-bG=vX z{wZZ@NBO0HaJ2g#Nq1_wagS2GEA%9 zkr~1o@=~|u#13E8g~_aa6-*N+iwI~gJnF=@-?6~+S(QU~;gfk^#f3IH%$RF2pJTNF zQ)0o%V^#T^Rp*Nzeepu7^j^I3mwIoOO%pK=a_rJJ%bhG^e{~Rm3Nn%Z0GTXzXfud}!zNm)~4!lKLaW3p%CrlYbo+ zI+kj4>SpJR4?Z0iGGiEie%W&3>3-3Bm-#|BPwYudU9{D~T-eDW_udz8r_G98-iPv} zUT(4x*?msY?O@iao4Iqkde7ck+4)j)MvnLI1ts0=ItfcSo-51yvSw9FToc-zw7P3r zfga~f9yjUZF|F3eg>Qr?9DAJL_2KZU^_kwMgqRAKmzn*tXVFnvv*T!1hR}JBgZoas zG@U2r(v$1zlrN!iA)}mqLUh;5u#Zj~4CtfAF}EV6>R0P}hmYzq<0c#Iy^hNosWN4v~rDV(&Al zKB=Le)#=x(ZehEVTg*$W>{Gzj%xR~;x~NQZZ`k;4#!=I7E*UGu-ji$XP6UMswVH`v zN-L9T<*7Xt9qwFx`nAaE3tk_#8EVhtYy23jYblbyVfSp2Nr#W_IRmhQ7b<~a>@xPQG zJagW;ReLu)*l_W!meY-YlOD}*bvJO47r0egTa$gfb=Ukh@xzBbq-tJsx)@E`6Kb=> z?!>wgIPvd@G8Yw4?c(?d&=pPXzzeO11xefzaM|Lp}I?z~R#$`8%j?6l;sTK>=PLA;w6zYMb8 z9Ozabv@Ybs;iklg?oE&5xb4=T2w1gebCXyBMNmC@}ay)$2G&y0WtMAog9sX?hl>W_rc3f)D%ih16 zZ^rF*>0CV}qxaU@yrX^}7b%uW6xJGCytIC2#v-TF=Iy83IUFtpxIEdU_FIHQHSZDE zbM@FmH=|2bR{t!mF}$RiRPu1iPBOd8*gmIHi|ihnPN}o^x!% zm6CY}+D$JX;k4M$;qteMS4+D&HhkXn%O%Zoo~0#S;<3?gy13=~pDQQqUu^#srLe}z zq3o#ULcJ5sa%=KMr>O+YVqM22T-^Qt!t8GX>ofk?ND1W`Y+w;=d1O`iLhoYJ@2Ng1 z?Se}lPqj&Uz^LP=m2_{_y%}rm>o_)Uxs%alQZnuI+>QU9Zsh9@K52C6mOE2+dQ9l{ zc}%t|<9zu=KOS$?Upi|$oA9#xvXPc6)|^=?JaI+urPCEZE<1&B&)>z)0O}5(Wa++FE{Mk!+!nPVR0T=%_6=>J-Q!7{+8OiU_rsu+K3(C%McHhDX|vaA+!9c7 z>wI=-)x>4d3flrar_Fvf@wc?%%9s^V=ZmuDXnqWsE#cvF%e~#qqp4r;`n=;$TAyXS z%6)jfXo^?w)Ds_Lb-$)uQ`$DEW73JUiieNNfBB?vDK37`2A-L$cU?Bys1{7*yU z=<+X@q_@vV-!FW3`N6`V>NV{vKV7`A@#=%Ur`E5See}um*Jl>B{Jh#BWF%5!GU>_e z7@L{?Dbq^)eZKm4y$%rBafsu?--`-Y9+WOgo>8%9R*cn}G_&?!6WD%SYRNO#DEC!W zy;E?$IkU^0ZL*=yg2Fn_?c4^z$$_hSAKvDD9HqZuazJHTN!+G=nQ1o_RkzfeX_RCc zP0_z2BP5HO* zjD&5x7yA|8D;KY78Gtg=-D9u z!ROh*c}kTrp+EXoa%2YbO}?LLzHq~0uBJMzn2#y-zt=qZFFI$>@i|)eVt%B2SJLTQ zv8VW<#b$Z)2(_}Tk7|F55)xDVx)&Um>C*epxzbO z(*{+eS`lLr!H6G^CbnETFQtBU%kj3h27WuoOr@Ho&-=9>K4?BY`=N%={WVq(+GWC5 z+Ow>(C^*ffV7BhdiA%~m7HGR{5c~B}>`IZ!UD<{z2JO?cgs(rUx@yzds@~(XH_lxC zNBBd1k>!WaY+bvUyNl0okLF|D+iYb!c{6xi`L$cu8n2r!==nYIhS88O&#qACDXSKA?Xn7< zrqz1+*v{qJg;D}bZbrydwAKiGY_$(+lxRAt^J(+$N9GSwKJKdPs(-3ed3Z_EZF!kh zLYKA|EcCj#fJ;hG%txeg?^&*IOWL?BydId%-ud9I^ER&3A8+eUnY?*5SJc`3(X8BK zoqt2Vo;8dwx%ha!G@nm+0L#5F8{3?9Oj`VHHZ^w?>aVu&KeOYL6}lNH^}PJ)0g>tH z9(bP~S2iv#EQx<(|&X*S<9Kql#MYwjGP*llUK; zOlD+N|1QT`P}w3@alG)~x_^I;UT}H2d7A%}=~EUY_a1LInEm{#e_wJT^M{741%Y2` zD|8hmC+`mu*E#Th3F{j3Cr=e_F($;91TF)ts5TP-fS<^ZGW#- z^xK)Hw<#cQ=A%-U#ZNEZ;#;xp(3gc*x6GgS=YjFZ*)P|9Ewh*^c)+2~ch38c4^DFz z`z@G}yu7l9-#xnhqO+=|QooRJ^X=Za0Ev%bVSMaIs^6RL-gBz#+nz+ev*zWO-*r9z z;k@SR4Y|~*7ycbw?@`rOC$1H}=f~q&u`j#++_ElMn7CZp)W>|i*7Q&ZzKQ*|=NlZO zQ#mSA>+&^@ce}PKBtJ=?tJ4#DbLkWxDWgnFXLfUkKP)^Z`K*`E&$PRGroimFvQI&` zrNb8fB~LdiEI&2b^ZZ%CV;t|fk8!@2w^%Byq7WabyV3o?td*>@bTY4|Og#ULNx`30 zM&tcO*KI4TQ)Ql}oY~sMbnM-npH2y#v*)YUoZI{Erc^CUACK~O3l}eauD?xD7p|68 ze71~#%@-ZoI$!ZwZtOW7=NZS0w?v-QZB@HmopIg5F z`ij(*T`>0E^IRtHZ_tMQvQLf#pZ~9*XdaiywO*m_<(imD>2ljNE+ro6$W{34Ht}K1 z>-#e+c+RNix-6^7m@XptWA5uC-dlPe{i)b;MCJLqTPAOcqsv3yU)FKI=~nhQw(Y`= zGVT(_7qZv=&K#MhsHWN(zR|(>KZU-`{)d z#BD#z*O#VS95CECx#7Y_e)p%EwMSTvOT1q8#3|<1I}6`g2U-Qb)o;6b*d_Q>*(&Kz z^DOl|#aA^X-xr?qv3W_1ysY}a^2NI={PNvrpM3bc<{tl1TcbBmrDrAIT0Kjx=3uGw zf;B5A{dC`y^L&=kmGy12+1T!NU-#iy_sx%E(z3lG6a1K+_HEt!POIHQTF33sMy(C! z1x<6Rwyga;SK{T-j+J&7_nv#Au;|B;mwBG2FIvA~p1yuv{@D+kdV+7(#{KX;@~A{l zr(kdYbIa1VXaCu?_y!*1(bouEdpfDreR|Veb=@ml)EcDL893H_&zSDd8O%5*<5cRW z3y&u}J>7qDf5GF%^;?!5eDl<0qWW2dP)&~sT))$n`b;s4c=9~ac`w(4gQp)m%sd?E zW!Nrt@_@s%i*xty;8A+9Yx%Yq!+GNcvQv=r?p87FG`K83S z{nr>wr)`OsT6jaq)+heG^8(L?^v=tz7en9hSz5(BdrcMEBd)r_i}x>t4ACFOa?b*%F1KR5ROZ6-vxEDmoK~z@x#kkvm8=soOD^p1R^h##aZ^$DWb*laKik3u z_TKvtupqqc_z6i4z0JZlE010fV?Cc15|QQ$1%9!v$0iB?%TBxRJ7eLd16O~! zrJri{Tljxzc~YI2k&*awR<*4sf;PXE5YlYri^$>&i!DB}O1!yXf^Gf0SnI_$mwxhm z{TU)|$@^QgS?K6`#-kedUkH5=eYJ<5Y2jpNmijlfs+ak!q+ZCav$>%`OR$F59QBWn+tB1N^fqM%+hF4 zdD(PJ#_xFoALMNl?rJe*sii#6511&_B(lllRHwoDa+z<+_ixu0KGFSjefh>lnctZW z4CgA=9zIrg>X;VnnZ;uSSXaA>JJ_0xa)BGabJjIcK3Qz5T^5l`}Vf&+IAn)p5}dpUJFqd!tr3 zv-9)Q$9@Ht#njp_T`T&3Z~R5(uTfnuXa4tZ582qaqM-Nr;}0ThH}T$Ye>1J_?)=$1 zxu?GUnLQ;rY(Z;s`tgg}p9we|=7w>#gT$oq(fAUkG_Rm)eM-}>rf|M%Zn`KA6c_YML3 z%ioW$uYX=~{&Uam?|&O6y!Yp?o)+ghlrH$aEX;_sT*nt7?Z(0XL*VjFQR~(ha;tdn%Y_6oO|tS}wy5|KY%7qx zN^nDS>x<8ym!JLgbFams{b%pI;IC^EExbKRPPcAf&xzLe{d->RxtP!SB&h$(p`|=e zPVd=VsMmY-?K;H?2Xii7e*H}FYvq){m3J7LwU}E>%B|JEM|0Xe&5vYE3V83Aof^7p z1H1P_<>l2Pim^3ca_`ElW7<%iTr64+==|vOhZ2U*Zzdu>8WBL)_bD&i!7JdGD0tzPy5~etXl`t2(TVxMVb; zra;I;c-zQ7qM2;(zgG0H zeGBE;|N6D3^pnf8Iq%#&%^)#lvBxamotM{pEj<77(d33D^9A`t6=y8ZkYHcCVajIn z-%~odZ$H$sUBr3xgMoN+f80Dxvs@XcK*`y88y+1C z%QZ32xm3pJw?zNcB9Rk6A2RQbl$>f(q^!WYIM8!ZZ)b$1+n$U~_AER){kEwrJvuK$ ze@^md{KBXyu-f=n%)Dc)6AxSE3$A|2+0T4tvuyV6AABqd)~@ePYO=%@T^HtAzwFQ( z+YQOx0lOTOALRHwT<(29@adC7pK6ZV>7F%MdgKc4yVH*(bKPf6G48*;;b7RZU&g9I zzTR%K8+$X1LYK1DWEE^OpX|SuMU$=G>-z;&sZS^CqpK_*_XM6M!Q0_cqrt_t!NZ7URt9i!crc-^FR|dR&`Dx|sd#M>4 z=S6I3wASGf*EL>QSZsLotHGgF6TNnaM6{eyVq_Lra(|amNW8c@)5XG1CKsv>t@iq8 z8XR-t$FU2JmS?RTZfsy%vtLY^&tE#^QBIF)r}-xZ{ak5jm&x8*99zA#7cZaR8)UL! z`Ng$Ag4)dvFWb~mW5C(38tVSzCyy`#pV|F+a(Q`6F5N46(m7{`fQUo3sND%ZX>JwY z9>b-xMEVyNE_`svYt=g6)ca0b8|HKyt=y-fxsXx#b$@AS$m#pXZ$;k9pl%bL6Uv-e2UK}zgl2fWx42N&g$S( z>-+x;+~0oOFg|ZyR7-`wuy<#IY^eF^#de39utcf~kanqiwHNMmGuX5Y@*I)k1 z<>{#O+s)7X{rsVp=L3&987J3X7t8c9Od|L29WZ+CKuDTS1 zzL0+zyJMwT4Ht$REq|0?cq>Kye@kB99_=M%;VMs5Lv%tC>`LD4+oC){^uvp3?d?yN zc0KUn7B%!Zu|jgjWt||Gt2VCZ|CRg2{K-{2vgp?-_ZfP{^0)Jv0~;iF)Gd6}{!1w9 z*qr5@<_9ZtG?S> z_r5c=x|-kRy8e?g<9m^)u#0c|G^gCZW6OLflyCOsEScYn0>U1w(J{KeIP8zX;ZB=jHT3`x^gJ(a-napRnrh0XKLy~B>Iaq~SA z_;|{~#)b31jkJLK;_0pz>>`gcJCPiFwJ1DHR?ckEzD|*}ZSxmWLsi&>` zuF>S$!lg?Om1Ns&U;W`<^}M?Ox4*sn6~6Dv#7Zp{^PUB>a=JQwq*qUk`=qaRym&?Y z)!gY;H`^S7einvJE!0|bPTuX)rr)b1o_l*FFp2g|W>P#pDmDZeXaSc--$JPwzZ;FGEp;>L`5LjgPHp2NQ|IZf!b@Zn7Mn~Ac>MX5_PW2Z z=hdZdZ|}XvRLH!o{iyxUHSD50`A%?DsccudF+aSxc*nlk-FvsUUe8*3jOW;)xMg!3 z5_{FpF>z?DJ-VXGbkqK`!4<~J@21>5(cc>_u*KT;;*LPKRbdwdPwH7U+@5!X(>%@g zUdFGbi}S;Rg|eRcMlRu{#UwkPlJyUGz=I%(1ST=QuM?_{ayU2j`^)W$mH zQd@9VWa7G#=X>T=>9IfYc;1z8gl%qsucVYzu$oNhffoNi(+)*X({<80X(KJP_mke8 zNVc~ee?vT+%jnjl=;ykf@n{*aD8s_fZ{MO)_h6&=09*K(h=hkwx#u_!jy^=|!7 ziZVw#-Oxnm0GncXI9EIPwL*Vd#+q?nE52FUitc|TT13NMU7Y3exZGGx* zYIl57PW9P`FC)+BRwYc8w|_mgbM7nm&2dXs@w=@2`bRTi?*2(JwhD*1!mls%K)z1kSUOcVoYj)arb&xu zowK_aYqvF0-$!Q3lzZ3zznlG$C1jyt)yrweSJ>{|xcp_yv3FfE=RTU7E?9Rvci!nh z!(y|ji1mV9^R6s32>N#Kvr$06r-kRX`YtpzDy_Z6yr03p^tDO4w&c#%*-|&2=^g$O z;^Z{t+U>=zCj?CXhD&7MX8q0@vQTd&bGGeSA&sU3<|@{Ho{GO8)EW3Laa}DG@ub(HK^Y5dW)Rlw3lDGIbu8Fi-^ee(zOK08f$Dz)5JS`^5?VWY~$%I~&YwGJG z+n#8@w&$OJc-u13+Q2{4`mXgESgpN#UNd;l?Q0b_?{tM5uT5X$w(Lb-;KVb#pDc{( z^kiF6y(QzI-0}A~J`ZM8aqe82pmoS^!Q@jSLIn@p1h0tspA=B6HERcH5TMaQ@PW81oB zik*~qk%FDyy43C5FKc_`c;4L#ewg)kwZaXP3lBLB&lme91j!g|YV72mArsVfKe)e_iX#;-~x(nSUQCgqoEH1Wk@E4ut2)co+HWKIr*XY8)JfdSx#-GAbA^wqGM4#> zbe&HVIVI=Ts+qH}S*gn_lYQIOHS#qpU#!}F`qTx^;8(vN__d$YmJT^P^`XG>)it?y z@}JmWxzYVL`gTD2UKh`m3agB^hFgkNDsf&B?}-=7{&ll1)F*GHwSz8ay2VeCHi?_u zVjE}0CCVIKzK(fm(1z3lXLuqdH!3Pj@P9b@(Oaho&b@X#OZtyxt_qLXyLj!nfSk*X zpZs{fDxOsOA`UOT)0$acOTLWdi}c5}A4ADeP!lJ9Z(Eh1a*DrjE4;m@NjBJZvqvv$v! zl;yJm)cMV${DZ1>q?cWzSlsnCX_>o>a3`tHZ{ zEStZS?c=N8C*IHh7x1K`xJ@%O#Q9iGwCuZ3t6JrYH?<3E44zHtck)-Z$vkB6@z;IE zE4QwmTj-~dWB1%>a=7w#yLc(@j~l0jG>5x(9l0Gh{pBykhIf{&E~i}QEB*t9PWp!cJ_qV&hf4y7b#VeV)>c$bh&w9dM54a__EjA0SIl6m8^gr>#nKnAF zi`8U~t%{Q=ewcHZ%RZRkjWi=Q4i(Q(eR>otewt}T-_c-WXMT@M@Q zw*5LRDW$e~Ri^j3%i@w=^}iQh`XD0uRBLOrhi}LIXVR?c0e5HZPJVv0FLK&SpNf_1 z4357viAnx#Kd)f#WS9OwU;fGE9W%Pt=Ft*z?8@}rL65b}WpkU?1sNJ3TMt}Z0877}5?w}c5M?W~(XqK&sd z;8KyCn~R?0F?Aj3o%q%waT0f`>w^Qq)8?#sa?Dq^?X~Go`KmMf7VYKL@#OAZw?ao~ z+bNcCwd!l8j;pUMej66>Q}oT(i92L1A_PKR|N5GB8Hb#>&fCjb_x<2hm81_2B_dKc zD@DSTgaXXfqe|-QdU^8;bssXlKC$S8kl0^)hrFlSeRkh^*`NN}w0K6>pFPX3E_S%! z>b+wRdujOdU4<2LQa&k;i+;}wdc+&>O@80UKi!f$T-J5WiPf9>Jhg^T{bt=hV=L*T1h~;4x$ATDIfp z>a7j7Uv`DY`K+wr^>0sD`q67g-$K`94VEn#AIuzghaSG8nzqvW1f!cZE2~Cc!-|Ga zpSd1%@69-^u_|=I-Px{-*Y}&NUlP;Y^K{=KQ#1dIF-7&)lkfZPI{Ij@m-?S|qJ;-? zxEjnGx0DuaVlIEpgG~yy}6#b z57(@=*1!I#%Qvgh&0cA;dSF1%%@bEHYwxu2oxOBfsiN(M`Ht6&S{W0*|LpV&;d1Br zwR(Ya^u+^yMt7|L26EOLg|FgJ>iEU+a1N8@v762y-%Ieb$-2rU)rfA#<*m7vW?!{mYH2sTmYHueKhb-~j-mx(U8xT`xhr1%3p?#% z=J(QirvG`RSgAFi+3fdn>{|8Z@U0zd5?GV8zaEebaQ8AUm9jf@ewp7cy_Ee=4{)bG z{*dRL5&B?hNx`j|eOZ$Zu0QXqb-q#bt6%8L^Jl}H4qh?!*^$E}$S|vG^_$eXB}Qru z_nZp@k6oDX+~jpa>%STyvn6_~RI@#~o|=WLlo|Hi>PfabX7XX{p_h76Czcjfp9oTY z?)6dR%hYL+S7QY`B>shN;fXK)e?~5d@osJQQ_j%T-~WyX=Ev~Qd0A34C9P#~&aQTo z2MJ9-<4ykT^O$pd>q)H(sU`YOE`i_9Ec^AV&d&a~>Vt_&`^;`{m{=kvtr^QCcYE@l z896hW7MuybFT;?(HZ%KiVf42hw}sk-9v-qTGQB>8JY_2!5eg}+u6`O|wMVqN6l2I}0NT%B~z@y8}AF9x0SbW&J*6rc;aO*%Yz=K}jvCdDtoUnd%m$}wt z!%tSLyB9hoOr7ulvN=oOCU3uH)vTZ8cjV&`* zsanign=dK#{`%$OxdAro=NI27DE#nY(hY4Bk&Y=wV#i)sM_Yf%_paUMP&+YuxplR|{-@t-7N0IL(Up^VIn^WMWxm#` zy}>(@P9|ouZ9V2<^>@h;_i4ZNGx-6-XZ+hxCri}KY~*K%)4~b zJ#@D3%A29O@q#5&=CDkfGk1GefYfy@JF!Kpy^5}J)GscxJXU6QBkAwD@LMbD=C*7u z)La%EJGJ&B%dVKKZ8v8g-d%sau&au!|u4|e2nt?xZ|rYE^0@Sn={oPG8N zTz^zu-__rc4!^kataks22`8hj=sGOTOWfgRv5W2Gv5R-3+bk993k)Zn6nShV@00d$ z)#Sj~PB%xU7k{o_|CV)S$;o9!Pd$nX z^)qTk*H=cr`PUn^{riQUHwVsSIG&SDQ__txque0zAx!cakLx%HvCf0KG9RM|gtk(;S&F?IT(xdQP^{}*+-mH8^~ z(-9Q>DWVkVKj-atb7#FqjY+{BYtL7D>}S_HEw*!-TblWi&)S~b(-6WdG~>(+xO3CE54fp7Jo(#%tBF zrz{%PAKebhMaR8QJ(k?rWN*`i(O;pr4ZtE@AmnwhR^`R zNkM_DUJ0P2LIZ%<-!~Ubj}C6YRIDX4TtZ(a`*ug|-%VMD9%KC|SX| z|M$P6+jFH)xj)+D7vsqW*W?{{sbxQnY9>?+WsZpP%%Q|WNoViU^ ztYFfk&aWqzy*qa5)<)(ps`Eom{%dcGIvg%<)u?r9`$_)yC3!|GJ2povTs)^T<%Z)# z!5eNiozk19+Ej;bo~r!)k50jQA+GSxh3Cyq$2Nw({E_5;*+yg$m!787?bcYnRPm4D zuh=f$zPi5ST+SMelAfAm?1*u=q$Txw+rt@LFN~+n+b43NQ2D(0FU`yC z-{g+$oMoC7U)-Ip+0t;fdYb*@)|Us98>PZuEq52*@@AnD>zWn*pMn&n&(A-8{_0sD z^*~XP2;U3K+ga2KShv@QO}fJrJp1nHsrG82MW;CBo@`oI@KE6C>cw*n&5Bh`yQa&_ z*KBcptYhjZB_w)lWkA>LDaY2jWW?HR>ottFh4g{IRaUMWT|fzEv}v)nDb@GHh57 z`7z#I^8f$SO)@cpb=z6gfA8DbAW-ha{OPT-QS$IEW^<<6mBcpNGvj3&MGRd7*0F@dQ&=Rm8weae)BLPs~x@;-m( zO&RMoZlT^)OO{@6b?;QHIRC%J>&?=}T?UW(=iYY^P&*M^vG+i|+}i6=Pp3q33(LH{ zJSj0Fws6mLp{$J4%kLjIWr}M4C;Q(e@O&=~*2w%gK5P1)8OnMJuG=SzeG9#~ z%gehmzrk_i&C|Zi8JH^far5@wFg5>r*=6IeUBW?}T7OJ)8X~*9jps95XWX_sO38Z&OG9ecfPc%-nxBx{u=c# zwY+xOqP@;L!dp6*Z=O(kdhY6ojQhVo@Gkzmbg7N?k-|G>8lpT8!$kF`O`AMr*#p5N zGTkvgqNg*3zn}iJ!gbXYe#trO`+0c(8LKE*2IMKJyzkWsy}epAdG^Z)LC1w#cqNZ1 zhif0M4?N|?x4ooYCRXn0N$tW#{&#hi+jM96@W{LhS;)WT#V+-!b*|n_Wv^`rCj>b9WJy$aDD%Vwf%1{ z2KUt*lrMT1begAP=G&0%43Xt0r$&2;?@ttn7CG@;y{pu28|$BiF(m|%uQdrSv`BSB)neD^VG|ntbD2Y8%s7v`pV9ee%G7Q*HV(`u6;Qu`yAVT zYr$-jTlYEsTkI^al()1>b6b3mW4lFr(@zG&*$3~l>n1bTpPe}G{ll&Ebe!0O{T}z- z-cj|z@ZBkg{&tmimHAUmLZ1F~y1jL7v<~mwNj(?;?JbXA7wF_*`1IdzHmR5``xNaq zZC(~XML)|8Z zpL`^POX5`i3$ThU4Q|``KWuHN*`edNE6+?_FriF1Rlg}G?%|END-QijRFxi`pIqs^ z{ZF;rp^J5fI?Yuv8@4HbQ`D<@rTgha*uko`dI|5Y_hh==@9vbpV4`~LY>>F_yqKyr z8LHPdtlxe9+Kk!emqmIci?n#xN}l(;zRtz7qnDv%e}$v>qVGjpCzj;K7G%Ej^^sjF z|L(`;wY`?NKFrlJIK*+jy7}!Lb%%_XEpiR4A_4|tMuB@JUa%iAJksNraxAv0!1Tq{ zOJa{0mma#7^F^^~>&yMEKQ`}Wl{}ge8OeC(W95F{^X#)PKMJw0lRYo@e);9cAKumO zzkcz@yV`y7{M9={MYa8>y)pT9xX$osSM=Z6PnJC2S+L4FDdh7?$y0OZJvjaK0C!&H zo;tp7&%eB1U-~@l_Pg(Y=DvIWTg^28w^U}FTc!(b2(do zzGut$wDI!q&LBUhwQ3)|&9rhCKj=TR_v*)x%DeaLJdf?4ENhk_e(meTt6FD-j&r*n zUt1&>;;!ZMVM_6n)q2wpEI#Jdd1v~JZSF?FD;y>itTSiVa|~K}SwjBHw`mWyU98#o z?rhunay7ruBGmx47~9sc%=pEowZCVkzj>PwyR}GJg0{m$RN2prpanWaXD*K~zt?g%TR5Md#>Ihl2V5(V8 z_0y@56%S_Z*?m>?17Gha%XdE|Ba%;Ek(qX!RU}iam+$mL&PuD)$Ay*qZ8pW%6kcT1 z*nR!NC!xKi>#gT`{EwZq<=>y_JX-%8U2neiov=T^T-+|x&@#w1Z>sY8@Vt}hXJ<0j zF5oJDX!d=+v2H_0_~JJ=mxVV7{GQs`#@TS!zIWCf@r0#CqHd2Y1-zcFHe1Zabh70B zr;2Sp(T5LqaNXlJeQ9@V#>y)jH-vrtb=IKekt$2ck?xD@H*I+>*L_5cA;kDR(~)Be zUj?|^h0gqcpL%y=FK5Sd$%Rb%mv>EY-_H8`b^C%xF7u`9_IH}4?@!ylrFT_9?mNK? z0Y*hF=w>}XLjde(fY#Jg@0Ui zYrfp;JA1%CuHU4V!?SfcSJ0w=p-Sl&Zd|omad6ru-e}G)SE2G7wq9&keFbgZZ)q#d znKG+m(biJAC6Tw@6IqpLp5wsk!%|xO)wTzqE~>ykJ!fTwC+uhiTa_p~PzG8@DGk zHC3F@)N1l(`1Q@5=d4(K-wNhyTPEClB9x$($j-_X)c>nqywb>b$NQyhlJ(|iCNDd1 z__=FH`vk_ho4@gMH^>M-y(oIBAz7|<%K4w6aR0!HllHrdHO{uOHYzd1c0BNHytur%zb5`uK;zP+Khe8B8cNT6 z&h*#$Y^TZ{StHjPp;OxyoX9J@x^lJD|8EM~j6!@1p3b>k@W(K3vUfzTNB`6p8ZVWD z=4_cQv^PCJBsP@&yr5i=bF;-uPf4~iz@~fo7?R&2@ik1^kC0NkCNX6z6D2D z%+-5ka@FL`jFJW6v)?^>_B@b5MEWU{(1+%>IoGFZeUW^`_Ge=9t+~HG#r^Qw)oQAn z`fAbjck@ymKQ7hoHe9J&xImIg&nUz~T*u&am6ON6lfLSQmA5jlJr@`zG)-0bl(9{F z^0{1bi`P<0=|xG*P64W!($}A38r-Wwsp-uiCruef$U0$4Bbk z+FgGFXx0^XL2t>)P2yKBOUOmBztT}zvYesIEAPl&n`t4;_x0x-QuCf)eYxLc3&ZqS zu|uZQ?K$fgOnRkkdug4SrY*~U$@k~(n`msjJS~xLO3neVV`hfi!Y9vO8x*$1NBQOq ztrcu9!?km&Tx)M#d>mkLcH1udu46?^r}~sx4;pcV{oJB^(|y;MGhZf&DX~od=Hh#1 zt2NgR-A60!*Lhz{S;Lvfz2I@cGTWqS%mUtPIv=@3>EC)fGr@B6jWV%`T&t$Y=UzX> zmGMeW*OOnxByJbWUQUe^gP*q+r%u?&x@pJEIetrS{K&iYYeUa;p-qXIf7sqjD86$$ zRr2}S$M;q$Pgj(vZmkNtn9Dw=?oIcPMd7x;lEeN7rIt)36I39dsf3Mf(lc>%Mujy9l-VA7V%s`o9Y+e!%A5%OWn2770>3h@_F#|$EF8A3w{S`K4!kY zGB>55M?~~(&&h_cHJ(g8svJf%6!?cEjxE!@LHQ%Evp%8Zp&76 zc|Px%->~pxmBslkXRVc$CJOgeViM{ZYuHObCciy#eaVC_MYqT z(q?MEFeB03VSjduUvr)MV(*?w?;Gr&^~5zTOl_F+S8rBePS)gKq28{W3T`;3{1Vxn70e*W&)=t$o1q+iSJNFY8s8cX`}CyV>jQW!}xNOUfo1&6uRPlj+tq*`lUu zCY{ZFT5Ud_r<5igbt?J1rhUo<$%rUez*a@AIWd~D%{*5{{Q91pV6Nez5jTJ$N~A!c64lA<-YZp&=W zE0*Fcx%*Ow*E(m()m<6_)1#g4hcC+3IR44HtW8_vZ~xT?b4nH0&p!Y1+^HJL*yE>9 zUN|Nw+8gwN@tj7OmFXiptuOB)mx|OZ%9RiXE~`$j*ZFD&zU zwr0zz*}A+~Dw~sZY(`3l66cpsFIuO@N^HoR&)pvGI;*WNWQG4{jl`*ev%W}P+%C&i zmm`?EF=u(n<0V%b6?cd%RSnH8Pg-6UxViMTU#Smgn$K;G_qKQDzw7uGYPSEuSsN~$ z?f28R?>7jpsTa_*j80#9ba|t%eA7|y+!VJNCYpIlyoKjIw%*&nV(t~&DUy?Zg~r)E zyz=CUNz~&vKmKVxeOASuCgC^jRP!_0_JhtEK z<11-j-mAu(z*fEW^|uRYB}8Zyw7Fwr(I;!w^HZDBmSpBmx)?4{_`dGE&#CRUJ5I9nWq#u+ zjH%k$u`!ytA+&?5KUwnM-17xbC-M5$zwll1CPH`)f2y1KiQ}hpmnPnu;lKG-_VGKd zLiY|U{ywng*74-@o9kDHf7`?*r?A0lssGQ)E4z39{;@zW-sbLwBM#{vzwY=1`n<^g z#x>Xfg7-Nc)6IUk?AawkXACF`x+`4OJ!EwZ~svrN0a zJJqt6%)G2`<(XGt4GDFXoV2a$F(Qr|X%6pj<;+E|L!YWn_A_a()@YA8S-vexPw^h7txnb5rYmRG z9XIz&nJO3U^mnIbqD!Uw;h#C{U#Z;iKUUDW;r})34T1c+W@#%U_A1@8lHqvpYPn7R z6n3VxKm42}>-Z-8yr6OWP1%}{T}J(t3;yh9-BpwN_}_lDE8-iU=$<_+eK2HC;Tzt- zKxO^Fn~sKB-#TOV=XyuKddFGq<@bO4g@y08aPN9>r2N^Mg+9^^WiR|1_t*c9TdMSZ zi-zN&tc1l@QoMnWoHu>YEHY{cTeVckCo7Tp{N$N(DY4$iLuJ*{)IzpASsE_iY{B&; zGwQ<31$$53_i=mBKQlS#gk6m38bz*zwCuU;J)$e}YXvrOq)o6~Eaqi-SC6%9tJkCl zw;uH!y`rVle)aU)fJ9@pH*)U4`HotMb@pBK(o2%XNEZ==$ARZm%==;?GL^YZi}?-kCe7E{$e z$K}n8IjHqhKSGPEs_pCzff?`39JnH*x8F+)zRWn$j`PZ~tSa^i6?0S4E`AEy@$0hK zi*39bn>I?79Ix1ITgg+>%yM({)E$+#bSIxtE@{HAxC zcj_eNzdI@~eBY)pzh9X9!&KfU!p~c)N`(zRdS}4 zW%t&yPe)$f+`TU7+V`?geWBCKEH(=_uAAW^KO@HF@YD(xnLp2;omld6$E0d?&q|g= zj@^2CUzHxsDAe{b*)eHZhnl0uJBBARpI+sghY8Fq*c9b_X_ey3exo_38e)6}ZrQx7 zoPNtLF6+KzX=1?NyQkQ#^0ZEEUF>;XO58hX>iK?04*ln+8u}ylY<0aCa+58wBfYhH zX=;5v)Bl%#TrJtXa~1cOGlXCXe}1BN+a~r~wx9OVuEUG!-fI>a+mw9Wxo->SlUd0wPRZX)9x%K!p8vFw^({xK zVUbtjlm@r=Q_o}yTnP>>G@aX1r2YQ=pNsos8HFB4*3MZIcPyK=;*hUHA}+g;eEPFr<=KWwkojK|NX@~p^DIv=3Ut+IW} ze9=6&%KUsMxs#DICMpM7o^)RD>6+&Hwx%_#UV$9{Pv{s(Y|pTD3{ev=a(}lw!2Qw1 z_fr_AMqXat&$09B<#%h%H1Ev%sIcLtRHwqaO9lP~W``vk>&$kZo%8PX)3%eb6HIbe zcg?72X7W?eVz*D|IQM*V*|T|4f$}dMAO90upZ~w>BFEa(UZIKS<;#W33ohOekJjwv z`5)fjdTb{bSH+zjq7gxvMgO?-KKXg8Sgx*KGi~Nw)9LOr4hUuaHr~kEc}_>+LVm!a z=O=%8Xzb=y`6XnzGUL=6rTf~#2KATLw`7;SXA_a?*uWYyIdWm{-e>LUE{8hnj{GiK zbvS)TiQbKcsTFI@j-F0<5I!YBd>xy{?Z$iRYF@|G?oPb1JbI&>S(y7l!RA&g27eR7 zP={L+HC!Uh_$F+<8+Goo&d;qPH{Q%$sq$di+RNdbwNB4wuqL_3o!w$$xH0Hq+a+cm zGqVlzZ%nw(`*~VY^j>x6faTGFZQR<4Zyqve_0^~DvTkLFIAiuDZc3}|=6ehON+wKh zu*;86Fw8x_#)NB0!@|9rANep%jd;MjuJq{oa+6i;nJeGg9R1U%v8DIdrX{RW3yrH! z%`Vo8KC<>di)u?n;gS~qubRAJlbjFED>68+{Kzpa9+i0Jhm0o{=)dnU@;triSg-fw zOS6t?tl7Ua;!m?%M5*SbYI){uxd)%M3NfXey&<`wByNL_Rd-{af83HeHhZP!lrmZh z2`6}#TsjxZdV4!Vi|-1<_KSYZ>o>B<{@i;0f8f{qjCCt?tGR2gDHLt_;}J69@mi0$ z3hQ^Qjy(IZY)<9&t^X6$ZqK@E#$EFB-XhV~h$$hHLJVe1|N7pnLVH=J)b^^`mtJw0 z+e zY}Q$Y$W~2FTI0*X5t)1{-1N;1$z1cY`74$?*gUQZkU8n$^yb{#;~QJImOqq9Ufo-D zz;WwuhNTy>``E%4Cz*;G++11rZ}#seP5*hntnA9&$JfEle3#|yM0Vl3F|m>Ne!8X9 z#)n8pFXcV5^!kB5d6%rxiwcixGT&WN=Vaj(oSE{zSVzj|kn;7dQVRq2^E`06Ww<(X z`DfNiZMp&hE7yc@r=0r!=Z?x_9sQ;sQ;Z{m=EzT6&d~7us^YftttY>RFI=@vW4^7q z;O%Ft3rjWG-U=Q#^EMb>BIrtG`uma|oT|cIubJG9ACr zyelWpIEBApey*oEA-l|USu0OM*puv{+V-1gwfptuHRTSPT=+b>M9Z~Ce{zfJW#ydS z+JB4eB^YC48;&vluJj7Ou=k~pz?2)DTf3q{;zR!!?oE7Ya%VYbE5rRj)jx`MHEFlv zeE+4WT;zW=lQSgSbwfZ~;l%JSTF=>yy4r8Ia_+0!r?l|x0iJ?s`NytIX|T(FrD`1R zp8x7h+kz?29*1t(R^hw&!qL|!mmX;kKP0BBP!neGPIKRKi<%=(g1cWmy5=@#c2{FK zq~Blt;kgpy`nU` zH70mkS-&W6o#1ARR;^WmVa^8_TgtTF-+06QKd*Jy@>RKY(<@{@>`lt>>V3MwZTZu5 zg#=d(nKg3XmR;Ypu!`~7n>6D()fn&GSIJeJUd}Cr@YX+Ae-$(vP3j z5)-5MyEO-@bDz<<)3|8cn#m`VUs_Gx6hD{i_o_Ner*97}BRpROKll@tJ}1e})!*1req57Yv@K=48Y`6akVW(L)N7XvMC3Q! zTzr7*<;AD#y&N`6uJLQ+&NlbO;eF-~jtcz;t9cDhqcm z5@$J~N_ z+V6MR7IIWnh3-8#T}3@zX~D+noQH~gyC<1Fe6O@W)Z+K!-E*6*Ox&;3giPS{&fAsN zy1ORl)!GUCpH|O)obKFb@?fg;Vfh;xb6N}HCij1INa=O_xIp5-rmXPLqd#K$UcY*0 zJ#)$Ls@LnK&z2s#9(kx|Mbl4NG5&vD#+9;6e?NEq;Hf&yIJePGZ_1U7&lPjkLKa4p zgg<}Ne^`@CsFe5D_xGF1g2g6ZbXQn?L{vWdlE7oZz48+eJxbhWDskc3|C5)U|Mjbd zC2eealseh%-7>!@qj#~ddiedq>hwQ1Wv-a$S*w%Y<-cLGYDdqV2NQiho|oQQ=xL%< z5_eUE^EX>a!2PenXKf1edZbr2ZuM7P-g$D`l?=P}ekCj1SeGV-oLD{I{LlZuwAA=d zSNZafM;;GK_ipuEC1Y`u=Yn)zVLq#vr_#KuhZ?=rnx3dW+9{k}@gm}v_PND#ZEi1W zSb4-x=O3>UpFhi@XMvk}mdixEEb`~ElHar@d+KG*Fa9@nM9$jqUt7xX)a%e2Pxw|E zFOHhRubS{{FQ53f$l#uDPG4(Qn|pjeGj&g@(yGwO4acO-mLB!Lv1jX_d>!@QB391N zyo%56)Bl~abfLfc3HkM{XFmR~uh*ad_V-?qez`H_ z=D)AC56}L4{eS9P_p9Sv58w5RKfLtWe7;*=G3ev{?g^KYmZl&7dw=I_`}_OOR_$4>Uaz4gRDEK_ zQ*B0b<0ongYmXRRJ-j!kI6B4E{Ps2b{dt#W@fpW^{o~*`ypqYUF{eXD?}2pUp$vbv z=xL`EeDuw0C$p@sJ3iyk8x_N+qOOjeiYtR(h^6e?&e!(i$DTqKi!Ew751f=V?|UWh zP;{!!{rF_Jr;OL;&}vh5+6ZcO0f4k-$=h;endq3P~XE2+>XS$H7`OyutMOns|o;{m$E8@ec-PyH~ zzU>baR-QV0l2Q5MUDXNl-0kt=d6QE$A}o)8z5crRdUT>zyRH9H*Iftp_WCp#lwY2F zZ{evXqet!zx)pc1xSzRfJX!LWRrbTHGgrBHGw;@olyn^@?^PNjp$$qKw zpLXA?i++YG`+Edz5ahih-g3I;S#zygLwM6|k)TGaWfhmwSgQ-SGKDK0Vkr8c@hiNn zb-|I|s`dPtZsqRc-f`C%%o6vvbK2!hS-5pYLE)*ZGk>j0(K>lcw}NTv*#!|&8!s=K zeXZ@fRE?|kzDZSrT~Fi7IKy_n$UpA2#`tXCo_}7G*3VSoY@O+~#y}^;ak2gtCl)t$ ztyZSSrcxE=Q@865zm}e3dhVotPNs%Uc;}-18;?l_y|FNwI%PShaEtu0Nqs9O$*l>u znc9;Y^?$~Z9u;$$RmT{b)6`gnHb&YjacYm1kUsQ(?yIrDy+ z^A){)ue{k;%THZMb<=SNxmhbtIQN%t-?u4q(>$dWVSg0nR|#kA-}_nWyT{YEmVcWk zsYU(y5i0sa%j$>Xi;IrW3{<(?nG z=gsHTNoP#`lKj$8Cv9JEw#-JsS==n<3>8Op&EE?cKl^yyVb&Wj-x$s16G|ksC+E(7 zZnigr>&$`bkk2^^F`FMtWzJZ)WtB~!!PL7d&-tR3%h^Yq37mHQO!vb>>z7XM+~}h@ zCo*XIR%0!$)-6x32dZwG$yXvKp(oIrKJnu7K@r#6*>xZnRP0k+|R7OmcTCXC#C!Bs)#36*B2~Uyi|4`qX?!nvd+%y#gvk~J<=?t~?cw303Gqu0EO@KQ=)os(k3m{j zI>ev*e)WAv?+K-@f9x(F5iy)5(jYzU;ob+wEno2OTjb=@tfI4f`Ho9dW)*GwwEgUk z+-nJidfG)U6T8xnrv~0ywJzkNsolRT_l|3vkant7=IK5%&#J^ZOk|%4_nUW#_Q{nS z)2BBXmds7FV=Ce(^*5blSn_bu^>Z(r($;L^%zG`wW42{SM$e@`mv2thnX#57UO^+M z?Pz3YT<0_XSu65Sy}j(szxVqOVf#2~HIv`RsvmnyneKCJV&AU7Nz6Ny+r1C#PE+aG zcX0B%u6sNB6PMI(KY9IWq5x;^vtTpQAHwqm-a{owIFaP_FcRR#3_VwrO(3s1Z zfB94|zH01IYRO)yi%ed3e zzB=CP?()!HKdIY0GWeIL&7OUo(|mT^v)bdkN>s)(4tiY8+oWjW zacge=!>8JZExtrGujk!-ptfq)wR?K=1rpMKh6`o6{CFKb&$RM%zu=YXWe;)}m~C-7 zWT9aeJL%C+(FHf|zFxfT{hhy4rrcllOo#c^_w2F`rCC$LRtH^g)_l_=+nsZEM$V#> z9+o8@>*m+i{lC>5A$Drr>OFyqws%*xp0w3=YIobi`$2P3T(p<$)19jv9A6)h<#Vim zJP=-4S!=Jd^J;^pAV_WTkT9;^zXdj$XW#SaBJD2=2;spws@IT-(A7D;^k&jZIeGW)>&RhR>^;C zR&QBR(H$H0_s55Z#GN1fp5OU0UG3trqI=&mQZL4q<>&|SO^{!?xc_QMvz+AX-`6j0 zs`{g``&gc3>-@JjgnHdIYP{F{z8_rr=6bHh#nu;h1ZMNx+IjxztI&IGQ}s%tj!g6| zIv8zv*2u|8M!IYELDrj2TpeGP_paefUXT&aZ~8hWo#E}Oj9OJk2iBm6%UY*(owMS4 z9-+$7vdlOB^nr8leha0ias7NNx^*hk%IVS%i<9*BWIvr!_Bnq4?R%2?`wzd*H;Z#v z-FTjFhR@{t$NhG!sS7&AeR#PVqeh_0z0+%~En{_67jBD7UZRpa|8m#a8Gp?8?cDW( z?QyHBU9?|eN!K&`q6dBdzg@~b_kF8>-R9U`Z|~~&-cnaPdBoeaI3)UUEi8V z|L*Wzw~%^qh==V-(%JRG6Pu>k{i@IiHwl+vdSNo@S?z7_-+Ix;vR@Y*zqCbit8TKn zx@7#$(}-s9^$`KM@5-Cet+-|mxE zt@$zK#}&=>YuytjVm=I@UUP9;@s}QW_3ex8?@l?t^W3&Q&kv>NGq4Hq{L&J6c;m){ zmqy2XzDP2O>i@eib!~Df%Yzxo1!s0E-;ciWb87c9wj;X#>~HRP{l8pxzLS%m?R&qy z(f^a&RL!^iTqk11Gun-t# zuH_`5gUbp9!!GymFFk#I@A}y-R(HzUJhMGmwm)Z7m>9M=J0dRrNn7{sh4vG5TrSSm zO!~M(LhhO9O8(%Gj9o_#b|1Iwy`S>(MfBYkj`N<5;#=)KtmPNoa_OnqxMb3l74!C< zDn2CXCCl3U&ogAfMaQ;Y4ppzuC7TT{ImCY~d^0glUAe(-V&&OFg|`d3Ic=6$D=^Ad zUGx2Iw_bhr<^Sn3*YnDG+7+Fgvu7@syZZbW0_P5Juh8x@S|r+E%NDWCE1AFl(X9ui z3(9WCYigg7+-rVm$%Kni(Tn_z8f>Bi7S^^4Kix0w>0@&B+~WDcy|GJ~H{QM_bWlAg z^6+$(dxx$xR$LP_RzH*%u_|VL#r0D+KI^L2y=R?RefjxLHjAl(M(kCL3uag~KhLz> z=5$g!YH{Zgmi_M!34gWi+Me*?p!_P=``%a zIVo#KWT(E(cau9``n~Y6ZTC-KUEVg?x(&@*NxV@l{X!m#JbErX4VmS~>F_7@d#$`X z`=yknM*R2R1eozS`L%j%b-i0XjUhg}zCS*FyRf&T`QEdCuLXA>v)lLBlvTTi|8L-j z&+m(hh3a|q6#WC<=+9XiW^g^KctyP9B%4`v8(@66QBI)>XE1C{vP;|&G&fH?EBmt zYnT%Li`hr)wG1*o>%#m^J$lNMt+JW2ww}yOCT4XVILp4wF;DJvt?!j{5w_up{JT?X zc&>!+(JY_gF?YX!!shAQW^3>Ceh|kezbU8O@zqHtW9@786RTfaYP#mG-u^^T_~8p{ z{=Va1*H73t|74dv@4X2>x4*d7?fd5L3cZHCzfX18?O9b;|KIk5k!wxy%m4rHCw}i) zn6+XpH?OkN3TELcM;n*li&MGxP@>Bvny0UR*GGr`+8;~*{r)-i+vo1d**k3Id5)&N z{jvGli?7oD;%h^0x0+p+*(tXB($eRbT7*}$ckcZ<+aXZ+S$!+-7PEh4@#1nlDBE>%4xmJHDgDUR?&%T4GUQpIV@Z4kntoaYMOiY zLZ_Cvh0{*)ED~k4_|TG9TbAU`LfAQ_H&VTQT z8kH?CnxwMow))2_bw#b~RwW&;zP9e-s--e#UEX=9m>mzV)jPB_lFREBAL|d#Jm+MPDX6W1Pt-G^%F~8-t2?3?tMfKwG<@TIj zkG4PDIh9@J;f`+ixS-VSj?U-2f4EjoJMo}m-HO7g{$l@5blOz^yVq*yd6oW8;iqcGtN*ZQ0f)dQYyUm2SK6<d~D)6>=(WHrMmlH=o_MD{iyd z*@J0bnNGe}@BaLk>8Q2zSS>5Vk(;r7+gCaDNQyWt_dBw4S0KB&>~gWKX6YK%`I8q< z3_r`e;>hd?_RH-LT_}Fz?wYu6^?}loWhqm3e)tjPm#gS@_(n{?#Rn4t&p*7?eM&^2 z)!?W+>l=l84r1R+Et5Las&ywv*Gjoe*==rn&~w&2)sXtUjPTx9{-)+BN_+n@nX#<3 za8A+D{jdMpTxdahO6yg6rM6`n$}p`_d1}v+KS193+3MdC7s}yB~bnXd1S$vchgJPi$9gh@bQlm5&p%b*9@H z{|=3Px|4a;A%olnGxOx^?$-Q`-Ft39QbTJ)jhFbz)FqtLwGX;$Nq*+d{;e@7w^zXD zRiKpBlD~p#5+C_3`_m_OP7tuXxFq6ILCT-LIGqWWZ~pnGn{O@DIp<$ya#$feFK_>p zrqF{PhHX_E!qzMJZaVk8ZVURqOJDW-)G}%3FQ!2{%JHWx&n*6xv`Rtjk!j@i5R=n6 z4lhz)cnf|A-Qu$_=qdB0f=^y^7VVnPw7-0$K8ngv+PWk-w*g$f4F4R!SzyM zb0>Bz5SBH|YWVdnt!-(d(?^V^b>3t@ zTz&Ghis+QM1*b0Vxo2=WGT$_=t!lf1VaNaF=iBbJv`5@H%EaVZV{tqyPv7o|S>Bo` zW`F+#W?nrJsui60+eoe~?zdm|*7+VLvl~ADnDxxEwZ2&_-rrm-q& zbqhn>lD89UE=*k|d*tc8WqW!Y;_F}Ly#G{tihG`@l#kQCdAp|Wzcxj`{N%3%IjhsQ zU!B^mzxAnornK1kiS_T>7U#eJ({EXsRmXpck3Cc}?1 zrJ!}sO!>~ncg2}(vHGtX+OzL{mCRqp^Uas9t=X2pQLDtc`!d_D>iA>MnUkXgdOihI zFX3F=AS{&g$T#Msq|?s-I+pz@J5J@eb8h5io&7W+Pk(o+cTVc7)0w_u50ci2Dt}o# zQ~HTt;H-}6++oLZJYT$U`+xQ8=FrR1ipv7BPfiTmFSnlWLde%klG&9^DXh-t4Qi*a zI#hASY~|_+;ek7|LvFTgT6|q~=D#aH;*_4}6^8ni#{Ceuu;h@(?rn<=H-!ZyT{SZ) z`f{SZ;VkRszM?xW>)uadn-pa{To%eSm&w=C1EHJx|7INBbPcP2LRMUQ1re9FDw zd-LlJH%?+YGgUiRah&_{i%e&8_s-R7HrW+&eU0hn zk1v~Kg{GSuIsE2M-EnW~Dv!remh%D_QuR5-H?O_TUine+=jxOdx1w40MgBSPq(+i$ zp;7SRWqfxh3!RuL^;;o44eIX!mA;wOzuY;#J|BLxuDw&)z&GI7c zzrHJZ){3gqKG{{fe_om{bT94yJRV)svRaqs*%5~9=a+3V_`NaFwdD9Ri(Pkwj(kzp z;*wb6=@+S%chO=!pRS&cp2engyCc6M<5ntUozit%zin=F{=~wV2R@6_m1mhbhATBc zNl1#|J+nmFcKbG?yUx8=cbLB9+QM69mVN$p=k@z#7Qbq(`W3GiswMrpvgq7ttrzE` z-4o(jYd$rnYV6l{Tj&wpD7H{nsnG9ETi=>Xs}yr|thO8vP!f$ZkK1BvS)qQA!R_ek z!rtA7|4j%tU36Hi*u#li`;X^)4>!F}3krghRM;+j-Y#siv}dxC5@#Kg!YQ^1KaPrZ zKIKfcb-o`t$Gj{eVQ+iZp`X%IKYz4aufF)=?_H1C1tn&0d{h0)K7Rh&PaI+AS`6hT zEhzZ1`d!%H9h&`KSxYwXf2=%y|IJH9pOpL`vTcsaJG7QR4Q{OZ8Df0;-g95IzSv+J zf!7KhH*TN1|9E3+*ZrXV7d}Y^T{!⪙gtrYigGMDSwmCBa|3g8u(c|GC=+ z?rN>wC;zec?TxlOmr%d@z&79AVG=)g->TAo{-EUl>I;o?->_fa-&~n#6TMUN&LOs* zB*PlkU#ea)&t1B89j^V{}`-9Bfg`q%nk@TZb5I;>7|oNAx)H>fWt z{5)gEKCT_kD{uPoond_{8&%-Bn&;=Ad%m*kqAsgWy|(hqpUAJ9Cgm)$-7U#wD!(z) z#1Mk57xEW@BXcq@ZTIcS$ZJMkn{oKRyq?aH5E89>L_dV{YgZ8Rb^5N-K zYnwye+GJY)Uw4j`+dJdcU9lG(vkrRt6gx(|d4Hu>TdssPd%fn8z`1XxJiD&^JFM_j z!NYA^(UsYM<-J~DjX){-|x9{th39EMGRbHQ)F>%9D$+YJ3fby?%Ctms% zd?Gk)PUv&SE8#LakA4LI(qFZa{m`2BOf9o?$tfLE;#mU}oCO`7-mNy?9dhi_y_k2oU`(DJIGJkpUBDH5%HqU6AIqi!-e~;{? z!1MDZ^iC`})4oS--Ta%IUmv}fS)Y7i#X(z*-|6gX6~Dh(e6p6ByMO=s8wHKAd+)~V z+-hvJ`Pkcx9X980hA~~7@b|@ux15(*1N0_$NQO?nYrDbk>qZ?Lj!W+azZbr)3)-;$ znE1oA4$rxzSGT^g=aqx_B@_j^39Gl+3Ea(T^BZKr5<)O zS81EX(^0=s@z3^4Z2MPk5&3+&fPcASW#z%$*V^BDEdQEyrRt%4|Jh#+Mm3__s%|X( zziDG?@qATBBG)wDiEYiR8`xES|9jU2zqr_y^nXXxtGq7J zcTZ24d{BG6S?GR%-nHlaNqw~e94}-iY}+(r`F1biz$VjHZ2h@e8ICLKZo0g*NPQdU*j;R+>Bw4VkyY4s(apq0+!@V(qLOeFHJ=hXu?DUnki9eE+#er4rR+nBj=Tkd*0ab|5jw${4bMoiLL zeMhU;gV)gyCat{QxBJkttM>bJje6vQa;=OL72PE47>;{;o9DVPO;y@aHRJ8Xy)7-j zU4Kk^Y(05TVbsJghVy-U3T~U(uF{j|`KqF_TZqAZ?as~oX9GX~t};0BU#8lq&ak*` z?;2xQ zPMqhXs5Zy_MaV_HHYaa$m!wVX4&NX7ZtHv$5tXX7Mo8;>Z0+m*w{9HYoy0bG`TLlB zd{(`B!{z3zlQPVnPp+(I3SS;_FSD$kccK?Zo#UnaM|<A>Nq|bz2WCDu1(bI&1fAtMd*4&ski3&TL7%e|)A=NAP3i zyqEW59Q<;N!ewWy3_fonz1yPqL{t3!ze^YUzt6a0%Q$(~r1?*$FRuP?EpPYddEc7G zsvsqGKRz9wYm$#+I+boVJ-N&^-)QLxpW2k~tf}Ab%+~RnF{AFN=C|82Z#q}n2wV|U z$jUidG^6h7yu1tDGo9BNT+h6{QOCk;t;oZ7Z_WX&v_CW*Y2|XUzKg$2B|F<-Lt9-qyJ8?P_{GE zJGQLjfSu;-q8FDwKJV+Y(LXoKzi9WJ7OBPMY}rNo&Tl{bWSit}ag$|c50Z}_{IzV3 zoRUP7W3)xADsR+pS64>{sr+;2W*(_xkXdIL+V^#-OQ*yC3oHGN8Qz`|(tkW#W(?4eqvtDwus#E^quXzo*K5OGC&sukBAF+ndcP`OewbuC!gfEy|E(c;c^| zU)s4^ef3*^Llma;ZtCTDJWsvBws++xucaS?Z9XbYujd!srMkxLX7{`;B~P5U>{_`e zGSTAwwiDi6A8wmBq^;kt>vZ9md)kIxg%vMM6t8)@>+1i#u%c@79@C|Tlb(iM;Z*#P zCm-~b??klZot3lAk4Rp%=vJ_9u0H?tQ|fAS#o2A9{v0N)%XS0`^=cK))cRcW<8t5U zr5*`gy2o^GH9b9Pcz2=km6|Bg-O(bw+2x{ZGsVTGRG;se|MvLh)~j=-to&{fbeU!T z3i(C+ZF^?UUf_E7sle-VGN(T+D{z(FI%VdupMq<38>gN)yd`7X?^QmcJsuCHDVK)u z8>zXc|6F@|d-r#X(}HLAUsn3+X;<*_PKIRJoU`r|AC@IqYu)U#vLXKFn? zvCD(`()l}^LW<&6E`Q|e_3QDZybqy|tbF#*ys&D!^6ocDhXjtC?^8DZFRq`?wM{lY z_Iy|1b_>jqW?`exbkEGm|}J!FS-B$J1OLE1R^d#uI+6-v2AE zFQe;#t*!hlKDHkZ!W&jGT=*pJd3&0*ywmg-Pg2gh#YrscG}WHT)bhqt%RtzE!msrY z?qzItl5RNv`tSv<_qypOr!<#)?FuPatL7D6v0{yuW~^8D*O&YE%$=Kb!+UFZJj z+7WZj`c7J5(6W@0-@X@fn^Mg-wqAI`8MABd`|7KulIy;I|6E&d_r3r1r~LZ+x1WCc zTYW$M%*q=!b@jfV!*{ZOT46n3OU|vartrau71y|SesKMNd}jBx8u61d^;|RF?2DRk zUt(+7%AoY{5MPt8hrd~GZA!g-W0Gd}yP}=v<2+quIW}+IV^(#xAb&=(*(Cqx&JCZR zIY%fJF8;rG=T0m6 zJ9f(oc;B_Zs>!ami7AC6PnTs$Udq9^aD&#SfW0wurSqbfTg=*XHSF;Q|LqZ;N6z|m zyxq3<_Ax#S#yj2%v+`OU)gGMXVN3j~XffANJk0Lrxx!7i<*)qOVSg&=es1g(%dj^E zs*kvriE2!b*Ztl3utO>BApgcHrHQ326V^Vx^wjKnJnN1Ftud!;ul@{GPBmRExVgb$ zmz3+1Ntb`w>^k-^s=904Z;m~oOZM)lseGVtL$`D0{tF7<6~6sDk}}Jw*uv`!@4J8N zi%M@P>#m6O+~idE!FYSY#H9=7)>}WEz5Mzkr;B;gQ`J8{vH0J% zT;pX{?%Wj~xoN+y;ig4ZC z%=xF?)~nz4OIK=RjboZJ^R4dk<#h{_o<0$}R#dyRtvK1Q)x*qZYUOj2y8FMJ64y`d z*}ZRKRrigUiptQN0rw_;6STM`{^zNO`Su5=Ef}~ImrOr#<@Y3asqQ~+x?Q_#7v6Ko z&~XZmk`~@@$!(j|;b6Ph6^|F4yLo!@-hb22b6i~cc3oM!#U}?Qz21!%4`v>X?fg71u72_Hf4{~N1JkeDCwUv*-kBrwSo;5u>!JF-S=TbG-3xXd=FC|b zpk=!ErU*~w=@es7zD1K!RQtiAWQ#(vt$&0C)wC|zoO zZh=L!bgWu;n)DeKy+2nkT|d4h=TC6>ZLyYPv)*}}o^avIVQb%C7QSpd()O?KytL|f z>G55DFIw)@6gda-rnpWEefBctIInWy)T4d*JT3xTj_|cCR-7NmRPf$&t@_>QtpB;I zrv2D>V)a2mubEe7-(C5IgFUh|Y0`Ybg3IeN=Q4bs;<8m`>O=hx8}x3}U0%t>{&9v# z#N3j%H`2;4EX~)QbN=gMF*U}Xqh57AmMbUS7djRA>jC$hFCqVaKR4eR_i&GorjGp$c|gNMMiB|2LzPKSFhby0G2>hb=2^!=@l zs!zsoT>E9dt^TzC>4Q}hyDrLZ(+qmIu27}+*ZY#}3A-{{K23|Oocd6E;=_4+4qI$G zB2eAF_|sLx@cRs_nUyZHZ{Pi(`+vk|#`&fW9rxlg^0i;yPdyWO=6JQ*_m_{1R|Rh6bhj-e$Y41ay zpTE){kTvNp$M<79UaWfdaEUc83fwRnn^i|1sv=RH>rH(x#$5n4KM z_J?EJO0Iv~P!TUV_vEXu(^P#dr)=grv@XEt!}{C44W)6J=kM*EcdmKC8~egbM{``n zB$4`Z2MT?*5F{Ii3jpg3+V2j|K*#SqMOJ6C_4)`(ULZP1CB!k7f3e~@U zGZOc>J4r0P|5~8QzKZUnK2}HS^8}mU7rk*jE%I+WZ{x|iDuJP2ti|;oxZPe^Q#_?w zoB7J>j9!(Z_rfptU!3)ArG9_u2KUbg^t}IF_FSKR$v`pns#WWQgZ~^o;^mKiubrQN z`H4pH;ijke)(UC*XPUK5cu;URRoZR#`q?puqGqceKG~JF=WNFr{f8m9FHgI|aZaLP z|MIV0kNdjk$Gkc4?YzhT?S|f$R|Z<@$4!5mZ)$mYC0FW%@7;NGG74W-TmA~@)b?(w$t-S~2o_uxmGFv1P?pGDg zx+URx*DK@hgBnJ6CO7Q<^fdU*y*IacUntaQPe~0~Yj-h?qkQJGZ14G>vt?cizFRnj zKVPs;Gu$_5_qpfm`J*B~Pd`$tmpuLE{N>ALsKvsm z@)CCEJ$%_cW!X$w_5-;;cd}mpWG~lXdiP>~%e_5y75c1o9gnxqHObGrI7xXn%ch%~ zrzKB6s$#4sd5+z+Tu!-We}%}*L#GUr0-a9HIO=%UG}&^qvhsDG=jMVRvJdQ7r!oD+ z%5(bhqPp`w)|d69y)!@X@#nVshwr2LCwp&NXDT7lvnj0DH}f@9-Eo7^RafKQwS`7q zvzXzd<-4rt>q*Au|7%{Pt+Xo4kC>WQRBPN3bMxwvt_^Fi?06Dy({M#zXNg`}gl5>J zqNN+E7D{e4Dtei1QqA-1Sgf$`hT9X^^|xKRZNwzGYX_Hm@J7{>2XCf0#a`x1xzzOd=~{~=FOJS&JzdV}ob}f)&Xe+ZtTX+# z(%Ef#X?HIEe16_x&e@jrn-4qpsVDSawaHXczInrPQAc|7hpOwhyb|n{qISizI>=WY z;@RBs$MP5Btd0pQ+}HO%;@DjmHv7YpcZy$+sIJtPpC+^J^rFf;K5CkZo0i;tbSXk; z&;5&n*3U$;Os;JUGg4o;%wXO3_6_-W1HvukVr+Pyhcc@z%$xtaQ~8Hr?>60jF9U92 zSw-h%@4HXsI(9_rWjqi&ER-9zL0AuIsX2T=00q_B**o zZQkrpf})Fs&b&OrTwogO;kSR!!h7cD>+9v%5-&T<>)EM)S&-=n+m9&*9fez7{bQ9m zbgaKtLN3@NEc>IbXqE(jmn*BB;F-T#+3oJ>t(BomPBElpEV?4{NzWjE+xC+Ouf67U zJ?i6~voA#DtYgHyD;^6muH?_j)>*s}lb5iYNafVE zTy!;~gm_M8Jh8n+&0nBc21!$j%if~<*)nQ{arN(-u6xw0xY#BolO@P9SM zw8Gf+7vD9}1O`v-cWJ*X9W$@j+}E@hQ}K}7!ehcb{d0-c|IeC&Wx7|cZl2M;UH|3e zUl+Qxy#;dL`g6>`QrFV&^eQ2G?cdJ|Q%p02KCTJ*Z0t3mFZ)aN6s`m-E>6asC%$Aa z=`3ijKJjzW|2d~uu`SckeZJrrzx>=D|K>YZzf3P@m>=o>=)5th=+cdc4~nhVCRZ<; z5%Yi}KiR!SJwn;-Q}PkcrT+RJC3%aSeb?!}zp-`m>pagVY@3R|e)&?ho4xky!=v90 z$tWmK6q+%6dxgHvytwDeg-<`LZq z5RF$pc=8#?71_>u%Y#DJUkf)0Z9Lf{-eIhp66RRMHFeEdC6{!uM$d!@ms2w*>L2-_ zGiR^bg)TWK?`y_=6B~Rcao-dDy2Nbz%4zj`COlVk)HvZ;IECBO=~_~}jBNLAeRq|2 z+7VfppF0PchT) zy|N-JLdje{O(pmVgZGM#6J-rDW)mJS$)C<4GOHou_j1prG92rCMGn_~W>Wie=(C`N|h(Jr@KokdwS{wd2ZE*PrU*e>?ZP_eWm1syk)k ztLkDK8<^(F`mpTW5_9ZQ#Mkd9PON-+t6?hB z8|MV~&wu-wIBJptN6X|aA#$(0@3f}EiTXcB;66Jea_ZoOd8k=1C-68fb zd9mY@xOju@!7NOt1WX-8-*q`??KQpo@~`c`d^OYKvyE=-_wasFZ|L!b+w)?Zt0mP2uot@T5&SR#VvDByefl`MPFXf+EZ~)co(%?sXjHAu|hGcbA^~F z%d6II{iU03e*Q1e?rt4>H2KIe&HDKg2amBlxL)kCRb*;&={jx==6@ln-75C`JAXWw zq*tnPc=AhyiTge-eSPfLgbB<(JLmE!PrbOKsOnYa{`*cf^P)JWEt<9Hfa1%uGj5lB zGGsQHW}*=AHg&Oiw8o@y3DUa>ZUt|Jn_h1 zzqX)cAsctzG#lIed)FTx<&{|2CDW9mCUMKK)N|S1!^Szw-J?_3^pEII<;n5MP)fb( z7QpkZ_|@S%)>ePdHI)|!D;&A_MpRa;Fa1C`cj7zU4o=PA&2!gh%#~FBIa&N-sO`_-hs*FQSf1X`tKDcU*t~gTZD7E#pjy7-PXv?4f6C&xWYU<+~*Q2v$;>@3S$~ww`Cv(ubE;p4`38^}poyLz9-B zf4z6-T6RI-vvVD)KVMa3n|JHp`w!nAOS&Z>EkfBj_-MN&v$uG z*9H1_3OvotUOrygQgTq!No30dwb}03x3|tIc^p&ld%b$nQEiu)BKE^^re++rr6z}N zy!^W~qSs}0uE=#&;hiG4-@dsdnkHnn#iiiS#U&9L-?RkI{y#lUJ2d9fvbJj-|NehJ z{iWjn>r2~ypZ!1o@1N#iyLGM4rW!5EICRzDJ>J0~G~XfjG25z%G2K&JJD-JKSSuPF zCOczEh2x)2k?j*DAA3h|&FuX)alT;3<-052ya@hhk>i!4reP$NS5cH=$$5JNe@nBX zVZ)j49A91KZGs$6JBaR>kZd$pqSIyS^$j!C7Jb?wmRx-!s5kBULFctgKCUo6Q7m^M z$3sXkQ|!;;>)s6ySBW0}7-)AOTF%@jcE_*(e2(H@7_QdXo43D;Ncz%k)Rfs=6MbKi z`I+Vfp`~A{y=uQnzxu3Z_b*FO-@sDnb_`o)#1fMO^K5_LeJ{V%rSQvNJ+qX_M|3y) z$;=7WzV`3evTN#v35JK3nVfr89Q-t);a%U}pR0nhCnn@b?CC4iR6f)nyEG+WdYZ;t z)st+K`VEX6erMH+e!TQ8Y`cHfR{a@s7jIt1=F;`XF=eaQ?GN9lvKggy|Cs#b!-tYj zZ~lD$wOf4R1lui=D@{Ls-xw&l_sT+%bJ3-<-!h&&dtqX*eZtI0Zr%LDbKM$t2qa86 z>rn0+nw9ry+T-2co3y&$eV=byrNB|6wlg)tm%I``bSbmvc;-01aC2ByD{a%l z&t=gt-O1E|v-FbX+Ea%Y*}v8{eAB;K`f75d0?(C`mlRffTOH2t;aeX0PitNF-YE&f zaWRn%D!-JcMeX>QEjjW1>o$fGmhBSTGfj5~8oc=*IQy#SwAL-ACvQCsHhnVb%Z0yA zRWrGsH)Q49lm8K_-{jI;_E)(@OQWUMJD{#tV1wiOk551Ue_g%#dKh2kb}!E`A>O}S zy_}IAA;G+t`20;JT1^snH8?Y@^VKWqnHsXYR4#SSu6=qFpRzsrQ1Uzeo@RGmud{>n z8mncj^ZnCTMWo3yw@fv>wAC%}+Uy;68+Vs{Qr}jpHkV^(Kz4K2D`CaVu0y-LxubS* z8~r&p>Gqvn;je7$CZ*=}I>nvQ6!UO2u zwv4r>~evT4k`-xXD`Nrv~#qoa}Cg8nK;JfoG9Rh}zM*!AzvjWa7PeUn&Z zSnVD>cY5eH;cEMmg!+TOm#Eb3UOaj2+hv|xjIaK>;cR_pWy+_Sg7=sIo4@$@%USg= zb7!bO-gVr_uExRXj)L%wmy5dB%GRX@h1L6HMYtzhSA0KOJ8O#HmfGLD7P-ji&G6sh z*j{#9yxQrie}vl|w;5hvyB2@?$aRd3C&<@Z;rryXB6k+FYdB=}I$iq|DskF$slcMB zg%T>Rdsw@l@#lQ52tK?qw^F*Srs8$7u2soywyzzFOeddVi8gr~_-{>wTkWg`{kn{w zW__KuZkgm#u~O@$iA^GZbhpYEx>X!xJH~3MEv@b#|4>SWt%vYOZGTPyzexn_FRsVEf9U)s!mYSBOSX)7ifG~G|Q`}&Ja z@9E@uzlzr0J>pmS;`&rS!K*jsc>YdNdtZ`ysfA;Kc7}KOHg6sk(bZ2gdcSo|n8z?T z?fHA7fcxgx|GvMNyK3EUQFW_(E_c4A@xR!j(>P0b6VC+pKkai`S-;2p302DauhrQi_Wy4*Zpkrhf1DZX&vYo2fByk-;jf*!i*8O0`EAz^LqAOnoj1I1FI$`9$ab1 zzqYyXgtw)e{Ilf^&p64_q7$fQtO|87U|-j$QrrQeZbI67~tkH5h2*ALU=_IkR%dz=+p zUOA6bVfsrIew~lDcV4Ed_e6bo^07`-6in z%S0bH9D8}#_{{$u`)e)*u$_GLQ8wU`m+oB&n=@bg=0$mLwzBCp4>Fr7EztJs_qm<% zj_(tf+g!Ev)2J1QO%30aogcq3VpjZJZS@j!?tfZyv>q$3_`P7Su!n5Or)_)AIG3w! zV66?mAANIf?cdPOn=W2FvoyC}+LYIT+P$r@ zly!!}P3O<6kI8bf28xCl@?Wo8dzVx2+b642iff0tjJ{7o&*lqFkv?SvgEsm!ty z_OpLmZ`!OgH8d%@J*t>@)&kS3)26RXKBZUR-&nw%85QRnX80+1PqbRgWtMY1NfAdK zGEO$H*1pucZdG8H(u|ucS59%%+7W+L*WrSDc11!=1lPiCAH5Yzw|@~%dhqH(NS@l# zkG1C$wO%=`5fJZx`Rpu%?ac=}U+-QUxY1^wMNDLx>AR3w_VPz>yIJhFpB47HCtNdf zT79`7pJ&`{-mB_&uf~OQtaXjgopI5!Jn8gm-Fd#s(norNq!;*GM4Z0#abLHPiGLsi zpJIaY91T(Zh5C%WU+vF*Ho7)NA$kVCxzh}zSE1d83HesF)@;)>4d1MPKC!Ea|3dQe zJsY*}e_DO*UW@02`O-P_XFE-Oq~yl6S|;klt2Nq9mD!~$mfv0zWTH@}-}B(XLiui| zY2IJ!G@Kf2R!!W_qV!>zm+|X+bwWII3U18`c(QNbBCEYQy*ZiN&Rv?uSnZM7St75Y z_`CJ(r8f&6Ds=h0WMflYl;ATjX8Peo|8BXfM|QZh&0qe*<3eyuYXzvsa%d2-(T<%6M-0|-Ag8W@;=3m;{CTe{<>c~a2{Z=;)@RsuFoA_}pxHaq8 zmX&WdCt5vZ*>&>ZirSd_bM4r!3$_GCYQA|Q=5Sopzwex$efTOD>v`OLdwPSGZ&mi* zw5hS~!_oUarBx|YzU>KIGTAP2?vIN?jq10)89%K2-SS!@&GpslciOu1SMR&cGi~16 zjRrFeWz}xpyY^!hFPCk5OWuPt#?2R_S2cXJxcx#V=E3XD^b|K7hTY!#Wq~Nu z?}9>^GcC@|`OVjiyVqQtpz``-#KooiEvzz9{;hjD-ET%m+FGBW#XDZaUN~B?Lcn2t zjbe3P%kMu|d2Wh*xnnK#O!d;dQXvPY6IZ$V*nbGBmKn@k{54f*hnnW$FAt}EzjktJ z*c|7jOBWfdu`t@+*tuS4)8Yj?Dn$+Mu!J9ep*=x)fB51{Q<*c_%b71M+*2*uukARg zdBX;a(z<7?&%+)RFzrzmxz(##6DoW!TS&;}Uum*^w>q1`ezx!DFaP{q+qTt@cXH3v z*UhV^vYqr*(&TJp+~;q8mdhrieU*H8Q$pcg8|lzGKP9;f7wq@HjbZlJXaAMlk*9e) z_EI9t#xv7b%HLJ{p~0FUv`a;nWk%+!DUO$YeSaorZeJN{AfoZ)Lx7aH|LbLQCRt8? zd)DZ~h4tCjp7LCK%rncRZG~w_)l{Rz*4GXj+5aAWD4x=E%|U-wUA9 zT$9UY?zNp`qt|=#6Km><-8EseeRTJY9$%O8o}TGxd;5Ej z9b$c`EL|Mty*ugjzuysFe*_(y_MQ4@zxKiDhe!6xyH5{OO3&7i4(&@xob$)O-CS@;Hj~-jCia8Ohxjwh|fxl$-oOyiHUOIG4Sh{~F_muh5wPyZ`T^hY8 z*egUd{6$V^Xejqv{Z%VopJS1_pk=@@+tDNDheVSPQ?l-fokg2&RVtoif3aeDv`0@s z`0;4_SkJEON$GC_*JiY9-^_EKc869Pd`E*G1ithBlzC}(P`^{dhnJc?&$;2qb z5A*xpu(uz0ceQcW&s}#{t6TaQcIQ-PJY(7#lvVvgI`X^4rf(&>i;JfC%f)}#@jCN; zWPfkK3NJS%O@_Hmiec-syLQb=&6y zI__bYS&tTX#&MOOew5sLPxI%|_o1#!${#L2*Jqh}uTM{pX~V?IYkEm5-*Xp4>wo_% z|GfLd%a<0MTq{rASsQqtV^{hS+wS#0COGRc-I%k_M%(9X`@&d3iL+*#WVh#Lu3l%Q zU{|7i+VR~wmt)Mu3r)2=SZ6=k`&D51;r^%POK;ekCOlmdAAbAAmt8qCEQBUY-j2O| zp2d4kjMvK3og;MXpnKGshmR-uUW)ve(0a(o&dK)BoQNPh{_^TeEs`%B4bmIm zTIMa{T~ReV{aKx<`r6B9RZsXfukbE?aQEMvh?eZ{1?7V5SJoVTbIar8axRlo0XvVL z;L#L5*8fbob(((Wf*m!DGXKOSo!Sp9G3Dsmq;oJwUcmRt1*VnqGrn;r8-{W;i}3uo zYW_jCHBf0=sEJHznxTEsZTWnsFS~>o9zQ&2-EsHoArs-5axLZWHw0|>w#d>pHnB+h z`;PYapGq2|xIX2*`odWyF0I>b>7IO#SvDlv^r%b-|0CBUCfg+Hqpuj9$ksTr!*k!2 z#6w}T`PMvEU+=t-ck+{vDUk}xp7BTW{Rn^BIP2<{Z`IX58b9YxKl(pcbbt33$-TP* zEm>I{Qv2Sn(+Hd+A9axBPJfJ&ucrCIj4j^VSiOEMH{yHR6t>BCVY|S*km8TLi{4#Y z{ZwGuzRZPnqQ}BF#fBgEy%4{y=2F_<%l8-Z`$nEuj+1LC(BIqR7Qq(I=6?5gyWq4R zHryS$UH{(~wQkgwaZocon_sr?n_-QK4ZruZkhM({50~$>*yJ=tuqVT9+spsF>wboA zxOAOm+sozB6$gd3Nl(6h?#HVf?kzj|+}5nke%m8>x4BJTbGpgn?}^QgD=#0^-PAmP z!SU;yT`pCvAH?e4{H}TDa#C_mYiI5r&f52rAK%&|Y`^T<%#W@Mc4qtUKK{b(+n?XR z-^Xl<*fD*^+P}p{*IE9&ofz90clWX5KeJEayL|#)`v)E6l4onnNJlRWLe|h?v-K!Qn`Ch0Wv?aRX=|oG*D;JJTs1BQdzJ#mW z``;6%Da*PK)aZz49#Wnm?cVk{ zQ$I66*P3a)QkVZy9qE7b^VfRmo)oKc{`e$Bs_)wJofCg>`5)Z=s>0qYYbx{A6E9>g zZ9N`ms&(6IkLF%2u4fO6O7ipBcU}y=X&(MC;8)MX%BnjbjFz!Jd93hI$}GYq@P+y% z!El8Gw&5C86{mKx+$zaYPdt4#eZseQG2aj6hy)0}aB>rAzy15Ub%(^VkOPMWcw=4P zX~a$Cz9!&$r)7s++T(l0XYZ}C(chzViSy;OjpwI|7f$>3WsCVsbEXNWtGwP?29$4D zT7LV%CAOE*FB|{7I$$nvJzTx>m(5{;`$wLXepLEr9I`f~aK(*t2TrYY{2t4(M4 z&ZvUI&ktn87CUaa_2^r{|EW=JVSy+6emdVgnJxOl_orx^MJHQwq?O1&cfJqT{$JeO zyfDJ}ckR>*n~L98YPTCl*X;RczrMzHxlog=@V>2jE0qiRm&`J0TbUV-WQGosvYD!nc&yU|}O!@JyXUGjbN&7ULc7=PJ?@<`<;KTq@x z-C^A|@kL{)RMR8GW&C)I&+JTYozF2T3Uvayhqb`Mc-%il1N3Ux|9N<*&u=75Y;(>lk*jJ*Z3hJGm!= z_w(PmPyd$h`;xo*Bg={ZQ$KPu&bd8lZqWDpf|jQb6b1ahj9MTGh zR+lD5Y)d%nb0Y79{`p-wa}LxW|65j7e{|mDhUqU~Jj|W*bG_&iX9+{%OZzuk0xzlbRg4v)*Lq3u!R?*ufT` z{K0+t6xG9$ujfWj{&TuvpLo^voPZduz6#ymv&jZR&aTCe5=@P&w!3`uQ}i`y+o^ao z*5I2B!@6a8#;fOKMPIDG_x*_am!}%9MGr2?nDrrWO_8r~hp~l-e^U9b8m*68`mP$R z|EkDzq;fgSg+rzyK6Y!S2zp8L{?FNP^FYBed!_u1ABAUr5BgDW`}eyz>#ayGUcSX* zADU<0x+`5|eb$OG{N5_D8$55_taw~Z+_ij<-0E<>Y3HA zhi-4(zV)mxe5!Rmy9Hi z7UiA#D;Df<<}*9t#Rl5 zEwpdvVpC6h)-xMEPOOV8n=Y%^5TS0q=bzC!4a<-HQy#4~^_+S&xB3rP;}Jf`&l%SW zZ$Az`Bk<-OkHpI9a}%q=%xxmigz<#@$Su<2yTr}k=;ReCV^GwR_NUFr_^)8Yis~fJ zHIa>NjloW3+h)YQ>i(Pme$Um_KhGXL)pdqTsDp=Tdtp|!ZWQb0Gm*RQ-xI$ZcjHpn zj*mxvt}B@LLpeJue!hiR#(a*6SAQ;=V*91@#M;T%1%m|DU-szVf1h)h^U8Ns<=uSu zJXAjl%is3;aNYPt7{|@iVUZH*zV3|60xuM`8rXh)aAitVPT>*HT3K%v&AWfo{_jcM zyYukp#bMXaH$Zlr)5^tc| z`vYw&{y$lx`Xn{D_|xJgdFyKbeOu}M>r3M*JD$ZW9^6*k^y!-RmAK^+x0Krt-Z`3| z+{jwOZ(j9#`FVv&b~}ISpZx5*bAndP-QzZeCK8d^i!A4rZ8EAmUT~}P-yhqOiPxT; zbv*LGJI2(jN;%ro;D|!>(y+OGjeO0fl3Bk>?eFnDPl~!@|8t8_o$?}eg#(4!NBh;* z_8n{4F7mQv>aGcEQdwOmZVuC;*UX1nPN|xK3Px{{bv2eMa(4-CduUW5LI=TPkw6zbb7q_iazhb|mVQx#_gUR!_bzR;t)`qwYkt4pp6?Pj@gX^!c_%L^th zc=g!N$v&lWThsLm^NK7JkLn+Ke{w>xB=gCw`^+PLlv#(K%$?yd^ZnIjcO=E_GB>W& z@z(I$^qQft;^_JPPL`%N|Fj*m9q!w6_$`$`{r%6}d(!{wg!WHA&nC6zXkpAF7asF~ zBt5IWN?H?NT}a%iGkvM^a-%o1w0C&~C3HPIEj?k{@u>b?uU5t^23S^59t+a2ewHSwIfZ_-3XEmNtOy`D+y zE9PGQysmZDYF6>LUq5{8k3Z5Amn4<8uQUADRa|Abbn34y__pyKOT?C_N+NP2D_OSvmC=F0HSUTYV+}@ZW z%}?leIsQ&(vTrEg=7)v4sm%#34q}E3P9bHN3YX73YJE+9`wI^1-QO*ELuGd_TEA*f z)8S7?rv5v8dzIXj?{`_exO=naZ`l;^@T%~ZpsHHcA6t~Fj!*NP{mAa~?ELnCMN%J6 z^ep+!Q`_2@|NhFNY|g|9Zx(K{-^1o9wYy=lP@&`l|6GAXm+hbEJag4)b=Ey^lUBeL z^1+6sXzP|eE(~rCc`I4R6*D}BP`65O3 zk*JcXeZyCQqTgO6|Eqt0$iDfrQbu%nUr@Hu?XN$ivnIFhxc>b6+EqVleoF}YjP*V`1w2QO;>7w9~;i#`5WTCk#iL4=R*L5KTmw|Rw}I_lpX z|HE3z+ukd7Rm2LimIwCI^D54@&r$Q6Sa5kV16Pu%T=$e7mT<*jsY#ygFZmLz?P9eeDfNw&);;e^1eWvk-*QdlHU%@+#P7XTJxvdS9U)3 z<1_vEHn{4S{;ujjZScdnb=d^oRlHZ{PgZ+>Rl!c*b>rvnOZ!t!m`Y0@$TOI+_$l?PV^$)X@MVbN( z%KC)7DkKiPlmiZ;wItfxGqRJ#W?+& z&3(7zw<0oat|2>E#9BUTo`0*kTFb|aw|lGbqqv%Re3K=mZ$J1sS9-U+;E%-@H;a`e zzgBs5;o*&=A|E!Y_~%Z%ue?xcmU4j2srFf{&rKDL)-Yf1%b2mz;+}BXI~Dbf+mGG4 zRg!sD?M|nUapQ^CA6_e-dNX0dj%f#0^4#ue(RXt@w$W(Hlv^rXk9S;L9ky~7zi_hr zy*}4~7^m(#SKgjKV#=CvnO{HBe(u4EMhYe(2}(5&rzaT5y--k&El8N!ee}%U<1WER zkNlV%JWVWqdawVz#vcc?a$S~49aoetKAc%_FmUw-!NXh(SC8r?^G#l_BQC+VLM-{^ z=|e%T8uCl^a@RXNs&ATTb|r*iVfsD6dB!1CGOpGIrF^Xot(O_EGM^5A%<#+;Q)nj&x@x*GVb$3nxOE0o2R z#UwDlU!kVl;GdiJ$3v(8BMh!)rU|W%VDfKK+PI^5feHI#oqg z-)r{8-ra8$HgjQ~{LQPEDqGm!x;Y$4$ynuksp5cqmq&GtN3NK5*jeov6MuxQ(ae^p z%u2dtsd;#%(f8Q+6@@?BRa%SE1l%en^K;~`3wk?oX|wH~n2x*Kv=uJDOR8?JbZuSd zZ*4rStuex!^K-Gd%6O+raY#=0 zP>O4sd;g)(%2%2D{wE#WBsnF~XCD9R<}xMgf3t7zKXKn*`rqt-@!|Kszx`F?HMhu2 zdbi)73BKF7Bu>d^{`zKTF6kWeUpB+$0`uO~p2?xw$z=g`uk*RsQsft1h+K2hzRQ#` z|K_`pR7UVm;qEbW9p}-&GlpLlskqIt za^L>*^0HrS$?jJkDDLj!QquES_O$-8XXw3vM{ecvm-5$~J=gww>CEGQ|J$V;+O$pd z%KusJ$^3yOQlb@%E8l3{O88*UmE_W3du-+H{!>+Up>amHlLUgT3?BXSdGyBlV_$V# zv$?&0+LQw=&zFbF?AiBo=hv?d3@Hz96z-JlYMHippPkDCF%Ol${;Fcr8aD)NS$@r} zbxNsJL|SY-Bf-f*eFyLEf!@!m2hImB(-vx9HP z)|z9xj-E3&yXg0R&XN~FdcM=5+k1^_CQs7beo2g@UBK}~`}gGySFIOCE5!(^&U%@2 zEB-QH@D@==ohjGmZZI{PVXH56?|a|+={!}OlY}N&q+J$$6qGmT`+^VuAA9~V_;l_- zX2k*jR#9Qi|Eu*Ms_&dMwaiaO>F?y=FuB!6&LJKTL{wL)E?sl!(w4NQ`?bC^Y+a06 zuKx4+%YHjb*v_}_*ou_7GTy(QKWJJJ)K)xk(;c71+qcd5%U|M`m-|7fyVx?500>y^ap^9y2>MT*3N^L(!U-@WGR zjXc}8N2jWtd;LSl?--|)j&0a@AIbUfU14 z#XmeQGfZ}ZF#qHb1f+e6u&)M>H#HnQG+u=v76 zet~$Ecz?|+E|;5=p6|@*)yt-sx~24rI2TaAkHt{K}R0GQX{=zB{*7Nj-Lj zZM1=nVah$fMIR1bc(>GLF^?Q`=B5h=?)%^P9dh{D?`JPGkxj7!p`!#A};7C`=6cH|Lz1-|@sp4`9p)tAWG_fO1P z>L0Z5-Je%h`dat2GOX_Jzn5^DD}4F3xZ_fak{`}27T9#E>x#~vlN(B8f(~#lx-7Y5 zzJPOJQJg3)h{tRI)q4%a(u2zotXwu{%>lbW7!D#t%Fz?Eb|0Cvq+SKTUVx^;2oG@vp<* zwMzZluc#yT!}O0;aRZP3x=i)NE&I2Dg0<*|AEx&M`jc%>8`jalCF@Mq_(l+ zRh_DL#`?-EB~w-_FQ)z1?``|O*5%E1xjy#i{6dZwxtq*qeBBaquS}}CVCOci@<^7{ z>HdL_O3pS*ZuR?NTQ~ptMe#@{QH9zW$3BGnr6VH@cBdjn2a1|HcrtavBIn4UoI-oHFCRk z$Z|vQ$(uhOE%&Tb(WnU&k(;c!a@&am%rdKH9=-NT-tg__#c$88m?U@JBS-nj)h9=q z@2rcMn07X5#&WlSZ!ax)($gR9n=3I(eujU*UapTvj4qY#S-VK@<@vJxJgi5$uQ)8& z+ES|3{k$~oiA>e!TRc`PRHY2lv=t@5v*q4>sKP7Sd>4IwP`w zcLZX{R?sCNCN))&|F=iRZh3l`7ItV=tmY`36F>5J#8nF>cPu9tZ39-y>G zIM%34n(3{W@QgXCZ(lJlo0Wak@OAKM1%JMj4nz5z4@P}EN)je_H;b++nqR88C@Huy zkvYX&ValeP_hSCKirsRZ5)#4LswNT;wm$B!$U85!O>Nu1+4hUye>I~iB5KWlm9=iQ zZJ*CQTe7rw&Ro8^K|!~hzZn>W$vjjG3ivNnut4bQ`6YMehB6$NGGuAATTy-1Q+-D7 zwW!;z+za3Gwl$oaC%2)Zv$N@&A;Uk(32(xR&KYcbxwDV^=qi!m*RBqye!HKOtC+rf z+XKHJkwH?LC9RXcS=>}T-_=<7^3b}ctDJodOdm!HNG59E-Tf`|Ws9?pvD>bsWbX6@ zdeSqBD)g+j%`JJY+cUSdYiHZ4YpX6id-OrGC}vyNUbDWXFQ-mRqu} zDr7D_*&nMdcYdY7HB*k?0xyn!n9lGbOKXphI7i85-6p;M&!3mvynXV*mgqT~H9Hz| zJL*w$$lGIqsIudd59=vFE2Q@QmEh7k(}OlWWHUsST3@lPAf13D{MZ`67*Hg=^e*C8iK2qly?S zO@}RZo4fCJsOxu1Osn2=aPsSR=c$kVTZ`g_PtX6Pr1{(6#I?I8oxizni866#oEN?0 z`5TTXspDcBT=c~F%oKvX_AI^i(@IwP#qMunGL0_mhfd3_{GXl5CFHg8`0QJkzqnes zJPo{d*1c!#+1ZmfIz4-{IBTM>!rz{s;f!tPE$qVIGO1k>(&5hSUEmd4t?;LMemCdw z*XokXV?|E0)RewaGhSJe`J;*{J0vaGB=xar$ED=DMH0JtVtdvvPWYX2t~o#^Ze!u1 z|7u3Fa#y^VyS;5*(e0yIHr?SyQ!FJnd=j|Cw(9K9dVQsBLKQjhs`eWT@jc-7wN+{i zUzsZ}SKPV2UBGP0WA8ch`m3~(CURzWxljJ#`Q!3hp<6Fji8mIi-dT0Nms3!XPdwA< z`gykdX-qN(tQ-FAuJ|bLEMXdY_?~jy-FIT^|NXun>Jsqyz0{YtmeW_P;oJH>jB!iY zJoluu7i|w-e7tp4r&8~L^sThN-ttDrT|!G#Z_{Wmwd z-6}1flXUIk|LZ!%N8+mc*B3?nxPDCZt6+}1tHQot5n7d*?X&FH`@11|(x?8dV0a;`plk3UFl^lwK{a!!%A*H) zj{fzWwrb9;g6Xy^GEbB(`t#J}ZEM*59jsE_eI2%w&#gcBa=VJ?k6!6Tvra$nUuv)Z zTBQ2seMuoN(-j|M>m^%6W|!ux<_TurH{9{*YsQbJ6$`%nN>xAu2w<3Dh1I-D>b(TBkzBjc!zT9;+#~jtK7Oz-x zvsia5+x~gwf{n}`$C5w(-dwWdEvs8(=Y>5xxEQx*7vDBLHQ%#`-Gh1aRG}@luT0K; zwh=KAFZ&uY>u=~~gSnb3vST8654{hLJ{aAmc#5lRYgeiDzuyW^WeJGW7p1dgz?f4ekTUE0>xrxx64nP{RI9w@J)=K^6%}Bc=p4U>X8Q$4cmpf zt(qjtl_tLVXB)+Pu|}h+tciFh7LUtoG-`ePY4C+>%J zrwT5uUb#W&#qH^(+j-t6W@zy+*fw4a;4t_%?d%bHDA1GUfh%8DHdY6($3yy6Q^DJ78j_s+OL0!g6@^fU9D%T3O)Wy zbQhFAW3RaumzaHa#*`Q-J-L0Ap;zMXxI}KZCLsv z>gvjMUEdfVnoNC|(iVJZeyYZ8rOqwCzjrNsWK-G3UCdQ&XP+-2X>@X*<)tm5?tg0k z6rVd$%U;dCdtb`y-^a3_DDC2@6zPt2Xu6Ve>E`0(1DZBD3(>i{{JxJbV`zOqqRc=c1Ee-YY~c>uP&iu6wiUXUFUuhth2g zXQOshzdZcv%AUqt=3k0277tej=j>UT`khlW=xU;~=4M-MPZ=qL#RiV2VofiaAA0J1 zmi49h+K*iKea}ZfeD*c}L-ME9{j0a#c$1precNa4k$Lxu*7rPVa8EgR#!hDL>2>Cx z6xSE_y-9TW=$&6UXMu8tSStIMq7VN!Tg4lMP5;fa>b?E)wvX|#ANN#!QD;-I_-1gm zE>>k$W!bLcNz?nJou|8)XbJW_Fx^vmWQKo)%NoWuU$^o%uMR8ytaJv)Pfe@uEi#grv#}zgF{a~$@25Zf_YY6G^|S1i_t$m4 zW{b`kWm-7Kwi!*(J}j?ZSU95ii+HPa-Pudfcbj+rXG2x8LF&!kv}6j_|th-Nilw{yPV1! zW37ckOJ=njI;`cpxjkp2ZFI@YRn-eJ`UD@XZoYeY*U~xD>y@`1TGGo^)>v^@PF#Od zqSbt_MM`@g--*s@{jqV$66WQngC88R^?N?`hL!`zmH@Td)7t}EefHKgyIe8kI^C=M zOjX9t?CS&BPoLLs;a;0>wB`Op!MPX8pDZ!II_tP#{%?_J6Opo`89(}e)uxuKz7KeA zHKkPj<5Z<(^En(>y;)RqI^TKayKXJL&S( z<#V<@U!8YZi+x&@u*tL}Yl}0p%+5qy^=vx1X_Zf=fjq~o50CeT&(2XRuwUPHt=65d zqCHPjx>xYJhf5b{*qo}FzU8$yU#_T;n7c4!(be{2OBE+6-fX^nprqq;?%RchbM~5v z7C*bbP_eWoo9pT$E!Xq!)_>()GAVG?l%o&!%{e{!llxxZPBxK*iMomxT21dqFIQr5 z+w2z9EGx21?D0yGA) zxf4!In0s`EYg9+lp%tsY&N!Fv>u2U{>%%FS-1OBn)H8#7F_Sx^T=fm*;K|df%C!wo zCGMW{@+rq%(S4fMEZt$brFCLwH=YkPej%$Gy8hjAohm5>S++pwgF4G!uAg^~u~DJg z^mkMC75n|1Yn&Hz=yT2g#CA5rFXc89ch~XNzxSLjJkvMx^usgPerddZ{bKb&jZG&G z9}cT*-svhdZHwYL{f(Lo1K$Y%f;5c z-#z8><5!IFE2f`#aD|^~#=Y+|mjAQlwK!9n(9hsdw$A5LPmzrEVy$ByE7rt-Jg%^sM@=Ta!zaJEA(o7B8N?S*NHz_8iOnk~P;C|BReJU(<3< zLAB_C)`$6@SF7zPTgau%JH@v5;)Qpvi9g+&y&l*!bflnFo~7kCB~<8(oQk@Oxotlel+Q|PjIBIkbIuVrUiYb zUKx_Qvp3aAdZ@;xRDCEspXPP#^pjrAM2Qn0U)k*u<(B6KKVDrmZJm->M1L)F)}$Yr z>_?SCoElwpQjb*}zT*0IQLmSsRtd+Jy06ivE8cxvJTsB$Xxo!dYrO7<78aE1Rb9T5 z{bF&8b-bEH{nGvuul#l%-9KYXtWtCr$Gukf*+tFMG7-3{z4OceZT6q;-WKTTWcYvj>hgw{^By1AU2U1lqnNzDOnj-v69;<{kt?s4T2ETE zZ*PRka+a5^J708v=wRb6eYryF>7uvQYu8@0ZZdwn^ln$&_NeTTwU3r*{G9S_^O?6x z59jGf>I!+-)tWBzmn-#La?WF~+M0s@kLT_-iQIlIb~1bC1w&iC)(i8J!?qUQ`8ema zp_R_#b07C9&eAHpo2NDLqaFmq+BY0k@c1tD>Y8kiGS{!v6JuI&I{A|DykozWb&Kx z>Y(|zt}qp$Wmf4SYc?*=zZCjJkQaiTs>rYo-Tzq-|-sksEKD+njo$#&PpPzD{e9rq>&Kzf6_g~GA_szW6 zqbK+2NgjCMR%;`2JNL-+KUNlR(*ynUHuS`Y&%DU8Zi-+GCtuCa^+MclgC5l~od0~} ztJZ>@3FQ>Bw?0)fD@xhn-mbx01jDiox`RA6VI^K$7K4hL~HIHM9 z>s!^%s`HaWC;m3PkbY!ZR8O!N>ndS+)>P|QU9I3nX71{~hf;b^*y!zRj1CfxUKYGg zf6ooq-h!Xc(iY6iIDh4|M#7{o&nLgQu%}m0eeR}g|F}7e>Vtn2Tr}`be^~K(!gBND z8Ea*3Bp95k&eW2hSy^2hvNCByt;vjAlVjUM7Kr-axX|VEecMD&&fWLc@&3Ip_9)kX zqU)08^HVQWU-0xVFLEk4^fR98e*6MQWuETHxs!Yr9>}i|UcKJ*NYm|=^PZ+>XZbH% z#4~NDl*w5h+bx0~i?ZsY(f4y_`{M6(F`IhF_cJeDbci-sz2?z_@TzoHQ=ykLmi}qZ%xm7jb7+#(rz5QA9);iX z`T6swe$i(*m9|f0nwGJ-UDDWdX|AB3-9agx z`3(&R*)%$oW>@R;UYZsAyj3nOI$($K>%DSw-@n|s?+%BU{Mpr>rJH}1S-rN_VQ^5p zuwIdYCHja{+NKU+pNT>oSrzcygYQDz>S=FO}9@;CEX=tVPDF?hYa#Cm5-U)a=( zd*Y8iEEah>xg(}(tO$V8)xh%gxBt5f|XZ>oycXew24otNB;pH2Ve)dE3ETx`J zD%WFzq{BY^NVp>3>2&)??m?1#Di4Z3o68@4XZD-My| z=d3Ts-Y5G}&2sq{+s2GNdtc@77}lOCUTwZ;$)j+0H>O#=eH(ITg&xU!ew%5l?cIec zlb@8X)JbkTR&KHBNX*X-3w|$u>1w@pS(DPtGkFiDh4ob5pBWg)B-qvUC`aw@wKsli zl{qI@PW-5OR7FcwY|^=Ihwu|gf%oQ3O=M7??c929-t8>==sk-(8h$;`bLflYbf42C zQP-k*?4i#yL+%-8iX`{>Ef>7RFw0S(C;$Anzg_W5olf*^icY^i|D)r<<*N1b-v7Kj zk%^^vw#nYr4T|FIH*!3mOn&+-zm%i(PJD(=0wezg>Hf5zrlJ1fcGEt({o6O=QmH(@ zo7H5KhCHLAzWydFwUk3edFRdeSL!(X_S3q8;L@IEgD6q{6$#EuIxa2|5Bhj_gI4Q0 z4OSU>26fL$FU_eU>ks&^wK&F?^8cxuJ>8} zQu#@O2QvyP*YGfSe&xvs5MB_o;cV_-^FEow_juQ?{k!+RV7mkFpM5&>YTxn9{}1*hMH%kh^2lR>m8kp# z^W?{SPlxGme5@k8OXlS@-A4 z)4k1a1Il7mwub672(4g96xzdoSz+>D>p61k{pS}SoqYV|z0dBO@41)P?&F&OKES?D zb=mR_UlbJjdowefG#DOSc2OG%UK78}RuK!E3DsGrSpyMdTBF|%E z8=aC}QYOoDbv;em?&A`)<&Mj)-d2-Mua6jpEbGfDvgr|WSfxCv@r%^CRUiL7yTtrm z-R;7OfDD-_S2~1r&uik}G=?42KH>hk8* z>SN;4Y7d)#toAkfdF`?j&shr(RT8U#r)gPPvGw~F4TXt?}Fld zD_)narxvZ6x%XX0dCJ=96HQigZ2mf92mj}=tlb$dA$ekj{}a4-@aU5 zpLjquOHO*)lt}{F?HiZ73#t?yabDSzocUd7-Cma)-RJKetY_EO)SUd$CZ*Bk+W*s{ zGD13QChuZ$`!Ii}{N8P`YF3 z!%6uTC*EHTSf@XG&ILcG-$&mGq$>0GXDA-5<}T#A{q*p4-&u>Zb2iQw(s)?ZUCbW2 zUnnN=`8|cHVL@rLGfX&{_Nz9>Z&)sMDeuK~3wDF|&l`a=s}mX|K%dX zKY`Nq_A0A77iC8&SE_C7OkcX4UE;hY?-hmzE8k35ml*nX%bP4KA;y~I%|CA)Enma` zdEO2`9e3ILnDw=W*p@qvfgRylTW)vvN{S)S#-_6?(R3; zEeCeGRQTPO{Cjp{&1Lhd+>pKeH)lD3@ zXFalh^r&!x@EOC_^DDP*)Gl!qsfn1z^>srA*Qfrc$-?^|bL?9$^WW)4pIyG4vj5TW z^DEvs%({4M+jNUFGv2dzPOdnfuvzvJ@42JqjGb(MXLT4F7HAh|eqC24&S(1O(`j>- z@X7lbzE9EIdb{+2Qgvqg_Ka|Tt2V|>Orh)e3L@rx`gifOfZQq`z1r(Bk(W-M*w23F z&C07gT9jJu@}7$mEbcORE75kN(C}o(#Ag-_rQ)mS&*G?9@k(K4Mw0AN-lQvmC$H{| z3%GI0?uE>W?rZ(qV*@=`ni{(N4*L})_R_^DN%mrrSnBWOoTjqdDf;%8RYC>amA)kS z#c%V7eZl(e(2;hd0P&{3H{LMM^NF2X8!y{_PGQL<4&nOptFg0Vh5FW<-mvzh*VoAU zg{|%yPXl%y71mj-63oxA>~8){`MI|Z(&ZQJc`M~;`yorVs?s4aa82}!wj#%>upq|| z@{0}UAG*LiXR*@pmTHshZJcVU_gBojtSXxPJhfNh^c;b(-usGr%GMkoIJE5;HYd3* z{k(N%t&eEGKilJYn?HN@T1bgLmi;Il#`u5zZ5@t4+tP=rOnJ}VE=bm^w|1HwC9LSA z*peA_doH&;@BTZN|902&)qG6;X!tz7?_g!!zV%t$OnebyUrijPUr4-5sH#)Gzhkj< zbn&e{hJoA>sl^MmGkN|!=bvD{YX7U$&^Qb4$@1O3m)1m_w<-@ke8wb#_k=;$5yPI< z%!}u%NBRn1TD*nv)$Li9dd#tF-B>0G&r-<^iI{fyK(b-uvAg;&xS3AReSWC%-6ILt z+1s)e9NRwEtIgj1_fboL>cZt=HxKlzXug=?{q^now(w=QoCTsoEZU0mir;?_5~}fi z9(TA?ZPoE3zRf-}|8KSvd_KRkdBNYfP?7z8AIlXM#{B%fMpM&2v`{T_hWs|2M~(`a z*K8Gk&x>)qdQkGrUbfArHJ)gHX%PFl_=wmow{mVJKeR4>LUFJ!g+8w?cBp1gANQ|N~^ zE)^d&Sff_yKizYK=Vg3c5%-F@te%hJ_stG^e#xlue=Wz9l^;}X(yT3%18;BN78~fE z^gaB7M)ch^NAGNP2wyrgEipvOL}=yHsfMmoV>ADrSJhPgHtmvVNA{P$3k|L2O8xaK zdGccNy}1sDRXe?#!}`7y$ICir9Xhk4F?(sN@|^p!7uLML_xIw(`M+l_;uo#?v${L; zT_&@%lFM2@ZKJ9KUQQ>=kHlZxlK&_FOTdj?=U&aKJF;wk&FQlHyc*N2Bz#}@E1a|R XWVHJ?OSW$R6A}Io-)sNY#wP#(gogaD literal 0 HcmV?d00001 diff --git a/tests/data/arj_m4.bin b/tests/data/arj_m4.bin new file mode 100644 index 0000000000000000000000000000000000000000..0c0cbd210d486029cc8ddc8a95301c6a76793f68 GIT binary patch literal 66519 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