diff --git a/0022-e2fsck-add-m-option-for-multithread-mode-fsck.patch b/0022-e2fsck-add-m-option-for-multithread-mode-fsck.patch new file mode 100644 index 0000000000000000000000000000000000000000..e79047e335c63fc77c803024d4ad2707d836692a --- /dev/null +++ b/0022-e2fsck-add-m-option-for-multithread-mode-fsck.patch @@ -0,0 +1,9260 @@ +From 7521911489339f5c0c6c50a3ccbd8c24fccf8e59 Mon Sep 17 00:00:00 2001 +From: Xinliang Liu +Date: Sun, 4 Aug 2019 23:28:59 +0800 +Subject: [PATCH 1/2] e2fsck: add -m option for multithread mode fsck + +Enable multithread mode fsck to speed up fsck on large +filesystem Lustre Ldiskfs[1] which is based on ext4. + +This big patch merged a few paches from branch +v1.46.5.wc1-lustre[2]: +cae456c88 e2fsck: Annotating fields in e2fsck_struct +87956fd51 LU-14953 e2fsck: pfsck progress report +9aba968a7 e2fsck: propagate number of threads +7c64686d8 e2fsck: misc cleanups for pfsck +2ec32e1a3 e2fsck: fix memory leaks with pfsck enabled +65e05891d tests: add pfsck test +cbc482289 e2fsck: reset @inodes_to_rebuild if restart +34bd9dce1 e2fsck: update mmp block in one thread +a3148d944 e2fsck: make default smallest RA size to 1M +ee9db4667 e2fsck: avoid too much memory allocation for pfsck +25fbae873 e2fsck: cleanup e2fsck_pass1_thread_join() +89abc92ca e2fsck: wait fix thread finish before checking +2a287f701 e2fsck: set E2F_FLAG_ALLOC_OK after threads +0365be40c LU-14768 e2fsck: merge casefolded dir lists after thread finish +f4a01112e e2fsck: simplify e2fsck context merging codes +3e4d807aa e2fsck: merge extent depth count after threads finish +97a352d7b e2fsck: reset lost_and_found after threads finish +9daa1458e e2fsck: merge options after threads finish +3641f5061 e2fsck: fix readahead for pfsck of pass1 +cf6791b28 LU-14432 ext2fs: fix ext2fs_get_avg_group() warning +770ed1aef e2fsck: adjust number of threads +af60bfcbc e2fsck: allow admin specify number of threads +2ea8b7596 e2fsck: kickoff mutex lock for block found map +02a677ca4 e2fsck: merge EA blocks properly +0640d4c9f e2fsck: split and merge invalid bitmaps +a20634fe0 e2fsck: move some fixes out of parallel pthreads +4de7e16e1 e2fsck: serialize fix operations +12b25a3e2 e2fsck: merge quota context after threads finish +a6d96254e e2fsck: merge context flags properly +7d6322473 e2fsck: merge dirs_to_hash when threads finish +f74b7f858 e2fsck: merge dx_dir_info after threads finish +219ffeb8d e2fsck: merge fs flags when threads finish +2e08ff513 e2fsck: merge counts after threads finish +bc691e101 e2fsck: add debug codes for multiple threads +43e7ce031 e2fsck: merge dblist after thread finishes +dcaba7f8f e2fsck: merge icounts after thread finishes +ee33ef257 e2fsck: merge badblocks after thread finishes +ea2cadec5 e2fsck: rbtree bitmap for dir +f661bca26 e2fsck: merge dir_info after thread finishes +409111a4c e2fsck: optimize the inserting of dir_info_db +ed24d26ab e2fsck: do not change global variables +c0ff8fd87 e2fsck: merge bitmaps after thread completes +0cde48cca e2fsck: print thread log properly +ee76393b9 e2fsck: split groups to different threads +88ce0b26b e2fsck: add start/end group for thread +63f476a75 e2fsck: configure one pfsck thread +f88968b9d e2fsck: create logs for mult-threads +b4cdc225a e2fsck: open io-channel when copying fs +68bd0f979 e2fsck: copy badblocks when copying fs +5d9544912 e2fsck: copy bitmaps when copying context +68b29c3c5 e2fsck: add assert when copying context +0abf6f7aa e2fsck: clear icache when using multi-thread fsck +54b2c1958 e2fsck: copy fs when using multi-thread fsck +c4c939b43 e2fsck: copy context when using multi-thread fsck +805df6c10 e2fsck: add -m option for multithread + +These patches are mainly backported from upstream branch pfsck[3] with +a few bugfixes, a.k.a the LU-xxx ones, maintained by Lustre community. + +[1] https://github.com/whamcloud/lustre/tree/master/ldiskfs +[2] git://git.whamcloud.com/tools/e2fsprogs.git +[3] https://github.com/tytso/e2fsprogs/commits/pfsck + +Signed-off-by: Li Dongyang +Signed-off-by: Andreas Dilger +Signed-off-by: Saranya Muruganandam +Signed-off-by: Theodore Ts'o +Signed-off-by: Xinliang Liu +--- + e2fsck/dirinfo.c | 238 +++- + e2fsck/dx_dirinfo.c | 64 + + e2fsck/e2fsck.8.in | 8 +- + e2fsck/e2fsck.c | 11 + + e2fsck/e2fsck.h | 103 +- + e2fsck/logfile.c | 13 +- + e2fsck/pass1.c | 1825 +++++++++++++++++++++++--- + e2fsck/problem.c | 10 + + e2fsck/problem.h | 2 + + e2fsck/readahead.c | 4 + + e2fsck/unix.c | 44 +- + e2fsck/util.c | 193 ++- + lib/ext2fs/badblocks.c | 85 +- + lib/ext2fs/bitmaps.c | 10 + + lib/ext2fs/bitops.h | 2 + + lib/ext2fs/blkmap64_rb.c | 65 + + lib/ext2fs/bmap64.h | 4 + + lib/ext2fs/dblist.c | 38 + + lib/ext2fs/ext2_err.et.in | 3 + + lib/ext2fs/ext2_io.h | 2 + + lib/ext2fs/ext2fs.h | 17 +- + lib/ext2fs/ext2fsP.h | 1 - + lib/ext2fs/gen_bitmap64.c | 62 + + lib/ext2fs/icount.c | 107 ++ + lib/ext2fs/openfs.c | 52 +- + lib/ext2fs/undo_io.c | 19 + + lib/ext2fs/unix_io.c | 24 +- + lib/support/mkquota.c | 39 + + lib/support/quotaio.h | 3 + + tests/f_itable_collision/expect.1 | 3 - + tests/f_multithread/expect.1 | 25 + + tests/f_multithread/expect.2 | 7 + + tests/f_multithread/image.gz | 1 + + tests/f_multithread/name | 1 + + tests/f_multithread/script | 4 + + tests/f_multithread_logfile/expect.1 | 25 + + tests/f_multithread_logfile/image.gz | 1 + + tests/f_multithread_logfile/name | 1 + + tests/f_multithread_logfile/script | 32 + + tests/f_multithread_no/expect.1 | 26 + + tests/f_multithread_no/expect.2 | 23 + + tests/f_multithread_no/image.gz | 1 + + tests/f_multithread_no/name | 1 + + tests/f_multithread_no/script | 4 + + tests/f_multithread_ok/expect.1 | 7 + + tests/f_multithread_ok/image.gz | Bin 0 -> 796311 bytes + tests/f_multithread_ok/name | 1 + + tests/f_multithread_ok/script | 21 + + tests/f_multithread_preen/expect.1 | 11 + + tests/f_multithread_preen/expect.2 | 23 + + tests/f_multithread_preen/image.gz | 1 + + tests/f_multithread_preen/name | 1 + + tests/f_multithread_preen/script | 4 + + tests/f_multithread_yes/expect.1 | 2 + + tests/f_multithread_yes/expect.2 | 23 + + tests/f_multithread_yes/image.gz | 1 + + tests/f_multithread_yes/name | 1 + + tests/f_multithread_yes/script | 4 + + tests/test_one.in | 8 + + 59 files changed, 2992 insertions(+), 319 deletions(-) + create mode 100644 tests/f_multithread/expect.1 + create mode 100644 tests/f_multithread/expect.2 + create mode 120000 tests/f_multithread/image.gz + create mode 100644 tests/f_multithread/name + create mode 100644 tests/f_multithread/script + create mode 100644 tests/f_multithread_logfile/expect.1 + create mode 120000 tests/f_multithread_logfile/image.gz + create mode 100644 tests/f_multithread_logfile/name + create mode 100644 tests/f_multithread_logfile/script + create mode 100644 tests/f_multithread_no/expect.1 + create mode 100644 tests/f_multithread_no/expect.2 + create mode 120000 tests/f_multithread_no/image.gz + create mode 100644 tests/f_multithread_no/name + create mode 100644 tests/f_multithread_no/script + create mode 100644 tests/f_multithread_ok/expect.1 + create mode 100644 tests/f_multithread_ok/image.gz + create mode 100644 tests/f_multithread_ok/name + create mode 100644 tests/f_multithread_ok/script + create mode 100644 tests/f_multithread_preen/expect.1 + create mode 100644 tests/f_multithread_preen/expect.2 + create mode 120000 tests/f_multithread_preen/image.gz + create mode 100644 tests/f_multithread_preen/name + create mode 100644 tests/f_multithread_preen/script + create mode 100644 tests/f_multithread_yes/expect.1 + create mode 100644 tests/f_multithread_yes/expect.2 + create mode 120000 tests/f_multithread_yes/image.gz + create mode 100644 tests/f_multithread_yes/name + create mode 100644 tests/f_multithread_yes/script + +diff --git a/e2fsck/dirinfo.c b/e2fsck/dirinfo.c +index 49d624c..b4adaa6 100644 +--- a/e2fsck/dirinfo.c ++++ b/e2fsck/dirinfo.c +@@ -7,6 +7,7 @@ + + #undef DIRINFO_DEBUG + ++#include + #include "config.h" + #include "e2fsck.h" + #include +@@ -122,6 +123,170 @@ static void setup_db(e2fsck_t ctx) + "directory map"); + } + ++/* ++ * Return the min index that has ino larger or equal to @ino ++ * If not found, return -ENOENT ++ */ ++static int ++e2fsck_dir_info_min_larger_equal(struct dir_info_db *dir_info, ++ ext2_ino_t ino, ext2_ino_t *index) ++{ ++ ext2_ino_t low = 0; ++ ext2_ino_t mid, high; ++ ext2_ino_t tmp_ino; ++ int found = 0; ++ ++ if (dir_info->count == 0) ++ return -ENOENT; ++ ++ high = dir_info->count - 1; ++ while (low <= high) { ++ /* sum may overflow, but result will fit into mid again */ ++ mid = (unsigned long long)(low + high) / 2; ++ tmp_ino = dir_info->array[mid].ino; ++ if (ino == tmp_ino) { ++ *index = mid; ++ found = 1; ++ return 0; ++ } else if (ino < tmp_ino) { ++ /* ++ * The mid ino is larger than @ino, remember the index ++ * here so we won't miss this ino ++ */ ++ *index = mid; ++ found = 1; ++ if (mid == 0) ++ break; ++ high = mid - 1; ++ } else { ++ low = mid + 1; ++ } ++ } ++ ++ if (found) ++ return 0; ++ ++ return -ENOENT; ++} ++ ++/* ++ * Merge two sorted dir info to @dest ++ */ ++void e2fsck_merge_dir_info(e2fsck_t ctx, struct dir_info_db *src, ++ struct dir_info_db *dest) ++{ ++ size_t size_dir_info = sizeof(struct dir_info); ++ ext2_ino_t size = dest->size; ++ struct dir_info *src_array = src->array; ++ struct dir_info *dest_array = dest->array; ++ ext2_ino_t src_count = src->count; ++ ext2_ino_t dest_count = dest->count; ++ ext2_ino_t total_count = src_count + dest_count; ++ struct dir_info *tmp_array; ++ struct dir_info *array_ptr; ++ ext2_ino_t src_index = 0; ++ ext2_ino_t dest_index = 0; ++ ++ if (src->count == 0) ++ return; ++ ++ if (size < total_count) ++ size = total_count; ++ ++ if (size < src->size) ++ size = src->size; ++ ++ tmp_array = e2fsck_allocate_memory(ctx, size * size_dir_info, ++ "directory map"); ++ array_ptr = tmp_array; ++ /* ++ * This can be improved by binary search and memcpy, but codes ++ * would be more complex. And if the groups distributed to each ++ * thread are strided, this implementation won't be too bad ++ * comparing to the optimiztion. ++ */ ++ while (src_index < src_count || dest_index < dest_count) { ++ if (src_index >= src_count) { ++ memcpy(array_ptr, &dest_array[dest_index], ++ (dest_count - dest_index) * size_dir_info); ++ break; ++ } ++ if (dest_index >= dest_count) { ++ memcpy(array_ptr, &src_array[src_index], ++ (src_count - src_index) * size_dir_info); ++ break; ++ } ++ if (src_array[src_index].ino < dest_array[dest_index].ino) { ++ *array_ptr = src_array[src_index]; ++ src_index++; ++ } else { ++ assert(src_array[src_index].ino > ++ dest_array[dest_index].ino); ++ *array_ptr = dest_array[dest_index]; ++ dest_index++; ++ } ++ array_ptr++; ++ } ++ ++ if (dest->array) ++ ext2fs_free_mem(&dest->array); ++ dest->array = tmp_array; ++ dest->size = size; ++ dest->count = total_count; ++} ++ ++/* ++ * ++ * Insert an inode into the sorted array. The array should have at least one ++ * free slot. ++ * ++ * Normally, add_dir_info is called with each inode in ++ * sequential order; but once in a while (like when pass 3 ++ * needs to recreate the root directory or lost+found ++ * directory) it is called out of order. In those cases, we ++ * need to move the dir_info entries down to make room, since ++ * the dir_info array needs to be sorted by inode number for ++ * get_dir_info()'s sake. ++ */ ++static void e2fsck_insert_dir_info(struct dir_info_db *dir_info, ext2_ino_t ino, ext2_ino_t parent) ++{ ++ ext2_ino_t index; ++ struct dir_info *dir; ++ size_t dir_size = sizeof(*dir); ++ struct dir_info *array = dir_info->array; ++ ext2_ino_t array_count = dir_info->count; ++ int err; ++ ++ /* ++ * Removing this check won't break anything. But since seqential ino ++ * inserting happens a lot, this check avoids binary search. ++ */ ++ if (array_count == 0 || array[array_count - 1].ino < ino) { ++ dir = &array[array_count]; ++ dir_info->count++; ++ goto out; ++ } ++ ++ err = e2fsck_dir_info_min_larger_equal(dir_info, ino, &index); ++ if (err >= 0 && array[index].ino == ino) { ++ dir = &array[index]; ++ goto out; ++ } ++ if (err < 0) { ++ dir = &array[array_count]; ++ dir_info->count++; ++ goto out; ++ } ++ ++ dir = &array[index]; ++ memmove((char *)dir + dir_size, dir, dir_size * (array_count - index)); ++ dir_info->count++; ++out: ++ dir->ino = ino; ++ dir->dotdot = parent; ++ dir->parent = parent; ++} ++ + /* + * This subroutine is called during pass1 to create a directory info + * entry. During pass1, the passed-in parent is 0; it will get filled +@@ -171,30 +336,7 @@ void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent) + } + #endif + +- /* +- * Normally, add_dir_info is called with each inode in +- * sequential order; but once in a while (like when pass 3 +- * needs to recreate the root directory or lost+found +- * directory) it is called out of order. In those cases, we +- * need to move the dir_info entries down to make room, since +- * the dir_info array needs to be sorted by inode number for +- * get_dir_info()'s sake. +- */ +- if (ctx->dir_info->count && +- ctx->dir_info->array[ctx->dir_info->count-1].ino >= ino) { +- for (i = ctx->dir_info->count-1; i > 0; i--) +- if (ctx->dir_info->array[i-1].ino < ino) +- break; +- dir = &ctx->dir_info->array[i]; +- if (dir->ino != ino) +- for (j = ctx->dir_info->count++; j > i; j--) +- ctx->dir_info->array[j] = ctx->dir_info->array[j-1]; +- } else +- dir = &ctx->dir_info->array[ctx->dir_info->count++]; +- +- dir->ino = ino; +- dir->dotdot = parent; +- dir->parent = parent; ++ e2fsck_insert_dir_info(ctx->dir_info, ino, parent); + } + + /* +@@ -204,7 +346,8 @@ void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent) + static struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino) + { + struct dir_info_db *db = ctx->dir_info; +- ext2_ino_t low, high, mid; ++ ext2_ino_t index; ++ int err; + + if (!db) + return 0; +@@ -245,44 +388,19 @@ static struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino) + if (db->last_lookup && db->last_lookup->ino == ino) + return db->last_lookup; + +- low = 0; +- high = ctx->dir_info->count - 1; +- if (ino == ctx->dir_info->array[low].ino) { ++ err = e2fsck_dir_info_min_larger_equal(ctx->dir_info, ino, &index); ++ if (err < 0) ++ return NULL; ++ assert(ino <= ctx->dir_info->array[index].ino); ++ if (ino == ctx->dir_info->array[index].ino) { + #ifdef DIRINFO_DEBUG +- printf("(%u,%u,%u)\n", ino, +- ctx->dir_info->array[low].dotdot, +- ctx->dir_info->array[low].parent); ++ printf("(%d,%d,%d)\n", ino, ++ ctx->dir_info->array[index].dotdot, ++ ctx->dir_info->array[index].parent); + #endif +- return &ctx->dir_info->array[low]; ++ return &ctx->dir_info->array[index]; + } +- if (ino == ctx->dir_info->array[high].ino) { +-#ifdef DIRINFO_DEBUG +- printf("(%u,%u,%u)\n", ino, +- ctx->dir_info->array[high].dotdot, +- ctx->dir_info->array[high].parent); +-#endif +- return &ctx->dir_info->array[high]; +- } +- +- while (low < high) { +- /* sum may overflow, but result will fit into mid again */ +- mid = (unsigned long long)(low + high) / 2; +- if (mid == low || mid == high) +- break; +- if (ino == ctx->dir_info->array[mid].ino) { +-#ifdef DIRINFO_DEBUG +- printf("(%u,%u,%u)\n", ino, +- ctx->dir_info->array[mid].dotdot, +- ctx->dir_info->array[mid].parent); +-#endif +- return &ctx->dir_info->array[mid]; +- } +- if (ino < ctx->dir_info->array[mid].ino) +- high = mid; +- else +- low = mid; +- } +- return 0; ++ return NULL; + } + + static void e2fsck_put_dir_info(e2fsck_t ctx EXT2FS_NO_TDB_UNUSED, +diff --git a/e2fsck/dx_dirinfo.c b/e2fsck/dx_dirinfo.c +index caca3e3..9195457 100644 +--- a/e2fsck/dx_dirinfo.c ++++ b/e2fsck/dx_dirinfo.c +@@ -5,6 +5,7 @@ + * under the terms of the GNU Public License. + */ + ++#include + #include "config.h" + #include "e2fsck.h" + +@@ -79,6 +80,69 @@ void e2fsck_add_dx_dir(e2fsck_t ctx, ext2_ino_t ino, struct ext2_inode *inode, + "dx_block info array"); + } + ++/* ++ * Merge two sorted dir info to @dest ++ */ ++void e2fsck_merge_dx_dir(e2fsck_t global_ctx, e2fsck_t thread_ctx) ++{ ++ struct dx_dir_info *src_array = thread_ctx->dx_dir_info; ++ struct dx_dir_info *dest_array = global_ctx->dx_dir_info; ++ size_t size_dx_info = sizeof(struct dx_dir_info); ++ ext2_ino_t size = global_ctx->dx_dir_info_size; ++ ext2_ino_t src_count = thread_ctx->dx_dir_info_count; ++ ext2_ino_t dest_count = global_ctx->dx_dir_info_count; ++ ext2_ino_t total_count = src_count + dest_count; ++ struct dx_dir_info *array; ++ struct dx_dir_info *array_ptr; ++ ext2_ino_t src_index = 0, dest_index = 0; ++ ++ if (thread_ctx->dx_dir_info_count == 0) ++ return; ++ ++ if (size < total_count) ++ size = total_count; ++ ++ array = e2fsck_allocate_memory(global_ctx, size * size_dx_info, ++ "directory map"); ++ array_ptr = array; ++ /* ++ * This can be improved by binary search and memcpy, but codes ++ * would be more complex. And if the groups distributed to each ++ * thread are strided, this implementation won't be too bad ++ * comparing to the optimiztion. ++ */ ++ while (src_index < src_count || dest_index < dest_count) { ++ if (src_index >= src_count) { ++ memcpy(array_ptr, &dest_array[dest_index], ++ (dest_count - dest_index) * size_dx_info); ++ break; ++ } ++ if (dest_index >= dest_count) { ++ memcpy(array_ptr, &src_array[src_index], ++ (src_count - src_index) * size_dx_info); ++ break; ++ } ++ if (src_array[src_index].ino < dest_array[dest_index].ino) { ++ *array_ptr = src_array[src_index]; ++ src_index++; ++ } else { ++ assert(src_array[src_index].ino > ++ dest_array[dest_index].ino); ++ *array_ptr = dest_array[dest_index]; ++ dest_index++; ++ } ++ array_ptr++; ++ } ++ ++ if (global_ctx->dx_dir_info) ++ ext2fs_free_mem(&global_ctx->dx_dir_info); ++ if (thread_ctx->dx_dir_info) ++ ext2fs_free_mem(&thread_ctx->dx_dir_info); ++ global_ctx->dx_dir_info = array; ++ global_ctx->dx_dir_info_size = size; ++ global_ctx->dx_dir_info_count = total_count; ++} ++ + /* + * get_dx_dir_info() --- given an inode number, try to find the directory + * information entry for it. +diff --git a/e2fsck/e2fsck.8.in b/e2fsck/e2fsck.8.in +index dc6a585..37dc893 100644 +--- a/e2fsck/e2fsck.8.in ++++ b/e2fsck/e2fsck.8.in +@@ -8,7 +8,7 @@ e2fsck \- check a Linux ext2/ext3/ext4 file system + .SH SYNOPSIS + .B e2fsck + [ +-.B \-pacnyrdfkvtDFV ++.B \-pacnyrdfkmvtDFV + ] + [ + .B \-b +@@ -333,6 +333,12 @@ Set the bad blocks list to be the list of blocks specified by + option, except the bad blocks list is cleared before the blocks listed + in the file are added to the bad blocks list.) + .TP ++.B \-m " threads" ++Run e2fsck with up to the specified number of ++.IR threads . ++The actual number of threads may be lower, if the filesystem does not ++have enough block groups to effectively parallelize the workload. ++.TP + .B \-n + Open the file system read-only, and assume an answer of `no' to all + questions. Allows +diff --git a/e2fsck/e2fsck.c b/e2fsck/e2fsck.c +index 1e295e3..db0a505 100644 +--- a/e2fsck/e2fsck.c ++++ b/e2fsck/e2fsck.c +@@ -79,6 +79,10 @@ errcode_t e2fsck_reset_context(e2fsck_t ctx) + ext2fs_free_block_bitmap(ctx->inode_casefold_map); + ctx->inode_casefold_map = 0; + } ++ if (ctx->inodes_to_rebuild) { ++ ext2fs_free_inode_bitmap(ctx->inodes_to_rebuild); ++ ctx->inodes_to_rebuild = 0; ++ } + if (ctx->inode_link_info) { + ext2fs_free_icount(ctx->inode_link_info); + ctx->inode_link_info = 0; +@@ -102,6 +106,10 @@ errcode_t e2fsck_reset_context(e2fsck_t ctx) + ea_refcount_free(ctx->refcount_extra); + ctx->refcount_extra = 0; + } ++ if (ctx->refcount_orig) { ++ ea_refcount_free(ctx->refcount_orig); ++ ctx->refcount_orig = 0; ++ } + if (ctx->ea_block_quota_blocks) { + ea_refcount_free(ctx->ea_block_quota_blocks); + ctx->ea_block_quota_blocks = 0; +@@ -187,6 +195,9 @@ errcode_t e2fsck_reset_context(e2fsck_t ctx) + ctx->fs_fragmented_dir = 0; + ctx->large_files = 0; + ctx->large_dirs = 0; ++#ifdef HAVE_PTHREAD ++ ctx->fs_need_locking = 0; ++#endif + + for (i=0; i < MAX_EXTENT_DEPTH_COUNT; i++) + ctx->extent_depth_count[i] = 0; +diff --git a/e2fsck/e2fsck.h b/e2fsck/e2fsck.h +index 00b2091..4e86d2e 100644 +--- a/e2fsck/e2fsck.h ++++ b/e2fsck/e2fsck.h +@@ -186,6 +186,7 @@ struct resource_track { + #define E2F_OPT_UNSHARE_BLOCKS 0x40000 + #define E2F_OPT_CLEAR_UNINIT 0x80000 /* Hack to clear the uninit bit */ + #define E2F_OPT_CHECK_ENCODING 0x100000 /* Force verification of encoded filenames */ ++#define E2F_OPT_MULTITHREAD 0x200000 /* Use multiple threads to speedup */ + + /* + * E2fsck flags +@@ -210,6 +211,7 @@ struct resource_track { + #define E2F_FLAG_TIME_INSANE 0x2000 /* Time is insane */ + #define E2F_FLAG_PROBLEMS_FIXED 0x4000 /* At least one problem was fixed */ + #define E2F_FLAG_ALLOC_OK 0x8000 /* Can we allocate blocks? */ ++#define E2F_FLAG_DUP_BLOCK 0x20000 /* dup block found during pass1 */ + + #define E2F_RESET_FLAGS (E2F_FLAG_TIME_INSANE | E2F_FLAG_PROBLEMS_FIXED) + +@@ -260,8 +262,30 @@ struct e2fsck_fc_replay_state { + __u16 fc_super_state; + }; + ++#ifdef HAVE_PTHREAD ++/* ++ * Fields that used for multi-thread ++ */ ++struct e2fsck_thread { ++ /* Thread index */ ++ int et_thread_index; ++ /* The start group number for this thread */ ++ dgrp_t et_group_start; ++ /* The end (not included) group number for this thread*/ ++ dgrp_t et_group_end; ++ /* The next group number to check */ ++ dgrp_t et_group_next; ++ /* Scanned inode number */ ++ ext2_ino_t et_inode_number; ++ char et_log_length; ++ char et_log_buf[2048]; ++}; ++#endif ++ + struct e2fsck_struct { +- ext2_filsys fs; ++ /* Global context to get the cancel flag */ ++ e2fsck_t global_ctx; ++ ext2_filsys fs; /* [fs_fix_rwlock] */ + const char *program_name; + char *filesystem_name; + char *device_name; +@@ -270,7 +294,9 @@ struct e2fsck_struct { + char *log_fn; + FILE *problem_logf; + char *problem_log_fn; +- int flags; /* E2fsck internal flags */ ++ /* E2fsck internal flags. ++ * shared by different threads for pass1 [fs_fix_rwlock] */ ++ int flags; + int options; + unsigned blocksize; /* blocksize */ + blk64_t use_superblock; /* sb requested by user */ +@@ -280,6 +306,7 @@ struct e2fsck_struct { + ext2_ino_t free_inodes; + int mount_flags; + int openfs_flags; ++ io_manager io_manager; + blkid_cache blkid; /* blkid cache */ + + #ifdef HAVE_SETJMP_H +@@ -290,6 +317,7 @@ struct e2fsck_struct { + int (*progress)(e2fsck_t ctx, int pass, unsigned long cur, + unsigned long max); + ++ /* The following inode bitmaps are separately used in thread_ctx Pass1*/ + ext2fs_inode_bitmap inode_used_map; /* Inodes which are in use */ + ext2fs_inode_bitmap inode_bad_map; /* Inodes which are bad somehow */ + ext2fs_inode_bitmap inode_dir_map; /* Inodes which are directories */ +@@ -298,18 +326,21 @@ struct e2fsck_struct { + ext2fs_inode_bitmap inode_reg_map; /* Inodes which are regular files*/ + ext2fs_inode_bitmap inode_casefold_map; /* Inodes which are casefolded */ + ++ /* Following 3 protected by [fs_block_map_rwlock] */ + ext2fs_block_bitmap block_found_map; /* Blocks which are in use */ + ext2fs_block_bitmap block_dup_map; /* Blks referenced more than once */ + ext2fs_block_bitmap block_ea_map; /* Blocks which are used by EA's */ + + /* +- * Inode count arrays ++ * Inode count arrays. ++ * Separately used in thread_ctx, pass1 + */ + ext2_icount_t inode_count; + ext2_icount_t inode_link_info; + + ext2_refcount_t refcount; + ext2_refcount_t refcount_extra; ++ ext2_refcount_t refcount_orig; + + /* + * Quota blocks and inodes to be charged for each ea block. +@@ -324,7 +355,8 @@ struct e2fsck_struct { + + /* + * Array of flags indicating whether an inode bitmap, block +- * bitmap, or inode table is invalid ++ * bitmap, or inode table is invalid. ++ * Separately used in thread_ctx, pass1 + */ + int *invalid_inode_bitmap_flag; + int *invalid_block_bitmap_flag; +@@ -337,10 +369,11 @@ struct e2fsck_struct { + char *block_buf; + + /* +- * For pass1_check_directory and pass1_get_blocks ++ * For pass1_check_directory and pass1_get_blocks. ++ * Separately used in thread_ctx in pass1 + */ +- ext2_ino_t stashed_ino; +- struct ext2_inode *stashed_inode; ++ ext2_ino_t stashed_ino; ++ struct ext2_inode *stashed_inode; + + /* + * Location of the lost and found directory +@@ -396,6 +429,7 @@ struct e2fsck_struct { + + /* + * How we display the progress update (for unix) ++ * shared by different threads for pass1 [fs_fix_rwlock] + */ + int progress_fd; + int progress_pos; +@@ -404,7 +438,7 @@ struct e2fsck_struct { + int interactive; /* Are we connected directly to a tty? */ + char start_meta[2], stop_meta[2]; + +- /* File counts */ ++ /* File counts. Separately used in thread_ctx, pass1 */ + __u32 fs_directory_count; + __u32 fs_regular_count; + __u32 fs_blockdev_count; +@@ -458,8 +492,49 @@ struct e2fsck_struct { + + /* Fast commit replay state */ + struct e2fsck_fc_replay_state fc_replay_state; ++#ifdef HAVE_PTHREAD ++ /* if @global_ctx is null, this field is unused */ ++ struct e2fsck_thread thread_info; ++ __u32 pfs_num_threads; ++ __u32 mmp_update_thread; ++ int fs_need_locking; ++ /* serialize fix operation for multiple threads */ ++ pthread_rwlock_t fs_fix_rwlock; ++ /* protect block_found_map, block_dup_map */ ++ pthread_rwlock_t fs_block_map_rwlock; ++ struct e2fsck_thread_info *infos; ++#endif ++}; ++ ++#ifdef HAVE_PTHREAD ++#ifdef DEBUG_THREADS ++/* ++ * Enabling DEBUG_THREADS would cause the parallel ++ * fsck threads run sequentially. ++ */ ++struct e2fsck_thread_debug { ++ pthread_mutex_t etd_mutex; ++ pthread_cond_t etd_cond; ++ int etd_finished_threads; ++}; ++#endif ++ ++struct e2fsck_thread_info { ++ /* ID returned by pthread_create() */ ++ pthread_t eti_thread_id; ++ /* Application-defined thread index */ ++ int eti_thread_index; ++ /* Thread has been started */ ++ int eti_started; ++ /* Context used for this thread */ ++ e2fsck_t eti_thread_ctx; ++#ifdef DEBUG_THREADS ++ struct e2fsck_thread_debug *eti_debug; ++#endif + }; + ++#endif ++ + /* Data structures to evaluate whether an extent tree needs rebuilding. */ + struct extent_tree_level { + unsigned int num_extents; +@@ -487,6 +562,8 @@ extern int e2fsck_strnlen(const char * s, int count); + + extern void e2fsck_pass1(e2fsck_t ctx); + extern void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf); ++extern void e2fsck_pass1_check_lock(e2fsck_t ctx); ++extern void e2fsck_pass1_check_unlock(e2fsck_t ctx); + extern void e2fsck_pass2(e2fsck_t ctx); + extern void e2fsck_pass3(e2fsck_t ctx); + extern void e2fsck_pass4(e2fsck_t ctx); +@@ -505,6 +582,8 @@ extern void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file, + + /* dirinfo.c */ + extern void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent); ++void e2fsck_merge_dir_info(e2fsck_t ctx, struct dir_info_db *src, ++ struct dir_info_db *dest); + extern void e2fsck_free_dir_info(e2fsck_t ctx); + extern int e2fsck_get_num_dirinfo(e2fsck_t ctx); + extern struct dir_info_iter *e2fsck_dir_info_iter_begin(e2fsck_t ctx); +@@ -519,6 +598,7 @@ extern int e2fsck_dir_info_get_parent(e2fsck_t ctx, ext2_ino_t ino, + ext2_ino_t *parent); + extern int e2fsck_dir_info_get_dotdot(e2fsck_t ctx, ext2_ino_t ino, + ext2_ino_t *dotdot); ++extern void e2fsck_merge_dx_dir(e2fsck_t global_ctx, e2fsck_t thread_ctx); + + /* dx_dirinfo.c */ + extern void e2fsck_add_dx_dir(e2fsck_t ctx, ext2_ino_t ino, +@@ -658,6 +738,7 @@ int check_backup_super_block(e2fsck_t ctx); + void check_resize_inode(e2fsck_t ctx); + + /* util.c */ ++#define E2FSCK_MAX_THREADS (65535) + extern void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned long size, + const char *description); + extern int ask(e2fsck_t ctx, const char * string, int def); +@@ -726,6 +807,12 @@ extern errcode_t e2fsck_allocate_subcluster_bitmap(ext2_filsys fs, + const char *profile_name, + ext2fs_block_bitmap *ret); + unsigned long long get_memory_size(void); ++extern void e2fsck_pass1_fix_lock(e2fsck_t ctx); ++extern void e2fsck_pass1_fix_unlock(e2fsck_t ctx); ++extern void e2fsck_pass1_block_map_w_lock(e2fsck_t ctx); ++extern void e2fsck_pass1_block_map_w_unlock(e2fsck_t ctx); ++extern void e2fsck_pass1_block_map_r_lock(e2fsck_t ctx); ++extern void e2fsck_pass1_block_map_r_unlock(e2fsck_t ctx); + + /* unix.c */ + extern void e2fsck_clear_progbar(e2fsck_t ctx); +diff --git a/e2fsck/logfile.c b/e2fsck/logfile.c +index 63e9a12..60ab95f 100644 +--- a/e2fsck/logfile.c ++++ b/e2fsck/logfile.c +@@ -16,6 +16,7 @@ + #include + #include + #include ++#include + + #include "e2fsck.h" + #include +@@ -291,6 +292,8 @@ static FILE *set_up_log_file(e2fsck_t ctx, const char *key, const char *fn) + struct string s, s1, s2; + char *s0 = 0, *log_dir = 0, *log_fn = 0; + int log_dir_wait = 0; ++ int string_size; ++ char string_index[10]; + + s.s = s1.s = s2.s = 0; + +@@ -307,6 +310,15 @@ static FILE *set_up_log_file(e2fsck_t ctx, const char *key, const char *fn) + goto out; + + expand_logfn(ctx, log_fn, &s); ++#ifdef HAVE_PTHREAD ++ if (ctx->global_ctx) { ++ sprintf(string_index, "%d", ++ ctx->thread_info.et_thread_index); ++ append_string(&s, ".", 1); ++ append_string(&s, string_index, 0); ++ } ++#endif ++ + if ((log_fn[0] == '/') || !log_dir || !log_dir[0]) + s0 = s.s; + +@@ -325,7 +337,6 @@ static FILE *set_up_log_file(e2fsck_t ctx, const char *key, const char *fn) + append_string(&s2, log_dir, 0); + append_string(&s2, "/", 1); + append_string(&s2, s.s, 0); +- printf("%s\n", s2.s); + } + + if (s0) +diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c +index d4606b8..553c299 100644 +--- a/e2fsck/pass1.c ++++ b/e2fsck/pass1.c +@@ -47,9 +47,15 @@ + #ifdef HAVE_ERRNO_H + #include + #endif ++#include ++#ifdef HAVE_PTHREAD ++#include ++#endif + + #include "e2fsck.h" + #include ++/* todo remove this finally */ ++#include + #include + + #include "problem.h" +@@ -82,7 +88,6 @@ static void alloc_imagic_map(e2fsck_t ctx); + static void mark_inode_bad(e2fsck_t ctx, ino_t ino); + static void add_casefolded_dir(e2fsck_t ctx, ino_t ino); + static void handle_fs_bad_blocks(e2fsck_t ctx); +-static void process_inodes(e2fsck_t ctx, char *block_buf); + static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b); + static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan, + dgrp_t group, void * priv_data); +@@ -117,15 +122,15 @@ struct process_inode_block { + }; + + struct scan_callback_struct { +- e2fsck_t ctx; +- char *block_buf; ++ e2fsck_t ctx; ++ char *block_buf; ++ struct process_inode_block *inodes_to_process; ++ int *process_inode_count; + }; + +-/* +- * For the inodes to process list. +- */ +-static struct process_inode_block *inodes_to_process; +-static int process_inode_count; ++static void process_inodes(e2fsck_t ctx, char *block_buf, ++ struct process_inode_block *inodes_to_process, ++ int *process_inode_count); + + static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE - + EXT2_MIN_BLOCK_LOG_SIZE + 1]; +@@ -377,8 +382,10 @@ static problem_t check_large_ea_inode(e2fsck_t ctx, + pctx->num = entry->e_value_inum; + if (fix_problem(ctx, PR_1_ATTR_SET_EA_INODE_FL, pctx)) { + inode.i_flags |= EXT4_EA_INODE_FL; ++ e2fsck_pass1_fix_lock(ctx); + ext2fs_write_inode(ctx->fs, entry->e_value_inum, + &inode); ++ e2fsck_pass1_fix_unlock(ctx); + } else { + return PR_1_ATTR_NO_EA_INODE_FL; + } +@@ -642,6 +649,31 @@ static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx, + + } + ++static _INLINE_ int is_blocks_used(e2fsck_t ctx, blk64_t block, ++ unsigned int num) ++{ ++ int retval; ++ ++ /* used to avoid duplicate output from below */ ++ retval = ext2fs_test_block_bitmap_range2_valid(ctx->block_found_map, ++ block, num); ++ if (!retval) ++ return 0; ++ ++ retval = ext2fs_test_block_bitmap_range2(ctx->block_found_map, block, num); ++ if (retval) { ++ e2fsck_pass1_block_map_r_lock(ctx); ++ if (ctx->global_ctx) ++ retval = ext2fs_test_block_bitmap_range2( ++ ctx->global_ctx->block_found_map, block, num); ++ e2fsck_pass1_block_map_r_unlock(ctx); ++ if (retval) ++ return 0; ++ } ++ ++ return 1; ++} ++ + /* + * Check to see if the inode might really be a directory, despite i_mode + * +@@ -672,14 +704,14 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, + LINUX_S_ISLNK(inode->i_mode) || inode->i_block[0] == 0) + return; + +- /* ++ /* + * Check the block numbers in the i_block array for validity: + * zero blocks are skipped (but the first one cannot be zero - + * see above), other blocks are checked against the first and + * max data blocks (from the the superblock) and against the + * block bitmap. Any invalid block found means this cannot be + * a directory. +- * ++ * + * If there are non-zero blocks past the fourth entry, then + * this cannot be a device file: we remember that for the next + * check. +@@ -747,8 +779,7 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, + + if (blk < ctx->fs->super->s_first_data_block || + blk >= ext2fs_blocks_count(ctx->fs->super) || +- ext2fs_fast_test_block_bitmap2(ctx->block_found_map, +- blk)) ++ is_blocks_used(ctx, blk, 1)) + return; /* Invalid block, can't be dir */ + } + blk = inode->i_block[0]; +@@ -869,8 +900,11 @@ static errcode_t recheck_bad_inode_checksum(ext2_filsys fs, ext2_ino_t ino, + if (!fix_problem(ctx, PR_1_INODE_ONLY_CSUM_INVALID, pctx)) + return 0; + ++ ++ e2fsck_pass1_fix_lock(ctx); + retval = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&inode, + sizeof(inode)); ++ e2fsck_pass1_fix_unlock(ctx); + return retval; + } + +@@ -908,6 +942,7 @@ static void reserve_block_for_lnf_repair(e2fsck_t ctx) + return; + ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); + ctx->lnf_repair_block = blk; ++ return; + } + + static errcode_t get_inline_data_ea_size(ext2_filsys fs, ext2_ino_t ino, +@@ -953,8 +988,10 @@ static void finish_processing_inode(e2fsck_t ctx, ext2_ino_t ino, + #define FINISH_INODE_LOOP(ctx, ino, pctx, failed_csum) \ + do { \ + finish_processing_inode((ctx), (ino), (pctx), (failed_csum)); \ +- if ((ctx)->flags & E2F_FLAG_ABORT) \ ++ if ((ctx)->flags & E2F_FLAG_ABORT) { \ ++ e2fsck_pass1_check_unlock(ctx); \ + return; \ ++ } \ + } while (0) + + static int could_be_block_map(ext2_filsys fs, struct ext2_inode *inode) +@@ -1060,16 +1097,20 @@ out: + static void pass1_readahead(e2fsck_t ctx, dgrp_t *group, ext2_ino_t *next_ino) + { + ext2_ino_t inodes_in_group = 0, inodes_per_block, inodes_per_buffer; +- dgrp_t start = *group, grp; ++ dgrp_t start = *group, grp, grp_end = ctx->fs->group_desc_count; + blk64_t blocks_to_read = 0; + errcode_t err = EXT2_ET_INVALID_ARGUMENT; + ++#ifdef HAVE_PTHREAD ++ if (ctx->fs->fs_num_threads > 1) ++ grp_end = ctx->thread_info.et_group_end; ++#endif + if (ctx->readahead_kb == 0) + goto out; + + /* Keep iterating groups until we have enough to readahead */ + inodes_per_block = EXT2_INODES_PER_BLOCK(ctx->fs->super); +- for (grp = start; grp < ctx->fs->group_desc_count; grp++) { ++ for (grp = start; grp < grp_end; grp++) { + if (ext2fs_bg_flags_test(ctx->fs, grp, EXT2_BG_INODE_UNINIT)) + continue; + inodes_in_group = ctx->fs->super->s_inodes_per_group - +@@ -1146,10 +1187,298 @@ static int quota_inum_is_reserved(ext2_filsys fs, ext2_ino_t ino) + return 0; + } + +-void e2fsck_pass1(e2fsck_t ctx) ++static int e2fsck_should_abort(e2fsck_t ctx) ++{ ++ e2fsck_t global_ctx; ++ ++ if (ctx->flags & E2F_FLAG_SIGNAL_MASK) ++ return 1; ++ ++ if (ctx->global_ctx) { ++ global_ctx = ctx->global_ctx; ++ if (global_ctx->flags & E2F_FLAG_SIGNAL_MASK) ++ return 1; ++ } ++ return 0; ++} ++ ++static void init_ext2_max_sizes() + { + int i; + __u64 max_sizes; ++ ++ /* ++ * Init ext2_max_sizes which will be immutable and shared between ++ * threads ++ */ ++#define EXT2_BPP(bits) (1ULL << ((bits) - 2)) ++ ++ for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) { ++ max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i); ++ max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i); ++ max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i); ++ max_sizes = (max_sizes * (1UL << i)); ++ ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes; ++ } ++#undef EXT2_BPP ++} ++ ++#ifdef HAVE_PTHREAD ++/* TODO: tdb needs to be handled properly for multiple threads*/ ++static int multiple_threads_supported(e2fsck_t ctx) ++{ ++#ifdef CONFIG_TDB ++ unsigned int threshold; ++ ext2_ino_t num_dirs; ++ errcode_t retval; ++ char *tdb_dir; ++ int enable; ++ ++ profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0, ++ &tdb_dir); ++ profile_get_uint(ctx->profile, "scratch_files", ++ "numdirs_threshold", 0, 0, &threshold); ++ profile_get_boolean(ctx->profile, "scratch_files", ++ "icount", 0, 1, &enable); ++ ++ retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs); ++ if (retval) ++ num_dirs = 1024; /* Guess */ ++ ++ /* tdb is unsupported now */ ++ if (enable && tdb_dir && !access(tdb_dir, W_OK) && ++ (!threshold || num_dirs > threshold)) ++ return 0; ++#endif ++ return 1; ++} ++ ++/** ++ * Even though we could specify number of threads, ++ * but it might be more than the whole filesystem ++ * block groups, correct it here. ++ */ ++static void e2fsck_pass1_set_thread_num(e2fsck_t ctx) ++{ ++ unsigned flexbg_size = 1; ++ ext2_filsys fs = ctx->fs; ++ int num_threads = ctx->pfs_num_threads; ++ int max_threads; ++ ++ if (num_threads < 1) { ++ num_threads = 1; ++ goto out; ++ } ++ ++ if (!multiple_threads_supported(ctx)) { ++ num_threads = 1; ++ fprintf(stderr, "Fall through single thread for pass1 " ++ "because tdb could not handle properly\n"); ++ goto out; ++ } ++ ++ if (ext2fs_has_feature_flex_bg(fs->super)) ++ flexbg_size = 1 << fs->super->s_log_groups_per_flex; ++ max_threads = fs->group_desc_count / flexbg_size; ++ if (max_threads == 0) ++ max_threads = 1; ++ if (max_threads > E2FSCK_MAX_THREADS) ++ max_threads = E2FSCK_MAX_THREADS; ++ ++ if (num_threads > max_threads) { ++ fprintf(stderr, "Use max possible thread num: %d instead\n", ++ max_threads); ++ num_threads = max_threads; ++ } ++out: ++ ctx->pfs_num_threads = num_threads; ++ ctx->fs->fs_num_threads = num_threads; ++} ++#endif ++ ++/* ++ * We need call mark_table_blocks() before multiple ++ * thread start, since all known system blocks should be ++ * marked and checked later. ++ */ ++static errcode_t e2fsck_pass1_prepare(e2fsck_t ctx) ++{ ++ struct problem_context pctx; ++ ext2_filsys fs = ctx->fs; ++ unsigned long long readahead_kb; ++ ++ init_ext2_max_sizes(); ++#ifdef HAVE_PTHREAD ++ e2fsck_pass1_set_thread_num(ctx); ++#endif ++ /* If we can do readahead, figure out how many groups to pull in. */ ++ if (!e2fsck_can_readahead(ctx->fs)) ++ ctx->readahead_kb = 0; ++ else if (ctx->readahead_kb == ~0ULL) ++ ctx->readahead_kb = e2fsck_guess_readahead(ctx->fs); ++ ++#ifdef HAVE_PTHREAD ++ /* don't use more than 1/10 of memory for threads checking */ ++ readahead_kb = get_memory_size() / (10 * ctx->pfs_num_threads); ++ /* maybe better disable RA if this is too small? */ ++ if (ctx->readahead_kb > readahead_kb) ++ ctx->readahead_kb = readahead_kb; ++#endif ++ clear_problem_context(&pctx); ++ if (!(ctx->options & E2F_OPT_PREEN)) ++ fix_problem(ctx, PR_1_PASS_HEADER, &pctx); ++ ++ pctx.errcode = e2fsck_allocate_subcluster_bitmap(ctx->fs, ++ _("in-use block map"), EXT2FS_BMAP64_RBTREE, ++ "block_found_map", &ctx->block_found_map); ++ if (pctx.errcode) { ++ pctx.num = 1; ++ fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); ++ ctx->flags |= E2F_FLAG_ABORT; ++ return pctx.errcode; ++ } ++ pctx.errcode = e2fsck_allocate_block_bitmap(ctx->fs, ++ _("metadata block map"), EXT2FS_BMAP64_RBTREE, ++ "block_metadata_map", &ctx->block_metadata_map); ++ if (pctx.errcode) { ++ pctx.num = 1; ++ fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); ++ ctx->flags |= E2F_FLAG_ABORT; ++ return pctx.errcode; ++ } ++ ++ mark_table_blocks(ctx); ++ pctx.errcode = ext2fs_convert_subcluster_bitmap(ctx->fs, ++ &ctx->block_found_map); ++ if (pctx.errcode) { ++ fix_problem(ctx, PR_1_CONVERT_SUBCLUSTER, &pctx); ++ ctx->flags |= E2F_FLAG_ABORT; ++ return pctx.errcode; ++ } ++ ++ pctx.errcode = e2fsck_allocate_block_bitmap(ctx->fs, ++ _("multiply claimed block map"), ++ EXT2FS_BMAP64_RBTREE, "block_dup_map", ++ &ctx->block_dup_map); ++ if (pctx.errcode) { ++ pctx.num = 3; ++ fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, ++ &pctx); ++ /* Should never get here */ ++ ctx->flags |= E2F_FLAG_ABORT; ++ return pctx.errcode; ++ } ++ ++ if (ext2fs_has_feature_mmp(fs->super) && ++ fs->super->s_mmp_block > fs->super->s_first_data_block && ++ fs->super->s_mmp_block < ext2fs_blocks_count(fs->super)) ++ ext2fs_mark_block_bitmap2(ctx->block_found_map, ++ fs->super->s_mmp_block); ++#ifdef HAVE_PTHREAD ++ pthread_rwlock_init(&ctx->fs_fix_rwlock, NULL); ++ pthread_rwlock_init(&ctx->fs_block_map_rwlock, NULL); ++ if (ctx->pfs_num_threads > 1) ++ ctx->fs_need_locking = 1; ++#endif ++ ++ return 0; ++} ++ ++static void e2fsck_pass1_post(e2fsck_t ctx) ++{ ++ struct problem_context pctx; ++ ext2_filsys fs = ctx->fs; ++ char *block_buf; ++ ++ if (e2fsck_should_abort(ctx)) ++ return; ++ ++ block_buf = (char *)e2fsck_allocate_memory(ctx, ctx->fs->blocksize * 3, ++ "block interate buffer"); ++ reserve_block_for_root_repair(ctx); ++ reserve_block_for_lnf_repair(ctx); ++ ++ /* ++ * If any extended attribute blocks' reference counts need to ++ * be adjusted, either up (ctx->refcount_extra), or down ++ * (ctx->refcount), then fix them. ++ */ ++ if (ctx->refcount) { ++ adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1); ++ ea_refcount_free(ctx->refcount); ++ ctx->refcount = 0; ++ } ++ if (ctx->refcount_extra) { ++ adjust_extattr_refcount(ctx, ctx->refcount_extra, ++ block_buf, +1); ++ ea_refcount_free(ctx->refcount_extra); ++ ctx->refcount_extra = 0; ++ } ++ ++ if (ctx->invalid_bitmaps) ++ handle_fs_bad_blocks(ctx); ++ ++ /* We don't need the block_ea_map any more */ ++ if (ctx->block_ea_map) { ++ ext2fs_free_block_bitmap(ctx->block_ea_map); ++ ctx->block_ea_map = 0; ++ } ++ ++ if (ctx->flags & E2F_FLAG_RESIZE_INODE) { ++ struct ext2_inode *inode; ++ int inode_size = EXT2_INODE_SIZE(fs->super); ++ inode = e2fsck_allocate_memory(ctx, inode_size, ++ "scratch inode"); ++ ++ clear_problem_context(&pctx); ++ pctx.errcode = ext2fs_create_resize_inode(fs); ++ if (pctx.errcode) { ++ if (!fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, ++ &pctx)) { ++ ctx->flags |= E2F_FLAG_ABORT; ++ ext2fs_free_mem(&inode); ++ ext2fs_free_mem(&block_buf); ++ return; ++ } ++ pctx.errcode = 0; ++ } ++ if (!pctx.errcode) { ++ e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode, ++ "recreate inode"); ++ inode->i_mtime = ctx->now; ++ e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode, ++ "recreate inode"); ++ } ++ ctx->flags &= ~E2F_FLAG_RESIZE_INODE; ++ ext2fs_free_mem(&inode); ++ } ++ ++ if (ctx->flags & E2F_FLAG_RESTART) { ++ ext2fs_free_mem(&block_buf); ++ return; ++ } ++ ++ if (ctx->block_dup_map) { ++ if (!(ctx->flags & E2F_FLAG_DUP_BLOCK)) { ++ ext2fs_free_mem(&block_buf); ++ return; ++ } ++ if (ctx->options & E2F_OPT_PREEN) { ++ clear_problem_context(&pctx); ++ fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx); ++ } ++ e2fsck_pass1_dupblocks(ctx, block_buf); ++ ext2fs_free_mem(&block_buf); ++ ctx->flags &= ~E2F_FLAG_DUP_BLOCK; ++ } ++ ++ ctx->flags |= E2F_FLAG_ALLOC_OK; ++} ++ ++ ++void e2fsck_pass1_run(e2fsck_t ctx) ++{ ++ int i; + ext2_filsys fs = ctx->fs; + ext2_ino_t ino = 0; + struct ext2_inode *inode = NULL; +@@ -1172,20 +1501,14 @@ void e2fsck_pass1(e2fsck_t ctx) + ext2_ino_t ino_threshold = 0; + dgrp_t ra_group = 0; + struct ea_quota ea_ibody_quota; ++ struct process_inode_block *inodes_to_process; ++ int process_inode_count, check_mmp; ++ e2fsck_t global_ctx = ctx->global_ctx ? ctx->global_ctx : ctx; + + init_resource_track(&rtrack, ctx->fs->io); + clear_problem_context(&pctx); + +- /* If we can do readahead, figure out how many groups to pull in. */ +- if (!e2fsck_can_readahead(ctx->fs)) +- ctx->readahead_kb = 0; +- else if (ctx->readahead_kb == ~0ULL) +- ctx->readahead_kb = e2fsck_guess_readahead(ctx->fs); + pass1_readahead(ctx, &ra_group, &ino_threshold); +- +- if (!(ctx->options & E2F_OPT_PREEN)) +- fix_problem(ctx, PR_1_PASS_HEADER, &pctx); +- + if (ext2fs_has_feature_dir_index(fs->super) && + !(ctx->options & E2F_OPT_NO)) { + if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50)) +@@ -1196,17 +1519,6 @@ void e2fsck_pass1(e2fsck_t ctx) + mtrace_print("Pass 1"); + #endif + +-#define EXT2_BPP(bits) (1ULL << ((bits) - 2)) +- +- for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) { +- max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i); +- max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i); +- max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i); +- max_sizes = (max_sizes * (1UL << i)); +- ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes; +- } +-#undef EXT2_BPP +- + imagic_fs = ext2fs_has_feature_imagic_inodes(sb); + extent_fs = ext2fs_has_feature_extents(sb); + inlinedata_fs = ext2fs_has_feature_inline_data(sb); +@@ -1227,6 +1539,7 @@ void e2fsck_pass1(e2fsck_t ctx) + } + pctx.errcode = e2fsck_allocate_inode_bitmap(fs, + _("directory inode map"), ++ ctx->global_ctx ? EXT2FS_BMAP64_RBTREE : + EXT2FS_BMAP64_AUTODIR, + "inode_dir_map", &ctx->inode_dir_map); + if (pctx.errcode) { +@@ -1244,24 +1557,6 @@ void e2fsck_pass1(e2fsck_t ctx) + ctx->flags |= E2F_FLAG_ABORT; + return; + } +- pctx.errcode = e2fsck_allocate_subcluster_bitmap(fs, +- _("in-use block map"), EXT2FS_BMAP64_RBTREE, +- "block_found_map", &ctx->block_found_map); +- if (pctx.errcode) { +- pctx.num = 1; +- fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); +- ctx->flags |= E2F_FLAG_ABORT; +- return; +- } +- pctx.errcode = e2fsck_allocate_block_bitmap(fs, +- _("metadata block map"), EXT2FS_BMAP64_RBTREE, +- "block_metadata_map", &ctx->block_metadata_map); +- if (pctx.errcode) { +- pctx.num = 1; +- fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); +- ctx->flags |= E2F_FLAG_ABORT; +- return; +- } + if (casefold_fs) { + pctx.errcode = + e2fsck_allocate_inode_bitmap(fs, +@@ -1317,14 +1612,6 @@ void e2fsck_pass1(e2fsck_t ctx) + } + } + +- mark_table_blocks(ctx); +- pctx.errcode = ext2fs_convert_subcluster_bitmap(fs, +- &ctx->block_found_map); +- if (pctx.errcode) { +- fix_problem(ctx, PR_1_CONVERT_SUBCLUSTER, &pctx); +- ctx->flags |= E2F_FLAG_ABORT; +- goto endit; +- } + block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3, + "block interate buffer"); + if (EXT2_INODE_SIZE(fs->super) == EXT2_GOOD_OLD_INODE_SIZE) +@@ -1344,6 +1631,8 @@ void e2fsck_pass1(e2fsck_t ctx) + ctx->stashed_inode = inode; + scan_struct.ctx = ctx; + scan_struct.block_buf = block_buf; ++ scan_struct.inodes_to_process = inodes_to_process; ++ scan_struct.process_inode_count = &process_inode_count; + ext2fs_set_inode_callback(scan, scan_callback, &scan_struct); + if (ctx->progress && ((ctx->progress)(ctx, 1, 0, + ctx->fs->group_desc_count))) +@@ -1356,17 +1645,51 @@ void e2fsck_pass1(e2fsck_t ctx) + fs->super->s_mkfs_time < fs->super->s_inodes_count)) + low_dtime_check = 0; + +- if (ext2fs_has_feature_mmp(fs->super) && +- fs->super->s_mmp_block > fs->super->s_first_data_block && +- fs->super->s_mmp_block < ext2fs_blocks_count(fs->super)) +- ext2fs_mark_block_bitmap2(ctx->block_found_map, +- fs->super->s_mmp_block); +- + /* Set up ctx->lost_and_found if possible */ + (void) e2fsck_get_lost_and_found(ctx, 0); + ++#ifdef HAVE_PTHREAD ++ if (ctx->global_ctx) { ++ if (ctx->options & E2F_OPT_DEBUG && ++ ctx->options & E2F_OPT_MULTITHREAD) ++ fprintf(stderr, "thread %d jumping to group %u\n", ++ ctx->thread_info.et_thread_index, ++ ctx->thread_info.et_group_start); ++ pctx.errcode = ext2fs_inode_scan_goto_blockgroup(scan, ++ ctx->thread_info.et_group_start); ++ if (pctx.errcode) { ++ fix_problem(ctx, PR_1_PASS_HEADER, &pctx); ++ ctx->flags |= E2F_FLAG_ABORT; ++ goto endit; ++ } ++ } ++#endif ++ + while (1) { +- if (ino % (fs->super->s_inodes_per_group * 4) == 1) { ++ check_mmp = 0; ++ e2fsck_pass1_check_lock(ctx); ++#ifdef HAVE_PTHREAD ++ if (!global_ctx->mmp_update_thread) { ++ e2fsck_pass1_block_map_w_lock(ctx); ++ if (!global_ctx->mmp_update_thread) { ++ global_ctx->mmp_update_thread = ++ ctx->thread_info.et_thread_index + 1; ++ check_mmp = 1; ++ } ++ e2fsck_pass1_block_map_w_unlock(ctx); ++ } ++ ++ /* only one active thread could update mmp block. */ ++ e2fsck_pass1_block_map_r_lock(ctx); ++ if (global_ctx->mmp_update_thread == ++ ctx->thread_info.et_thread_index + 1) ++ check_mmp = 1; ++ e2fsck_pass1_block_map_r_unlock(ctx); ++#else ++ check_mmp = 1; ++#endif ++ ++ if (check_mmp && (ino % (fs->super->s_inodes_per_group * 4) == 1)) { + if (e2fsck_mmp_update(fs)) + fatal_error(ctx, 0); + } +@@ -1376,8 +1699,10 @@ void e2fsck_pass1(e2fsck_t ctx) + if (ino > ino_threshold) + pass1_readahead(ctx, &ra_group, &ino_threshold); + ehandler_operation(old_op); +- if (ctx->flags & E2F_FLAG_SIGNAL_MASK) ++ if (e2fsck_should_abort(ctx)) { ++ e2fsck_pass1_check_unlock(ctx); + goto endit; ++ } + if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) { + /* + * If badblocks says badblocks is bad, offer to clear +@@ -1398,25 +1723,49 @@ void e2fsck_pass1(e2fsck_t ctx) + fix_problem(ctx, PR_1_ISCAN_ERROR, + &pctx); + ctx->flags |= E2F_FLAG_ABORT; ++ e2fsck_pass1_check_unlock(ctx); ++ goto endit; + } else + ctx->flags |= E2F_FLAG_RESTART; +- goto endit; ++ err = ext2fs_inode_scan_goto_blockgroup(scan, ++ 0); ++ if (err) { ++ fix_problem(ctx, PR_1_ISCAN_ERROR, ++ &pctx); ++ ctx->flags |= E2F_FLAG_ABORT; ++ e2fsck_pass1_check_unlock(ctx); ++ goto endit; ++ } ++ e2fsck_pass1_check_unlock(ctx); ++ continue; + } + if (!ctx->inode_bb_map) + alloc_bb_map(ctx); + ext2fs_mark_inode_bitmap2(ctx->inode_bb_map, ino); + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); ++ e2fsck_pass1_check_unlock(ctx); + continue; + } ++ if (pctx.errcode == EXT2_ET_SCAN_FINISHED) { ++ e2fsck_pass1_check_unlock(ctx); ++ break; ++ } + if (pctx.errcode && + pctx.errcode != EXT2_ET_INODE_CSUM_INVALID && + pctx.errcode != EXT2_ET_INODE_IS_GARBAGE) { + fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; ++ e2fsck_pass1_check_unlock(ctx); + goto endit; + } +- if (!ino) ++ if (!ino) { ++ e2fsck_pass1_check_unlock(ctx); + break; ++ } ++#ifdef HAVE_PTHREAD ++ if (ctx->global_ctx) ++ ctx->thread_info.et_inode_number++; ++#endif + pctx.ino = ino; + pctx.inode = inode; + ctx->stashed_ino = ino; +@@ -1465,6 +1814,7 @@ void e2fsck_pass1(e2fsck_t ctx) + pctx.num = inode->i_links_count; + fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx); + ctx->flags |= E2F_FLAG_ABORT; ++ e2fsck_pass1_check_unlock(ctx); + goto endit; + } + } else if ((ino >= EXT2_FIRST_INODE(fs->super)) && +@@ -1479,6 +1829,7 @@ void e2fsck_pass1(e2fsck_t ctx) + } + } + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); ++ e2fsck_pass1_check_unlock(ctx); + continue; + } + +@@ -1499,6 +1850,7 @@ void e2fsck_pass1(e2fsck_t ctx) + &pctx); + if (res < 0) { + /* skip FINISH_INODE_LOOP */ ++ e2fsck_pass1_check_unlock(ctx); + continue; + } + } +@@ -1511,12 +1863,15 @@ void e2fsck_pass1(e2fsck_t ctx) + pctx.errcode = get_inline_data_ea_size(fs, ino, &size); + if (!pctx.errcode && + fix_problem(ctx, PR_1_INLINE_DATA_FEATURE, &pctx)) { ++ e2fsck_pass1_fix_lock(ctx); + ext2fs_set_feature_inline_data(sb); + ext2fs_mark_super_dirty(fs); ++ e2fsck_pass1_fix_unlock(ctx); + inlinedata_fs = 1; + } else if (fix_problem(ctx, PR_1_INLINE_DATA_SET, &pctx)) { + e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); + /* skip FINISH_INODE_LOOP */ ++ e2fsck_pass1_check_unlock(ctx); + continue; + } + } +@@ -1561,6 +1916,7 @@ void e2fsck_pass1(e2fsck_t ctx) + if (err) { + pctx.errcode = err; + ctx->flags |= E2F_FLAG_ABORT; ++ e2fsck_pass1_check_unlock(ctx); + goto endit; + } + inode->i_flags &= ~EXT4_INLINE_DATA_FL; +@@ -1575,6 +1931,7 @@ void e2fsck_pass1(e2fsck_t ctx) + /* Some other kind of non-xattr error? */ + pctx.errcode = err; + ctx->flags |= E2F_FLAG_ABORT; ++ e2fsck_pass1_check_unlock(ctx); + goto endit; + } + } +@@ -1600,9 +1957,11 @@ void e2fsck_pass1(e2fsck_t ctx) + if ((ext2fs_extent_header_verify(inode->i_block, + sizeof(inode->i_block)) == 0) && + fix_problem(ctx, PR_1_EXTENT_FEATURE, &pctx)) { ++ e2fsck_pass1_fix_lock(ctx); + ext2fs_set_feature_extents(sb); + ext2fs_mark_super_dirty(fs); + extent_fs = 1; ++ e2fsck_pass1_fix_unlock(ctx); + } else if (fix_problem(ctx, PR_1_EXTENTS_SET, &pctx)) { + clear_inode: + e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); +@@ -1610,6 +1969,7 @@ void e2fsck_pass1(e2fsck_t ctx) + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, + ino); + /* skip FINISH_INODE_LOOP */ ++ e2fsck_pass1_check_unlock(ctx); + continue; + } + } +@@ -1664,12 +2024,16 @@ void e2fsck_pass1(e2fsck_t ctx) + failed_csum = 0; + } + +- pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map, +- &pb.fs_meta_blocks); ++ e2fsck_pass1_block_map_r_lock(ctx); ++ pctx.errcode = ext2fs_copy_bitmap(ctx->global_ctx ? ++ ctx->global_ctx->block_found_map : ++ ctx->block_found_map, &pb.fs_meta_blocks); ++ e2fsck_pass1_block_map_r_unlock(ctx); + if (pctx.errcode) { + pctx.num = 4; + fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; ++ e2fsck_pass1_check_unlock(ctx); + goto endit; + } + pb.ino = EXT2_BAD_INO; +@@ -1687,16 +2051,19 @@ void e2fsck_pass1(e2fsck_t ctx) + if (pctx.errcode) { + fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx); + ctx->flags |= E2F_FLAG_ABORT; ++ e2fsck_pass1_check_unlock(ctx); + goto endit; + } + if (pb.bbcheck) + if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) { + ctx->flags |= E2F_FLAG_ABORT; ++ e2fsck_pass1_check_unlock(ctx); + goto endit; + } + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); + clear_problem_context(&pctx); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); ++ e2fsck_pass1_check_unlock(ctx); + continue; + } else if (ino == EXT2_ROOT_INO) { + /* +@@ -1738,6 +2105,7 @@ void e2fsck_pass1(e2fsck_t ctx) + } + check_blocks(ctx, &pctx, block_buf, NULL); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); ++ e2fsck_pass1_check_unlock(ctx); + continue; + } + if ((inode->i_links_count || +@@ -1765,6 +2133,7 @@ void e2fsck_pass1(e2fsck_t ctx) + } + check_blocks(ctx, &pctx, block_buf, NULL); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); ++ e2fsck_pass1_check_unlock(ctx); + continue; + } + if ((inode->i_links_count || +@@ -1803,11 +2172,13 @@ void e2fsck_pass1(e2fsck_t ctx) + } + check_blocks(ctx, &pctx, block_buf, NULL); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); ++ e2fsck_pass1_check_unlock(ctx); + continue; + } + + if (!inode->i_links_count) { + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); ++ e2fsck_pass1_check_unlock(ctx); + continue; + } + /* +@@ -1917,12 +2288,14 @@ void e2fsck_pass1(e2fsck_t ctx) + ctx->fs_symlinks_count++; + if (inode->i_flags & EXT4_INLINE_DATA_FL) { + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); ++ e2fsck_pass1_check_unlock(ctx); + continue; + } else if (ext2fs_is_fast_symlink(inode)) { + ctx->fs_fast_symlinks_count++; + check_blocks(ctx, &pctx, block_buf, + &ea_ibody_quota); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); ++ e2fsck_pass1_check_unlock(ctx); + continue; + } + } +@@ -1970,138 +2343,1092 @@ void e2fsck_pass1(e2fsck_t ctx) + + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + +- if (ctx->flags & E2F_FLAG_SIGNAL_MASK) +- goto endit; ++ if (e2fsck_should_abort(ctx)) { ++ e2fsck_pass1_check_unlock(ctx); ++ goto endit; ++ } ++ ++ if (process_inode_count >= ctx->process_inode_size) { ++ process_inodes(ctx, block_buf, inodes_to_process, ++ &process_inode_count); ++ ++ if (e2fsck_should_abort(ctx)) { ++ e2fsck_pass1_check_unlock(ctx); ++ goto endit; ++ } ++ } ++ e2fsck_pass1_check_unlock(ctx); ++ } ++ process_inodes(ctx, block_buf, inodes_to_process, ++ &process_inode_count); ++ ext2fs_close_inode_scan(scan); ++ scan = NULL; ++ ++ if (ctx->ea_block_quota_blocks) { ++ ea_refcount_free(ctx->ea_block_quota_blocks); ++ ctx->ea_block_quota_blocks = 0; ++ } ++ ++ if (ctx->ea_block_quota_inodes) { ++ ea_refcount_free(ctx->ea_block_quota_inodes); ++ ctx->ea_block_quota_inodes = 0; ++ } ++ ++ /* We don't need the encryption policy => ID map any more */ ++ destroy_encryption_policy_map(ctx); ++ ++ if (ctx->flags & E2F_FLAG_RESTART) { ++ /* ++ * Only the master copy of the superblock and block ++ * group descriptors are going to be written during a ++ * restart, so set the superblock to be used to be the ++ * master superblock. ++ */ ++ ctx->use_superblock = 0; ++ goto endit; ++ } ++ ++ if (ctx->large_dirs && !ext2fs_has_feature_largedir(fs->super)) { ++ if (fix_problem(ctx, PR_2_FEATURE_LARGE_DIRS, &pctx)) { ++ ext2fs_set_feature_largedir(fs->super); ++ fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; ++ ext2fs_mark_super_dirty(fs); ++ } ++ if (fs->super->s_rev_level == EXT2_GOOD_OLD_REV && ++ fix_problem(ctx, PR_1_FS_REV_LEVEL, &pctx)) { ++ ext2fs_update_dynamic_rev(fs); ++ ext2fs_mark_super_dirty(fs); ++ } ++ } ++ ++ ctx->flags |= E2F_FLAG_ALLOC_OK; ++ ext2fs_free_mem(&inodes_to_process); ++endit: ++ e2fsck_use_inode_shortcuts(ctx, 0); ++ ext2fs_free_mem(&inodes_to_process); ++ inodes_to_process = 0; ++ ++ if (scan) ++ ext2fs_close_inode_scan(scan); ++ if (block_buf) ++ ext2fs_free_mem(&block_buf); ++ if (inode) ++ ext2fs_free_mem(&inode); ++ ++ /* ++ * The l+f inode may have been cleared, so zap it now and ++ * later passes will recalculate it if necessary ++ */ ++ ctx->lost_and_found = 0; ++ ++ if ((ctx->flags & E2F_FLAG_SIGNAL_MASK) == 0) ++ print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io); ++ else ++ ctx->invalid_bitmaps++; ++#ifdef HAVE_PTHREAD ++ /* reset update_thread after this thread exit */ ++ e2fsck_pass1_block_map_w_lock(ctx); ++ if (check_mmp) ++ global_ctx->mmp_update_thread = 0; ++ e2fsck_pass1_block_map_w_unlock(ctx); ++#endif ++} ++ ++#ifdef HAVE_PTHREAD ++static errcode_t e2fsck_pass1_copy_bitmap(ext2_filsys fs, ext2fs_generic_bitmap *src, ++ ext2fs_generic_bitmap *dest) ++{ ++ errcode_t ret; ++ ++ ret = ext2fs_copy_bitmap(*src, dest); ++ if (ret) ++ return ret; ++ ++ (*dest)->fs = fs; ++ ++ return 0; ++} ++ ++static void e2fsck_pass1_free_bitmap(ext2fs_generic_bitmap *bitmap) ++{ ++ if (*bitmap) { ++ ext2fs_free_generic_bmap(*bitmap); ++ *bitmap = NULL; ++ } ++ ++} ++ ++static errcode_t e2fsck_pass1_merge_bitmap(ext2_filsys fs, ext2fs_generic_bitmap *src, ++ ext2fs_generic_bitmap *dest) ++{ ++ errcode_t ret = 0; ++ ++ if (*src) { ++ if (*dest == NULL) { ++ *dest = *src; ++ *src = NULL; ++ } else { ++ ret = ext2fs_merge_bitmap(*src, *dest, NULL, NULL); ++ if (ret) ++ return ret; ++ } ++ (*dest)->fs = fs; ++ } ++ ++ return 0; ++} ++ ++static errcode_t e2fsck_pass1_copy_fs(ext2_filsys dest, e2fsck_t src_context, ++ ext2_filsys src) ++{ ++ errcode_t retval; ++ ++ memcpy(dest, src, sizeof(struct struct_ext2_filsys)); ++ dest->inode_map = NULL; ++ dest->block_map = NULL; ++ dest->badblocks = NULL; ++ if (dest->dblist) ++ dest->dblist->fs = dest; ++ if (src->block_map) { ++ retval = e2fsck_pass1_copy_bitmap(dest, &src->block_map, ++ &dest->block_map); ++ if (retval) ++ return retval; ++ } ++ if (src->inode_map) { ++ retval = e2fsck_pass1_copy_bitmap(dest, &src->inode_map, ++ &dest->inode_map); ++ if (retval) ++ return retval; ++ } ++ ++ if (src->badblocks) { ++ retval = ext2fs_badblocks_copy(src->badblocks, ++ &dest->badblocks); ++ if (retval) ++ return retval; ++ } ++ ++ /* disable it for now */ ++ src_context->openfs_flags &= ~EXT2_FLAG_EXCLUSIVE; ++ retval = ext2fs_open_channel(dest, src_context->io_options, ++ src_context->io_manager, ++ src_context->openfs_flags, ++ src->io->block_size); ++ if (retval) ++ return retval; ++ ++ /* Block size might not be default */ ++ io_channel_set_blksize(dest->io, src->io->block_size); ++ ehandler_init(dest->io); ++ ++ assert(dest->io->magic == src->io->magic); ++ assert(dest->io->manager == src->io->manager); ++ assert(strcmp(dest->io->name, src->io->name) == 0); ++ assert(dest->io->block_size == src->io->block_size); ++ assert(dest->io->read_error == src->io->read_error); ++ assert(dest->io->write_error == src->io->write_error); ++ assert(dest->io->refcount == src->io->refcount); ++ assert(dest->io->flags == src->io->flags); ++ assert(dest->io->app_data == dest); ++ assert(src->io->app_data == src); ++ assert(dest->io->align == src->io->align); ++ ++ /* The data should be written to disk immediately */ ++ dest->io->flags |= CHANNEL_FLAGS_WRITETHROUGH; ++ /* icache will be rebuilt if needed, so do not copy from @src */ ++ src->icache = NULL; ++ return 0; ++} ++ ++static int e2fsck_pass1_merge_fs(ext2_filsys dest, ext2_filsys src) ++{ ++ struct ext2_inode_cache *icache = dest->icache; ++ errcode_t retval = 0; ++ io_channel dest_io; ++ io_channel dest_image_io; ++ ext2fs_inode_bitmap inode_map; ++ ext2fs_block_bitmap block_map; ++ ext2_badblocks_list badblocks; ++ ext2_dblist dblist; ++ int flags; ++ e2fsck_t dest_ctx = dest->priv_data; ++ ++ dest_io = dest->io; ++ dest_image_io = dest->image_io; ++ inode_map = dest->inode_map; ++ block_map = dest->block_map; ++ badblocks = dest->badblocks; ++ dblist = dest->dblist; ++ flags = dest->flags; ++ ++ memcpy(dest, src, sizeof(struct struct_ext2_filsys)); ++ dest->io = dest_io; ++ dest->image_io = dest_image_io; ++ dest->icache = icache; ++ dest->inode_map = inode_map; ++ dest->block_map = block_map; ++ dest->badblocks = badblocks; ++ dest->dblist = dblist; ++ dest->priv_data = dest_ctx; ++ if (dest->dblist) ++ dest->dblist->fs = dest; ++ dest->flags = src->flags | flags; ++ if (!(src->flags & EXT2_FLAG_VALID) || !(flags & EXT2_FLAG_VALID)) ++ ext2fs_unmark_valid(dest); ++ ++ if (src->icache) { ++ ext2fs_free_inode_cache(src->icache); ++ src->icache = NULL; ++ } ++ ++ retval = e2fsck_pass1_merge_bitmap(dest, &src->inode_map, ++ &dest->inode_map); ++ if (retval) ++ goto out; ++ ++ retval = e2fsck_pass1_merge_bitmap(dest, &src->block_map, ++ &dest->block_map); ++ if (retval) ++ goto out; ++ ++ if (src->dblist) { ++ if (dest->dblist) { ++ retval = ext2fs_merge_dblist(src->dblist, ++ dest->dblist); ++ if (retval) ++ goto out; ++ } else { ++ dest->dblist = src->dblist; ++ dest->dblist->fs = dest; ++ src->dblist = NULL; ++ } ++ } ++ ++ if (src->badblocks) { ++ if (dest->badblocks == NULL) ++ retval = ext2fs_badblocks_copy(src->badblocks, ++ &dest->badblocks); ++ else ++ retval = ext2fs_badblocks_merge(src->badblocks, ++ dest->badblocks); ++ } ++out: ++ io_channel_close(src->io); ++ if (src->inode_map) ++ ext2fs_free_generic_bmap(src->inode_map); ++ if (src->block_map) ++ ext2fs_free_generic_bmap(src->block_map); ++ if (src->badblocks) ++ ext2fs_badblocks_list_free(src->badblocks); ++ if (src->dblist) ++ ext2fs_free_dblist(src->dblist); ++ ++ return retval; ++} ++ ++static void e2fsck_pass1_copy_invalid_bitmaps(e2fsck_t global_ctx, ++ e2fsck_t thread_ctx) ++{ ++ dgrp_t i, j; ++ dgrp_t grp_start = thread_ctx->thread_info.et_group_start; ++ dgrp_t grp_end = thread_ctx->thread_info.et_group_end; ++ dgrp_t total = grp_end - grp_start; ++ ++ thread_ctx->invalid_inode_bitmap_flag = ++ e2fsck_allocate_memory(global_ctx, sizeof(int) * total, ++ "invalid_inode_bitmap"); ++ thread_ctx->invalid_block_bitmap_flag = ++ e2fsck_allocate_memory(global_ctx, sizeof(int) * total, ++ "invalid_block_bitmap"); ++ thread_ctx->invalid_inode_table_flag = ++ e2fsck_allocate_memory(global_ctx, sizeof(int) * total, ++ "invalid_inode_table"); ++ ++ memcpy(thread_ctx->invalid_block_bitmap_flag, ++ &global_ctx->invalid_block_bitmap_flag[grp_start], ++ total * sizeof(int)); ++ memcpy(thread_ctx->invalid_inode_bitmap_flag, ++ &global_ctx->invalid_inode_bitmap_flag[grp_start], ++ total * sizeof(int)); ++ memcpy(thread_ctx->invalid_inode_table_flag, ++ &global_ctx->invalid_inode_table_flag[grp_start], ++ total * sizeof(int)); ++ ++ thread_ctx->invalid_bitmaps = 0; ++ for (i = grp_start, j = 0; i < grp_end; i++, j++) { ++ if (thread_ctx->invalid_block_bitmap_flag[j]) ++ thread_ctx->invalid_bitmaps++; ++ if (thread_ctx->invalid_inode_bitmap_flag[j]) ++ thread_ctx->invalid_bitmaps++; ++ if (thread_ctx->invalid_inode_table_flag[j]) ++ thread_ctx->invalid_bitmaps++; ++ } ++} ++ ++static void e2fsck_pass1_merge_invalid_bitmaps(e2fsck_t global_ctx, ++ e2fsck_t thread_ctx) ++{ ++ dgrp_t i, j; ++ dgrp_t grp_start = thread_ctx->thread_info.et_group_start; ++ dgrp_t grp_end = thread_ctx->thread_info.et_group_end; ++ dgrp_t total = grp_end - grp_start; ++ ++ memcpy(&global_ctx->invalid_block_bitmap_flag[grp_start], ++ thread_ctx->invalid_block_bitmap_flag, total * sizeof(int)); ++ memcpy(&global_ctx->invalid_inode_bitmap_flag[grp_start], ++ thread_ctx->invalid_inode_bitmap_flag, total * sizeof(int)); ++ memcpy(&global_ctx->invalid_inode_table_flag[grp_start], ++ thread_ctx->invalid_inode_table_flag, total * sizeof(int)); ++ global_ctx->invalid_bitmaps += thread_ctx->invalid_bitmaps; ++} ++ ++static errcode_t e2fsck_pass1_thread_prepare(e2fsck_t global_ctx, e2fsck_t *thread_ctx, ++ int thread_index, int num_threads, ++ dgrp_t average_group) ++{ ++ errcode_t retval; ++ e2fsck_t thread_context; ++ ext2_filsys thread_fs; ++ ext2_filsys global_fs = global_ctx->fs; ++ struct e2fsck_thread *tinfo; ++ ++ assert(global_ctx->inode_used_map == NULL); ++ assert(global_ctx->inode_dir_map == NULL); ++ assert(global_ctx->inode_bb_map == NULL); ++ assert(global_ctx->inode_imagic_map == NULL); ++ assert(global_ctx->inode_reg_map == NULL); ++ assert(global_ctx->inodes_to_rebuild == NULL); ++ ++ assert(global_ctx->block_found_map != NULL); ++ assert(global_ctx->block_metadata_map != NULL); ++ assert(global_ctx->block_dup_map != NULL); ++ assert(global_ctx->block_ea_map == NULL); ++ assert(global_ctx->fs->dblist == NULL); ++ ++ retval = ext2fs_get_mem(sizeof(struct e2fsck_struct), &thread_context); ++ if (retval) { ++ com_err(global_ctx->program_name, retval, "while allocating memory"); ++ return retval; ++ } ++ memcpy(thread_context, global_ctx, sizeof(struct e2fsck_struct)); ++ thread_context->block_dup_map = NULL; ++ thread_context->casefolded_dirs = NULL; ++ ++ retval = e2fsck_allocate_block_bitmap(global_ctx->fs, ++ _("in-use block map"), EXT2FS_BMAP64_RBTREE, ++ "block_found_map", &thread_context->block_found_map); ++ if (retval) ++ goto out_context; ++ ++ thread_context->global_ctx = global_ctx; ++ retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), &thread_fs); ++ if (retval) { ++ com_err(global_ctx->program_name, retval, "while allocating memory"); ++ goto out_context; ++ } ++ ++ io_channel_flush_cleanup(global_fs->io); ++ retval = e2fsck_pass1_copy_fs(thread_fs, global_ctx, global_fs); ++ if (retval) { ++ com_err(global_ctx->program_name, retval, "while copying fs"); ++ goto out_fs; ++ } ++ thread_fs->priv_data = thread_context; ++ ++ thread_context->thread_info.et_thread_index = thread_index; ++ set_up_logging(thread_context); ++ ++ tinfo = &thread_context->thread_info; ++ tinfo->et_group_start = average_group * thread_index; ++ if (thread_index == global_fs->fs_num_threads - 1) ++ tinfo->et_group_end = thread_fs->group_desc_count; ++ else ++ tinfo->et_group_end = average_group * (thread_index + 1); ++ tinfo->et_group_next = tinfo->et_group_start; ++ tinfo->et_inode_number = 0; ++ tinfo->et_log_buf[0] = '\0'; ++ tinfo->et_log_length = 0; ++ if (thread_context->options & E2F_OPT_MULTITHREAD) ++ log_out(thread_context, _("Scan group range [%d, %d)\n"), ++ tinfo->et_group_start, tinfo->et_group_end); ++ thread_context->fs = thread_fs; ++ retval = quota_init_context(&thread_context->qctx, thread_fs, 0); ++ if (retval) { ++ com_err(global_ctx->program_name, retval, ++ "while init quota context"); ++ goto out_fs; ++ } ++ *thread_ctx = thread_context; ++ e2fsck_pass1_copy_invalid_bitmaps(global_ctx, thread_context); ++ return 0; ++out_fs: ++ ext2fs_free_mem(&thread_fs); ++out_context: ++ if (thread_context->block_found_map) ++ ext2fs_free_mem(&thread_context->block_found_map); ++ ext2fs_free_mem(&thread_context); ++ return retval; ++} ++ ++static void e2fsck_pass1_merge_dir_info(e2fsck_t global_ctx, e2fsck_t thread_ctx) ++{ ++ if (thread_ctx->dir_info == NULL) ++ return; ++ ++ if (global_ctx->dir_info == NULL) { ++ global_ctx->dir_info = thread_ctx->dir_info; ++ thread_ctx->dir_info = NULL; ++ return; ++ } ++ ++ e2fsck_merge_dir_info(global_ctx, thread_ctx->dir_info, ++ global_ctx->dir_info); ++} ++ ++static void e2fsck_pass1_merge_dx_dir(e2fsck_t global_ctx, e2fsck_t thread_ctx) ++{ ++ if (thread_ctx->dx_dir_info == NULL) ++ return; ++ ++ if (global_ctx->dx_dir_info == NULL) { ++ global_ctx->dx_dir_info = thread_ctx->dx_dir_info; ++ global_ctx->dx_dir_info_size = thread_ctx->dx_dir_info_size; ++ global_ctx->dx_dir_info_count = thread_ctx->dx_dir_info_count; ++ thread_ctx->dx_dir_info = NULL; ++ return; ++ } ++ ++ e2fsck_merge_dx_dir(global_ctx, thread_ctx); ++} ++ ++static inline errcode_t ++e2fsck_pass1_merge_icount(ext2_icount_t *dest_icount, ++ ext2_icount_t *src_icount) ++{ ++ if (*src_icount) { ++ if (*dest_icount == NULL) { ++ *dest_icount = *src_icount; ++ *src_icount = NULL; ++ } else { ++ errcode_t ret; ++ ++ ret = ext2fs_icount_merge(*src_icount, ++ *dest_icount); ++ if (ret) ++ return ret; ++ } ++ } ++ ++ return 0; ++} ++ ++static errcode_t e2fsck_pass1_merge_icounts(e2fsck_t global_ctx, e2fsck_t thread_ctx) ++{ ++ errcode_t ret; ++ ++ ret = e2fsck_pass1_merge_icount(&global_ctx->inode_count, ++ &thread_ctx->inode_count); ++ if (ret) ++ return ret; ++ ret = e2fsck_pass1_merge_icount(&global_ctx->inode_link_info, ++ &thread_ctx->inode_link_info); ++ ++ return ret; ++} ++ ++static errcode_t e2fsck_pass1_merge_dirs_to_hash(e2fsck_t global_ctx, ++ e2fsck_t thread_ctx) ++{ ++ errcode_t retval = 0; ++ ++ if (!thread_ctx->dirs_to_hash) ++ return 0; ++ ++ if (!global_ctx->dirs_to_hash) ++ retval = ext2fs_badblocks_copy(thread_ctx->dirs_to_hash, ++ &global_ctx->dirs_to_hash); ++ else ++ retval = ext2fs_badblocks_merge(thread_ctx->dirs_to_hash, ++ global_ctx->dirs_to_hash); ++ ++ return retval; ++} ++ ++static errcode_t e2fsck_pass1_merge_ea_inode_refs(e2fsck_t global_ctx, ++ e2fsck_t thread_ctx) ++{ ++ ea_value_t count; ++ blk64_t blk; ++ errcode_t retval; ++ ++ if (!thread_ctx->ea_inode_refs) ++ return 0; ++ ++ if (!global_ctx->ea_inode_refs) { ++ global_ctx->ea_inode_refs = thread_ctx->ea_inode_refs; ++ thread_ctx->ea_inode_refs = NULL; ++ return 0; ++ } ++ ++ ea_refcount_intr_begin(thread_ctx->ea_inode_refs); ++ while (1) { ++ if ((blk = ea_refcount_intr_next(thread_ctx->ea_inode_refs, ++ &count)) == 0) ++ break; ++ if (!global_ctx->block_ea_map || ++ !ext2fs_fast_test_block_bitmap2(global_ctx->block_ea_map, ++ blk)) { ++ retval = ea_refcount_store(global_ctx->ea_inode_refs, ++ blk, count); ++ if (retval) ++ return retval; ++ } ++ } ++ ++ return retval; ++} ++ ++static ea_value_t ea_refcount_usage(e2fsck_t ctx, blk64_t blk, ++ ea_value_t *orig) ++{ ++ ea_value_t count_cur; ++ ea_value_t count_extra = 0; ++ ea_value_t count_orig; ++ ++ ea_refcount_fetch(ctx->refcount_orig, blk, &count_orig); ++ ea_refcount_fetch(ctx->refcount, blk, &count_cur); ++ /* most of time this is not needed */ ++ if (ctx->refcount_extra && count_cur == 0) ++ ea_refcount_fetch(ctx->refcount_extra, blk, &count_extra); ++ ++ if (!count_orig) ++ count_orig = *orig; ++ else if (orig) ++ *orig = count_orig; ++ ++ return count_orig + count_extra - count_cur; ++} ++ ++static errcode_t e2fsck_pass1_merge_ea_refcount(e2fsck_t global_ctx, ++ e2fsck_t thread_ctx) ++{ ++ ea_value_t count; ++ blk64_t blk; ++ errcode_t retval = 0; ++ ++ if (!thread_ctx->refcount) ++ return 0; ++ ++ if (!global_ctx->refcount) { ++ global_ctx->refcount = thread_ctx->refcount; ++ thread_ctx->refcount = NULL; ++ global_ctx->refcount_extra = thread_ctx->refcount; ++ thread_ctx->refcount_extra = NULL; ++ return 0; ++ } ++ ++ ea_refcount_intr_begin(thread_ctx->refcount); ++ while (1) { ++ if ((blk = ea_refcount_intr_next(thread_ctx->refcount, ++ &count)) == 0) ++ break; ++ /** ++ * this EA has never seen before, so just store its ++ * refcount and refcount_extra into global_ctx if needed. ++ */ ++ if (!global_ctx->block_ea_map || ++ !ext2fs_fast_test_block_bitmap2(global_ctx->block_ea_map, ++ blk)) { ++ ea_value_t extra; ++ ++ retval = ea_refcount_store(global_ctx->refcount, ++ blk, count); ++ if (retval) ++ return retval; ++ ++ if (count > 0 || !thread_ctx->refcount_extra) ++ continue; ++ ea_refcount_fetch(thread_ctx->refcount_extra, blk, ++ &extra); ++ if (extra == 0) ++ continue; ++ ++ if (!global_ctx->refcount_extra) { ++ retval = ea_refcount_create(0, ++ &global_ctx->refcount_extra); ++ if (retval) ++ return retval; ++ } ++ retval = ea_refcount_store(global_ctx->refcount_extra, ++ blk, extra); ++ if (retval) ++ return retval; ++ } else { ++ ea_value_t orig; ++ ea_value_t thread_usage; ++ ea_value_t global_usage; ++ ea_value_t new; ++ ++ thread_usage = ea_refcount_usage(thread_ctx, ++ blk, &orig); ++ global_usage = ea_refcount_usage(global_ctx, ++ blk, &orig); ++ if (thread_usage + global_usage <= orig) { ++ new = orig - thread_usage - global_usage; ++ retval = ea_refcount_store(global_ctx->refcount, ++ blk, new); ++ if (retval) ++ return retval; ++ continue; ++ } ++ /* update it is as zero */ ++ retval = ea_refcount_store(global_ctx->refcount, ++ blk, 0); ++ if (retval) ++ return retval; ++ /* Ooops, this EA was referenced more than it stated */ ++ if (!global_ctx->refcount_extra) { ++ retval = ea_refcount_create(0, ++ &global_ctx->refcount_extra); ++ if (retval) ++ return retval; ++ } ++ new = global_usage + thread_usage - orig; ++ retval = ea_refcount_store(global_ctx->refcount_extra, ++ blk, new); ++ if (retval) ++ return retval; ++ } ++ } ++ ++ return retval; ++} ++ ++static errcode_t e2fsck_pass1_merge_casefolded_dirs(e2fsck_t global_ctx, ++ e2fsck_t thread_ctx) ++{ ++ errcode_t retval = 0; ++ ++ if (!thread_ctx->casefolded_dirs) ++ return 0; ++ ++ if (!global_ctx->casefolded_dirs) ++ retval = ext2fs_badblocks_copy(thread_ctx->casefolded_dirs, ++ &global_ctx->casefolded_dirs); ++ else ++ retval = ext2fs_badblocks_merge(thread_ctx->casefolded_dirs, ++ global_ctx->casefolded_dirs); ++ ++ return retval; ++} ++ ++static errcode_t e2fsck_pass1_merge_context(e2fsck_t global_ctx, ++ e2fsck_t thread_ctx) ++{ ++ ext2_filsys global_fs = global_ctx->fs; ++ errcode_t retval; ++ int i; ++ ++ global_ctx->fs_directory_count += thread_ctx->fs_directory_count; ++ global_ctx->fs_regular_count += thread_ctx->fs_regular_count; ++ global_ctx->fs_blockdev_count += thread_ctx->fs_blockdev_count; ++ global_ctx->fs_chardev_count += thread_ctx->fs_chardev_count; ++ global_ctx->fs_links_count += thread_ctx->fs_links_count; ++ global_ctx->fs_symlinks_count += thread_ctx->fs_symlinks_count; ++ global_ctx->fs_fast_symlinks_count += thread_ctx->fs_fast_symlinks_count; ++ global_ctx->fs_fifo_count += thread_ctx->fs_fifo_count; ++ global_ctx->fs_total_count += thread_ctx->fs_total_count; ++ global_ctx->fs_badblocks_count += thread_ctx->fs_badblocks_count; ++ global_ctx->fs_sockets_count += thread_ctx->fs_sockets_count; ++ global_ctx->fs_ind_count += thread_ctx->fs_ind_count; ++ global_ctx->fs_dind_count += thread_ctx->fs_dind_count; ++ global_ctx->fs_tind_count += thread_ctx->fs_tind_count; ++ global_ctx->fs_fragmented += thread_ctx->fs_fragmented; ++ global_ctx->fs_fragmented_dir += thread_ctx->fs_fragmented_dir; ++ global_ctx->large_files += thread_ctx->large_files; ++ /* threads might enable E2F_OPT_YES */ ++ global_ctx->options |= thread_ctx->options; ++ global_ctx->flags |= thread_ctx->flags; ++ /* ++ * The l+f inode may have been cleared, so zap it now and ++ * later passes will recalculate it if necessary ++ */ ++ global_ctx->lost_and_found = 0; ++ /* merge extent depth count */ ++ for (i = 0; i < MAX_EXTENT_DEPTH_COUNT; i++) ++ global_ctx->extent_depth_count[i] += ++ thread_ctx->extent_depth_count[i]; ++ ++ e2fsck_pass1_merge_dir_info(global_ctx, thread_ctx); ++ e2fsck_pass1_merge_dx_dir(global_ctx, thread_ctx); ++ ++ retval = e2fsck_pass1_merge_fs(global_ctx->fs, thread_ctx->fs); ++ if (retval) { ++ com_err(global_ctx->program_name, 0, _("while merging fs\n")); ++ return retval; ++ } ++ retval = e2fsck_pass1_merge_icounts(global_ctx, thread_ctx); ++ if (retval) { ++ com_err(global_ctx->program_name, 0, ++ _("while merging icounts\n")); ++ return retval; ++ } ++ ++ retval = e2fsck_pass1_merge_dirs_to_hash(global_ctx, thread_ctx); ++ if (retval) { ++ com_err(global_ctx->program_name, 0, ++ _("while merging dirs to hash\n")); ++ return retval; ++ } + +- if (process_inode_count >= ctx->process_inode_size) { +- process_inodes(ctx, block_buf); ++ e2fsck_pass1_merge_ea_inode_refs(global_ctx, thread_ctx); ++ e2fsck_pass1_merge_ea_refcount(global_ctx, thread_ctx); ++ retval = quota_merge_and_update_usage(global_ctx->qctx, ++ thread_ctx->qctx); ++ if (retval) ++ return retval; + +- if (ctx->flags & E2F_FLAG_SIGNAL_MASK) +- goto endit; +- } ++ retval = e2fsck_pass1_merge_casefolded_dirs(global_ctx, thread_ctx); ++ if (retval) { ++ com_err(global_ctx->program_name, 0, ++ _("while merging casefolded dirs\n")); ++ return retval; + } +- process_inodes(ctx, block_buf); +- ext2fs_close_inode_scan(scan); +- scan = NULL; + +- reserve_block_for_root_repair(ctx); +- reserve_block_for_lnf_repair(ctx); ++ e2fsck_pass1_merge_invalid_bitmaps(global_ctx, thread_ctx); ++ ++ retval = e2fsck_pass1_merge_bitmap(global_fs, ++ &thread_ctx->inode_used_map, ++ &global_ctx->inode_used_map); ++ if (retval) ++ return retval; ++ ++ retval = e2fsck_pass1_merge_bitmap(global_fs, ++ &thread_ctx->inode_bad_map, ++ &global_ctx->inode_bad_map); ++ if (retval) ++ return retval; ++ retval = e2fsck_pass1_merge_bitmap(global_fs, ++ &thread_ctx->inode_dir_map, ++ &global_ctx->inode_dir_map); ++ if (retval) ++ return retval; ++ retval = e2fsck_pass1_merge_bitmap(global_fs, ++ &thread_ctx->inode_bb_map, ++ &global_ctx->inode_bb_map); ++ if (retval) ++ return retval; ++ retval = e2fsck_pass1_merge_bitmap(global_fs, ++ &thread_ctx->inode_imagic_map, ++ &global_ctx->inode_imagic_map); ++ if (retval) ++ return retval; ++ retval = e2fsck_pass1_merge_bitmap(global_fs, ++ &thread_ctx->inode_reg_map, ++ &global_ctx->inode_reg_map); ++ if (retval) ++ return retval; ++ retval = e2fsck_pass1_merge_bitmap(global_fs, ++ &thread_ctx->inodes_to_rebuild, ++ &global_ctx->inodes_to_rebuild); ++ if (retval) ++ return retval; ++ retval = e2fsck_pass1_merge_bitmap(global_fs, ++ &thread_ctx->block_ea_map, ++ &global_ctx->block_ea_map); ++ if (retval) ++ return retval; + ++ if (ext2fs_has_feature_shared_blocks(global_fs->super) && ++ !(global_ctx->options & E2F_OPT_UNSHARE_BLOCKS)) ++ return 0; + /* +- * If any extended attribute blocks' reference counts need to +- * be adjusted, either up (ctx->refcount_extra), or down +- * (ctx->refcount), then fix them. ++ * This need be done after merging block_ea_map ++ * because ea block might be shared, we need exclude ++ * them from dup blocks. + */ +- if (ctx->refcount) { +- adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1); +- ea_refcount_free(ctx->refcount); +- ctx->refcount = 0; ++ e2fsck_pass1_block_map_w_lock(thread_ctx); ++ retval = ext2fs_merge_bitmap(thread_ctx->block_found_map, ++ global_ctx->block_found_map, ++ global_ctx->block_dup_map, ++ global_ctx->block_ea_map); ++ e2fsck_pass1_block_map_w_unlock(thread_ctx); ++ if (retval == EEXIST) ++ global_ctx->flags |= E2F_FLAG_DUP_BLOCK; ++ ++ return 0; ++} ++ ++static int e2fsck_pass1_thread_join(e2fsck_t global_ctx, e2fsck_t thread_ctx) ++{ ++ errcode_t retval; ++ ++ retval = e2fsck_pass1_merge_context(global_ctx, thread_ctx); ++ ext2fs_free_mem(&thread_ctx->fs); ++ if (thread_ctx->logf) ++ fclose(thread_ctx->logf); ++ if (thread_ctx->problem_logf) { ++ fputs("\n", thread_ctx->problem_logf); ++ fclose(thread_ctx->problem_logf); + } +- if (ctx->refcount_extra) { +- adjust_extattr_refcount(ctx, ctx->refcount_extra, +- block_buf, +1); +- ea_refcount_free(ctx->refcount_extra); +- ctx->refcount_extra = 0; ++ ++ quota_release_context(&thread_ctx->qctx); ++ /* ++ * @block_metadata_map and @block_dup_map are ++ * shared, so we don't free them. ++ */ ++ thread_ctx->block_metadata_map = NULL; ++ thread_ctx->block_dup_map = NULL; ++ e2fsck_reset_context(thread_ctx); ++ ext2fs_free_mem(&thread_ctx); ++ ++ return retval; ++} ++ ++static int e2fsck_pass1_threads_join(e2fsck_t global_ctx) ++{ ++ errcode_t rc; ++ errcode_t ret = 0; ++ struct e2fsck_thread_info *infos = global_ctx->infos; ++ struct e2fsck_thread_info *pinfo; ++ int num_threads = global_ctx->pfs_num_threads; ++ int i; ++ ++ /* merge invalid bitmaps will recalculate it */ ++ global_ctx->invalid_bitmaps = 0; ++ for (i = 0; i < num_threads; i++) { ++ pinfo = &infos[i]; ++ ++ if (!pinfo->eti_started) ++ continue; ++ ++ rc = pthread_join(pinfo->eti_thread_id, NULL); ++ if (rc) { ++ com_err(global_ctx->program_name, rc, ++ _("while joining thread\n")); ++ if (ret == 0) ++ ret = rc; ++ } ++ rc = e2fsck_pass1_thread_join(global_ctx, infos[i].eti_thread_ctx); ++ if (rc) { ++ com_err(global_ctx->program_name, rc, ++ _("while joining pass1 thread\n")); ++ if (ret == 0) ++ ret = rc; ++ } + } ++ free(infos); ++ global_ctx->infos = NULL; + +- if (ctx->ea_block_quota_blocks) { +- ea_refcount_free(ctx->ea_block_quota_blocks); +- ctx->ea_block_quota_blocks = 0; ++ return ret; ++} ++ ++static void *e2fsck_pass1_thread(void *arg) ++{ ++ struct e2fsck_thread_info *info = arg; ++ e2fsck_t thread_ctx = info->eti_thread_ctx; ++#ifdef DEBUG_THREADS ++ struct e2fsck_thread_debug *thread_debug = info->eti_debug; ++#endif ++ ++#ifdef DEBUG_THREADS ++ pthread_mutex_lock(&thread_debug->etd_mutex); ++ while (info->eti_thread_index > thread_debug->etd_finished_threads) { ++ pthread_cond_wait(&thread_debug->etd_cond, ++ &thread_debug->etd_mutex); + } ++ pthread_mutex_unlock(&thread_debug->etd_mutex); ++#endif + +- if (ctx->ea_block_quota_inodes) { +- ea_refcount_free(ctx->ea_block_quota_inodes); +- ctx->ea_block_quota_inodes = 0; ++#ifdef HAVE_SETJMP_H ++ /* ++ * When fatal_error() happens, jump to here. The thread ++ * context's flags will be saved, but its abort_loc will ++ * be overwritten by original jump buffer for the later ++ * tests. ++ */ ++ if (setjmp(thread_ctx->abort_loc)) { ++ thread_ctx->flags &= ~E2F_FLAG_SETJMP_OK; ++ goto out; + } ++ thread_ctx->flags |= E2F_FLAG_SETJMP_OK; ++#endif + +- if (ctx->invalid_bitmaps) +- handle_fs_bad_blocks(ctx); ++ e2fsck_pass1_run(thread_ctx); + +- /* We don't need the block_ea_map any more */ +- if (ctx->block_ea_map) { +- ext2fs_free_block_bitmap(ctx->block_ea_map); +- ctx->block_ea_map = 0; +- } ++out: ++ if (thread_ctx->options & E2F_OPT_MULTITHREAD) ++ log_out(thread_ctx, ++ _("Scanned group range [%u, %u), inodes %u\n"), ++ thread_ctx->thread_info.et_group_start, ++ thread_ctx->thread_info.et_group_end, ++ thread_ctx->thread_info.et_inode_number); ++ ++#ifdef DEBUG_THREADS ++ pthread_mutex_lock(&thread_debug->etd_mutex); ++ thread_debug->etd_finished_threads++; ++ pthread_cond_broadcast(&thread_debug->etd_cond); ++ pthread_mutex_unlock(&thread_debug->etd_mutex); ++#endif + +- /* We don't need the encryption policy => ID map any more */ +- destroy_encryption_policy_map(ctx); ++ return NULL; ++} + +- if (ctx->flags & E2F_FLAG_RESIZE_INODE) { +- clear_problem_context(&pctx); +- pctx.errcode = ext2fs_create_resize_inode(fs); +- if (pctx.errcode) { +- if (!fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, +- &pctx)) { +- ctx->flags |= E2F_FLAG_ABORT; +- goto endit; +- } +- pctx.errcode = 0; +- } +- if (!pctx.errcode) { +- e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode, +- "recreate inode"); +- inode->i_mtime = ctx->now; +- e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode, +- "recreate inode"); ++static dgrp_t ext2fs_get_avg_group(ext2_filsys fs) ++{ ++#ifdef HAVE_PTHREAD ++ dgrp_t average_group; ++ unsigned flexbg_size; ++ ++ if (fs->fs_num_threads <= 1) ++ return fs->group_desc_count; ++ ++ average_group = fs->group_desc_count / fs->fs_num_threads; ++ if (average_group <= 1) ++ return 1; ++ ++ if (ext2fs_has_feature_flex_bg(fs->super)) { ++ int times = 1; ++ ++ flexbg_size = 1 << fs->super->s_log_groups_per_flex; ++ if (average_group % flexbg_size) { ++ times = average_group / flexbg_size; ++ average_group = times * flexbg_size; + } +- ctx->flags &= ~E2F_FLAG_RESIZE_INODE; + } + +- if (ctx->flags & E2F_FLAG_RESTART) { +- /* +- * Only the master copy of the superblock and block +- * group descriptors are going to be written during a +- * restart, so set the superblock to be used to be the +- * master superblock. +- */ +- ctx->use_superblock = 0; +- goto endit; ++ return average_group; ++#else ++ return fs->group_desc_count; ++#endif ++} ++ ++static int e2fsck_pass1_threads_start(e2fsck_t global_ctx) ++{ ++ struct e2fsck_thread_info *infos; ++ pthread_attr_t attr; ++ errcode_t retval; ++ errcode_t ret; ++ struct e2fsck_thread_info *tmp_pinfo; ++ int i; ++ e2fsck_t thread_ctx; ++ dgrp_t average_group; ++ int num_threads = global_ctx->pfs_num_threads; ++#ifdef DEBUG_THREADS ++ struct e2fsck_thread_debug thread_debug = ++ {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0}; ++ ++ thread_debug.etd_finished_threads = 0; ++#endif ++ ++ retval = pthread_attr_init(&attr); ++ if (retval) { ++ com_err(global_ctx->program_name, retval, ++ _("while setting pthread attribute\n")); ++ return retval; + } + +- if (ctx->large_dirs && !ext2fs_has_feature_largedir(fs->super)) { +- if (fix_problem(ctx, PR_2_FEATURE_LARGE_DIRS, &pctx)) { +- ext2fs_set_feature_largedir(fs->super); +- fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; +- ext2fs_mark_super_dirty(fs); ++ infos = calloc(num_threads, sizeof(struct e2fsck_thread_info)); ++ if (infos == NULL) { ++ retval = -ENOMEM; ++ com_err(global_ctx->program_name, retval, ++ _("while allocating memory for threads\n")); ++ pthread_attr_destroy(&attr); ++ return retval; ++ } ++ global_ctx->infos = infos; ++ ++ average_group = ext2fs_get_avg_group(global_ctx->fs); ++ for (i = 0; i < num_threads; i++) { ++ tmp_pinfo = &infos[i]; ++ tmp_pinfo->eti_thread_index = i; ++#ifdef DEBUG_THREADS ++ tmp_pinfo->eti_debug = &thread_debug; ++#endif ++ retval = e2fsck_pass1_thread_prepare(global_ctx, &thread_ctx, ++ i, num_threads, ++ average_group); ++ if (retval) { ++ com_err(global_ctx->program_name, retval, ++ _("while preparing pass1 thread\n")); ++ break; + } +- if (fs->super->s_rev_level == EXT2_GOOD_OLD_REV && +- fix_problem(ctx, PR_1_FS_REV_LEVEL, &pctx)) { +- ext2fs_update_dynamic_rev(fs); +- ext2fs_mark_super_dirty(fs); ++ tmp_pinfo->eti_thread_ctx = thread_ctx; ++ ++ retval = pthread_create(&tmp_pinfo->eti_thread_id, &attr, ++ &e2fsck_pass1_thread, tmp_pinfo); ++ if (retval) { ++ com_err(global_ctx->program_name, retval, ++ _("while creating thread\n")); ++ e2fsck_pass1_thread_join(global_ctx, thread_ctx); ++ break; + } ++ ++ tmp_pinfo->eti_started = 1; + } + +- if (ctx->block_dup_map) { +- if (ctx->options & E2F_OPT_PREEN) { +- clear_problem_context(&pctx); +- fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx); +- } +- e2fsck_pass1_dupblocks(ctx, block_buf); ++ /* destroy the thread attribute object, since it is no longer needed */ ++ ret = pthread_attr_destroy(&attr); ++ if (ret) { ++ com_err(global_ctx->program_name, ret, ++ _("while destroying thread attribute\n")); ++ if (retval == 0) ++ retval = ret; + } +- ctx->flags |= E2F_FLAG_ALLOC_OK; +-endit: +- e2fsck_use_inode_shortcuts(ctx, 0); +- ext2fs_free_mem(&inodes_to_process); +- inodes_to_process = 0; + +- if (scan) +- ext2fs_close_inode_scan(scan); +- if (block_buf) +- ext2fs_free_mem(&block_buf); +- if (inode) +- ext2fs_free_mem(&inode); ++ if (retval) { ++ e2fsck_pass1_threads_join(global_ctx); ++ return retval; ++ } ++ return 0; ++} + +- /* +- * The l+f inode may have been cleared, so zap it now and +- * later passes will recalculate it if necessary +- */ +- ctx->lost_and_found = 0; ++static void e2fsck_pass1_multithread(e2fsck_t global_ctx) ++{ ++ errcode_t retval; + +- if ((ctx->flags & E2F_FLAG_SIGNAL_MASK) == 0) +- print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io); +- else +- ctx->invalid_bitmaps++; ++ retval = e2fsck_pass1_threads_start(global_ctx); ++ if (retval) { ++ com_err(global_ctx->program_name, retval, ++ _("while starting pass1 threads\n")); ++ goto out_abort; ++ } ++ ++ retval = e2fsck_pass1_threads_join(global_ctx); ++ if (retval) { ++ com_err(global_ctx->program_name, retval, ++ _("while joining pass1 threads\n")); ++ goto out_abort; ++ } ++ return; ++out_abort: ++ global_ctx->flags |= E2F_FLAG_ABORT; ++ return; ++} ++#endif ++ ++void e2fsck_pass1(e2fsck_t ctx) ++{ ++ errcode_t retval; ++ int need_single = 1; ++ ++ retval = e2fsck_pass1_prepare(ctx); ++ if (retval) ++ return; ++#ifdef HAVE_PTHREAD ++ if (ctx->pfs_num_threads > 1 || ctx->options & E2F_OPT_MULTITHREAD) { ++ need_single = 0; ++ e2fsck_pass1_multithread(ctx); ++ } ++ /* No lock is needed at this time */ ++ ctx->fs_need_locking = 0; ++#endif ++ if (need_single) ++ e2fsck_pass1_run(ctx); ++ e2fsck_pass1_post(ctx); + } ++ + #undef FINISH_INODE_LOOP + + /* +@@ -2114,24 +3441,65 @@ static errcode_t scan_callback(ext2_filsys fs, + { + struct scan_callback_struct *scan_struct; + e2fsck_t ctx; ++ dgrp_t cur = group + 1; ++ struct e2fsck_thread *tinfo; ++ struct e2fsck_thread_info *pinfo, *infos; ++ int i; + + scan_struct = (struct scan_callback_struct *) priv_data; + ctx = scan_struct->ctx; + +- process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf); ++ process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf, ++ scan_struct->inodes_to_process, ++ scan_struct->process_inode_count); ++ ++#ifdef HAVE_PTHREAD ++ if (ctx->global_ctx) { ++ cur = 0; ++ infos = ctx->global_ctx->infos; ++ for (i = 0; i < ctx->global_ctx->pfs_num_threads; i++) { ++ pinfo = &infos[i]; ++ ++ if (!pinfo->eti_started) ++ continue; ++ ++ tinfo = &pinfo->eti_thread_ctx->thread_info; ++ if (ctx == pinfo->eti_thread_ctx) ++ cur += group + 1 - tinfo->et_group_start; ++ else ++ cur += tinfo->et_group_next - ++ tinfo->et_group_start; ++ } ++ } ++#endif + + if (ctx->progress) +- if ((ctx->progress)(ctx, 1, group+1, ++ if ((ctx->progress)(ctx, 1, cur, + ctx->fs->group_desc_count)) + return EXT2_ET_CANCEL_REQUESTED; + ++#ifdef HAVE_PTHREAD ++ if (ctx->global_ctx) { ++ tinfo = &ctx->thread_info; ++ tinfo->et_group_next++; ++ if (ctx->options & E2F_OPT_DEBUG && ++ ctx->options & E2F_OPT_MULTITHREAD) ++ log_out(ctx, _("group %d finished\n"), ++ tinfo->et_group_next); ++ if (tinfo->et_group_next >= tinfo->et_group_end) ++ return EXT2_ET_SCAN_FINISHED; ++ } ++#endif ++ + return 0; + } + + /* + * Process the inodes in the "inodes to process" list. + */ +-static void process_inodes(e2fsck_t ctx, char *block_buf) ++static void process_inodes(e2fsck_t ctx, char *block_buf, ++ struct process_inode_block *inodes_to_process, ++ int *process_inode_count) + { + int i; + struct ext2_inode *old_stashed_inode; +@@ -2143,15 +3511,15 @@ static void process_inodes(e2fsck_t ctx, char *block_buf) + #if 0 + printf("begin process_inodes: "); + #endif +- if (process_inode_count == 0) ++ if (*process_inode_count == 0) + return; + old_operation = ehandler_operation(0); + old_stashed_inode = ctx->stashed_inode; + old_stashed_ino = ctx->stashed_ino; +- qsort(inodes_to_process, process_inode_count, ++ qsort(inodes_to_process, *process_inode_count, + sizeof(struct process_inode_block), process_inode_cmp); + clear_problem_context(&pctx); +- for (i=0; i < process_inode_count; i++) { ++ for (i=0; i < *process_inode_count; i++) { + pctx.inode = ctx->stashed_inode = + (struct ext2_inode *) &inodes_to_process[i].inode; + pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino; +@@ -2164,12 +3532,12 @@ static void process_inodes(e2fsck_t ctx, char *block_buf) + ehandler_operation(buf); + check_blocks(ctx, &pctx, block_buf, + &inodes_to_process[i].ea_ibody_quota); +- if (ctx->flags & E2F_FLAG_SIGNAL_MASK) ++ if (e2fsck_should_abort(ctx)) + break; + } + ctx->stashed_inode = old_stashed_inode; + ctx->stashed_ino = old_stashed_ino; +- process_inode_count = 0; ++ *process_inode_count = 0; + #if 0 + printf("end process inodes\n"); + #endif +@@ -2290,30 +3658,20 @@ static void alloc_imagic_map(e2fsck_t ctx) + */ + static _INLINE_ void mark_block_used(e2fsck_t ctx, blk64_t block) + { +- struct problem_context pctx; ++ struct problem_context pctx; ++ e2fsck_t global_ctx = ctx->global_ctx ? ctx->global_ctx : ctx; + + clear_problem_context(&pctx); + +- if (ext2fs_fast_test_block_bitmap2(ctx->block_found_map, block)) { ++ if (is_blocks_used(ctx, block, 1)) { + if (ext2fs_has_feature_shared_blocks(ctx->fs->super) && + !(ctx->options & E2F_OPT_UNSHARE_BLOCKS)) { + return; + } +- if (!ctx->block_dup_map) { +- pctx.errcode = e2fsck_allocate_block_bitmap(ctx->fs, +- _("multiply claimed block map"), +- EXT2FS_BMAP64_RBTREE, "block_dup_map", +- &ctx->block_dup_map); +- if (pctx.errcode) { +- pctx.num = 3; +- fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, +- &pctx); +- /* Should never get here */ +- ctx->flags |= E2F_FLAG_ABORT; +- return; +- } +- } +- ext2fs_fast_mark_block_bitmap2(ctx->block_dup_map, block); ++ ctx->flags |= E2F_FLAG_DUP_BLOCK; ++ e2fsck_pass1_block_map_w_lock(ctx); ++ ext2fs_fast_mark_block_bitmap2(global_ctx->block_dup_map, block); ++ e2fsck_pass1_block_map_w_unlock(ctx); + } else { + ext2fs_fast_mark_block_bitmap2(ctx->block_found_map, block); + } +@@ -2326,9 +3684,9 @@ static _INLINE_ void mark_block_used(e2fsck_t ctx, blk64_t block) + static _INLINE_ void mark_blocks_used(e2fsck_t ctx, blk64_t block, + unsigned int num) + { +- if (ext2fs_test_block_bitmap_range2(ctx->block_found_map, block, num)) ++ if (!is_blocks_used(ctx, block, num)) { + ext2fs_mark_block_bitmap_range2(ctx->block_found_map, block, num); +- else { ++ } else { + unsigned int i; + + for (i = 0; i < num; i += EXT2FS_CLUSTER_RATIO(ctx->fs)) +@@ -2336,6 +3694,18 @@ static _INLINE_ void mark_blocks_used(e2fsck_t ctx, blk64_t block, + } + } + ++static errcode_t _INLINE_ e2fsck_write_ext_attr3(e2fsck_t ctx, blk64_t block, ++ void *inbuf, ext2_ino_t inum) ++{ ++ errcode_t retval; ++ ext2_filsys fs = ctx->fs; ++ ++ e2fsck_pass1_fix_lock(ctx); ++ retval = ext2fs_write_ext_attr3(fs, block, inbuf, inum); ++ e2fsck_pass1_fix_unlock(ctx); ++ ++ return retval; ++} + /* + * Adjust the extended attribute block's reference counts at the end + * of pass 1, either by subtracting out references for EA blocks that +@@ -2372,7 +3742,7 @@ static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, + pctx.num = should_be; + if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) { + header->h_refcount = should_be; +- pctx.errcode = ext2fs_write_ext_attr3(fs, blk, ++ pctx.errcode = e2fsck_write_ext_attr3(ctx, blk, + block_buf, + pctx.ino); + if (pctx.errcode) { +@@ -2439,6 +3809,15 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, + + /* Create the EA refcount structure if necessary */ + if (!ctx->refcount) { ++ pctx->errcode = ea_refcount_create(0, ++ &ctx->refcount_orig); ++ if (pctx->errcode) { ++ pctx->num = 1; ++ fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); ++ ctx->flags |= E2F_FLAG_ABORT; ++ return 0; ++ } ++ + pctx->errcode = ea_refcount_create(0, &ctx->refcount); + if (pctx->errcode) { + pctx->num = 1; +@@ -2603,7 +3982,7 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, + */ + if (failed_csum && + fix_problem(ctx, PR_1_EA_BLOCK_ONLY_CSUM_INVALID, pctx)) { +- pctx->errcode = ext2fs_write_ext_attr3(fs, blk, block_buf, ++ pctx->errcode = e2fsck_write_ext_attr3(ctx, blk, block_buf, + pctx->ino); + if (pctx->errcode) + return 0; +@@ -2643,7 +4022,13 @@ refcount_fail: + + inc_ea_inode_refs(ctx, pctx, first, end); + ea_refcount_store(ctx->refcount, blk, header->h_refcount - 1); +- mark_block_used(ctx, blk); ++ ea_refcount_store(ctx->refcount_orig, blk, header->h_refcount); ++ /** ++ * It might be racy that this block has been merged in the ++ * global found map. ++ */ ++ if (!is_blocks_used(ctx, blk, 1)) ++ ext2fs_fast_mark_block_bitmap2(ctx->block_found_map, blk); + ext2fs_fast_mark_block_bitmap2(ctx->block_ea_map, blk); + return 1; + +@@ -2914,10 +4299,12 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, + if (try_repairs && is_dir && problem == 0 && + (extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT) && + fix_problem(ctx, PR_1_UNINIT_DBLOCK, pctx)) { ++ e2fsck_pass1_fix_lock(ctx); + extent.e_flags &= ~EXT2_EXTENT_FLAGS_UNINIT; + pb->inode_modified = 1; + pctx->errcode = ext2fs_extent_replace(ehandle, 0, + &extent); ++ e2fsck_pass1_fix_unlock(ctx); + if (pctx->errcode) + return; + failed_csum = 0; +@@ -2959,15 +4346,19 @@ report_problem: + } + continue; + } ++ e2fsck_pass1_fix_lock(ctx); + e2fsck_read_bitmaps(ctx); + pb->inode_modified = 1; + pctx->errcode = + ext2fs_extent_delete(ehandle, 0); ++ e2fsck_pass1_fix_unlock(ctx); + if (pctx->errcode) { + pctx->str = "ext2fs_extent_delete"; + return; + } ++ e2fsck_pass1_fix_lock(ctx); + pctx->errcode = ext2fs_extent_fix_parents(ehandle); ++ e2fsck_pass1_fix_unlock(ctx); + if (pctx->errcode && + pctx->errcode != EXT2_ET_NO_CURRENT_NODE) { + pctx->str = "ext2fs_extent_fix_parents"; +@@ -3036,9 +4427,11 @@ report_problem: + pctx->num = e_info.curr_level - 1; + problem = PR_1_EXTENT_INDEX_START_INVALID; + if (fix_problem(ctx, problem, pctx)) { ++ e2fsck_pass1_fix_lock(ctx); + pb->inode_modified = 1; + pctx->errcode = + ext2fs_extent_fix_parents(ehandle); ++ e2fsck_pass1_fix_unlock(ctx); + if (pctx->errcode) { + pctx->str = "ext2fs_extent_fix_parents"; + return; +@@ -3109,15 +4502,19 @@ report_problem: + pctx->blk = extent.e_lblk; + pctx->blk2 = new_lblk; + if (fix_problem(ctx, PR_1_COLLAPSE_DBLOCK, pctx)) { ++ e2fsck_pass1_fix_lock(ctx); + extent.e_lblk = new_lblk; + pb->inode_modified = 1; + pctx->errcode = ext2fs_extent_replace(ehandle, + 0, &extent); ++ e2fsck_pass1_fix_unlock(ctx); + if (pctx->errcode) { + pctx->errcode = 0; + goto alloc_later; + } ++ e2fsck_pass1_fix_lock(ctx); + pctx->errcode = ext2fs_extent_fix_parents(ehandle); ++ e2fsck_pass1_fix_unlock(ctx); + if (pctx->errcode) + goto failed_add_dir_block; + pctx->errcode = ext2fs_extent_goto(ehandle, +@@ -3213,8 +4610,10 @@ alloc_later: + /* Failed csum but passes checks? Ask to fix checksum. */ + if (failed_csum && + fix_problem(ctx, PR_1_EXTENT_ONLY_CSUM_INVALID, pctx)) { ++ e2fsck_pass1_fix_lock(ctx); + pb->inode_modified = 1; + pctx->errcode = ext2fs_extent_replace(ehandle, 0, &extent); ++ e2fsck_pass1_fix_unlock(ctx); + if (pctx->errcode) + return; + } +@@ -3397,7 +4796,7 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, + inlinedata_fs = ext2fs_has_feature_inline_data(ctx->fs->super); + + if (check_ext_attr(ctx, pctx, block_buf, &ea_block_quota)) { +- if (ctx->flags & E2F_FLAG_SIGNAL_MASK) ++ if (e2fsck_should_abort(ctx)) + goto out; + pb.num_blocks += EXT2FS_B2C(ctx->fs, ea_block_quota.blocks); + } +@@ -3452,7 +4851,7 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, + } + end_problem_latch(ctx, PR_LATCH_BLOCK); + end_problem_latch(ctx, PR_LATCH_TOOBIG); +- if (ctx->flags & E2F_FLAG_SIGNAL_MASK) ++ if (e2fsck_should_abort(ctx)) + goto out; + if (pctx->errcode) + fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx); +@@ -3925,18 +5324,18 @@ static int process_bad_block(ext2_filsys fs, + *block_nr = 0; + return BLOCK_CHANGED; + } +- } else if (ext2fs_test_block_bitmap2(ctx->block_found_map, +- blk)) { ++ } else if (is_blocks_used(ctx, blk, 1)) { + p->bbcheck = 1; + if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, + pctx)) { + *block_nr = 0; + return BLOCK_CHANGED; + } +- if (ctx->flags & E2F_FLAG_SIGNAL_MASK) ++ if (e2fsck_should_abort(ctx)) + return BLOCK_ABORT; +- } else ++ } else { + mark_block_used(ctx, blk); ++ } + return 0; + } + #if 0 +@@ -3949,7 +5348,7 @@ static int process_bad_block(ext2_filsys fs, + * there's an overlap between the filesystem table blocks + * (bitmaps and inode table) and the bad block list. + */ +- if (!ext2fs_test_block_bitmap2(ctx->block_found_map, blk)) { ++ if (!is_blocks_used(ctx, blk, 1)) { + ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); + return 0; + } +@@ -4030,7 +5429,7 @@ static int process_bad_block(ext2_filsys fs, + *block_nr = 0; + return BLOCK_CHANGED; + } +- if (ctx->flags & E2F_FLAG_SIGNAL_MASK) ++ if (e2fsck_should_abort(ctx)) + return BLOCK_ABORT; + return 0; + } +diff --git a/e2fsck/problem.c b/e2fsck/problem.c +index 757b5d5..3bc2910 100644 +--- a/e2fsck/problem.c ++++ b/e2fsck/problem.c +@@ -1279,6 +1279,10 @@ static struct e2fsck_problem problem_table[] = { + N_("@h %i uses SipHash, but should not. "), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + ++ /* Failed to goto block group */ ++ { PR_1_SCAN_GOTO, ++ N_("failed to goto block group"), ++ PROMPT_NONE, PR_FATAL, 0, 0, 0 }, + + /* Pass 1b errors */ + +@@ -2503,6 +2507,12 @@ int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx) + if (*message) + message = _(message); + if (!suppress) { ++#ifdef HAVE_PTHREAD ++ if ((ctx->options & E2F_OPT_MULTITHREAD) && ctx->global_ctx) ++ printf("[Thread %d] ", ++ ctx->thread_info.et_thread_index); ++#endif ++ + if ((ctx->options & E2F_OPT_PREEN) && + !(ptr->flags & PR_PREEN_NOHDR)) { + printf("%s: ", ctx->device_name ? +diff --git a/e2fsck/problem.h b/e2fsck/problem.h +index 24cdcf9..c09fbf9 100644 +--- a/e2fsck/problem.h ++++ b/e2fsck/problem.h +@@ -716,6 +716,8 @@ struct problem_context { + /* Htree directory uses SipHash but should not */ + #define PR_1_HTREE_CANNOT_SIPHASH 0x01008E + ++/* Failed to goto block group */ ++#define PR_1_SCAN_GOTO 0x0100A0 + + /* + * Pass 1b errors +diff --git a/e2fsck/readahead.c b/e2fsck/readahead.c +index 38d4ec4..40b7366 100644 +--- a/e2fsck/readahead.c ++++ b/e2fsck/readahead.c +@@ -234,6 +234,8 @@ int e2fsck_can_readahead(ext2_filsys fs) + return err != EXT2_ET_OP_NOT_SUPPORTED; + } + ++#define MIN_DEFAULT_RA (1024 * 1024) ++ + unsigned long long e2fsck_guess_readahead(ext2_filsys fs) + { + unsigned long long guess; +@@ -245,6 +247,8 @@ unsigned long long e2fsck_guess_readahead(ext2_filsys fs) + * in e2fsck runtime. + */ + guess = 2ULL * fs->blocksize * fs->inode_blocks_per_group; ++ if (guess < MIN_DEFAULT_RA) ++ guess = MIN_DEFAULT_RA; + + /* Disable RA if it'd use more 1/50th of RAM. */ + if (get_memory_size() > (guess * 50)) +diff --git a/e2fsck/unix.c b/e2fsck/unix.c +index f267bae..96b9c1e 100644 +--- a/e2fsck/unix.c ++++ b/e2fsck/unix.c +@@ -75,13 +75,16 @@ int journal_enable_debug = -1; + static void usage(e2fsck_t ctx) + { + fprintf(stderr, +- _("Usage: %s [-panyrcdfktvDFV] [-b superblock] [-B blocksize]\n" ++ _("Usage: %s [-pamnyrcdfktvDFV] [-b superblock] [-B blocksize]\n" + "\t\t[-l|-L bad_blocks_file] [-C fd] [-j external_journal]\n" + "\t\t[-E extended-options] [-z undo_file] device\n"), + ctx->program_name); + + fprintf(stderr, "%s", _("\nEmergency help:\n" + " -p Automatic repair (no questions)\n" ++#ifdef HAVE_PTHREAD ++ " -m multiple threads to speedup fsck\n" ++#endif + " -n Make no changes to the filesystem\n" + " -y Assume \"yes\" to all questions\n" + " -c Check for bad blocks and add them to the badblock list\n" +@@ -822,6 +825,10 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) + int res; /* result of sscanf */ + #ifdef CONFIG_JBD_DEBUG + char *jbd_debug; ++#endif ++#ifdef HAVE_PTHREAD ++ char *pm; ++ unsigned long thread_num; + #endif + unsigned long long phys_mem_kb, blk; + +@@ -853,7 +860,12 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) + + phys_mem_kb = get_memory_size() / 1024; + ctx->readahead_kb = ~0ULL; ++ ++#ifdef HAVE_PTHREAD ++ while ((c = getopt(argc, argv, "pam:nyrcC:B:dE:fvtFVM:b:I:j:P:l:L:N:SsDkz:")) != EOF) ++#else + while ((c = getopt(argc, argv, "panyrcC:B:dE:fvtFVM:b:I:j:P:l:L:N:SsDkz:")) != EOF) ++#endif + switch (c) { + case 'C': + ctx->progress = e2fsck_update_progress; +@@ -894,6 +906,22 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) + } + ctx->options |= E2F_OPT_PREEN; + break; ++#ifdef HAVE_PTHREAD ++ case 'm': ++ thread_num = strtoul(optarg, &pm, 0); ++ if (*pm) ++ fatal_error(ctx, ++ _("Invalid multiple thread num.\n")); ++ if (thread_num > E2FSCK_MAX_THREADS) { ++ fprintf(stderr, ++ _("threads %lu too large (max %u)\n"), ++ thread_num, E2FSCK_MAX_THREADS); ++ fatal_error(ctx, 0); ++ } ++ ctx->options |= E2F_OPT_MULTITHREAD; ++ ctx->pfs_num_threads = thread_num; ++ break; ++#endif + case 'n': + if (ctx->options & (E2F_OPT_YES|E2F_OPT_PREEN)) + goto conflict_opt; +@@ -1013,6 +1041,15 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) + _("The -n and -l/-L options are incompatible.")); + fatal_error(ctx, 0); + } ++#ifdef HAVE_PTHREAD ++ if (ctx->options & E2F_OPT_MULTITHREAD) { ++ if ((ctx->options & (E2F_OPT_YES|E2F_OPT_NO|E2F_OPT_PREEN)) == 0) { ++ com_err(ctx->program_name, 0, "%s", ++ _("The -m option should be used together with one of -p/-y/-n options.")); ++ fatal_error(ctx, 0); ++ } ++ } ++#endif + if (ctx->options & E2F_OPT_NO) + ctx->options |= E2F_OPT_READONLY; + +@@ -1434,6 +1471,7 @@ int main (int argc, char *argv[]) + } + reserve_stdio_fds(); + ++ ctx->global_ctx = NULL; + set_up_logging(ctx); + if (ctx->logf) { + int i; +@@ -1513,6 +1551,7 @@ restart: + } + + ctx->openfs_flags = flags; ++ ctx->io_manager = io_ptr; + retval = try_open_fs(ctx, flags, io_ptr, &fs); + + if (!ctx->superblock && !(ctx->options & E2F_OPT_PREEN) && +@@ -1691,6 +1730,9 @@ failure: + + ctx->fs = fs; + fs->now = ctx->now; ++#ifdef HAVE_PTHREAD ++ fs->fs_num_threads = ctx->pfs_num_threads; ++#endif + sb = fs->super; + + if (sb->s_rev_level > E2FSCK_CURRENT_REV) { +diff --git a/e2fsck/util.c b/e2fsck/util.c +index 3fe3c98..7dd565c 100644 +--- a/e2fsck/util.c ++++ b/e2fsck/util.c +@@ -11,6 +11,7 @@ + + #include "config.h" + #include ++#include + #include + #include + #include +@@ -37,6 +38,10 @@ + #include + #endif + ++#ifdef HAVE_PTHREAD ++#include ++#endif ++ + #include "e2fsck.h" + + extern e2fsck_t e2fsck_global_ctx; /* Try your very best not to use this! */ +@@ -77,20 +82,75 @@ void fatal_error(e2fsck_t ctx, const char *msg) + } + out: + ctx->flags |= E2F_FLAG_ABORT; +- if (ctx->flags & E2F_FLAG_SETJMP_OK) ++ if (!(ctx->options & E2F_OPT_MULTITHREAD) && ++ ctx->flags & E2F_FLAG_SETJMP_OK) + longjmp(ctx->abort_loc, 1); + if (ctx->logf) + fprintf(ctx->logf, "Exit status: %d\n", exit_value); + exit(exit_value); + } + ++#ifdef HAVE_PTHREAD ++static void thread_log_out(struct e2fsck_thread *tinfo) ++{ ++ printf("[Thread %d] %s", tinfo->et_thread_index, ++ tinfo->et_log_buf); ++ tinfo->et_log_length = 0; ++ tinfo->et_log_buf[0] = '\0'; ++} ++#endif ++ + void log_out(e2fsck_t ctx, const char *fmt, ...) + { + va_list pvar; ++ struct e2fsck_thread *tinfo; ++ int buf_size; ++ int msg_size; ++ int left_size; ++ int fmt_length = strlen(fmt); ++ ++#ifdef HAVE_PTHREAD ++ if ((ctx->options & E2F_OPT_MULTITHREAD) && ctx->global_ctx) { ++ tinfo = &ctx->thread_info; ++ buf_size = sizeof(tinfo->et_log_buf); ++ left_size = buf_size - tinfo->et_log_length; ++ ++ va_start(pvar, fmt); ++ msg_size = vsnprintf(tinfo->et_log_buf + tinfo->et_log_length, ++ left_size, fmt, pvar); ++ va_end(pvar); ++ ++ if (msg_size >= left_size) { ++ tinfo->et_log_buf[tinfo->et_log_length] = '\0'; ++ ++ assert(msg_size < buf_size); ++ if (msg_size < buf_size) { ++ thread_log_out(tinfo); ++ ++ va_start(pvar, fmt); ++ msg_size = vsnprintf(tinfo->et_log_buf, buf_size, ++ fmt, pvar); ++ va_end(pvar); ++ ++ tinfo->et_log_length += msg_size; ++ tinfo->et_log_buf[tinfo->et_log_length] = '\0'; ++ } ++ } else { ++ tinfo->et_log_length += msg_size; ++ tinfo->et_log_buf[tinfo->et_log_length] = '\0'; ++ } ++ ++ if (tinfo->et_log_length > 0 && ++ tinfo->et_log_buf[tinfo->et_log_length - 1] == '\n') ++ thread_log_out(tinfo); ++ } else ++#endif ++ { ++ va_start(pvar, fmt); ++ vprintf(fmt, pvar); ++ va_end(pvar); ++ } + +- va_start(pvar, fmt); +- vprintf(fmt, pvar); +- va_end(pvar); + if (ctx->logf) { + va_start(pvar, fmt); + vfprintf(ctx->logf, fmt, pvar); +@@ -506,13 +566,136 @@ void e2fsck_read_inode_full(e2fsck_t ctx, unsigned long ino, + } + } + ++#ifdef HAVE_PTHREAD ++#define e2fsck_get_lock_context(ctx) \ ++ e2fsck_t global_ctx = ctx->global_ctx; \ ++ if (!global_ctx) \ ++ global_ctx = ctx; \ ++ ++/** ++ * before we hold write lock, read lock should ++ * has been held. ++ */ ++void e2fsck_pass1_fix_lock(e2fsck_t ctx) ++{ ++ int err; ++ ++ if (!ctx->fs_need_locking) ++ return; ++ ++ e2fsck_get_lock_context(ctx); ++ err = pthread_rwlock_trywrlock(&global_ctx->fs_fix_rwlock); ++ assert(err != 0); ++ pthread_rwlock_unlock(&global_ctx->fs_fix_rwlock); ++ pthread_rwlock_wrlock(&global_ctx->fs_fix_rwlock); ++} ++ ++void e2fsck_pass1_fix_unlock(e2fsck_t ctx) ++{ ++ if (!ctx->fs_need_locking) ++ return; ++ e2fsck_get_lock_context(ctx); ++ /* unlock write lock */ ++ pthread_rwlock_unlock(&global_ctx->fs_fix_rwlock); ++ /* get read lock again */ ++ pthread_rwlock_rdlock(&global_ctx->fs_fix_rwlock); ++} ++ ++void e2fsck_pass1_check_lock(e2fsck_t ctx) ++{ ++ if (!ctx->fs_need_locking) ++ return; ++ e2fsck_get_lock_context(ctx); ++ pthread_rwlock_rdlock(&global_ctx->fs_fix_rwlock); ++} ++ ++void e2fsck_pass1_check_unlock(e2fsck_t ctx) ++{ ++ if (!ctx->fs_need_locking) ++ return; ++ e2fsck_get_lock_context(ctx); ++ pthread_rwlock_unlock(&global_ctx->fs_fix_rwlock); ++} ++ ++void e2fsck_pass1_block_map_w_lock(e2fsck_t ctx) ++{ ++ if (!ctx->fs_need_locking) ++ return; ++ e2fsck_get_lock_context(ctx); ++ pthread_rwlock_wrlock(&global_ctx->fs_block_map_rwlock); ++} ++ ++void e2fsck_pass1_block_map_w_unlock(e2fsck_t ctx) ++{ ++ if (!ctx->fs_need_locking) ++ return; ++ e2fsck_get_lock_context(ctx); ++ pthread_rwlock_unlock(&global_ctx->fs_block_map_rwlock); ++} ++ ++void e2fsck_pass1_block_map_r_lock(e2fsck_t ctx) ++{ ++ if (!ctx->fs_need_locking) ++ return; ++ e2fsck_get_lock_context(ctx); ++ pthread_rwlock_rdlock(&global_ctx->fs_block_map_rwlock); ++} ++ ++void e2fsck_pass1_block_map_r_unlock(e2fsck_t ctx) ++{ ++ if (!ctx->fs_need_locking) ++ return; ++ e2fsck_get_lock_context(ctx); ++ pthread_rwlock_unlock(&global_ctx->fs_block_map_rwlock); ++ } ++#else ++void e2fsck_pass1_fix_lock(e2fsck_t ctx) ++{ ++ ++} ++ ++void e2fsck_pass1_fix_unlock(e2fsck_t ctx) ++{ ++ ++} ++void e2fsck_pass1_check_lock(e2fsck_t ctx) ++{ ++ ++} ++void e2fsck_pass1_check_unlock(e2fsck_t ctx) ++{ ++ ++} ++void e2fsck_pass1_block_map_w_lock(e2fsck_t ctx) ++{ ++ ++} ++ ++void e2fsck_pass1_block_map_w_unlock(e2fsck_t ctx) ++{ ++ ++} ++ ++void e2fsck_pass1_block_map_r_lock(e2fsck_t ctx) ++{ ++ ++} ++ ++void e2fsck_pass1_block_map_r_unlock(e2fsck_t ctx) ++{ ++ ++} ++#endif ++ + void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino, + struct ext2_inode * inode, int bufsize, + const char *proc) + { + errcode_t retval; + ++ e2fsck_pass1_fix_lock(ctx); + retval = ext2fs_write_inode_full(ctx->fs, ino, inode, bufsize); ++ e2fsck_pass1_fix_unlock(ctx); + if (retval) { + com_err("ext2fs_write_inode", retval, + _("while writing inode %lu in %s"), ino, proc); +@@ -525,7 +708,9 @@ void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino, + { + errcode_t retval; + ++ e2fsck_pass1_fix_lock(ctx); + retval = ext2fs_write_inode(ctx->fs, ino, inode); ++ e2fsck_pass1_fix_unlock(ctx); + if (retval) { + com_err("ext2fs_write_inode", retval, + _("while writing inode %lu in %s"), ino, proc); +diff --git a/lib/ext2fs/badblocks.c b/lib/ext2fs/badblocks.c +index 0f23983..3c9a608 100644 +--- a/lib/ext2fs/badblocks.c ++++ b/lib/ext2fs/badblocks.c +@@ -11,6 +11,7 @@ + + #include "config.h" + #include ++#include + #include + #if HAVE_UNISTD_H + #include +@@ -56,6 +57,75 @@ static errcode_t make_u32_list(int size, int num, __u32 *list, + return 0; + } + ++static inline int insert_ok(blk_t *array, int cnt, blk_t new) ++{ ++ return (cnt == 0 || array[cnt - 1] != new); ++} ++ ++/* ++ * Merge list from src to dest ++ */ ++static errcode_t merge_u32_list(ext2_u32_list src, ext2_u32_list dest) ++{ ++ errcode_t retval; ++ int src_count = src->num; ++ int dest_count = dest->num; ++ int size = src_count + dest_count; ++ int size_entry = sizeof(blk_t); ++ blk_t *array; ++ blk_t *src_array = src->list; ++ blk_t *dest_array = dest->list; ++ int src_index = 0; ++ int dest_index = 0; ++ int uniq_cnt = 0; ++ ++ if (src->num == 0) ++ return 0; ++ ++ retval = ext2fs_get_array(size, size_entry, &array); ++ if (retval) ++ return retval; ++ ++ /* ++ * It is possible that src list and dest list could be ++ * duplicated when merging badblocks. ++ */ ++ while (src_index < src_count || dest_index < dest_count) { ++ if (src_index >= src_count) { ++ for (; dest_index < dest_count; dest_index++) ++ if (insert_ok(array, uniq_cnt, dest_array[dest_index])) ++ array[uniq_cnt++] = dest_array[dest_index]; ++ break; ++ } ++ if (dest_index >= dest_count) { ++ for (; src_index < src_count; src_index++) ++ if (insert_ok(array, uniq_cnt, src_array[src_index])) ++ array[uniq_cnt++] = src_array[src_index]; ++ break; ++ } ++ if (src_array[src_index] < dest_array[dest_index]) { ++ if (insert_ok(array, uniq_cnt, src_array[src_index])) ++ array[uniq_cnt++] = src_array[src_index]; ++ src_index++; ++ } else if (src_array[src_index] > dest_array[dest_index]) { ++ if (insert_ok(array, uniq_cnt, dest_array[dest_index])) ++ array[uniq_cnt++] = dest_array[dest_index]; ++ dest_index++; ++ } else { ++ if (insert_ok(array, uniq_cnt, dest_array[dest_index])) ++ array[uniq_cnt++] = dest_array[dest_index]; ++ src_index++; ++ dest_index++; ++ } ++ } ++ ++ ext2fs_free_mem(&dest->list); ++ dest->list = array; ++ dest->num = uniq_cnt; ++ dest->size = size; ++ return 0; ++} ++ + + /* + * This procedure creates an empty u32 list. +@@ -79,13 +149,7 @@ errcode_t ext2fs_badblocks_list_create(ext2_badblocks_list *ret, int size) + */ + errcode_t ext2fs_u32_copy(ext2_u32_list src, ext2_u32_list *dest) + { +- errcode_t retval; +- +- retval = make_u32_list(src->size, src->num, src->list, dest); +- if (retval) +- return retval; +- (*dest)->badblocks_flags = src->badblocks_flags; +- return 0; ++ return make_u32_list(src->size, src->num, src->list, dest); + } + + errcode_t ext2fs_badblocks_copy(ext2_badblocks_list src, +@@ -95,6 +159,13 @@ errcode_t ext2fs_badblocks_copy(ext2_badblocks_list src, + (ext2_u32_list *) dest); + } + ++errcode_t ext2fs_badblocks_merge(ext2_badblocks_list src, ++ ext2_badblocks_list dest) ++{ ++ return merge_u32_list((ext2_u32_list) src, ++ (ext2_u32_list) dest); ++} ++ + /* + * This procedure frees a badblocks list. + * +diff --git a/lib/ext2fs/bitmaps.c b/lib/ext2fs/bitmaps.c +index 834a396..000df23 100644 +--- a/lib/ext2fs/bitmaps.c ++++ b/lib/ext2fs/bitmaps.c +@@ -45,6 +45,16 @@ errcode_t ext2fs_copy_bitmap(ext2fs_generic_bitmap src, + { + return (ext2fs_copy_generic_bmap(src, dest)); + } ++ ++errcode_t ext2fs_merge_bitmap(ext2fs_generic_bitmap src, ++ ext2fs_generic_bitmap dest, ++ ext2fs_generic_bitmap dup, ++ ext2fs_generic_bitmap dup_allowed) ++{ ++ return ext2fs_merge_generic_bmap(src, dest, dup, ++ dup_allowed); ++} ++ + void ext2fs_set_bitmap_padding(ext2fs_generic_bitmap map) + { + ext2fs_set_generic_bmap_padding(map); +diff --git a/lib/ext2fs/bitops.h b/lib/ext2fs/bitops.h +index 505b3c9..1facc8d 100644 +--- a/lib/ext2fs/bitops.h ++++ b/lib/ext2fs/bitops.h +@@ -120,6 +120,8 @@ extern int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap, + extern void ext2fs_set_bitmap_padding(ext2fs_generic_bitmap map); + extern __u32 ext2fs_get_generic_bitmap_start(ext2fs_generic_bitmap bitmap); + extern __u32 ext2fs_get_generic_bitmap_end(ext2fs_generic_bitmap bitmap); ++extern int ext2fs_test_block_bitmap_range2_valid(ext2fs_block_bitmap bitmap, ++ blk64_t block, unsigned int num); + + /* 64-bit versions */ + +diff --git a/lib/ext2fs/blkmap64_rb.c b/lib/ext2fs/blkmap64_rb.c +index 0df58dc..d7c88ae 100644 +--- a/lib/ext2fs/blkmap64_rb.c ++++ b/lib/ext2fs/blkmap64_rb.c +@@ -977,11 +977,76 @@ static void rb_print_stats(ext2fs_generic_bitmap_64 bitmap EXT2FS_ATTR((unused)) + } + #endif + ++static errcode_t rb_merge_bmap(ext2fs_generic_bitmap_64 src, ++ ext2fs_generic_bitmap_64 dest, ++ ext2fs_generic_bitmap_64 dup, ++ ext2fs_generic_bitmap_64 dup_allowed) ++{ ++ struct ext2fs_rb_private *src_bp, *dest_bp, *dup_bp = NULL; ++ struct bmap_rb_extent *src_ext; ++ struct rb_node *src_node; ++ errcode_t retval = 0; ++ int dup_found = 0; ++ __u64 i; ++ ++ src_bp = (struct ext2fs_rb_private *) src->private; ++ dest_bp = (struct ext2fs_rb_private *) dest->private; ++ if (dup) ++ dup_bp = (struct ext2fs_rb_private *)dup->private; ++ src_bp->rcursor = NULL; ++ dest_bp->rcursor = NULL; ++ ++ src_node = ext2fs_rb_first(&src_bp->root); ++ while (src_node) { ++ src_ext = node_to_extent(src_node); ++ retval = rb_test_clear_bmap_extent(dest, ++ src_ext->start + src->start, ++ src_ext->count); ++ if (retval) { ++ rb_insert_extent(src_ext->start, src_ext->count, ++ dest_bp); ++ goto next; ++ } ++ ++ /* unlikely case, do it one by one block */ ++ for (i = src_ext->start; ++ i < src_ext->start + src_ext->count; i++) { ++ retval = rb_test_clear_bmap_extent(dest, i + src->start, 1); ++ if (retval) { ++ rb_insert_extent(i, 1, dest_bp); ++ continue; ++ } ++ if (dup_allowed) { ++ retval = rb_test_clear_bmap_extent(dup_allowed, ++ i + src->start, 1); ++ /* not existed in dup_allowed */ ++ if (retval) { ++ dup_found = 1; ++ if (dup_bp) ++ rb_insert_extent(i, 1, dup_bp); ++ } /* else we conside it not duplicated */ ++ } else { ++ if (dup_bp) ++ rb_insert_extent(i, 1, dup_bp); ++ dup_found = 1; ++ } ++ } ++next: ++ src_node = ext2fs_rb_next(src_node); ++ } ++ ++ if (dup_found && dup) ++ return EEXIST; ++ ++ return 0; ++} ++ + struct ext2_bitmap_ops ext2fs_blkmap64_rbtree = { + .type = EXT2FS_BMAP64_RBTREE, + .new_bmap = rb_new_bmap, + .free_bmap = rb_free_bmap, + .copy_bmap = rb_copy_bmap, ++ .merge_bmap = rb_merge_bmap, + .resize_bmap = rb_resize_bmap, + .mark_bmap = rb_mark_bmap, + .unmark_bmap = rb_unmark_bmap, +diff --git a/lib/ext2fs/bmap64.h b/lib/ext2fs/bmap64.h +index de33454..555193e 100644 +--- a/lib/ext2fs/bmap64.h ++++ b/lib/ext2fs/bmap64.h +@@ -72,6 +72,10 @@ struct ext2_bitmap_ops { + void (*free_bmap)(ext2fs_generic_bitmap_64 bitmap); + errcode_t (*copy_bmap)(ext2fs_generic_bitmap_64 src, + ext2fs_generic_bitmap_64 dest); ++ errcode_t (*merge_bmap)(ext2fs_generic_bitmap_64 src, ++ ext2fs_generic_bitmap_64 dest, ++ ext2fs_generic_bitmap_64 dup, ++ ext2fs_generic_bitmap_64 dup_allowed); + errcode_t (*resize_bmap)(ext2fs_generic_bitmap_64 bitmap, + __u64 new_end, + __u64 new_real_end); +diff --git a/lib/ext2fs/dblist.c b/lib/ext2fs/dblist.c +index bbdb221..c4e712f 100644 +--- a/lib/ext2fs/dblist.c ++++ b/lib/ext2fs/dblist.c +@@ -58,6 +58,8 @@ static errcode_t make_dblist(ext2_filsys fs, ext2_ino_t size, + if (retval) + goto cleanup; + dblist->size = (num_dirs * 2) + 12; ++ if (fs->fs_num_threads) ++ dblist->size /= fs->fs_num_threads; + } + len = (size_t) sizeof(struct ext2_db_entry2) * dblist->size; + dblist->count = count; +@@ -119,6 +121,42 @@ errcode_t ext2fs_copy_dblist(ext2_dblist src, ext2_dblist *dest) + return 0; + } + ++/* ++ * Merge a directory block list @src to @dest ++ */ ++errcode_t ext2fs_merge_dblist(ext2_dblist src, ext2_dblist dest) ++{ ++ unsigned long long src_count = src->count; ++ unsigned long long dest_count = dest->count; ++ unsigned long long size = src_count + dest_count; ++ size_t size_entry = sizeof(struct ext2_db_entry2); ++ struct ext2_db_entry2 *array, *array2; ++ errcode_t retval; ++ ++ if (src_count == 0) ++ return 0; ++ ++ if (src->sorted || (dest->sorted && dest_count != 0)) ++ return EINVAL; ++ ++ retval = ext2fs_get_array(size, size_entry, &array); ++ if (retval) ++ return retval; ++ ++ array2 = array; ++ memcpy(array, src->list, src_count * size_entry); ++ array += src_count; ++ memcpy(array, dest->list, dest_count * size_entry); ++ ext2fs_free_mem(&dest->list); ++ ++ dest->list = array2; ++ dest->count = src_count + dest_count; ++ dest->size = size; ++ dest->sorted = 0; ++ ++ return 0; ++} ++ + /* + * Close a directory block list + * +diff --git a/lib/ext2fs/ext2_err.et.in b/lib/ext2fs/ext2_err.et.in +index cf0e00e..860b570 100644 +--- a/lib/ext2fs/ext2_err.et.in ++++ b/lib/ext2fs/ext2_err.et.in +@@ -551,4 +551,7 @@ ec EXT2_ET_NO_GDESC, + ec EXT2_FILSYS_CORRUPTED, + "The internal ext2_filsys data structure appears to be corrupted" + ++ec EXT2_ET_SCAN_FINISHED, ++ "Scanning finished" ++ + end +diff --git a/lib/ext2fs/ext2_io.h b/lib/ext2fs/ext2_io.h +index 8fe5b32..8cc355b 100644 +--- a/lib/ext2fs/ext2_io.h ++++ b/lib/ext2fs/ext2_io.h +@@ -82,6 +82,7 @@ struct struct_io_manager { + errcode_t (*write_blk)(io_channel channel, unsigned long block, + int count, const void *data); + errcode_t (*flush)(io_channel channel); ++ errcode_t (*flush_cleanup)(io_channel channel); + errcode_t (*write_byte)(io_channel channel, unsigned long offset, + int count, const void *data); + errcode_t (*set_option)(io_channel channel, const char *option, +@@ -116,6 +117,7 @@ struct struct_io_manager { + #define io_channel_read_blk(c,b,n,d) ((c)->manager->read_blk((c),b,n,d)) + #define io_channel_write_blk(c,b,n,d) ((c)->manager->write_blk((c),b,n,d)) + #define io_channel_flush(c) ((c)->manager->flush((c))) ++#define io_channel_flush_cleanup(c) ((c)->manager->flush_cleanup((c))) + #define io_channel_bumpcount(c) ((c)->refcount++) + + /* io_manager.c */ +diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h +index 6b318e3..06a1387 100644 +--- a/lib/ext2fs/ext2fs.h ++++ b/lib/ext2fs/ext2fs.h +@@ -273,7 +273,7 @@ struct struct_ext2_filsys { + time_t now; + int cluster_ratio_bits; + __u16 default_bitmap_type; +- __u16 pad; ++ __u16 fs_num_threads; + /* + * Reserved for future expansion + */ +@@ -841,6 +841,8 @@ extern int ext2fs_badblocks_list_iterate(ext2_badblocks_iterate iter, + extern void ext2fs_badblocks_list_iterate_end(ext2_badblocks_iterate iter); + extern errcode_t ext2fs_badblocks_copy(ext2_badblocks_list src, + ext2_badblocks_list *dest); ++extern errcode_t ext2fs_badblocks_merge(ext2_badblocks_list src, ++ ext2_badblocks_list dest); + extern int ext2fs_badblocks_equal(ext2_badblocks_list bb1, + ext2_badblocks_list bb2); + extern int ext2fs_u32_list_count(ext2_u32_list bb); +@@ -864,6 +866,10 @@ extern void ext2fs_free_block_bitmap(ext2fs_block_bitmap bitmap); + extern void ext2fs_free_inode_bitmap(ext2fs_inode_bitmap bitmap); + extern errcode_t ext2fs_copy_bitmap(ext2fs_generic_bitmap src, + ext2fs_generic_bitmap *dest); ++errcode_t ext2fs_merge_bitmap(ext2fs_generic_bitmap src, ++ ext2fs_generic_bitmap dest, ++ ext2fs_generic_bitmap dup, ++ ext2fs_generic_bitmap dup_allowed); + extern errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs, + const char *descr, + ext2fs_block_bitmap *ret); +@@ -1137,6 +1143,7 @@ extern errcode_t ext2fs_add_dir_block(ext2_dblist dblist, ext2_ino_t ino, + blk_t blk, int blockcnt); + extern errcode_t ext2fs_add_dir_block2(ext2_dblist dblist, ext2_ino_t ino, + blk64_t blk, e2_blkcnt_t blockcnt); ++extern errcode_t ext2fs_merge_dblist(ext2_dblist src, ext2_dblist dest); + extern void ext2fs_dblist_sort(ext2_dblist dblist, + EXT2_QSORT_TYPE (*sortfunc)(const void *, + const void *)); +@@ -1459,6 +1466,10 @@ void ext2fs_set_generic_bmap_padding(ext2fs_generic_bitmap bmap); + errcode_t ext2fs_resize_generic_bmap(ext2fs_generic_bitmap bmap, + __u64 new_end, + __u64 new_real_end); ++errcode_t ext2fs_merge_generic_bmap(ext2fs_generic_bitmap gen_src, ++ ext2fs_generic_bitmap gen_dest, ++ ext2fs_generic_bitmap gen_dup, ++ ext2fs_generic_bitmap dup_allowed); + errcode_t ext2fs_compare_generic_bmap(errcode_t neq, + ext2fs_generic_bitmap bm1, + ext2fs_generic_bitmap bm2); +@@ -1530,6 +1541,7 @@ extern errcode_t ext2fs_icount_decrement(ext2_icount_t icount, ext2_ino_t ino, + __u16 *ret); + extern errcode_t ext2fs_icount_store(ext2_icount_t icount, ext2_ino_t ino, + __u16 count); ++extern errcode_t ext2fs_icount_merge(ext2_icount_t src, ext2_icount_t dest); + extern ext2_ino_t ext2fs_get_icount_size(ext2_icount_t icount); + errcode_t ext2fs_icount_validate(ext2_icount_t icount, FILE *); + +@@ -1687,6 +1699,9 @@ extern errcode_t ext2fs_open2(const char *name, const char *io_options, + int flags, int superblock, + unsigned int block_size, io_manager manager, + ext2_filsys *ret_fs); ++errcode_t ext2fs_open_channel(ext2_filsys fs, const char *io_options, ++ io_manager manager, int flags, ++ int blocksize); + /* + * The dgrp_t argument to these two functions is not actually a group number + * but a block number offset within a group table! Convert with the formula +diff --git a/lib/ext2fs/ext2fsP.h b/lib/ext2fs/ext2fsP.h +index a20a050..d2045af 100644 +--- a/lib/ext2fs/ext2fsP.h ++++ b/lib/ext2fs/ext2fsP.h +@@ -34,7 +34,6 @@ struct ext2_struct_u32_list { + int num; + int size; + __u32 *list; +- int badblocks_flags; + }; + + struct ext2_struct_u32_iterate { +diff --git a/lib/ext2fs/gen_bitmap64.c b/lib/ext2fs/gen_bitmap64.c +index d980908..cb78308 100644 +--- a/lib/ext2fs/gen_bitmap64.c ++++ b/lib/ext2fs/gen_bitmap64.c +@@ -346,6 +346,35 @@ errcode_t ext2fs_copy_generic_bmap(ext2fs_generic_bitmap gen_src, + return 0; + } + ++errcode_t ext2fs_merge_generic_bmap(ext2fs_generic_bitmap gen_src, ++ ext2fs_generic_bitmap gen_dest, ++ ext2fs_generic_bitmap gen_dup, ++ ext2fs_generic_bitmap gen_dup_allowed) ++{ ++ ext2fs_generic_bitmap_64 src = (ext2fs_generic_bitmap_64)gen_src; ++ ext2fs_generic_bitmap_64 dest = (ext2fs_generic_bitmap_64)gen_dest; ++ ext2fs_generic_bitmap_64 dup = (ext2fs_generic_bitmap_64)gen_dup; ++ ext2fs_generic_bitmap_64 dup_allowed = (ext2fs_generic_bitmap_64)gen_dup_allowed; ++ ++ if (!src || !dest) ++ return EINVAL; ++ ++ if (!EXT2FS_IS_64_BITMAP(src) || !EXT2FS_IS_64_BITMAP(dest) || ++ (dup && !EXT2FS_IS_64_BITMAP(dup)) || ++ (dup_allowed && !EXT2FS_IS_64_BITMAP(dup_allowed))) ++ return EINVAL; ++ ++ if (src->bitmap_ops != dest->bitmap_ops || ++ (dup && src->bitmap_ops != dup->bitmap_ops) || ++ (dup_allowed && src->bitmap_ops != dup_allowed->bitmap_ops)) ++ return EINVAL; ++ ++ if (src->bitmap_ops->merge_bmap == NULL) ++ return EOPNOTSUPP; ++ ++ return src->bitmap_ops->merge_bmap(src, dest, dup, dup_allowed); ++} ++ + errcode_t ext2fs_resize_generic_bmap(ext2fs_generic_bitmap gen_bmap, + __u64 new_end, + __u64 new_real_end) +@@ -698,6 +727,39 @@ int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap gen_bmap, + return bmap->bitmap_ops->test_clear_bmap_extent(bmap, block, num); + } + ++int ext2fs_test_block_bitmap_range2_valid(ext2fs_block_bitmap bitmap, ++ blk64_t block, unsigned int num) ++{ ++ ext2fs_generic_bitmap_64 bmap = (ext2fs_generic_bitmap_64)bitmap; ++ __u64 end = block + num; ++ ++ if (!bmap) ++ return 0; ++ ++ if (EXT2FS_IS_32_BITMAP(bmap)) { ++ if ((block & ~0xffffffffULL) || ++ ((block+num-1) & ~0xffffffffULL)) { ++ return 0; ++ } ++ } ++ ++ if (!EXT2FS_IS_64_BITMAP(bmap)) ++ return 0; ++ ++ /* convert to clusters if necessary */ ++ block >>= bmap->cluster_bits; ++ end += (1 << bmap->cluster_bits) - 1; ++ end >>= bmap->cluster_bits; ++ num = end - block; ++ ++ if ((block < bmap->start) || (block > bmap->end) || ++ (block+num-1 > bmap->end)) ++ return 0; ++ ++ return 1; ++} ++ ++ + void ext2fs_mark_block_bitmap_range2(ext2fs_block_bitmap gen_bmap, + blk64_t block, unsigned int num) + { +diff --git a/lib/ext2fs/icount.c b/lib/ext2fs/icount.c +index 888a90b..48665c7 100644 +--- a/lib/ext2fs/icount.c ++++ b/lib/ext2fs/icount.c +@@ -13,6 +13,7 @@ + #if HAVE_UNISTD_H + #include + #endif ++#include + #include + #include + #include +@@ -236,6 +237,8 @@ errcode_t ext2fs_create_icount_tdb(ext2_filsys fs EXT2FS_NO_TDB_UNUSED, + * value. + */ + num_inodes = fs->super->s_inodes_count - fs->super->s_free_inodes_count; ++ if (fs->fs_num_threads) ++ num_inodes /= fs->fs_num_threads; + + icount->tdb = tdb_open(fn, num_inodes, TDB_NOLOCK | TDB_NOSYNC, + O_RDWR | O_CREAT | O_TRUNC, 0600); +@@ -287,6 +290,8 @@ errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, unsigned int size, + if (retval) + goto errout; + icount->size += fs->super->s_inodes_count / 50; ++ if (fs->fs_num_threads) ++ icount->size /= fs->fs_num_threads; + } + + bytes = (size_t) (icount->size * sizeof(struct ext2_icount_el)); +@@ -701,6 +706,108 @@ errcode_t ext2fs_icount_store(ext2_icount_t icount, ext2_ino_t ino, + return 0; + } + ++errcode_t ext2fs_icount_merge_full_map(ext2_icount_t src, ext2_icount_t dest) ++{ ++ /* TODO: add the support for full map */ ++ return EOPNOTSUPP; ++} ++ ++errcode_t ext2fs_icount_merge_el(ext2_icount_t src, ext2_icount_t dest) ++{ ++ int src_count = src->count; ++ int dest_count = dest->count; ++ int size = src_count + dest_count; ++ int size_entry = sizeof(struct ext2_icount_el); ++ struct ext2_icount_el *array; ++ struct ext2_icount_el *array_ptr; ++ struct ext2_icount_el *src_array = src->list; ++ struct ext2_icount_el *dest_array = dest->list; ++ int src_index = 0; ++ int dest_index = 0; ++ errcode_t retval; ++ ++ if (src_count == 0) ++ return 0; ++ ++ retval = ext2fs_get_array(size, size_entry, &array); ++ if (retval) ++ return retval; ++ ++ array_ptr = array; ++ /* ++ * This can be improved by binary search and memcpy, but codes ++ * would be more complex. And if number of bad blocks is small, ++ * the optimization won't improve performance a lot. ++ */ ++ while (src_index < src_count || dest_index < dest_count) { ++ if (src_index >= src_count) { ++ memcpy(array_ptr, &dest_array[dest_index], ++ (dest_count - dest_index) * size_entry); ++ break; ++ } ++ if (dest_index >= dest_count) { ++ memcpy(array_ptr, &src_array[src_index], ++ (src_count - src_index) * size_entry); ++ break; ++ } ++ if (src_array[src_index].ino < dest_array[dest_index].ino) { ++ *array_ptr = src_array[src_index]; ++ src_index++; ++ } else { ++ assert(src_array[src_index].ino > ++ dest_array[dest_index].ino); ++ *array_ptr = dest_array[dest_index]; ++ dest_index++; ++ } ++ array_ptr++; ++ } ++ ++ ext2fs_free_mem(&dest->list); ++ dest->list = array; ++ dest->count = src_count + dest_count; ++ dest->size = size; ++ dest->last_lookup = NULL; ++ return 0; ++} ++ ++errcode_t ext2fs_icount_merge(ext2_icount_t src, ext2_icount_t dest) ++{ ++ errcode_t retval; ++ ++ if (src->fullmap && !dest->fullmap) ++ return EINVAL; ++ ++ if (!src->fullmap && dest->fullmap) ++ return EINVAL; ++ ++ if (src->multiple && !dest->multiple) ++ return EINVAL; ++ ++ if (!src->multiple && dest->multiple) ++ return EINVAL; ++ ++ if (src->fullmap) ++ return ext2fs_icount_merge_full_map(src, dest); ++ ++ retval = ext2fs_merge_bitmap(src->single, dest->single, NULL, ++ NULL); ++ if (retval) ++ return retval; ++ ++ if (src->multiple) { ++ retval = ext2fs_merge_bitmap(src->multiple, dest->multiple, ++ NULL, NULL); ++ if (retval) ++ return retval; ++ } ++ ++ retval = ext2fs_icount_merge_el(src, dest); ++ if (retval) ++ return retval; ++ ++ return 0; ++} ++ + ext2_ino_t ext2fs_get_icount_size(ext2_icount_t icount) + { + if (!icount || icount->magic != EXT2_ET_MAGIC_ICOUNT) +diff --git a/lib/ext2fs/openfs.c b/lib/ext2fs/openfs.c +index 5ec8ed5..b08eaa3 100644 +--- a/lib/ext2fs/openfs.c ++++ b/lib/ext2fs/openfs.c +@@ -99,6 +99,40 @@ static void block_sha_map_free_entry(void *data) + return; + } + ++errcode_t ext2fs_open_channel(ext2_filsys fs, const char *io_options, ++ io_manager manager, int flags, ++ int blocksize) ++{ ++ errcode_t retval; ++ unsigned int io_flags = 0; ++ ++ if (flags & EXT2_FLAG_RW) ++ io_flags |= IO_FLAG_RW; ++ if (flags & EXT2_FLAG_EXCLUSIVE) ++ io_flags |= IO_FLAG_EXCLUSIVE; ++ if (flags & EXT2_FLAG_DIRECT_IO) ++ io_flags |= IO_FLAG_DIRECT_IO; ++ if (flags & EXT2_FLAG_THREADS) ++ io_flags |= IO_FLAG_THREADS; ++ retval = manager->open(fs->device_name, io_flags, &fs->io); ++ if (retval) ++ return retval; ++ ++ if (io_options && ++ (retval = io_channel_set_options(fs->io, io_options))) ++ goto out_close; ++ fs->image_io = fs->io; ++ fs->io->app_data = fs; ++ ++ if (blocksize > 0) ++ io_channel_set_blksize(fs->io, blocksize); ++ ++ return 0; ++out_close: ++ io_channel_close(fs->io); ++ return retval; ++} ++ + /* + * Note: if superblock is non-zero, block-size must also be non-zero. + * Superblock and block_size can be zero to use the default size. +@@ -122,7 +156,7 @@ errcode_t ext2fs_open2(const char *name, const char *io_options, + errcode_t retval; + unsigned long i, first_meta_bg; + __u32 features; +- unsigned int blocks_per_group, io_flags; ++ unsigned int blocks_per_group; + blk64_t group_block, blk; + char *dest, *cp; + int group_zero_adjust = 0; +@@ -163,23 +197,9 @@ errcode_t ext2fs_open2(const char *name, const char *io_options, + io_options = cp; + } + +- io_flags = 0; +- if (flags & EXT2_FLAG_RW) +- io_flags |= IO_FLAG_RW; +- if (flags & EXT2_FLAG_EXCLUSIVE) +- io_flags |= IO_FLAG_EXCLUSIVE; +- if (flags & EXT2_FLAG_DIRECT_IO) +- io_flags |= IO_FLAG_DIRECT_IO; +- if (flags & EXT2_FLAG_THREADS) +- io_flags |= IO_FLAG_THREADS; +- retval = manager->open(fs->device_name, io_flags, &fs->io); ++ retval = ext2fs_open_channel(fs, io_options, manager, flags, 0); + if (retval) + goto cleanup; +- if (io_options && +- (retval = io_channel_set_options(fs->io, io_options))) +- goto cleanup; +- fs->image_io = fs->io; +- fs->io->app_data = fs; + retval = io_channel_alloc_buf(fs->io, -SUPERBLOCK_SIZE, &fs->super); + if (retval) + goto cleanup; +diff --git a/lib/ext2fs/undo_io.c b/lib/ext2fs/undo_io.c +index eb56f53..267fa38 100644 +--- a/lib/ext2fs/undo_io.c ++++ b/lib/ext2fs/undo_io.c +@@ -1022,6 +1022,24 @@ static errcode_t undo_flush(io_channel channel) + return retval; + } + ++/* ++ * Flush data buffers to disk and cleanup the cache. ++ */ ++static errcode_t undo_flush_cleanup(io_channel channel) ++{ ++ errcode_t retval = 0; ++ struct undo_private_data *data; ++ ++ EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); ++ data = (struct undo_private_data *) channel->private_data; ++ EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); ++ ++ if (data->real) ++ retval = io_channel_flush_cleanup(data->real); ++ ++ return retval; ++} ++ + static errcode_t undo_set_option(io_channel channel, const char *option, + const char *arg) + { +@@ -1093,6 +1111,7 @@ static struct struct_io_manager struct_undo_manager = { + .read_blk = undo_read_blk, + .write_blk = undo_write_blk, + .flush = undo_flush, ++ .flush_cleanup = undo_flush_cleanup, + .write_byte = undo_write_byte, + .set_option = undo_set_option, + .get_stats = undo_get_stats, +diff --git a/lib/ext2fs/unix_io.c b/lib/ext2fs/unix_io.c +index 47f7f98..56774b4 100644 +--- a/lib/ext2fs/unix_io.c ++++ b/lib/ext2fs/unix_io.c +@@ -1201,9 +1201,9 @@ static errcode_t unix_write_byte(io_channel channel, unsigned long offset, + } + + /* +- * Flush data buffers to disk. ++ * Flush data buffers to disk and invalidate cache if needed + */ +-static errcode_t unix_flush(io_channel channel) ++static errcode_t _unix_flush(io_channel channel, int invalidate) + { + struct unix_private_data *data; + errcode_t retval = 0; +@@ -1213,7 +1213,7 @@ static errcode_t unix_flush(io_channel channel) + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + #ifndef NO_IO_CACHE +- retval = flush_cached_blocks(channel, data, 0); ++ retval = flush_cached_blocks(channel, data, invalidate); + #endif + #ifdef HAVE_FSYNC + if (!retval && fsync(data->dev) != 0) +@@ -1222,6 +1222,22 @@ static errcode_t unix_flush(io_channel channel) + return retval; + } + ++/* ++ * Flush data buffers to disk. ++ */ ++static errcode_t unix_flush(io_channel channel) ++{ ++ return _unix_flush(channel, 0); ++} ++ ++/* ++ * Flush data buffers to disk and invalidate cache. ++ */ ++static errcode_t unix_flush_cleanup(io_channel channel) ++{ ++ return _unix_flush(channel, 1); ++} ++ + static errcode_t unix_set_option(io_channel channel, const char *option, + const char *arg) + { +@@ -1411,6 +1427,7 @@ static struct struct_io_manager struct_unix_manager = { + .discard = unix_discard, + .cache_readahead = unix_cache_readahead, + .zeroout = unix_zeroout, ++ .flush_cleanup = unix_flush_cleanup, + }; + + io_manager unix_io_manager = &struct_unix_manager; +@@ -1432,6 +1449,7 @@ static struct struct_io_manager struct_unixfd_manager = { + .discard = unix_discard, + .cache_readahead = unix_cache_readahead, + .zeroout = unix_zeroout, ++ .flush_cleanup = unix_flush_cleanup, + }; + + io_manager unixfd_io_manager = &struct_unixfd_manager; +diff --git a/lib/support/mkquota.c b/lib/support/mkquota.c +index 5de7c48..a60f022 100644 +--- a/lib/support/mkquota.c ++++ b/lib/support/mkquota.c +@@ -615,6 +615,45 @@ out: + return err; + } + ++static errcode_t merge_usage(dict_t *dest, dict_t *src) ++{ ++ dnode_t *n; ++ struct dquot *src_dq, *dest_dq; ++ ++ for (n = dict_first(src); n; n = dict_next(src, n)) { ++ src_dq = dnode_get(n); ++ if (!src_dq) ++ continue; ++ dest_dq = get_dq(dest, src_dq->dq_id); ++ if (dest_dq == NULL) ++ return -ENOMEM; ++ dest_dq->dq_dqb.dqb_curspace += src_dq->dq_dqb.dqb_curspace; ++ dest_dq->dq_dqb.dqb_curinodes += src_dq->dq_dqb.dqb_curinodes; ++ } ++ ++ return 0; ++} ++ ++ ++errcode_t quota_merge_and_update_usage(quota_ctx_t dest_qctx, ++ quota_ctx_t src_qctx) ++{ ++ dict_t *dict; ++ enum quota_type qtype; ++ errcode_t retval = 0; ++ ++ for (qtype = 0; qtype < MAXQUOTAS; qtype++) { ++ dict = src_qctx->quota_dict[qtype]; ++ if (!dict) ++ continue; ++ retval = merge_usage(dest_qctx->quota_dict[qtype], dict); ++ if (retval) ++ break; ++ } ++ ++ return retval; ++} ++ + /* + * Compares the measured quota in qctx->quota_dict with that in the quota inode + * on disk and updates the limits in qctx->quota_dict. 'usage_inconsistent' is +diff --git a/lib/support/quotaio.h b/lib/support/quotaio.h +index 84fac35..240a076 100644 +--- a/lib/support/quotaio.h ++++ b/lib/support/quotaio.h +@@ -40,6 +40,7 @@ + #include "ext2fs/ext2_fs.h" + #include "ext2fs/ext2fs.h" + #include "dqblk_v2.h" ++#include "support/dict.h" + + typedef int64_t qsize_t; /* Type in which we store size limitations */ + +@@ -236,6 +237,8 @@ int quota_file_exists(ext2_filsys fs, enum quota_type qtype); + void quota_set_sb_inum(ext2_filsys fs, ext2_ino_t ino, enum quota_type qtype); + errcode_t quota_compare_and_update(quota_ctx_t qctx, enum quota_type qtype, + int *usage_inconsistent); ++errcode_t quota_merge_and_update_usage(quota_ctx_t dest_qctx, ++ quota_ctx_t src_qctx); + int parse_quota_opts(const char *opts, int (*func)(char *)); + + /* parse_qtype.c */ +diff --git a/tests/f_itable_collision/expect.1 b/tests/f_itable_collision/expect.1 +index 01c85d4..7e98baa 100644 +--- a/tests/f_itable_collision/expect.1 ++++ b/tests/f_itable_collision/expect.1 +@@ -1,6 +1,5 @@ + Pass 1: Checking inodes, blocks, and sizes + Inode 12 block 37 conflicts with critical metadata, skipping block checks. +-Illegal block number passed to ext2fs_test_block_bitmap #268435455 for in-use block map + Illegal block number passed to ext2fs_mark_block_bitmap #268435455 for in-use block map + Inode 12, i_blocks is 48, should be 56. Fix? yes + +@@ -27,9 +26,7 @@ Clear inode? yes + Restarting e2fsck from the beginning... + Pass 1: Checking inodes, blocks, and sizes + Inode 12 block 37 conflicts with critical metadata, skipping block checks. +-Illegal block number passed to ext2fs_test_block_bitmap #4294967294 for in-use block map + Illegal block number passed to ext2fs_mark_block_bitmap #4294967294 for in-use block map +-Illegal block number passed to ext2fs_test_block_bitmap #268435455 for in-use block map + Illegal block number passed to ext2fs_mark_block_bitmap #268435455 for in-use block map + + Running additional passes to resolve blocks claimed by more than one inode... +diff --git a/tests/f_multithread/expect.1 b/tests/f_multithread/expect.1 +new file mode 100644 +index 0000000..4db68d9 +--- /dev/null ++++ b/tests/f_multithread/expect.1 +@@ -0,0 +1,25 @@ ++ext2fs_open2: Bad magic number in super-block ++../e2fsck/e2fsck: Superblock invalid, trying backup blocks... ++Pass 1: Checking inodes, blocks, and sizes ++[Thread 0] Scan group range [0, 2) ++[Thread 0] Scanned group range [0, 2), inodes 3008 ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++Free blocks count wrong for group #0 (7987, counted=7982). ++Fix? yes ++ ++Free blocks count wrong (11602, counted=11597). ++Fix? yes ++ ++Free inodes count wrong for group #0 (1493, counted=1488). ++Fix? yes ++ ++Free inodes count wrong (2997, counted=2992). ++Fix? yes ++ ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++test_filesys: 16/3008 files (0.0% non-contiguous), 403/12000 blocks ++Exit status is 1 +diff --git a/tests/f_multithread/expect.2 b/tests/f_multithread/expect.2 +new file mode 100644 +index 0000000..a833aef +--- /dev/null ++++ b/tests/f_multithread/expect.2 +@@ -0,0 +1,7 @@ ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++test_filesys: 16/3008 files (0.0% non-contiguous), 403/12000 blocks ++Exit status is 0 +diff --git a/tests/f_multithread/image.gz b/tests/f_multithread/image.gz +new file mode 120000 +index 0000000..0fd4001 +--- /dev/null ++++ b/tests/f_multithread/image.gz +@@ -0,0 +1 @@ ++../f_zero_super/image.gz +\ No newline at end of file +diff --git a/tests/f_multithread/name b/tests/f_multithread/name +new file mode 100644 +index 0000000..df838ea +--- /dev/null ++++ b/tests/f_multithread/name +@@ -0,0 +1 @@ ++test "e2fsck -m" option +\ No newline at end of file +diff --git a/tests/f_multithread/script b/tests/f_multithread/script +new file mode 100644 +index 0000000..83cd0f0 +--- /dev/null ++++ b/tests/f_multithread/script +@@ -0,0 +1,4 @@ ++FSCK_OPT="-fy -m1" ++SECOND_FSCK_OPT=-yf ++ ++. $cmd_dir/run_e2fsck +diff --git a/tests/f_multithread_logfile/expect.1 b/tests/f_multithread_logfile/expect.1 +new file mode 100644 +index 0000000..4db68d9 +--- /dev/null ++++ b/tests/f_multithread_logfile/expect.1 +@@ -0,0 +1,25 @@ ++ext2fs_open2: Bad magic number in super-block ++../e2fsck/e2fsck: Superblock invalid, trying backup blocks... ++Pass 1: Checking inodes, blocks, and sizes ++[Thread 0] Scan group range [0, 2) ++[Thread 0] Scanned group range [0, 2), inodes 3008 ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++Free blocks count wrong for group #0 (7987, counted=7982). ++Fix? yes ++ ++Free blocks count wrong (11602, counted=11597). ++Fix? yes ++ ++Free inodes count wrong for group #0 (1493, counted=1488). ++Fix? yes ++ ++Free inodes count wrong (2997, counted=2992). ++Fix? yes ++ ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++test_filesys: 16/3008 files (0.0% non-contiguous), 403/12000 blocks ++Exit status is 1 +diff --git a/tests/f_multithread_logfile/image.gz b/tests/f_multithread_logfile/image.gz +new file mode 120000 +index 0000000..0fd4001 +--- /dev/null ++++ b/tests/f_multithread_logfile/image.gz +@@ -0,0 +1 @@ ++../f_zero_super/image.gz +\ No newline at end of file +diff --git a/tests/f_multithread_logfile/name b/tests/f_multithread_logfile/name +new file mode 100644 +index 0000000..faaabc3 +--- /dev/null ++++ b/tests/f_multithread_logfile/name +@@ -0,0 +1 @@ ++test "e2fsck -m" option works with "-E log_filename=" +diff --git a/tests/f_multithread_logfile/script b/tests/f_multithread_logfile/script +new file mode 100644 +index 0000000..dbb6531 +--- /dev/null ++++ b/tests/f_multithread_logfile/script +@@ -0,0 +1,32 @@ ++LOG_FNAME="f_multithread_logfile_xxx" ++FSCK_OPT="-fy -m1 -y -E log_filename=$LOG_FNAME" ++SKIP_VERIFY="true" ++ONE_PASS_ONLY="true" ++SKIP_CLEANUP="true" ++ ++rm -f $LOG_FNAME.* $LOG_FNAME ++ ++. $cmd_dir/run_e2fsck ++ ++rm -f $test_name.ok $test_name.failed ++cmp -s $OUT1 $EXP1 ++status1=$? ++ ++if [ "$status1" -eq 0 ]; then ++ if [ ! -f $LOG_FNAME -o ! -f $LOG_FNAME.0 ]; then ++ echo "$LOG_FNAME or $LOG_FNAME.0 is not created" > $test_name.failed ++ echo "$test_name: $test_description: failed" ++ else ++ echo "$test_name: $test_description: ok" ++ touch $test_name.ok ++ fi ++else ++ diff $DIFF_OPTS $test_dir/expect.1 \ ++ $test_name.1.log >> $test_name.failed ++ echo "$test_name: $test_description: failed" ++fi ++ ++unset IMAGE FSCK_OPT SECOND_FSCK_OPT OUT1 OUT2 EXP1 EXP2 ++unset SKIP_VERIFY SKIP_CLEANUP SKIP_GUNZIP ONE_PASS_ONLY PREP_CMD ++unset DESCRIPTION SKIP_UNLINK AFTER_CMD PASS_ZERO ++unset LOG_FINAME +diff --git a/tests/f_multithread_no/expect.1 b/tests/f_multithread_no/expect.1 +new file mode 100644 +index 0000000..eda2fca +--- /dev/null ++++ b/tests/f_multithread_no/expect.1 +@@ -0,0 +1,26 @@ ++ext2fs_open2: Bad magic number in super-block ++../e2fsck/e2fsck: Superblock invalid, trying backup blocks... ++Pass 1: Checking inodes, blocks, and sizes ++[Thread 0] Scan group range [0, 2) ++[Thread 0] Scanned group range [0, 2), inodes 3008 ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++Free blocks count wrong for group #0 (7987, counted=7982). ++Fix? no ++ ++Free blocks count wrong (11602, counted=11597). ++Fix? no ++ ++Free inodes count wrong for group #0 (1493, counted=1488). ++Fix? no ++ ++Free inodes count wrong (2997, counted=2992). ++Fix? no ++ ++ ++test_filesys: ********** WARNING: Filesystem still has errors ********** ++ ++test_filesys: 11/3008 files (0.0% non-contiguous), 398/12000 blocks ++Exit status is 4 +diff --git a/tests/f_multithread_no/expect.2 b/tests/f_multithread_no/expect.2 +new file mode 100644 +index 0000000..e2b954d +--- /dev/null ++++ b/tests/f_multithread_no/expect.2 +@@ -0,0 +1,23 @@ ++ext2fs_open2: Bad magic number in super-block ++../e2fsck/e2fsck: Superblock invalid, trying backup blocks... ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++Free blocks count wrong for group #0 (7987, counted=7982). ++Fix? yes ++ ++Free blocks count wrong (11602, counted=11597). ++Fix? yes ++ ++Free inodes count wrong for group #0 (1493, counted=1488). ++Fix? yes ++ ++Free inodes count wrong (2997, counted=2992). ++Fix? yes ++ ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++test_filesys: 16/3008 files (0.0% non-contiguous), 403/12000 blocks ++Exit status is 1 +diff --git a/tests/f_multithread_no/image.gz b/tests/f_multithread_no/image.gz +new file mode 120000 +index 0000000..0fd4001 +--- /dev/null ++++ b/tests/f_multithread_no/image.gz +@@ -0,0 +1 @@ ++../f_zero_super/image.gz +\ No newline at end of file +diff --git a/tests/f_multithread_no/name b/tests/f_multithread_no/name +new file mode 100644 +index 0000000..fa49692 +--- /dev/null ++++ b/tests/f_multithread_no/name +@@ -0,0 +1 @@ ++test "e2fsck -m" option works with "-n" +\ No newline at end of file +diff --git a/tests/f_multithread_no/script b/tests/f_multithread_no/script +new file mode 100644 +index 0000000..db791e1 +--- /dev/null ++++ b/tests/f_multithread_no/script +@@ -0,0 +1,4 @@ ++FSCK_OPT="-fn -m1" ++SECOND_FSCK_OPT=-yf ++ ++. $cmd_dir/run_e2fsck +diff --git a/tests/f_multithread_ok/expect.1 b/tests/f_multithread_ok/expect.1 +new file mode 100644 +index 0000000..4742f40 +--- /dev/null ++++ b/tests/f_multithread_ok/expect.1 +@@ -0,0 +1,7 @@ ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++test_filesys: 10251/32768 files (0.0% non-contiguous), 2218/131072 blocks ++Exit status is 0 +diff --git a/tests/f_multithread_ok/image.gz b/tests/f_multithread_ok/image.gz +new file mode 100644 +index 0000000000000000000000000000000000000000..42622c3786a81f348f2935d4f9cc2812bcf539d4 +GIT binary patch +literal 796311 +zcmZsDd0b5U|Np&QLdaH0YS1O5hC*5oq7Vj2v<*@r85O1V*b*usDQ&||l9u77P0Jva +z)moi2ay?#B-{A1g-MTuXxlc&!%*nZ`Yr&2R^&X_lC!>_;{TW8E#9C_u2 +z?X$mT&bu@3*^C+27RxT$Fk|(}1BVYBuI6ReHoL_PRy-a|8Mbk%tQWKj@bvCM&9##cH`ABn8T#VO2Cw9fWDfZ12lq^AW5)8dn$>?Yc*2zkIZCI;rnxhkQ?M +zcfe9Vom}Q)zZ`+mxSgx813C2`7Y5H0+Fgz*D+~7zQ4Z4i8dnqh&!Bv2@R{0QbbMpi +zzR2~EDlwakQk(s8RI4KQ(b*l_}%GXG&h2_*3^- +z-|%A-4qp?$eadlQe4YocN30c4a6hJ`<3EcPu>-OM?El&HZqHsn(oZf5g%oe_uhul5 +zTRFJW|7`H7a?#LoF6J?L*Z>thvrqqB?8JW;+xdSiHvFH(7XJ9pVV_6*SMs0#m3+_W +ze#0F1Gf+i_QE$)cEDUYFznWHHP{A$0mP` +z{YUaK0s9j=Ecd_WT#84c9si$G1#p=7GJaGGpO~oJM +zqXyZ+75(YA{vdA>3SYJl4JLKO=Z86PZc4dIzK99K0s8{2JDo*~G+@=IVXzXQK6BC9G@=5qWEU7w}y-kwd%^F`AI~ +z9<1ivjp7V?KkA8(A-GV4^{Xj)F3?2}@$oi#+E#MIo#Fu7686n0=+?W@Pxr(x4itGl +z7G1rx#QhfI6|(3mDdq5;*Wc+Ob@b8J-nqwu?bh_gh3(lOClEarr3-d?1kGaXhd-j% +zG0(aBt5Slq>*q_JQLohT@UB8tyPqoXMQKez!g;@yJzpREvuO0o#E$+EqLnhOU5hfh +zPc5E;SSBvAd(B**hAii7O{nH4nEfzO3p=@PME=AGTi|!H;}+Sk_r|-BBWnwf_K-_^ +zNDr6};T$ISSCHhH%<&O{`O(^VzyAAhgTe^W>tKP$zEqq0aQ!W5NSev(^UhY}-aBxy +z_dPt__QRPEKXKuUD<6xFu`+qeTXbZm`Mo)`rsyQP#sRH5+SN^y>Z#4DaCWP_1g30>zy-ckJMg#>qn& +z7o;JcUuEXY8#DJU$3Hu+cqlfUnwDT{JFQ1a;Nv_?aK`T3Pg6H8{NWC!h2 +zBedAd=f1~B9D`a4ju6=|Oqe4RRd;7Q9o;vmm?{oFc7!)Zv%CJwYPaB~ip0O7F7PSi +zDZg&TaG?F8Tb5xQ^Uctrie%n)PvZVQ)gZc&^ZEx%8qIrbwUlu7GRJXjVUqXC>OMnm`f+3~{H +zGn$a!zLe=Wl3;`Ar1li1La`_pSh#4Ds8i=yHhk6Sv8XuE@bb8A^L6+urK}G8tfv$$ +zY&Y>Fy93{Dvj0=ldMAB}|KhuW1n*_->~d0~uE6xc;nF)aPimPA!!YH2?2(DA^*uRi +zS_n7P11fX=q}BPk)NJAWx9D%f^FA2h9<86By-@0fR>{#66#H)W9H=v6?t_Z-02_Fx +z|FpEFJccQYS80HUdl)sgBPItWD&zl%#ij3fJwI1hx(IF{<2YiHvAX}9WknlnnZy(5 +zKe_Z~$JjY@=Mcv&X+mCWJ^y=7sR>keU>(!%{HN+hmQw7s&mzumr~ivDWS3?p6y;&F +zp+RXt9eHu|vPRpe?fj71iRA2?CFm%4awcCzk!}Rf*2bmt3}f8+16!fP?BZf2gY|<4 +z`Fjri!uo#)E{QLsJ{I;n21ffTKNS=^O=Ll=9NQj}P@I{p6H06`HA|4t{jf8NetQ2^ +ze9s_~R)ekPVhYFj{;!%7tL96R!_;hnV^M|t*HuCBPzHRN1Acwyb!zekKH<9W8~OB% +z@R5}%OyLS*2crm)0xxE8Q+-3A#PsOuG-N30hC(-a(G!W~Nks-Ye~_v*C0}okL~}^A +z05iLvM;;r{Hz7ng?SOg(Cpbqr*a +z!p5KvB@F0Es_O-`je-m3PY372ka^uWh}yg@H$6kW0gtgF4d>p9zP)WKrQC=(?gBn0 +z&Bi_s^*h4=QFY_96kiW^GY3ppNM1$mf{<_M9aF1yhOUaZCGSB +z0*4-vkt^D$w@YGCTpw7ax^kyN-l~J}{79@f&VG2GQ5^iq5+VzFWfLN;wyNo}OH((j +zF!CU$d{f^y3ynkI27%?+G~PvObgX3%;cSLn5gI!D{xM!^=s@)&UY3 +zs32+cIoF1}X~X}(N2Lb1#rktbCDzkm9uIe6qh3S2IWuM1@$cxC18wKhQ5_&bhPU?g +z8mHY*sOiABSmRN07sowSprcOXV@wzJxq-muJnmG&&6yO=d|RE3CS+t_V+S03=8tX9Q&In+V7@^!#*z +z_5~iU82d&g9i(OUEIjd^92w_Hfvt&+phfD_v5n0c*F310jPN%b_# +z;?s)_zH<=aH0W_Q;4EpYdV`~yBVb~22J5v(3eK;qs1KC*2)iN==N)g)zoAYvHfG=; +zhPILJyrVneS_WV(_M!%)^{g?GxX8dCmL~A2m)D0trIWy;t?aAcr+7ktr~-i+xzXVA +z%F&pqP)Q;Hm`~))b$4C}>pFS`smE +z-MZRV&w`*A*J~8u?iI+=2iDi1pzHZqpxxNrbA}h%*TZKs08Ee%2ze;HJYAw+R5uOz +z`Ch9tk&3(gMZjL9G!JK7j){A(Nxt#RIgp&BsMm;lf=ARTeP9%{gFwh%|m*-)33z5AhikinyTd}Um3g@}N? +ztk!0?Ef5K7V}cR2oX+?5P?_pL +zCtAnoE0;DAWk4N-OzUT462d03!`)%l$4t%Bu-njQC +zffwy=Q$HGhy$*jg7bN5W)l`R!a#NyA^1x|t3jJzon_wour+VOf8;0$V>@|a$%mHHF +z4zV|`5MrkAtRam8@@BsGVBou$6zEi +z0%jt-InPahGfWSNOd8^GsEnsrArQ>{t*8jJ2dx^!RPg>xpBF9exh0MH<#Esl>+e05%a$`~z$`Ri&qW|d^RNIhpLbOp5a +zopS8cRL47&b(`qK4q*|Z1Wkv(s<%9XC7-G3feYsyTGts^K=4<~fOn#qN4ZigV#^aF +z0Y?^_>8D;+nsoIKJ(M%n@jD!P6$^=K$tZ0?TEh3-K(en*VKRoFESTur-#3c1+S4C+ +zsF=b8W&wiu#@+avdkw7?z#6(b4Q+ccbjY!T^$g+#^pXSm)W&R2W@F=Ip5GK9>gUy} +zyV;{>VL?Op0p83rZST>dqfo(?AYhquHKImDDo{%y8w8|9YG$d%7^`#zY(S||-WX#< +zs%?K*2yF8h1wE`^qpoAd!P3wH0Si~W6SML24e@}c@7^Gw?X9F{$JEvn)Zl=^xFj#BByUI$CjhThHrm_-z4%E4G;)z +zXAd)YOwK|0t{xXVGh{y;77_&QLSq@=wNI(R+f$~%W6+O}cqlD6pq0-v*))$}r`kYE +z(3=-|H7*DGo5v3>y^vfTsig%wa?}JAyb8T(YP +zAn!!A3AOY*Dn4Aem4Z?jZeH#B}w9-j^W~ +zUjj^=6gOFTS@?3!96|x;ogDOQI1-yqCirnx58Ow&dHul2nE-c7csDXwPB6A4rc}3T +z-cy!@I}8Dr7E(*kEE=?!bP8`bI$rIS;bL4D5KL^sEAYh@S|;p1UC|HqE({xSiO8SKNdQ?(u(yWd5^;$W7oLM}BkkoJ4x{|MGDx^sD1$ +z)8_khxZE9qu%iHplGTmbPpn7!`Ks+YR+hlmuVGBhUP5U*zo +z686+Qa=UZ>%+=2w5^7hb#Sr)OF)x$a6ma0zpoE?d&=eTG-TCIuO!Z0T;Y4Ex5;rR& +zf8(#~M`j2yUpa>)Q9(8fwe`xpWPOgP02|Yg;o(Ql=gUPoo3_&-(RHnkl*{SZJYR7H +zCY6v@Kdc}z#knd(e;*MZ2f-e-0U1g7u}K=lE{l%{k7bDbdClh_T|la6LhLo((4sQo +zg%G}&+ksT~2tQ^#`2bU%9k@24w9c4w&P6zrVBU*ecdoiUzXbx%_YZb?5eqN>gQGPeEt +zZ6aHUnK>ige4CT>(NryoU!b!9?wrvRsdK?u9`1P@SdA6HxqK4Ast+LL#WpcYroG*l5C8`c;f{H +z$;we^Gl96L0F>N0+_Ew-h)B>lpyqB(pBlR-#YcUq|f?jeljslWn|2Jp3pZ;f8JkbvBEl(5U-=CskIq0`JOD_1d1Y^($wSe%CIdpJ1Gi5PEQq*_g +zW&=xq(Hd$1OMtwlK#SSCW&ICJKf)==KlAa20>;%fNCm{7XiN^ewpU@%(X43@sex8= +zqoVef*W;AyP)UK=bhLh~`@Kwq^HWKNr2^9T%*U6@Hykt~SZn6PI_6m6t*00VQM?9! +zSCogh1Yaw7UU_T_yslX7HEGI8G)3f7zROaG-)hqMap+?{~24Wd-q4-EAjgj!E;6tEl-l9{0J8{D@W?EB5o +z(5r1gumS#T80;I6ucS2a?XQU>f^|5&LZ_x7Jyoq6qA2UN~ +zpLrWlL$!skXEIe`eWn3AF=@0k>&Nz;(5{&v*~~a2xcD_rwRpLNCCdbNiBeHh%ayP2Jm=g +z)ZYAugP;F~<~h&B61^Q=j~13dWhMgsHr%~q>SPJ2byNl<4SWylFMh6E0Fjn#9nc{y +z65{4F`UgC)Z#foJyMXRIwA}?h65lIq@=Qpkx{n`&d-`!P9Zc}>N)yp-Oa%-=TWVsy +z+rBjr_oDZ5P`^M=E?1jPfj7ZmiiN&lTh%|V=Y8f91<50e&#n<&tgm}_m55=ayoX#p +zlGtIjSsi9R^hORkE-0q?b%{FWj|(N2Y!|uMZM_Ag&AC$vgc+hKP@#Ied({sGOj?Io +z=8L7pS4wYs)Ej$O5>NnHa_9M&I4uI(AQj-EC((es +z(|;dp{7EBym0kmYvjn-7A +z8n|{#xWTAAB0wBQ5{ju2iW@TsM4{R!O1n6cJB=(4Z^b}b9g~T2``ggk*GCyv8*uA3 +zXm{o|XRiJv%r9$XA)=EXgxei?s<7WjK-H59$=4n3b{>Q&h^{558en)1KcW)6qbv~O +z{e8yHBQM}E3OD!gvr;6i3VQc!$fGtNdL{Ec +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 +z=q2FelQO)C!mQ3UN$3vO+e7;5VO +zv+sxuER%D9!cRPI=@fl~fh4BsqVk6l$6Z83D~4|Zu@K+nZF^aVvj)DZ4Fqs+>#W)A +zX-k36#KU!Vn04+7xAmXaegf#;PmoB`my_k`^=(7wosTOE|i-s}zX7(<1Au9c?{HrAam6^1xq>L@kBsX20}`YgDf8USlWT2jg{n;>U`{|OYV +zTp?BCH^90IwZsP3PQha?pZ|TDNMsu^S+`)b%-qM;#7L@)1Nyz|z0qbCQwM(MhKr|) +z+Xn7Eh_Zl`FAlthk6n8@lQ%MXCy7uueh8ag@F1T86Bj?K +zq7iB1&*hh~A8hv%*3SqO=|qT}ooYkwri>3>keD9b?||+prv0O3|=*_Ncj@c*bMltvIAaF=x@Ap<+>$sx|dZ3iX)PxSM^I-#yME=+Kpwm +z?%Ybewrtm?wO(I;R)2}8Kb*eWB>mdM7i)H@-O{O9b}MoF^%tL)-8{Qjc8S}|o6Fh{ +zUtjh-@=!ci(BsXsc5XN60U`quPA)oM=l)A +z;d-j*pLUwRwh5_Rd;jOr(Hu?eUjp({{*mm-KQ1&1&mZ?J +z&o#MzP_n1&VqB?H+mL*e`DhP6ByHjxvI;1^ux$#F!nh>Iuw5?egw&J5yeSQ{L%clk^^1Ix7p%GK +zkII58^n?qS{ra}79X&cBCAo;5$?BVLld}mbmQgyY>QlE&)9vW{8It#y+8mxHSzGhm +zAyo1nel`fSXwt^YHiu%MsssA@-)&AD?jGv7zxwy;cvlcwo;@}0>s@pol;?Us`SKRO +zi>Ga8!lfdEP;!XeK|QQ_!xH!_&?78qzB|BJvKu~$>JOPQ7hlm|V|-YmK(ZF5L;5EC +zIvi6*ee%O@Lg?=G*z$t?z6!GWw+N-?2chG&T1Bmt+3{aRoZpJD0Ub@M^HA#zBRi;7 +zK&7d27{8>tR~>j?JmF5Yj>4%SAxjnA*H13y2NL8ojPozb)RL1NjeR8t-P0EAB;tD< +zev3v=cqi>s6Ot|;!cwP3Nz}uf4_c5o)4it)qWf1vhZO)A9B_W2`%`gYKwADY +zbk!)@c$bi2AMmoD-3u2oFK_-6dMN%J+@W2j{p0k(frtPp(7lDM2|aXVGjw;>Oys+*Wf1QZl}lVira^1V@pOEK!iTqfcWxz*1YE=>Ra +z`Kc2TP3#BWpy&U};O_5>hsOX3^PAuLJd2;%3}_b|0FS9$s-yE`EhUM@N#&zC^qBEW +zeXmF0IcT8L7+hA-XmglM2jXvh4s%aLTa;WR6qI>Vn4`Tb=Duybf~+JcoIp?{@%Azu +zY8{~)HGtK8FPw1Lp71yECLY?)Qhu<$%zmpj@r(&Rh}f8C=i^%a`WW>23}6-Oa~Z{r +z-!Dt_jWdDuYQNQOaI!imaji@{q1N4e-3~5hl6DX}4I1T*ceV%Xn6*F<0p>0zMleJXf=nF +zjd+|Gpr{e{#FhD?0Jhw^0sX=Gvce3LB=R9~qUM37y`@u+{jBMe?G0#WdOy=@!?PA36=+;_kB%kr}qeN +z5E;-2076&fX!zy&K;l^exFoqP82{1j_U);}@&TX^YAYX3EYyQpJOuQbFZm9Ul;D40 +zvbYbd;;j6sf0m|~HeIVjgz)WVHF +z0^j`ttYUc1l&%`$w^ic0At3%<`ni=IWL<*4;sC2$dxS4;d_y93DAvNh*myll$lyPP +z{)f)yi>hXXq{MhtQcNVPQ9wRDBglLn(z93Mk_hP9&YXyH_UqSx>xVAJ`}X-a$fefp +zC#+J^$S3(7V;Y<`af6Y!2IM+6YBG>`tryxe5fn(Yo!gh2c@6pt_!`xW<*%n2-U+KY +zsmvFDT9Sh_rC8l3tV!K~{n=~Ey+fPNUkG2-=VE^aD`Lx*(?0W7K}StQ(P+@ugtTw-hb6wL}f2gE`@p&ArYI +z&sM_3F@-Pa;B9Ko)M@3~LJty;6mIhr_y|%VI;68e6}i-pjlRw!0+xBDABn7P+xjj! +zS_H-P2bn1|M`^F6LH8d}LGwYk^X=Jn?&Dr~er8K7o-;E3^j9Ej?mrSS<+U)qJDAI- +z4(@3v(+)1yf6RAF>P0j7WF=rLE$PYI*+~Hqqnaw^`7H0;$4c^+4+-aU0s&>LU#_t5ksZ)<(-S5Rg^q%>n-lOybF_1f#E3h}l~8#%d@H!?(;$OI5EQ(4}pef;5pU)#{bq^cI$T +z_WLHJ!b!L}d%vp&R1p~7&-EV2l%fqm42pwq%BL6E%Q5MpmDpe$l{JmdJm;z`K6+r7z?0p?dkC*yP+ETXQuP +zdbAYa(1eTm3;EEGe!ludN~*-iRYf7_SM(je*aN@pAlGT0I~BN|`8r_; +zkgsaP&a{{E5TGN#lD$!~(zEuE??^m_1$6qVyYSH4+0avv5)oGLDZempdM#{F#h1YS +z%^INzHmmPS-a`O{a=M#6s?lXEaYH(|0`Rso{rlWn6Uh@4)JKiqDl`Kabx(+;I|X&TJp>gA1`eynA2@9b^@Bf>2hFyIL8Djt +zWW5A8U3}6C{XLGu1}y}LLpAuKoHGJbsoTgzRc)J(u%HbmtFB-hza +zhjFFnfk&^sKw&N24@Cr1lP#9`zxm-y2%Ln^;*gFc8)x4@+{*re_Cv!2A}M-k+mtdQ +zKA2#3RQ+eEYE8;0yAXdr!BXHppbXu6psbuC^9UArs-w_Iz#Y0Zw)!UFTH1h}3JOlX +zp#3ih56k)D@Q4C)kgpCFW+f`Fg;_-!^eLRSJCx85(6wkF&)lm^I`nZQ5~?i|Tsd1O +zw?1|oIK1*9BpZ0^FG-httbF6U!aC9`=!^aj{{-~b!6RQ@`P$7cL2 +z=I_K`JUW_1tVZU7vAQFIEQ>o&U?&6qodw^L-gPjz`@nljf8O}^F~m+-Wt3FicQ*Z* +zE<6Se_|F&_6B?vVuf5yo&XkiZ&)mYHySG^OHuh|Ss?Z2RQ$EC#1DeNfz#rY<;9WRS +zhb)pD+Hxdp7S^<)gSr}j5QLinhxC0}k#b!k6yVlOa$`E9Y95+2U#9!{+`W)FB3F!duy&=$FK7yad(P&t4dQ8{p|RR-n1h=X@DC~ST>|G_ +z5dV_RBace_vgMyBJBF4Bc6TaGIim&*td_?Ll$Z2}XjsfJ0h;AshAaKqQWb +zQi>24*N`Gg0CfPyk_AX^G=s<;_Ol?-e#@5|i@Vxg_47jCIMM??II<0pERpJ1uuqbxf8BFJCM$ +zXE2C6=EuHVe<<-#T%vipdC-DqXSG+JowjYBcl9l$zh1B1<>YVNn|E#5jFZJjP8Pph +zwsK|l*{GKbQs@}Fwy6Ub7I{hW^IwZkD;U|RhZ@iDG +zB#v!^)}<98WuJRD`3mlek>GD1SjQpB)iA!beNos1A#Yn23;ia?=tVqie%D7pn|c-@ +zC;30?XIj05p=xnlsHKtd(yXUi>M-~)U_v9fY7qD=h@GeynrtdU+FO~! +zWRkAfXMYRe7{s&~-;d&oai9nOZBj<%s7d~k@5@B}bPW3O5>RiS4255<+f2k^E$D97 +zW(v!U3caC2*ZL`MF>^Css7xd*Y2Ba?q54me +zYdrR4ktBer;{PkyoBd}jqaLPz0hl+Gl{qbUWSP9IFv41%s)kPwLbs=6MtX-u)z5~J +zzmh|J+1uQHA0sft9MCL|k7j)OHIS_D2)-x54$W!DdJFQ(vDle^Pu=jN&p6 +zt`kN9g0c53Tk~Q?%2t@A%s|Gtmt)@b-cudA1)yjKf9**6;PL$6dzq}}Oii))uC|8J^X<3;G7?RD_&%4|Km@HE;+yuPP$67cxlBAY#v; +z7ltawp*5YsfT8i}%O*|$b +zHekp0ldUt{im#k3BqRk?r%4UJYba~rpS#c@?*eQ$b}?c9pXx9p>j7GN^ke1jJOkp1 +z78YA&>z-=ZvJ8fRd=aAW;2r+GQ02vs1RrW#;DmN90HT^IdOJ=l{dG-J4|yQ3)!y+i +z-SRqB4O&@`gAcX*JRg7F1G*pYeIEWW{Sse?j6igN-|44lMCJvUU};SU`+S=N{ZfS9 +znwZ}v8UE3hratCR^umPjY;fOk?E|ya1~-?1?mz?QXr|;ZY4DVS2PPFE8&3MNidCe< +z;PJQGK8#u%ZA`JKuJ$&7UgHbm$Gw#olkIhe3|B+IX98xH1N +zZ|iM7-qTe=IBEb0<^By*rFoZOjzqU`*lXGtR}Xf0h>5%jg&@}eiN3q>Nw~~(h?qh^ +zaw@HJyRhq#=Hz0awRtRKWH6YrG)Q7)67c$Ajhi53J$%HsR_*a3XBQgr#+`bJyg>K3Kd;-(s=s;0L0Sp&0 +z*;L7xHK^AdC~++08W^OO>J2DPkcGWC{T&F6BeC=Uq_oe0z(oAt;a2QcS>U!2qA&VK +zFdR4BucG#_1Y&R!m`P7b@+Xh3aQR!ZJgx}r8Qb3y8*}p@R2i<$VW0M)A8b)6C7vOV +zb5J=s1)Jl0%2z`<7Xcs2($sY|H-Xwn1TD74+48E7xiH$R0N=7r^xA+CyHtFm_1mp< +zfm^W!#jEi7+n|C_FhJ|G-Y1%Rw~Md|3ow&=Wb^k6PB(0Ud+r7QF~O&!`(2kW3}hx4 +z3PT>IhK*%4$LsSMBe!uDLSH +zZ`eO};Y0C7sUx^7klD1V=sdFJPf4an0zmU(rLa&sT9G(0ZVfbtjPJXXi_aw7elUxN +zUe4UnTBXg~za8omq4)Deqn52p83Zo?I; +|SE0a$X#z<_t>Fy}b?j3`23SAbH8 +zbv3+UtN`5FZz-tdqw-Np4R!juEeSo5Tk`P}_VH_OOULdthMO`U=Aa`@QHM?lya;e0 +zCgDO%6Jm9aKWuKBWnN=i3NzFvV?>2LSq;*;xXVW!CLJXU+n#D9h^N|SbKqquTLE+Usu3mZ6yx; +zNPq=QOVldJw}Ra<^KO3#d$SlR>L@^v4S(yNqz-t%P#Ok>u}m>d +zGj;D>V@Q92xvQ4Kh+{FDUC`dNQ^N3E>aakoj$T1nhg2-Wj0ywTGOL%uIAH?jX-P_S +zjAhDfnD!ism|Fv6IyRp5blWTm9aNfwtnB$2-6ZOO8x(^~N53XfM@E=0D1U-3^$vz-WHL2YrtVphOEnj>;H0=7nS|g=_g0u?2hY +z+nbFPt=ri-NdBG2r9k)1wK?|4Gg}4zZX0)yQ7%{Jjm3t;{4C0S7ovIRYavgZ-B1|Tl&Jz(6O{BlBh%<_OpK3o-jZDBO?qtf?W_g^eR1R?r^s$ +zL}^n2{tBv0Qu8r`Z79A4u;j@W<&QlBkHig)h5tt83xm+E`&Ap#GczCqNdeyq(^sY5 +z*6W2A73c$i6*I$~W;N>Vf~U9x9>v^9H`6yJfQooZk8ujW^w@vxq4)es@b7rr#MD*S +zqgyd%%iWcr?CU^lM-8m_`idX{bO04CNVg?@Gax~oc>-MfsYmf^QM646%%I3)V3o0! +zIadcKGXwJ-V9P#eJ0yFj!?cBp|4D`Uoo@G2#m3P0R)Xbnx;d54<`QiWuE`hDP5ArL +z>EV-Y-z*N2ao}o&i|6@sM5y3kUUoE=-T2~^BJ{r`0JVNLsONOILX1NJ_YK|c^La`> +z7o`cD=>%?p?A!~>yOU?Ri2!u?od~h0u6c?#7fxP3MYyT +z+*15c)DAVA56Ld3U-<6d8o1ZNp +zp^Akca7UmGU6%Xoz9u7RPVxUrYI+`%SYZS!3?Q@o14bHUKWEOC6~1m#&Od^6g0g>* +z#LY*%+BBeM!3@bUZx@fg#^dm$-ijGPj92n(RY^TNZ;YwRx|Q +zx9?4e`hb^;Fwb4FQw@9Dc@Qt)0K$eon7dBlYcxED2ROejcKq&(WSEr{z+yB{mkT}h +zJBX~0gDV7G1@u?{(-ZJ#6cFfN1xx4V9~2L${0=4rpnUWDDvv|#<`VpwCKfvl)nD)+ +zWg*lC6}Uy)ln`4D%#bLdtSmM{yVo0m_L`XhivKs`fH(?Oa+J3`YA&Zsj*Ea%XyZBf +z^3|<$JLoI&fB{VS&~LObQ*=cF;_xVeh?(vbB3RdJ3gH2c0J%tAJ|_!PPvWxp_1`BB +z2PUn}d*EuF>osK>bEIS^BMip@dSO)UcJZ);8J>AkxX^8%?y=D@RVV}#w7;qCi7%!E +z?1$;r;5mk4yVDo!w?Cq=TfD8@nqYriF$f*b5K#g)CJ}8E9up%rZ%4r9yih?7#vpR +zs8qG3`-yX5+(}*|CkQF^9DJkG)1+;baQqf=7Pg}>ZjhDj^()VvI5bn9!#fy%<_@Kf{{sA{q~9i& +zS&Vq3Pwc-)ae+2>Dzw|XT4{oJ|$kA5`=SjBwMn+^Fl(= +z)O-EBH)q;{Uqr+b`=ZOie^glbKCxMk)(lBX6#OeEH@#Yl^n;G)&|{S>?fO}WhtLZ>Cj2#0VJ->tBT$1>mw~m +zYt-m|zC!e)Zz=q>X_I3mhaWFZE78$$MFM%$uyv +zOqh$}!M}f4*}wnYZ7+B*k`{JQCMjMO6aJhlu|IP*hyJ)Nb7&Ts12bu!0)FowC+@1Y +zb;La5qkc-_mrmPDyao@rdfQ^$cpDF2U`1;&kR(@BTm@~l{QA3=!n#Wp|FiB7xL@n1 +zbA*$iA4W-5LoCrDGgU}CSpZzE)S&$Tn7Z;nsJi$6ZIw#eWGUt?NhPU>%5vWpR6?Z) +zF_lonBq8g4OQk|nNh-@!vLz(hvfLtDVv?pAz6 +zxfL8t9Iv-Uuz8=`-m%3G{%9K?BH)eRQ0voq^2|pI$eoWtI3Ej?i_sp%`YP43I=y*q +zZ+0%+5a2(VB*M8Vjj5+5cW`gR+>oEdH|B?x31v^#Vq@dsw+=J>><-Kf3%QEQT@k@ +z?-fG;I?by*3QYo(e{OD$F_4w=i-9>gA;}TaDzgut4Do_#6bH1k +z8-`*z14Y*$yA=Z9uJfI6@U%mp<)*~Kd&9-#OPy8#kZ!Le4ak5X`F?}PBZ +zY%!ga`o73vP(XW|mvOGBEi8Xzd?sR|$W_Me>=Y!P@&^-DFfpcpKK6shmg{29ORnci +zMtPb39X6zZFvrb*y$J90(Or{yp*WaixDyas9ew~dqv@yk>=BAtQJk4PQVxC4>~q9USgghx)*$dy3b)Ymip=h1d3(P$9*oUZSd7F=)cCI4J+Si4b^ZBlqj6*X5%>zo1#u2R9sP?{t+ro&UigL0h-!tQ%!N~%t?VVJWA5TCZhfyX!p%h(jqyuO%b8u^pfSBL5j +z*v$dr9-d_MT}2);1RU-&zIK{?vnv$pE)_VaV(o4(o;B*M8Mgv+zZmO$>fmCy;*mZM +zd3{YyxfpG#j@APR7%=Qnp}4)2n^a32bjV)jnqk;xIJ1gH0o8JLS{Sj+a2Don6FK{D +z^Qaog<=mb^N478Pf0NjW`RCxy_Z^mcxw!2{d{YIeONQt@;&`Eaj`2>wVf;z6{-g49 +zs{XSaOy-f?n4jGgod!D{)_gA=5? +z&&o_hH>2atf^@r74dL89&~k|Xcmh|tNJX;tcI5O)%O(~cpP%P>W^{ahW&#huz~6Jz +zyUKla+22-7GK;taieP@W7J3(tvtSBN03%)#LG#?W1?JZHW)6q4c(=tYBc)x42e@b( +zW?L9ydREB@@rt+)elBSD&XtW*!8I5Gp$47x{a#4*hYqhCgy8n96Rh8|Nzef`fT6U0gY8rIfl8eU%99{-_)2tL(H+~e`Yr|CAv9@^ +zh-NrCMSv+Zopr3uYvf~QK>gGP(_iGvwooPymT1P$q7t2Mb4RnKkXV;z6Xf^dmnOx7 +z6o~q9=W+7s$lZl3hiZg#EO2UFw%DW6tLxAlxPU6?;_v3aoq3VfEDeQq4N%{v;j!!+eU#INyrh`&+w_{jHmzx8UJ{nH^bI{{r94szaS +zKNp4waiEr1Slmn@&%aqdAq62>@ebDnTVb-h025RuaAHAx%#2 +zp${)O7B!{Va^U9{lniHQ4bxj-%#s&GrZc;*&Z4jyMIf)}1IFBwj$flvoz5_bI_u +z=6!6&^%2>-4O*IWC-;Tl_69@4zxJktg$1Lm>|--VI~{yLsvcqksnv$_d!LwH=)h!e +z!g|7ZY*t@rw(77dYC#g9AEOy6C*YothbqdH!kO#(B!8 +zz-Ch=qIb=`4o#j4zMC?7?RI7S@d(5VgC;ii##enuZYw&?p#pN!&vzfbOh!sD9_Y1A +zFP<6XvlO;%2@pGl}zyi6245I^#9FM`a{?lLQZ=_oNi7-^k) +z)F^31z$E2NJH9+_u`uUn4w`Fcfv9@!8(EUeoQ^;dFV7$Y8GXkE9z%AQ#zyCebpN!D3SwK$DjTjIFC}4!7hQ +zxIiW70ZK5W8uBb-HH25zcVHtCn?`@6xuDwE +zRltn(g39|*v-l7TXdry?-)TZO8#_4{%2E;3X&aA6H9Ywy12+r4@Iu_sO-bpg9zT#U +z;gxd0vohJ(^c5~6ZZNW92I0THlvIDQuY^R6&%tSON_a2N!g(ih9!JPN*4#C?;O7T~ +zHOy8&lKp46%d;~RCI2`$$07GJa*?n1CJFve$D{UZ$Im@t-}@*`9o2b!Puto1efW)Q +zmk9}g^MTiv{MfJZ2&yu(T_`*oF1{qWo;^MiIx+IG8)zhB8ExqIACKvX3^3fNU?Z37 +zqSZY$xx`Sfxva5**@&e +z-v(j8K>}}e(XDFMP1mpr2)Y>1&EAJO|Ja*=G@u1nXS559OMeIsg0rW&&5(ID4ou}EHcX!=IS=8o%D^@F~xq76Tlc*kb5YbCBaJg2YAfvyFrMl`%qqstRw^ZKiK|Dm2E=?1^7)bd3#buqA(&Ia +z!2NCO{W^KRXp&<)7@fKQX2+())rhEeX)=q#unZaNeN>C6R{}Y7wT)vgZj72CED&+~ +ztVz;7$YpMY2y+WGIX>W#v|wLHD49^8iS^<=58n8}V^GAFHvHt*C&QzHL=@vvuMLPt +z_2sQp@B8D0C_O4o4jr}ExK!B%>kd?KN5)7+gB0V(&PipUMh-BwMlZEB%Tr(!!2@$5 +ztUlwLS!yt3AZE8QA~YOKS}G!zPNEBLSj>t(l3r0|oaqD;UZRv6H=5k&6H~BoQh9N# +zn3dzkQ0@)Sg$HD)py>RYx^4Jhrg7$z?^O1ipZG^Yy^WzcP+0ToWF#~i3ui;X?@<*#CGPJt +zAngR|aQia={0P6OF>*ISJG&l)@3~gl7_uMD@@bsn8*5auqB`+=2%*BH$ahfz9(z2z +zBGI$|0WI6=9;Z(>$wEOEg9bs4-q`({njX;8g>Mpym^vRI^3P9&;)c>VE6>;CT1;p( +zG&}6h0M#$!SKrGelI~9-&d@-0LF2W%zSVD3jEl&@|HS2ax3*L_!$p^YDY`ONi`d2? +zIi!usz_ST+Mt&#A!8Roeq$WG`dWS{5?#}f))5Z|S@%;hBp1J1xNL#%ZrY4zoe5N7K +zhe5`lhYUK=CtwwP7L?sAf>;MmtCAVojqKEcsb+oS7U4?8+bi}qE`ixQ3uG# +zN2;bl_Ira#vY#Gn2a5ar;qDiJhE>Uf-Py)^P!T;&^Jlye-?rjt{whRIB#37%LQ6|i +z(z-WI`bZ2MVk|JW|KR=`w)0t!28xMtuqr|JT<)eK;3D0Z|$L^BVq~b +zHu@rE|bQ^QvO6k`d$>t>V$Rv=i!H-U@fW$;a< +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 +z1Yc8yp +zZH2GWpN%m8+!_$EXYyvvpOm5N4PkqDY*9{f?{&1_oOVCmBr|6bp8Tm)_8rcfBHqOfQC%YV^tO{>D9 +z2l*dfXZRrommK8T$JdWNnHF00jy_!G6+Nc%yak(sr?yYIy;{`F93o +z!nRI5!!P9a6c^ai)&GNrNii7m&^q|0idH`x$tCO{i{v}merapFeP&W?sQY^v`ZLsL +z9Va4Y!rj`|2oo%9T}K8P8keEMZLeZAoGi9uTC||uraT!j?xba$a}r)qm6~LS*gVjK_4&Y#LgJER|R&$b0SGHwUwpK)-g$fo$?ikAC%iE&4Y{AQn@H3qPY5AVT$f +zDLhe4ikau*`B2C>fQN={y)vzDJQX1YOKu8XwCjI=>|1){@4x*dSxd)K;zpRIJ9D(L +zwB1O4Gpg|YSKamtvvhObPudo7w*fPt$8kS(UxU0{?LhvHc&peeIS8Y`&o(}IuvSR-;7RNLDN@kHaeUa5Gny`rQTpD@9Wzp0>J|AK7KhJ1q +zX*Y_)Rjq1-`y4K8I^C5q16mOa7@JMKc!#3MQz$LQE^sMiJ$Z*I?TzT-EEGh`)oqJ# +z?Qyc%KN*&1Qj*EP+}!|xWM7deXrg*^6N39<@>VRX$l;XDmvNC_%PxJVn413b4+5@A1Nww>^V-WWadQfa< +zFGD)iI47WjITI=zx!R31cjaC@^+pn@dE5E#E??2NylHy+3LzQUn}NK +z`nB=9lqs089`ctp!(eV +zZ+G+&;rC_fvjFGzt&^#4z#(>c!BEH_T&4`dqW0y0ypFCbDIoO +z?0k2LoCq{XtzjYOy5;sqi6IEeiGO`b-kBy(`kPj$BE;TiJlWT4C1)sf5Go-vW`xN& +zs^TS4a{PY~3TZXM)a~w@+m9Nlt48 +zy@JRdKEE6OnuG)CBXMb+A2*WqZqml_&|eI)E#08br2YvCZnky{a%uxN>VH_UYw}fG +zXIR+WV(l5zm;@aI_1__n{1Yw;>wVqjAljsu@Zv7ALp#khp=&2Sx&`cyA<45zb9dyR +zuGMfTzx%8!l2WI(yL=DcST|6g`}j5r+Q>D-LMztF(IVNo$q>1T8x5Gv3(0L_7(;xv +z@ZI~=(Z7Bx5CCM`%_~Enbr6Sjdl^|bdYlK>Pf0r5i*)9t^$hfIkeTBF4cMbbzf2=> +zU8tGF)doy==e0#<;ZH6T!~8sr7o?Q~nfr!lJ@__bA#}2wc!7<_fZoLzCXA+V#xF+K +z7fy$({&J+21_>N??uNiCnh|eBp+=K4083OBEHxkQy#+BT0EAuYFSq%88e9dD5Ce|! +zRG4K^wZ~F_2ukEbK!I;T(q)(EDrj6d0II&y&y8IP!{{05|BL35-XWVgn4S3^{Uh*= +zuRm#S*Wf*!bb~}t16C_<@HY454Y(030o?uE*H_0`5c(flHOPz15me?ZNGh0GArS23 +zV1M2jmK_3H47io&vpJE(Ft{ig+g^n!boTrIFsYtgRbWqEB@dBdHNx%IwWm5lCB-MSc#IT^lJ!_C{+R^M +zdG2kC`;lEY0YMMc#)w$Zpga_isn_IZJ8j~T<(?&M+{|;#^tSGL5cV8iZ6+gNtr~0G +z=9K)o$ZtA~gp?Kv({MV0r$Xs7nS@SPf=Xn$M9|!D +zBt?d|^PB{HW+p$@c}f3h`mY+1U>|PgJ+(12#W4@j-+ZHZd=~t%`hUh~g1&E>*G}@F +ze$#djc^rFN(cs}X6_{)V)R*n7-Cy67HXEW$&K~m52443xUY+R-C`;vMKnH3;YWfw*<>-%AhdBt44TJ&Z7L3ov+%TR@VM6zi7t2jNq+K +zZDAV{XH7~47kP&NsXAa8{?iYlNecKc{@HZ-wDkzse4ml;MezEK$~qH~703$l8PABs +z+R7c%QWT@1@vuQwp!c2~+Nkw%29)~s@o3=P#;k8+94KNIz_r~QzqJp~L1D1S9y}-2 +z&&^k_1|cHr<}b`uuia~%Nm}<6xB~0pFKWivdF?ob>Z*4XsotZ;e=}47Df@U0IyQxY +zUeLqPb`8-9^}6?~dhTjVjrP+N&JKCRjxhaK1$_P?b|!Z+2WIc;WqeHRmduyAjvS&P +z@SDFvID+mvJt$JuZeg2w%+9mbv)Blq*!!FD*>M_kezgWew8LGW;m6N=m;7#3Sq?)9 +zVpckCr{yyA@bQ$(RZbA3?MOIz`1d8XmdV81Lw+pmw`@zPePPmdL#+Kw4o?o4LrJLD2+u|~Y|DSD +zhys|*m=R-^D5c?&j?;WZfA0<9?e|88t3+tRg+ZLjtX&(#9Bt`q=(}ei&D@-h|5&zN +zkJ&MP!=h9 +zhIA*m0b}W<&k^tSpY8YKVYl+t@dAnm0P-J|%1(Y-Rnvne19)5olr8YOEn7BDN5&+# +zha8fB>P$DWoKkl~F!10ILZ4pAa-D%Zs$x3+F&V$_iz}lI>VT{)_07>z0~Ahio{i8A +zSaqIkt8=rE_RzXHG+Cqck+WMR(Xu*w$oQRDR@|sN^4YAgx8wnb>SE7Nt{xEQI3S*C +z`l2pvQUDQ*MQ^}viaIq*=0ImeVCnen`A%V3Nw1WpU`fTVMworLx^RuFxhCSB$U=dj +zk2!cF_nSD{hjF~XB$Zb}FIPhRB-f?mE6CApZ@pGSMs+rWUW`(M$# +zdJ+FB2iZ%$uMs|~d8dkh9a{j+m9ncD?>PQv=+WZ;AU_DqjocT(+U#^l8O0b_^awNR +zV`N08ts9E2@wMsrg#{kBw71FzLvAx_JzVa1T)xyha+j?810K +z^^>eX!(kWX+3}stctc9JOjpxFM1AWX^5JF1Meio%6eYwuc@QM;$gzC)Y8HYM3IM=T +z>E<+IKo2c@7vwLsElQ`2ygU$x^$+pvnM+dmS82!}h=UL)`?;J>fF+9INCh`CyQ)-E +znQbaQ^{NS*lAHCTm#?+}ZErKsue4Y8=h81DDnv|pB^4zldGAxS-@|wv-;j=v<&Ny* +zUs{F`fDRZMmXLQ�!Ewu9c3jQXIM+!F?l%XkA$&uy2iQp+~DD?Z+;Aktcc{>&P#j +z4h4Wd|H)Q}~;6Xu@V|v}0UXAWX7|^V4}i +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 +z77+5-V^_*cd!_mh6{P +zjNOneY(uVht`_x<523k?F_}!WL45v2mAZ{UNI?GEJxVX+NmfbFZ6@9vB!r^<>`HQo +zAj?Sx$povtj@+=}<$jw9D_|Q4g!ca8%Pt!!0_0DW5F@Feg6M~DZd{`bUBP(CbH?}egTuDuGS(@m&lo5f?7n`qtXuF5Wb~7XR9ZZTa=`0gk?+On +z&|>U?<-44#{drym5eg^&d@>aWQ5cMbYYbH7>lDvi0`{4%!=Kr#3n2leRm)?L4GFA5f5FY$y_@ +zzW|034C7u3&ATMNGSLA#BMj8y-p60Nt?Q?a;v?$6Tn%ydv2yUaa7_*oC9ZP2^L2`) +zyp3IT#+|aC>MJ=5w}85A-^vd%x^p&jcCF36y6}Sd%Aa!cvNg7ZeY3Mn)62-%T#?@y +zA(+;wCD%Ey4ZEZ*mr~M|+1WYT)-xa+5`NmSFGeuK?C%|rq8wg*_+0Fhx$nJO{Cnkg +zgsIRVTj0w7&wyJQd*o-^-w%4xTYo=Ecen&gf?0YgGor&8H9W7z|^!f=x?!Gmi<&|}d?Snog? +zs?E{<($*)dh$s8rJGL{xDPmE%j=s(RWU8Y#gPS<44#HCLbg{O_hF-=ivA(~I3eRE_ +zPPwKf>te-2qb3>30@vy)`}#GP%F+&ZjZV_G8XT={Up4$^%a-oHgxtr~XOPO^NOaR1 +zuW76U(UYtqO^dOoXZ8vT_*nNz$SYQ{FWD=2EOw>*cQRd9$NDd`PWSO>hH`4935)i^ +zN4-tLuAk&hx|ziKKLdYd#s+7U=d09jN+N@eUqK0l@Pv&+gJM>N%K#H*dYp~lbIYcc +z2n0`Gbje8%-a3Rf-5i9E_|f&`meajXpv{0Y+ht#?*A9H`L{j2_IeNLEGrupE2Sfhj +zb2Lz*B+jY2p!iYL +zF{lS7*(~fAqeU&N5}mFAg2RR5y*v^_yfPDCi|9@idRrcDd5(r6THj{ +z*Eanr($t*E2&>uxoD_lPf)(^KM4Bz_PW#qQH-K7n2yl5+(!z_s)DW#9#St>Uq**9P +z3D>0^A+r=ZNvI +zcj{Gz`J93;!pnb+2nW~AHa0an&6Te^2ziH9^fEpuIQh4EPdzH^WkmNjZg(bXmIeCc +z{#8i(Y{B5slR5oqY0x4W?|T_>BDtjDCGTWItu42b@XnNcY3$ZX=NmlWIo&KEizXMW;n@Y6rAZa#beY5jC>!(bv0B +zB}j#047VLL+Gt=siqwhuqlL_7XBurT6M-AXA2niO8MwuzH4o9N63!%l+jG}lBXkB@ +zVLgW@vLG~Pn~qhzG!ocWXYxpPgF@~R8q$;cY?5?g*KEyvE03UNIWU!9pDT#kZ^=kr +zvA`3TxIRG&e8Q@UE=vn|c#`X!XGbX1#aeCbViM +zz~i&J^!xH`1T{FapJyG6E +z;av9m7F4|CZud8-X~~h +z_`2*s8)gHg>x}Yi!7d@)#6R>h{>Xzvw>$$3stF08)+{_7z!l2tC5vN0=!yuAkN!`wtu~ny_lDb;P)A?rwkK +z@vSqVff)ng^#1sKPLYa4Jql>p?D){5cQN`k25^iio&7Zsc +zOwCL@UrJU=wKfvcfKSWB>#~E+-{9#iG?=&!5I@gT>>asrHE9My4YI74vD`p!M^y4& +z#19o`QfvM8^*{Pz?jp@(xbiw{%MNAZpJLIPR~j+4(Sko74tnTS@OjPnqOVoV#Ms#< +z5&DM#8yP7)Lmw%F5UB#N>R`dc=kNVVCBNAdp#ljs%snMlBF^*~G!Z3d@}-h&gp7ph +zGGv!T6Hj~rV}bj(280Jh;bJ@T_!*sz9W{w3Hh|D$;+wfrq$7(|uWaqxIr-6SNn5^U +zZi9{vmwp2JHSif-kE3#9k8Ex-ijj9wspM*Eyj-#Pkek3BF@SY~FL^Of=3afS2DAyX +zgqtJQH>c#Q!cq0nwqv{PJq +z;N6$O$!H0j_SJv1byuD^JK_fNV&$8JuK6tsAA9*qLCwbXi!tJf@k7U!9LP~Tq!DZX +zXmo3oHN0t@1%ENz7N}TH)9Qd1^CoXcrrvJES{8-uew-P*3L6M{7V_7&BeMjm@h7uv +z>g7XFKo-^s`T!-Zi=ua-xQzhc15Ww6O@U@=h{%F53fKaAXc?e?wdPX +zbUe*Um||bY2(x}(oToJ#p$xG&6Q7&A>Ym@a5$b^IL=1@sG-9?4{Y#|klpfm_vr_6> +zx)RuG&yebEY{OqPmr5ryej1jbhXBaDu!u#~wyKa(jykqN5`#DawB`?!wKA +ziBn-ku6d242(wTjo@dVON1>$!EpLw&A(}O>z;Y_Yr +zk@v*!OZDin$v{4(sF&fmao!T+b5{Q${le_{CUPw6Ul;BFL2PRX!ov#W0$2H^AXH#Q +z4j88#S-+lL@lqE_6 +zH56?lUv*@)8&T@wAUoLr6*H2R4tKMU-G)JNY?DwlE2kiP@E`;ajkXcy&-TFlIOk^zWzg-ramvDKrHhI^ +zrZYKY@oLRLbtPhXUba9rdDtRukuGuynZWq3VD);Rv;db>*ZoNU!v-GLFlR|b*w*Ke +zN36SzSjmifUA9jIa;2<*0p{C3C#+htgVFD6ZWcyiB}w95zl`KYVy%XaPTP{WeP_V-IG4w1ySlh)Hmqls7EdkG3YBiFeO(GPp#RnZoFW +z(>`JxCmv$p<^1hB+#3!)#`3QFXMfZ*v?%yC$JvwljjsMm2cZ#RZEP8nQza47ftfZi +ziTz(D?jG^=(5sK(5YNC#`~laKnlr?6n=V75zz1Z0B*kf_sjyMP^iMIX>sy_bb#^q8 +zJ2*ZrUp~Jf^6;DW5~Jc&AJSq}97Ha`nH;X^@toxlx^`y^+CtM6^PG*LC4f(m%=5nZ +zwWlRvDRhnjs>1j0$=`-jez%Z@|I@}$RoNP&drTF+NCyFbaVqa#n2y1F==Jvk;7ZIO +z{@niQ3xSJLlt=bmC=kw)_J`&TK09pBuj%>sz5jm1GJRE{oNoE^;*OFP@8GXV6=P+i +z2OI{r=s;IV0fw>0WWn_su7(68>3tKA;^T*LUk$HB5(Zz=2y4|`FggN0=nCs4S{z|c +z*KTpfT(=mwfPItjW=h1eO*FwtDB%ErVr1=`mmgZ-nq)*HWY+P6m~O!o%JqK +zly3_>3^h%rjpCZon!xwfH-f1X2B3{YVaVK**abDMD+n*BephXd)ghz+7cGHOhfl2T +zU78UJvKVE(l=^Uc_oL>}KuI9@Hx?J`;%+a2N@NeBUut;Jo7>bV1gBW|05gKCRp|6} +zJ`xr6JR5(g*?Rok9(nZ4Rf_yAmR>1IXKEtY#Ww=j)zPB7rKyJM?EX_a_%}=fL41fT +zX +z+@e&-r&K~r%S9zgViKAnRAee!*2$7dV(c@_^8C(}_j`WdKRupj-pe`Xb(Z%z=Y0op +zL^Q}+$?@D%EanQdS|x9R>-N<*SZ}zx7{zIYe7)WNix<219m6ZLgnonD9fIm~>SD2I +zO=S?e{RO97>PaX+yWYB +zPqEF2J=QwV>ykJ@oYHwZx&jaC1xEan;ee2`HCWu>df1`x;rwN9NO$~NU!yo~*N?+3 +z-;<3H$TBZAP#0S@O--sigQiO!^C17*TJe%0rYB%yqV@!rX)>^+fwO55-pgz-x?+WP +z^&g}rg2Hp~5x+WmSUtq{6%E2c{oKY1p;62K4bcUE%P9>E!4o!GD!!u=eDbR4dm-Kc +z1+ck;$qx^{h^FFEqhJvyzHe{;E_L*byad_-jkUU!AxvbhkslhxbsYglS{|jf2&k-D +zA=xd@SKa2k&BbU!^&8ok=(dw}lvlE0;#>~o*UoKM(_g!wbiwlVvUBH45^m>)-SXbF +zEUI#OSo!RtePOo_tH86Axyws>nLKCGHJ#Jc?AAT>Q^`C1bh;>zHxlgZ?D>*$o-l3U +z2Dt1v{829lp969=g)z>1*dNMY#!teB;ZP;~sG@mVV66f=ZMX=z(gqyo%TYK3g=Z}& +z%`OgRmn`I=XgHG|Kt8tmESl1!HFhv`uZ1)m66N)cbI=tJ;b=9aIai@wVZ +z!^e9B6v6e_p76QjtCRUQoW12!FBQ`49$t5_XRs_ml59CQVBAt>SSvelh)^9@I7oWvWEWi!W!fs6&ZQ)$lQm3movo#d`1G +zpoGs6Y~dLCNp)6E;FObSn}}QWR3&eElj(|CXnVEcFy{!*o7XiBZxVHL0l~{DiD++p +z#K8x&sq$j~L!Jds^fV$6vB-sRxO?e+)Z->4JP$6E=rs=|dzVGzqJsqTOg(kJd4A-; +z6R>_q$3gHzCf5FK&`uausf(yE0Hgh;g(&(r>HS6;=O#yMC9 +zz!!nnbqqX2&VQlvKF%ca65*6{iWPwlu*eCJsJ46W@`k%J5nJfla0w$Xoep>3lm&v$a(&?cRgMV +z>Cqq))^3%*t0ZveRD2S~v}TjeY7WE4cYC4my<={6m^va0 +z7g9T~+i%bgSDl3!9Zpz9OBNUV>~WrfPqvppZReGNMGn(Cr6>N7S`wE1P;FKEZFwx# +za+ApRX}Q<4>@}pDIU}2pMB!&aWo5TPU`VH+KtJ7C&)L4gsACUQEgs +zrES9n0^~HvRgukz>9JA8qXr!#`MVx=)fnBA#f$KK00r#n9yiE85GOHV^;Pp^SjL(- +z*+!Cu5;ix7qJNQ-vH7?GdHR7P8{Ai64Fjp6}n2rpJ(DhAt}V)A@xjkTj>y< +zFPYHGd-9@bPG6Js0UxIqMeQ +zDaaoTWW8)KJ+MU$50E^O%v!cgr{A8BbAmj#@$=MvHk}*<#fdU|V&Ra!xKQ`T!Yew6 +z$7ql!R9EVBHp5q%)3l_8`0ie|%ORJ$7bhYy<_f#rouB=%7ve0IvKeCQD4*=@>1O{Y +z-_MKkxg_J8s0K-5#%jJy)RUtL9ocuLA*5bxBXF%5$#EZFfEg-deK-B4f498S9(*`X +zi|b`w)H~vu*DXEqw*yT&x=--d#TKEar)4+2!NsJVCan-5>>x`my+vilA*fLREZ60WHc65+(dyjF=ALCfK@=R1NdPJ&tz$iBTwH8{d&K(A64nTMcg?0*#=(d=mUj9!U-%Q^;m~DSUi|e2z^k8YCYKcQ>k+i9h0O#35MM +zT$Wi%%T&BB)g1!Y9czs&d0LnoOytELZO44&l#`mKA>9l4cv*Aq1@8K;DE$(a)%8O| +zR5J|{YJ>cfHGWmdL;>VJ%d==sdZvMAYyx?DB8nW7qKIuUc33Za^u%G-Gj;=>G5cCQ +zm0aHaEuM6>!eWyEisOBZ^Tk8M_*?GQZhA*UK;W0!VwA`NnCll1nDUI-q>5&&1CX0@ +zEw=5pVG^DQWYV$D8aOYDF~jWTJ6GuW_;j~Rt}sgpBVGDLg6G*hIH}HC3QjeE!%Swz +z2Wy(QqAQ}pO8T%g!%U}zBKnj=G!Jx(u#9+G@J+5e)Uq?a@58&-0JVgfwf{cb +zlZ+Wak~#NSaeQdJp86kS=tS5<$Bj7srCGk(2y-Rbbmi}wHC))TVHjW)S}3_c<9xUH +z$zvW)oJ5{&@(NXB{DnoIyOAF)ZgxFU?pux5FDcfJ)Hm1Vxct3tEQgYu0#ahk$>OZR +zCW9~3G8=bdS`XyjoTHn3U?S>d^iKQ*{Yj$p1J3QqqFltD$?U;mm +z+em-{f{0*92|il=<<`7eXnU#9e&oZ8sDX6ZMe#i&sU=Zt?6in*Z_8 +zJ`=o0B9NJT@Azgh{eNP$LSC(>eyVG0;#eUaMVEhzsnig(t<5dB$cGZoNU6!f9s^km-17QCC~>oG$PY)9pYlNEc$A`eZIci +zLxHh9-Xm>!@eJdN%Bx&v++>XU(_85FD_!G7;UdiUlB%*O^|`5*)hOYb1XJ#)f!_;n +zQTcSFeI)5||9&=TZLHabSqmty{N&X6p(oDLADb&QsPSwLVG_y#5>(FH|86KGX*^m!3H3sLweKDl(6gq?<=kHKX!58$_dO%u`|T48EbEpBxmE2C&Cz7G#*hqDjKY|!Q`@s +z7AEcY-u`!XHPQl5>|VNmKtFHtFy@gANE7FX%kISsbEe`wvI`^6g~Z-a8r+QwY{_HC +z$gO*y&pWYGnz(sy68WaM`|hK)A-l&RaWI5%MOnmT2gC6w4gp={yyxvd(?dq66*z5V6%g1wSJl=L0V&?MH5{e3w9!16H$W0Me +zOB|vaDA+(i3b<@w>6@PC1+vIgXaL*sK~+GSf}6CCjlCUuZuPVd +z-7zvl;>8T@wF=?Bm@BB}4B>H0!9EERpTDp+3$t8IZ?xBFfJ;br2f`6HI6E5m4u~AT +z9mhJGFlwQ25|k5~ePyuD4xC6N9PL_>yKQ#lZ)PPuCyN1=9O~S>ZPp)M(wo)sAKZz_ +zgF@=p2O>DiAa4R%sQ?@fdsa?~`F8voL2aS$ +z&-PBRyYmUN5&@asRYOf0d(u}a@-Ket0Rv^n$of0hmkdk)NtluKuIBAC +zog(`s-dnsU8pCNp$Wn%XL&o6%2 +z@1MB{K~=OhTn^A)eEEsM0t33$y_ckWo~NsIcC_?a>Pxc8W6xdRfnmhLEU3~Fi@?*b2~Ebf-AHQan?+)$XVn@Ey^0=Oa|UI?B5v3-vxXW% +z>N+X5(BjRF-px&h%J-zeMPh4lDhOtJQS-G*K@5r-N!pq+w+!bjiNi&0l@Nb@IHAXJ +z=!G(tBv)v4YLvzHto!=j9B&f~)R}LOILbX3PYw*KWmja5%Q&FG8a1|_niZ&N@z-HB +zWXX`mKX?>#tL-5xscHxc{lf^s&|Ddj{r@L#^ieVIj$-(t91rS5#J~ffqfQL%*c31w +z(LfKd{P>0~E!CrFYnht>YEDPdP03ZUe$ +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 +zzJsF*n0Q4x(P(*Cl!DWVo{xjUUk^(RQATF +z-^ptNv1`^z?~Thh(YK*5*-#;E=)V1(J^LIQfl6L%(wE@@^BC<(T+%SXpK2fK8i95u!A;ZP@Bq`p6xVHqI3^1gYmi?#)|C +z6}8Kt9VVgflXcf+RdcX19+lH5O5J&J!lZMTOaGTS#&f)zW%qns=M;tiG^=G$&MQM`mZ80auv@7gwe!zR~W4c%O?#=_>&gfcZiH< +zYlU357~1s<19%;vghSHqI+yR+jDJy$LF@@EHcMlin1uk9c6e0gRNM@u(Ey{_2rB!b +zK;?eXkHLLb_|fF8XQ_x+E0sBexciSfTN`c-81a` +z-QMCiJBC>oANDN_+?B40H~L%ymBA_zB=f@2+A`h`QuC?+-vxw8sprYG>Vy*Wlk{1;yf>Fzvo3Rd>;Ew^L+ercE-g(u~P_8GEWZo(K=RIGlf)P-&mUUXS+24UJr;TU(5fbFZQ8Z}h^ +zmlcIyTh}8tm=l~=OTB@)%m@lu?i-ur$m+@XY-t|s-b5NQNnJo=O<-}4#-e>_%|P*Cgd=i(aRVTvbW;6Yv!_LMFo +zs?H(_Fopuk;VtDuF9+u%W)j7T&Bv801RBOoK?G!m5l);?CI5-+8E7#af +z<&WsF!Xh;2NJ23dk{ +zCr@5qS0(|TU%HcaXjFz%(V%d>S`|@&`o9M1gjHPk!QM9-2r8LStoKmwr{k^zqt56V +z;~Ti9Z-O^;<)C>m)hnsryAKOWpAk=^@s0$h5UsZx1l|JAFfUpjRagAanxu)(zcz|MWINCNSua2UQ8t1-mT6eJ3_7@ru37zC4ry5q& +zo^M6wDzHvvBn68xhXrJ<+cG|Wh_Q}(TO0-X;Tn|a#vr%-lyJ0*cEK{kHSz_X;##P=q +z8$UCur2eR+UZ#Fm8i#(43gy(N8!mo*vI{8%kaMf!-`_o}<5~R=ahP5uvwhf2dwgyB +zc}&*QK}t+c`%dBOeOUCx0FkF_I&XV(tdL3|py1beL4cM%`TZ#7>esM_eD2nexXox# +zCX~e8xK|-N><%EuHx)Pz5un)3f?57K4PH0U){!!eJSz2ru~Loa0`!cS$RG;YRJv%x +zHaw3r(5q%=&stVpC+8iKY2xi*bn^|L{e(~rF_R3y(wFwZ|1}lw8{-H{c{e@5T{k7M +ziM}1}8adyCY}ej9Rd`xzIZRI>{Nnb4~T3RC@o|iC49MD|xxk +zB_k}DG7;ej73y?lgioLPn!UilO40y;^RLhHI=&LIA#`QoFuv8vdGKE$*rT59zy^^Xu$G(4_E!F3{N=ry;*qkh=KIWEA6X2npBi~wpF_Qpd3QqMyJo&z2M +z8eQ1$p@Kr^`0+l!`$%mrDrN +z6tPcYcCh+7Y!#iyShva@b2JHspY%uh1COkN5r;5AM_&u^4UZ~+u?~UPL@?-i@5?Ui +z@ry+~NUrxF|Iw(JvZrAh;u=D}lG=YHJn$mbA1f&)I=RNxx%3vc*B>slJNz5)~vpEHGkg{@x +zW>5i{Yc=k5_+9;NiBq5p$92J!X%Rhtp%Is)kR|HwlU*N?Y18qC2BI`IV)yf|JAa|w +z<3Rr&qnDcw)TAO-w}94Qt2cdmDd#zJF8Z;(Da4WL{$d-;Ap2{GumjJzY{NLmCAU5F +z@Q)dYikf8?Y1F>_3vD|ARm6Xr>Gha>#ma#E6Kt96to4OYR-+GCL&0RhNwi>6e;cmHp-vmKvyLK5E*$ICHxre#Ct)QmA@#N;GVhkC>GS;v4D_yFHj= +zAbkxiudpxrmY7^DcHrw*J;D+MoB`?aX|){Vwu?`InLdB8VUwbWXCP|uv`nMU +z3z0=bl2+iie`)`_PG;5XF*}O@Thyo_Up~Z#7>~Gw(hdc&Oxn9Vs&r;EQ;2)|MJj(Q +zx&4X8B)}fiS*wy<^Rn)Lcmx*sE7r}7?~bu5NU@MhA%bwHG`Mu?Ezk~w-QS>5;Gs{{ +z>z(wahmN^$^|oLein4!H5JdTM@cpClQ8?0at%2(3yTU);X9*ICQV@yb&uMSRQ4v5? +z0!gRQQ?v~{M)0UgJ>s@2pH96Iox!|Wnk%qM9{KPzViz_RsjmlF1Kh@Zx9*q^Z;@t| +z1n3fN;YDWQVUO<*|wwRJ=q%gEYF +z-cHZdX^X8rhvb|Jw$i=eJ^tMH$FUPjn);IOR#qQ-A2%B#$rLa?RFr%9&Pw>vDR5Xk +z*a0U#odq*9i8AUqByrErGqZ>9FCX_eJw)~0T~gD7JXPO#IE+cfbUD-`3N;_1edq~c +zOv7q>DtKY~UDc22kMMr5pif#=;j8v{A}kykCj_qB7`11WZcX|JqlO}Qjs3?Hat@Wa +zp|!I>(|-FeXPkuzCMXR!wem`Lt9O3`_Vk%01;mba=e)@*1`2=>iJ#ZK}m!Sz0 +z;FkU=bIPwVUj;oPr}c=s%nvz7`+IxIV1vg9qKP9{YR%RLydsO5a>IFhnZzv>MeqBH +zwxb<4?cN`~uCJ+8v{V_I+38Q6zbv(UF8mdK^VWG|)3YCfAD{W3x=cfel_zjhTaVV +z-=arv((xnvTv1HUiaCBC{$Vz<7ImYNv0}4)n33DEgD&su)QnS}XJ#C2yuwEcW`nq01OV%C@7kRz94% +zCFsR3+K|wHBW*m@(sDF=7M`(oBq1JlqT4kO>fk9ulfMksRF6b{0u? +zdL=N`Q1Y>kjmi}AY$PGNYCQKHIk*vRsB#H)D9Yb`%gD|(=#fJSGiY@~PG+`#!wy6X +z-aeu4vv)@ll$KA^H2=MKYa@y5?_S-7FN`*zxAe;S+QB^QBcpH6Vs_dvo5(2kT_=k9 +zyrb1(o9gJ!kwAU%vIhGc)?T|Q=(jkt$y=4QQxhABY%{#nyOG2ZahZChZaH@~+9u}g +zHahJ{fCZbVzcWUEE;QP^CO6q~iLE?-YbAp)56X$LNH5sGvsF;AO#GlXXy(FYrEIerzUU6Ari%uKQ#2A2eacmh@hY?k+0Y +zb$uOLJpnDgl#|VgeD{qjuaAiiv+}yVseW~|> +zFSzFa#qh}+MLec{B(e8HmEPwdCKd?Zej#OfmqtrN?>79}Q?Nz)sZGOS|5#wzJmf*X +zN&4PV%b1VYfm{r7u0S5@=PThAlr0lGES}=4cRlE<~)EqR}3aD&Q6{tLL}W*Kb~Zk*Y4O!`G_+{|=W3Ny+R@3=r;Jbt^~_k^H-^5igg8G#}e>}3BtkZ6s54Y~pr +zE8MlE6oer;b%aPk{d3yL=kR+E#@LMp?L?;~4O-q`_BR@nboU^`+<%hKk2>LX`odX3 +z>ZrYSlLrq21`Vd`70Z0DmN^xD$^;)s@q_yGl_qNVkrsorXVWN0QeZb(;DfsE{x5WN#O}g-QLb&T9C5;q1Q<0;v|ltE*MGPh8dr`Ok8(* +z*Bigu@1ba^0&p3cPMv^3n4zFd_FcqVwXMYiV<1o6Cv-WyLt^5OXb?jlN4p!b&Fn}l`#y4hspBBQn``7dNA +z(9Kng3z^X7_=jHHY*C2ZHU0qm!3t|h>wG43k6(2vzP-A=bv;511~i1MZH@^KUKS{i +z@N%6p$$uBF#gX+qhxnJB)W>uBxM1$78`^l2WJ-t{RcSE>^nvd{ujhCFV;n=!#i3&aK}}?r{nt +zJ{(>)2S3xw|GWt~3#A|--(FNj2AoD*NnQ>l*F=qpFLk(QPDIR^a71E~Fl||A_&I3L2j7Q#aElV;=gFfVTRD +zmZ{$uo9fqNB7h5YUSoU2_fIN_q{?8Tm>>2o`FA-`%WOd0+|pk~A%$rnCRoZG2@2(TWa{ +zGJd>C$<(@MiRjm+K%nd&SBsDX6wC_ez~k_(Xi&~fnT&sIUI`)o^fd1>^ve +zm{n1cPD5F#zbV>J|L}?cPv_E`?ur+VYUnjhFtd95lD^t7e0DbgMVnq&#n(!i}!;HOBgDmRmN<*jmCs527zrf-!niCeJJ5(r99XF +zgg$K(vFi8`No*I7OrITO{B_GkCQ)B-xEd*qF*j?EA!)Iv{VAx2XBcq|3*e* +zOM%pjB({za+mo-=ok7sUjD?&XkColFZW#Ybb7-d8d0I>NyZSZ$(P^G$c4C3VH*BqY +zpJ-cw9V>~IXcD|)S;`bdQ5j{j&3lh)z}Cf4=;w(Gf#j#?4dm=6KTc>NyQWf^tcrv* +zw{BG&DWE`YJk~^wp=&N +zfGp^w9rUj8+5E~3X)x*)pZeU)yq32|${`y{sCW6=M)GE+c)nQ>?;3hNExI;j<8K>$ +zgi6jFB~r<5QYg6&4&2&&wH^Cj4Qv2-&AxPw1gDm7w&<(V(SKk@yE1#3K-(K#lS^vS +zkQ*im9R>{gX=OBhIEy%d`JP`pJD@MFS8R!3T9PBtnML0g&Bd-Nq~H9P)89+`5rxz# +zWb}oGCY{r-)bht14DRMrhSKC!H4_oQF~JPszA8Lwq@i>dsncx`r+s1frPg~q+ByG7 +zqTO-fhQoG0&!Lxez)|_p+G(9JZ%YuBX=!!+mm3@#qMN(nsy5<#?g=h+_DQ}mS0f!O +z@BwA=E5BqzX{0W)AxWnaqV%fvhJlWr^~jr%9LXoDMx0A6#-IX0I9A<)j6Y>OmF}Ij +zqDLKQk%ZuQi)KZ?ckbAL78DKDKdCik42jw_krr$Cm>Ysh^g*E-Rm#^527n7dNF{*s?)P7l;UP +z9=Gd7Mpwv3!HecvQSfko0RN@=favZRf|HOp)M2zleW^bkZz5e^+_uY8C-H_UhB~&( +zJ93zr>$yWYBT-MHTaR7&yqixg;)jRqdT?AAm#>c*e9BUBX}|aT0HO(pQe2e@=DbPH +zo0+jlK{BD)_?|2~V>wog^UmMV;wj6-I;vbfrJWFifxWGtC%esxSfs*?{@re-!mIh+DiPnVu(i7e5)X!xW&q3T=I^J-k*R&bowW +z8?j8hfpzQQ%oE3TG2D5T5RE+B#i_xwE+C|&K`U)5VVWOYuXt!tUueIaFjZ)IQjmHe +za&6Kr3Qjh`BkX25!tpmDPNzmY)Cie)wU-nAD +zyjk3_prSow%`oSiE6-hn$F<89DHw<~>HA4O5`U%&Pn`9ibNYYEc{HpgBvGlOs>l2v +zsa*aoR5WPwZy~6;+}wqA8W(bb)0|)W8`El1Vib2ip)zv&lDC +zvwpNwbuS@8k@I-sHqn3Ecb{{?Gc#`#SPewRW~pw+(oS3qBs-Vg^;o@WJpQ#k(2iZS +zwxIE4!Vl!CFjs(dIHxPktfUkR#zG-48^xO~AJQ|Qn_`AhFCkl!II8^P#{aPdZYQn)y`OAALHAgPVhTBEhbLPZ*Qf_PWcnvBEk +z%}3XwA0zD`;XQ`;kQFM2nKA(cBj{vhyL>ze*L)0?TQlh$Y!(#Nmd|vD?o==Ivu}P6G;@yr_bA&m-ATo;zy_N;-8ZNI=n5Q*pkC;Uo=8!-Sv{9I3uz@b1n%UY1Im{@D!e| +zEG(Gqp0B0CxBV~Y~PuJ47Xso2Eq0%D}O;Q0i%MZG&*mdh+W=Mu=fMsD3nG +z+_`BfmIV(W#GqRsncjw=l3T&Ipv`WcJ9N+tFJgxW+1S_f-Crb-#ZVczRO|%zv(4u5 +zCST)s@&rCmQjpmzxdG}Y9bDC#f$ZX%-NB2-PfBFu=*&15NO}S$8nCMSVrKk5LRjv +zd$QT7?8SJkA#lbw5X5-2c(W%Cm2$z&{j)T0giT1DE->!%_xM=p3_nxF-$Ewe(cas6 +zuIUAsJfYyjg;*Zh`*qVy1iliU_gG57a<47o;NIZ_q2Va3^ +z&t)t-lrlb@oOhRO8_34k#D)x+0q5)EtQpKsDKhqs +z_0!9{=~Z1bV%ZdImqKcs+U^zqobWb8VFMT7x(%E=o!Yu`caV;wUWa=fX;Y>Rh!2Z* +zV3w_%P4>FBp4T)#hK&y@s9L-Djpn)oyruX(xGKVbDE96B(Yzh48U4yiP*mj7LIoY{ +zR4b>~{7@G`1w@hz<_QyTHXEInPPv%xTH@@_smLqC8`YM}CHLm+TmMDigrB*B_}K5* +zS(7pklhGRjfnxgo3*!wCd=SyF42n;5evmPaG*Zv>@q%`G?);d+yo^t;_m)r}mw&MC +zWVvJgO)urM(-HW(Q7%M?m!tj@y +zcHC#ulTEj_v?1`S5 +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 +z{b?o|LpK8{AuG8qHA` +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 +zsqy8m#th06Wc4Dak_ +zW)}Xd0MlS-Pnhv>7~LXVKHrdx!=$?^(=INSx!d(_R61AYK1Al+1yz2%w>Bb4a|c5G +z*W+gh +zAMVZcN%U%4JKtH(>k46lZGUHA@&3%wd +zMJE*7_W&9k(iOzggGALu@wLUABI7F6t8_bZI-^=MSdI`a71_QU@cl)58J +zmcxTKg$GjiSk2mV6lunl5u#(CsdRp##W*|XQ`%46iM`~nfD&-rb0 +z43PCp>T~hk*W62jTacp-sd2VdEBloLIX;})trA%n9xfqXX5vc;`y2_goI>+-4>5xnv0sz`}5-*raKX${bK{nE9J +ziYYKlI?156PG(Ejmt#7t;gVfv(wB?xY<+)` +z3>AAJLS?R!W~MXB#f3AF1m&Enw`^>2zreuv7eXY+#oQbsVgNVsrjOtKW%t1u}~6I1uFzu2u~cJVHLP8y8tX{#f2P2%D<2&jXF<9Vibo6UpU=_ +zX5cvqNl`O5vR2L1A~0 +z$Md!!-jqP1Z{jlf7xtWFB<51UYxFq0)HLT~Aa$m+{bIVh*6u|GmuYAw>mgHiB37;2 +z|G@-Aj2jz-_)e33;=V6Vl%{61%5?mn+lCz~Mh2NWWH{#DZRp+{mX8L7C?K!CATn^Y*y4clokU6ve2i|DOne( +zE}9~lVO1<)8nvPf3YJ*Q{@8z{SS9^63h=V`i&ZWrIUVZxGLr4XAaZ}8=v})N&H6TV +zUO1%ZrUmG#(Cbc3!5uo!yi*zj`s>Krf;vIpkR4*<6tD$8XKxdXwhbAspUogwXJU&w +zj>deBosQ_M~J{nEcZm$~7eUg%^M6xJdBz@uwvm!B4J(;Qi7i}+y4G=GcLP8g5E +zt{m`J*j2xb6*L5%-zFPl@QF+nyZiAu;uR9#Elu>%Xi@wFVy5>c!uLqOHnjqdQenOr +zxBLPkL0d3^MzcTlwCjYAz6EGL6wDe)oe;GliHbBmnh>TK{H7kE@W`YAk8H5 +z4pwjn-BFwNC)FP(#alwj-@7)1@ElK5?xiB?7j8OhyO}l0{-S?g(Wtr@1=ctDz%i9zKusG<#r3E* +z+D{TZ*l*J!Pn!>-?Sw=Y&q26ooIZUGO5?CWyVOPR2);%~`c{$KlVrx1baoCST@@4L +z5yEfo-F;45%%&32{@>u3!Kld1Ex+c(MnYAQ{aHBWMv&Q~kvUwg6)5Sa{2aIa~r +z?mTk0S4W?7E(=XJIQ43gdQJ66h|{l(*yrc_>S^Ohc$b+_E0napv7I;l6Ot@=l88OW +zx-NOq!NOrQrEvMeb%6X?zoO^O6g0#Y2s0;Eo3#XwSkJp51o*6L(vZ1b5VCQSntuc9em{ZU09DKoUR{X6}mC|UqLC-15yx;>sFeyoK5paMq27h +zsXlXgwdu3k*e3Ll3AvO_CnT?vOewBp#srba^BmRL)!`_jX4}$;n+4U)U%O}w#rhnh +zOf1B2H;=;!RiV~U2oqkp*7?xKqNF|fRB0i2Cvk-ZCX5nuq}?Sh;vg*dKiwhj@94B{ +zfGU@!1=zeCk8}@RPwLlk?3+gKtEd8`E~~*@?tf|aUd9J4wRJ6hWJQ})}7n@KBT!=#hp?6=1h%|w-;I>y4(ngAjHsea{MB+z1ePJbu8QM +zsE3Ca+RU{HSwgi9R;T`}Ieq`qo(I2YmF(O+Gw82LcVE|4?tXX(I=|KkjYXlx?rmj$ +zWwKT%WVX^xHR3FWaAafTT+hXweh1XQ{@Q)JCvDmT?AJWxPFQpLb)fq!)0>x>l +zMS~wxk40OAm@Qwh{LHX_LwtrdlVg2?T2UL-M@EB*2stw}v>g#AYm3>3wps3b{;~X;|*l1Z%@#!e>jcW +z-O)41w5VC!p6=eGM#Iq=83sMbca8O5Z7D^~w(8JHcI6vA39nM823QZh5JT(#B5QmX +zi+SI5$)zOVEds)4nV$+H3@YCJH=k2tk0@G;AI;aVcN&Kf=YEqAmPe}7BEpWNn*Y;U +z$@Wq$z#_vO}z66r_UU763C(jiw6u>tNIk)?#{(N66rPTOCV^l*w0J;%S|2H)n-LzyNB{v&-0^_2D<$OHecLIf +zAyuJYtK4ad=;d1UJ7~b)Uel9ReSf4i3%Yvq~ +zIBXF;^3P7xCZ#~aETdm*HL{;HhD~@uE0SRYpCpOur(aZ*jVlUAl<>=y(0E<%E0{CG +zs5U7@=a4eC0apeQ{NPwT!1M{vO5sB{WB;TKVTfDg@ob28ldQ)n*QD +z4+6`@;o_}%_37T?&F_{DTL=Ttpe~3%o$6x4MJzTkG?&$9PdxE5T# +zREoD``>vx@zbqEoj2`gM-A}9|r6TRl~Ekphu +z!wn^8NxN<#S*rdIV@@FbB1OA^L?>#^3M92WsW+nlOk`*wza;(JPs|>YqcxBY{iDRr +z`1isesHR0&t +z0g2;PY_40leiy!Z7R4N#mO_#Ud?Wrghdu?3c~&Z`jH$oy{8kqMa-5P!fn!{q&g*5`ENrA&jaGe&nrsN +z*1^3TI&MAPXIhUT0gnUHfhV)ow9r^D0MR}l(2Xn(1m~s^vq|71^Lj)dh^6q3IF&rHuX7t +zibNh;#9G)tbaXzo0V)7Q;@)~v;F5}#0Jm^3w*U8Xy(*oCuw?LmdTH6|J-40>j8Pfs +z6^4ZSZg*{upfpoz2y!x5PyJZJ5jlGVB{9lZTH5mV06$?45(lL@LQdM$fCW!~tfWpm +z3XG9K9rF&U>l_5mfCFC5de^AUoZO+sNW{ZsDEiC#ue%E+h^ZOALaf3_o4xw^VrnM1 +zUJI@8an*UL>O>mqxx+6=<>>_s#*YhZ1UtiiC6`;+$)etx&q6p}8qh~-V_e%glt>$n +zuQ##Zb6;0_KO%4*>T>;37=PW +zl@U3ksBu$#gc#PpZqAWsCe*>kf=N;;DocvUq*7i@I3Up+k77TN3mm3O0oGn$sWmXz +z_vXsXx10M=dv}UHaj5)8f~QRgZy%bmZ4Mvn7JqT*oOK87d%7>MJO1Uk&}q%cGia;! +zC|14Y@|cb6M?kK-mc;2_Fzt2+}E)X%{CjZ_Y$_XN~f7^L{JT0fMBy% +z458$aPHq4dZ09dD&Fv^=BeLc7jhlvl9-y>5e!6VxOKM@r8au{ +zJqABv_#zD8y7{%X8qXuCq~cj}H1t{5A1OCTo`{qS4Rp|EcEp>svJoglyw!}f8Q8t$ +zalY=Zo^~i&@8Pw7rU@s6e~fGtU%Od +zAe49_ut)MtJtjJ>AGG86(UE3dt8OV--SBSv#X7_d3Y2Yc_Cs}g>^gkn@#5f +zy^%+7&xqr|^8lN7%h8qtv|~!ot@>NX-EL8ul?3S4hdbZ&^}j<9R0?EAJA)jJeF5$x +zXxOu1B6+Vr_kLSBfl{piZKxr8`+2hbAyVfg0GaJ`6}oQU$+19|7frE-yN#+5cEgGC +zv-somIC*A}Sl$`A85E=<*4M);9}pz4`fpY@6^$S)2!LBN*=Bzh8cqKBIRPmxmB-3N +zp#D|_eeEOfG;RE8<;d80136SG*OZygAblAAf(r!(V_>GKdj|wAvdjyS+^)nCT{);l +zcCYbh8z(w`iK^u#=&OjZdIw%h{gK}(4jnUtED5>Yw`J@eN>u`oAMPDEPCe?RKt!Pf +za3;0zPjruqnp{ytX?wV-gCX^26-KmrQN{`V)qu2 +zbIuI7`XL>E01A|n9GZY_ozXbvil2A>aKD=>czf7qUg}Le&UFl>c1b-rwKClq^*2?K +zfE@=QQCYfQ=j=j&Gn@s0sw|i~UV0SWWumx-x9zZQr@>1BNm4?Z@kz~U2noy>PXG^IZg;nQPD-*H*Kl*^=JnKR*M?~ +z-si`Y&0CWX&&-RVPM#lCk69UC>oQ(e6^{-O1n#o;jw=ig`;SQZ +zHNe=H_HuDYU8I)mBFMXU)R^b_(r2@g60U=bB6CC+0_^@Da36rzX*rs8T8_Zzz#2y +z7`?D=6un`A12HB(o?BfkP~q2cd$TRr8whGVHsHkjKUu2Y9&L +z!W#)6M^mDNvjnaiEqm0Amm*v-4tNF^zKSAwLHQ$~wrv3W_Pn$@50aMD9W&FxCv-Vl +z^~7xlT7f;t_@WzCNdY0dVyGSGVA*(yL;Cb8{CDaRi32xGw*Ktmu^D|0VD-*-bZS2R +z5qu2sLb^UNE@46pF`_1?4fl>Wg1d5W{TyxXU5gvtt}?m7u)Q)WVdbHZEK4M1V?Z~5O>_kR8W>M$ku!u=gAd*)~SBalXW)) +z7@!F9A6(qIt?IWMdr(;)2Rgz$`Dt-aO_Il=NH#ZtT(GbzEyG<8#o0Bv_~VOdSxv#q +z(Z_!0;z=QPd4HBLvrxt+04fN`&vobHUQrnqK9q4p*$%|4*gc+#o^y-^7}53p^`3(7 +zD36L=uf;RuaYjky0+g7NK)U8l<%^9QenE-rAZQnVFH}wc5Y|D}Mc{Ndj-)PyxoJxj +zN}35FKm2k>zc%Xuf_N~4qN^@T?Az;t6DaNu4bY+LI+M^NOx8pAIh-oYGtF%k{T}!(~1-d`bO954C$;*Lv>OZqvVW7Ala41Zp^k~%<%aL!`Y=sHZ=iZ&(vyqlhs6I{P$1Do +zX@eq2>_5%gdV#kK9p@3~i|s%3z4||t<-peou#j*A3(xEqOQ=G)D5(1B+mQM9%S3c0 +z=1^aC*hcg^&Ix5|ps2Fensb)X(A$PK+uRS@cuS|RQYk?P90iG*Pu0s!(}T}Z$rkLI +zR6aVY@6ju^+cT7Tq`mBnTDI?YmM!;^4fqZ +zOMn1h)${D!P{ji{)cj|kGAjFX`7jhxG4TKrXj1ReSVn03A7@FEy?u6F?2-_o +ztH5fGi-|p2J;PmGYMnIo+de%5bbb>Qm`tBKr#gxD|Bl!(u0hJanV9JPoPu^PCiX#9 +zRVP2U>gENshD@k0aoy?1A!>9XSFI^X$S +z#M6>36br%GYdo8m6Ht!|7)qg0|F)w#&&>8T%68KCi!~ES8(z;iQ4mU>GT#)CwZS=p +z@`a<&Ou~V@gw?6m8>S=bg(5)~A+SenWnQ2Bv+%nukO$2-&LVuPPE92AXb00-2`W!1AdS?Na(BeVp?BBy=Z>W4eU7hJ`dVY*mAR&wUMv +zzq*l*UA0VXZb8f6#s-Zj&pKOx8TN%`oj4ZyKlCcJ7zZC&w(P-|k>1o}WklMV6152{ +z;zt)thbx7lP%tG@c=PIsAQjYz3w45wnxgfgj^|MJk@Z#P9?X8(TNHx0+yH8)a|SLo +zTN;c-ZG2D{=?9bOA5%r{n95r*$)wqu-qZxXtF@IGtRsSDH)vCi8s7>-DA_={0b3|5Q@RV9A_p~ +z=BlERcY>3dQm$orJaE)h;czyW4b33-RYwkX=10$`M1rF3&sZE)mbYX$od|V*aq{w= +zVNn@AJ4DZ@Wr%i%dK0@`D~y(lzx|7Uq67k|;zl+%Ta@OPwIDv>#7YU0 +zXCI}u-0%1VN|umsI@MW;#`F5ab6rq5C=F_07Hu8~@J99HPzo54YPe!m=8od51M>q1F#_5=0Uu<2RQ$*{wZ^ +zcIf~ln1FAYL9N<=aT3{0RNWl~?~8HA@GHB@6&XZl_x9P8o|1nhg}^lJ|hfIEyMh +zaH#uwV_z{voD?@w{XR95tW6I~i78w?e5q5o9E#5KXPcUSXJC}LVYkUr{)o|v$?S?l +z1)3zFK257|e?5KH8A{jS*J^3}z}B+-s`sdtgbig4Rv-3Fe)Q1|F$gr=@}Br*>J6Er +z>5@<#)zF@K`rg`MAJ>^21Kl^3i6Y+veTUHoL4}@SU+~Uv5*M^8I&`Lb$_yT)JVe|^ +zzUt%v=#>MRC*h#>GCWQy7yMG(w(y|i8q~t7Xv$8WUZ(4~48i)4pns0VZ{8eojYip5 +zB>d{6VVkYDiT(w2q|kDEt}BsNe@B~ogwGVfoqY07y3NJGRNV*(eK0ZVoXEX7s2xI4 +z%ZH_1xASIR?P(pU5aJt>?V3+>jz;w% +z$qEeual4(jR@T^uBSFB2hSfX^i=}u4D&J9HgV5TRMLIJ7hxW(}mN0XL$SBx%2@;|z +zptuY1eVgn?5IHt-@uw4*a2=ii4XRZ}j2GJOo&1B#evd}Qnq{RD@%X6SatH&$b&OK- +zi!7z}qi{pV2q2fDNtW|T*UH$57y*ER0+vOBi)sTWy0@W2fQ=gy?X1zZ8tG^pK#-o_ +zNZpn$K?(_fCnrRVDBI%Mb;$AnREdUt93xLVd@A90tJwn}tHb3y5Vapec68n`PDRrt +z%jLwr50d75UpjLm+LJMvoE%|$&OcFgh&DL@Dqz`?r4@P{X#%oIrn64;;^xJ$Pl!cu +zs13XB*s=TE#SJfown2$X92ne?+&AgD+0nk}W9VQ_ooA4>HXa+lUx@5b%qHv4L(9bO +z&f*ky{)@T4ubM&41=G*O-(~sF(gvbK`Yn +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 +zd=2FH=2uiUP%5azR_~M&rq3=8`U)_4I +zijHc|IZQN^yE%zp1_j?bkL2@|=D;y6;!DDk@M!NKq~@z#2CT+cJ2odu-#Am|F_YaS +zN%zOMZg2NNGJIkYt=gmIqxrF=l)Z_MKF9HwJbgd*jO^J}iZl%l4j5dNy6r3ZFOWKF +z^@9Ti(@RR$Bvy^0NMzP3*@vy=u|kJf74%47R;xogX+PDSNj-{RDKkwM+Fd^JKpTA? +zoT~LPQK^lgPfk(K0C$drLK{_Eq(@kgLd|JObsl=IjPfeP5(}c0r+QQU7Ma>3iDth_roFXl%Gk7;%o}J> +z2(+tYFF4paTZ!7BI2!(qCi;yJK|B6i$fR}y@c($Hojn5@-#Kh7ma;ulNh=vN8^4tf +z)?G?b7XK)vt6THGT$a>ibrr|!Hjg@!nI}n9H-0YLn=Pw1nqlki{W=$nFcuHonvJYITrlbuL +zI$ecTX4qS-gVYH0V`AAmy(e(is#0eKu{4qMt9ubTClTR0t|OQ9i`#B)i28|isMt#( +zcu!r%@tI2_kOvI$vixjsi$Cuepy}p89Qm%rZjWkDd!+UxUkY)VId|L*o7Mz5qzrlUKk&wjrKNhrX` +zpbzPkHgKd`$TD0Bf$(dM*F@ik4kFPIk}G7|>?>TJzd>33r?mJ&p&9?LY}5Hqen&@z +zbMaSBjgu?;JN?nCqjQ8L!{nKZ@cLVds}v<_Ijf8}x|w`dUZbR7dwdcUO~?Y0AJ-N} +zQ{N-^pTp#@qVj&(Jr-%&Fn!s{eY*ZS!CgonDdKpgPC+I@W}~tWNBKDjn+lBJ +znsKOBQJ6C7;IQ^p7D$5QDefSTaB;iJ&(+I&(hDe&q=<-xbPL}f!X{FB5nmu7`HQ?8 +zXxdInEKKD9Q;TSmB`;4#v}0XL7!n2HV>g<3bx!LR{Q*n)>4bVMR>y~&mUlM}2Xmgo@#=E`_MY4txW%#kQ(Ks2bL*F~Ul +zj}my~f^KQ-gO;c;7VfXab64u|sRGP4HQ6nJ@0Wl^g`y5^*W|Hslc{Lu#!KYyPmR+N +zn@L9EVZaQ7%{uRc@PJd)s|xf#H4MwmX>&%iI|OS;I=<9aYO`3ZXoXRP<#^xDrI@P| +zf~nJp3h8V7f&#x!M3{6L&PC=qzNko;d8i}qzUzn}aQDGUQD9ANP`x)B`Rf<}U8Fxw +z>hcd&R;noZ9)R;g?R~ptp+%_vz06>f|{2TeWIGBXC80x9U;embZy +zZ>{#G2j^-gFK*{BQZCqxyy +zLTN!Zq?GAj8c9xSPsW?&I@CR{85sC@(JB`mi34k?z`G`R_pEol-&99Z_nJOJlE)No +z;?kIN5EKvRdM$ak`Lo8Y&GV?F3;XpT<8x1RnCBjp2xJ1b+pb!xQC^P|?ove`97y`j +zO<^RTTaKz=^b{4w2`jXwq57p(sDASpwCcPaOvV41FGI+~f)=)~0glqfF=e4-w7tHD +zq;h1$;!Z}c@jyiB*`T;RKUc2frnS*A^rkR(~B +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 +z4?fr&@#tVk{XwVyo-Y4db5J8A(B?`_|L|q +zQRL0U+E3r=4<#oiclV7YI3+lCdV5w?#0c^)z_>DhU3*{G0$~MJhyg5EVY)HBDyfC= +zDFFLq-Zf|JjibyUtSqLHNv3kxY#*2UiE@<=EcUJVG;p%%8!AYC!&A^=0sn0D*3`hG +z{=PG68iircc(Ch9b|X_2NLuD7*ro%<9$!7v#Y7jCsA0>&ZdKZC{IQLK&a1T<&u6(D +za7k*E)yi4v3YZ}x#{(ap??M7_7Ao0j=UwaHFGOnq#OwC8AWu5;wN}@afQ^_QAE*&)cd<&ILOMufV<=ykNMR#Oqq6uG|bUr3AL0%ye6@jpUhIu-^ +zY4;AY0y5?Fx4rby`oQv^0jg^f(TjD#q4svP_Db4Id>#p^ +z+xPeXBi2uK-~~P!G21)N>zzU9OEw%%s9JKfvLk_El7j@I%-uB05|u7gHHRvO%dd;83zcS>Ec@kb6BY?#nvpHlF9_4iZeb}7b!6SX_ +zvR;ykwfA28()RV}D~h2SFZ!g@=0F~Sg<~5y1k}X&6sx`lKPPm% +z^!cJp73-dP>(JOlMj(q$TeZRDhd|JSGzJV9!D{U3cNiurqD*dDy0moD&XAfG80MUk{ZHftSC)!11boE8>1^KyoAp +zcaWN!QKr5v=FliJ+Bxj27)A;|n(tDvdy$kNC<$=s<-OY93Qt-5=*~qClGh4~%tspH +za@M_QX@wrHzEiWRQyX$V}%FIHapj4B0c0GFq3C8^j$9URFU@*CE%LVQU*1t3MW{INl^OZi^}G#6 +zQf|8R4E6#CL9<_U|M`&}=#<$&2he_LyrhL9Lw$j0liIIRb@ml17RKS)ioS&Y=84I| +z0D$zi?@-z6m$#76O;8^>bh_iDDV|h-v@`QR<@7{0i?OW%IhxXD>O3#H0tyOc> +z#ijqu?m(8Ft1Af5dTE&OUmkY{IxGyPE^FpujcqndCYBFAf++K*)6j_^Jz0_hqVazW +z)vHYSPO8MUB7-^kTC5Nsn@G$t!hwo4US(kYtyxwRzLYQKh_sTH1uh|@IZ60h!O6m5 +z<9G%AKFH5b=ArNlZ1V0V55v(|nHmUt&1N*#4=2@(Y)e8XO{;Jes;3XA(;M9-CoLVw +zTO2Ji!6>c{KffL)j#|5_mu;Jiv;KJ?)J1o2_gX=~udCvAKUvFPO}tq$O~bW(3deZy +zr7aV(k6mH04fFfPzVVhL2xRv12; +zo;hW{TgHWw%9*kk>k5KiJnh`^SSwG;qLT{VE(g4E%g|3Z4_Sf;hGNi;&SuQ_Eks&} +zp`VGx1=e-ckmc=>-KGHT_hX)x;Ls?NDF*cC*jp-$vmR=ZRo&qlRamax%HPk#49W(| +z|Acy!l`D5%UxaWx7&nCf82!b{xH&y^vW^m%)&_-ECmrJok@00L@tcI*Ah#Ex6 +zxZA)LM|<+~RA%61tNiv#E&&5fhLw$-wsC@A2vVK8l3BriCOND0-* +zaiM`iUD%8%E6kA~L*1wO_+$1w#mUKSLpVQOq}_)l(D3k9u})7F6;i&em3TJRhxbzi +zly8&>7R7%@GT;mlIJdT_6Y)cJ#7$rT-C+5_ +zn^f!%RAG0wLL7K_Jo5M9ksUWkU4DZZ^(3gAyx`4jv~e>-d8(Ne;%XBfZCZ908VO_r +z+`Vk?WmybV+6FkA?)@Lr89EI_dVvC?!MuCS_U&7QqOx4DEweNi{CDsO(Vtw#qQsPTeilI@f6=36GUQ7AyiL5dW#Xq?bsbShLyTMO^g0ZEpq +zP8gRZtFLN(`*)rGOVY_b1M +zLUG2riQC*#d`}GOAoBpNt=8KOzH|f_W3Wp)TMmOt;W<-Qz2BhiC8e!Nq#2v(fWKeK +zzB$&!v69K;j7-KrTjR|ZwF#!61Rf7uD^TO?`^ge}%VyzN#fWm0ZAPbQRq+sF8CfB| +zMbq^Qe-(l{1ZY-aTKS^jIv{hsF!_kaL;l^tE^`Lv&4;K@v9IEHB!e@4EE_SZ&NKl*LJIZe8Jz#X946bBQZfg9w&Q$F{ +zB9kHMEuwx??qyYz74oPs!1?@{Gj=i-2ZDYdv;0MBS!sZ{ju$At3+k6c5eOG};eW^5 +zuol!7BELeS8~0kAo4R3@M72R>XSLi0)Qw&R#Hl79|r4@oC^TMJdMR) +zyeRXM1uzir%;uvEZ4)HsP(sP7e`)XA{VEqd$%Z*;>Cc;+njRvnF9(S`_amYoL+Sc +z^}Y|d#+s{uULb+U$hil;3o6l{0G8BE^56d@I5q@D137rFlD*}d-0=+dAQS0w#T +zdGZkUeacs~$b3qChy)YTYzYzl+*c?wo@=Tw<9z#@41+E-K& +zRX`2hHYlF-T4C?JeNF{!Oy9n8uv)dr{}~VZMVO23rjH)BXGw{0Qcn};X7%yj%L~h7 +znyh)mg~K<32N~h5H=bG~YZXQY=H7U})zFH)NC8XcwJjjMnsrn*gH+Ph +zj(f!>k(yI|+e~=HJytbEbP+(Ng4$KW??&hvlEC(1$9sCO$g-e-Yu({Ct@!boRZFB^ +zC0r@J&{w;Bc$!FY17h{>9>2=GT{2JE9L9tRUY=L3%RqS%~KwcaJ=HuY4cfg(T=D(jn~8>A6jWA-DktW@Wr8H~N3g2B8j$;eL)} +zvtP>Ml=x-j1Qt2x(2eI;XoIq}7!HEeZCmuNJR6-S9hy#kpsBp*5h=-XN;CTf%z~av +zvwZxV<&c0>LpZyuD|-EfmFQq*0l?kUP$p25a_FULSZ(m*_ZPa=E4mpTK+>QK@UT9Y +z+snvDh33HC8@sqUYV^F!`GLNC^EdR_Tyn5gL@&*Z5xvE&>-0LCWtoMTm3CFZ^xR3dANilmJyBt(bN;r?Hyn&dm-foD^2H(Trz_Dptbvh+NA{R=dt<3cjnE+oefIoZ`fJ^C +zpMz-qyMO{`me76JOCR+}n+c2PX*O!rAQ2V`DwC5ktmtvMfj$VbTjs#9iaP3dWeXXV +z*8F~fcn5Czjm4YC=fF)@=cLOFEx!DHqt(Xv$tU&IOsyIm3b +z1-tzf5qwRSOoGSqm8_g)Xs{Wu?$Vd+|Mp-m5}Q>H*yrb)rl|QGRY8UZgBruOs#z7@ +zp1%0M*zwuJFwBSklCwFkD +zn%Dm|bVio6G0epK4s~~Fu7@RImIPmUwbu^ll&w8*@$bC{ +zbkyT+&q`{2lBi^GM@cENv|{c8$2ivqcm6JlndNw>;>LW=^aTqXm$+^%(mA+C_oMNH +z0)`)>$JdW<@5FGze%SZe3#|Qf^2zo+xH0yV+#BV~F+-#9*l&By*I48;s4WH}1g62H +zOuduiJFMmqt{<-DfccdFcRhc_Rl=8N#Io4;8XjKnkIyEMMNB>u8~ortWu4rd?QgjY +z*8eSaOktWi9z&N8j=SI~YsgqoAdg^4LcwepCzFoCZPi7LQLw;OrxXy@%tcN)`It9yC +z4ewGxW(O#E=PoH{We$hP(rro6A|?E%ipsZR;{W%@95xai +zQo6kKx?}>2G^sP}#$pB<(FntUGcUD$i)Du*^ANac}W84h+YEZjDVNat{XRQOf%cNIYhV|Hk*(W1@Up_bRb-m;=vo$7u1t +zzWHZXA7uqEWUwH=uRQa8i632zhN+74fI-4u97{Jv +zUDt9N1=?=YikBw{)FRR6nE*=kc5!vSzpVm-D{(6aEGH^$Uy#pznV$7?z-#I{_b`*~ +zrHx0VNY5{P0lx1(`_dc(6B&w51!9HAKGq<4BmG{j=!YI+(h?Jit+kI^nR*ZMz*G_dY>w%y4x+pXx6L4>pG`>ne%8@0DMD +zwIw<(`gPS?&w>y!jW5DHp`Y+@)N$8b0xE(%$)Buk= +z$a&!JJSF6GL!rIDv2YD+fV6L);xV2hp5;`?44A%B$l+KHN&OSWQ#{YrdcwRrznXU< +zCOAylWn1g7{mf{+#zm`zZb4HTns){}H6o~$@w@>S;~iv@yX}AM&ocPZzyTXNUN}>2 +zoK8XZmhpQg*?au+)#f%sLa>08M{)W3Xxo9I{QbrRdw-}xoGgf4T{U)`xeR$_+hRoC +zR;sJ#7;X5K*fH(30!KDC`!A8lQ9?`kQ{ggve!4qgMx%`kep{4@9eGonxNE^Yq*N)V +zc#aHJ#_C5dO2o6`)(UYbDQlP6SvOy4v6e(lL3=hlz@HW_q-{mp9d(Qsh$&?myPVfW +z&%!+4)lV7Au>PVBbb7l%-bB2c*GZO$6h*_ePcV>miZ=i&-*h3?q*-3If=<-4cT&=?u+}j}SBO)~nPYt^Odg4cq)ptVFg??gDTI(pFv=id?c+VRFR!7yySqaC(mBRS6fRQ^FymJ)A^wGy +zKShU7j#iK-vb;PpX5H0;L54O?JpM0R!ikh>gr|2D8!AOi~L8)=` +zhF4rKVkh+>zrXJzFRm;E392&K#6o`P^Q-(4ZOhp;s1g9{~HEl>6&XsoLKreyzAq@KVHrp{rvk%mvn2=YKT +z%9VRuoXvhN_0; +zZ8?q}bcQ@%f!|*}C97l)0#f{9;LMLqVxU$I~Ql6ESUsoypdx5D%2T`hYtnM +zr0Z5pt}*AY1%hlgn&95`{Vz*N#ZcrX +z>6_{aLS*+=cW$wKoUFJ9nEL7GjoOZO%qAq<6Es`Xhs=|)BJXR6j)ntQu368&LUgRp +z8Z8wjFWh|?DO|LWCGEW;bqCZOuy@a%yD3qu5MTtAzs%fLPCyjhROVg)&2-(I1ah7M +zvaT%jtAj*}U<1^B%qx%0Uc)Z<;! +zZ7WaKOA@#!DRaM(&px-IvTS8I +zPnM254i{u^<#d;gGGgDxO!8AVoN}9;97qtK0Nb4P%%?QFE|r49Ngx^OC~_Z#3Z-?l +zQtS$vU>2?xyS%AbhXmvy3=iye2{)ou4(1VSAm0^;m{%QhR0AIzm=Ju)P>g*w1s|L$ +z3DrY}$~5LQh6CB#D{R8|#+w+;7x4yM6ooTHZ6J5+OVozz>OkE}%Eq*Tm;d?6-~DV` +z6Zk@>1;AO15skU`&;MPUgh&Jc4(4Y)I<|d3x=K(;tp05C{qJ+EW)l2${4eMl9;bDu +z(G!t!)PYQ**w&@2f|`JyfwcX#`TOGCJ`wXd1<-Eo7#BewP#MW-t0Ts*7 +zG#?MEC&T2KGVyZtS@s7|xQ#*Al9^Re6(N0ybcI8oJKM)mGbk;np{Zn4N0EJD>6g$* +zl)T1Op!XDibQ&cAQN`&H`DD&b49Cx0Au=)yz#d#jKHeD`OC_e4@gzXs=hStdvxq6U +z-xz>gdn%MqTc3`yER1NHxSAt!&CIh~Ep6&1xfs}Vz9@UwHj%MhX%s4vkrWcMKKtLw +za7Jz{;CGp6)?>XLOreak58^n7yqc}!tRTGyLLAC#0ZP`lJp94rFbWp1sT{I-p4BX7 +z!O_cv3Bv)yyGcp&>dm=|wzmvCt%R|I7b4`*Tdly`9q%(MtIS7E4+GL53Sl3e*`lZO +zkX>Wk9iktwT}AC{LeYa0xdwJ2M}wO0bnV +z+3E0(gHca!B?-}&SZu`0G%eQ%TpSLgp94~rD2ViAL(5sC`Gkd)V0|_xr?{3cMD8t6 +z>C98Me=VZ07NS^*49MGHS$uctW}*%3LV>=HKzr*N?;LOLVgk-#SM*YiG@ot%`94Kf +zdI=0W^DkYCJLYljq3VfLP{%it4cy&U5@Q +zE%4;loBT9mUaKbbI32Q%oEss=whK_chYS(Mz3=yqH+kqIX02LVWRC>Rzo|c|aj!Z{QqTv(v<QonaHNHSswOd%jg(5IzqY)~RJQW9vS+x3s^Dj(xTO)=B>UY=BA-k*o)U!Eq0 +zM7G|4l)Btz_a9k*d8~rjWb6}RW}jyqyz=SJpUZjifAYR%Klv8$ZOfWXPtSFoyulkw +z=pi$E++bi#Rgk@IT^ucc?6tjrXO&Pku16OV4E4hT;}^{&JrqjNA>Ulu$E3@p69}GU +z1V&qH;qOW;*CdLKYV?o4WxRXJ8Uc$YA>lAeX(f^*B4AT&^d&hy`$ +z%ibwSS%?6vAovc~@fw!E%gq@HM^v;(gWHtaW^s%d4i3naxUITUJMFxTWuOU1u3=M` +z(tMgsa0M72d*ypCzHspxfWbV~xz3Y>I1pT;4ExWQWh1kIBNt!&!H-%Atpm9Tby3Khdovw> +zC0r_8AHH98j&H);>x3PWc=gLp-sM%@QXnLhp(_YHoL0X&tG((mdLs!w!zqqc!S+On +z6PyHbPA|(igO99a$+bSwc$Pb4DfMfUIZ-?A4g&%d!vR=Q8LM +z#$Nee%G|rZED@bEBq0Z5t2gBMtR)mI1#DABu~mUGorwH8g?S-UcbyV4M9Fho!1j5bY4yz7|;V5oOklMqb1G#d#>Vp +zD1%}3P)STa&nebQ)|3HCoRd7Zp<>fl{JSis9g7h;tLpVedi8l(p~JSX5bt2|Jcs<} +zBKn=A6W_dtg`xf_D~K(@AkXr2>=Iuiv%^WoK9~(IXmg(`#Sy84nQ%H(|LazPveI}e +zpsg9sVFSmbWce68h(%v7I2BfLRu^e#Ht;su-Y0C*R7Q{>H1ShUv`lZGqKYlTRN~r5F!}RNK1m|+bV5cX*Vl`0Djw?}LB^B<&egf%@fDGwvN}Zkr~_VoO~-F{ +z-B}daK&i2>$|vnyzfHuJOAyS_>F(pSSw=Nslcdz?kj@p-MO%`tBBT$@iEnBBFIJYm +zs3wIEbyylkYX{zlej(H^ZkkE%uFAT+%Sw^(QC+Y +zj`tRAYp!esm^rA%@suVf&}(T})*l&dUm%V&PWe}RlZB5jWy +zhMZOYNS_9?gLr2;&@76*PYO+YQJ0Z!5E<6F^P5wb5&y&ogYDFO@p5HSSR$dgDUcHR +zOe|Xs*UcSv2Ug1Su}<*L-q0KC0#6zYJYJux-55(PlTAth)^mG3~n6 +znfCU|p^cP)t3!R)Z5cWKQaPdwh)rjaMlG^G{5$BWj$%NV +z#KC+~ertIr6Ukf@xXZC)TWVgtA~uQ&fmTOJcxIIs5f3xw0!7tgPaQK2x#9&eq>c-#(c}JDI{;O8}k60-Kf+||kLs6|G@=7HQ2cehw +zUrU-)rET1#h!OPPiE(ng^Lhaa1ECI@ZfxSPU33^3MoAfTqM0!I@bLH^q>lmFO!nrL +zHq$FN-!Px(yJQ6?qi0Z(xoIgnEU1E>l_sz_5~ZetEI#1UF+YV#!3Rzfk}sLcK@Y4r +zr(hv#699;%Z8_8QwU(RA*$ah6NseC}tqgKylc%6Q4`%aC9b`BI77Q1uwoO)Ar>kA(JgBQBI{+%G(-p9MQg+0IX!5U`Re`J`?Ry +z0@QzXGwxL;8lx)$mC@d!b8p`!J +zv}xxT|CH67NwPwk&IdL(RH5G&L7HCPDeIfjOPSmCKj3Xv@}A}BP`5xlW_>oMuIqgwVM54oGer4`9!@slrz5|P +z3_aIl%q_?K^ilDjq_jCJ#ZtXu2nBKyPGSESr~K^3qv$T+%20%&ZEvsOcMgdIjIJ@LC_88E;FlfbJ5iU27-n{1}L|;%dLchM%0dM~G@CKTrv$<^70Ql$E +zIfwewWc?ceCDrpeU-nZ2ogNN%(%I~MAL)YMOya0u#IECaR;rax1t`4udg@^b{eTP| +z*GVg=GfCEnICB6pq-l93CrfV0O1qL=+2n>1U)ra;vNT~e7;%GBJASr2Me+uaUk=6J +zF+w>;mhOUs2_Gt{swtK6dI8@XvOj+tyUa(Zj3Yqb569B}eZjenOa%@TYR|e}it;Rw +z@%w-j>J!|cqGE?YDG8OM#F8DZ*V^HNwl@Z&C|of-I9(GOA<2HBUByH)lrdM^9}nQSk3 +zW!%f6=3DXT_n}5BGxzJQAKSK}ZBqnnXeHIv^5Dn0Xzf7;_%3#ABmT|{t(^gvIZ7?e +zr->F19zL|W`iN73$p?G>=%;pz!3Gj?DHw1AKYIF?tz@AMmH>h7d8#viie#E#Y9{$r +zn~_FYs+NijYlQneSN-7ASW{&Z=$M9}tx2gVOwDrpKwx~vX5&vYVEN+`s$B9dcDreE+!=VUMMb&QjjPatW +z^n{QT8Ip0kBAQ({yFf;B{oG?QsRCpaFZZ3;j|#rZCGJB=_# +zF3^(gno>5&h1uOlA4X@f1)qmf%IZpxeI*^^C3Wn6-6?pm3hAv)4h$^DzAh?%q(Kjf +zWgrY-^Jw#FG22b}5*S#W$c(PJA%;ZUBANany36(&9%1Znjq1OkbyUg&gh59NZtP&y +zh3*099S5qgR?nv4XnWGc+Hpk(2D_x2aV^c)8>LHtRu}$rpiWb61NvUzOuKn@rM~%p +zU4p`N1rJ}i=f)2UQS%=<@H)L(jNXoQHlsQbsAWB54bPyMJJ>($&Baq&>*cvbwjBzwEIe${f-^_L5)UuMs6_x-_A-CT?IR +z9yM`&j;RuE4-Y`r=R~}k0F-3+sC%(+-Kx94&r0K`#cB#4=JuA+O*1)8qDW8pWY9X}_pzc4D#4euEnX!TNV*xb2r-LC$n{OvAfCjUOL{ypRO +znIT8|m!5*ZyUOPTH*V?A(a&7tPW3HHVytkm1MN}gTUHs}+_q%xU9 +zrFCu9g7~XAy;01Yg2UhoyUQ6=CV)@r1xAa%x +zLm^GY&tGESCCJ$*Uff5Iij6x#pY`yI__CytVGI6W1NpQ-k?H9w`_uIX^6cFVl1-1z +z#nnFtrB8A$3X*z?`6_q$kLHoc%Ej++oowt{$(`%HBCQCXyd4lSX5#9NTyk}6M1_+3 +zv)>|#KQeMenO^3*@YgF>5uY{&OVG(bG+vU6mVh4@&aAT3Qh9;7X%O$k%lqhYJ&D?O +z)9)`MrGt9Eid(qg`A7Db2<(;6k1=11EM7fyGrM1Y8m*Je5sOnhr#mWU#~f;JllU+L +z*xNq(D}|3GKKe;$>9-rmqMnFyZiLms-2ypDBiO6hFWK0NMh(Rc=QJby@#)Ie`#`z8 +z!^tlAU(d9-YYS#XjE;gpiPK+;G9O0mZvUvk(U&Zqsn?0A35p>fgV*DNi;yegd+ +zC}?ime~aGLc<+Jq8;_UZ*QifYJOlC;$X;GFDj3nGXe5>|wn8$%T_+ZlQj*)}E!>(Y +znj(qn-r*)C+uoNa(B`Ws;lZ=hn|>;oTb#w;NViM--6$=Q^lZs1>aqo6UQ#Iw +zS|{#F4|CP_<#9hAncP+FlF=w%y8^TJzP|n=ggC}8!lO^H4!b7EKPI-C5;utLKe_Ac +z|2Q+yfzTVsl{c++r(;>Gh~2{HHA3f}C!MU*GNHO1jBS12-o1-Hy8l*~bP0_4Fq>t4 +zT8oKksv&yv3&_-k^z9!X=%8hluN9x&QCD|~We=0ICN`9z+eQ(Mmu9uD^H006&D35h +zwl5mRV{HvKW7&}h(eg|C=-C|ae@(dCiH&0zXJdALPL2^8u$LCSjd%oOW;S-$Bvr-w +zP{s%2;RU6}Fm-g(Tlt6U!=_R9zbM~B{Ut1D_KE%C*++Cdz +zk~wbg^e?e(iyOr;J{cL*L&k)JIJpWOx9th9x!T8`&zLfy6KsO9<^%`({s#N?Zzpdt +zL#~Zy!m +zze?Sbz4s=+4BO&@KU>6l=XBg;RUe(@ja!LB;G!p)l|OU0wLL~i2eo39V^{e3MbWLx +zgfvs%jmkA1ty!g)(i_|A`On066_3&{{b;Ng9dOV@SCZr^NE%MAoxbfv^5o~U?=+AT +zKATScYIBefaHVX_Q2&fV%g}qdpvli~ZWJr|W`|h({To_iCmg_w5`CXjFtKh@>91LY +zzwX%N>~@kmegb`M*(iDUnp!Qdrq)+T7;JUK$D_=%%QyD!KwGQVMjsKp=h<7QHyoe* +z5_Vt%*&KJF3kUur4!PliAgLyF&hnt($HaMRXJf{Jmx7Zm1BlIb&Jk57Z%)duWvLLS +z#10+gFY(Q?*f}tdIDl+NVfYGWU!1`!%?KXzdTYE?&ls&0?<@BcE<2%Xc#>EH_rvIp +zByn3*fyX-HJB)P1IZ+-SgGPo$C4g++)N7!Wzi9xbbUSix2Tu&la9} +z^692X!)X@8ersl9-QxnqG|MZ*Pc<#V=fux&H|O2ugb^FWrVpCWHu=(&lcY_2M4p?# +z@tIXv^jz~i*|&nF85Nj7L+A&D`eTO=QeV5DWPZxpLYzA3O&{IDZ^{f0cK;3H1!S2*-^nvC>naf1D_NovFwQDvoX^-@@BmU0*Qr^+yorm?6CaJ;Q`Nw1(SySm<#@%B3S8t5JQsXm&2#H +z+~Bt5KUYa~PdO}l(eoOqC;1MZIsJ`Ttb+XrB%XX5 +zj14%3EGhE2)3CGzp%d +z4Y&^`!KLTTlOQ$XyvV@~Wcg`xT*X~gf1|awG>W~`?auU)Q{;#ngKcc1@9*gOls~Tk +zombd*o_Tmxz?Po*iRkNY)9}-LtAKQmjoXM-n1hBAzWL8G-~sVc5{OdFTzYTZw||K9 +zdia`;s~?`}cGQQjKp229FaY;skDra*B6}rld3I2sPuyyABwe=$`TpPaR}XeZ+((Ni +zpA?3(-GBEKI`Y<{pF1s#Pgyb}Y}MzxgaN=emXKd{{Alq!#|b<+d27fwX*kAjY}usZ +zL0D!CY~;JTkc|cxekX2-`daZET|w~qjTyfZeSDy8^&3J +ztS6INmK@PQ4$%x%vKQ2zAr@-h#tXwePcE^YhNO#L)kh!jzIA{UagR7EQc)jWsgT~J +zep@iM+}3NK)B~lw8_k=eyw=(5 +z6V-ySA&ff$yi}*EniOoWH=D4G<*zxo)zJjib=vFJIV@#kT4)3(B4r6Z9|)9p-Y|u%S!8hCc0|jfNUzIa@29X@S^3& +z#{i_O)Gsm_mv&#@d&VB-E={u{aqh@x>4)Uju65Dz&F76tG@Vib=ovSWU|39?znn&PD<^X +zHxmIPCI_E?^ys1-hCI5>@nAp<+!QM2i;fkiy#r$;(Cq5Q}H+FF!DXD0B +z*VV_!rm!JgstLC1?W+Bk*hXwsHdbFdzV5StSxf{dY`DDQ?84#x#mJGzz+G9f+V=K5 +z%Ui^gxGBVUquTB<;--0ofO9zsIQzgE>)wyvyU~3ifhHfXIXx!uMVgj$N?71OV592M +z(X|fAOyFzL(5U!lN=_cywGvpuUd?3`FSG=5#b{|wZ&Y+!T;{JxvCMVBMNJ{{Y( +zY~f_!6}C>iRHXfE5BCeq7oH3Z4YRRj^{GE+(E^D-;W{pOgfkp!4k8>I5ExNM;ON@U31h +zAG)$VP0%ZcAXtcFZ}=^kvmzgfYEaBT2ZW|#N<)(_@&T}r1~Rs__d4S%@&W3=#j+fU +zPw;N=kg4~}gVc`k>Z(T%0+493j|naA`j16e%vL0>Gyb8EL{2*T*|~6R23o^j7krjM +zre-#G3Hmp1CzHcHzBRgr8wAejpK6hrlO($p_k?bGsnw*(3lpKlVsj_H6)tmum~g9jlF5w +z=z|4NM!Y-Bl@R2s95$GkGLbjAq|+7k>spgUcq;gO6j=;NkmWBc??T3)J) +zHlhy!EN*CsqW(ZT4EYLlW*_V^5 +z$i{pZ#_`72{$nO6&8#>pMN=FB0qMW6BBeU98a+%0LFp~mRhh;lB5izT3HjLD=HQyL +zX6jA$FH-Cc-(7;Y*UoipiXwkR@ek$AC@sN*9Q9vr$7-|=9Mr4msoT`3Y3P73xHy5A +zIcol%gv8=b(2+TGo7O2tp|2_-vU7T(MHYP+G(osj#jm}#B_LX1^Xz1u>t=e(&2D(l +zIPqlK{cF(yPyX!u^dy=SQ~QVBp@;{EEwa>YRz03^@WGWD-Jn;&#Nb7R+`fi~Z}%bg@(pW{hr5UAol>JXs_6a6N}LkKf< +z#n$mpRd1Ym)wUM)PQpu_iPtT{O^ec0c7-n4I+Y~75)e1?_x!lH-pkHl)#wDQYp@9a +zc6eJ@s;zJT${D5;nB~3_yt}`x)Hl2G;gv8c^gs_9qPMt?hSBaFE{V}Myc%1LR^ +zU7q_fL;txi~p?i+SAEvlDX&S|||b +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 +zkkUFQ*2g+DdWH{dKX +zqqCth&wDbOzFQRWp~FN|u<|QXe1PIC8Zr*;diVS#8ncfM8BMy8cZY5^e!EXa#_MJj +z(NM78=eeC8RRO7y9Gmgus)kBer8IU^0LIysS;Xg6s!*}@0xZtax3hfu4E;57=usIq +zrP_~|?^Irb(+);VuZ6;z1BKR=uK0BvN1>7Iiq-QCdTN4^+z6w{Xe+sSd+l!G#BLm$ +z3n%Io{dA8Ede`xi#KpQBB +zjEVimD8e}B_Lc?1!kqa?KM02s>O+qgpWLkq?N6e>iv>7?yCJQk_MsYDq=gW#ehB>f +za5J@oJmPiqU}j_|j$9 +z#H_s=$F`XTG^NVLA+et_upCVWcGriHB%RkI2-?oVn45`SmS}3!)z(AK(dEt|EQ6=b$>ac#!svnA7U-x=gt`WO48Z^&L}}P0_qv +zo!j+yeeE3-a(TWS=2YYtt`6w<7cZKvhS)*%TDk@Q@!wbz0O|X>!zZjZH-8ZO09$qO +zglNV33l|1wBQYwKC-2(sVKnA`h#b>g!VTiL>O<@^c|>UVm;s`^8dj<0JF%a*>Y*LY +zf%A+9nR_lizir}(7TjWuSYFM<<59ox^jf4;`+E54GOF&T!67f5 +z(KSEt>u$`39Z%OF15E^#uoiU=RysZx7EBu3W99^&p!D>ufhyfRLzA%pgZoBAmZhEl +z;ZVC2S!fvtq3nvNrdY9y>%`8UF^(!*CH817=(NuvUxyNvA#(*OYO)CU);4(LwcSp-s{H~B34%1tPn;LwJf*za# +zTY4vpSIXc?WS+vNCI<^9oM!ek($O49`4Z|azmXI7Q>u{l-oV8M8vPD27Y`EI+Pkn!!7;Fb$Z%dkY#GXZ(#^3;5ZM#VUPa6$_0tw&A +z*wRl-yHH7%JRL$e_7`=MF&TS4D&VgvR|A3zO*UckQR+pKe}3lw`+)V5jctV^%)p&< +z_REC;$$bDZ{M(hq53|JyI~6j!^mP?88NqB@q|3b^MP7evJ623XYbFa)bm*o3_A&`J +zK`!KxWJHn0>N;z{_FYQP5?9E7OUQw%OpD2co&;@+nNKPcUF)wN`=4-QcL}xNduvsb +z@{(k1o-Kgpm{C+UH8c*1kp(cqYOlJS(~CwGkJAR=zH*0%pjVr?$@K67I1VW0=oYVhdXZv*LQ#zlz32;7Eg5H^$G9{b~+g +zGg{kFWu@cli4BJVG5r;65u=rlT7e;F!@EiNo9O_*{dmg_b2G*}H448y^69sUtKA&lwP(f3;Mb%T$6CYfM+-U{{p9bdMeSxCDRI +z6O2}WUz=mSHG*!4xOysQ9__5CPJ%}RH=y5#c~V%G{0JxhKuephdX>4L_gmN>_;p+; +z3yAfsHS_cEBu3dHN_Dj92Sdmec*MMHE=49c#NCv86iEnRH)qWYdS+`Tp!jhm)O3`^ +zMjfe>YOx|S;g=l(tOgaD`eTI0kxe1A*jz?nt8q(-7^w#^|2P3WN@RvA&UHqKf2U~?8Eb-2Eh^ZAhmVKLL}!IeoSh|n8_ZMD=CuEN3r#n#cN3%;W8BidXmpP +zzKG+9N=IShe$HH{8T}Y}9fg_m+X7X;RVQx3dc}c4{@W9_TMT1?1u(WZe|V6G<3j6w +z95Mbx2Qq(tb$oVLOFh`Yf_joB%o0Ti0p#Pn=yb}j+?GEEmvabFmWWP1Cy$d0p`JKp +zMcnm_)ETgdRx5>6plN?BdHUK~1$jmqupFi(QqGAprXtf#sEe124colkI8>C`GEV_N +z#HZ}^b2}9E5)i;7#CKnu_c3BxXee)m@-LHI29lSwg@0!IS7l`P01WJZ+1Lj^5{J}K +z1?J1YGHv|ydbFf8kWM>uiv3f*^CV<5EZ|oJIQGF`G*wO`0Wbp!#j3ujyb(n-)HzUD +zqX)doYt^$r&shOkL{w(A_2GKnY%GVV@+3cgXy?kQQ&8!F8D3AF{qpLaJknlL%LT4m +z$y}> +zyEqvz$()E(=N_&E3j-?0@^+h5Kl7!~B+kQ?0&DlT=|LFbWC2yk=7)WPRWjBa284%N +zY)a#YZ_nk>f;fAS1B0nOjmrnO)sp1_*v4hBroTJta=g$)?c5R-2?r9I2nTZe!Ne^4)aYGyED +zhYBi$N*3X|Dm8wm(_%DFyC`DYhZpO4v4P080DYGGrMAjtV^*Rs*zLdj#oNX5a9CN1 +z^3UF=E{QgHl(6(1jx`RyO)^Ac1(@F}r?d_`Mn=JEv>f&&%mbx^$1b`pMS@icgxcHN +z3%?2$peroE(oeUcGH=HzG)!fa;aC*dti}R+4j7*Sz9`E)pY-lSX{{ECu8s^w^2W0x}=7h)RMzAAQ)sEIXwFNHm6A*XhvT4d2Vf?WU89t6I7mC+)@5c +z1+0*A(B!de1^Mp}kxU)V*_fcK!6hFAr-;f +zhAIFwAb))M?034@28F3i$RT(US@ht{TS{1O-C!fE3XFzKwnzYbX2me4$Kcc70gj_B +zD8D%^#6Dqh#nPi&-#(H=!ZYDFie4*i%wNszJcHNW1TM06-JpHs9GQG4{!$Bn#)6Xk?H%ALRk4+&%D^>biqQfOi +zR1Uu!oHX$EC*2uJl4C*=(Mxa0E7(%v0{HCjDi;Z?amJ0|otL{>RwLu^8frC1iXU%^ +zsiB@mfSD%n51+nuQ0AE+*GIzI7KY`ORNvo(#$oM2K1=`7ZI;TmL)Kvn^oGdje_7T1 +zAQ_uyX4$Yx!5mgWKs&7w&(l%3#U-;xeW8boKi+$$rufNn?PH2@a<~vW+AB&_o=dpR +zScjreg3&8OmHp~gY%O;TWujE5aGsYf=-6w6aAQ&i)WL~G9IGhsLP1gz0Peg40j7f* +zcsU?m5nTFteHRUh2N~IGq4fAcR;i_=tU|^GkzcnY3SP}z)rG6J%=al|J=Niw1xvMR +z*U*O1HQ!|B*i5_Dt7dpGdu7t1SgL`hultvu-efQVl@ +z+I~7lx6=@Bw=kJ`y(&o=>kWO4_^aAZg#fjV)^R8bI0wy3aS@YCw#MOwCzg~@eS2-g +z^qsHb@R_N>=4P%7@M?Hx5GEN6RLno#d1>uufgyD!Lnvv_F%au!oA2jVi!UDN`f6(dK20e=M|I1&Z_fRhO@K+Rv+ypf&Bc2exvd)>X@(h8=K6c+y +z=$KDXJAam+Hy4kD4%yW9#Oqat)Tm#AJ=&$ux&pmheZgDl-wt4N7zd6ihwqrqdx&fT +z^*EG77|PmzjSTO;68ifGSc;gsKvNJeh#54NOm-C{e;%CSTNdk4c;orDn-TUz_7atJ +z(#NCwr-a(g%+afASLS-mj975;uPG<*FaQ46_x$i3Rz?quw-+==Qt +zXR2SBuV86@$b7?;xn`5ptqz)*rKmqEPu>2R4@b&m)bNiE*}J9t6YZneELq<+5|AE{ +zz&Vz=!9H0#LLwri!vaIG!+!^ysd%QHn&OX5k&|6ScGt`ZG_CP$hHY~Hg$v%C$%$i- +zn3RV2N!q1|yK55=YR~+e$79&bhHL$(iA915_~`xv#SRKZ-r>lC0X(Y7ah}Lbz0>5$$2oEfca%inD21HHW;{PKbp6)r*GL(% +z9E9~MnW6*5)~slWYyq!_BNN=>h$y%gOHt);Y35!n!_4iTXiDjtVtcM%+=q_xKana!gYU&=zREpfjsG85)}o_` +zp_{MHhBCIHA~@@8keFb%zqxKzj?yuIXQ5^E=NmgaQ{yip2kHsUX;k6b_i)|55Qev^RrNjgyO{1V^a)Ws*)eD|GzODi&1LhlUC)(X;;Z +z$wwx^cb>b`)G;6n*ys+92|wv5^zM#f?kYTS42{N^?NbJ47mOJTe`s$e`B4onCTKl) +zkl(kRy5Znd3Sq|_H+9QjCE!!NbWimIHPzvRXy2Ko2IQv<*Q2l8dNZ)^;5iEujrT@Y +z1T&$1VJxmAUk`KM+w0_&W@}(S#%oR>zJ55e?bDr%4D2VEU}Ejq_i|1DxRy3RnQ;! +zhDf+SC!ow~kUy{Wx$RmC3gU@nY_9IYzztsn67t9!15zWXs3_IZ0Ph3|Tq0GUdCzIj +zVo<GEzvP^T4ME($k723 +zROqx0d?q+!7Azd4I_P+i!CwTCKMm)iEu{kmhp}V7Z;8qw8o0l3HGv7=;#&eqyZCgy +zMy@1_kd-H|pIYwrw6+ZkKJ}77+{-I(8BsLbE8$fB2}zA#Nzz_<%$g>FBcd+~aR0#d +zMI*C-B=Uz@XG?)c+NLoTXF$3!Ii{9hvv=DhW>r~8&FC)^4O;-ef^cjaIdy9XUONKr +z{4k^-Wa$BmdXz6SF92oaY(~A2tQ=UDu0WT(UwI?| +zLVWd()L@nz$_GYSdPHW!>;&HdRf*L2u*g2Xqls}-FJ53Z0JP6L=!L0HM(_p=N*2$> +zd4I;S8qbbpK1?V^6r^*f1q7`_Q+0|WKd49gr7x%hL+Emg>+y?Ay&D=%+w)6(u3?f> +z8vqh57iUrQd}Q!m&28Y(>0I-lja8D~maDLup^9SPfv-0wBAaXlh1DyAz7>sWc(?>; +z$igG6Q{R;^inxv^F6$^5y2rl?(%PHTOYfrr!S?ykHm1)W1=C|)?|`jyQR{qxUZ9sH~U^opz*_?FVR?$>tp +z5pgF-W57yNF0}g&eaGZ-bC|->zmGIDE`cd%8~ypK34{p=RS!NYzx%FIGvwWw +zz#+S^L&a$FUhzDXMFYt6UMHk4pjCfGH{;_=m0#<|(-8Ap?j@b7P}_{Ql{D-T#Ymmp +zmh_sk4Qm&Z(ObDWC?LhXZ$4fmnKj~b{1FFAku!lU$9I&=-%^42s-viwc`2=7Pxos{X=pjfrRtirK2_FU +z-2O$J1E7d|Z`BNW)K5dMWiwZ}4ko!IN|>{ww973aYBKTuqCfFyHG%)@pOAM`+_n(U +zwGzq-c{i-rD|K!~yBY)}fQAv*n%AwWc=nZWUW}Ueqj3G}7(E(o7=P!Pcdg~?8MIe` +zs7?GleA_gW_6VmWOvnSJwL`yrSPzZ;V{RZ4&KJrW&b8RAhUD!KB#>X0gmm2BkK|1a +zl*6=1fxds+U69>7cgXGH7y#IM8VJYc4lQhIXpqDI_!(C@WKf99<>U%BchIMt5@FvE +zDyiH6zfIp>;5Z`s4^N(ea`Rc9M((i@1Qju%`kvcFb-HRBi(f~Lhe9Vq_+VG3E*hLC +zknvcpwoeM|0Xg__jeG5vfrq5sePdO<`DCU1(be@~Pf&JZv +z4ZnRVd83}{OXli5YuJfr%7v^Uo%_zrvq1tA-)DhYWX7)~U4?;FjLxeN!efT%5=`(Cdk`Yok5auK;IF| +zu}5&guv}7UKi-?(Wyjs{nU%-=os0@;qyhOi83E$|=@a`R_nXw1Ac|{=N^+RXml>vx +zb^ue9MdyMcBdlF9Ps}{RCDWNpEL;a2&@K^RO*!Jg2rXtDDzT4JCT9$UEH4mrKugnD +zQz*#Z(VnD7MnTBAk^soeJ6aK=Q-zo@qm2%Shu+ZK+`SFa^r%p%3-%O$36n)Z6vvxO +z&CAO?&S?urV}KZtV>)G)_YR6pgT`qv`l=R={gaTOiy4e_dA^CK)&1>m~nkn{E5&K!l>ZwYXeaq_CU1by}TcvKkME3`mzPvlIZ~L +zO?XPK +zgw(+;>t<}E3@3>L;ddC2ef0)xWLNI~`b(-J6l;`$;$798n>8sPX8{BhT+|PYl!Yoy +zmuy7oFi&16Y`ZQt#U|Do0->E7lN!!C;sFz2V%)-aO555n#w2VMbPXk{S0wcIUd2;| +zv-K?MGFPyp2b0EPR2o3>GV^woZ&kykB*LnMTAE>*sZ1oKN&4j$uvzJKk*=j%-Xjk= +z3Lf5LizZC4!K0;tW%iu3i{AM&f{Mm5vxMsSp|PV$l!b8dbU^3sSFc;BGK6vm8d$m1 +zpqha={{l%(v<@=I&~zJh+UgW+ftk{5N|1U^O-3TlkZYZU29&M$m9F&w`Tut@j2OqJ +zR%C3CPo?u}5I&L)1*g9Hj-xBoQPqzKfhbFUxAtw1naG;Y1foq^@NptS!50Y|aGgGE +z;7o|-b>Q%fFe;(0{{F84{jA*>9HzZrSip>WNGV*5IiV#{WJL(Q)1~VRY8_%uWpn+H +z1cg0HE=IwLwv*7YCt~ta=NiNvVny{5yFR2lyoiiDf$U*9pkXO;3XfJ~p#mK-i%n!! +z-!$IfTYz2##Rl%@&gzohbjD#s9$=m9Woc_+p9BDIsX!w(yk|EWJvkSg$L^YygF7)8<_^I;)3*QljU@n0fL}}$)@z6@ +zr_Y=6ZkX5b9h(?5dunM4{u`1$FVsxZc>SrxbJyxC3M+c< +z-nxH3J5E);=YFk7+P#9qC(yraLMLcj8Tf6vVu +znq>bSx9_pVc`}Tc+6E>oB<%Nb0jvu_;xg*fnkF;4E6!m(q3-uhFLQo)zQ{^w2S^2{@j* +z{7sFfZ#PMBn(Mu^3$__e1@A?^SOv8q9<6d8JjSA6?i?{40#aT&G4h&+9M>qmdW?Vk +zxY^f1B#2>!^;AqRSb#s6iSY$jY!Grfu9^1=k +zxJcW{*V*^8;vej4;vw!K>*=!2GbF@DP3V*j`PATIj%meqFpG}Hh2LNBzawF`gSenA +zd0rs%J#yWw^SwMmW683Xrc$t~S?4DGLQ?!WO{AKg+LsJ3vsrj3%27=JOu@_ThK_iV +z$y2?Id2?7A$$smQ;V^(mcx1?RZe5S@79=G0z@y6ju)^sB=H7wh(j+#VVMR$Jbp+qz +zVi{R;+m2#qlhsQU2!R)p@^08fJZPMp9T&466)ym{wCL50&!6@h1%Gr1s6DrG+P%}@L9?sv +z4@XN#)SJB)9$)T9T2v>-W8I>EDUl()lb@;RAq_KXF1`X&$rjN~;g +zyu&?;Sr*iDy>wbgl5NeMb!cx)fGtI8Hzu}}VgE)2?vni92Hw()Zb|p+N;dhkav|fC +zo%pE~-Z7vbE)V^7`AX?|Y+6Q1gx;CQMy|dSOhmd#av(DB&2rg$wOcYgVEJ_C+Apyk +zNIuERZVoEAGI}aD6JV_u9tEBEFBZya +z@Hyu`1tYMd8QD5b>dc^IDg2~nHkWx=54cESpU{fBK-t3LW2G?nW;>=Kk1i>LB3$Y5 +zN>U4C9uQ_Q<>zkqeuVo6_5eZZp~hdw*tFTphR>$@iBp9x5J9~f9B(KXJvL{on>eC3 +z-P`f&3ti3%$+Z}PFnOO~17EC9owdYJJPPvamoRsKZ3$a+uAFiTC58l)Q4O!J*Xiv3 +zj<-S$1d170@b`w9eMq2aZ@L*xyoklV+YpE`3J8^y%FI;wPlBtaLx^gg?(o3Ua|RYM +zO4%@@No;eMl`^*&=L-aYZj^cdmUMUHJpLDX@UVJ*YmOY=tx>X|$t2^gBkYJ~q-0xQ +zBfNQM@-~%%e9oCM|MsX}jAD+I8S=WE^HPiON7SGeP+GYC$M`H`q-JW6ig6>ii{q`~ +z;b%W&lYTvXvX`PKPTjs|wv*(`Z-+UrCex*3kGaml(rpz*eDR~Jo2t4*;jEDv+iPJ^ +z=n}y=Y(2xg{d@2wc``4}HbnVPFK2!94JTWCm9ujS +zScINb04n+}ClKCX&ldY-s+xk#+5H#@14`kS`~EL_Jjq0aKbwmmyXgvGzlKuUuahILD~N~gD@ +z5-y>@H9Gfm=Q`S2*etz`^hXhBAs?-k_axV#j8@n6gTJHhzq54a`Tfld2z@%uT^{OO)59vf8lguZ3Qt(; +za)WlyuM0=vWGHkOF0G8W(tNrW;olRY2=?3)8EohH>xdr&=Q*nMglgrrhT|ZW3Bp-- +zU-z;!A88#G%3!`}?;7&t#Ia#x4vIJvBvvIV8kA+2D4SsvK{sb-87C>G-E@h#e=g^j +zUngG}kb~O={4mu6<+vC2y#YCQNAQMS1^j*#VbK9Z;(VU8K`9P>)&k=5k{a7=|J}H# +zZ33RYFqiqke;2MVJ3=(LfVAow*?^JoT8 +z2;*-nai;FZRHKQ|Rg-Q(E`9dzEVO2f`J^so@=CJ@dlB13#6qKcaMToLq7QA0^_{x5F;x9T|)FeMx(bY({c6^kl^BSwOa>EWy{H^>(D^^Cyi? +zJ>+t!#UUj7hkV(7>0|h9Wv~OuFZ&|)m|R0Guncw+@ixmpa5$_N&0G_REp?CQ%BzK- +zQ@=>L9sz~=@R`QrzV5l`n>Qf9OIw}({!zVz0^Z-iB|;YDtyud|!t3ADz++jsX0CT? +zzhQ+F3N^1vVwI|*bz9l>YV<-T6e#~*@9{d<7>z^?*pI}+k_G8u^cJMwfMIg7^xW=b +zJV!HSf?;)WtNAWgf^gi2)0p{-D`5?@u&MP`Pq3CWdjZ*x!o1Yk-?aA`YJ!EcC3uGi +z*&{!5)3BE(&qEXY(W3Au=>)7a&T5tH +zIP3*jP%y}2c}9o&NH7xUC#YKNy5$j}giIw9qK{IksdnpyIg=0o4ZXhf#PlVtrzOW~ +zkWl5Hx4LnGVecv&X_8=!u6=Nq-=dj?Lw*uU9;Jz!vZR)lH{y0yQW*|UwP;ER(71qI +ziU2AoT*mI^p^R>{rvyZFu0vN3 +zPn0YkRyj)e##ooN>EU&wwlop)@rA1E^9^u_LI+)*x7GYz{C^SH<)mFq(sENQ +zaHDl&-5+_+>>Tkxpl;0Hkmr{05PH3Q2E@#FqsMCWFbh=Ju0lzx7k`(gfb*Khn>coq +z8~g_DC@e>P_Nl1gY*RXJ-2qsRY0Y^ZGB<_M5Qzd3=3i`9o~Suw`pIN`BlqQSvW#*T +zYmq*x#}I!5GwmMh#7kM_F4Tvo1}61kj_(V%m$UHZM6MA#U9w(c;yHx5b-2 +z;?eQ?01h9aun@@0m-fpUsg~4Q7;wh5{Z@nPLyO^9$+4QjohYUYKRm+qm>dd(Xi>fN +zl>W-wgVjSwz0?4{_nW%B>18omxzX~&OHt_N4nI9CUz&)_b<>)gN&uYsWvHgwnJEW484J1@+rxNN&Q{v|>)^`xZ5pzJu +zEqvU4@Xh4~NNb=@LAPjg4BA45B3{Di33aYCgIzgwxWf$2r>pY#NI!Hw7zac^G|`-# +zxvih;*JFZGJzyBUkWVPBH7PeULa`{hfX$fW|1Fy*T#5|=@PMs#*0j8OW*%6IyiOSi +zm#F7#kjZnr%jD!N!Xr)afOl1lAB}Mmvf%`OYP>aS%OP}2$V;B}jDldZ?LYcuezS^0 +z=93qUD;ZIbLWC}Jgr`z`#8zS;ezrbhF$Si(;tG{{3DbM$=LgpdEi6z(2tVVZc7ylw +zM}E6fGP0MdYsBIs3foLpMkCOVcCnYnWR~7|sN{(}0|8c0oHX$D#lU+_q`FYvs1mO~ +zqV?nZ-W4HZZJ$gvHu-q?ijPC!CbTakgcoI59>%T@j5zq4>f&UDrm~-@>k-F|gu=*y +z_7}7ko1Mtf(*WE>%PPT5Og(>qw4-?+V1z0D1@0*`SaZkG@JkAJ~;V +zzT3VB=6J7w7L;7`F4ENMm}E=gOu4#nyFT~c^~kS}9)|k!b=d>EdGpE24McodI;w}nA( +z5l@Ioh2OSl8cr)^M}9?<_XVJ4Xuvb@^?ID<(&+WnOlSMZ0M6*qt-l2eSc{JJTKNgp +ze+@3cHeei-k;jvJWjgwF(X1vzYVhpT&AYQH_;sucy%u)W+;DC~y)Ir~g(HAr=ISEod5wpb>e2r-$tKY?=e<@=aYb5EFr%`Kw^HUFUeOtApPsD +z6(nCpoKCb5FPW3z3^d`5N@klhjA7T4pYSsdl^166*~N>HQIi6wz?uF>lPn9_LKc*d +z-L}Zxe7-hg92%u6ROA@T+VhrR7#GfbsjwJ2V_<`?xWRmRYONPTK1>+%zRa0y+NVzY +z+i#K+(dV+9gtBEaD{pq&T}AJPvjT;x^QJyXu$+&c1CC>z%Un}wdz8yC4d6$v-t!** +z*@R7q6u>!$#SP?R|D_++$G9ml&)lWvtVc~wb|9wfc`?6`7(~~yZ +znwpty3SWGB*|ek?rYp?u99V5MZBwD3u$~kMYWA@9RAv-%1j?Q4oSNLqLA|n|+@{p3 +zW0g6(1!PaYr-k(TcPiRZpRb)4pFJm*qLp7s-8S;<=FxoO!^}mQPKku}CbA~3w#}yS +zsWOF2Ia<8g{cAhRE|Vzy$yv?+!Odx3#%Nfx!&YmA_g^ +z2~ML@+Ab>?yOtS~3FpKgz0U@6+Nf6|qIoj84tJj)9^fX`QK$0zozk?l)s*mOY%_`6 +z(3@(Rrf!B!)b{X;bx%Js>30a5cN6&Zp?5{40;$H|pSFU7c~`f260D$LJaB5Yc+caf +zFTN*p+t{KokNFQ)DToBALzQ(WCb6w|H75!U(-R6GjL5*S)y$d-U8>3^{Xlb(+1bsg +zqBYrb>OJra$-k<_Z^Z$(+vKMI>=keLy=Gx^MU`{P=UHozLmTm$k+U|DE2dhv+_R2< +zkH;tjW2|wUM)Oeoj)xQRV5st&>!$F5k)$)&pe^J{f1c0qGg +z|G9gHyJG2R#VEJysNCnOen)$)H~k18Z~b1}izyr`_pNd+$rGLv_=m{67!PTRB~)SycHwKa}0t?xA1r2uT#?MsD-s=tq;~;q4&N0B^BiS +zYVo1QjMlp)PJFax$ty-Y73Wx|9EjmBkqqbw%*NN`!HvZAKhbO`$?a4wKf;Wba4}3W +zo%A}Y>Z5DQPXlDJ^iVep3d<~-R%ei5M}n_d{N6&YC15iVSKYmDO~xW6uo7@wbG+R` +z^=z)unyUXhIlG!i +zk^8#CiKw|I8BSsfhw++4%iJXYEiu^pmu^zcGl>Ou4|A73A7Ui(j{jb?d{;AeMXr?2`^7IkT;~L+ +zsNvlrPu(HjE*f;*HWKVMb3M{m(iFx`4hEHLs;Kl~wXuL1X8$~AW4dR8WHKwO#SixC +zh6eqx%xuR3{WV2Y)&5`b+UIAm>?u}@O=CN4KP|sV=UJrwY4~f}tey<30pf?( +z)mg!X8kH&o2EMi3GX1Oc{rwNp#lbp?-w +z0Kr?oE1k%0`+7`b3OhmnTari8r1DF!Zm4bVW*q8QI2`;~1?xsqiYVj0QE^A*>)u}R +zjY0DXzjrmVkSvjy5AOY;%15o&6tZesu;j78da&o(Sdq=Uw_yM5W>v|2FSJXYWNnYNow+TO +zFssPXGubPLwYbwtpz`VI;HlU^$-XAHGapTOw!G%s#~R7rOx{GEd+Szz*EhWkPup|n +zfCX{%Kz-x`x%v-SU%9FyE_OQ~G#*dBmYIb1fjr?#KD7Vh!TJ=64TCnw*`r6@3Wrx! +zAUPv4TuH^sdWY)U2Hn`f68GzblGfMhfce1OPwpdWeotcE6R<=v$wUu~!RB%4*m>&6`)&FC+ +zq^tWGngutqxrZ-cWnevMC$eAN@|fuzZ+aJRtN-$mESZ>&!ju-(Mv0U*o`XZ~xt;dU +zL;dl5NFQ)C;nXI_U0Emb*Lff*cMqFdmmcPBK&wkmuNDXTIqvAYd>PM%3(}KSGN7Nm +z_&vUD3mAnxX|<<#y9OoW;VmDrp!(gdJsT3n#}+qzj!3Q8r$Dyynj~0Y?i!%{cPE6A +zrpxRx$Ff2swlmd^+Oqb&RvGz#ygMtsopo0v6(U#bR)oKP+?5hB5(@y=H`Xqo-&E8P=P>aN80R=(1HtF +z@d&TDl5_M8_q#-EV|`~pz}TS{y|plLp=83wnMACwyziRf#?9Cwk#g0QB=7CzPj?z` +zZkJew^mF2~vRQW@D%4%VB27)LqiS|G*)EwWSy&&K;K=KsD%xI&1z}isGh|}USLB8+ +z#;QF%Mdb6Cb^WuNYA>2H3GPC?EMWn!zerv3;Z2*!r<0hQdvpV9 +zeTw8_Lvr#fpt{6=Gqr{(ayo+9O>(i +zh0T`iF{?E2yzifT@7HM#?-#$n;pQAH*tJxs;I+=us)u%@+A(Xc5#e8cOBnbuhQZi< +zrtt35?ysNkZ2Azn(rmSl!pKM2bk?40H0x~R@gr_cmg{#<3-RA*vvJ-)L9+4ZWHnyT +z^)!de8`}kHzV3UZ4TeLT{Bk}-*y(*eTPXBD*1X_sRw8*r>@PE-@%e|P>fqbxrq-8= +zMrOB?eS5B7k}CMxGgJ259mX=gXwEUx-DOqCsX~3e>uEYg^-ST4f{&JMA9)5JmKmrN +zRH{~SKE`a}K3daqx@aKuT*#2C)&So^#>RfKsMI6Fnq$QCe^hv_@RVQm4>yH#i7M{2 +zCreaE@^!8J8#Zu>9V1P`b~&vyoqtFrXYtbd*(01K4;tN7*dN?HcLy127cf5RreFCE +zP?IKq(YUJy(SPjh)tM|jo&4%Vz;Rb)!ML8jFEal%vd8^1lO8s1oq_cD&wV;GW^vWO +zkLZ`|WtLu7c=PSALY;Q?LY-FluM7Tbf&V(-zwhdW+0RRdTPD(bU;FBp$kmpAoAte> +zf4)y=P*l!L{gQ@oWk-)iboHz!rPu3UIlg!AQ2(w4e~xqUn(t#95S6paprm1!vSUvp +z+~)@Oorn8s;69G}_vgI%K6(edCi>_di^_?IcU8bWa&S*->GdFb>GimF_3wW0t~~gZ +zfriex98>ta1^hh*-cj%PzMHN7eQ0pLk03BAM+Bc451)B4BifvTCo1zDT09i$l}oXs}zr`7j4))SNi4d<~32W(Jum; +zmu;OD{W3&Z(9#_0K-oHHsCaSnIQ_pAPf49NTC+!IhUKY6Ypisp$xJQ%=0F$qURc@{ +zW^zjO^S;-(dsC$xa=oTFPl;$&Z=RyRTJiLaBK3eGN8yWOJHAL+Ocgj>^BU(oUCJTa +zYf8dAX`@`PiQlK0G|M;7*Y8vh-B&I<^wOs&^tzhjan9+m$N%U|RD(BdYM!!kPIS?h +zBK6&^a8tp`t}yFUqQ|>+#-&e_YF^hoD}S|O_>!X8yH_Zl);{I<_&t2iW_4HC+@jFk +z%N37n!<)=>CVEbdaLDwU*fcM?XhHM*eD>&@RJ+15;U*QuH(UaWY0RndkoD-=(<7dZ^?*7<`m#l#`cYlh(<+++v? +zmv*3b&5?ewy7{lJdD1UAMGjvUDV|U}mH60NXEM$CF@>5wG*$3T6Qp +z)T!d1XrA9hjcC5_H8B)MuHHOf +zkvE^3zHN%&+ug^MZBwPbJ@cAXF(u-gT=N>?3dIu{McZ{$6vO(J*_`T04iw?iu87E@ +z@xyjHQwX@}lGpsz(@nme^O_@`6aA7ldXtp{Wv}c|F{@~N_G-n}=3beIzb<>tCu1tu +zQ^cvI+uy8E3_A?>S@}6o8sKG$MdRNrS3I@1=5Ye) +zXI+^sZM3I($`#q@je*Vccm9Owt(Ydbb?GssXO8qgPR)PqoGrbmTTdQSVy8&mdf+uHc51|}9IyE{Q%r6p +zdCjo_3HN|Or(`~sshc9Wo#r*JZmQJn0$sPuNk=kQ4DLl(;;5; +z$CN)$PxxT2Go|sg(FY@)8K!TJyeIjC-Z}jK?@SiC?f?JNzBsL+UHe<>|NA#Utj;3i +zZ~pH;kI)K|F|DFf(P>dIp(Kqphi#lYEt<&(PjLn{-5o8f}BJ +ztgfZ&d$8le#|Z-IH@C%GbaemUKapDMz8mFI?E=xg&lPV?-X-+9ef9W~2j6>oo9NHH +z3#*fL{ORu{Ia+*W(3m-1MI~8bX;v?+hlWUQ^%~L0AR!ujZzV1#el{5OWX+N+lbCVe +z`v{K%Yn+wR5a92f>)R$4vflovxhm)x;a$RAI~p$?iKzV(bB&}B$>^h +z8bS_QXE?W*h>8cJXr#X)cypfp-Xzmwu+#Nz#;Ba-kux2uioz=I;?fP6tZVFO!k)Yvok}Aw_7&WC)Lhlo^|A*Q2ThhjJq}={RiA!wq~T%alZRk +zzg%m=d-$AwFQ?G=@smA!yLb3Vtt|i4aV55`T6dk}N)a;*}m_}msVej +zn{MM4=pHBiWAH+s_DJ?z#Rh4wXO~mcOihZl7*q0&u2<|@xV!b3jzDkUdEPF)MV>`} +zyK6nO5h+(U2_}5|tMtX6>1opT9w)!0dGG-jnw`FoWQ>V*)>YJ`ppJl7(=#=W4V!8fy-DCr)YhKE$*Ni`69PZj&-siT5)@PvDV|<$`41pGtWD$h_^WH +zqm!N+yicyUX78lDpW_t!{W_lyecZJBeUF#c<}lavtVb2btP^SSxuKadoyC72p047u?_yX=b?nrmI#SyX +zDX;W9(z);99?vk>>a&~nY`z?<>ey!}6WKGK6Y!reUs3JEYw^R} +zV3HCZPn?og{nlE$U{Abg^5cTY}sC2QMT@JM_P4Ltd*A^Gug88d$p@yy7b5R-Ad>6&TdP7snsx1h0u$aE8gF8 +zr|r`!o5*{Us=r>}^sGrnO5mpRy>{Q!^r|COt87#IFYgr#Ei +zZGl0%MT{ztqDj2kqwA+_^V7O1y78>yL^Y9>J25S$xr?w>+S=fo+HpUq`0J{N(WdDq +zHqjn#Gc24Ym8Tf(F!yG|YTK-N3PTY_Hap`B$VoQ`%3arav};v21y7Uq(9^kLWaHx4 +zz3y>cY08!&-keqGFV%%|H{UO{w9#W%qzq~8{Xe$8JR0gR{69suP!ZWvmSj(|o0R2K +zwovw6mh4Pp8#5!4%AO(&LPGXrUnYcv8Qa*mF&N7*m|>VPf1 +z$35qs=bqE1O +z#y7bUUo|q>p))?2bF*`{{_Rv1_}mj4+Ell_X4?B2O85G!hoJt|wcnlc<(y*haJ{YD +zm}hG7M&$!HLzsn5ur*&)T{)by7VO4_t#chCtLz{`&=;Wo>SR0(HW8np(e>r2+ni3D +z=))|a76G>~6(&F+XSfUn1|we7c|d{BngQMi5ILpVmsY3tVn&F)E5Ls_`rrbIPbN}Y<@P{Pav642IQ;rSi@yQ7FXPy5 +zYvW6xpuHTuY7afV2sYe$rn5Fb6RBaJ73or+>7HC>+HpL;goYUs$ZgE^^&CYuz`mY} +zly2=aQ*bS>GpG7QT|Nl-81Gt3C_Gg8Ddw}dbjoIx8{cxj-(viyn4G(#V5lB#b5Ll! +z%qk$d2*#jNUK{(gE;9FBZ?Hu! +zx3^`8rnyYd`V8BQ<{De +zdH6^JCJg%0Vq02V0V{72zesG(7yvuOj$N-Pa{C@6oHXX@oASNeBj|}yt$bu%qVJ1P +z2X<_@+TVT$VpmqpKM4oiGDn5Go=wp=g<69Vg>E0jTY;Y5mo>_LqmgV5Zkj$kfeoH= +zH)lI1wlBm--Pz=F_Z)-D`(bl~?gkdg*Fq&X6H^1daxn|hmQj^!^!_!}1iW3Gs5!D> +zU&>nO)Twb}j)NM`mFpCfz7rj_xaGD&oo+w-n3hW$z$t#Pik+MLBYH!$k-`QfDqdG_ +zGOv^^xE;z<384flj)d_n6~vqEOgt#946TAL)d)Yr;`g^4QOxP$V# +z`Gb6HfpR_}_REV_rSn*iB#QXnd6ebHt^oW}({f#gi=XOumo{;k`J=8qB=OsNYj8X^ +zhGO>Tv8qTgyuSKHk?++KH9*)9LZaL;-Np)+S^cO_X;hlbM^NnBZ+!-z5a)F3z}Dv* +z?VY0z2T#zKCD-(}T9tUP{oez$R>OY@6C=JU%Xdv$=|t1rl-6DxUJ5ymZ&k|1c1=F5 +zN(;cRg{RV&!*ea=JDVhxgo%~u^kq$)-lB5_A-7I9zfKc0{BDib(MQ^;jQ1qk?h-=oE1}s10=}PkZ#CflRTcNgV+4_ +zsOdByF#5TZ{-PKq#pS(r{p3^Lg1YJ0cdE6_R|xU?(08O@Sg+ +z9{D#r7^LP!z{{pwZ+cJ$sIJZ9AX`xk+$spBwbKLHJ$gRX8v7E)3!k^ZzfXt|m4D6N +zo>EHfobEu17z)MH^%c9PN>Wjs{UUJ-Z|d^Ee_UmSmcw`W`W^>;@cJt1Iu~^)y#mA= +z9$mtPGe%xsfDb_R=q%K>!t~*=%j%pHK{s3hINJiuBYV15Cgv|+<*#`n2e2s +ze#Hkb-go{3nc59p=d%H;M>0<6aFj${2Qzx!-8OyQ-Y$@_d!Kq<>6Ufqq5R695x^kr +ziS2vZlcMf4Y-FQ|aEapLXRIqB)FnVb7%v{2Kaz~qao5N^_HM~hFKz3B^ah;^G4VZ( +zJNCFg#Z3CiM`py@s7=SZC`kpuhLMF>+Zv$REoK$Wt*I@Rm2C4Wx1BGldI4S_HuAv> +zk&vb(QQZa4uH?Boqxg_~(~f>fi(+g>x(lmU5K5lo5p?auVdcdL(hIo~7!wNumkRiNvQ75*Qe&+yMWa;fKO +zfSP)DG~Vw$z4}wdMp+%uoYD$iu2ovuvHP(1G3=nRDufde*b_x7et@rPzmBTVH>yMm +zXofAQ)_-rc0?vi41v&q0V_Xa_u|nkrtIVq)k`pjs`QDrW*(Eiqvqi{SK;rMF)h%gf +z;&_tq^|0LIRqAk(v=A317|SkV|FJTlqBDF6eDgK+@73exPgg&x!20`JgFj&LtQo6t +zRMr&uY1t@Cd(>oGLxerw($W% +zxbS5!>j?~f8Jt^`OHUTqn{Pq|tDI^wua}=1an_jeYu5)ZEG;On4^`GfGfwF9^;YEI +z%}mPLC%g72H$XX2LUq!$!?wYs504J&xP9&#$wb%|zNzg?KyAr&c +z$ho6K;)C0E5;=crBQh!;=|3gYmj9LiuNJYG8uc>1D(KMNWvI1i(q%C3mu4pJ +zXp9MO_@#U*MG>&t{9f_AHVb#-k~;Kx9#$1h6ha6Z^#$Xdo62gk`PXf)!!DxSnwWzA +zCLDp!+4gt5t>{q}2o{$O;BolyGH?E`(eS`Ky7r;U+{JYdwO0O0HmOGDO6D3e#_Ufs +zR}OA3?0kqA>g^O^gf2n9{~)td>{4goISZ{X+Mm>3oAz}*KFvcg|HTo>=K{oFTsKm> +zq}wlfO@Hw+cyS-~{z!Ds7@?I?C#EBZ%Svkt*lzv<=k##yMLkmJ?InyxFo5qJU&|9! +zk_rC~NY+Dq7ypRIt~>9`zSqux2xaMRZ3KN{k4Oe|^wE>S`J8XP$nC}53tFwBhsDH8 +zhtbRDNzpOQ$vDd{h}Kx3NCDBZ=3lE;_j2agOK#G~kM@6w(jgKsuBCw2m2(DLDXx5r +zt_11o7_?s^)Kc08a~bjbj8HCY>Uo}O8Nh~WI6|yWXGF2Xl$SDza3eYk=T8PGAobO~ +z3QtL-=J&RbUal{=;c`(*;5F$m6KJWKjxseS*+DZ;2pjDk=o*^JR`y;mBnVH7GLji +zq=R3T%$sa9TJl@O@aHv7qm__)3#@~jn) +zS#5>gR&zrxXo9(R(r4Quua2wRH`j9E)5w&s%1bSwZSkGX8K5~|RuqHZeEnS5=UE%W +z{@kEfqRS`kCWzS6_;zAq%MY!w-Gp}^-o1C%|CDxfb85kf$1sM;P?o>O_gw9jn;)(z +zA(z%=?eDSQ^YLSBefQ*P5hH81UQcvknoW?buB@0%q0LhsFVVL&huMmQApzKn)xId) +zB& +z;Ca2Uji%Nb@`boq?aR5}1Fx8@cJq+Fcfs0Vf6PNf+F;%j#P%VJYghbEvu=_+AgJhDfmC-qpX)=?esI%oiE3Z +z7$Jb`#T!xibZBm|)63B-U7d-=$z^?=q54Cg^G?{3bDoH%PlDNSyVWGsRngJ0Z&GZA +z;JToR#?FB6gXg@-6*VU8Ssc4Eap|^}Ym64zab4*o1?*<1Go6+DC;b2IXz!BlH&&evRR^G4jfm%*K}|4iF$zF(f6(I +zQI-DV3FSE(4HK5?B^1GzRh2?1#g!l{t%e&9)qlaFA=d7W8Q22zTb$$c +z9|tYL$&EuGhh*!7+kS|K4%Ot$HM>O(`u207d1l{ds$<*7uc;y$-|5gbUw{+8hV$LM(Vg5Lu9WzpYD5Dg+VUi* +zvZ`w=v~PSN{GF8cGu&DPpsa+%9u5lKp0zJQ{&2SB1DS85y^7>3QtYeO(AC@rZLGm^{aO +z`Om&Go28T{g`zOGiLb`x)t$DW^&iB^(kk6Dt}Vh=Ze-EgCa7a*@L`s2m2Qgx)X56u +zOw*`De!O4}EKk_kp}@V-$|TM&!3Q}0qM0W;urTV|LA8~nrH~pDCnHP?!sscEN4jwq +z&LP_#MSbLFp0tc)d$?l+dp&EbHeE2N@(J62&A90AwRI!pjuPOI@2x@Q}b?`8Buj~BI&2+{9r0goh5gJUGc)3 +zblX41Z=iz7TOUyQgQm-vt$V4LSim2G_PO^Cu@;!CnQ6=z&3E~M``^2qxWpF~@=fo* +zvDXuMvmKL9F#M38KYBc9dz7%W|1IcA{t_m$YfxXyA}YK*&FcN;WJ+hFvxZ`~DLSdWn#WxYx +zLhawH1`N=SFdMp<3emU3y5*#;Up7;eKukK0VTI*$QCzGJLvki7AA;$C{wqI-lQ|uQ +zH7h)Ht`Y-uEj(&p)PBsFqL~GUAF;I0ZA=C^=~g-7jZqCc@C84bJ7!%ZRo!cwmz~;n +zp?$(rbS-N@x=SDN;9~B!R8~k2M{gge`@vuHUiZXbw3S_|mCGqiKt_lb*JX>6@RQ2EOF*{Ma2y5|0<|FB+ijp~pmCjBVunEn+7q=lgv=TB&`- +zCm(F2Mv&8KmN8t;+M@1u6SXie!g$OyH*^QDZ@mnkp@_M!3Ob=*bWt@~93_TJ`~39Kxpz)( +zeCzzli|$ahh1=~Nov2$S^75V{HV7&FAh~CZlg_&ap1<1WTmC}CFkZe(az{5K*HN}k +z9U1!ZQu6i2%g7!qs1*}Fzu|Y{ubQu(OS+i_+K_1SyPemNFu&JMdk{s?y1v*7m(Obe +zI`;oe*y=7*P#5Zbw)HpFAlXo65<6~SYIqQMD|hT~y%G9&a>;sj;DV$oR;N0Ka1=StP!wxd)3%iAm4MQr=lC7PGCnEo;PuJHs{8JyMk&NSSz6JsNRXdjgSs{&*O$cMUx^J#uHVb4+Ssp`|JE=OrrxKz +zuNmc@SK4yrWO0YVjt<)raq;Op82@A^V+H6)UfJx)|B4whEJu}P092gTwkxwArL@fF +zM;#w2kCfWd?1y^Gt@Rf*K(*fBa;J1`2jTJv%5LZf;=TkZug%n4`)`v%Ai71Pnfq-hkmVI;HUzD53K2JE9`G{wEJ%) +zmY}O`-|xTwX%yGNYm#zLz--J3PxQm>|5g^ +zncF{b$jKW@Q>YO&Mj-^Bh`hLN;`m@ucLEmSq!yR=g0`hoGb?b&%$6B0s(rfW5lJ5_ +zdGUx+Uv_0ZVPktT{qNg*ja|p`uA(A5oO`aA_53SHPvN_?v5A$VK0TApl&{IDRbNp6 +zCsrKOI1edu{K}}Lh2e0S0)M(ZJ6PFjlV!&Fw%>s)W+h{^vD*5n^E*hX^f$VN<*@6U +z8W}HhUq!-jdH%#rsjf=)lA%(CFUlM3T$3!!w9=qpAZGvmL0sD#dK67ZNHw$N(Vddv +zbkWmTEjO?<*?-62uJnnlYoJCy4+S{#WG8>|>Q4y5}md;)DY;ZVby+5$7 +z{wrtH{tK8TvqsqV_eiQBPT^~Qjq#1yMh8t@mEKu^`FJfjTz +ztbT2)NO&84pOK%o_I#(^LFz7LJFJQPbJ3$gE9vVgAQ77P#Iv^t%g*pczVN|I=;g-hmhkjrop7v$6Y$w +zV(Ua04U9?)ADimB(WE67~|U{24<# +zJrVmTVbefX%{rcBK_iIxs?#9*mxUV0YkmeQ8$9zV_Xwe@qj6jS|YBjgH6L-B9E0Tjb1{_~5=_Vm`r5 +zXIi!-5CAGZOlwUuFXR$yT}-^uIxfsrGS;u8WX-}%y$Ir-)c29-KfKv@&(Emiz0&wo +zQdO6gsHwL8qHO)uEw5VU2NAh*W3R;dZ%6PnpYA-wxRfZeUlw)a{f%-1{78yw@ +z*;whQv4iZE$AkWr^W%mB&59$co02Om&stFR^%IRqTl8tZaYubifv9|oYMIW;Y@F_T +z1R{RDze3{!tO~u0o~c*CD1DpgMTdQ{@ue1`uizoL!&Q~}i-n-d7RSS#Iv;Sq0O^PQ +zcAzz(0#=DBcYd$?v*f|EgyPUtw5x?Ci_fKwU&j`0kZR7JvE*A4mN!cKE%;b`cW=oj$$~Bb@r*K?ZL{-NFOEn}-orT}c)35GyI=PbHmjQ)#)=E!qRh!YO5eJb)lTli%u)x2aZommIZk~* +zD_CD@iv)JfT;xuEDMzYP|IB~1-?HxHPLC1c+^Rc$s3tIF`rOWioWzYf3J^|`E7uM~no08A(oDUUnN`FYXUZ+ibCOoOj(&AV01dx5OY9d%v5%BP +zi`SofnSMVcC_KpgzW7yrENA7ztb6GgZt<(wd{K~%>7mU`VixgkT0{sWbNx~Jg1*d5 +zayTBU=^Cier)&o3Q4UjOGo%`lT-V>3RZYekS(6GD;KqTfPoqL|xPBXP#eY0lMZH+l +zGVV1pL+~7idX0QA=jswfJ<0-@Nu?5mr4)gAl3fvOL|iDpQ>0L|nTV-@+2$A~=%SFQ +zWS_l)WRWJc=TbA_Epl8FQ=T&)2NaRZ9y?Z!Yu9Aw1U$^72=?zJhbaT|2(Jg+3mq#R +z69IvfWd|kw9)VgB%ID2GjCqqbhwhPl;Bj2eB7CMEkB88ZU8%17pofbyFuk$0y+ZvW +zgs|LZ$?rWm%omNX09x<5*DJgl?(LRmIhL4Lyv>UNZ8d1?B6k``I5kou +z%ZZ|^hU_775i$F+%DX!$gTG6J`$_v3k<94~JAH~50;~A6E4p(@?4OPYyW^P#ySIi$ +z`aKmWOeY22o?t0zApsTmk*>|6N>w0h=O +zu*pDc_QG(d+@sJ?_s|Zs=B_t3qHJd|PIjX7}d4Gv9C7$!5%PT0NA +z%!{BsnQg3pyPTh{@N`~a2?t)>9TdzeLetJF@Xy$S;M`7?_5iaSN)hre%N +zTO_&r+v38HlH$|FawMsLR-w6J%APWd&244k#8;lkBMbWT_4F#t5dx>B{B*6o)alnc0{&co8{3i9*3d8IqAYoJW72h=V +zYiWHGGDsN0e>_9Mt>%V=bmWHGI3|=qZ$*yeq+Vpjo!ppN&`D}YA=Hsw>DL1n$%XL< +zn_m#M*G{ykgdln6_xbq;{NYE(b|bs;b7J^`XNR|H!n)}UBt#BVW@ahVr)wnKtb)tr +zYZ?#Hs;kz|2=QPhuR^z7MkS^RpmH8|#l&v_Of)K0VE|d%yE%;c|nZGW&gV +znOfS?J-y8vc3gb-19((;!tN+@dJ4f|G9Yeu7&9*Huga@|vdTAuc|0DM!4@k8;|`;Y +zo3bzOfOrv~61(TJI^NDDB|ZY!_$c+lA7m5=GsTYtiQK{u9phaKq(-SrVK)bc6TPb0 +zG}Gx!M9rV9Sm2<^%H+4?BBI--W`p4Ln_w=Az`hthA}zUa0*fq~aL;pt4K*dw?$Sb< +zD!%P-w+vHLRd3V{hm~-31>V9h*S_HX4*b^PK7_`XrAdv+qy@wb+!}xT4?F(0>q!|i +z6Y-kg=kd2Ovu`@y565Slt4GhI^6SDX)I~UPEG4Atpqn&)&`qj3K5~ipshO0UJ+y28 +zPnwjy2HZ2F=d>$xHT-B9J#u|2c2)0+zR5D90S^cjTUdHs(EO>;kR{3t^)# +zN(l7a*G=;_J8S{N_#;e>t6d?@^L +z(pyUbt-Rw+A><#-L*yUNt5as3*x{3BHMPWD6xS>}tP|%HQ?$jA?2b`sA_VJ90C@1- +zpM&^GDoeZPPApC@dwH~9Hq$$0JF%D-ftGE{;#@q!`26XnepWox_NqE0qGjt@JxF7d$8!Atkd +zLM;AOT*WWjg18E~^%3Ut3& +zN;_T1GCaENW4?k~Gm{HKRs9z1lKL&6`U2rFbLIVbEGeoM*trA1*p`AoexEe2RqMgz +zh1dYkYZAz;ralr;AI7if#LWl@f1qD%7KdCuE>cWAF>gtPr?o!W*LzYO{RjiN>Gdh> +zb5yEohL-tEzLvQLFEUO?(BuQcEa<+BxYr6v(1pxb(>nSbjsBKfC%Zq#!*gdIot*B! +z&*|Drp53R2Jrgi+s{}{EDF<{4;8uc?4yKkemYpcRfkzmM9k0PF~@NfSpnb +zRjFfL;)DfAIQMIZu5_~fO4EnFrar>H;>KIQrxw&5cIBZtDFzTIUq)oNP{V~rE=>nm +zEFNw^+b;M`Qo{JUYj*bY96Or4`6o4aL|HOBaUxxn?|SY=KtwZ)oO_><)-;odrS3UW +zOkS;*@zsCEx0@nb)LzqpbO#D*L$mZk +z34M2#m{NRkYy0Z2)zI7}@0PD}C`TqQqPPz5kUxmdsde~@wS93E+vTY0dNT?{WN%x> +z8wW+crj$5eLe5$cUxC?8gN5t=4d>|iL|y{@2UCvdt6>airYTSgH%yP(j{~0qet}1B +z$#HzoSl>z0C}5RgDyfm4QACuu1RDHSo`mW3T>}_Yf7ZDsG(I`(JMH-USgmPw({TJ+ +z_q|^>p@M2Fp)Bpg%lF#6_Se?oV~k}Ck`N6w)F(=wrF-f8#{2P|@#o{~c-a$|5GkJk +z%K3Y}p-S4NXC39f2#&d$@K56tiK35Flt3aPewc{1i8dCw`NwA(F6Q+5KsV~S(*q-3|+FiBm*710JwnZB}`(sCj#>WUo?MfZv +zO@LTbKE;fpck~;{Yk>-G7N*r2GY8=%)qa?-d(y6rM|BmQO;-uiU0+(>`_+=;!X3#T +zdTd*U@g`=uoN0LH_e&Lq9mI{>yqe<#C>E7=AMx*opyMq7tO1NF9}l{QMy>?}B*}m+ +zR&gOR!1S_$+s^d%Q{dTSV>$Ilky#uts=oOt*sN+q;|363MgsnHwh_Hv?QP=7k~G1Q +zg_VKi{UfxunEXr_o*`~9j#SGnNBqXC|O;+f2uh{Xp8?d`Aqg3q< +z-%)+C%Xg@`_S@WSl|1Dw`bqs7s(EF1SBBg->|OmyePLw+pK}-RyHVlvl>?KqNW0H3 +z)Ia!sLG&@i)T8Z&nlCjDV%zIDHKm;m%LzyF6Mk2`@)^>RC#t|Sn-eYXhr%*pzIF>{ +znFngP@>$Rw&&Mat_^Cd%Jwgg!{9i4`G|t>GQ7c +zd+uQ}E5K}CsHW%gGYtuX%&?n&TZ;@+Co-ub^h_TC3X +zD=jaYwc2Tb_(I6evm;CdhY(@T$<6OG>f`m<5#ymkrW4{ptlrE6*54sIPiWeA%Iyb}x_WM(y-`F?B3 +z6qmq=i;{-!hYHXz2LdN6{@|vu!`VM4o;txDk;04N?E>48n+etS8Wur8qRZ2sho7f( +zaPPb9LpR)_W=5ZN_9OqC%F6NzEn9S&%Q45BUQHK-NC*(ZbC>q1J@FHu*JI`2rJO<- +zvRQrc1NpI&6x^xkFbxR&k8kPmTJ>s$kY`bXrG4l80d}}%m3dtvZ?ZsD`O&WTQ2NN1 +zW88}0CJ9j_F;LEANEFlVMmMf==ZVBoH}lSwaE5#*g~}i^Lk*)4T>(KJ{-1!~EZo(6 +zXSPNnkFC`WDGlDu+ss`apy1nc&j6gT{S$7azw38+e`2Ij&<83;JK$|$*@P+^=S!Wr +zXJnrC*7?JuBr0vhy!;lUCL$I187hF+F;wv9igp%Y?v$>V0(y>`4eZd*S8d0T>Y^wt{zoDKoicKhL6Ap?~10e-4Udp +zR^+8HkG0NzNyCF9Knatyd{%@bP{rHEbE3XZ +zRx$(m@c|QswQ}wQziPM4XqTS#o;Hlwi36jGtLt%>a0B|^Mk0IQLV}f!ccl!R9s6Fi +zX{lLH-s4Ag{_=#BqZCesWP-sYG{~$ssUEG8x@Uu){*mM;xVmT;!rPhkVQu0vPSZZi +zvR_(FwA@z~`&`>!f|IOs-!9(6^f(`qrDE$OWu?_PaIR6sw|>w}?D?cWKZ>Nx#a~^W +zI&w8LP%PR+f-YtH?i%X2w6c7MJ&_16GUXt%XIYBu{{Y7)+Iy5!S+Gi0WFG!7dDR)` +z7s+8&D&V9+uFog>$Ly2Y+W)OdRU-zW;=zv1(C1{yUdJChmUpX;bIr0(Oh;M$#`z9a +zdS#B!r@Mg=>A~f%Km_->;!T~~*i~JiJ6Z3zQKXuB_fu8kne>$u>SGiVO?%es-hgg@ +z-fOu^lghNO!%g6DAIx-*OLzsgdj`w?;8wqnWou_2SD2q&J3qjx*rUVD+3&Qw;Fh*z +zFS&o8wPmdHBKV=Jrx6#|M`OCF{u<;p#7Q3F`H@SfHF@I0za +z4{A|_sI%8RQ@*2~`FtB{U +zR*{eSiKF)FVo^KU>uXY2PA8utLc;oLesO&M<_&s6M^h@fh>~jf7ba`B_GtjTr>K1e +zpSOIP`5}Px^eJ<9&)>R!hUUjn2JIIpFy(97Q6gpv4~RyT(=zTq*ch5|PqYfAV0 +zo)%(uE%M%J!-cu5D9+|@K{??sez=-1;v!X;O6a>?Jh +z3L$UuI1fuk%e#1Ev)m`xN+fyR`!5MXCjtM( +z%j}-0HvZ<`LvRa?<`1KAa=V(B(ns27TjQh(w=cvb&7U`E#6x-cCuvXhPZB0r +zP13d5#dqe37Jp$MK~-2{>X`pe`i6d|k}NlT4#A3a4O=#VG%X4B7CDC1G2)uei9%b2 +z2#`r5w}-j1kq0E@d$<4%wIRuXO9^{kqyBop07uOrZ?5EArq(7+0gz_ultpfwyyMU# +zV1U&X)n09hsyffWnnh-zt57QRUY;?=izItVd3RP-rgU|tal^6{@Y}i{#=Gos +zr1}K!HP=15{-JB}>#iU|C#!idUu=A_Ue06RT?djV +z_hd729Y=E_-C&8`v%1GO)~cj^XC_>fccgCwBCip#t%<4p(imUvL4E+pH+&pmJBS3f>WL#8+pGSV!f=fq4SO#{Wi0zd{!ZC^~dD{`LN+pvj^3< +z(9iL)n+tX+FWakk>!O}jP6Iul&1uib&b|G@N9UZ2<}yt{DH(eq9A!I`iG6d~?e=R@ +z`@uTT7tB6fg9D4&oz`A7U0QXjKAqrqX+L$2xLCSzN>*_Hc;R1bV8o=>iBCJ0Q<@O? +znOv~yNK7F(FPtr`wZilwxMT^stB@BFlTpNrndFgGh+l-L^+I1Jd3ayMYC-A~d3RsL +zd|^?Zz&+5)+xq`0eg97#ymh)`C$~VYQmb{s{b~+3P&;n9{$zVTIbFlwAz#^h?5CtK3x^BxEiOj9RS_jpMx!OWC$CW*ES +z_KBYt7^DviCj1j9LbwDd$%UP79N_-9=W^3Iy3h#Un?ghLZvWZwXNCzQzqdY<3W4dX +z?Qth(WGCpC@!nX`+o#p61WaS#_W|V;G4$C}cn&fLPTa}eDK~`WiJt{tH@3k<@}pM2 +zNx~DV_bQgrAe}hno;{N9v+@KERNuGda}k_Y`R%T4lGlWcAPaLhR95D~-bEQ~A>^S9 +zKd#FYi>3ttF-`SRyuN%-a_4qVV!R)?1z!|7SbN%0-KObuVWOWblHjpC@-=ed`Dx+^ +zzI0Wc@j#HIuw&39C;!!J4^n*UcE=M90Ppr(-P0WIi4D@2;BK1$GCnjnUOGM^M5EFB +z@OJwL!cL3Hiye!NbdB2ER{M?V$WMfsHCHV&bXrGrfML|pBhk)IQ3Dg5q_mmVpV;5Q +zH&r5(e6xOfnhO%z&} +zsDZGHyZLPLCp4O1fl_@bt;4zFzj<;jOuDg?Gk!c&8v_w~3+rgUdKyK$4x+bR +zQ#lFOp>tBs*EmY5L}g}J&Z-J;*se!D@n8J1uoQJ=;fQjzCg%wauyA9lH)rYm`txus +zuKMZek9I?=T&g22mG>@`#ec&N|B6>;v=7T&Dh;>>KiOVVW9DqjGRyr# +z`a0oC?gIljc=2QX-ZR_9;e@{O-GvlY)`rlurEgYjUQXph7?l%Mu$PG6b5QZ#g;H}t +z{VRP-dcQg+Y``MFdcFovsNJ|?|9+`$DF|11pCF1S$0m$gOR(X +z;hZfOl|@leByvd|&-(8H(9ujdu?>y~KA>w`o8we1~9xDf9|GEg~1j$F+~&NEIj +z3msk&Lc=g%(ZJ#q_b-g5z`br&g#zIqL2NvsL*JxHCptR_l<&>pM`4tUo;N;%odv^G +z*^Wy)$CO5-2Bnh}Fvva3wBE|(MH38%9^9M?yr~HO8syQZ^ +zb+q!r`wFi-B_zl{IOZ5W|1HsK?ox4BkvcPeC;rsB?)MHboF3k_CpY!yUd8*$yWO2T +z2A#+`1+_Ow?*?Gly;-OkX7jT~K0RTLFQ%^L3j90vb-r^Cc>$sC+*^|ubnuTsgg~D~jSZZ8_ +z8)9DOSM%c0!1daB4U%4B&hpDZN@st(C6ggYV=9l86Y-U+u+_PSUAc3^ztdKsb8Erx +zL1o4!Ltr)6WjGoYm(S%Y;Lx5c=g>X@?A(y>X&ToY4=R=jqL#5AIJ{I2hX!H}tgkK_ +z^3*$YWspEn9rc|@5KY7M$cT`=b(Rggrg7i2P^M%mL(z*vEb#q +zkyMIIH9h0{5Rpg4Haik7(04akxyr=et!1#9`>#q8LF<0s-HCywV)|cIagUs;f^w5Q!qbEp@DjGR1PZ%021k!r6U=WN=vqZIbEiaWERM^=j01Pkjq +ze`soNk}gLUltHp1GDFc5Lv2-1I_G-h{9EreqKMqFMRz|AMKWsS^l#gdC%ce{LnlwS +zHqAp6!_-;=!Y&=``e@}b`9K!RwG!qOIMUP&I6f24TUW}pKrFX=`QPNd*Krm$KsAT^ +z5Ni*p_fy+OuQ_brCyw^CWxnBMzIg +zl;;agK0s}@;@~BzOy!iP +zsKC%0W@D}9-GR(3$uCovKB;z=n+fYJT!a3{fj~Uom+;8v#-puB*XsCEZ}n{L?T)dF +zqm(w?LqzIioFK>Y6S^wGcpR2#DZrECE}0d%sY)WT4ea9B2Re_vqZ;Py*MH8rMMh4W +zG5XS&)TH`V-Gtt({Y$xwM>Br}FxFp!Pjs8fXz86+{*n<`JK^4RIUtU=&M@H*y5rBr +zj-Mqdo>lmbIsrX7Z;=lQpR(k^VccXlgb25GF@EMJ*F@PF)|p&rYQb?XK7Cq-S~oJW +zna>hRxf+>QF4Nf|2wpvboTTn^;Dd?rXEt#p*zCv{KWBDWZ|C@70iApvrxa5JX>2wF +z&B$N#o9p#{I?seR!QMOk8p=R5JxE*nl9CGXA{iD4KbJE1T9^Nh2%`wMJUx(x0$P+? +zoRVzMe&iQrMqZsQ?p{ziI~LMff>d2~?QowE%~Fn@wzY?1&QpYv*b^Mpm`HIc;i<-dF +z+6pD`Eqgo)UcXAYfz7iUi>$1H4YY`%xbLF)Kg&#V_nOE~^7gWec0L<4Td4P-r5!hy +zzP9$M2R-gpp`Zk+8=U%^I@2qh=(OxA_kEiLQJeN5^HoZ(8o{*`@Hb>WeedabKeMCD +z;`e&BN+kwxjO+l90TcUtb6<^)agWbbLT4 +zuW#yy7gjBN0v)t1_*p3Bqi*u)@HCrV{bw^6UgP25sZ}!Jc81OIrQLN>M$UXpmscWZ +zM3wJ3u8jvSTk~%TS`RE1V4BC?(dO^CosNL$h+kP3G{cq*(RchRsyvtC`4lAb9gcM? +zSH!o%0$9}>BF*+KEVp&H+oxk@prWYRfqKPWO0VPUY{2^s;O-v +z2IIsI-}oYxU0qHWfc>L#bG-~%I^gyGw7b%>DK`hL@*Ifrf=#rkZk11yGA7OXi8xDz +zuNO5D^1vASGo3L9VPw|B%?n;T4XMhxU%gaLD=VxnUE7W=TN`!O_LDyGXS=nBOR!EW +zZQAj4^o;Z&c%s(TMyutAPcFQKikigG6d~gz5 +z&9QuQBb1#!2Fab%lq)D{JZA9=eCz&wMfb7HBvllJnD_XJAxnbYPAdQTL$wL*N$VX;}3Evx+@Mb;v(^|R;-c)flEe_Mb +znlNK9wx8#a2?r}NQ044PpLQ^5uL5%rR$txj_!qzvWlfiW6ddH@+0jEcNlS +z?8Pq2p6=b7{}QGFJ;meM*$0?UCkrH-`+YxQA1?gfxO5Uf`rn~3Mc~jlvTf-_K(WYk +zlZ$S2q +z9^87nPzMj(gfG107ofg~{vb#zSHK*Q2p!nr_0hu$@0#zt>{M@0L_M|B+xEswQ~!so +z?~H2V`=V75QBe>PkQxzzpCV0qjf#MZfQW#!(7W^&NE47IB`N|^BO)MOq=X)NkrL@W +zfT0HnJtQH?B&zo1o&t14q=;KdGCJhAS%i>MeWc +zYH1);=!h<{qYh0Tm#b;Bnxi4wmg8D!HcOB|P}8((FZe${;=lQO>Qxa6aQz7rAHW3$+@`tsZelrV7BjIz=pzn +zO%1&-Gt}XA*E!yDgiL8?sfT3tg92qlA?7>+ +zsVsp-(ne +zt4w}p`GFHuyoCa4at*Y)jNpb8$3dHsOT*beA7aaI3ySh?* +zquJrZ)l9={S(psp`>H_*v3g&nW-=cELJi@Z(9;z!WPUn!W7k4&?2=@8v2Q4XD}C!1 +zGbKdLXz*NP?`LcSr0aXBkHy~Bjl?{-FhEi>sK}xq)h|ks%3_5~!R`QK&n#5v}#a;rg820$7!fAgi~kBCl^ASiA1c +zjrawbde1I3z9{z1OwBV7&kA|`3q9ixa%O9tkv{$V6Mt>7IIvb|D>LhSfuM7nTXgj9 +z$q2U9yC8LFsLuNzx!{QFEzIVGF>JWbo|=DA*K;JGRceq+;4zB|MlN4u((Be_eL{=x +zMS(y*WSOS^6TNb;^BIt#F~Y=-z$-|sGj7Tae0G{;0ky^bnV(uKr{cdBjkO6q>oq0W +zO`U_Y9a%mD714si6X;U2zk%7aW6~XH?EP~y2H%r{-6VZ*XK9Vw;wnE(a(8W&99oXJ +zst!VhEhtq|@J*E@t^C#lhq#H{JkrR{OdRsk;5zyg&^p)J)pW^#alf9j$?{pN$iG(@ +zAF=>trEi2@pPbY8S}%y$KX*bNRoUrU(eK^Oq`dNZn)RL~(OIpR@I~=>X*u^ib>|ii +zyesIZKE~nQc#3L*C!z%mvtloRnk2}{NI)*cOrxj#M5!f*r!ED@B~WVXLD%;gO??J; +z8cnu^G}x9GgwtNM3OC(S&Ir-p{DQkC^u{}}4CK~&H&cxKRnH}HA`e&q?p_15HD#-RPc>S)F5CCv9EDeSSH97~aC0w{d}mUx~Q@ +zILZGKy^+d8z4jnP$^)6W^EFBRA+FU1i(=USx6S^Dbknk=naRNk4oj +z!Qud9QW#$vpD}8Y>6D0e>QDByIcdNhKj4sq~h(#iw*fwarNXcom%gM_CI0 +z33sg-R5EjYJ`H8!Q2|={@fcyo=pni9GCVfV9u@5~iZ*J07VXEXY82I5V;~}P)>{_E +zT4Q;;^U{`dhPilF$T%Zw1YT{kWkwzQ|2B-ZiAxMj`G)gJSO1xf{dTs|RYKol)0Tn> +zlajK(%|QFepcEHqy7sEs;QHSj-(OXaSiJ-+?mHN$>IJOS*V`zsUK3~Mlc4%K=kwjy~ +z9B;Ggi^z!t+A`Tc&}UzP&)Ql_z2;9-r=gUoVXuQfG?O}-y9|FE$YJF*dlpa)1~#Ip +zigf6%euz+kW-d=I^|8B@U!YbJqkNt*vlva=-^@85n@K7!I7f^0Y%4odp}&s4>r53EJ1JE{f_6#?{XZNgp@6O0~VNrA->sC0F77!4GDc=C_-X +z<=MdNHqWTweFz8>6i57~l9(NykJ;IgLPZ0zn?71xk>lN-)0CQAb@|yBgAMoRahH7| +z-Nj +z#g=wy&qVH9hh6Nq2P4p=@(6$F#f>Dzoug1OA;|jO)Jo?d0Pp +zU(E_#cIS4QDjOEAa&W<@@^JNg0{Zis{#R+_y|=Y-$~@a`p0PZMGqLGB)ddT#gWTDz +z9TMwf1>O;&u*e1akuY{xkf4Qq<$S49@D?a7X&MRV@9?7QH@T%iJ%B6vvX_?6dX)eBF;wZ|4k^iW^Pb^=o7U1 +z*TK*_CTjM@L)MRsJG0ID{QuGlkS*fUsLNPDS#CF|Ia>%4D(T*d?>b&BEVDhu9hSCP +z4#wh0iwUc^=vC}Y+iLOY9rtnmoKHluvQ@}UZ`Se)Gz*3|Ppb=CHSMBWXBu+4(F>|Q +z8h<+!JIv0nDhse#X(VV)^|xC}HM6mlp(B}sX@w!>ZBaO%gI6dIv(|;;OE?TH2~EryRqR&idcG#F +zukS%h`gzXX!I6X`%fEg4qIT4) +zx3Z`xcHezhuPccaL3}fQf_C4ujPrP)%SdkWKu#AGjj%j-ypeoUo+VY}MeU8~02>4q +zJ)rkp_P3=*IZD?4p!r;HB+i74$UM$c5vnVeikWne|w%jmn}X$+;ytqb1=khbj)Hsj +zt?En(4{fYlHBIW!y^_VR+dpFC>F_0BC7@TxdY?OxxcR9+Zkqaufi!uTJwhn}XP;v8 +zT^v27u~`XLRYLxEs&|KbH|N>#FNq&%-o2!hlnS&WG=?a#BD=Rp{#24I-JCZ`3oXG?{5gJ}; +z9dLn}%spfamrqrXgv*D*U~2;>KbrEV!Gq%k8z(E8s-^TSRUh(OTXB?qnaTJ=Lt!({ +z!U$VPIQ3SC$VYLrI-%+dU8nv$W&UF($}T99xJypP)a=L)8_IQRRkadjN0hGQxBkjH +zLglXKSuf^7(H7+Q`o8ioe;|(Vtfv43xNrUwYx{xyJVY}dnot3xd%d9b7=MNT0R=l(yVWRsS2Y7*n11zcQYjRH#ST`rC8-!PR+dwTt30i|A9T{I4 +z@tnPKU*;Wb%8pzN9w5R(o~oP;c`CsfW}Vp&vVySGeG2qm;Z(XNAXz?-oc42&E`4jE +zRa9hd*kdOI8!}su6Uagq%6YJ@u=vqCZ`H_oaIEk^tq-wHf2IE$ROzxRvlcL99_*B5 +zohy7z)c8-So+(-j+tI_XrORP4HCaJ +z@w$6HlDj^@VhuU^=6OS}FK#3>_CcP;vN9@cx`u*uaPbw0ZB8EO%zB@xaZqiaU%k$h*Kfh{-vi;tx&! +zl|aI{FVl7eBV|9PEA^+~pQ(eXS?tSJzl!sG2JDVMAM${#gY{qAO?r$?4Trl&SJF7muwoy9(kZ;6a9B)imn +zA4IX2WF7G=Hcu7-tL_+AUzfda21{?Qph`h)t7nudA}B7J@A$5HF;`!AVh6FPr8IhZ +zMPEgrA!xR!+4jHe|BA8Re8|IlU`g_@{rH;@6Y$wX4qz +zCUuh%3ltqKT8Ugo!YmnpP6`?Pn_i +zWytqDV)s>A++8YDCi{hh;%eDB^|CyJ73*5t_LmTB9_B!SagJhPz?;i0gNduS9+D&N +z7m-QeL|_}(KhUvmx+mG7TgxL0t3b)r0Dm3YoKJip^aj7ZF#mkrZaQ%P%2w!!=oWe^ +zU7+VtPfqet0lfOf?E>H04~JcK{96@Mtjc}lrPj|=JH-hEol+6<71-NKiHaFi<{MRB +z&6)wdcgFC{!!9@7jq9EG#pv$FOx58&!h?*2lhv&*Ux +zzB%5e_%~%h0cm;0E1A-9(ZL~uQlp*uc=U3pNqqNUiS<`v#}~rQE?7Y6xcn)8P8lrm +z{wh6QZ9$MJIEwod$d0#I<8${F+-NebQ*2|%UhfP1j9(JhJG}6HjMA%eh|GDTCkt{# +z=26h*WfcO_^fJBrIuB`0f(Y!bjR5d#8`8Gt?b2RA26S@9dI+#m3xnC@Y^z4~X% +ziki-{mgcG<0qKK_9jZ)FXG08 +zR`zI=z;H@`MYLM)#5J_TR)k7j9gj{iVp*Zz#+zOib+3}UMdMM~d6MAuedkERFk3W!z7pYB>5nA%?8XZn9 +zsr;B1PnxP8ZM-6FB+~L$zp4F~k^@VSyaUUgJY;DPy!V$fGKpQuzt$&jOZ2kyw%qI! +zu+Hqt%m8)KWl4AZUCAm7H*D^V3oUu+vz#f;>}+bFsZv|}1vjaF7+YjYNW`Rfw~!>s +zX>+|3busfmXM5f0ZrwQkvR`Sm;(^&r6%&avBxB~x#7qQ9myFisKmn}sjj5bDrY*;TZ_G6bk3LkNmi6kodO7k};L7o>kEBP3x`Fp!x +zU}^xL@%d;sn?W&tS6NrvitCzJQUCoYzI~cu +zvoF=dU2U2Dr?ep2PN;qBV&;kMwgT<7yINlNFU%D;QJ*g;BM;RYqxQS(OPa$L;|lLP +zH1eiW-y~ibbUsTE3=k&8t>{ilPoJo&^y3F7d7S+(QtR7Yw;64*B^f?RVa6w75Dcxl +zWqh_r)2H$)Y+(^tXHx|{YYKdKvg-UFL3%i+Ma3$X_Wi5MCVMccQe3^}>;y3WJG#Mv +zGxXX#izPPg6^4Q1<`2OR=#HbE=gnt~yVzdvQhVyGm}Egq!g&#{mz9@H33pb1&d(}v +zq5_4J3F6%*YLzMW@L$Z%>^=!0f{#Bj*oRUHGTns@rubQRSXbs#U_sZbvYDGaR2L8B +z?g+Q)YzKpT@*=ER{zC_5=KC3ValM3k$GF<41X1Vs_7Boq%w5(-$b}Es`r9@CK41uG +zE@iNUm(zlYJfTU4UG-JEH`zPMEGUbqyMu**m^NqM#uzPa%48v2NY!CN8B;5!?P-)? +z?D7_{GQrbS6(NAMn0}JT<13*M>FntHB2PL?{sz9{rkUlmdHe*cm79NtufoCBX$OD} +zA9s@zS*|nNT`{4YC|7Y>EoA$I +z1RC=?U<{1)H#N|A;@qXV;BO6@77TST9}hR`S;*L7gOd_9UQN57Y~kL##byiAk&RcO +zE3T%-_yJlbJcjp*wGsqt)|;DB<^rEQjO4a15_;S`x}MuJ^8DliRAzv%7@T(^Io{jt +z`6fd!{~zT?BU2)Z=w4v6A+`%$;yf;i3K?aVpLobAYlbORv^UGBIW2I3UC4(?hF-i{ +zw6*|wkE;h#qipA4Eb~TNs>k2?K(^NJni^D`Vfrh-6I*Zt;OM3c6MvUWchN6u6Uir4 +zEGSMO7d)_Lrkzn$&vm@NdD8GRm0RkeWGHmOF*71KJhP6nJ9@oxu26!P@hOlqNErWQ +z&$tWu&!d*@x~{CE9mWt|d%(HZv6KYH^pnihY!T6fl)(GV4owS>bY)(bCsF?bdsI_T +z_?o?6Fdd%|hDs)6EM;(aSbH4Asg-PP)k9dMv=TOIXd`Yj_fuzWK~Cs9Ultk@#Wk}o +z9-1`Fk1Z{)5ne^5MG$VSn5akRsGdL6%nucm6~Xi5ptOrfJ2O|Dx$zfOYh!uc%CdDm +zBVTvh!+I8VaJv4d5~sA{THV2|UIlSb7mhRdtUd4Ng31dWSX75nYT?lj#hm%1K)|k_yUR+suxWA>{PS$I +z+c^hWx7*v0=Sk`0!|L=%BLBeQ8Ir&mAryY29z{&R&4?+1quK=##JaPiCxS-qQb1L*4w +zpiQnn{<~KiYQwR0{f@vm_y?=cD+u#wQAP(Q*G}k-ymGV!?X*1N_=alo`xQ@En +zXVBzUa3bTbnveCY&lXJkU449&Z(m43VNPZ?m@x78C{JmZ`g{AnUm}HTsbeg8(^oF| +zU;25f;$}>-fy>sL$v9aX8elv<(!bWLfLa%nr@8d!w;EG1|A*S_{q`9A`J=PT#_u}y +z9p*mvpBeX&^-YgH{-%IFt45Uxsaaw^y4I=C(p$zUoEVn +z2h2-gb>#iE(KK3n+0ba>UezZp2@I0}jb-!huWZ=)Jr!G?sF!_z5^qJPG=1@X0RgC# +zZR)kSn{v#cm|T+oqsts@jjJ38hI0pLR^tGlNP +zLyU`?`ccTNf!2eH_5j;mrH{Y|1EPc8t*HjPunpbmtT+484IhES@!y?)2pUQ~1IC^% +ztK0bf4wHkhT)Wa{z+;;UHu1seVPYUpWtlJ{BkJyA=Un(<{Rp5Sa1QWl`SEdJ>l|AN{q8Z? +z6w#ZBIk3%w3UtgiPes?!8sAkDytsaKDRdOF?4JbjEd0k56LNsJZ&YFLK?nIvZ_eq&v$8z6vjiQ`@;O` +z!vDV7LvDlCzki$=7Sb2gRr;We>Jg{~J=fO-rta!9m^$P=!F-csrFU9FFL$i|2$y-H +z!&ir!0)1xw-ac9sIj{xsP?J?bs2_wxq4`p?hv|=K +z35k$UcWU$@#-$WB1^1^hv~XEdn&0T8QtirVbTLElxU1x7&V#`)Sn2WvZhChR$B)%p +zXMOKO_5yho7Uu#si|qwEpubO8_dnXHgdPuM!hX$PK6<^WJ&Fo<;0qSp-&YMM+d+=< +zn+&$t&4Meqr>}PyyXqH1^siOXaFE^wkzsW(@k%;*#kzLGFDDK^?4OAyZ5IN|` +zCVxa#QPI)y9sF~U@Q-tQzKP-Ab^bts=M`><4!tk?aL(yk&h4d$(Wm-sXPcRC$jh7u +ztlFl3zvP}a`-&s>;@!sy#Xm#1q^{o!x7OY%^W5BB1g=Fxj-;s#6DlrQ)hibMTVz4J +zT64Q~!jW)b_(WuO3FAa`bTKuu5MCDzX>3w1MB=rQKoOdHFA +zi=%pkxegn!>JxsqMuKoC|AKOEa#ieiK8a_XTv|~S>99Yt#%$}IFRl&0;2p&1EyI_j +zoOO=?)5R5-;a?dKv60|Ahqt_#nnp(Y;t>`-Z`NrWvk$0t(Xm~33gNTSPIvgY=Tol>Z6lVLBG} +z>TKo%iDN}V$fcWYb;tG{?Yo1A?d!S=HLuXuQ#iDq&HdE9h|Pul&Ha0}(?&MiPGEm- +zVCCzfpwD3Ab=Z?>W2nGy%9FCxiPS&ys+bpLS$dTl*sI>7+M_wOV}8<3Fs{bp`^(<# +z_LL`+LYZdk1Jymm@zuA1?D6lSXR>~y?3)K_*F!QL)Y;16!DpajL7hprtshBWqVn^) +zY#Aoav+usQo~Yn%_4_9L$Pl>ns(&;4ZDRp9hhZhRRi3*jEpHMt-!d +zF=v_`W&rHGxdB@W$#8(!chg1WAFKc#AdE95s8{Un@!j4>od$1i3jqw~v>AM~`-}IlJ>@6KO{31B(`cY +zEYK{{1`T+)?GTF~|9;xcI$Sbv9PpK`!)4@Fv&(=3R6NB1TAl|9fp-CW>4BMpll5>P +zh`*SHkOsGxclzSix|4FI6I-tLC(_ +z4-TN$^UThK`fM<vR&$!?f}}69IeG7mZNE^4W{X>CY>0;ISx6o-cfmh3 +zv#;M=+{nN34x4dlCjN4X(BK>+#j)5PjUPOxUc-4@G}spw9_ +zmFHT20DM5k51}F%8O;B?hBJJ50h?Z`M{jm<`E#{3g~waDP_||YSq_?5Mid0g<7}03H(zq!ow3@apNs`Byz_x#_ +z@2)TkajPJ7ZOF4~*dBYfyH^PgwOQX7;(XY=T_BO6WCBF&eLEZ=z9v!uI|loP#as1# +zDJ!S;oQj*X!;N{<&D;5&1MDU<7}Y$zKCZDN%-rl>KdVE!H$-r9FZ57zpAd}}u%Act_$&rgzaMJN*F?c2V=4S!^o +zgXK{Ox%EtptC)mmC_ld<>O|A;=?hDJFL3d!sh>l6vQ6IjDLp_ +zXX75VWRgic)AT)r7go|>0iB3T*YWN*j7!oS(+JJG@GLR!htl82-I(uz@wA~xis0z? +zZuUFnTyx%IK!#bVpmR>ml(#6$XH6~5sZvoxe$&fGUI0H=O7Ows;E0_j36J1YAG9P@ +zqdhaxl1CC{09|o6{*5|am(hpnhcycw;h#k( +zH+uAJDbEjIy6Qf8OXUqd=t1_nk6&FqZ$hxSq)M?p%O_v}Ku;5xXV&A}sZ^I3qN4H! +z{qSJ*QP#axj}g1yhIqJ?#qPJ}aG_Q~Jg-l%zzW^o{rsNBD|XbFW55r)D-;ge +zI{~Dz_cx9)>IcQvG%i2JSNS)Itp$aymtU~gHEVmO&~C_C%2z4ElQJ`!-dn-eW9gzO +z;R)IGiJxPJh$QlIKVQ{7@`HokZKcusYslLCZC%%3S{&G=3$%vKEt-$c`5`jY9i_Wu +zl}WBmOkndYG>OH06aXK=2>5Hc_3Q~{f`))=!3_r!{}n~f+JbZeVZUFmBpMq3)cut; +z^r)8WnE6NHzsirJpJw&)L{ye!F4G!ee1?C1B@mJeVhWi(a%o^6?UMKo(9ilb18DZV2?pGWbI3dUu*#w_1yWkRZl_`BQZ +zLuyu)ucK}5s9K-|oE22yriwi~k<-k0`T8I4Ha2-x=O8`w=Yt4LLfp^d +z%S0c;X;DA+JJqp#0J$Pfx@M91Pv48Fxl|dfe2^enAWuG6M&kL?Zy0kMwSlYr1Eo~f{^wA?7alz+jb)eJDx~;# +z2XR`pxA$^Ha(uFXR`+kMW1 +zot24ENVj;a(_Qk>p7`Dt1+hz(P}?EztF_u0_V$|P#;n>1Ju%QsXc@uHN0n(diPtWX +z2$LSPkluDPo5!Qh-E`MY+RNTv52d8gw{rXf#2-R4)xyB?hL1_;vk6UtaR^YTp5JDk +zz^Yoj9)vB} +zOP!zT4YZPsCUR`jAc0n;xj~nMgp-PcZQA?hGKD9nnLj5fIU_?8HBu(onwoZx7bA_C +z#pSNO1*9~>?qhTzM8*@g`J-FjDDLN=xfSvA4ZqkJ9F>fJiemoX5FhB*t(5s>xv4W@92W^AnmySyLUkn19 +zp0WYy);_(KYs`4f+bHkpr<(IiT08&k>RwDd0-roTIdk&7zi`1vs>$J?=^$>``}-o& +z8*gpTKBbQ-XP@?cI62UF2RB@?xG^WswEkX%FQ2#)oIw$o+u897rR^c$Rv6u51W~)MDr7xE5sSLgL5OvU +zEq;&s@QBp|_gSlbBE#SHR6qp8_m$rxG`vvyz@udST%wg?iIEus=&`cXm9A+EZs15D +z6k{E*fHCE|(0P({E}uteSmbErboK8p{XFe)`9YH17MD7$rR|0}dR_S@j=$_vweyF$ +z-BoPrVj2(SA0UOKqm|ud)V+4}u{yP4!1Y1<%VU#T9%&`og_A$cSU!nvN+_B_{~FOe +z8u$d6F61zm(iI~%LOB~K_1bricl4jT2;q21E!T~GqK|H^Y;&^oneV=bJ*RU|`b-hc +z+@D{gDDmPtsVz|vba=U_HDuz +zqzx4pI8)w38Y4M0QY16~3K>|5m6z{_eb|5T-AfdnW&xW^QPxwxr2jTkKmI;~B>^oI +zr5gcEBJcx|^l|SWLX!hYWT!)0b-_Q*i+8wy1vups6Utp@g?E%ipAy&OY6@>ULpe_K +zoKsl*Gb5l_&_{7Om-a&NMV9aIV8*5STImY#+-JV|96S;R;Tau=eh?U^3?zgmlK7X(YKVOz}{ +z#MN)j{iam7<(4JWSq3rnkj=RGl@mj|he7kBRC!LOK;jcY5vaZhNCmO3SWGoRXg4UkCRS5N2LYmCH50>eogS3AzP+ZIMX+u+`P +z_3RHGZJ}d4v4Amz{>2$InS^}iBg#i9Yj0Ldq*(j+)kRE8VT5eB<~YhZC(Z(=53Xt0 +z;4eb8U@ZSk%hFUI_ygw6k8Wf`>{up5;l@WcC!pElb%l_`G)@~)9RPB{d~3!?#P(># +z+|f%c2xa;6YAj3J*huf_Pr|1ie_*;0nDV?fH01Sh9Wt)afyBSCwVtJ#I33J|+tyNQ +z6^`eGZ@1+wKm`Rf=ieI^WJxNMS#~!Mq;q-=6WV41HE(DFqF;&wEZ<`xRIxx}1rHQt +z6EAL+$r`N$?B*O)Kf}fzj(-V;sANnBk~Dnkn5EG>a;-REI6K1Pyc8y4KLhqX<-{N^<+l;&nTQ>;xbAOx?5mg9mE450U5+H( +z7v{KIg*Tbaq;0~B34^u{Ka;RLmj+it1NPR>w&K*!A7Qu!PDWhU=kB%MZMw`r3-0zS +zT^${c&N&@M;hv2s3(Bt;O&>dzY_i)`g`+xHR+1UECq75N&`YIh}_0X|zBugkFU(qhCX){nbvF(MK9CC10tilhW +z^5^D9)L9His0?Ch{$;Z2yW| +zXXu#DWQYZL6m_08n3}9~gC3H@IH?L_$B2RoT84WgV!bLU!}RqG79jhxu!~xth?;th +zr$JWj^c8TJz&25Rh35H#?Sp*X;?ssAu1Q}Zn_&?ho#B3XW;GaA;%0P6+G?)KFEl)C +zeiJ$!qQF7t?oQH^jVo+AFeZ4sbQx{(**iHy$S~9w0**1e=B0du7)n2H?km!Nr9>D_ +z?HyYUUesIe9-X1~f{(t&bx24Q&g}lVHy_!M-c49_s#G;mh8p2Fx@~-;G!`y|9F#ef +z)zuz3TJx*@PPv!c!z->Q;Lg&;dUJKgn7s>*FVjx7FA8&|Hm;hpb~U07x+>iftp@rj1dl#Y +zhtnU^fA^j43+b&t?=4pyyF$F`5UF=VDQdUB{2RWfpe3vA$xt>};RzhLmH^hu_lVK$ +zfQbfu96eX3^osW$h)KsYbzk!6ey!J3+==_KKkZo0$Z#RVX#Ahyy216be_K8qGXr5@ +z`7e-NbY)y8t4NXH^?6^q(}7rF!;VDp;O%DHaU*|z%|idtYh%^@algVTpvp(!$3}u{ +zoE$h&_!1}@xRiHD{#Q&8oxYmetWA8l-z#(&;=Xx5)=o5#ixfpTyLzP@-<{%}XI4WL +z#&forcj&(|^ecjkYTWI20-yiEb+8~a-wl*TyaCeP&!HY~=D%no8XMl)cIf`ZucY=@ +zV|llK#7710yqK|;v1j7v&5{?xn?^0HmWnotw%P8k961y&&sL4Gaeis@El3q{3tuu< +zdF(o=<+S}~o(KCB!GygHxlajiOxnK}x11dun$oX}kJ=919#cI@ECe!1utB9{UzTo= +z91j~|AN^w!8sM05&%%P^O7}zI&@yG~Y;EnPKmJ|lPEJ{*wyr~Hk~emrfENh2K$dl5 +zh07eL`)-Chfsdx0zKck>*B(gux{E+@)zSPjXI)2z-G&R~ibt4v0#z%11yuGoEMW6V +z`sr~lcA;kzwCZ)X6V?ibn3j#@{uyE#zt1Hn@J7-HA}Z?47Wr$mU~>L +z^TCAu4>xl@t&a6-`RKSS?(dvf_V>L646y@_bY`VWpFnspxrVrSreZ2j>!OzmU&E{} +zu<`l#u5B3S#=+B2ytRi*-<+DAmot8ohq+vQt* +zhOW2gR4D%bpj!2#8z-P=1Dj^1+2C%H&v|%>up5>-HpA*a)WQ5%V292;fv(Slve%-d +zZ*2iQ3a~$FMAnN)^Jw(8aISvCHn`cs>%P2DoBF&NASd-NDA_=GesEsUqgd!M#7yod +zt?~fdXC^Ypvv-EJZ;;y_H?kgPhLpird!0*~p?rNNH7m8(J7DLyQ1{H0XfLd6g?S-J +zk6;79S&xEJbJ2YjuA4#k_#l+~r^BdYxNS57ttIzh=LK_Ju>F~)UARnW1Lh0)){&SW +zamjIG$GT%|>Kv;+$YZBcMRMFgKgR`!)sE)bFQggxRC`}88z1;N$IQX+p%JgH?hp8C +z4!>w%kP#6*7Q3+c?eF52j32QB{Hr45(!lK7m|C;CP?=xTJRSsjUT~4pq_Rc?`PR02 +zKp;*0biskW?fx?@{WX^?LZ^98N+eZ6>}96F@S9WMjrunpfg06m53>wdAk;C(6>@I5 +z`_GXby^SifT+Ne@ivz+5J2kz7^`)P>%6`)j@*C~gU6T6|ED@t5-!`w(O#fkYA-m@Y +zV-M8gjuxMHrWObsFlk}|m~MTMd!W8S!myuXr`;4C6P;N2pYsfBIi~Pm#pZELJCA8R +z_NY^%_#VX>f%s)^x%(vOBwS9>w50ctgs(BZ-g@Y2L#!tY>bk# +zf_+h9$w=pJ-74i0Ki?pFvUK3j&8#iMHMMWQ6=$SEj#vILP3_i?qhG_*J*g;-QooQI +zLHS_k<-94Z<%^K|y$^3^@~DJlk|R>>yRrUqy*dUvW?I%in4!5opZs7ZO1I{9Sq~k@ +zXaonCz-p}NKGdQ)@;(BiWwO6Xni0bk7WE8zC_FPcWpB{_!SXjYHdh_E0}Ja_u$O)k +z%@5I=jh2YHf+GJQP@K(`vQPyz?|~A%BB?)#fY7~U6Lu%6)A$ISO9gZUmig7Fx*@D1 +zd7C<*IrWb72dX|R&_tPSZYTFY;z4!K7O +zPxdRuj&aKY<1XvXQU1R>*U$fM-jrNgjm7qiE0Q__Ge(gz{%=6+nmm@drt3?hYj=v` +zl`N$^-$XbclV2QIVq__Is+)y{ur2>tq}a3snmVLCvdvi7HPB5WI8WmPNuG-r59m=s +zEFwvFm-470yEv9GATTQy*cQ+>;zjK|0iy2gdS8OTmW-_)TpH{Nk$>UOU9NGUrDed= +z?U6Ss3@%!hTL`NAN?2IYv2y=Bba3&jTCRbFm?oEtPP%l8ZsV2H+5n&T^{SS-L*oC>|59Y`twBt~mN3U1a +zM3|m72AoJ@!p~pLf6De9cNrT_6=er?!L89O{@ODy+n=UfS71{knDHknzKaLc2HTSsLhp4M*fd$4eiWhq( +zZEQa$?Hb4A>{h!%E>AoW8gQ8%hz9KX?^YDA<_2rsNh0H9_jhIr+Iw+&(%t@c$Tq@{ +zhQ-vOtc8fT(!T@e@cql5SbPUMQGXeoO16+{)HL858xZ-`reN#uhKXS#$@u}LG4u=! +zM~weEKXv(6lPgnAu=r<)__;}t%{xtL-LS0z_}=QsNKcv>?dO(uh3Uov=f*Et5eP_?qGI(}TB}4Ar$uaktBHrQ+qF +z?fB~P=x>XC+!aAbk7XJg&tECm>6-on8QP!IIzAcLKR&U(3WpnYVZD=L$dT&rr_J!I +z69sJ??}hsVjZ?Mzr8}~~^nuqK2j&lshS|SMKa55FTMX81<>?t8tzn-H!`vFzDQgq4 +zWdhNvSSgrIZNbY62ojqdc9z3&W$Muqj@;>bXn(hw&QnM7l52c7&&0D(yt_pec0Js7 +zhf@C$ea`;A=D`b(5|f_MIgwuW9bG(lV<~r|yt(PZ_N^wt=7-$&TlzCS%*w#*5(xSX +zriq-ct}YwRi^_>n+@9CwC(S2?@xWt+ywtvj5sZ7$!93xsTTG`Q$3-HnK4l8!Zlje| +z8mA-60-`BZL(TvjOGM@kl;S|aJVhc$+?4z`ENYxvs*O*ZvmmihwF)6%BmLbAwTdtc +z*x4u&OOm&EVkdh!-~!|nkHbxwEci4;slr(2W*T`sN);EQC)6Ca9Ft;Znl!FoDYtk@ +z5K7o-9Pq(UZO*8h5i51T>fNh{2|Hj-LwbS8=OrR=!8dDl^AIglh_*DQ%f*#66q)rh>u*|jxzL-N*`D1{g&#h~N5>>V&61C+8yb9)G%`#;&LE1kudE3v^;#BRGS0ke%2f +zp-G)hQ^c!M>~~ivw0sZ`kH0nSMZu>|D-32lQF4U>b1L`kRG%-OkLvzV2gii0CUsh& +zrQzsbUkRHTQe~${HSuD8gI$7f4T9r0kbe@JmM>5nwfQaemB63PP^wsSXmzGSlLps|pY`9* +zp2}c88UZcHA3p2vGJ7UB9#eMJ!`0~jkagWbO+De3Dkx1vdI^Y%N>hL&B4s*CQJ@RiOezf9k}Qd(ac#P9Zk*iF +zly>k>?_yDynz#A;(i#`@uRegDq+!LScNH66UJezhuu;GjZ;jO7Ays2w +zEDxV_A8_in;L+Y~E&d;XlS#Q7{H>7atbp`^Rqv>eUojPZJzte8ek5sldfvk6pI#sq +zPK#-3$ys0CuVPO)AvX$Rzl^&cN<&Y(;7Cc>u)5;eHvmo8cMJXaaWC8sx*13O +zpv6I=LvmGoZoV+X#DPKfe&L-Eb?g0}!X^NE>tkDgWoR7T0h9;EO-)8!E=NsmZ&IFc +z#nQl`0dq!>wjQ6ZMqiJMDpwA0#Y#X~j +z!~Y4MV$DrKE&jYQ^GJGx5ANH!jOqX0=Ch0=kZhfx$dUrp#4Nv=3jpMn0lHZPtUhHojT@wshjj2}5Yk +zB!8EhqWrKG4%o^6nk(GyE(1bBG+cSXw#!9BA$G=>%GpeJy4Nepx_>JmG@S(?5&dpw +zwhk*fZs2~|0jNnj)jMH8F(X^+oE|WmzCWpe=TS1aHvUBdo(du~@_W}C1f@=`Xyfl!x7P)gYPYS^Qh~Is +zDnsJ?S;5i^$qNIq&~2sq#AO0l4q*8&GZS-KS@NIX9xcmZ`9JU~I&f&WpxN~G`;Q-- +zyoTi2v(5a)XE9aSif0RGnl@$hS+omn>0*f?%lV^fdc%wDW6zQUo;J$Dnz1-ap%>g| +zf&AvEAOk&Ji|>DyRY!YI#2MOpqFRrP`(3LjgJWFsv^%p(ir-h~(1B-w^kf2+tXMPH +zFSSNss-;$D5P18gfAxD-_RPeC^_F#`o;Zqhw6*`v|de8UT4)k}!YK2+JcqYp?=GS8R*^`6f>8-#oU>%!J +zRtn=)wU!gyEH7cuakTA%T;|F);`X<9(pj9=gRtGYhre$n>{pn!T`&J;w<ZauLHZUG|pKubT0_Ob=N4e0}Qhf?|8KmBh9qW^(7fmZy +zA3O+Tz&X_ek89rr^2bFXlf+z9h2+09rCJ{%IfxD0{|$Y52{>znKNAKz4|!{wDkP7Y +zW{F)ryZ`*YIEb)weR4yM9=f^SYO-X1S9`i|=N?5Aesp^I0T@L$ckACL*LQ&C)y-0~ +zK$8UM56~TdyC>Zb{pDr=O9kPCkjI>z#DCG&j^7-vO$}x|;R@Rw*pZtF26+*5Iur-? +zD!|LM%h?&MnCrjr^7XqM#6s@O$+oI#D1J?V*H15Xj^Tn5%i{7t?1{>q)V=|wsRS9* +zqg$SfHm3KD=bBTV+)gkbc5tO#;Jnpj)vrI0ioK>A!XB9?&G}XxQAMu +zn&Q{|IJDX`xmyme6?d9TVy??;-&o=QXECsuXs}fN(Q`@j^*8FF|B3Ah!}#fj=SZK< +zNpEM(Nq9i;@5`Q|V$%FeV2LC7eL*uAY0uCKZ);B+GtD>XJhM4<_A}B{@{m@tZlm49 +zd?P-eXSTXE)k%EbFSdU+PRb(%I)*PB;HTm}Q?(3|3b*FsonI%sr?LHtjfifsA45VPO^4TkaGML(N;=}S-GrjV9A +zD~aRf_=V`n@k)Lzvb&lXJrwb~KseG)o4w#zd67S!_zerDeulPAEMmDJ_k>LoizXaY +zSZ6dmF1H)Es*6JkO>j5Zw8^P2HDm0w(Rn6QOQKJu+KeN|@T7E4?CrVNWQJq00Q%$Q +zUUT1lxL)R^5k5Cv5GxBdTjxCLK%0CdWd*hfnmw#4rpF*ad +z^zy&3Hg=V|&xM|kUdI^qte1<5A$E%g|GZEqz*LwOlU~wpcw8El&#}Uk=1E~{e{f*{ +z`k7gL+v9WmBLP%`-(`AwkG_j?eln;k;s4b+T7C7)S-^J;n5u>WuMMOsfYaBj5R6dq +z!;b@d8Yj%z%qDG-cVQU1IeJ|5PD{X*8Q8vVN@iM+bvXm7l`EHqp1ZWyI-!ef)rt`b +zPW>X&LK0Lz-YK{%Y$+TNJle~BD|)7xSx&n=4A5r6xj?`Bv)w!g_^Gh9v`tR4f=!E| +zPPmFjFA}UC4$=gvoiJyt>8l;FDib>@BmrmUD#wQutbVK_cHtU{PH=hR89dLiHJeHg +z0LUZuZ30KD(7WiLp1{AnEGHd)GdmyAl75ckghEE*%oD1? +z<>*<3Z_Z2Q{3wJ;B{TL!za$}fX?s1>CR5}w?C@{t6TU)J;c4T_L_RGJlXzVdzHx|7 +z=nNUJr$xWBTT+yBeWE0(NyRjM3ndbN%Nt#hzgOQisG8rgURs)>r-nGy?GkCRRF!*rEQA$@RQc>6E8Ra;If}sU9_S3wPy!hE)ssUL +zRE$tvDLl!xGFTapEbpnMW{s(8fdZ<>>6Wb1GRqajrI9YER1R@qyRg+z!PRJ_!B9L+ +z^Q6W4`Q_@Te6knCT!=H+oZ#6ao(DdD4;=d)b`IltCd~p*9OkWt@7RJDS)iK!-=B*O +z1+Rn!@#=dqoi@x1+?B0M{)E#mqUqPA8iM+2PESNwU&ajSmj}=CA6{!?$qRX!90r`s +zW`}#<{~K(o(?VYw4(A`L_yXs$VJzVQ{%H!0RZf1CHHQnGdf6OJkX7Pbe|K;pgQZH3 +z-tM*qix|RIsKvY)R?n4Dr#*EQ$9wk=FYO`UbK_u6r*Z>aVmf_>WPb#~?9C%x=kLl4 +z_R|*l-Pz;eYKqPw_DmI9vz}+i;BeOrzJZ7hn+n0kEZW6)F`6WeC5N5K7^n8vng148 +z{U8+#9F1rdOl4lQSrH-c`oCDb@09@S*v9A^2Vuxp4sGi7dvEuCZ@uWjI&?OV!@q9g +zXr;L@i7D>`7Ww8G{+07@$kq{BoqJU*_Gnk3y%2C$2cgTGw78GmGC$E7VBNs)(JjdD^(`u19(hCt +zK^QHS`?+OY^}mViM3z2dNGxYr=~$%9P;f +z>1!IbweZ#oC4cn*vCnhrBX;6^9k|wQrh&EhJd5v8*P1yqML+KZk*}USRSdJ!yB=J( +z>s_CHEtnWB7slxclhFuItJC+fy>pIf68Eb7Y>(Bvl?M*t@6(T|5Z3qNM2lLvmb(k? +zuYZ6ZKJ1+uQQVkZtm!ccTaPq=?OU&}<#6fmap1TMe@XV_`!B10r|8n6zc@%hARc;U +zo%&~A?fIc^fuEdsvebFsw_$SkI+k5%jAfSDZ0Ni(ySDyT#3dT)O9LnM_7u-awmh3i +zysE;51wI71H}|*y6{#XS3q!dG8jTMYh8b +zB4&Ul?>RVqg!6(>l~`0JA%NXMk^gLcUgx!kpV-S5nXruJ#Nk~F=|y)8r;3d?{c#eP +zy-!?62ks|5ESh(iL_!7C4RSBKS~H3v=DEcX6CCrfw@+KqMy`*_v*s_^45D>u{HV8< +z-obT#&aYim`E319RR`9LeR1<2yf#Un?!qiMeA74YI(sW?95?fNoYZpMRo&)5X#%1G +zkYX`2W!hR8h=EkLdX$M4P5o~3<5tO>^!D?2)b288g=eeRSoA@%RW*r$=x!|bC10p= +zWimxVF2n`dL?N_D`gm6NW6|RULiX^il!iO9L2BTcS7?OY5gm1^Dt=wrvqNU)(II}n +z1%F(kfF}@~<9GQ7gGt6sL8R0MKvh5E8u6_C_X#ElJHv)wPcLr8BZN+mr`ZP%*xj3c +zvvL8;L#^k89Qr>nc2qgw*`_7%oGSnms{yV|DDu5Y#8?#C1wB0*b)T*GG57AXg7Lcwr-DZqiFU1TlDQ? +zj9d9y`C`asRG}sJLQCPt&+dLPwK3+~jyMV|(_DC|A4Ro8UtMK4DG)O@L%w!RMc!_2 +zTjsxEo+!LAbyhqccH(3BPBZxjSsV9v+1&74r*HMf?XCH3uaEYhJs2^&y@p@oXoOLg +zXNin2sB6JjS6L^MObc$w=Y)$If91li!VC+Q%|O^^mT6u`lToPr+g!tM9Ks%K;tjg3 +zjLqdm6!YJ6XNotEq>|;3%pA<-v%^{M;r4J3wrLSwnyoL_U84hR{(DM5q@7gq9UC9eZ!Ao`*8^t9 +zRkjv1t}beMfqm1A-~pThAs}`jAF)kYJK~3Y%xvNWzVUutXpiM~+9GK6qnBsV#NsWA +z@^D2=C^X8u3wc5HHaT!)gdYFYk&H0X-fMH-8@l8X2khdS$v4t(1z^ +zP?@C5jde4u0352rLye73|| +zdb|RTjx1BCEj+~*oO<+j0CDkwXYIuoFIRPd$?L%dN16C_;pj{s7ZEkW&i1sG)TFNA +zy70YOTyV+Jn~n7YrbADJrUvvRYFKtGjUL1AC!6yNFOIJL#OvO>umF0&T)owqeTT$q`m7gjhkNogR_3Ct$4Ha;L& +z4Zt(mCJ?hBupEZyeS=o@D|@4EgaNhabqW2p)P!; +zL<`^7k4!mg&w;Tuu~uQu&u6A1t;NCt3sxKgpiT9!9nhL!f;IGTeSbZ-q{?OmKeL|l +z{^mfE=8Jr`IQf5W>wNp&CAVQa$0xov`~5w!qAG9t%>k6~vEv4TYz|@HA><1K+bfUUb8$8}^*M}FiuJ(d@oO!D +zzQi@jY%bq4<0MZ?%}FO3VpMy-mcti5E6;J9&oMis!gM}B_9EL{)=B-qR#+_lAW@-2 +zbaP3XSn3@LVDXvVav0v_b%7@K%R~FQl@q-1bqJrri-lt9+YVzy!>cM{fNTh%DP0&) +z?vk|{Wl%Iznjs~Yiy6Iyyh6!>5Ag*4sj#k<%7FFfKg#m`bbss>Y>B1&r@CJ|?ZW_L +z7M_NmW6@ltplx?{qF9P%k?B%mIa_J_S-ufvV6guZY)jl^0H~`W~5ZTuQ!EhbE9YP!}sa`RQv+YnD#H&iESr}BgG-kc((he^y{WS7=3bQys;VI_ltGxtpW^&Hx84i8#!;SH{6xf7Yl33Lp>GwEp$zh +zw?a`?*%9)#NH$q3MXtc6sL6qL!^2$1))~CPiFW3vx2Iyd+DkJ(w>h%z-HLj +z!Bq9b3W5kZX32g>%nBm0ycMVm&fTCJ>%;T+0lCA&ZxQZ$ILjOR=+u#QC~9Uu$osn*2UnHa +zXHV$yMIYm+0LL?%Mb&TWAw;K}dwpQiD>C7Hovg*yd1@sm1eIR-!zH7ac@?g0lFHu?B +zL1(I)VpUinr7O#dG9<;7X-tjk+vA~8LyK^Fx%| +zk~_{Lv9`f}owf1*iA~Xef`3a*#?!)@E?`Nk0YEMLnJf4&OMR_?CqB@6u9ry<14HeC +zC|{2qy#A5e@NW2?iUeH?WwI&lXmd%K)F +zF=%?q9e*5246jvr>4Z6n*H@6=HM|ED7&hbDwNpn=>xaKNKCp76E~()een`~Q%`*BU +z0h}Q1xK5YCR(ssKeNUF(ISHbPy=wM?NgM6cf|kz}1=L0Ir~h&kFk0tZ8{v={k#0Fn +znB?hkzt&*%o@k8(773L65^s9&&f=|kXG=4grdDxoEqZ&@XJ*Y7TL_B2(8DuhAT7F&#!4G +zKqWhVpS&3GxrT2}jnMQ&+&&&4aphvuO|hxU7N0kcy}n)le6m>Fvv5_l_TJu>Whh&Y +z2$@HvHoqTz>&I+@Jc1=w{%k{@Z${6ck!%6)sJJeQdKj?tnfB2L6?hmuaX%kY?hJ#4 +zXDrlk<)?o|+V-dVEFc+lued3kMMibON0iqdmlw~ioR +zC-{+%CM_nxMd0$e?v~V$#D3b!89SC}VJd>Q>E87=eb2tS6wNDty?H3 +zsymryp`kb)51TSyy>!;u17G_te_bp8jayi|ygcD@4IAdB*y~v7>lt!#K62MVum77h +zxO5R6xBUQ%+OZ|Uu3AjWF)}=2dY2qr6m)p0xY43+3uMG(9dL!^p7^7yp+z6B@;`rl +znSSPB{Ef@p*Y0!Qy>l&oq4kfX`lo$8zV~D7>5&4*gY?FM-dcTd!T|6thG2xTJALl$ +zU2rz}O>N!Qgn5;)YhY9=9-!$5LNISKe@lYD)FDyeqI_0gZfdpTq@`IgcKCT^-o*8C +zU}fE>gVUWfjMY=Ez^LyQPqi>Rtu>e0r=&uq@7yZS-Vdlz*%!ZN@T;qMZxJ#nZsLb1 +z#BwaHFsju2_?U6RZ1`J!IiE=MaTJznp|!vF&p4odP9IxNEH_1Fh-K>?B{0Ty7jxz? +z!+MH2-N`e#AAg~3d_O$Q@FFL8KI$qK8%9!Jef&!_oHdH#a-WJ;h*)|KaP(jEC10B` +zyqOhgo|)s{wW>04@zCFD`8msQb-sDp+0LSt#|Mt}xwFJ$NZzUO;k#0&ePJAzpASAh +z5Oee170LgXmT70cTPT>LB(~I5#LTxQH||2Al}r#cStAIvI(fY&YkLMSk&M1A(_4vr +zc9P{95R5SS&4s@ +zAv$JT2yl-n=Mi%ocwR(Iu(xDp$R`5%nzmT%{-qS%eISu`dthvZ_KBs2xAk}+&n&}> +zhbQgWbmQ@nRV%pm{=Vi>U8`gb?dhx`JZ7{h?WJNtL|yfLcjhdOF!=b^7^W2fASJZA??~c>t76+dO@3M~C4F<6Xbqf{9u6FFp)-0EQ0$JdHD%#+ +zGM=K&#l5*-`Z!Y|DfOaBFj6pkb-PUvTRc4QN>+M(X1sbfIJHWiw=jhA^`dd`_uuYT +zWvjn1L%tpbQ)#=7ep_>QJK2WiQ(}hm4DC3O;l9*vX#5_uhz-L;;dRfK6`d1Ayuez` +zHE?)#d0?kr$9{s+1s-%$na8RXx5$bAB3fN$R{oOS#ZKDpMhHg)aeS8e3~~9O*9u023q|wb@n}-ZenMqwZEN?mOkb)>?h)?WXd` +zZX&R4#1i`t8rxBac~QEiW0U>~RWfDSGd1F7USH-4X>I6KlBh*6*7o(ct=@ApJFBRk +z!gAb>)y-?03Q?DxS`3KKZcm?2D+rL={YYf+bU++}R(G)!2RDoL(s8~v$w9$TMDP$v +zxaVKXzZ%!!p%+j7n_3iz%LO)PvH=VVFH;x>+VINUfkha%&$f76b;P1b(#@eaA4Nr^ +zlgi89n>!cpVH-(8D)Ogl8}eU{E=kpqHnRJ%9% +zHf!eUVHppgT^OTPf_J|u6r2DlWMr&^b(ju`(9OL9UI40Eio%yqc<^P)KR+2lL=14s +zetcv<%C)!KZoa*n(Y(r8QLHC~H9p6YQqjowf&n|LsH@4KI=}_wp#QZs!(l*Hc_`J! +zg=uovh5@{A@lNxOF=Or89O7KbUa+{tpR_6<<$Y&oMTUbT;?pn1%BJ +zA$<+pO$2k6dpJwMCS_#So!UXIJ3iAJf2YU01Uf4pcP051-LLg(kvQ#EFJA0^#rHNf +z3UP4Sf2Veb8K0r794v)?HX;qevEr1$Oyrea4c_!gqYZS7WNWuRn{QWi8{VU8fl0|N +zMt1|-MavL##cLKK}zSxe|YE}MpNe90D@HAAST +z=K&4>$t&-FAPjp$Nxn6}d*E%HtloH`Ocz>r#Q;(7;9n$+O>u4tWd+-ucv?ofpNs2; +zT_)wZY7pN>y3d6bhv>4+?*^Kp**LuF45ei+am%IK5)v+B%NI7YBlwzd@=>yvj=YG< +zM^m!7@lA6#T%99*CpyY@IKP&|`i|yvk)cgPntU(Un4NW#9M=p`R +z_%u(|hXEwane9dHAvJpo!d>hS&mjyCXw^-5r-}1TJ8(T{bv6D_uB_9^(C(ZovpO(4IR<^G7eEf$gDeM4QW8zzw9`aEZ^mrZa>`VI%iJSo&m+ +zekgvKBItT8)EuxU5NY!R6$n0iEJ5l+dD-Q&?RT9)W8X=?BoN}V{8_?o$Qx?jf?cNs`qNgDY&zvt0HuHYUGG_6{D)LV|E +z94+1}il15KC%|_P^I5n=^nAeGktIUJX5v^o)g>Njh#*QP* +z4p5LxW%1Li`*g<~u~!gwVxoLE=Jnp;dT(tm9Z~c0dgdvL&4Dh70cZco8%16LTq|t* +zcI)WgZ~j>QKIm)e$+uhk0LwvJ;TvScEzA|l48>+IU)Jn^KcnS?^I>9>M$^%PBioYo +z@7vMeK(Eh%zj>)%S-h01=h#e)GZ*E`4NQoHA(i(As6Fj?;%(t3vDr-d5h6VEQhMiF +zQ+W)FQcR}jR9rxw)6S2xG}{G@M{4oj%jR!GagdrDUIYOJhU6_tZkm;J-3>J`%_eey-WIBHN07CygJt +zGlu`t4++z~Efp{cfpWV6TW8CaJlo +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 +z~wOD~={oK)*4rWz)e*fI4l +ze)7BdEqnQiNTd4S&C+Xq!kmR`o<_^4CX{*LZ;vWf=MSl|qDvXSiai~>n>0>n=)b>q +z+-(X58vIN%`Z-9DuX>X*kX)VzaDmJ-i;(IHD&QaPtqU*Md6pWsCM3YM0Tu#&4ybvn +zX`=dWH|d1p+C!%%>=YMCOa5tmE#`xU$-3}r?un?8`eR2#M;R|z%bcRKqTyZgFeC29 +zuI!el`KMwQ9aY1YuUjUg7mpu}#+;+-Hv4iDv#kt^rnE`l5G;~W$0mJe#kAqbpST+7 +z;s|R*^6{7>wL0C(C(mzfO?7Lv_L`Gi-KpBDYK;3|k6F#o$@`@<;~g$iY=e@09J>92 +zKCk|1N`D_7VwQY*BJ;O;a4A406%y&(tpws-w;%hZwX6D%rOY-L +zB%m2NRPH17&$Yzi8CU7139Nq=+Iu#9$r1W>)-Usb9iWm{&hcU&B0mWmO*J;j#05+1Icgv-KLDK +z{hIQM*&Va-ketjPaKkN@CBq$WJ#W*WtOb(qXx5_92us=(|$PJMB +zuZo1`J7>cG^qflhajY0r`yW1`4ZugK@cTs@Jy? +zl0EyJYwevdP1WgHY?|}?DBO46`LEX&tQ6nx&}g&oZgKWt9yC2PuV%M>tQaOYpi +z1NBEAe`I=|${n;H`mIFuf|hE;rB%mizb9E`ONCsY7)nbP^S>nW*BKwFHo6)W+Rkn1 +z{`EF&auTaY7&)F}pyUTH)QLP0wn3OUx>%$dH6d4YN2j;gbcGGWLynzFY;UEz0{7zt +z=OEI)6cx20Prr++g$H-0c9+dRoA+U~Qm-ULeJhr;fi@oV;7dy9} +zT3xw1oSkb2u!*&C*hTjwEeB+3Y_xl17}T}+*{dF;n&=Rd^6ctXw`#3zbIOmQy`QMR +z;x?1Q=6;S9>{+9gj;b2LSn~RFsxRL`r?4{nUtO9LT2QYte*5stNaZjW%q#AD*qk#p +zPO@q^+5h-IBfe8J{^vdCHZKFO-D7KPK79C$@6?YC1G~WnE7h>e%wiU$_JKVsb4($7 +znF-9ASrhNw_=d`BiXq@PoV7is&UdI<+vR!^u|Zy_w-)WZ1&YFl5&9)S-h*#lKZq7||MIX@~{{>#bmS(t8AFKv=#N--`B>&8epuXF%w8 +zlA*`2-6H9vQe>lQOt#W(vJ=*t{)86~Q0hT7 +zF`Ux6|0JFl-ujfjq(@0E9%;Zpo7Ugr(AX@IA^rG|^vOVF_ +z2~(;6o(+9q&YPhjUObD^fA6Ii8NY15Y+`_~DSSe{3Pv2ME)SJD{_C-FhcJ^Ri3%Lj +z!>IVV$=m#=sP!JX24g?6qFci-N>kc@rJYN~6QjxB==+EzZtka65HYLQbqnWf@K;|8 +zWyq$=k9;<#t;nxd4FgK@dvagc75o~l%AuDfn8`-#`^ufchIu`Ic)MXZbLv^)TDx-5 +zf`%r)mdRfAlm`}Y2!(0#!*B6q`>XRKb$UPqPpt6a|4?-0@lbx>|67tmdq}Mm6_CqYF9}%68UvZ+O9%pvC#?!gs9h#d9x?8DKPkF!OJ*dm|re#z0M +zux#^O*@%j-;40$WwHm +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 +zyf%>U(5mXr8r^p3TX< +zg{NP4Ru|qlzJ7VD^J~`wP?&21v8xX2hkod1BAeU^2HQ*CTK19=+cU#k_0%g`=ARs_j$kVUtxd^!b9m5Of +zuyrtKq-G>OIm%*7tN+FFS`lzll}CI +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 +zr1D>**VJ&^B(eO +z=cgyp=awDULqief^zw=)8a@;GZK6bwpx{Nch>mbnX0|I&&ifr+w1^g6oL0PXDfGB1 +zFXKGa^{CBmJf$)xBsf%%7X89(tKuinYf44q5@;ccWnyC4y-ahX{HHpqcf9Y?l8T9Xqr1yC0{9jvyj7a-ORUxm54z&niKF)O;JYf4VL3h|{^Jv9PCU};LTZRt@2z$H +z8ois6jU$eya#GkzN5iwvF#RmH4g`oGNO+_U3(|_d;CN~fe77s}44`)ODAMgmr0@b9 +zbPL=w1$g)8zI;t3`PnV-`JLgB+^R~9_KXHk`m-+$xV8x&{bZ?nOg7IYUUbOx9r&d8zRSz; +z7H#3$@xddC-`I@a=qC(fqV-l|wZcH4-7Q+epWlnQM7a*9#q78OyIA$?oN>4^&|JWL +zOSCzsDZcY5_T2o^13_zmNnk#Sq0I7UcUpVY(qDbk%CgkKNb7szK#;2Sq6eW>J1Zb| +z`a+FLwRaU^Qod5ab^p25%w4i=Mp!n@b17dVG1SzYJ5{OmPsgyk_|)4rYs-%BMVlA; +z4?JB8pO^}cbHR$G}}F1G#0qug>JbIdfuorrCojyWHDtv{>k_pSycu#-f1|T +z&X7M=-`QwstVTJ9Bpg04vr^U@$T308EnN4_AAAj?bDAWf5%CP(4b{x<41x-n7BlJmIUY0i}wNK$AjWp=GkIi-uT<**wdL6i}2`@N{XJU#7*A +zwM?0+Bin!qjll7<6?yq^^=l1ww`BOO++5AU7(8w}_>Zf7=h%Z65i +z(O+&f%`7fR?002#emRWK&0Gim9es>KkVQfQpQgRPRO9uv?eNi>5aK*Otn*=n2hFCMkS*~(xSxu; +zCC8tq4<;K+%MyxMC%#8*dYGz^zz+$j@E0*DekIV7@c2WCL7S?iO@i&4=Gynjn;RGR +zPGlSecaE&%x9R5eIIzx!$zEPs;+w(C9zxh=SD!M$j_v=7s$VNqhGb0}Q$tVqQ$cn` +zoRvkg;mYKooV|>lhL0YAnpuNCk>4{;R>L1=8&+G$J2rJZIV{Z;v<}1NHdv%oRusZ? +zb~exNd)4i(k72{N{cU*jw%p-m0s>y&iBjfW;?DDj{`+5TgU7O8Xf;&(J*Y0WkL%@L +z?RsDnP_^XCFjfI?+!$s&DUC^XtS|$6`WaN+D~yu7()zNT{!YY*bA*% +zU45nY@iV7z1l}!ger690t;I%=yV%nnQD*W~YUDt?B+xKbZwCo_Ew!IfdB_LZ^{vVF +zVK?`pfp-V$VCtvHczKQ(Br2;zi&xXTcBtrafkL|8EP%bM%lpp^%q9<40WlcUi>UhN +zAw?P*rK&OyT$ga-K=VsVoFIk1~XbPycx%aK2CtZiByr +zEwSGc<>=N3b+w$igH7z0%)Eo0#)(9{s4`(KyvPw<4-Hnn%L&5ugq3tJ%TPwc6gf2@ +z1!fb!9%C|)AxfNE6!|?r2n;yUM6gvsHrJL|VL>%;XpHR3)LkKdV$ +zgK$3Mk99H{-GhG8Pu>!q7l;jv?4BxoQ59$or5Rld;I6aS;WkWqiIV}wtbnyo=3P&h +z`;@HC6H7gqT^@R&&X1W3P~oJ4=Awb!k1-v`TZ9)?Ga`FPf%9ETtH9Rol;pQzyAjt& +z*r`6vPiqBr;j=e{HFoqF@+-tMVyB(;V1R}s@&(8Ufa0F~7P~)X1K@^OrrN+`4b>`x +zRlCP9&Y^vrCiKS$4KZQzVj@bLC+Resi!nKU|0s+(`*za3)hA4~)6>NszI0tf1qDu6~ML(}p6|RfQ3!cVwPl{tfL=ifjvaQOD7RP?2iFAyE+y4(cQ1cC+zcR@{F8DFR%; +z{*yYs6=Ehr>UgCp-M7nHm%#~aA--AQ +zqnJ|W%JN@$x0M=MmkCm*W#!=fx>HMYI(I$PaRecmWQe%s_t5^?x9ifH)6h#0Zq-+~ +z_O}#$i#qw3?oq_-uC;mqU)Id +z7qDc_R@i0qcW-*xg?0INErJ43V8cH)jLXCXx32;`XHdP72RRqkeV?{oNcwFD2kVMr +zfNg<`7-Cwf?$rBYz`J{kimB)g$>kX&xk`fqF)r4lch!0kmY0+m*xMN*0UwUG?%D-pBJpp8`Y*sj)X@fEK3x|4vZ=Eon=DDf3X-b4TUu+tXQ*(N0^ +z;@fSEF)51n3}aD|o#E=KpDnencgxQ|@nfXw*S0WTaP(@2PRX)gJ84HKh9NE22IQr+ +z31!zwt$Ux}3^Dl$Y>qvD{|5KQHD1ve2Cea+yOc4p?tRnv#^_k!5=m-uJ{noTHk#_+<0$AA +zAy;aB$!nA;%&I55{cBNba&I(p|9Xw5%gOutVH{g4?jj>8?4ohf^imo6LmaLX01e_(H# +zno;SAL?}KZabZudxOfo$&W_kqy0n@%Lk{;mYbx{Z_i5j}%g@=Y-R7w&%BXh+9-g+f +zzSHG31x;Vv?hfQXnDLv74}H7^w} +zRP5`J<%A3$s@)z?HnezmHPkq*b6e4>)f(F3Y;uyaL7q&1LnzhQ3B5h+jqbBvdbWMP +ztHQ0i3RAP~=mCfdN^PpG8OM0g4U~E_U6l34zx4#Za)@IRPM+m;@8zpknvPr5NN=lo +z`Zj7mT~GJ%=GxGoR8j^GGb)aqyuFihOE%#Vjr!}iWcyg>e)|3?EBF|i7Zjr#A8Oge +z^<-wMGEUTWR>sMLZ(jKR%s0XNy4he8tfIMy`J6HR8O^!j5b;;%#&AtJqJGIt`!o;~ +zy&3k9Z!)l6uH5A`^qZ$q*(|B!+Lp#;H}0wWiO$;<(F~7S`X-zl&&>99;?Wx47!|F= +z=;JNAsJJ&PI0Bwoc)i{nbbIIOca=S*OCh|&p4rI%^7`(~JyvL1 +zirv?xI_+J{^F!(fj(k-)Z9oLDPEHnBplRQZ7dP)jd5*ix*@^jGajASWHRkOU4plCD +zcMoel!F7GH_GBVZj=NMqYX9|knCUgo=jADG;6c53@9uA*V@ck%U#K6-#xgpxqGQ}& +znI7~I;14V(oUV8ZkcoIc(o&Vw%cZDYiZRJnAjyB#KYfb)t1(?9TDn%jvLYg)xhS;% +zb>Y%PnM=lo)igWcX(p;dI3>+U=Xn2= +z5|Z(KJPZwf?<4#=Y0@|2NKt+)?Bk-1c5>eAy>NNz^Zm=~A?r$c={*r_i+lGvmq69= +zZi*f*>&^DfFI6jd`YSa=DlF*gPqR1ir-=Nlmk}_LROyJM@`#)DY_{zWx?FK#tJImy +zqx?uU$ArJ~^^S%DmdVkFT*F_#7v1ExqsDG>Jk$ELY3HL*(`vT%+h_huNl4gSN7-@R +z6Mx5Sc>1OtP;${1mUQ5cZ830G;&+xg^2*^;0Gf9?s~F&Rp#re1aln+$Joxz2B7y)aVflyAQ$bsyM6px +zAm~TZ-pSxw`AZ^HTLJ1gKZc6n)LiRtl^jHGEo=@DhKgGe3&_XkoptaNL$B2dnlA#w8IOE#tAR@?$45$;?5bhoCN|LS +zC)0)Ue&gn&%x6h~xD}SILD)Qg3HgkxOVo}QrV(Tm;S{bxTKUG$aO7Ha*$S)`CJ$vQ +z(44sn7dHnn8|pKg@}7=S)ZG=pylt@s;Uv+9b!4vxxy#qz2N>A4Ia7#g^+U0fq&ffX +zzhWhIUC}K&8~U$TwEQfhIwCumm1JQ#0Y8g0sug6iV{0HX;xfet+;WN49~ds4ziqFN +zK8_3vU?mMUB*C9tKN76zbU5QIN}c)0PPwEH6X5F~u0N4Fg&EJe+IzAF4Nm>K#D`AZ +z2v)Vb4piLT-Hfk5vUt0*;`|ese}QM53E$Ui*|DHx2Ik2bIk`rN;}zJb +zrHTLP=_9kE$6GJ(_@c;ei2rj5+PR|_(K2JL<4l{bD~#@cdOM~hXMiQS`je$KQX6sQ +zI8H0SR0gKRvVZG|0h=yo&a;bj7wXb)Q;LhBm`nYeIkr2;&88%wg=gxGS9BM!AMG>I +zM>eI|Pf7qZY{x(*`dIF$!tNK_=M&k|D^%Csnf%);z@2MtjSUY`!n4j7b^ZqaP0l2m +z4R+yWR#?<6rtAzx{piPT5~R@a5lAMnU6fH7&KG1qI#WO{B^3ghrfR#`6p_RJ>wI6}%>)D+(bEj0_90#>`OuldQtlp-)(3q95?Vqyqm9G2f +z7kE9~hY#HR^JLoYhThvi`sQscWwt)7X1VnZ1a!At`O<8omwAi +z?sR5dM2;T#+D^C}pQ)=!RXYA%>8cX+F8@HJ)(WD#yJ>xC@$0ktDfF-j@?CAL-bBM- +zsUV~G_n74qLp_Z5EJ`rcE-dt|3e_~rmb=b3&xTs(a0wt?HuKpF`*-ounW_HoUt58- +zv7>F9acVU%o0$k?n;>Jf_r$CQW{1Zu)y1Ne;9;gJ;NC_%o7xq>tjNdKm!Mof0>*=ALUY`Cn9$sZ7`U32sK5Li#gpm&O2 +zC}q1|kP>3YE&NsAw|{TFT9Bgdvjm4n`AzKZg{ctX$?|Wiq9W(N5%ezwXl|@N@|;We +zIA1h&Pe4!UX@O8s5AW7Bb87SPmlCtVXE?lS0QSqvrONiFRQ190^Z3&;FKDrB)nxlI +zO;RZ7#&E09s7rF3QtQhk>SX%Xvz +z{I;eK_m1uz`Ed)aW1qabI`hj+ppBmNh;>DTe!=4B+R@^-(7z(*X`l6@cVLBD$!Cxr)7K^hrLpRZyYCj2;#Nr +z(gd%{c)@JkwTE4M0SYxd4n+p8`G*#JP9BHWIA=Q_f1jagnWpG_UjH?F47pf@uzQ{( +z`}cEH0ha!hIzOIvH}LB>mhZay?`&RS1=vV5k*qlUK&+MIdRHgrIa`0G5Hy9nufR-sh`?1v2cHzyCy`id^kCB +z&HJEy6Uo`LLP_0}mU8@!pHwa}s&@p@ZXJ3*NSfIWwh=8qJ&VtVhUc;>^BZbfgah`K +zl-cfE$4sjT3vDxNkw#RLc<+dXQ(r1C^m9{qlchzM0+lzYuQF&@O62#Sv%`;I_&#-` +zkgMUm8(nqvFS**~_#P*B9X7pZS~bOykT+0s=|6;=0P23fx1ubbBWHM|?zq+toQeD|kAuK?FqS@%z*U5o4v7mmZ3uH_R%uT{{5 +z#y775?1S;eHjf7My#756KFYBT0%m?Z=>uCFfi_xze^7!10u|b#mLa<4S}aLx6mxyM +zTRjipW1$B|Le1J@C{b$7QOIK^0J&OES>vmOG3<&hgyk=Y|uO8l+0C7=^`A_ +zXAsPZpVPal37a-d>S+(aucv-Ly-ZuyAAIR)Mq+=3dM6YG!^Kt0>r=c!+Rde}Y742C8 +zlP>8O7qe?F*rjq+vp8&w@vPt^?2w^)b&KY2Wa8?NBp~-ZWJeAXx<`MPFqR0LG0!F| +zwWpopd)k*IR*;?IlYS(*4J`afy1}BquI95{{pS7Z{b7_8KTE_UJL2R*LVYcuE0yS2B +zl8~+$F3P5(O?YN542Ip{AL&s!)|rs+U2)n4k{pF;Uj(KL)v>vF%Z21<%#FpM-`$Zo +zy>CX^`(lB1&50&U&zJL)d&MzfhovKXL}hn|wG?Ot7Blj`VR +zTgk7>KQhqXXFsE&xQDh?6X#i7N!VbfT;m3KF4KR%pWHbm4fv0HQPF>T^8LDY(~Mhh +zH?Y5e_)eQ-)Au`g73R&tp51F`C%Tk*HM!HIDf2S7h%M^HYi-hQQza%D!ko}qrN5uF +zN!Pm_e`;`r;Y095XA3isM+aYMvqxOP-C_uH(<3)JfNQYs>BtCi(NLvu-*9bOLqwln +zPbspig%P0*E;6f|zj+;CO&fE)Xs-J+vf#>c_aE&=$ukJe?WN*#6tE6cFz) +z51NSi-PDW3o|l5gw|>k>7j5MK4^=`8VV=V>M7D~|KAcwPzxOyBW(qApj2278+3~En-cAj?vJ&mgd=Vi=1tGHKOz%U#_`MAf+rLw{ +z`|9Q|xMs78HcfF +zE6zMjAGnx(0pq(}0q02#^W+Oqzswj;DG`q&T3NG!^DjVE8;1sdR}}Qc*~AeoshQ4Z +z_lsbik%nTl%2Ww%o-z04wFk8~DV~>P93^3TZbyvihs5%%n0F68S~mC@LvB*$7qx;+ +zKXMnQPfB0Z-E49#OkcKZIi8Zfh$R1h+j?`|+kr7Hevz@WXP7McQ!g$ABYqKyhYW8y +z54`0pqjfH%dHL_BE3?>B9se9=CtjP=cmw}$>$&~BcvJ1m9SQmyAS|?@Jv-nRRjbMS +zp1nNI4nYza=4;fha`6)VPr%c#(4dQj>Zz%QKc(@3;pCdW!}LrK{+8)IToagofWhgd +zDqPnwCcmgvSalnt1b-vNINhO +z9T?vp9Uyr4YJ4!@HhFDsETb=lqZ;#r21i#{T(%(J4J_|}UgegDW^dV-*mjkPzRNeQ +zvl2Dn2E=i+#!l$|uP)2&%ACT)!i8-va(^CtOqZpaW4O;|UU`P?(v+eR_Kul|DcshZ +zeOu^&ZEm9Y5$r1pVUP7Rq<^|A+Hi^*U#uy`+X4)!mW%o)vr`+SoM$th@M7?n0Kswh +zCXV0n<&1zjmDk*5GoSc99+-WyNc-aMVOf|Z$v`0*AcsK5gSS}*G6nNJj6Y2ap5+$h +z)v+CJPcTvm5>LRjpZcSsiduk(N5rtz+d!$8Hbv9Oqyj0PWs4B7b_=CSV2s;h*P +z8r=ulzIhC7o!B|HRm_9oJ(-<#bdiLD{c+OWn+}e1rL_fDwD=yGnB}=w=^E>p&0R`0 +zOxfVe&`Z@Vx95-5+exz$-^PfNXE*yQ_b`NKdHOY;88Zz&R()#C^bF7Ma~2?Vhi31* +zx=O+D)?lM9XIxvY%m~kl&C$D_<6!UErF!+zos$4Ry8@f?zQf=c-vDs +z{)__#hdAk}$;iTaws{1v)dpAR-V`Z)kxQUy*vPDHCQlxN{fD?0D9Nkev&@4Sg4rohi*DEg6@*%U{f!Rh*(lY3+P7Q1-B`Y +zyt7XllxVRx=1sH=Q46_udIb<3+u3JEs?s|~1-HIXDZfWc3SsGU&gO4pEu0(OD*|ms +zsH65H=3&1!hu;~8(^i0f8r`h|feasa$~`E}9jS!F`u9x~z-FlL%e4&Q=0YiJoX$$& +zySLo2)8!c7cd?^)-w$7PpBw-rVQ^m#nvZ@Iju0!SU;hL7)=bE0E^|7sYVCejB8Be% +zoftvmv(x<4yDR5b{3iquYUCKL5hCPjdT@R!zX)Dc1J*^+6Z; +zeg%r3ozt>w9T~83HnQgRc%VF*Cq3NIso48t1iOEfWz$-hzdTw(C{mPgmU%ne;44Q^ +z|DW}9{MZzkW`&M>YR0}{J*gxleP<&osT)@$3O(iY{+HsHBqwTWtF=8!o +zJ5!zr^McH@{W!|g*(&BBS-(Fil_#2PZWO+a8i6x*CHdER8>~kVKO%GZgGN}Xb(kc) +zJdsaOb+Y3gL5;+KbI=-A%e3T)18zIWwU3?M@_o+y*zw7^6M1y5iLT$i-YjU)$nd2=C>ihUABRkO7wsevhgrt{AH)2FE0IMdL +zN}N|3L7{i2`N#{iJCbc;l>zTpU)fQVmlWiJVnz^l^duQ@^W>!jXV{S+C~St0yqfT{ +zx*i=@Nj9(}rK{KIy^Fz2>{TW^r*!Q_wcgMqmCPKwE^Pi7z5QM9r(nak`L +z>`T;8J-RQU&&faL|Jb|tsHVDo1Elfql8zLa2 +zctb&mihx{qJB%`|BK1lIkt$W>8U-P8O)XVaiV+ZkKnPxtON0mn0tw0fy}|A`{r9)l +zS!W&B`p%ivb=Gb|_WRlI^?9Fnk05kG#~~~AS4|UbH$O@)SeZ%w{*p-DC9B~JFXSxw +zGxb+mkNU0W{hSbe_J`A-$1BAZI@Vnd>X{+=HyJepdT=Whruydkqc;i^1TdOrG3I(duO{&~+S3-v%w +zKzUQkdUHofNVM~rpEd{kHSqSf=8zkE+$t%!k*XfJ{%8zyrA=Vl)YA4BgWmWGXAR81_{)9u2rJxAh8mIL@$rmol~JhO_0w%;0Eeukf|XF>J5FKf@xzF)ldR +zcJK##c5aTva7m$ga=;5KQI>h_I74lA!PdeX8aH$E>T&uvS6kf*igw=b>-M?rV7A@- +zkAkAvhr2qRu(W72BCIh_B${f~!0|F3$00bZa +z0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_0D)Itz}sy6Xk#wG*TVvfrLTNx +zPyh%(00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*yz+Anz9m<#Y) +zFXKNN91ws21Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SLVE0uu&W +zJ{!pexXtFhv*DF54hjGP2tWV=5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_< +z0uX>eee|f;jmZG-voeP@;D7)GAOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z +z1Rwwb2teSK7w|S4KiZfJ@b$33V(BYi8WaEm5P$##AOHafKmY;|fB*y_009U<00Izz +z00bZa0SG_<0uX=z1Rwx`gZ2yFHs%7n*30;h1_uNn009U<00Izz00bZa0SG_<0uX=z +z1Rwwb2tWV=5P$##AOHafKmY=-yugHkmd{3V0dBK-?`(MGi-Q6{00Izz00bZa0SG_< +z0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_P#-<&bz?HX`>f1i4LBeG0SG_<0uX=z +z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009U<00IzrRI2J+v-mU5j=5LH_&chsWoJzj-Y1+ow-g +z_bxsWa^j42U)Sn|Z;iZO0RMmh1Rwwb2tWV=5P$##AOHafKmY;|_#YRLtda8E7ECqs +zR@of7wK{O2Zsl6(+=rX_p7rU6KDDg#TK1n^QOBjO=MK9M?_Rih<(3~R!hgD1db0dj +zkuo;1_GU&^bXjif#fOrGE7Sb@hxcWc7Dnz{`z-|9b7U&+J-Hrkz}IH!^GO-R~Nk;=}A~*U$LGEN|HQGgdtQ>Ljf3Y82rj?{AlA%eLXC&So+H6X`lcQfB*y_009U<00Izz00bZa +z0SG_<0uX=z1Rwwb2tWV=5P$##AOHaf9JF8X_DF(4FXKNN91ws21Rwwb2tWV=5P$## +zAOHafKmY;|fB*y_009U<00Izz00bZa0SLVE0uu&WJ{!pexXtFhv*DF54hjGP2tWV= +z5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX>eee|f;jmZG-voeP@;D7)G +zAOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2teSK7w|S4KiZfJ@b$33 +zV(BYi8WaEm5P$##AOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwx`gZ2yF +zHs%7n*30;h1_uNn009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY=- +zyugHkmd{3V0dBK-?`(MGi-Q6{00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHaf +zKmY;|fB*y_P#-<&bz?HX`>f1i4LBeG0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;| +zfB*y_009U<00Izrm;v+<*ixd2}e3oMqt +z@})rmAOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5IAVR;B8|r +zz-zsX|7dVP00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_@X8BJ +z7-;!yBp2W|oA=I!SH3tX00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_ +z009U<00Q+_mrr}`wYSG?`Ip}3&>L(1+%oH7%l5ZM(gW}h2tWV=5P$##AOHafKmY;| +z_&+1?v**IUHNI}VozMKVEct(!-72&HGk1p@fdB*`009U<00Izz00bZa0SG_<0ucB= +zFYsf1^r(^e()+B;VGYtHAOHafKmY;|fB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb +z2tWV=5P0PUyv@dsHfAh*JuI+T`pTCE1%LnqAOHafKmY;|fB*y_009U<00Izz00bZa +z0SG_<0uX=z1Rwwb2teSV{erhg-d@nl_>Tq$1Rwwb2tWV=5P$##AOHafKmY;|fB*y_ +z009U<00Izz00bZa0SG_<0;8D0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;| +zfB*y_009U<00Iy=XusfXV=lmJy^Q~8a6kY85P$##AOHafKmY;|fB*y_009U<00Izz +z00bZa0SG_<0uX=z1R(Ir3rrYj`D`Q?;5M80&W2aMI4A%FAOHafKmY;|fB*y_009U< +z00Izz00bZa0SG_<0uX=z1Rwwb2tWV=_0gkVHzotT&&nLufCB;$fB*y_009U<00Izz +z00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOL|^UclRI{Agn?z}Le9i>0r8X;1(NKmY;| +zfB*y_009U<00Izz00bZa0SG_<0uX=z1Rwwb2tWV=5P$##4%#nx+n5XRS})^28XORS +z00bZa0SG_<0uX=z1Rwwb2tWV=5P$##AOHafKmY;|fB*y_009WR@&XeE3}XkCHySmi +zx|p|@{dw(-zkTqx5B~l3inV_}_5J4;|Ni$cwaeH2{ezRs(*FEKhtmi8wa5Sc_5||p +zm;G52o>ijx?Ogc1$hrhKA5maHU&L8A*}ef)gRa#^wt221kFV0SjT*@_z&{`W0SG_< +z0uX=z1Rwwb2tWV=|JwpB?Cbic?Al8YMis@+uz4!3z8F<7#5YuIHw3Er@o57*wtx1x +zBF_!!8!Fe$WIlFD-`~UVX0n>Ok{UKs%^2dEHnP^+oov2mC*NeQ?w*~zThp1jS~QOz +zd~1AJcht3-H~I}ecQ@!2hSYacyQ@`o=Y28@G?$xC3 +zZF=w-wubzlVom-J`)=-^#WFg@$b0%;NOGNL*B(w=`J*p*VI$$GTQ0y^Mcz +zxTn5DmF)41(I>lna_Q+Ad*S8b7t>0%{aq0JY4yw$Hrau7KddP5-t(oO<(+uTBl|1b +zB@f&AzFl1u8vbBHJ#?RLZ +zukWl}HS^x{%hQH(qK^ek)>ll@lQ@h-b#`@l$3IJ-fAy1x1DoT(emG59T+sb>YvlId +z@0?kf!j$>sx7&vOW@%f&eRAe^1{*CaVpIRgej<`~yPkjgId^B0i&c`2yVC+X`tGUp +zwEP<#*yDoIqU~~R+M?f!B`L0wY`pn~-a}aXC07KYznT~HS>o%7GnhJogDQE;NWp|# +z)z%@s_eR-S8h(ClGRK!yC29NO@Yq?xx@C^sCtW|)ib@`xUK(rXe=$Yle08L#;<;M! +zq=zka9eTmkpQf?nZ;ntan%ntp9lU_7`OnC`x|MN?`4KxTxod)|cFFS;-)N_j +zz9IiP3D)e{zo)QA9oR#Xh)=IqXvYR|k9c*RKDW$MENbZ8&3#vrTP3;sdg@;~)`#Bd +zniIzUZRB}Mj#n{zo=6U5@^^pDJ$S{X8>dwHtwk3~GZ +z@lWv)L(yb?ykdRirf9>7LwC97akoxC*IRw1C&jv&e$GQ9wVJ8QoEPXyZzrZoQtQ~* +zWb>lSR&|p5V7R+RddpRnJ}{KFh~DCNLG1HAWiK8v`pEbr&HUfVD%$zk!SW&}m#C=g +zN1j#ir{8Iph^r*ao`|};qc+js5!4nk_X-aDntsV9NNxCJqy;cGN<)X&(78+TqA4G6 +zl~6NVYi8M7XP+yae4e|OLGF9d!?DghGJ(Spd8<|GyH_={!hDPMP+S(YxI9pOw2jGfyORTy<>PiYE~l6>TdkQy +zf7Nlmm%t><^Hy8i82;th7`LhKKc*5@7cx8k!R&u{QpXuFqm%}>;PS1p@10BI9&TJt +zcd~Hx6n<;X%>7)usjAbj?~dznnJ=y5%2G}`rwvK-y$6CFJL!`-Y`MRkv-Ub&xq8#73-dyE9;Q +zE^-;Qw4JXFu@(>9+0OSoPkSL}Qj0trSM9ncUqYK1`!}VYO}Q84d)Huf$yBEGS-Lj$ +zht4hwduGvRuK2Z(nPu@peSdyxJJ;%KNGYGCBtP6Q7dX?dxrTiC1~0i|zh*zz?wLbX +zOtt#U^%eZ!E3{?`ebpj$-4``sCF+|SXn_>Jwew#nJ(E3kH`;g69*bR>!rsbpO7`zx +z@5KF4MN>O}U;IbXO3{@puEGhu<@_KvG`rgn$khVYjWj52Url+^9y-eL8`~w9mdhqj +zXnashDtfDwO*hOWxBVfELM^)Fl(uejUJ*L`zJ>N+{%D!p%hdAqn^ksh{;pnhe@tHF5gP;aL9qZTQp^0%ZWE7 +z#qV>qz?#&8<)u-3yS(K4X_s-3l%?UiTbB9rRQl76lk|4`7YGN2b6us!X|wguQt_2V +zdZ+%vqi1Jwf3tD2-opM$%f-FoBvZYxo}+b+%$8P6;LS{-AM{W#1ue38U1ii#t``#Q +zmh+Pr_utiOij-Uha3U2TZhTx--igguE~Z> +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 +z7bOL`iMp(4=RJnhvzK@%N`aFd>m}1t^ +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 +z&ME9qjn9(uE~w~CgLO|~S{=ia13_r +zw#TJnBx>kYr(z8Y@@t2k2TUt9V;Ivvym?^|yQ!A$cWCm@u?<39V7ZHVDBb6iRFOOa +zhqvx!9k^}kFys1%$`3}~Q--+H)FOt&G4~Jk7x%}P(x$8<;c9>9ynq^U5!dAz&;MwT +zjc>D_oJX^FRX!ww6fS+se6glyh?~Z-?~x~?Q51Ytov5Le%s|Q#a9#h)N6F7k;j6JD +zWm%TkA&~^1r{fN9CwVxkOY?24`srFFnxy>*)hip1jg`^*D0Y`Jp7*bM7Sz;4zQRSAi+XwXjVAz^j5&vbblX;{lWS2GefJCk?wW^S_Q +z123{JxD#^CY$RQ_jHHN`Je(*#!(5;vHqV#j+a2O<&S6Q?Wgg)%BR|zZ|j0g{yAHFy_66p`075npHHlTSaof?;W;o +zJaFez`Z?0429#Xf8k1;FdW@RDjH4rmFEk{GaD7aCe37#CD4j1bKaqH6CU2H%$&fo; +z!jM!;ovX^ec~@oeAG(YsBnHOp4FBSA9A9M$N2&0KfExkdnkz~J$>z%G7+w5>QtzIP0GJYbz*w=8)l#ZBbEY3L9M&Xw<;h%p`YbfWf +z?kbJwPn2`*l$}NbHy&(FNzbKkxL;w{rZ9&Sqyqb()I;>z>=gFwlfr@eHInS3PhIWW +z+ZY$NhdkUiS@Dj+G-vh8^f6ZAv5b9#T$W`P@94WZk%sijV+|9!r&Q%SCEw-#By)ju +zFF(~}dj=^y?78(8`*(6oV{dcbs!MV@_nB^?_Yj>6^}J(IPMgnkV+yU|zS1wUpoeCm +zvc@M{ClK&+9{kNT60SdDsPH?YbP13;1*!YuUS{j^x2uH_O`*2xOi2uVTn%A{jQ)WV +z**r!!W-=YwrKC}M=KdIR*lMhjPEC@1)x0H{(%8T;Q)y~gs+*KqwYb8hmpV^dnO +z8+o<`3bosuJlb_I_ef9V64&(LMXYJdX+Qa#!d;Wpd$Zh@4)?}ARlAMF1^d!;S{n9j +zi#6nR{-Zeb#nei=npsKaWb3s9jT=OC&(HcQ*_kX!6U02rr5}5XbUOnFo}F%WRhwo+ +z?1g@vq-@cEaPgIV(>%?M{PepT^DEDq%eAHk{g7N0&EnnP()lOT(E6cLBibmRz31NJ +zKLiRZ$R{P|7F@nJ@$eW^NW_)wi3AUCz2D9R(C|IL^K*Fh!bMNxrM)r#rV@ +zl#A);qauS!8RIZu7eP9Mmz%AOg7nmphURgV0d!E|k?yzFQ{|^fqaPEH1$M}TV#bXX +zbuE&uxVskz!$E(cz9#nX&RYGc2h~3uIkH12`4Rd;GQiRi`Y5dH_9x! +z7n)AviSnY@kk!doyOL*_vfm_EO4*(+LHR5X^}py?%96u)b$pxbM{RQYcwNca!q)9^ +zD~J4y3)T5ib7vW2PE1l26PY(7Ze!Z;ooTc@e#Y|19erd=Xegf{`2+j!eP8ZtlWhv> +zO2{3Fb#FXz%<~xhflfCBLUQxlY6g34O}WepvP^ED`fgbBdI24;84@0l%Az8=)+?ve +zC=ZX!OCrK6pJcsfPZNM`Ni`5_oX_?>q?ydDBguNp8Tx6!BHsBVwd7CM7r8d>>&@wk +zAz94a{s*7z=}pmBKXu4+rrRtQBpFZIG4$)n6NVq?T%Nf~iqrUw^Tu7aU2o9J!Df)1 +zBk{@u`*w=xc_G%8j53!iPp+DlPDd1Ds^#!K=b*4o{U=m1M5$B7&y4cD`3p@zW6j8( +zo=_NC*y9sRpAI=5{*A|!{@>J<%n}lLmP)PJ3@tf_Bg`y(bY^3tz;xV<&1q)&VUHgS +z<&6X$N2V!^g+4yd*EXyBOTSdw$up!=eDd9{Ck;zzT8Y!DdELoTA@&|uWe<&`sCmb! +zD#E3H?-5{Y0Fk_PCy}{Pj)sAvg%LyS<(27gN +zITu>J=_p9DESav#_ +zvPi!dO~7>FKxlEYTw<2rPr>+itt;r|0sTFc^L?go6OOtF$Xtp<=HOXibrLCdi +z1Jy3IXq~w3Uzc=@oq+3^T*--Td;N(&DJ?c%qEAsXM=R{!qww>0-&jSP9XYIKCvV#Q +z=t8!t^dtJw40FBf;xz$lhl(c7qA|hRBZgI%r0x%tcS`Bxj+|gqU$plU6#ZDrRY6gJ +zS~L{Yb#oN|z_TE3C?k26{G8{hhiwh@bm1YJr;Tq2e_&xb<2l{o(Aa20g!d!vQY^}4qxUaF5f8eV#wCf~c +zOF_YN3!z4P^&sud`6Ro4M$+)TLjMX{&z6%Y>i3nZYYnOi-0&hGsT8ZjyX8Z%BbyX2 +z508_ilo+dcSJOjq7kvR9VvIg1N4nb~SZlk*;zIEeF1&9MK7Vdl9ar9R5} +zELBvJ#I%yoyJKB;ScjT+{CM7Ef!QrGJ5d91_9Fx#egzkTiUriwPM|iFIejE%B|sOyeN@TV#G+A-8gxRlkaRTDD{* +zSeSPwJwZ0h^Aq|P$+Mnh6Hr_F5XB9^b_9Cs1vekc#X_xLOS>{J4D=zi)n@$e3l5256^59N6UpS5S +z@OGpQszv!(^IPAbUI&BN;{H7cABjBa!AKF=;}c0A2J|J+1-&FUh&|aDpqs^%=FvK& +z+CtKzn)}3}EAkH0P?^zhVAtAq-}hsy=|y%%3fpoz#$|KJvODAHEMAgW#jKZ!tnveD +zOuPRfB*>a*E#GSh($Nlr9IR@)VIQ0xqUp5cq6v%{$!jtUtbUR_g(jXFXZ9DPL$cKk +zrXV0Wj}Q?VaWReek9s#cX%P6Slh+T3SJXyzn&#`G+)_45l^QbH>-;&|!%LdUL7N-f +zivpTejh^&%AdEGM%ba!zR_^;HrO31Zwm4#lEG#W*On*yCJCYJ|@6UFeO5E&9$3O*1 +zTQob_Sh8*Km%CigBq3ROi*5Zh?j-)nb$7OID%QH|DmgOQ&$UrTKxU{xd74bkjk)2b +ziAZ9sA+{o_ux*fMXPPcWkvb3_o4zjXmuAz0c#qupm`Y8jSP|~R1&SDkY-Hz(o5Gi; +zoDZkr39`#qb6(Nh^@p+6j8u$L$Bmx*x_IHVPA(;r>z_3)7JnFOg(ULc_R)sK-p{Ag +zdX`A4MWX+}u0^_BU#`&16>_mKDI>m^{dozk7Hlxt$(|$JAnM=x7VXaY2@O+}Yx#W=2E^B=SeI-ZZS37=nRIu$-wYxaE3UPa!-DRjoIG8RVn +zT=uvjPe*&yA~M%{@SXlyQ$IbJ#|wyL^?@N>0?oJd5I-xg(6-AG-FNK4&h|}RPozo`|V{_^dXQarC#GwIAzWD#$;dW7*6tLk7n*|X^EW9GsQ#6 +z5$KP$j&Ir@5l$r~{W?K>etJ#EzvNsO&wfn0_+5?B8`YcLY5qB%%#2f>O?@z!y_B1} +zu}jI~Xy8zEs&fF%KjsD?Idv0UuOEN;=i?@{PhlO#+xhA}x%&Nw?EZk9R +z6E}4xH+m$Kj2@lJ?ovmR={RyK2?e?59?G5WLeJbtNy2RL+U|PyzW3(S`S^O0&|Z2r +z==tSZ(+=yr6!yDyvMH`n>*+~;mK?^fI5&0*KT4TaeuqAmwj+ibB@-5LF(IDB(tkhy +z*+E{mG}FPx{6LebpI{D=LZ7O1uCLdYI8end1T>#ICgK{mJ2kVZmDN=}Sm;6h<)BCktx0&#{Lc*nYvvotw7@(T;*&K|o1{^ZbmpY*>CxdQ?Owyv8ic{vGo? +zn6Iq4T4p@hks2C5xAE*g`rar;PB!VjGq0SO$M(|QJV`zAX>qKy>)%Nimx@odny|s{ +z_pAzRR*~<* +zURkn~&d4hWY`Us3{lQV^{F7A?Lv4SbtXGhCl%(6{yJ$vP(@3XklY%|)te`D(VQ2_f +zJk~f5oY0umcuk)ZNMZL8*w_1{NpjtM`a!aZ-S>lqG$T-D%-j9T%t)`1X}^x#(T6d4 +zUcCqIgwi@X%J^VP1LQ5W0kj1lBr$MBtQ}K**K}q+hJ4v0uk^=WQHGR0KpqJiyC@$0 +z^34QQ$!A=}HBN`hgpxf^USCC@;0&^RB;EbsQrVsD^qMbui<;Uaar?v)+PCuOYh95`{05rQ&G?ez9rubR +zR-OwirIQl&Hs`S=UsReiA>VQnRhFcXE{Y7>m2vnMUEBs4_ZWD!-iC1#Y0VX7 +zDOk&z;hgay#j>Szip6Xt2Q~sLj#f5(Gk&Br15TC}l?&+tUL+>5(@1GWYLwd1 +zk-Kr0oO6<$4qD`*+uqPhpKUmKwvkIz^Y+J>g7Ri$(Xy%0YQ8L+R&!fY+3GW^PkEX% +zdk)glRFM^G_|QG826-r*i?esgX3Ynp{Q>*R?r^n*^&!9VhAill0-r!1?taMr^6-;W +z(S>yp+5*$Dy@^T{E7cVEKD}U7M5hn}^12q*eQ#~Au(6|E!M;p)A-R=0M*K)_?q85$ +zN=#WrQe$G08X|r3Y>V!gJ}W0%izmFgyt;n)W|3CIynIt4OWtX+Q>N@Z-!>&Bg<&VY +z+yZbWci8)860S{=w +zNQNa-EtP9C2cLavsaO22$XJl%g)WUG?aq4&HA#y4{S`YB^2UNaS#iP{Y1;po3ic)$ +zA*MGsil0?w1<^O`2z}J5`}rM}ebNJ|^avk0fhQT(=IA?viuF5aMIx`UtoqMHU93v> +zPpNGlJ=wIWOx)aV3G4oN#0k$ZR)E0 +z)ru=l(RS`9!$bdbgeIJ&ldTgrH{`d6I{Kne0eRur(7&w?)h$e?5pqR&yW--iJns~b +zs3mkd>PjMOh27EK6SBi-Kv4Fn*0w-*&n~rTGwq;^Adr=SYr**ZC!? +z%omr?3=w0d<-W?mGTWKt1TvTKPhytVnzmCRA%kIMd$?~4D%ur+@txC7$0zL; +zYN?BxT6I8mn9e=OA}nxOMfj!p^)6g(F&=uG7%(@-y~0*SLs&sa3|*q|prdt4GUz!^-6x25WC~qLS3P#eaE6w*g&ewUsnE?>srp0aCfP5{ +znjFX^U$mh&bDn&gxn`ahAa~TzWlPx+L*fjV13v~md?$qt;*T8IwK}=>=L;pPX;`eE +z#6|zTmACu;k2JGTM7EhG21M)`emIxj^*iJ>IQx4}|vNGPuI<7c6yn`mn@tesz +zAO{DJ)ujfRj$x8`Wm0yDrs|9M?lc;NalX>b6l8R49j7hryG+{`zp7m^_-)RU^0-3% +zY`Vc^%(B!DPb_y0%RWX&f8lNtrMgr5?wHb{#sl2F8;^tS9t{5Fkmwv;kQ(1Ul^D~EPQ=flnp(}FDB=e{14gZ(qpwrVm&fOt +z%sKP=2R=XS?S1^VkDY1Gb-%82o$I>Jbod)+yy?!? +z)+4s0Q+0P(zoht6E|_B))J1zG;YD`~60v+hJrADUMgD(N`gBU8vvtMk$TDa>Vaua@DeXL;BYjIX_ +z30^^p3&5r_JMNuK<>Km*zIyk%)b7svAN*=D*)AwD%&Kr+@7er4%3HTVC@by{-P(Ma +zw#5^8CQS7l-H`n2$EKLvMy=_#P?KL0F|>_uQjQa5XsA4GVY$L9BKsuPsk&WZx%i%M +zh4`)$irwgR2cJzF +z$rVrU>*Bf}?Am2jtH!<1Ro!iI50Mp=%MR#lCU7imvISZhCR%)j| +z5W00N5{**F!{;x>HdM-=sqfotEm1;KcW63wU*xuB@%vb7TwJ1)z%nfcf+O14^gQiO +zySkOKKD(ksX(+sc_m*HEu$+HsNB5=B>DUhA;f9>8?*^my0HXYXFMz#rtKQz?hc>1BN{CgMMMAN+&BF#mGxCC1f6CJG+Rpv^m=KTAY+?ep;6WCv>&w~d&uk{l&DfewhMn?Su +ziJp;3WVu6y9?~K87d-3o3-M4TyWj=I1uQw#Jh-@Zk_nAFsQsYUc3N0z;d`|ZfB7O* +zWg~C(9M)~bu~ji#)i>x_C>u@;uiS!iM0G!<)6liBPEiPsB}7}{pe*E~qF3eGCatv~ +zqH$W!wPU$O*iYX82dty$j2crf#%5swNtI>D@Zr@H1lXjw&^8mcPOO`9YN$=yoY)L` +z4Y!|{$vxSJx9Dhf!K6KgRX=UF_8_`?IHorok4!7THv-btP)+FH;FxF}5`dE;)-Jd@ +ztf$_gMKlE`vQo2Qdu2xBTeD6c1|d@?%dkZkn;YqdYg^LdG-mnp9G-`?_W%kBS=*H= +zzqT0mu7F_e{v7j1ztTuQwP45Uf<(Tyl06nQ<9qJ?uBczXY0y56flIKaFO$}-R@!Sf +zLDKoQ2W`7VPNr(iGusP1=wmAF9?hGrcS>i14ks +zJkbC2fx&H0PvmGX-?UNdCRiS8Esw*6IUdADW`>H6lQ)XAm%s6VMxli&NAJE~xb}c! +zHF*D)_nnRfCQ{8tgNiCXpqdz`vXz8*x~8gPaB5u*lBY@D_rHE9x_~pLiBM5WK^(V&BcrmhvZmh>?g^`hk +z*g;ZjqqxZ7k +zl23Ct;Q&zxpR5Sp^z?p$)oeT|`S8I|L3ru>Udea(s6rM{RlZ+SIw{87vTW +z*jXt{k}y6Yv_6-Mc`nD_EmpFvRntG55@EyX@C?=2d0vK(agdM%#n#IuJ9Ca^ZNl@- +zWHZdSj=YW<*Pa)fkdI-00yaPRosd5DC^^#3qcgV;F&#_|GYalphTZb17P~tSbA9nm +z9v&_<)&Fu~Q(sEo+XlS;Ff-wgbg+F2w))~~A9D#@yey&Er(pPVq-*9dJZsQ*+}zWY +z)P!TRWze=)f9{Iwja0)tyi>p_v|^S@a=T{LFT;oMgs_mj%JSh1J^l=-mP!M4JDzy9 +z_5H2hq9jzN?giT$Q`@|?ExrQ#?f<|K^Bo=D?G~L@7u}i$;SRr((0Xk0uDq=$yK^r1 +za?>|=4v#c5jDzo=5IoBlH`}7MfcYA}FO@#sb^pA!)2$Omp2&6=>(TR?@ZD`DMUl*T +z>*O^7d#7C~Kv52Lql|jnpS`iTwi^!}s>+Mm;Ykm(6wdg|G#oK?3@@;aj@2I2SGQF@ +z|E7GPEFWfr{hNFyZ)A{uFhebyLyPa;uxfR{bt;pBNJbVteQt5uaIG&^vJbdvQABRf +znOntpf~p%UE9qUbP|o5-_Mr)qefJN(_d)Tj*(2R?lE8$%iSH_*+XtDi%8vgxJ&}tg`uB7q(fXopmdB!k+gY%!| +zJdXExt4U*6Q<9SK_<21YoYi +zk{-{QUb=(4qg2d??r8yN!!zf+{PD23PJIwhvAoiGq}o~yx^ti?{!f#dwA)+uFr=wE +zId0Ocsn~F)!q{uQwzw{ +z#wZNRb%1D?#_o-*+^O@z +zd9NR|lhvIaW$mi6&__7&PHO>@VR8a1}AynZv43@ +z$UH1Y>3Vj-sXbCU}FCNdQ-2 +zWk2nbcT5?YF(ai+_xX8E@Ba|!U^5zNu*?mAeY{Gy5w8q1{IR@X8IGEX;zuC)re2+82n=gE8eGPm^Q4vAIXv3$5GJg>p~7 +zyg@qjFriO{rV3DUw>xDKE$T0UJ_V^BZcUwhZU6no+UfnoB`d+_r;%O_>wDQ*e={-HMnASY~!QbMl1!W$(aku4p(k4Nk;Czxd>{ +zS2-upaA@d7A9#LOys=cJ4TI>ShjgvGU#e-JBmk567|!IHw1i4t85!e5W)!>xrgd(R +zTUO(%R2;x{PKJwNEqkv_@(RVvYn1w4*dVW#cHv4iXBl<9GEB-<^|@C1{-4|YKZjSI +zjL8uSoVcg7XIjdv8J&4HZVQ+LT8E*oSh@;JF8Zbvo8ZJ1?y@wPFu!g`b5N8CE{wz& +zD6_1Fe@r>dW#KK(`M{v +zp<~LDIWv=bhx?NZAPMhs&5ww3ZLPqkWLdChQUBXk`RbVQ(4p%=@8}xYBjmwaw7gt; +z%kJ0N+Ad-qY!SY7W{$nluPxh*jof_ku#omq&NLHrYA@sA!QtD`zIQHk`5TjGAuJS@~S0gH;aq%v>mMyJW^cg$J*G_s%7wAn)O7oLfT+ +zh3aW1??{1h1#YXchlXP-|7RURI&bh-4Io}mZON`XSEqxMC?j|llpXq0)HtI+ZJ8nq +z2(=8TCMD$g;1JqgEy?ds5))&jxJ4}mK6l@@Ipq1oSOM0d`jA!y;~|dk^}|W(NUAXC +zoutEGj6IhJ+)9ufRW@I)jKO<(bT$+d3yZwc*Wk*9x?V|t!z%N9d#wwbcruhgJyKh8 +z@9xspz+S@k~;8R@&&46}4W|-UzC$R~AflGtaxj)+W5YP$68-guC9d<>N$1f3h;CrN6#k +z>H8L++%vgs#r&<o})$9o{!$Zo$r}U8Tfy@K3zU +z4~M|v^rcC~F85evAP&Pho_&JG0AA(v<$}u9`1{mYxCF&QBqVA>F6ybbODSYTdH$z_st=sV5naXRnJ^G +zX25gZI(+#7ynTmxZe=vyncH!FpLUN;aH*0});dKw>%PrFv1U2=uwUNp=~U$RYd6!l +z#h^P!c~PiI9_^qVRXvPK;1*X#w*+t?9O=#6(3LE6otjfi|2P+fs914OBTYcFT_kdpZL2MD7aEf$z+S1E4 +ziFFd}sw?0<3sSlF>+}0k@wX>H!8H5+#aZs!*A=wFBd*xO)-9O&`-s9q^UfFRPPxc& +zUS&Z;4?f^S^ZJz>y2Zcow$uPms}yKI=dSP!F3mL;&4hR&+Y#Q}A)l%=XneXLTw&O# +z?X-ofEk*Xp!Q6~tZL3TqOiKM?gNK5lXXRMxc@VanOZ;`WGWi<*{w|;_1d?Gsq5J61c{5x +z%R{@TUko~b_fVy3uxNO2RB^3?R=-up8!plCD_)m!o>z)bjEHTWDFTEFQFFSuy2r%HYt +z+U~B+8~zIpBQ&FWAUm?@1`c2uLwIUxTb1V(dIMaqZ(v_^`PSVWqwkw(UOW`E9A16ix27kzoQe@NOlgeaK6g&QYz(rpC))&y5R;` +z9`rWL`|T2J?kD3*I$01*3@MV0?&iM3wF6e6N~J7sOR%J}an!(q@0RzpZfKCaf0F>+ +zAks~3jDxb;MaWE3wI1Im-}0eK{GqUUK}?;T5aIc2+biV3m_40x+9I_tP#(ac@GTDZ +za5&@*Q(ae62Cs +z(xt-VhU>vHb~M`gH4n~4z}fY~Drt@G$%Pdy2j46@Mh~14tKahD#K;+!hT5I=N_-9h +z8ZZ^Y*D+~))8ARz9Q_m|XT2W63l>{%^`cmdDgzJSY9(Gfom>zJ&SBOli-O% +zbNzT#hl$8%Z`5AaeY{*3T#&JRotB6FRJ;j&mn!O4-B=mr=DFf`7p*LCCux1}1WuY& +zq{J4al~!l?RjT0HVO!4=GxiwoBGab1G8|rCvN$PH1qN9ECNR3~^R +zQCxWLqnI#^@m7PBV=XKwp!z5CA3&#syf|K`8jbm9-M +zIkYT(a!OI=@?CZhGk;1s-|&^^f7kDyadTt*db==*{9TaLS=Q9*)fF@lW94Pp+14ea_#^C5PMTu!CeZr^^;Xx+8yxkq1a9^|x3_)iYhMb?FFKu@+QjAn9| +z7wig|Gk0+F%=Od8F*VJ-98U4@viIpvOlP;SYe&8*-c3`#vj;;4j_yRCaam&I? +zia$kzm?V+g
gGgl(@MzeBO9d>^~C5EYLIPFITN&=Ia*?>`s3qWqtTjju>_gID!9L8vZf*g$a@&!C=eNu*|~D{XB=S +zZ{@!ix+_eJYoSL2wb +zIO=(7WRg+GrVRAA#3~i%(4}RiLLSFjLrC;O!V=tA_CJTVbDHr>{e{%%n~Gx(ugud7 +zi~3lmOpm-TIKXX|k6R<-6^!Uj27szWW&VLbf0ZacEoGG*4oL%Q4w(RGX +z)a99rxn3_baxidqdn9vvHaEBGNJl9W!KPUm;QykqL>h%qQXLY$VsGO(fl53T*~Y>) +zDd)`l(DvSljT!@@_sHyXr<-3|VYF5wl)hSoxZ5d@XE0;%cs0}Zcx~$g>g}Kwh9-1Jzxuqh3r%{8+O9}s_qoke5KZJxb0gXE6NDqb{M7GS_ +zw`A()o}E$PG#XhXvs=V|>-aK_l6^B;!;DJmy4TBD$7yX^?5~q3;a}S)yZrO6?-a2M +zRi#q9O4ic;Hb1aVOj$-K>KQlk589V(|8*BHRE5VQ7JVOe} +zn8M^nJFNL#|CGrQjm%tkh1bTVo4zi2ydH_OD2@tGAD#E6)%9GTXvPQosad3oPIXQi +z?-TN1l7=bgNH=fVz`5Ud++M8tCdI8{yzgaYC~VA;Wy^k3jB?a5PF>CxApbyv6FIvh +zDevz~N6<+B!)2yzd8Jn_U?Ic)sfu}UD{s5u_QcbgfeLQ6u%oHOPfeDtLIX(dwx2^6 +zd#_t(fNk1wtD?o=r^MLvs*>-pfu+S!zhsq3mdz_lT&dB%<90=FjGMo%&Y^!EDceR| +z8D&<*{%%L9&2UqFb|CY?J#bRXDZM0PsVQ@IEE?<>7=ENnWPMpQ!fLV`&Ka7{Es=QH +zAbb0o%WUb(nVj11G8$Q>Z5;K?uh{riYs;@lfP`+@d^&%<_c}`~K;t&W#E3DQA~(*< +z`VtG^7Dui7%O>%?p0RN{9$HE_Zz?pW2MZ0+I9lVV+CHbWuGab1=oeyO{Os=LsVV3; +znMGVC{BnV3e9%NRnLGVq_}}E*lKOm)zQ*eo-iyp1F4#bCM8q0B6iUj%HKM-I9ODuF +z(QV(qdCQH$b1U$KG+3mX6!9OPTyboYV8}8(F;2HxJJ3*I%dcA$BElBh_2m%6u2(1|v%4;&d~!4adf!DQOPgNFX}b +zQCa*ovLDkb_R^+$<5!P$3)gD?()}q+Uo|JBLzHZrAs0K_n5b7Bid`kDc3;yq$mWNf +zMrcL*yE*k2^JN9+cNMNHqfU+Zd%rt_UHjisHOZ +z4R76me8!PD%FQ};Rw_6A+2jm)wbRIoK0__RQ@cl%ENlGi*Jim1J-@fVHg^qvRvSn2 +z!-_Kx33>7}SO?KzOvW{l9j|fuFK8f%@TjeI$GZDX$ccmZ^3XlxnO3LVV~X7A0-2)m +zaarX5jy9c4*Q}i7u=>q(>#^k<{DA&eR5!aUB4iw2HwRgtti6@GGrMuoF4-MDq=U~v +zf?iQkpk?V_8rhi%Rdlbw)a_8MADZl<*ly8=ylBd;`?}-W_m+IA+-6Aj3f_Y7mz34H +zY#;I)x#ff +z(iDX>aJ-yaQmp$Vd1IXB3H1@o>;7;5c_j%%I@t%2hokiJ5%$8PXz+FtRmkE?_Y0aP +zAX~gqLNl8s8Aa}gIlH1Xu9kJPf?3b}(o|sPh~Vh%P*{%AFOK!yv=4iwm6Ms0Yx@M^ +z(X3rDns4f=SMA8*(AT$@A*ZwwqOKENp484GY!pl_sA79Hozsb2J-Q1`^BXX!b8@CH +ziO5H>CVPK5Rh#>1Aba7TX!P@{*zFGurhAC;kZrQ}%jL4|wqsh1_g?-6k@%L&JQn`< +zvz%o-%@g*qZu_?jGU^I4sZa1EXCLn78Z?*m{{8&&uQ>XlVR4@nksC1Z=R-99boKaW +z1-)5O9gBWod>gAQm)mIRB@FsOv!3ueVCOz>V{s_w+rXdDGnnQ9`7K}axMwtYC~(Jy +zMW5|0RbDYz6Rv2Qt*2VoETX=XF9=?rZ*ne>SrMzVNgZ6WgrEUwf<)pFj-4%gU$@}t +z)}6ekc7B02XiigKxA7O;E)ZAv-mzSZTowQ3AUnnXg2$6TD>ve2_Xc@RWi#4edz&Ns +zp!UdwnP>j`qi`%*39?`zODY#V86HAQI{ +z#Cc7&r>*!lDC88v;!tpU)UhKDS?JGK4|=d?n?LAkxbrcZVw+*2FA`0N+Z%$6hO&a; +zwX<2~${mJUXXtgkT +zCE<^?zdq476HQNA*uwVZPv{SMb_`EXTNuP!YaQG3f!x{n;iqv-LnCLZ(%WzzD_pFcs<>L@4xZelPF=%0qf?0{6^ +zx1Rsfiz)PEQnRwRKzQ4ZJt^*c&BPG2LrF`S^Nn$9^N$)9^x-h(mXA++t;lOV0!x|6 +z6pjfq(>*sWH#me=HfE|s?&!L|RY%5N{u%o63Ayr{m%L)$z)9qj`8SoSg{D4%SD!Q@ +zrLfy8nUn{?_ZqlT9!j!|U}1>x_lXl9+&EXMdhsEpT@H)*jn(dLk7Cxok?DSje>apc +z3_oc>-uqv+Yd;tY9~9YEOblVF_aH->0KR$>9b%Nz7q0!FwM0(aWm=D}oc4W&i2Wg+ +z5Z#Pm&c{jzFYnb&MpSEt^&~Q0@|}r`s)CWODfptNgXmDD)a~y- +zG-hMp5y=b|H=RA(Z)PaXq_pn^)-$5g`-z&1S9exfxRr@YLkGNq^{*Qol`oRbG| +z&P&}@s=C`BwkyKQkvAyzr>Tw2!-5Boq*@TgFxA^$Z1~KpS)q>&sHs%S3Ch-+KD6fU +zS2%;?Lh3%A{YAt;yb8Gv3y^QeO}h!xHk`oUkppY6Y~0S8;6TS}$Cm6uh& +zg|!kBW6U8is_aSxKJV@16Fe+~Uly$O(>JMqtcMAG> +zBy(<$r}f_KkI_)dOQp;biIr)|5etOc5VVx)x+9}l={pO#dXqNJQg7x$=qL~5iKK0n +zl$rbWcMb{8$i+y-l~my+)wIT$Lj`C-d($jpo+X+ZnQi|B{r!)t*j=yhmQIqP8DYRa)!UIADqd!9)NbzID14(1gsF0dZDRdxm!S2K*(X;y#9r%;xDud`))F3A-GPnHrylO`S)tJa +zVNN`iC1*AA3ZMQ1}s%Gm5ckxf42u`>g-VNY)Vsue5it`v#E;By$aTnF)MbEIN3U4^-)L5 +zsYsWLb6@%Dndoxr +zpbn>#HM|JfAC%l2>vCph{900?mm&Aqc$a;bnG3_{nYcRDU5#HXu7G-3HIhg$|zwjL)56 +zRyV`B{%@hQwKJkIlwA=fC~SPnYW8aBtSzqT-($jvLoSZg^h%q1O_n_!SD~wm>W?(k +zuc$ti@5}zfXi^jdpPa{MuKZ|2BhMjv)yi!45}w&-G7Etfg9mRaxt07wF5)WPEn?!m +zFMnGiuDAt0A=TV+gNoV>SN=Y)I`;0|WH2A!ks>0~o<^s3oewD2H7KBoFPGf}in0er08g?zI5ZO=uSLp(xUj%RZYYKcKN0 +zk^AUgXsnaw_EU##*%yz$%lA--`^pRE&}}hDMNoV^BhB(YVz{2KAxe+uGQULZ +zvTd+QGDoR;4RF8CDLQZudrx(pQFN@t%*V%GBNXLV#g?v$@p)0M>-!UU#*s=sC#{?H +zx9oS9;nHBNSmOmMo5KQ;VK6-!+|LKTCJR*8%&e8iw@8Ft8ZSbzB&uDZ{YHXe5prCP +zuw!93?or!v9b}m@$Roa}*xRl%fV`r*BDtYruXT7}Fe(m;c;(bFZr45L!bJRoiKTLn +znggy6Yb-G`>S#C5^5JjXhP(;okhOiV1}I&cv{V*Zv^Vd>0_6D1?DzdI>`{-GdKvm4 +zXM8y|cS!Y)BY9_tN=&v84D`Jg9_l}aTwYFq%zpFr)~gK}_(x@85Fpp|m|XHS7VC3N +z8-IC++d)U~X?VP5Qz*JUQU21(YZbP&c@mY=1~1C@ZhQn*u^0Trt5W3`<$CIf{lnNG +zzs(B|n$hNsgPxjZ<%WN}cJy_*kHwNU0?IXMW9{`*P8`xKL%Pr5RwWmmgM-Bxcx;Ak +zEW;%OYn^ixQTRtYO;y~n9fm#9^1~28x{Q>W9HB($`|!n0*+D!I*6kK{fqZ)R;Dtqr +zgM;ckd%|R9iPzm}@vHAF-~UM2+tnyMPOSuo^w*xpUIFG9xB=wEiS|csZMU?+!n;>d +z2W<-4N{fpOS0YJ82g<3tdCLr)zB_@88B(TCR(WjSD1h?f2aiXY!sgi8j#X=O#yOz{ +zYX*cefjz6%+}wg@s3YXlEK~b~<4v?b86Z(5PxqfYFOpe}eZaiQOiKL4h;bqm0A2bOc7XB<>tM^7Pwyxk=mJ{WX@+Z9a(L +zuZ;e?stw90AJ!(_?FvWPl%R!KF6xb?4?e-QRK~ZP95^TNNj=`T^Npk09j%gze|6ja +zsm8sEQoDs)f(HGs?#FTHRv3SJUE+{I1)6zb3shOc;4Sk)!y6}|`DqYGRfiem9VypV +z1C3;=f=BLou5%xu$|Czzw@l#D8ybG=F|PbU;r~&mhd|`B7_CCId7E_Ef;ZM1%{j<` +zptyeTz!cC*lKU}$e^XKDcD3` +z^F?MBmpN6sC!i`n@q^!H8mV6D4jYV0XGwqXaf6_7BcJT0RVhq0{I6>aROMbjv*R5V +ztBZxsx31IdHvanEtM}E(Ab#ZZ)z&zxHBDS^JUZx7dG$sc5It9~(XI +z&HGd12Us^PnMdx_>Gw;vqIDx`3Ulsg!V0d;7zOd{19D~K`&{D#>-@@hyWj%beKhU3twedoi)1qA=c$;x@72CKVc#g1T +ztSv-Z-mAki6(Y#{gMw_b+b2%Pex6mMROMV96x)g|=R_lC%2-O|oXC9{MtU4(1s?8Z +z$xu?Jqpf(DhgLa?-%Wj0^v^H9d*K3(Zi$qNf9spyrqp%Zh +zgAHN*$?O03W}vVKdw%xIO2*-iY_#y@ok^%(!h$8J;;jBQg&h3?b-jf>y=<`k@?5m_ +z%Ld;uM*qU(1};w*vHgvfX*>-@lrTM4ba=uO-(_X69&Jv${+w6&uT&tzN}oEpXzfRZlAt +zCmyy#wN86*cYp9WS6nL4raqGePV4mQ#Iv(p+|)(J5f8|QRewy!rta|ucy(a{tLVVy +zGw1VfbRy}6@W+x9b2@H{H{!U6ols7#zjQu2LT-lr9e<(fkVO`KyfWJW<#XRjRCjzG +zEoXEtLo%&WuNsm4_iFe!_F$IDlx>T=6j7EZ@p{9ImMN(31LMCExu~$R=-(CQMS}Hp +zS$B?2#Sar;o!;hq|A6Euj({ncweB}OJ9Ldv;f|eBPVLako<51D^)%{Yyde50s@U7G +ze>L(60h1|dswZ@q +z_yH?R@Vt^K?2FBG;|yVo;NJzgY_fLj$aIeX^W#D^q#49nMC&_5!n6S~~R7dL>$78zCx|TFtvsK7`^K +z0c^E!ZAVwzuza8@VmjkZa*w^cqApANY2NbF7{WbXmLNM=*xBEk!M-^3srmO(in^t@h&HxK^~n(W%|K$(3&lZ?&ah +z)XYSgQZRGn$}0)}92|%8Yb}{$ZbSWpEWKz{&*FkhRh;Y(b+cw8!$^fJkW<&Bdu21~ +z4x#k9%vbZ9U)*ks8$e#Y1wtwxmzdx9htSBvV2e*LfBFW4CFzfp8^qU4I~Y?Kg^Ei}dwnA?Akd|Lvo>T^Ve;;B%_H~Fda>Ab+ZG07kgG}mpm}>hkJ2vlT%<)>v +zu4-W?Jd^!A-4X4KFiT;T2y4C}t-<@O;5wc71J>8?>LMN6!|;!OVc9EdKzmN?J5ZID +z{PF(vxTG*Ne)~N%Gq?Xo!3CS%8>noYRVt$DtsWbxjvZ{vqa&F^TX=qI$_y(>9iAe{$5 +z#8Sk6(^=^MIr0V}5*ddMe`w+>&_ymoN2ZdqEh>`bO)nzRH$^2PD)GC|r*!Xpn}VK= +zgTLnK7kBU6gTrWG&L2>3n(#f?-$1zT_%8 +zm%C3KgXWhX6wrii>pphffie#ftP>CGTGM*>IwGyDfOzXupBTN=*Q?R^V<2ihqc}YW +zj(_0XiKWJ$8(M8q2*n~zHbN~@sj_0MtKq%kIyew1Z+Ko~H*xHn*HCbPftiYWCRprslOTKvP$;D35 +z`#-(7dEfNg{@Deq{+R7>a@CL5j|SUcs(mzRz*R;SRV&`qC}jC}8ecRB#EI02vhLL% +zk$;2$AwUQa0{?FiP`N4p{A%62;@-er?DFixb81X +z7vQ5F%IA}Ry);AsLVyq;1PB2_fDj-A2mwNX5Fi8y0YZQfAOr{jLVyq;1PB2_fDj-A +z2mwNX5Fi8y0YZQfm^ASG`;lIN+f3mX8wn3WfDj-A2mwNX5Fi8y0YZQfAOr{jLVyq; +z1PB2_fDj-A2mwNX5Fi8y0YZQfAOr{jLVytX*AsXWHR@w^Gr$a{(R%H_UK%0*AwUQa +z0)zk|KnM^5ga9Ex2oM5<03kpK5CVh%AwUQa0)zk|KnM^5ga9Ex2oM5<03kpKY}M8I +zMBNMUhk|491HnNE5CVh%AwUQa0)zk|KnM^5ga9Ex2oM5<03kpK5CVh%AwUQa0)zk| +zKnM^5ga9Ex2oM7QdIHgwOFvil0({g%`F!%Pmxc&H2oM5<03kpK5CVh%AwUQa0)zk| +zKnM^5ga9Ex2oM5<03kpK5CVh%AwUQa0)zk|KnM^5lLnrDKhg_un<@NaBjG^^5CVh% +zAwUQa0)zk|KnM^5ga9Ex2oM5<03kpK5CVh%AwUQa0)zk|KnM^5ga9Ex2oM7QdIC?P +zMt!Vq2AIJ#TCe@rOG5-81PB2_fDj-A2mwNX5Fi8y0YZQfAOr{jLVyq;1PB2_fDj-A +z2mwNX5Fi8y0YZQfAOr}3t-3m&sCxnaP;d->AUFsCLVyq;1PB2_fDj-A2mwNX5Fi8y +z0YZQfAOr{jLVyq;1PB2_fDj-A2mwNX5Fi8y0YczkPaxWI>F4TRfRB18pHKev(hva% +z0YZQfAOr{jLVyq;1PB2_fDj-A2mwNX5Fi8y0YZQfAOr{jLVyq;1PB2_fDj-A2mwMM +zap3u1>Q;d7A25x17e`(fp#D$tj}RaP2mwNX5Fi8y0YZQfAOr{jLVyq;1PB2_fDj-A +d2mwNX5Fi8y0Yc#a2Lf^bSyjKe8UFB${|}|d@C5(> + +literal 0 +HcmV?d00001 + +diff --git a/tests/f_multithread_ok/name b/tests/f_multithread_ok/name +new file mode 100644 +index 0000000..45dd561 +--- /dev/null ++++ b/tests/f_multithread_ok/name +@@ -0,0 +1 @@ ++multiple threads checking on clean fs +diff --git a/tests/f_multithread_ok/script b/tests/f_multithread_ok/script +new file mode 100644 +index 0000000..7334cde +--- /dev/null ++++ b/tests/f_multithread_ok/script +@@ -0,0 +1,21 @@ ++FSCK_OPT="-fym4" ++SKIP_VERIFY="true" ++ONE_PASS_ONLY="true" ++SKIP_CLEANUP="true" ++ ++. $cmd_dir/run_e2fsck ++ ++grep -v Thread $OUT1 > $OUT1.tmp ++cmp -s $EXP1 $OUT1.tmp ++status1=$? ++if [ "$status1" -eq 0 ]; then ++ echo "$test_name: $test_description: ok" ++ touch $test_name.ok ++else ++ echo "$test_name: $test_description: failed" ++ diff $DIFF_OPTS $EXP1 $OUT1.tmp > $test_name.failed ++fi ++ ++unset IMAGE FSCK_OPT SECOND_FSCK_OPT OUT1 OUT2 EXP1 EXP2 ++unset SKIP_VERIFY SKIP_CLEANUP SKIP_GUNZIP ONE_PASS_ONLY PREP_CMD ++unset DESCRIPTION SKIP_UNLINK AFTER_CMD PASS_ZERO +diff --git a/tests/f_multithread_preen/expect.1 b/tests/f_multithread_preen/expect.1 +new file mode 100644 +index 0000000..b4b0cd9 +--- /dev/null ++++ b/tests/f_multithread_preen/expect.1 +@@ -0,0 +1,11 @@ ++../e2fsck/e2fsck: Bad magic number in super-block while trying to open test.img ++test_filesys: ++The superblock could not be read or does not describe a valid ext2/ext3/ext4 ++filesystem. If the device is valid and it really contains an ext2/ext3/ext4 ++filesystem (and not swap or ufs or something else), then the superblock ++is corrupt, and you might try running e2fsck with an alternate superblock: ++ e2fsck -b 8193 ++ or ++ e2fsck -b 32768 ++ ++Exit status is 8 +diff --git a/tests/f_multithread_preen/expect.2 b/tests/f_multithread_preen/expect.2 +new file mode 100644 +index 0000000..e2b954d +--- /dev/null ++++ b/tests/f_multithread_preen/expect.2 +@@ -0,0 +1,23 @@ ++ext2fs_open2: Bad magic number in super-block ++../e2fsck/e2fsck: Superblock invalid, trying backup blocks... ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++Free blocks count wrong for group #0 (7987, counted=7982). ++Fix? yes ++ ++Free blocks count wrong (11602, counted=11597). ++Fix? yes ++ ++Free inodes count wrong for group #0 (1493, counted=1488). ++Fix? yes ++ ++Free inodes count wrong (2997, counted=2992). ++Fix? yes ++ ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++test_filesys: 16/3008 files (0.0% non-contiguous), 403/12000 blocks ++Exit status is 1 +diff --git a/tests/f_multithread_preen/image.gz b/tests/f_multithread_preen/image.gz +new file mode 120000 +index 0000000..0fd4001 +--- /dev/null ++++ b/tests/f_multithread_preen/image.gz +@@ -0,0 +1 @@ ++../f_zero_super/image.gz +\ No newline at end of file +diff --git a/tests/f_multithread_preen/name b/tests/f_multithread_preen/name +new file mode 100644 +index 0000000..90d199d +--- /dev/null ++++ b/tests/f_multithread_preen/name +@@ -0,0 +1 @@ ++test "e2fsck -m" option works with "-p" +\ No newline at end of file +diff --git a/tests/f_multithread_preen/script b/tests/f_multithread_preen/script +new file mode 100644 +index 0000000..8965f4a +--- /dev/null ++++ b/tests/f_multithread_preen/script +@@ -0,0 +1,4 @@ ++FSCK_OPT="-fp -m1" ++SECOND_FSCK_OPT=-yf ++ ++. $cmd_dir/run_e2fsck +diff --git a/tests/f_multithread_yes/expect.1 b/tests/f_multithread_yes/expect.1 +new file mode 100644 +index 0000000..8b780ec +--- /dev/null ++++ b/tests/f_multithread_yes/expect.1 +@@ -0,0 +1,2 @@ ++../e2fsck/e2fsck: The -m option should be used together with one of -p/-y/-n options. ++Exit status is 8 +diff --git a/tests/f_multithread_yes/expect.2 b/tests/f_multithread_yes/expect.2 +new file mode 100644 +index 0000000..e2b954d +--- /dev/null ++++ b/tests/f_multithread_yes/expect.2 +@@ -0,0 +1,23 @@ ++ext2fs_open2: Bad magic number in super-block ++../e2fsck/e2fsck: Superblock invalid, trying backup blocks... ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++Free blocks count wrong for group #0 (7987, counted=7982). ++Fix? yes ++ ++Free blocks count wrong (11602, counted=11597). ++Fix? yes ++ ++Free inodes count wrong for group #0 (1493, counted=1488). ++Fix? yes ++ ++Free inodes count wrong (2997, counted=2992). ++Fix? yes ++ ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++test_filesys: 16/3008 files (0.0% non-contiguous), 403/12000 blocks ++Exit status is 1 +diff --git a/tests/f_multithread_yes/image.gz b/tests/f_multithread_yes/image.gz +new file mode 120000 +index 0000000..0fd4001 +--- /dev/null ++++ b/tests/f_multithread_yes/image.gz +@@ -0,0 +1 @@ ++../f_zero_super/image.gz +\ No newline at end of file +diff --git a/tests/f_multithread_yes/name b/tests/f_multithread_yes/name +new file mode 100644 +index 0000000..3a70319 +--- /dev/null ++++ b/tests/f_multithread_yes/name +@@ -0,0 +1 @@ ++test "e2fsck -m" option works with "-y" +\ No newline at end of file +diff --git a/tests/f_multithread_yes/script b/tests/f_multithread_yes/script +new file mode 100644 +index 0000000..8b4aa9b +--- /dev/null ++++ b/tests/f_multithread_yes/script +@@ -0,0 +1,4 @@ ++FSCK_OPT="-f -m1" ++SECOND_FSCK_OPT=-yf ++ ++. $cmd_dir/run_e2fsck +diff --git a/tests/test_one.in b/tests/test_one.in +index 78499ad..a1d46c9 100644 +--- a/tests/test_one.in ++++ b/tests/test_one.in +@@ -27,6 +27,7 @@ esac + + test_dir=$1 + cmd_dir=$SRCDIR ++pfsck_enabled="no" + + if test "$TEST_CONFIG"x = x; then + TEST_CONFIG=$SRCDIR/test_config +@@ -52,6 +53,13 @@ else + test_description= + fi + ++$FSCK --help 2>&1 | grep -q -w -- -m && pfsck_enabled=yes ++if [ "$pfsck_enabled" != "yes" ] ; then ++ echo "$test_dir" | grep -q multithread && ++ echo "$test_name: $test_description: skipped (pfsck disabled)" && ++ exit 0 ++fi ++ + if [ -n "$SKIP_SLOW_TESTS" -a -f $test_dir/is_slow_test ]; then + echo "$test_name: $test_description: skipped (slow test)" + exit 0 +-- +2.33.0 + diff --git a/0023-Misc-small-enhancements-and-bugfixes-for-Lustre.patch b/0023-Misc-small-enhancements-and-bugfixes-for-Lustre.patch new file mode 100644 index 0000000000000000000000000000000000000000..9825cae85f76e29208810c57c1004e3947d3c473 --- /dev/null +++ b/0023-Misc-small-enhancements-and-bugfixes-for-Lustre.patch @@ -0,0 +1,21354 @@ +From 3ca055f697cf3a5bd339c7e73834b378162f5903 Mon Sep 17 00:00:00 2001 +From: Xinliang Liu +Date: Mon, 23 Mar 2020 12:56:00 +1100 +Subject: [PATCH 2/2] Misc small enhancements and bugfixes for Lustre + +Some misc small enhancements and bugfixes for large filesystem +Lustre Ldiskfs[1] which is based on ext4. + +This big patch contains a few misc extensions and bugfixes for +Lustre they are maintained by Lustre community and cherry-picked +from branch v1.46.5.wc1-lustre[2]: +8ff559144 LU-16067 misc: cleanup compiler warnings +57e83aa66 LU-16067 debugfs: quiet debugfs 'catastrophic' message +9530ef297 LU-11545 debugfs: allow for ncheck +e38c28893 LU-15330 e2fsck: no parent lookup in disconnected dir +4410a636b LU-15164 misc: fix chattr usage message for project ID +281d5dd58 LU-13717 sec: support encrypted files handling in pfsck mode +dc56e74e4 LU-14710 e2fsck: fix ".." more gracefully if possible +c7b7006c9 LU-11446 e2fsck: check trusted.link when fixing nlink +46a6a39c4 LU-12158 mke2fs: avoid too large stride and stripe_width +8ac1c0efd LU-11609 mke2fs: allow 64bit feature without extents +58c36dc7b LU-11215 libe2p: add large_xattr as an alias of ea_inode +8cd96b8e5 LU-9501 mke2fs: avoid inode number error with large FS +16478a6c2 LU-6722 jbd: double minimum journal size for RHEL7 +7b2f3cbc4 LU-1540 e2fsck: add missing symlink NUL terminator +20b63c299 debugfs: decode and dump xattrs on inode stat +7cf65606c tests: add basic tests for dirdata feature +f1303140c e2fsck: add support for dirdata feature +153ade60f ext2fs: check if Lustre filesystem is mounted +73a002e4f tests: verify large xattr inode support +cf27ae5f9 libext2fs: add a regression test for in-inode xattrs +6698e5b34 e2fsck: clean up xattr checking code +7799a7651 e2fsck: track errors/badness found for each inode +4f6226ce7 tests: add tests for expanding inode extra size +2f4418928 LU-14768 e2fsck: merge expand_eisize_map properly +96b6432ba e2fsck: add support for expanding the inode size +618d0a683 e2fsck: allow deleting or zeroing shared blocks +196dd848b e2fsck: parse config file before command-line opts +034566f03 filefrag: Lustre changes to filefrag FIEMAP handling +d3f8d86b5 LU-13241 libext2fs: add quota to libext2fs + +[1] https://github.com/whamcloud/lustre/tree/master/ldiskfs +[2] git://git.whamcloud.com/tools/e2fsprogs.git + +Signed-off-by: Andreas Dilger +Signed-off-by: Li Dongyang +Reviewed-by: Artem Blagodarenko +Reviewed-by: Li Dongyang +Signed-off-by: Xinliang Liu +--- + configure | 2 +- + configure.ac | 1 + + debugfs/Makefile.in | 1 + + debugfs/debugfs.8.in | 23 +- + debugfs/debugfs.c | 4 +- + debugfs/debugfs.h | 1 + + debugfs/htree.c | 2 +- + debugfs/ls.c | 46 +- + debugfs/ncheck.c | 19 +- + debugfs/xattrs.c | 284 ++++++- + e2fsck/dirinfo.c | 3 +- + e2fsck/e2fsck.8.in | 23 + + e2fsck/e2fsck.c | 9 +- + e2fsck/e2fsck.conf.5.in | 13 + + e2fsck/e2fsck.h | 57 +- + e2fsck/emptydir.c | 4 +- + e2fsck/encrypted_files.c | 139 ++++ + e2fsck/journal.c | 27 +- + e2fsck/logfile.c | 1 - + e2fsck/message.c | 38 +- + e2fsck/pass1.c | 494 ++++++++++-- + e2fsck/pass1b.c | 64 +- + e2fsck/pass2.c | 251 +++++-- + e2fsck/pass3.c | 28 +- + e2fsck/pass4.c | 120 ++- + e2fsck/pass5.c | 40 +- + e2fsck/problem.c | 104 ++- + e2fsck/problem.h | 66 +- + e2fsck/rehash.c | 79 +- + e2fsck/super.c | 8 +- + e2fsck/unix.c | 172 ++++- + e2fsck/util.c | 1 - + lib/e2p/feature.c | 2 + + lib/ext2fs/Makefile.in | 59 +- + lib/ext2fs/dirblock.c | 33 + + lib/ext2fs/ext2_err.et.in | 21 + + lib/ext2fs/ext2_ext_attr.h | 31 +- + lib/ext2fs/ext2_fs.h | 40 +- + lib/ext2fs/ext2fs.h | 49 +- + lib/ext2fs/ext2fsP.h | 3 + + lib/ext2fs/ext4_acl.h | 6 + + lib/ext2fs/ext_attr.c | 1002 ++++++++++++++++++++++++- + lib/ext2fs/fiemap.h | 7 +- + lib/ext2fs/icount.c | 20 +- + lib/ext2fs/inline_data.c | 14 +- + lib/ext2fs/ismounted.c | 193 +++++ + lib/ext2fs/lfsck.h | 122 +++ + lib/ext2fs/link.c | 10 +- + lib/ext2fs/mkjournal.c | 56 +- + lib/ext2fs/newdir.c | 4 +- + lib/ext2fs/swapfs.c | 2 +- + lib/ext2fs/tst_read_ea.c | 239 ++++++ + misc/chattr.c | 2 +- + misc/filefrag.8.in | 9 +- + misc/filefrag.c | 67 +- + misc/fuse2fs.c | 5 +- + misc/mke2fs.c | 144 ++-- + misc/tune2fs.c | 26 + + misc/util.c | 15 +- + tests/d_print_acl/expect | 13 + + tests/d_print_acl/script | 55 ++ + tests/d_trusted_fid/expect | 4 + + tests/d_trusted_fid/image.gz | Bin 0 -> 8361 bytes + tests/d_trusted_fid/name | 1 + + tests/d_trusted_fid/script | 27 + + tests/d_trusted_link/expect | 12 + + tests/d_trusted_link/image.gz | Bin 0 -> 10740 bytes + tests/d_trusted_link/name | 1 + + tests/d_trusted_link/script | 26 + + tests/d_xattr_edits/expect | 2 +- + tests/f_bad_encryption/expect.1 | 6 +- + tests/f_badroot/expect.1 | 2 +- + tests/f_badsymlinks/expect.1 | 16 +- + tests/f_badsymlinks/expect.2 | 2 +- + tests/f_badsymlinks2/expect.1 | 27 +- + tests/f_badsymlinks2/expect.2 | 2 +- + tests/f_dir_optimize/expect.1 | 511 +++++++++++++ + tests/f_dir_optimize/expect.2 | 511 +++++++++++++ + tests/f_dir_optimize/image.gz | Bin 0 -> 102520 bytes + tests/f_dir_optimize/name | 1 + + tests/f_dir_optimize/script | 36 + + tests/f_dirdata/expect.1 | 15 + + tests/f_dirdata/expect.2 | 7 + + tests/f_dirdata/image.gz | Bin 0 -> 72169 bytes + tests/f_dirdata/name | 1 + + tests/f_dirdata_optimize/expect.1 | 10 + + tests/f_dirdata_optimize/expect.2 | 7 + + tests/f_dirdata_optimize/image.gz | Bin 0 -> 32121 bytes + tests/f_dirdata_optimize/name | 1 + + tests/f_dirdata_optimize/script | 3 + + tests/f_encrypted_lpf/expect.1 | 4 +- + tests/f_expand/expect.1.gz | Bin 13462 -> 13461 bytes + tests/f_expisize/expect.1 | 427 +++++++++++ + tests/f_expisize/expect.2 | 7 + + tests/f_expisize/image.gz | Bin 0 -> 323883 bytes + tests/f_expisize/name | 1 + + tests/f_expisize/script | 4 + + tests/f_expisize_ea_del/expect.1 | 16 + + tests/f_expisize_ea_del/expect.2 | 11 + + tests/f_expisize_ea_del/image.gz | Bin 0 -> 12311 bytes + tests/f_expisize_ea_del/name | 1 + + tests/f_expisize_ea_del/script | 4 + + tests/f_ibadness/expect.1 | 60 ++ + tests/f_ibadness/expect.2 | 7 + + tests/f_ibadness/image.gz | Bin 0 -> 41023 bytes + tests/f_ibadness/name | 1 + + tests/f_ibadness/script | 4 + + tests/f_ibadness_bad_extents/expect.1 | 68 ++ + tests/f_ibadness_bad_extents/expect.2 | 7 + + tests/f_ibadness_bad_extents/image.gz | Bin 0 -> 91025 bytes + tests/f_ibadness_bad_extents/name | 1 + + tests/f_ibadness_bad_extents/script | 4 + + tests/f_itable_collision/expect.1 | 8 +- + tests/f_itable_collision/script | 2 +- + tests/f_large_ea/expect.1 | 48 ++ + tests/f_large_ea/expect.2 | 7 + + tests/f_large_ea/image.gz | Bin 0 -> 13401 bytes + tests/f_large_ea/name | 1 + + tests/f_lpf2/expect.1 | 4 +- + tests/f_messy_inode/expect.1 | 10 +- + tests/f_messy_inode/expect.2 | 2 +- + tests/f_messy_inode/script | 5 + + tests/f_noroot/expect.1 | 4 +- + tests/f_orphan_dotdot_ft/expect.1 | 6 +- + tests/f_rebuild_csum_rootdir/expect.1 | 2 +- + tests/f_recnect_bad/expect.1 | 2 +- + tests/f_resize_inode_meta_bg/expect.1 | 2 +- + tests/f_trusted_link/expect.1 | 16 + + tests/f_trusted_link/expect.2 | 7 + + tests/f_trusted_link/image.gz | Bin 0 -> 18213 bytes + tests/f_trusted_link/name | 1 + + tests/filter.sed | 1 + + tests/m_rootdir/expect | 16 +- + tests/m_rootdir_acl/expect | 37 +- + tests/r_fixup_lastbg/expect | 4 +- + tests/r_fixup_lastbg_big/expect | 4 +- + tests/run_e2fsck | 4 + + tests/test_config | 10 + + tests/test_post | 3 +- + 139 files changed, 5919 insertions(+), 518 deletions(-) + create mode 100644 lib/ext2fs/lfsck.h + create mode 100644 lib/ext2fs/tst_read_ea.c + create mode 100644 tests/d_print_acl/expect + create mode 100644 tests/d_print_acl/script + create mode 100644 tests/d_trusted_fid/expect + create mode 100644 tests/d_trusted_fid/image.gz + create mode 100644 tests/d_trusted_fid/name + create mode 100644 tests/d_trusted_fid/script + create mode 100644 tests/d_trusted_link/expect + create mode 100644 tests/d_trusted_link/image.gz + create mode 100644 tests/d_trusted_link/name + create mode 100644 tests/d_trusted_link/script + create mode 100644 tests/f_dir_optimize/expect.1 + create mode 100644 tests/f_dir_optimize/expect.2 + create mode 100644 tests/f_dir_optimize/image.gz + create mode 100644 tests/f_dir_optimize/name + create mode 100644 tests/f_dir_optimize/script + create mode 100644 tests/f_dirdata/expect.1 + create mode 100644 tests/f_dirdata/expect.2 + create mode 100644 tests/f_dirdata/image.gz + create mode 100644 tests/f_dirdata/name + create mode 100644 tests/f_dirdata_optimize/expect.1 + create mode 100644 tests/f_dirdata_optimize/expect.2 + create mode 100644 tests/f_dirdata_optimize/image.gz + create mode 100644 tests/f_dirdata_optimize/name + create mode 100644 tests/f_dirdata_optimize/script + create mode 100644 tests/f_expisize/expect.1 + create mode 100644 tests/f_expisize/expect.2 + create mode 100644 tests/f_expisize/image.gz + create mode 100644 tests/f_expisize/name + create mode 100644 tests/f_expisize/script + create mode 100644 tests/f_expisize_ea_del/expect.1 + create mode 100644 tests/f_expisize_ea_del/expect.2 + create mode 100644 tests/f_expisize_ea_del/image.gz + create mode 100644 tests/f_expisize_ea_del/name + create mode 100644 tests/f_expisize_ea_del/script + create mode 100644 tests/f_ibadness/expect.1 + create mode 100644 tests/f_ibadness/expect.2 + create mode 100644 tests/f_ibadness/image.gz + create mode 100644 tests/f_ibadness/name + create mode 100644 tests/f_ibadness/script + create mode 100644 tests/f_ibadness_bad_extents/expect.1 + create mode 100644 tests/f_ibadness_bad_extents/expect.2 + create mode 100644 tests/f_ibadness_bad_extents/image.gz + create mode 100644 tests/f_ibadness_bad_extents/name + create mode 100644 tests/f_ibadness_bad_extents/script + create mode 100644 tests/f_large_ea/expect.1 + create mode 100644 tests/f_large_ea/expect.2 + create mode 100644 tests/f_large_ea/image.gz + create mode 100644 tests/f_large_ea/name + create mode 100644 tests/f_messy_inode/script + create mode 100644 tests/f_trusted_link/expect.1 + create mode 100644 tests/f_trusted_link/expect.2 + create mode 100644 tests/f_trusted_link/image.gz + create mode 100644 tests/f_trusted_link/name + +diff --git a/configure b/configure +index 45c91ae..657a174 100755 +--- a/configure ++++ b/configure +@@ -10458,7 +10458,7 @@ fi + done + + fi +-for ac_header in dirent.h errno.h execinfo.h getopt.h malloc.h mntent.h paths.h pthread.h semaphore.h setjmp.h signal.h stdarg.h stdint.h stdlib.h termios.h termio.h unistd.h utime.h attr/xattr.h linux/falloc.h linux/fd.h linux/fsmap.h linux/major.h linux/loop.h linux/types.h net/if_dl.h netinet/in.h sys/acl.h sys/disklabel.h sys/disk.h sys/file.h sys/ioctl.h sys/key.h sys/mkdev.h sys/mman.h sys/mount.h sys/prctl.h sys/random.h sys/resource.h sys/select.h sys/socket.h sys/sockio.h sys/stat.h sys/syscall.h sys/sysmacros.h sys/time.h sys/types.h sys/un.h sys/wait.h sys/xattr.h ++for ac_header in attr/xattr.h dirent.h errno.h execinfo.h getopt.h malloc.h mntent.h paths.h pthread.h semaphore.h setjmp.h signal.h stdarg.h stdint.h stdlib.h termios.h termio.h unistd.h utime.h attr/xattr.h linux/falloc.h linux/fd.h linux/fsmap.h linux/major.h linux/loop.h linux/types.h net/if_dl.h netinet/in.h sys/acl.h sys/disklabel.h sys/disk.h sys/file.h sys/ioctl.h sys/key.h sys/mkdev.h sys/mman.h sys/mount.h sys/prctl.h sys/random.h sys/resource.h sys/select.h sys/socket.h sys/sockio.h sys/stat.h sys/syscall.h sys/sysmacros.h sys/time.h sys/types.h sys/un.h sys/wait.h sys/xattr.h + do : + as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` + ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" +diff --git a/configure.ac b/configure.ac +index 1e7b9be..973c798 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -968,6 +968,7 @@ else + AC_CHECK_PROGS(BUILD_CC, gcc cc) + fi + AC_CHECK_HEADERS(m4_flatten([ ++ attr/xattr.h + dirent.h + errno.h + execinfo.h +diff --git a/debugfs/Makefile.in b/debugfs/Makefile.in +index ed4ea8d..dd2acd7 100644 +--- a/debugfs/Makefile.in ++++ b/debugfs/Makefile.in +@@ -51,6 +51,7 @@ STATIC_DEPLIBS= $(STATIC_LIBEXT2FS) $(DEPSTATIC_LIBSS) \ + # clean up this mess, we should be able to drop it + LOCAL_CFLAGS = -I$(srcdir)/../e2fsck -DDEBUGFS + DEPEND_CFLAGS = -I$(srcdir) ++@LFSCK_CMT@LUSTRE_INC=-I @LUSTRE@/lustre/include -I @LUSTRE@/include -I @LUSTRE@/libcfs/include -Wall + + .c.o: + $(E) " CC $<" +diff --git a/debugfs/debugfs.8.in b/debugfs/debugfs.8.in +index a3227a8..2f5f7ec 100644 +--- a/debugfs/debugfs.8.in ++++ b/debugfs/debugfs.8.in +@@ -301,19 +301,29 @@ corruption in the file system.) + .B dump_unused + Dump unused blocks which contain non-null bytes. + .TP +-.BI ea_get " [-f outfile]|[-xVC] [-r] filespec attr_name" ++.BI "ea_get [-f " outfile "]|[-xVC] [-r]" " filespec attr_name" + Retrieve the value of the extended attribute + .I attr_name + in the file + .I filespec +-and write it either to stdout or to \fIoutfile\fR. ++and write it either to stdout or to \fIoutfile\fR if ++.B -f ++is specified. If ++.B -C ++is used the xattr is printed with C-format escapes, and if ++.B -x ++is used the xattr is printed in hex format, while the ++.B -V ++option prints in raw format without quotes. The ++.B -r ++option prints the xattr name in raw format. + .TP + .BI ea_list " filespec + List the extended attributes associated with the file + .I filespec + to standard output. + .TP +-.BI ea_set " [-f infile] [-r] filespec attr_name attr_value ++.BI "ea_set [-f " infile "] [-r] " "filespec attr_name attr_value" + Set the value of the extended attribute + .I attr_name + in the file +@@ -558,7 +568,7 @@ Instead, it will stop only when the entire log is printed or after + .I num_trans + transactions. + .TP +-.BI ls " [-l] [-c] [-d] [-p] [-r] filespec" ++.BI ls " [-l] [-c] [-d] [-p] [-r] [-D] filespec" + Print a listing of the files in the directory + .IR filespec . + The +@@ -578,6 +588,11 @@ non-printing characters at the end of filenames. + The + .I \-r + flag will force the printing of the filename, even if it is encrypted. ++The ++.I \-D ++flag will print the extra data found inside each entry when the ++.I \-l ++flag is used. + .TP + .BI list_deleted_inodes " [limit]" + List deleted inodes, optionally limited to those deleted within +diff --git a/debugfs/debugfs.c b/debugfs/debugfs.c +index b67a88b..78b93ed 100644 +--- a/debugfs/debugfs.c ++++ b/debugfs/debugfs.c +@@ -195,9 +195,7 @@ try_open_again: + } + current_fs->default_bitmap_type = EXT2FS_BMAP64_RBTREE; + +- if (catastrophic) +- com_err(device, 0, "catastrophic mode - not reading inode or group bitmaps"); +- else { ++ if (!catastrophic) { + retval = ext2fs_read_bitmaps(current_fs); + if (retval) { + com_err(device, retval, +diff --git a/debugfs/debugfs.h b/debugfs/debugfs.h +index 39bc024..db58aba 100644 +--- a/debugfs/debugfs.h ++++ b/debugfs/debugfs.h +@@ -27,6 +27,7 @@ extern quota_ctx_t current_qctx; + extern ext2_ino_t root, cwd; + extern int ss_sci_idx; + extern ss_request_table debug_cmds, extent_cmds; ++extern const char *debug_prog_name; + + extern void reset_getopt(void); + extern FILE *open_pager(void); +diff --git a/debugfs/htree.c b/debugfs/htree.c +index a9f9211..1d94841 100644 +--- a/debugfs/htree.c ++++ b/debugfs/htree.c +@@ -298,7 +298,7 @@ void do_htree_dump(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + goto errout; + } + +- rootnode = (struct ext2_dx_root_info *) (buf + 24); ++ rootnode = get_ext2_dx_root_info(current_fs, buf); + + fprintf(pager, "Root node dump:\n"); + fprintf(pager, "\t Reserved zero: %u\n", rootnode->reserved_zero); +diff --git a/debugfs/ls.c b/debugfs/ls.c +index 525f084..9b3a7c1 100644 +--- a/debugfs/ls.c ++++ b/debugfs/ls.c +@@ -24,6 +24,7 @@ extern char *optarg; + #endif + + #include "debugfs.h" ++#include "ext2fs/lfsck.h" + + /* + * list directory +@@ -32,6 +33,7 @@ extern char *optarg; + #define LONG_OPT 0x0001 + #define PARSE_OPT 0x0002 + #define RAW_OPT 0x0004 ++#define DIRDATA_OPT 0x0008 + #define ENCRYPT_OPT 0x8000 + + struct list_dir_struct { +@@ -44,6 +46,41 @@ struct list_dir_struct { + static const char *monstr[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; + ++static void list_dirdata(struct list_dir_struct *ls, ++ struct ext2_dir_entry *dirent) ++{ ++ unsigned char *data; ++ int dlen; ++ __u8 dirdata_mask; ++ __u8 file_type = dirent->name_len >> 8; ++ ++ data = (unsigned char *)dirent->name + ++ (dirent->name_len & EXT2_NAME_LEN) + 1; ++ ++ for (dirdata_mask = EXT2_FT_MASK + 1; ++ dirdata_mask != 0; dirdata_mask <<= 1) { ++ if ((dirdata_mask & file_type) == 0) ++ continue; ++ ++ dlen = data[0]; ++ ++ if (dirdata_mask == EXT2_DIRENT_LUFID) { ++ struct lu_fid *fid = (struct lu_fid *)(data + 1); ++ ++ fid_be_to_cpu(fid, fid); ++ fprintf(ls->f, "fid:"DFID, PFID(fid)); ++ } else { ++ int i; ++ ++ for (i = 1; i < dlen; i++) ++ fprintf(ls->f, "%02x", data[i]); ++ } ++ ++ fprintf(ls->f, " "); ++ data += dlen; ++ } ++} ++ + static int print_filename(FILE *f, struct ext2_dir_entry *dirent, int options) + { + unsigned char ch; +@@ -147,6 +184,8 @@ static int list_dir_proc(ext2_ino_t dir EXT2FS_ATTR((unused)), + fprintf(ls->f, "%5llu", + (unsigned long long) EXT2_I_SIZE(&inode)); + fprintf(ls->f, " %s ", datestr); ++ if ((ls->options & DIRDATA_OPT) != 0) ++ list_dirdata(ls, dirent); + print_filename(ls->f, dirent, options); + fputc('\n', ls->f); + } else { +@@ -195,7 +234,7 @@ void do_list_dir(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + return; + + reset_getopt(); +- while ((c = getopt (argc, argv, "cdlpr")) != EOF) { ++ while ((c = getopt(argc, argv, "cdDlpr")) != EOF) { + switch (c) { + case 'c': + flags |= DIRENT_FLAG_INCLUDE_CSUM; +@@ -203,6 +242,9 @@ void do_list_dir(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + case 'l': + ls.options |= LONG_OPT; + break; ++ case 'D': ++ ls.options |= DIRDATA_OPT; ++ break; + case 'd': + flags |= DIRENT_FLAG_INCLUDE_REMOVED; + break; +@@ -219,7 +261,7 @@ void do_list_dir(int argc, char *argv[], int sci_idx EXT2FS_ATTR((unused)), + + if (argc > optind+1) { + print_usage: +- com_err(0, 0, "Usage: ls [-c] [-d] [-l] [-p] [-r] file"); ++ com_err(0, 0, "Usage: ls [-c] [-d] [-l] [-p] [-r] [-D] file"); + return; + } + +diff --git a/debugfs/ncheck.c b/debugfs/ncheck.c +index 011f26d..9a8d734 100644 +--- a/debugfs/ncheck.c ++++ b/debugfs/ncheck.c +@@ -51,6 +51,9 @@ static int ncheck_proc(struct ext2_dir_entry *dirent, + iw->position++; + if (iw->position <= 2) + return 0; ++ if (current_fs->super->s_feature_incompat & ++ EXT4_FEATURE_INCOMPAT_DIRDATA) ++ filetype &= EXT2_FT_MASK; + for (i=0; i < iw->num_inodes; i++) { + if (iw->iarray[i] == dirent->inode) { + if (!iw->parent && !iw->get_pathname_failed) { +@@ -134,9 +137,21 @@ void do_ncheck(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)), + + iw.names_left = 0; + for (i=0; i < argc; i++) { +- iw.iarray[i] = strtol(argv[i], &tmp, 0); ++ char *str = argv[i]; ++ int len = strlen(str); ++ ++ if ((len > 2) && (str[0] == '<') && (str[len-1] == '>')) { ++ str[len-1] = '\0'; ++ str++; ++ } ++ iw.iarray[i] = strtol(str, &tmp, 0); + if (*tmp) { +- com_err("ncheck", 0, "Bad inode - %s", argv[i]); ++ if (str != argv[i]) { ++ str--; ++ str[len-1] = '>'; ++ } ++ com_err("ncheck", 0, "Invalid inode number - '%s'", ++ argv[i]); + goto error_out; + } + if (debugfs_read_inode(iw.iarray[i], &inode, *argv)) +diff --git a/debugfs/xattrs.c b/debugfs/xattrs.c +index bd11450..6c266fb 100644 +--- a/debugfs/xattrs.c ++++ b/debugfs/xattrs.c +@@ -17,6 +17,8 @@ extern char *optarg; + #include "support/cstring.h" + + #include "debugfs.h" ++#include "ext2fs/ext4_acl.h" ++#include "ext2fs/lfsck.h" + + #define PRINT_XATTR_HEX 0x01 + #define PRINT_XATTR_RAW 0x02 +@@ -24,6 +26,8 @@ extern char *optarg; + #define PRINT_XATTR_STATFMT 0x08 + #define PRINT_XATTR_NOQUOTES 0x10 + ++extern const char *debug_prog_name; ++ + /* Dump extended attributes */ + static void print_xattr_hex(FILE *f, const char *str, int len) + { +@@ -74,19 +78,293 @@ static void print_xattr(FILE *f, char *name, char *value, size_t value_len, + (strcmp(name, "system.data") == 0)) + value_len = 0; + if (value_len != 0 && +- (!(print_flags & PRINT_XATTR_STATFMT) || (value_len < 40))) { ++ (!(print_flags & PRINT_XATTR_STATFMT) || (value_len < 120))) { + fprintf(f, " = "); + print_xattr_string(f, value, value_len, print_flags); + } + fputc('\n', f); + } + +-static int dump_attr(char *name, char *value, size_t value_len, void *data) ++static int print_acl(FILE *f, char *name, void *value, size_t value_len) ++{ ++ const ext4_acl_header *ext_acl = (const ext4_acl_header *)value; ++ const char *cp; ++ ++ if (!value || ++ (value_len < sizeof(ext4_acl_header)) || ++ (ext_acl->a_version != ext2fs_cpu_to_le32(EXT4_ACL_VERSION))) ++ return -EINVAL; ++ ++ cp = (const char *)value + sizeof(ext4_acl_header); ++ value_len -= sizeof(ext4_acl_header); ++ ++ fprintf(f, "%s:\n", name); ++ ++ while (value_len > 0) { ++ const ext4_acl_entry *disk_entry = (const ext4_acl_entry *)cp; ++ posix_acl_xattr_entry entry; ++ entry.e_tag = ext2fs_le16_to_cpu(disk_entry->e_tag); ++ entry.e_perm = ext2fs_le16_to_cpu(disk_entry->e_perm); ++ ++ switch(entry.e_tag) { ++ case ACL_USER_OBJ: ++ case ACL_USER: ++ fprintf(f, " user:"); ++ if (entry.e_tag == ACL_USER) ++ fprintf(f, "%u", ++ ext2fs_le32_to_cpu(disk_entry->e_id)); ++ break; ++ ++ case ACL_GROUP_OBJ: ++ case ACL_GROUP: ++ fprintf(f, " group:"); ++ if (entry.e_tag == ACL_GROUP) ++ fprintf(f, "%u", ++ ext2fs_le32_to_cpu(disk_entry->e_id)); ++ break; ++ ++ case ACL_MASK: ++ fprintf(f, " mask:"); ++ break; ++ ++ case ACL_OTHER: ++ fprintf(f, " other:"); ++ break; ++ ++ default: ++ fprintf(stderr, ++ "%s: error: invalid tag %x in ACL\n", ++ debug_prog_name, entry.e_tag); ++ return -EINVAL; ++ } ++ fprintf(f, ":"); ++ fprintf(f, (entry.e_perm & ACL_READ) ? "r" : "-"); ++ fprintf(f, (entry.e_perm & ACL_WRITE) ? "w" : "-"); ++ fprintf(f, (entry.e_perm & ACL_EXECUTE) ? "x" : "-"); ++ fprintf(f, "\n"); ++ ++ if (entry.e_tag == ACL_USER || entry.e_tag == ACL_GROUP) { ++ cp += sizeof(ext4_acl_entry); ++ value_len -= sizeof(ext4_acl_entry); ++ } else { ++ cp += sizeof(ext4_acl_entry_short); ++ value_len -= sizeof(ext4_acl_entry_short); ++ } ++ } ++ ++ return 0; ++} ++ ++static int print_fidstr(FILE *f, char *name, void *value, size_t value_len) ++{ ++ struct filter_fid_old *ff = value; ++ int stripe; ++ ++ /* Since Lustre 2.4 only the parent FID is stored in filter_fid, ++ * and the self fid is stored in the LMA and is printed below. */ ++ if (value_len < sizeof(ff->ff_parent)) { ++ fprintf(stderr, "%s: error: xattr '%s' too small (%zu bytes)\n", ++ debug_prog_name, name, value_len); ++ return -EINVAL; ++ } ++ fid_le_to_cpu(&ff->ff_parent, &ff->ff_parent); ++ stripe = fid_ver(&ff->ff_parent); /* stripe index is stored in f_ver */ ++ ff->ff_parent.f_ver = 0; ++ ++ fprintf(f, "fid: "); ++ /* Old larger filter_fid should only ever be used with seq = 0. ++ * FID-on-OST should use LMA for FID_SEQ_NORMAL OST objects. */ ++ if (value_len == sizeof(*ff)) ++ fprintf(f, "objid=%llu seq=%llu ", ++ ext2fs_le64_to_cpu(ff->ff_objid), ++ ext2fs_le64_to_cpu(ff->ff_seq)); ++ ++ fprintf(f, "parent="DFID" stripe=%u", PFID(&ff->ff_parent), stripe); ++ if (value_len >= sizeof(struct filter_fid_210)) { ++ struct filter_fid_210 *ff_new = value; ++ ++ fprintf(f, " stripe_size=%u stripe_count=%u", ++ ext2fs_le32_to_cpu(ff_new->ff_stripe_size), ++ ext2fs_le32_to_cpu(ff_new->ff_stripe_count)); ++ if (ff_new->ff_pfl_id != 0) ++ fprintf(f, " component_id=%u component_start=%llu " ++ "component_end=%llu", ++ ext2fs_le32_to_cpu(ff_new->ff_pfl_id), ++ ext2fs_le64_to_cpu(ff_new->ff_pfl_start), ++ ext2fs_le64_to_cpu(ff_new->ff_pfl_end)); ++ } ++ ++ if (value_len >= sizeof(struct filter_fid)) { ++ struct filter_fid *ff_new = value; ++ ++ fprintf(f, " layout_version=%u range=%u", ++ ext2fs_le32_to_cpu(ff_new->ff_layout_version), ++ ext2fs_le32_to_cpu(ff_new->ff_range)); ++ } ++ ++ fprintf(f, "\n"); ++ ++ return 0; ++} ++ ++static int print_lmastr(FILE *f, char *name, void *value, size_t value_len) ++{ ++ struct lustre_mdt_attrs *lma = value; ++ struct lustre_ost_attrs *loa = value; ++ ++ if (value_len < offsetof(typeof(*lma), lma_self_fid) + ++ sizeof(lma->lma_self_fid)) { ++ fprintf(stderr, "%s: error: xattr '%s' too small (%zu bytes)\n", ++ debug_prog_name, name, value_len); ++ return -EINVAL; ++ } ++ fid_le_to_cpu(&lma->lma_self_fid, &lma->lma_self_fid); ++ fprintf(f, "lma: fid="DFID" compat=%x incompat=%x\n", ++ PFID(&lma->lma_self_fid), ext2fs_le32_to_cpu(lma->lma_compat), ++ ext2fs_le32_to_cpu(lma->lma_incompat)); ++ if (value_len >= offsetof(typeof(*loa), loa_pfl_end) + ++ sizeof(loa->loa_pfl_end)) { ++ int idx; ++ int cnt; ++ ++ fid_le_to_cpu(&loa->loa_parent_fid, &loa->loa_parent_fid); ++ idx = loa->loa_parent_fid.f_ver & PFID_STRIPE_COUNT_MASK; ++ cnt = loa->loa_parent_fid.f_ver >> PFID_STRIPE_IDX_BITS; ++ loa->loa_parent_fid.f_ver = 0; ++ ++ fprintf(f, " fid: parent="DFID" stripe=%u stripe_size=%u " ++ "stripe_count=%u", PFID(&loa->loa_parent_fid), idx, ++ ext2fs_le32_to_cpu(loa->loa_stripe_size), cnt); ++ if (loa->loa_pfl_id != 0) ++ fprintf(f, " component_id=%u component_start=%llu " ++ "component_end=%llu", ++ ext2fs_le32_to_cpu(loa->loa_pfl_id), ++ ext2fs_le64_to_cpu(loa->loa_pfl_start), ++ ext2fs_le64_to_cpu(loa->loa_pfl_end)); ++ fprintf(f, "\n"); ++ } ++ ++ return 0; ++} ++ ++static void print_name(FILE *f, const char *cp, int len) ++{ ++ unsigned char ch; ++ ++ while (len--) { ++ ch = *cp++; ++ if (!isprint(ch) || ch == '\\') { ++ if (f) ++ fprintf(f, "\\x%02x", ch); ++ } else { ++ if (f) ++ fputc(ch, f); ++ } ++ } ++} ++ ++static int print_linkea(FILE *f, char *name, void *value, size_t value_len) + { ++ struct link_ea_header *leh = value; ++ struct link_ea_entry *lee; ++ int i; ++ ++ if (value_len < sizeof(*leh) || ++ value_len < ext2fs_le64_to_cpu(leh->leh_len)) { ++ fprintf(stderr, "%s: error: xattr '%s' too small (%zu bytes)\n", ++ debug_prog_name, name, value_len); ++ return -EINVAL; ++ } ++ ++ if (ext2fs_le32_to_cpu(leh->leh_magic) != LINK_EA_MAGIC) { ++ fprintf(stderr, "%s: error: xattr '%s' bad magic '%#x'\n", ++ debug_prog_name, name, ++ ext2fs_le32_to_cpu(leh->leh_magic)); ++ return -EINVAL; ++ } ++ ++ lee = leh->leh_entry; ++ value_len -= sizeof(*leh); ++ ++ for (i = 0; i < ext2fs_le32_to_cpu(leh->leh_reccount) && ++ value_len > 2; i++) { ++ int reclen = lee->lee_reclen[0] << 8 | lee->lee_reclen[1]; ++ struct lu_fid pfid; ++ ++ if (value_len < sizeof(*lee) || value_len < reclen) { ++ fprintf(stderr, ++ "%s: error: xattr '%s' entry %d too small " ++ "(%zu bytes)\n", ++ debug_prog_name, name, i, value_len); ++ return -EINVAL; ++ } ++ ++ memcpy(&pfid, &lee->lee_parent_fid, sizeof(pfid)); ++ fid_be_to_cpu(&pfid, &pfid); ++ fprintf(f, "%s idx=%u parent="DFID" name='", ++ i == 0 ? "linkea:" : " ", i, PFID(&pfid)); ++ print_name(f, lee->lee_name, reclen - (int)sizeof(*lee)); ++ fprintf(f, "'\n"); ++ ++ lee = (struct link_ea_entry *)((char *)lee + reclen); ++ value_len -= reclen; ++ } ++ ++ return 0; ++} ++ ++struct dump_attr_pretty { ++ const char *dap_name; ++ int (*dap_print)(FILE *f, char *name, void *value, size_t value_len); ++} dumpers[] = { ++ { ++ .dap_name = "system.posix_acl_access", ++ .dap_print = print_acl, ++ }, ++ { ++ .dap_name = "system.posix_acl_default", ++ .dap_print = print_acl, ++ }, ++ { ++ .dap_name = "trusted.fid", ++ .dap_print = print_fidstr, ++ }, ++ { ++ .dap_name = "trusted.lma", ++ .dap_print = print_lmastr, ++ }, ++ { ++ .dap_name = "trusted.link", ++ .dap_print = print_linkea, ++ }, ++ { ++ .dap_name = NULL, ++ } ++}; ++ ++static int dump_attr(char *name, char *value, size_t value_len, ++ ext2_ino_t inode_num, void *data) ++{ ++ struct dump_attr_pretty *dap; + FILE *out = data; ++ int rc = 0; + + fprintf(out, " "); +- print_xattr(out, name, value, value_len, PRINT_XATTR_STATFMT); ++ if (EXT2_HAS_INCOMPAT_FEATURE(current_fs->super, ++ EXT4_FEATURE_INCOMPAT_EA_INODE) && ++ inode_num != 0) { ++ fprintf(out, "inode <%u> ", inode_num); ++ } ++ ++ for (dap = dumpers; dap->dap_name != NULL; dap++) { ++ if (strcmp(name, dap->dap_name) == 0) { ++ rc = dap->dap_print(out, name, value, value_len); ++ break; ++ } ++ } ++ if (dap->dap_name == NULL || rc) ++ print_xattr(out, name, value, value_len, PRINT_XATTR_STATFMT); ++ + return 0; + } + +diff --git a/e2fsck/dirinfo.c b/e2fsck/dirinfo.c +index b4adaa6..322f4da 100644 +--- a/e2fsck/dirinfo.c ++++ b/e2fsck/dirinfo.c +@@ -294,8 +294,7 @@ out: + */ + void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent) + { +- struct dir_info *dir, *old_array; +- ext2_ino_t i, j; ++ struct dir_info *old_array; + errcode_t retval; + unsigned long old_size; + +diff --git a/e2fsck/e2fsck.8.in b/e2fsck/e2fsck.8.in +index 37dc893..b5959ad 100644 +--- a/e2fsck/e2fsck.8.in ++++ b/e2fsck/e2fsck.8.in +@@ -198,6 +198,19 @@ separated, and may take an argument using the equals ('=') sign. The + following options are supported: + .RS 1.2i + .TP ++.BI clone= dup|zero ++Resolve files with shared blocks in pass 1D by giving each file a private ++copy of the blocks (dup); ++or replacing the shared blocks with private, zero-filled blocks (zero). ++The default is dup. ++.TP ++.BI shared= preserve|lost+found|delete ++Files with shared blocks discovered in pass 1D are cloned and then left ++in place (preserve); ++cloned and then disconnected from their parent directory, ++then reconnected to /lost+found in pass 3 (lost+found); ++or simply deleted (delete). The default is preserve. ++.TP + .BI ea_ver= extended_attribute_version + Set the version of the extended attribute blocks which + .B e2fsck +@@ -208,6 +221,16 @@ be 1 or 2. The default extended attribute version format is 2. + Only replay the journal if required, but do not perform any further checks + or repairs. + .TP ++.BI inode_badness_threshold= threshold_value ++A badness counter is associated with every inode, which determines the degree ++of inode corruption. Each error found in the inode will increase the badness ++by 1 or 2, and inodes with a badness at or above ++.I threshold_value ++will be prompted for deletion. The default ++.I threshold_value ++is 12, and must either be 0 (disabled), or between 3 and 200, as some valid ++inode states may set a badness of 1 or 2 that should not clear the inode. ++.TP + .BI fragcheck + During pass 1, print a detailed report of any discontiguous blocks for + files in the file system. +diff --git a/e2fsck/e2fsck.c b/e2fsck/e2fsck.c +index db0a505..14fd2bb 100644 +--- a/e2fsck/e2fsck.c ++++ b/e2fsck/e2fsck.c +@@ -87,6 +87,10 @@ errcode_t e2fsck_reset_context(e2fsck_t ctx) + ext2fs_free_icount(ctx->inode_link_info); + ctx->inode_link_info = 0; + } ++ if (ctx->inode_badness) { ++ ext2fs_free_icount(ctx->inode_badness); ++ ctx->inode_badness = 0; ++ } + if (ctx->journal_io) { + if (ctx->fs && ctx->fs->io != ctx->journal_io) + io_channel_close(ctx->journal_io); +@@ -138,10 +142,6 @@ errcode_t e2fsck_reset_context(e2fsck_t ctx) + ext2fs_free_inode_bitmap(ctx->inode_bb_map); + ctx->inode_bb_map = 0; + } +- if (ctx->inode_bad_map) { +- ext2fs_free_inode_bitmap(ctx->inode_bad_map); +- ctx->inode_bad_map = 0; +- } + if (ctx->inode_imagic_map) { + ext2fs_free_inode_bitmap(ctx->inode_imagic_map); + ctx->inode_imagic_map = 0; +@@ -198,6 +198,7 @@ errcode_t e2fsck_reset_context(e2fsck_t ctx) + #ifdef HAVE_PTHREAD + ctx->fs_need_locking = 0; + #endif ++ ctx->fs_unexpanded_inodes = 0; + + for (i=0; i < MAX_EXTENT_DEPTH_COUNT; i++) + ctx->extent_depth_count[i] = 0; +diff --git a/e2fsck/e2fsck.conf.5.in b/e2fsck/e2fsck.conf.5.in +index e82610d..9d02775 100644 +--- a/e2fsck/e2fsck.conf.5.in ++++ b/e2fsck/e2fsck.conf.5.in +@@ -147,6 +147,19 @@ will offer to clear + the test_fs flag if the ext4 file system is available on the system. It + defaults to true. + .TP ++.I clone ++This string relation controls the default handling of shared blocks in pass 1D. ++It can be set to dup or zero. See the ++.I "-E clone" ++option description in e2fsck(8). ++.TP ++.I shared ++This string relation controls the default disposition of files discovered to ++have shared blocks in pass 1D. It can be set to preserve, lost+found, ++or delete. See the ++.I "-E shared" ++option description in e2fsck(8). ++.TP + .I defer_check_on_battery + This boolean relation controls whether or not the interval between + file system checks (either based on time or number of mounts) should +diff --git a/e2fsck/e2fsck.h b/e2fsck/e2fsck.h +index 4e86d2e..43051be 100644 +--- a/e2fsck/e2fsck.h ++++ b/e2fsck/e2fsck.h +@@ -11,6 +11,7 @@ + + #include + #include ++#include + #ifdef HAVE_UNISTD_H + #include + #endif +@@ -211,6 +212,7 @@ struct resource_track { + #define E2F_FLAG_TIME_INSANE 0x2000 /* Time is insane */ + #define E2F_FLAG_PROBLEMS_FIXED 0x4000 /* At least one problem was fixed */ + #define E2F_FLAG_ALLOC_OK 0x8000 /* Can we allocate blocks? */ ++#define E2F_FLAG_EXPAND_EISIZE 0x10000 /* Expand the inodes (i_extra_isize) */ + #define E2F_FLAG_DUP_BLOCK 0x20000 /* dup block found during pass1 */ + + #define E2F_RESET_FLAGS (E2F_FLAG_TIME_INSANE | E2F_FLAG_PROBLEMS_FIXED) +@@ -225,6 +227,33 @@ struct resource_track { + #define E2F_PASS_5 5 + #define E2F_PASS_1B 6 + ++enum shared_opt { ++ E2F_SHARED_PRESERVE = 0, ++ E2F_SHARED_DELETE, ++ E2F_SHARED_LPF ++}; ++ ++enum clone_opt { ++ E2F_CLONE_DUP = 0, ++ E2F_CLONE_ZERO ++}; ++ ++#define EXT4_FITS_IN_INODE(ext4_inode, einode, field) \ ++ ((offsetof(typeof(*ext4_inode), field) + \ ++ sizeof(ext4_inode->field)) <= \ ++ (EXT2_GOOD_OLD_INODE_SIZE + \ ++ (einode)->i_extra_isize)) \ ++ ++#define EXT4_XTIME_FUTURE(ctx, sb, xtime, margin) \ ++ (!((ctx)->flags & E2F_FLAG_TIME_INSANE) && \ ++ (xtime) > (ctx)->now + (margin)) ++#define EXT4_XTIME_ANCIENT(ctx, sb, xtime, margin) \ ++ ((sb)->s_mkfs_time > (margin) && (xtime) < (sb)->s_mkfs_time - (margin)) ++ ++#define BADNESS_THRESHOLD 12 ++#define BADNESS_BAD_MODE 0x8000 ++#define BADNESS_MAX 0x7fff ++ + /* + * Define the extended attribute refcount structure + */ +@@ -277,7 +306,7 @@ struct e2fsck_thread { + dgrp_t et_group_next; + /* Scanned inode number */ + ext2_ino_t et_inode_number; +- char et_log_length; ++ int et_log_length; + char et_log_buf[2048]; + }; + #endif +@@ -319,7 +348,6 @@ struct e2fsck_struct { + + /* The following inode bitmaps are separately used in thread_ctx Pass1*/ + ext2fs_inode_bitmap inode_used_map; /* Inodes which are in use */ +- ext2fs_inode_bitmap inode_bad_map; /* Inodes which are bad somehow */ + ext2fs_inode_bitmap inode_dir_map; /* Inodes which are directories */ + ext2fs_inode_bitmap inode_bb_map; /* Inodes which are in bad blocks */ + ext2fs_inode_bitmap inode_imagic_map; /* AFS inodes */ +@@ -337,6 +365,8 @@ struct e2fsck_struct { + */ + ext2_icount_t inode_count; + ext2_icount_t inode_link_info; ++ ext2_icount_t inode_badness; ++ unsigned int inode_badness_threshold; + + ext2_refcount_t refcount; + ext2_refcount_t refcount_extra; +@@ -465,10 +495,21 @@ struct e2fsck_struct { + time_t now; + time_t time_fudge; /* For working around buggy init scripts */ + int ext_attr_ver; ++ enum shared_opt shared; ++ enum clone_opt clone; + profile_t profile; + int blocks_per_page; + ext2_u32_list casefolded_dirs; + ++ /* Expand large inodes to atleast these many bytes */ ++ int want_extra_isize; ++ /* minimum i_extra_isize found in used inodes. Should not be lesser ++ * than s_min_extra_isize. ++ */ ++ __u32 min_extra_isize; ++ int fs_unexpanded_inodes; ++ ext2fs_inode_bitmap expand_eisize_map; ++ + /* Reserve blocks for root and l+f re-creation */ + blk64_t root_repair_block, lnf_repair_block; + +@@ -644,6 +685,8 @@ __u32 find_encryption_policy(e2fsck_t ctx, ext2_ino_t ino); + + void destroy_encryption_policy_map(e2fsck_t ctx); + void destroy_encrypted_file_info(e2fsck_t ctx); ++int e2fsck_merge_encrypted_info(e2fsck_t ctx, struct encrypted_file_info *src, ++ struct encrypted_file_info *dest); + + /* extents.c */ + errcode_t e2fsck_rebuild_extents_later(e2fsck_t ctx, ext2_ino_t ino); +@@ -680,11 +723,19 @@ extern errcode_t e2fsck_setup_icount(e2fsck_t ctx, const char *icount_name, + extern void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int use_shortcuts); + extern int e2fsck_pass1_check_device_inode(ext2_filsys fs, + struct ext2_inode *inode); +-extern int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, ++extern int e2fsck_pass1_check_symlink(e2fsck_t ctx, ext2_ino_t ino, + struct ext2_inode *inode, char *buf); + extern void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino, + struct ext2_inode *inode, int restart_flag, + const char *source); ++#define e2fsck_mark_inode_bad(ctx, pctx, code) \ ++ e2fsck_mark_inode_bad_loc(ctx, pctx, code, 1, __func__, __LINE__) ++#define e2fsck_mark_inode_badder(ctx, pctx, code) \ ++ e2fsck_mark_inode_bad_loc(ctx, pctx, code, 2, __func__, __LINE__) ++extern void e2fsck_mark_inode_bad_loc(e2fsck_t ctx, ++ struct problem_context *pctx, __u32 code, ++ int count, const char *func, const int line); ++extern int e2fsck_fix_bad_inode(e2fsck_t ctx, struct problem_context *pctx); + extern void e2fsck_intercept_block_allocations(e2fsck_t ctx); + + /* pass2.c */ +diff --git a/e2fsck/emptydir.c b/e2fsck/emptydir.c +index 7aea7b6..d05ba98 100644 +--- a/e2fsck/emptydir.c ++++ b/e2fsck/emptydir.c +@@ -98,9 +98,9 @@ void add_empty_dirblock(empty_dir_info edi, + db->blk, db->blockcnt, db->ino); + + ext2fs_mark_block_bitmap2(edi->empty_dir_blocks, db->blk); +- if (ext2fs_test_inode_bitmap(edi->dir_map, db->ino)) ++ if (ext2fs_test_inode_bitmap2(edi->dir_map, db->ino)) + return; +- ext2fs_mark_inode_bitmap(edi->dir_map, db->ino); ++ ext2fs_mark_inode_bitmap2(edi->dir_map, db->ino); + + ext2fs_add_dir_block2(edi->empty_dblist, db->ino, + db->blk, db->blockcnt); +diff --git a/e2fsck/encrypted_files.c b/e2fsck/encrypted_files.c +index 16be2d6..53e03a6 100644 +--- a/e2fsck/encrypted_files.c ++++ b/e2fsck/encrypted_files.c +@@ -456,3 +456,142 @@ void destroy_encrypted_file_info(e2fsck_t ctx) + ctx->encrypted_files = NULL; + } + } ++ ++/** ++ * Search policy matching @policy in @info->policies ++ * @ctx: e2fsck context ++ * @info: encrypted_file_info to look into ++ * @policy: the policy we are looking for ++ * @parent: (out) last known parent, useful to insert a new leaf ++ * in @info->policies ++ * ++ * Return: id of found policy on success, -1 if no matching policy found. ++ */ ++static inline int search_policy(e2fsck_t ctx, struct encrypted_file_info *info, ++ union fscrypt_policy policy, ++ struct rb_node **parent) ++{ ++ struct rb_node *n = info->policies.rb_node; ++ struct policy_map_entry *entry; ++ ++ while (n) { ++ int res; ++ ++ *parent = n; ++ entry = ext2fs_rb_entry(n, struct policy_map_entry, node); ++ res = cmp_fscrypt_policies(ctx, &policy, &entry->policy); ++ if (res < 0) ++ n = n->rb_left; ++ else if (res > 0) ++ n = n->rb_right; ++ else ++ return entry->policy_id; ++ } ++ return -1; ++} ++ ++/* ++ * Merge @src encrypted info into @dest ++ */ ++int e2fsck_merge_encrypted_info(e2fsck_t ctx, struct encrypted_file_info *src, ++ struct encrypted_file_info *dest) ++{ ++ struct rb_root *src_policies = &src->policies; ++ __u32 *policy_trans; ++ int i, rc = 0; ++ ++ if (dest->file_ranges[src->file_ranges_count - 1].last_ino > ++ src->file_ranges[0].first_ino) { ++ /* Should never get here */ ++ fatal_error(ctx, "Encrypted inodes processed out of order"); ++ } ++ ++ rc = ext2fs_get_array(src->next_policy_id, sizeof(__u32), ++ &policy_trans); ++ if (rc) ++ return rc; ++ ++ /* First, deal with the encryption policy => ID map. ++ * Compare encryption policies in src with policies already recorded ++ * in dest. It can be similar policies, but recorded with a different ++ * id, so policy_trans array converts policy ids in src to ids in dest. ++ * This loop examines each policy in src->policies rb tree, updates ++ * policy_trans, and removes the entry from src, so that src->policies ++ * rb tree is cleaned up at the end of the loop. ++ */ ++ while (!ext2fs_rb_empty_root(src_policies)) { ++ struct policy_map_entry *entry, *newentry; ++ struct rb_node *new, *parent = NULL; ++ int existing_polid; ++ ++ entry = ext2fs_rb_entry(src_policies->rb_node, ++ struct policy_map_entry, node); ++ existing_polid = search_policy(ctx, dest, ++ entry->policy, &parent); ++ if (existing_polid >= 0) { ++ /* The policy in src is already recorded in dest, ++ * so just update its id. ++ */ ++ policy_trans[entry->policy_id] = existing_polid; ++ } else { ++ /* The policy in src is new to dest, so insert it ++ * with the next available id (its original id could ++ * be already used in dest). ++ */ ++ rc = ext2fs_get_mem(sizeof(*newentry), &newentry); ++ if (rc) ++ goto out_merge; ++ newentry->policy_id = dest->next_policy_id++; ++ newentry->policy = entry->policy; ++ ext2fs_rb_link_node(&newentry->node, parent, &new); ++ ext2fs_rb_insert_color(&newentry->node, ++ &dest->policies); ++ policy_trans[entry->policy_id] = newentry->policy_id; ++ } ++ ext2fs_rb_erase(&entry->node, src_policies); ++ ext2fs_free_mem(&entry); ++ } ++ ++ /* Second, deal with the inode number => encryption policy ID map. */ ++ if (dest->file_ranges_capacity < ++ dest->file_ranges_count + src->file_ranges_count) { ++ /* dest->file_ranges is too short, increase its capacity. */ ++ size_t new_capacity = dest->file_ranges_count + ++ src->file_ranges_count; ++ ++ /* Make sure we at least double the capacity. */ ++ if (new_capacity < (dest->file_ranges_capacity * 2)) ++ new_capacity = dest->file_ranges_capacity * 2; ++ ++ /* We won't need more than the filesystem's inode count. */ ++ if (new_capacity > ctx->fs->super->s_inodes_count) ++ new_capacity = ctx->fs->super->s_inodes_count; ++ ++ rc = ext2fs_resize_mem(dest->file_ranges_capacity * ++ sizeof(struct encrypted_file_range), ++ new_capacity * ++ sizeof(struct encrypted_file_range), ++ &dest->file_ranges); ++ if (rc) { ++ fix_problem(ctx, PR_1_ALLOCATE_ENCRYPTED_INODE_LIST, ++ NULL); ++ /* Should never get here */ ++ ctx->flags |= E2F_FLAG_ABORT; ++ goto out_merge; ++ } ++ ++ dest->file_ranges_capacity = new_capacity; ++ } ++ /* Copy file ranges from src to dest. */ ++ for (i = 0; i < src->file_ranges_count; i++) { ++ /* Make sure to convert policy ids in src. */ ++ src->file_ranges[i].policy_id = ++ policy_trans[src->file_ranges[i].policy_id]; ++ dest->file_ranges[dest->file_ranges_count++] = ++ src->file_ranges[i]; ++ } ++ ++out_merge: ++ ext2fs_free_mem(&policy_trans); ++ return rc; ++} +diff --git a/e2fsck/journal.c b/e2fsck/journal.c +index 17e00bf..b8c9c6c 100644 +--- a/e2fsck/journal.c ++++ b/e2fsck/journal.c +@@ -578,7 +578,7 @@ static int ext4_del_extent_from_list(e2fsck_t ctx, struct extent_list *list, + return ext4_modify_extent_list(ctx, list, ex, 1 /* delete */); + } + +-static int ext4_fc_read_extents(e2fsck_t ctx, ino_t ino) ++static int ext4_fc_read_extents(e2fsck_t ctx, ext2_ino_t ino) + { + struct extent_list *extent_list = &ctx->fc_replay_state.fc_extent_list; + +@@ -597,7 +597,7 @@ static int ext4_fc_read_extents(e2fsck_t ctx, ino_t ino) + * for the inode so that we can flush all of them at once and it also saves us + * from continuously growing and shrinking the extent tree. + */ +-static void ext4_fc_flush_extents(e2fsck_t ctx, ino_t ino) ++static void ext4_fc_flush_extents(e2fsck_t ctx, ext2_ino_t ino) + { + struct extent_list *extent_list = &ctx->fc_replay_state.fc_extent_list; + +@@ -610,9 +610,9 @@ static void ext4_fc_flush_extents(e2fsck_t ctx, ino_t ino) + + /* Helper struct for dentry replay routines */ + struct dentry_info_args { +- ino_t parent_ino; ++ ext2_ino_t parent_ino; + int dname_len; +- ino_t ino; ++ ext2_ino_t ino; + char *dname; + }; + +@@ -620,7 +620,6 @@ static inline int tl_to_darg(struct dentry_info_args *darg, + struct ext4_fc_tl *tl, __u8 *val) + { + struct ext4_fc_dentry_info fcd; +- int tag = le16_to_cpu(tl->fc_tag); + + memcpy(&fcd, val, sizeof(fcd)); + +@@ -635,11 +634,11 @@ static inline int tl_to_darg(struct dentry_info_args *darg, + val + sizeof(struct ext4_fc_dentry_info), + darg->dname_len); + darg->dname[darg->dname_len] = 0; +- jbd_debug(1, "%s: %s, ino %lu, parent %lu\n", +- tag == EXT4_FC_TAG_CREAT ? "create" : +- (tag == EXT4_FC_TAG_LINK ? "link" : +- (tag == EXT4_FC_TAG_UNLINK ? "unlink" : "error")), +- darg->dname, darg->ino, darg->parent_ino); ++ jbd_debug(1, "%s: %s, ino %d, parent %d\n", ++ le16_to_cpu(tl->fc_tag) == EXT4_FC_TAG_CREAT ? "create" : ++ (le16_to_cpu(tl->fc_tag) == EXT4_FC_TAG_LINK ? "link" : ++ (le16_to_cpu(tl->fc_tag) == EXT4_FC_TAG_UNLINK ? "unlink" : ++ "error")), darg->dname, darg->ino, darg->parent_ino); + return 0; + } + +@@ -652,11 +651,11 @@ static int ext4_fc_handle_unlink(e2fsck_t ctx, struct ext4_fc_tl *tl, __u8 *val) + if (ret) + return ret; + ext4_fc_flush_extents(ctx, darg.ino); +- ret = errcode_to_errno( +- ext2fs_unlink(ctx->fs, darg.parent_ino, +- darg.dname, darg.ino, 0)); ++ ret = errcode_to_errno(ext2fs_unlink(ctx->fs, darg.parent_ino, ++ darg.dname, darg.ino, 0)); + /* It's okay if the above call fails */ + free(darg.dname); ++ + return ret; + } + +@@ -800,7 +799,7 @@ static int ext4_fc_handle_add_extent(e2fsck_t ctx, __u8 *val) + { + struct ext2fs_extent extent; + struct ext4_fc_add_range add_range; +- ino_t ino; ++ ext2_ino_t ino; + int ret = 0; + + memcpy(&add_range, val, sizeof(add_range)); +diff --git a/e2fsck/logfile.c b/e2fsck/logfile.c +index 60ab95f..1d71d8c 100644 +--- a/e2fsck/logfile.c ++++ b/e2fsck/logfile.c +@@ -292,7 +292,6 @@ static FILE *set_up_log_file(e2fsck_t ctx, const char *key, const char *fn) + struct string s, s1, s2; + char *s0 = 0, *log_dir = 0, *log_fn = 0; + int log_dir_wait = 0; +- int string_size; + char string_index[10]; + + s.s = s1.s = s2.s = 0; +diff --git a/e2fsck/message.c b/e2fsck/message.c +index ba38038..65e6886 100644 +--- a/e2fsck/message.c ++++ b/e2fsck/message.c +@@ -99,6 +99,7 @@ + + #include "e2fsck.h" + #include "problem.h" ++#include "ext2fs/lfsck.h" + + #ifdef __GNUC__ + #define _INLINE_ __inline__ +@@ -346,6 +347,33 @@ static _INLINE_ void expand_inode_expression(FILE *f, ext2_filsys fs, char ch, + } + } + ++const struct lu_fid *get_dirent_fid(struct ext2_dir_entry *dirent) ++{ ++ unsigned char *data = (unsigned char *)dirent->name + ++ (dirent->name_len & EXT2_NAME_LEN) + 1; ++ __u8 file_type = dirent->name_len >> 8; ++ struct lu_fid *fid = NULL; ++ __u8 dirdata_mask; ++ ++ for (dirdata_mask = EXT2_FT_MASK + 1; ++ dirdata_mask != 0; dirdata_mask <<= 1) { ++ int dlen; ++ ++ if ((dirdata_mask & file_type) == 0) ++ continue; ++ ++ dlen = data[0]; ++ if (dirdata_mask == EXT2_DIRENT_LUFID) { ++ fid = (struct lu_fid *)(data + 1); ++ fid_be_to_cpu(fid, fid); ++ break; ++ } ++ data += dlen; ++ } ++ ++ return fid; ++} ++ + /* + * This function expands '%dX' expressions + */ +@@ -361,9 +389,17 @@ static _INLINE_ void expand_dirent_expression(FILE *f, ext2_filsys fs, char ch, + dirent = ctx->dirent; + + switch (ch) { +- case 'i': ++ case 'i': { ++ const struct lu_fid *fid; ++ + fprintf(f, "%u", dirent->inode); ++ ++ fid = get_dirent_fid(dirent); ++ if (fid != NULL) ++ fprintf(f, " fid="DFID, PFID(fid)); ++ + break; ++ } + case 'n': + len = ext2fs_dirent_name_len(dirent); + if ((ext2fs_get_rec_len(fs, dirent, &rec_len) == 0) && +diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c +index 553c299..3dacbb3 100644 +--- a/e2fsck/pass1.c ++++ b/e2fsck/pass1.c +@@ -20,10 +20,12 @@ + * - A bitmap of which inodes are in use. (inode_used_map) + * - A bitmap of which inodes are directories. (inode_dir_map) + * - A bitmap of which inodes are regular files. (inode_reg_map) +- * - A bitmap of which inodes have bad fields. (inode_bad_map) ++ * - An icount mechanism is used to keep track of ++ * inodes with bad fields and its badness (ctx->inode_badness) + * - A bitmap of which inodes are in bad blocks. (inode_bb_map) + * - A bitmap of which inodes are imagic inodes. (inode_imagic_map) + * - A bitmap of which inodes are casefolded. (inode_casefold_map) ++ * - A bitmap of which inodes need to be expanded (expand_eisize_map) + * - A bitmap of which blocks are in use. (block_found_map) + * - A bitmap of which blocks are in use by two inodes (block_dup_map) + * - The data blocks of the directory inodes. (dir_map) +@@ -85,7 +87,6 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, + static void mark_table_blocks(e2fsck_t ctx); + static void alloc_bb_map(e2fsck_t ctx); + static void alloc_imagic_map(e2fsck_t ctx); +-static void mark_inode_bad(e2fsck_t ctx, ino_t ino); + static void add_casefolded_dir(e2fsck_t ctx, ino_t ino); + static void handle_fs_bad_blocks(e2fsck_t ctx); + static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b); +@@ -178,11 +179,12 @@ int e2fsck_pass1_check_device_inode(ext2_filsys fs EXT2FS_ATTR((unused)), + * Check to make sure a symlink inode is real. Returns 1 if the symlink + * checks out, 0 if not. + */ +-int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, +- struct ext2_inode *inode, char *buf) ++static int check_symlink(e2fsck_t ctx, struct problem_context *pctx, ++ ext2_ino_t ino, struct ext2_inode *inode, char *buf) + { + unsigned int buflen; + unsigned int len; ++ blk64_t blk; + + if ((inode->i_size_high || inode->i_size == 0) || + (inode->i_flags & EXT2_INDEX_FL)) +@@ -193,7 +195,7 @@ int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, + + if (inode->i_flags & EXT4_EXTENTS_FL) + return 0; +- if (ext2fs_inline_data_size(fs, ino, &inline_size)) ++ if (ext2fs_inline_data_size(ctx->fs, ino, &inline_size)) + return 0; + if (inode->i_size != inline_size) + return 0; +@@ -210,11 +212,10 @@ int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, + ext2_extent_handle_t handle; + struct ext2_extent_info info; + struct ext2fs_extent extent; +- blk64_t blk; + int i; + + if (inode->i_flags & EXT4_EXTENTS_FL) { +- if (ext2fs_extent_open2(fs, ino, inode, &handle)) ++ if (ext2fs_extent_open2(ctx->fs, ino, inode, &handle)) + return 0; + if (ext2fs_extent_get_info(handle, &info) || + (info.num_entries != 1) || +@@ -239,29 +240,53 @@ int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, + return 0; + } + +- if (blk < fs->super->s_first_data_block || +- blk >= ext2fs_blocks_count(fs->super)) ++ if (blk < ctx->fs->super->s_first_data_block || ++ blk >= ext2fs_blocks_count(ctx->fs->super)) + return 0; + +- if (io_channel_read_blk64(fs->io, blk, 1, buf)) ++ if (io_channel_read_blk64(ctx->fs->io, blk, 1, buf)) + return 0; + +- buflen = fs->blocksize; ++ buflen = ctx->fs->blocksize; + } + + if (inode->i_flags & EXT4_ENCRYPT_FL) + len = ext2fs_le16_to_cpu(*(__u16 *)buf) + 2; +- else ++ else { + len = strnlen(buf, buflen); + ++ /* Add missing NUL terminator at end of symlink (LU-1540), ++ * but only offer to fix this in pass1, not from pass2. */ ++ if (len > inode->i_size && pctx != NULL && ++ fix_problem(ctx, PR_1_SYMLINK_NUL, pctx)) { ++ buf[inode->i_size] = '\0'; ++ if (ext2fs_is_fast_symlink(inode)) { ++ e2fsck_write_inode(ctx, ino, ++ inode, "check_ext_attr"); ++ } else { ++ if (io_channel_write_blk64(ctx->fs->io, ++ blk, 1, buf)) ++ return 0; ++ } ++ len = inode->i_size; ++ } ++ } ++ + if (len >= buflen) + return 0; + + if (len != inode->i_size) + return 0; ++ + return 1; + } + ++int e2fsck_pass1_check_symlink(e2fsck_t ctx, ext2_ino_t ino, ++ struct ext2_inode *inode, char *buf) ++{ ++ return check_symlink(ctx, NULL, ino, inode, buf); ++} ++ + /* + * If the extents or inlinedata flags are set on the inode, offer to clear 'em. + */ +@@ -433,13 +458,13 @@ static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx, + ea_ibody_quota->inodes = 0; + + inode = (struct ext2_inode_large *) pctx->inode; +- storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE - +- inode->i_extra_isize; ++ storage_size = EXT2_INODE_SIZE(ctx->fs->super) - ++ EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize; + header = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + + inode->i_extra_isize; + end = header + storage_size; +- start = header + sizeof(__u32); +- entry = (struct ext2_ext_attr_entry *) start; ++ entry = &IHDR(inode)->h_first_entry[0]; ++ start = (char *)entry; + + /* scan all entry's headers first */ + +@@ -574,7 +599,7 @@ static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx, + struct ext2_super_block *sb = ctx->fs->super; + struct ext2_inode_large *inode; + __u32 *eamagic; +- int min, max; ++ int min, max, dirty = 0; + + ea_ibody_quota->blocks = 0; + ea_ibody_quota->inodes = 0; +@@ -602,24 +627,38 @@ static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx, + if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx)) + return; + if (inode->i_extra_isize < min || inode->i_extra_isize > max) +- inode->i_extra_isize = sb->s_want_extra_isize; ++ inode->i_extra_isize = ctx->want_extra_isize; + else + inode->i_extra_isize = (inode->i_extra_isize + 3) & ~3; +- e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, +- EXT2_INODE_SIZE(sb), "pass1"); ++ dirty = 1; ++ ++ goto out; + } + + /* check if there is no place for an EA header */ + if (inode->i_extra_isize >= max - sizeof(__u32)) + return; + +- eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + +- inode->i_extra_isize); +- if (*eamagic == EXT2_EXT_ATTR_MAGIC) { +- /* it seems inode has an extended attribute(s) in body */ +- check_ea_in_inode(ctx, pctx, ea_ibody_quota); ++ eamagic = &IHDR(inode)->h_magic; ++ if (*eamagic != EXT2_EXT_ATTR_MAGIC && ++ (ctx->flags & E2F_FLAG_EXPAND_EISIZE) && ++ (inode->i_extra_isize < ctx->want_extra_isize)) { ++ fix_problem(ctx, PR_1_EXPAND_EISIZE, pctx); ++ memset((char *)inode + EXT2_GOOD_OLD_INODE_SIZE, 0, ++ EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE); ++ inode->i_extra_isize = ctx->want_extra_isize; ++ dirty = 1; ++ if (inode->i_extra_isize < ctx->min_extra_isize) ++ ctx->min_extra_isize = inode->i_extra_isize; + } + ++ if (*eamagic == EXT2_EXT_ATTR_MAGIC) ++ check_ea_in_inode(ctx, pctx, ea_ibody_quota); ++ ++ if (EXT4_XTIME_FUTURE(ctx, sb, inode->i_crtime, ctx->time_fudge)) ++ e2fsck_mark_inode_bad(ctx, pctx, PR_1_CRTIME_BAD); ++ else if (EXT4_XTIME_ANCIENT(ctx, sb, inode->i_crtime, ctx->time_fudge)) ++ e2fsck_mark_inode_bad(ctx, pctx, PR_1_CRTIME_BAD); + /* + * If the inode's extended atime (ctime, crtime, mtime) is stored in + * the old, invalid format, repair it. +@@ -632,7 +671,7 @@ static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx, + CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, crtime) || + CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, mtime))) { + +- if (!fix_problem(ctx, PR_1_EA_TIME_OUT_OF_RANGE, pctx)) ++ if (!fix_problem_bad(ctx, PR_1_EA_TIME_OUT_OF_RANGE, pctx, 2)) + return; + + if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, atime)) +@@ -643,10 +682,13 @@ static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx, + inode->i_crtime_extra &= ~EXT4_EPOCH_MASK; + if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, mtime)) + inode->i_mtime_extra &= ~EXT4_EPOCH_MASK; +- e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, +- EXT2_INODE_SIZE(sb), "pass1"); ++ dirty = 1; + } + ++out: ++ if (dirty) ++ e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, ++ EXT2_INODE_SIZE(sb), "pass1"); + } + + static _INLINE_ int is_blocks_used(e2fsck_t ctx, blk64_t block, +@@ -746,7 +788,7 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, + */ + memcpy(&dotdot, inode->i_block, sizeof(dotdot)); + memcpy(&de, ((char *)inode->i_block) + EXT4_INLINE_DATA_DOTDOT_SIZE, +- EXT2_DIR_REC_LEN(0)); ++ EXT2_DIR_NAME_LEN(0)); + dotdot = ext2fs_le32_to_cpu(dotdot); + de.inode = ext2fs_le32_to_cpu(de.inode); + de.rec_len = ext2fs_le16_to_cpu(de.rec_len); +@@ -908,6 +950,150 @@ static errcode_t recheck_bad_inode_checksum(ext2_filsys fs, ext2_ino_t ino, + return retval; + } + ++int e2fsck_pass1_delete_attr(e2fsck_t ctx, struct ext2_inode_large *inode, ++ struct problem_context *pctx, int needed_size) ++{ ++ struct ext2_ext_attr_header *header; ++ struct ext2_ext_attr_entry *entry_ino, *entry_blk = NULL, *entry; ++ char *start, name[4096], block_buf[4096]; ++ int len, index = EXT2_ATTR_INDEX_USER, entry_size, ea_size; ++ int in_inode = 1, error; ++ unsigned int freed_bytes = inode->i_extra_isize; ++ ++ entry_ino = &IHDR(inode)->h_first_entry[0]; ++ start = (char *)entry_ino; ++ ++ if (inode->i_file_acl) { ++ error = ext2fs_read_ext_attr(ctx->fs, inode->i_file_acl, ++ block_buf); ++ /* We have already checked this block, shouldn't happen */ ++ if (error) { ++ fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, pctx); ++ return 0; ++ } ++ header = BHDR(block_buf); ++ if (header->h_magic != EXT2_EXT_ATTR_MAGIC) { ++ fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, pctx); ++ return 0; ++ } ++ ++ entry_blk = (struct ext2_ext_attr_entry *)(header+1); ++ } ++ entry = entry_ino; ++ len = sizeof(entry->e_name); ++ entry_size = ext2fs_attr_get_next_attr(entry, index, name, len, 1); ++ ++ while (freed_bytes < needed_size) { ++ if (entry_size && name[0] != '\0') { ++ pctx->str = name; ++ if (fix_problem(ctx, PR_1_EISIZE_DELETE_EA, pctx)) { ++ ea_size = EXT2_EXT_ATTR_LEN(entry->e_name_len) + ++ EXT2_EXT_ATTR_SIZE(entry->e_value_size); ++ error = ext2fs_attr_set(ctx->fs, pctx->ino, ++ (struct ext2_inode *)inode, ++ index, name, 0, 0, 0); ++ if (!error) ++ freed_bytes += ea_size; ++ } ++ } ++ len = sizeof(entry->e_name); ++ entry_size = ext2fs_attr_get_next_attr(entry, index,name,len,0); ++ entry = EXT2_EXT_ATTR_NEXT(entry); ++ if (EXT2_EXT_IS_LAST_ENTRY(entry)) { ++ if (in_inode) { ++ entry = entry_blk; ++ len = sizeof(entry->e_name); ++ entry_size = ext2fs_attr_get_next_attr(entry, ++ index, name, len, 1); ++ in_inode = 0; ++ } else { ++ index += 1; ++ in_inode = 1; ++ if (!entry && index < EXT2_ATTR_INDEX_MAX) ++ entry = (struct ext2_ext_attr_entry *)start; ++ else ++ return freed_bytes; ++ } ++ } ++ } ++ ++ return freed_bytes; ++} ++ ++int e2fsck_pass1_expand_eisize(e2fsck_t ctx, struct ext2_inode_large *inode, ++ struct problem_context *pctx) ++{ ++ int needed_size = 0, retval, ret = EXT2_EXPAND_EISIZE_UNSAFE; ++ static int message; ++ ++retry: ++ retval = ext2fs_expand_extra_isize(ctx->fs, pctx->ino, inode, ++ ctx->want_extra_isize, &ret, ++ &needed_size); ++ if (ret & EXT2_EXPAND_EISIZE_NEW_BLOCK) ++ goto mark_expand_eisize_map; ++ if (!retval) { ++ e2fsck_write_inode_full(ctx, pctx->ino, ++ (struct ext2_inode *)inode, ++ EXT2_INODE_SIZE(ctx->fs->super), ++ "pass1"); ++ return 0; ++ } ++ ++ if (ret & EXT2_EXPAND_EISIZE_NOSPC) { ++ if (ctx->options & (E2F_OPT_PREEN | E2F_OPT_YES)) { ++ fix_problem(ctx, PR_1_EA_BLK_NOSPC, pctx); ++ ctx->flags |= E2F_FLAG_ABORT; ++ return -1; ++ } ++ ++ if (!message) { ++ pctx->num = ctx->fs->super->s_min_extra_isize; ++ fix_problem(ctx, PR_1_EXPAND_EISIZE_WARNING, pctx); ++ message = 1; ++ } ++delete_EA: ++ retval = e2fsck_pass1_delete_attr(ctx, inode, pctx, ++ needed_size); ++ if (retval >= ctx->want_extra_isize) ++ goto retry; ++ ++ needed_size -= retval; ++ ++ /* ++ * We loop here until either the user deletes EA(s) or ++ * EXTRA_ISIZE feature is disabled. ++ */ ++ if (fix_problem(ctx, PR_1_CLEAR_EXTRA_ISIZE, pctx)) { ++ ctx->fs->super->s_feature_ro_compat &= ++ ~EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE; ++ ext2fs_mark_super_dirty(ctx->fs); ++ } else { ++ goto delete_EA; ++ } ++ ctx->fs_unexpanded_inodes++; ++ ++ /* No EA was deleted, inode cannot be expanded */ ++ return -1; ++ } ++ ++mark_expand_eisize_map: ++ if (!ctx->expand_eisize_map) { ++ pctx->errcode = ext2fs_allocate_inode_bitmap(ctx->fs, ++ _("expand extrz isize map"), ++ &ctx->expand_eisize_map); ++ if (pctx->errcode) { ++ fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, ++ pctx); ++ exit(1); ++ } ++ } ++ ++ /* Add this inode to the expand_eisize_map */ ++ ext2fs_mark_inode_bitmap2(ctx->expand_eisize_map, pctx->ino); ++ return 0; ++} ++ + static void reserve_block_for_root_repair(e2fsck_t ctx) + { + blk64_t blk = 0; +@@ -969,6 +1155,28 @@ err: + return retval; + } + ++int e2fsck_fix_bad_inode(e2fsck_t ctx, struct problem_context *pctx) ++{ ++ __u16 badness; ++ int rc = 0; ++ ++ if (!ctx->inode_badness) ++ return 0; ++ ++ if (ext2fs_icount_fetch(ctx->inode_badness, pctx->ino, &badness)) ++ return 0; ++ ++ if ((badness & ~BADNESS_BAD_MODE) > ctx->inode_badness_threshold) { ++ __u64 pctx_num_sav = pctx->num; ++ ++ pctx->num = badness; ++ rc = fix_problem_bad(ctx, PR_1B_INODE_TOOBAD, pctx, 0); ++ pctx->num = pctx_num_sav; ++ } ++ ++ return rc; ++} ++ + static void finish_processing_inode(e2fsck_t ctx, ext2_ino_t ino, + struct problem_context *pctx, + int failed_csum) +@@ -988,7 +1196,7 @@ static void finish_processing_inode(e2fsck_t ctx, ext2_ino_t ino, + #define FINISH_INODE_LOOP(ctx, ino, pctx, failed_csum) \ + do { \ + finish_processing_inode((ctx), (ino), (pctx), (failed_csum)); \ +- if ((ctx)->flags & E2F_FLAG_ABORT) { \ ++ if (e2fsck_should_abort(ctx)) { \ + e2fsck_pass1_check_unlock(ctx); \ + return; \ + } \ +@@ -1476,9 +1684,25 @@ static void e2fsck_pass1_post(e2fsck_t ctx) + } + + ++/* ++ * Lustre FS creates special inodes - precreated objects. ++ * They are zero-sized and have special attributes: ++ * mode |= S_ISUID | S_ISGID; ++ * valid |= LA_ATIME | LA_MTIME | LA_CTIME; ++ * atime = 0; ++ * mtime = 0; ++ * ctime = 0; ++ */ ++static int precreated_object(struct ext2_inode *inode) ++{ ++ if (((inode->i_mode & (S_ISUID | S_ISGID)) == (S_ISUID | S_ISGID)) && ++ inode->i_ctime == 0) ++ return 1; ++ return 0; ++} ++ + void e2fsck_pass1_run(e2fsck_t ctx) + { +- int i; + ext2_filsys fs = ctx->fs; + ext2_ino_t ino = 0; + struct ext2_inode *inode = NULL; +@@ -1502,8 +1726,9 @@ void e2fsck_pass1_run(e2fsck_t ctx) + dgrp_t ra_group = 0; + struct ea_quota ea_ibody_quota; + struct process_inode_block *inodes_to_process; +- int process_inode_count, check_mmp; ++ int process_inode_count, check_mmp = 0; + e2fsck_t global_ctx = ctx->global_ctx ? ctx->global_ctx : ctx; ++ int inode_exp = 0; + + init_resource_track(&rtrack, ctx->fs->io); + clear_problem_context(&pctx); +@@ -1652,9 +1877,8 @@ void e2fsck_pass1_run(e2fsck_t ctx) + if (ctx->global_ctx) { + if (ctx->options & E2F_OPT_DEBUG && + ctx->options & E2F_OPT_MULTITHREAD) +- fprintf(stderr, "thread %d jumping to group %u\n", +- ctx->thread_info.et_thread_index, +- ctx->thread_info.et_group_start); ++ log_out(ctx, "jumping to group %u\n", ++ ctx->thread_info.et_group_start); + pctx.errcode = ext2fs_inode_scan_goto_blockgroup(scan, + ctx->thread_info.et_group_start); + if (pctx.errcode) { +@@ -1990,6 +2214,7 @@ void e2fsck_pass1_run(e2fsck_t ctx) + void *ehp; + #ifdef WORDS_BIGENDIAN + __u32 tmp_block[EXT2_N_BLOCKS]; ++ int i; + + for (i = 0; i < EXT2_N_BLOCKS; i++) + tmp_block[i] = ext2fs_swab32(inode->i_block[i]); +@@ -2209,18 +2434,21 @@ void e2fsck_pass1_run(e2fsck_t ctx) + frag = fsize = 0; + } + ++ /* Fixed in pass2, e2fsck_process_bad_inode(). */ + if (inode->i_faddr || frag || fsize || + (!ext2fs_has_feature_largedir(fs->super) && +- (LINUX_S_ISDIR(inode->i_mode) && inode->i_size_high))) +- mark_inode_bad(ctx, ino); ++ LINUX_S_ISDIR(inode->i_mode) && inode->i_size_high)) ++ e2fsck_mark_inode_bad(ctx, &pctx, ++ PR_2_DIR_SIZE_HIGH_ZERO); + if ((fs->super->s_creator_os != EXT2_OS_HURD) && + !ext2fs_has_feature_64bit(fs->super) && + inode->osd2.linux2.l_i_file_acl_high != 0) +- mark_inode_bad(ctx, ino); ++ e2fsck_mark_inode_bad(ctx, &pctx, ++ PR_2_I_FILE_ACL_HI_ZERO); + if ((fs->super->s_creator_os != EXT2_OS_HURD) && + !ext2fs_has_feature_huge_file(fs->super) && + (inode->osd2.linux2.l_i_blocks_hi != 0)) +- mark_inode_bad(ctx, ino); ++ e2fsck_mark_inode_bad(ctx, &pctx, PR_2_BLOCKS_HI_ZERO); + if (inode->i_flags & EXT2_IMAGIC_FL) { + if (imagic_fs) { + if (!ctx->inode_imagic_map) +@@ -2282,8 +2510,7 @@ void e2fsck_pass1_run(e2fsck_t ctx) + check_size(ctx, &pctx); + ctx->fs_blockdev_count++; + } else if (LINUX_S_ISLNK (inode->i_mode) && +- e2fsck_pass1_check_symlink(fs, ino, inode, +- block_buf)) { ++ check_symlink(ctx, &pctx, ino, inode, block_buf)) { + check_immutable(ctx, &pctx); + ctx->fs_symlinks_count++; + if (inode->i_flags & EXT4_INLINE_DATA_FL) { +@@ -2311,8 +2538,37 @@ void e2fsck_pass1_run(e2fsck_t ctx) + check_immutable(ctx, &pctx); + check_size(ctx, &pctx); + ctx->fs_sockets_count++; +- } else +- mark_inode_bad(ctx, ino); ++ } else { ++ e2fsck_mark_inode_bad(ctx, &pctx, PR_2_BAD_MODE); ++ } ++ ++ /* Future atime/mtime may be valid in rare cases, but are more ++ * likely to indicate corruption. Don't try to fix timestamps, ++ * but take into consideration whether inode is corrupted. If ++ * no other problems with the inode, probably it is OK. */ ++ if (EXT4_XTIME_FUTURE(ctx, sb, inode->i_atime, ctx->time_fudge)) ++ e2fsck_mark_inode_bad(ctx, &pctx, PR_1_INODE_BAD_TIME); ++ if (EXT4_XTIME_FUTURE(ctx, sb, inode->i_mtime, ctx->time_fudge)) ++ e2fsck_mark_inode_bad(ctx, &pctx, PR_1_INODE_BAD_TIME); ++ ++ /* Since ctime cannot be set directly from userspace, consider ++ * very old/future values worse than a bad atime/mtime. Same for ++ * crtime, but it is checked in check_inode_extra_space(). */ ++ if (EXT4_XTIME_FUTURE(ctx, sb, inode->i_ctime, ctx->time_fudge)) ++ e2fsck_mark_inode_badder(ctx, &pctx, ++ PR_1_INODE_BAD_TIME); ++ else if (!precreated_object(inode) && ++ EXT4_XTIME_ANCIENT(ctx, sb, inode->i_ctime, ++ ctx->time_fudge)) ++ e2fsck_mark_inode_badder(ctx, &pctx, ++ PR_1_INODE_BAD_TIME); ++ ++ /* no restart if clearing bad inode before block processing */ ++ if (e2fsck_fix_bad_inode(ctx, &pctx)) { ++ e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); ++ goto next_unlock; ++ } ++ + if (!(inode->i_flags & EXT4_EXTENTS_FL) && + !(inode->i_flags & EXT4_INLINE_DATA_FL)) { + if (inode->i_block[EXT2_IND_BLOCK]) +@@ -2343,6 +2599,22 @@ void e2fsck_pass1_run(e2fsck_t ctx) + + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + ++ if (ctx->flags & E2F_FLAG_EXPAND_EISIZE) { ++ struct ext2_inode_large *inode_l; ++ ++ inode_l = (struct ext2_inode_large *)inode; ++ ++ if (inode_l->i_extra_isize < ctx->want_extra_isize) { ++ fix_problem(ctx, PR_1_EXPAND_EISIZE, &pctx); ++ inode_exp = e2fsck_pass1_expand_eisize(ctx, ++ inode_l, ++ &pctx); ++ } ++ if ((inode_l->i_extra_isize < ctx->min_extra_isize) && ++ inode_exp == 0) ++ ctx->min_extra_isize = inode_l->i_extra_isize; ++ } ++ + if (e2fsck_should_abort(ctx)) { + e2fsck_pass1_check_unlock(ctx); + goto endit; +@@ -2357,6 +2629,7 @@ void e2fsck_pass1_run(e2fsck_t ctx) + goto endit; + } + } ++ next_unlock: + e2fsck_pass1_check_unlock(ctx); + } + process_inodes(ctx, block_buf, inodes_to_process, +@@ -2374,9 +2647,6 @@ void e2fsck_pass1_run(e2fsck_t ctx) + ctx->ea_block_quota_inodes = 0; + } + +- /* We don't need the encryption policy => ID map any more */ +- destroy_encryption_policy_map(ctx); +- + if (ctx->flags & E2F_FLAG_RESTART) { + /* + * Only the master copy of the superblock and block +@@ -2669,7 +2939,6 @@ static void e2fsck_pass1_copy_invalid_bitmaps(e2fsck_t global_ctx, + static void e2fsck_pass1_merge_invalid_bitmaps(e2fsck_t global_ctx, + e2fsck_t thread_ctx) + { +- dgrp_t i, j; + dgrp_t grp_start = thread_ctx->thread_info.et_group_start; + dgrp_t grp_end = thread_ctx->thread_info.et_group_end; + dgrp_t total = grp_end - grp_start; +@@ -2714,6 +2983,8 @@ static errcode_t e2fsck_pass1_thread_prepare(e2fsck_t global_ctx, e2fsck_t *thre + memcpy(thread_context, global_ctx, sizeof(struct e2fsck_struct)); + thread_context->block_dup_map = NULL; + thread_context->casefolded_dirs = NULL; ++ thread_context->expand_eisize_map = NULL; ++ thread_context->inode_badness = NULL; + + retval = e2fsck_allocate_block_bitmap(global_ctx->fs, + _("in-use block map"), EXT2FS_BMAP64_RBTREE, +@@ -2802,6 +3073,23 @@ static void e2fsck_pass1_merge_dx_dir(e2fsck_t global_ctx, e2fsck_t thread_ctx) + e2fsck_merge_dx_dir(global_ctx, thread_ctx); + } + ++static int e2fsck_pass1_merge_encrypted_info(e2fsck_t global_ctx, ++ e2fsck_t thread_ctx) ++{ ++ if (thread_ctx->encrypted_files == NULL) ++ return 0; ++ ++ if (global_ctx->encrypted_files == NULL) { ++ global_ctx->encrypted_files = thread_ctx->encrypted_files; ++ thread_ctx->encrypted_files = NULL; ++ return 0; ++ } ++ ++ return e2fsck_merge_encrypted_info(global_ctx, ++ thread_ctx->encrypted_files, ++ global_ctx->encrypted_files); ++} ++ + static inline errcode_t + e2fsck_pass1_merge_icount(ext2_icount_t *dest_icount, + ext2_icount_t *src_icount) +@@ -2833,6 +3121,11 @@ static errcode_t e2fsck_pass1_merge_icounts(e2fsck_t global_ctx, e2fsck_t thread + return ret; + ret = e2fsck_pass1_merge_icount(&global_ctx->inode_link_info, + &thread_ctx->inode_link_info); ++ if (ret) ++ return ret; ++ ++ ret = e2fsck_pass1_merge_icount(&global_ctx->inode_badness, ++ &thread_ctx->inode_badness); + + return ret; + } +@@ -3062,6 +3355,12 @@ static errcode_t e2fsck_pass1_merge_context(e2fsck_t global_ctx, + + e2fsck_pass1_merge_dir_info(global_ctx, thread_ctx); + e2fsck_pass1_merge_dx_dir(global_ctx, thread_ctx); ++ retval = e2fsck_pass1_merge_encrypted_info(global_ctx, thread_ctx); ++ if (retval) { ++ com_err(global_ctx->program_name, 0, ++ _("while merging encrypted info\n")); ++ return retval; ++ } + + retval = e2fsck_pass1_merge_fs(global_ctx->fs, thread_ctx->fs); + if (retval) { +@@ -3098,17 +3397,15 @@ static errcode_t e2fsck_pass1_merge_context(e2fsck_t global_ctx, + + e2fsck_pass1_merge_invalid_bitmaps(global_ctx, thread_ctx); + ++ if (thread_ctx->min_extra_isize < global_ctx->min_extra_isize) ++ global_ctx->min_extra_isize = thread_ctx->min_extra_isize; ++ + retval = e2fsck_pass1_merge_bitmap(global_fs, + &thread_ctx->inode_used_map, + &global_ctx->inode_used_map); + if (retval) + return retval; + +- retval = e2fsck_pass1_merge_bitmap(global_fs, +- &thread_ctx->inode_bad_map, +- &global_ctx->inode_bad_map); +- if (retval) +- return retval; + retval = e2fsck_pass1_merge_bitmap(global_fs, + &thread_ctx->inode_dir_map, + &global_ctx->inode_dir_map); +@@ -3140,6 +3437,12 @@ static errcode_t e2fsck_pass1_merge_context(e2fsck_t global_ctx, + if (retval) + return retval; + ++ retval = e2fsck_pass1_merge_bitmap(global_fs, ++ &thread_ctx->expand_eisize_map, ++ &global_ctx->expand_eisize_map); ++ if (retval) ++ return retval; ++ + if (ext2fs_has_feature_shared_blocks(global_fs->super) && + !(global_ctx->options & E2F_OPT_UNSHARE_BLOCKS)) + return 0; +@@ -3568,27 +3871,43 @@ static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b) + } + + /* +- * Mark an inode as being bad in some what ++ * Mark an inode as being bad and increment its badness counter. + */ +-static void mark_inode_bad(e2fsck_t ctx, ino_t ino) ++void e2fsck_mark_inode_bad_loc(e2fsck_t ctx, struct problem_context *pctx, ++ __u32 code, int badness, const char *func, ++ const int line) + { +- struct problem_context pctx; ++ __u16 badness_before, badness_after; + +- if (!ctx->inode_bad_map) { +- clear_problem_context(&pctx); ++ if (!ctx->inode_badness_threshold) /* badness is disabled */ ++ return; + +- pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs, +- _("bad inode map"), EXT2FS_BMAP64_RBTREE, +- "inode_bad_map", &ctx->inode_bad_map); +- if (pctx.errcode) { +- pctx.num = 3; +- fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); +- /* Should never get here */ ++ if (!ctx->inode_badness) { ++ errcode_t retval; ++ ++ retval = ext2fs_create_icount2(ctx->fs, 0, 0, NULL, ++ &ctx->inode_badness); ++ if (retval) { ++ pctx->errcode = retval; ++ fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } + } +- ext2fs_mark_inode_bitmap2(ctx->inode_bad_map, ino); ++ ext2fs_icount_fetch(ctx->inode_badness, pctx->ino, &badness_before); ++ if (badness + badness_before > BADNESS_MAX) ++ badness_after = BADNESS_MAX; ++ else if (badness < 0 && badness_before < -badness) ++ badness_after = 0; ++ else ++ badness_after = badness_before + badness; ++ ext2fs_icount_store(ctx->inode_badness, pctx->ino, badness_after); ++ ++ if (ctx->options & E2F_OPT_DEBUG) ++ log_out(ctx, ++ "%s:%d: increase inode %lu badness %u to %u for %x\n", ++ func, line, (unsigned long)pctx->ino, badness_before, ++ badness_after, code); + } + + static void add_casefolded_dir(e2fsck_t ctx, ino_t ino) +@@ -3732,11 +4051,17 @@ static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, + pctx.blk = blk; + pctx.errcode = ext2fs_read_ext_attr3(fs, blk, block_buf, + pctx.ino); ++ /* We already checked this block, shouldn't happen */ + if (pctx.errcode) { + fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx); + return; + } +- header = (struct ext2_ext_attr_header *) block_buf; ++ header = BHDR(block_buf); ++ if (header->h_magic != EXT2_EXT_ATTR_MAGIC) { ++ fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx); ++ return; ++ } ++ + pctx.blkcount = header->h_refcount; + should_be = header->h_refcount + adjust_sign * (int)count; + pctx.num = should_be; +@@ -3789,7 +4114,8 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, + if (!ext2fs_has_feature_xattr(fs->super) || + (blk < fs->super->s_first_data_block) || + (blk >= ext2fs_blocks_count(fs->super))) { +- mark_inode_bad(ctx, ino); ++ /* Fixed in pass2, e2fsck_process_bad_inode(). */ ++ e2fsck_mark_inode_bad(ctx, pctx, PR_2_FILE_ACL_ZERO); + return 0; + } + +@@ -3882,7 +4208,7 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, + pctx->errcode = 0; + goto clear_extattr; + } +- header = (struct ext2_ext_attr_header *) block_buf; ++ header = BHDR(block_buf); + pctx->blk = ext2fs_file_acl_block(fs, inode); + if (((ctx->ext_attr_ver == 1) && + (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) || +@@ -4069,11 +4395,13 @@ static int handle_htree(e2fsck_t ctx, struct problem_context *pctx, + } + + retval = io_channel_read_blk64(fs->io, blk, 1, block_buf); +- if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) +- return 1; ++ if (retval) { ++ if (fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) ++ return 1; ++ } + + /* XXX should check that beginning matches a directory */ +- root = (struct ext2_dx_root_info *) (block_buf + 24); ++ root = get_ext2_dx_root_info(fs, block_buf); + + if ((root->reserved_zero || root->info_length < 8) && + fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) +@@ -4152,8 +4480,8 @@ void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino, + ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino); + if (ctx->inode_reg_map) + ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino); +- if (ctx->inode_bad_map) +- ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino); ++ if (ctx->inode_badness) ++ ext2fs_icount_store(ctx->inode_badness, ino, 0); + + /* + * If the inode was partially accounted for before processing +@@ -4325,7 +4653,9 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, + #endif + if (try_repairs && problem) { + report_problem: +- if (fix_problem(ctx, problem, pctx)) { ++ /* Record badness only if extent is within inode */ ++ if (fix_problem_bad(ctx, problem, pctx, ++ info.curr_level == 0)) { + if (ctx->invalid_bitmaps) { + /* + * If fsck knows the bitmaps are bad, +@@ -4394,9 +4724,9 @@ report_problem: + extent.e_pblk)) { + next_try_repairs = 0; + pctx->blk = blk; +- fix_problem(ctx, ++ fix_problem_bad(ctx, + PR_1_CRITICAL_METADATA_COLLISION, +- pctx); ++ pctx, 2); + if ((ctx->options & E2F_OPT_NO) == 0) + ctx->flags |= E2F_FLAG_RESTART_LATER; + } +@@ -4880,6 +5210,10 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, + + if (!pb.num_blocks && pb.is_dir && + !(inode->i_flags & EXT4_INLINE_DATA_FL)) { ++ /* ++ * The mode might be in-correct. Increasing the badness by ++ * small amount won't hurt much. ++ */ + if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) { + e2fsck_clear_inode(ctx, ino, inode, 0, "check_blocks"); + ctx->fs_directory_count--; +@@ -5012,7 +5346,11 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, + e2fsck_rehash_dir_later(ctx, ino); + + out: +- if (dirty_inode) ++ /* need restart if clearing bad inode after block processing */ ++ if (e2fsck_fix_bad_inode(ctx, pctx)) ++ e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART, ++ "check_blocks_bad"); ++ else if (dirty_inode) + e2fsck_write_inode(ctx, ino, inode, "check_blocks"); + } + +@@ -5164,7 +5502,7 @@ static int process_block(ext2_filsys fs, + blk < ctx->fs->super->s_blocks_count && + ext2fs_test_block_bitmap2(ctx->block_metadata_map, blk)) { + pctx->blk = blk; +- fix_problem(ctx, PR_1_CRITICAL_METADATA_COLLISION, pctx); ++ fix_problem_bad(ctx, PR_1_CRITICAL_METADATA_COLLISION, pctx, 2); + if ((ctx->options & E2F_OPT_NO) == 0) + ctx->flags |= E2F_FLAG_RESTART_LATER; + } +diff --git a/e2fsck/pass1b.c b/e2fsck/pass1b.c +index 92c746c..11c179e 100644 +--- a/e2fsck/pass1b.c ++++ b/e2fsck/pass1b.c +@@ -341,6 +341,14 @@ static void pass1b(e2fsck_t ctx, char *block_buf) + pb.last_blk = 0; + pb.pctx->blk = pb.pctx->blk2 = 0; + ++ if (e2fsck_fix_bad_inode(ctx, &pctx)) { ++ struct dup_inode dp = { .inode = inode }; ++ ++ /* delete_file only uses dp.inode */ ++ delete_file(ctx, ino, &dp, block_buf); ++ continue; ++ } ++ + if (ext2fs_inode_has_valid_blocks2(fs, EXT2_INODE(&inode)) || + (ino == EXT2_BAD_INO)) + pctx.errcode = ext2fs_block_iterate3(fs, ino, +@@ -542,6 +550,9 @@ static void pass1d(e2fsck_t ctx, char *block_buf) + q = (struct dup_cluster *) dnode_get(m); + if (q->num_bad > 1) + file_ok = 0; ++ if (q->num_bad == 1 && (ctx->clone == E2F_CLONE_ZERO || ++ ctx->shared != E2F_SHARED_PRESERVE)) ++ file_ok = 0; + if (check_if_fs_cluster(ctx, s->cluster)) { + file_ok = 0; + meta_data = 1; +@@ -573,7 +584,7 @@ static void pass1d(e2fsck_t ctx, char *block_buf) + pctx.dir = p->dir; + pctx.blkcount = p->num_dupblocks; + pctx.num = meta_data ? shared_len+1 : shared_len; +- fix_problem(ctx, PR_1D_DUP_FILE, &pctx); ++ fix_problem_bad(ctx, PR_1D_DUP_FILE, &pctx, pctx.blkcount / 2); + pctx.blkcount = 0; + pctx.num = 0; + +@@ -591,24 +602,37 @@ static void pass1d(e2fsck_t ctx, char *block_buf) + pctx.inode = EXT2_INODE(&t->inode); + pctx.ino = shared[i]; + pctx.dir = t->dir; +- fix_problem(ctx, PR_1D_DUP_FILE_LIST, &pctx); ++ fix_problem_bad(ctx, PR_1D_DUP_FILE_LIST, &pctx, 0); + } + /* + * Even if the file shares blocks with itself, we still need to + * clone the blocks. + */ + if (file_ok && (meta_data ? shared_len+1 : shared_len) != 0) { +- fix_problem(ctx, PR_1D_DUP_BLOCKS_DEALT, &pctx); ++ fix_problem_bad(ctx, PR_1D_DUP_BLOCKS_DEALT, &pctx, 0); + continue; + } +- if ((ctx->options & E2F_OPT_UNSHARE_BLOCKS) || +- fix_problem(ctx, PR_1D_CLONE_QUESTION, &pctx)) { ++ if (ctx->shared != E2F_SHARED_DELETE && ++ ((ctx->options & E2F_OPT_UNSHARE_BLOCKS) || ++ fix_problem(ctx, PR_1D_CLONE_QUESTION, &pctx))) { + pctx.errcode = clone_file(ctx, ino, p, block_buf); +- if (pctx.errcode) ++ if (pctx.errcode) { + fix_problem(ctx, PR_1D_CLONE_ERROR, &pctx); +- else +- continue; ++ goto delete; ++ } ++ if (ctx->shared == E2F_SHARED_LPF && ++ fix_problem(ctx, PR_1D_DISCONNECT_QUESTION, &pctx)){ ++ pctx.errcode = ext2fs_unlink(fs, p->dir, ++ NULL, ino, 0); ++ if (pctx.errcode) { ++ fix_problem(ctx, PR_1D_DISCONNECT_ERROR, ++ &pctx); ++ goto delete; ++ } ++ } ++ continue; + } ++delete: + /* + * Note: When unsharing blocks, we don't prompt to delete + * files. If the clone operation fails than the unshare +@@ -632,7 +656,8 @@ static void decrement_badcount(e2fsck_t ctx, blk64_t block, + { + p->num_bad--; + if (p->num_bad <= 0 || +- (p->num_bad == 1 && !check_if_fs_block(ctx, block))) { ++ (p->num_bad == 1 && !check_if_fs_block(ctx, block) && ++ ctx->clone == E2F_CLONE_DUP)) { + if (check_if_fs_cluster(ctx, EXT2FS_B2C(ctx->fs, block))) + return; + ext2fs_unmark_block_bitmap2(ctx->block_dup_map, block); +@@ -704,8 +729,6 @@ static void delete_file(e2fsck_t ctx, ext2_ino_t ino, + delete_file_block, &pb); + if (pctx.errcode) + fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx); +- if (ctx->inode_bad_map) +- ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino); + if (ctx->inode_reg_map) + ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino); + ext2fs_unmark_inode_bitmap2(ctx->inode_dir_map, ino); +@@ -783,6 +806,12 @@ static void deferred_dec_badcount(struct clone_struct *cs) + if (!cs->save_dup_cluster) + return; + decrement_badcount(cs->ctx, cs->save_blocknr, cs->save_dup_cluster); ++ if (cs->ctx->clone == E2F_CLONE_ZERO && ++ cs->save_dup_cluster->num_bad == 0) { ++ ext2fs_unmark_block_bitmap2(cs->ctx->block_found_map, ++ cs->save_blocknr); ++ ext2fs_block_alloc_stats(cs->ctx->fs, cs->save_blocknr, -1); ++ } + cs->save_dup_cluster = NULL; + } + +@@ -882,10 +911,15 @@ cluster_alloc_ok: + blockcnt, (unsigned long long) *block_nr, + (unsigned long long) new_block); + #endif +- retval = io_channel_read_blk64(fs->io, *block_nr, 1, cs->buf); +- if (retval) { +- cs->errcode = retval; +- return BLOCK_ABORT; ++ if (ctx->clone == E2F_CLONE_ZERO) { ++ memset(cs->buf, 0, fs->blocksize); ++ } else { ++ retval = io_channel_read_blk64(fs->io, *block_nr, 1, ++ cs->buf); ++ if (retval) { ++ cs->errcode = retval; ++ return BLOCK_ABORT; ++ } + } + if (should_write) { + retval = io_channel_write_blk64(fs->io, new_block, 1, cs->buf); +diff --git a/e2fsck/pass2.c b/e2fsck/pass2.c +index 3b473af..505414e 100644 +--- a/e2fsck/pass2.c ++++ b/e2fsck/pass2.c +@@ -33,16 +33,16 @@ + * Pass 2 relies on the following information from previous passes: + * - The directory information collected in pass 1. + * - The inode_used_map bitmap +- * - The inode_bad_map bitmap ++ * - The inode_badness bitmap + * - The inode_dir_map bitmap + * - The encrypted_file_info + * - The inode_casefold_map bitmap + * + * Pass 2 frees the following data structures +- * - The inode_bad_map bitmap + * - The inode_reg_map bitmap + * - The encrypted_file_info + * - The inode_casefold_map bitmap ++ * - The inode_badness bitmap + */ + + #define _GNU_SOURCE 1 /* get strnlen() */ +@@ -281,10 +281,6 @@ void e2fsck_pass2(e2fsck_t ctx) + ext2fs_free_mem(&buf); + ext2fs_free_dblist(fs->dblist); + +- if (ctx->inode_bad_map) { +- ext2fs_free_inode_bitmap(ctx->inode_bad_map); +- ctx->inode_bad_map = 0; +- } + if (ctx->inode_reg_map) { + ext2fs_free_inode_bitmap(ctx->inode_reg_map); + ctx->inode_reg_map = 0; +@@ -298,6 +294,10 @@ void e2fsck_pass2(e2fsck_t ctx) + ext2fs_u32_list_free(ctx->casefolded_dirs); + ctx->casefolded_dirs = 0; + } ++ if (ctx->inode_badness) { ++ ext2fs_free_icount(ctx->inode_badness); ++ ctx->inode_badness = 0; ++ } + + clear_problem_context(&pctx); + if (ctx->large_files) { +@@ -393,13 +393,88 @@ static EXT2_QSORT_TYPE special_dir_block_cmp(const void *a, const void *b) + return (int) (db_a->blockcnt - db_b->blockcnt); + } + ++void ext2_fix_dirent_dirdata(struct ext2_dir_entry *de) ++{ ++ __u16 file_type = de->name_len & (EXT2_FT_MASK << 8); ++ __u8 de_flags = (de->name_len >> 8) & ~EXT2_FT_MASK; ++ __u8 name_len = de->name_len & EXT2_NAME_LEN; ++ __u8 new_flag = 0; ++ int i; ++ ++ for (i = 0; i < 4; i++) { ++ __u8 flags = new_flag | (1 << i) << 4; ++ ++ /* new_flag is accumulating flags that are set in de_flags ++ * and still fit inside rec_len. ext2_get_dirent_dirdata_size() ++ * returns the size of all the dirdata entries in flags, and ++ * chops off any that are beyond rec_len. ++ */ ++ if ((de_flags & flags) == flags) { ++ int dirdatalen = ext2_get_dirdata_field_size(de, ++ flags); ++ int rlen = EXT2_DIR_NAME_LEN(name_len + dirdatalen); ++ ++ if (rlen > de->rec_len) ++ break; ++ ++ new_flag |= flags; ++ } ++ } ++ ++ de->name_len = name_len | file_type | (new_flag << 8); ++} ++ ++/* ++ * check for dirent data in ext3 dirent. ++ * return 0 if dirent data is ok. ++ * return 1 if dirent data does not exist. ++ * return 2 if dirent was modified due to error. ++ */ ++int e2fsck_check_dirent_data(e2fsck_t ctx, struct ext2_dir_entry *de, ++ unsigned int offset, struct problem_context *pctx) ++{ ++ if (!(ctx->fs->super->s_feature_incompat & ++ EXT4_FEATURE_INCOMPAT_DIRDATA)) { ++ if ((de->name_len >> 8) & ~EXT2_FT_MASK) { ++ /* clear dirent extra data flags. */ ++ if (fix_problem(ctx, PR_2_CLEAR_DIRDATA, pctx)) { ++ de->name_len &= (EXT2_FT_MASK << 8) | ++ EXT2_NAME_LEN; ++ return 2; ++ } ++ } ++ return 1; ++ } ++ if ((de->name_len >> 8) & ~EXT2_FT_MASK) { ++ if (de->rec_len >= EXT2_DIR_REC_LEN(de) || ++ de->rec_len + offset == EXT2_BLOCK_SIZE(ctx->fs->super)) { ++ if (ext2_get_dirdata_field_size(de, ++ EXT2_DIRENT_LUFID) % ++ EXT2_DIRENT_LUFID_SIZE == 1 /*size*/ + 1 /*NULL*/) ++ return 0; ++ } ++ /* just clear dirent data flags for now, we should fix FID data ++ * in lustre specific pass. ++ */ ++ if (fix_problem(ctx, PR_2_CLEAR_DIRDATA, pctx)) { ++ ext2_fix_dirent_dirdata(de); ++ if (ext2_get_dirdata_field_size(de, ++ EXT2_DIRENT_LUFID) != ++ EXT2_DIRENT_LUFID_SIZE) ++ de->name_len &= ~(EXT2_DIRENT_LUFID << 8); ++ ++ return 2; ++ } ++ } ++ return 1; ++} + + /* + * Make sure the first entry in the directory is '.', and that the + * directory entry is sane. + */ + static int check_dot(e2fsck_t ctx, +- struct ext2_dir_entry *dirent, ++ struct ext2_dir_entry *dirent, unsigned int offset, + ext2_ino_t ino, struct problem_context *pctx) + { + struct ext2_dir_entry *nextdir; +@@ -407,6 +482,7 @@ static int check_dot(e2fsck_t ctx, + int status = 0; + int created = 0; + problem_t problem = 0; ++ int dir_data_error; + int ftype = EXT2_FT_DIR; + + if (!dirent->inode) +@@ -417,6 +493,8 @@ static int check_dot(e2fsck_t ctx, + else if (dirent->name[1] != '\0') + problem = PR_2_DOT_NULL_TERM; + ++ dir_data_error = e2fsck_check_dirent_data(ctx, dirent, offset, pctx); ++ + (void) ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); + if (problem) { + if (!ext2fs_has_feature_filetype(ctx->fs->super)) +@@ -441,7 +519,7 @@ static int check_dot(e2fsck_t ctx, + } + if (rec_len > 12) { + new_len = rec_len - 12; +- if (new_len > 12) { ++ if (new_len > 12 && dir_data_error) { + if (created || + fix_problem(ctx, PR_2_SPLIT_DOT, pctx)) { + nextdir = (struct ext2_dir_entry *) +@@ -458,12 +536,6 @@ static int check_dot(e2fsck_t ctx, + ext2fs_dirent_set_name_len(nextdir, 0); + ext2fs_dirent_set_file_type(nextdir, + ftype); +-#ifdef WORDS_BIGENDIAN +- } else { +- (void) ext2fs_dirent_swab_in2(ctx->fs, +- (char *) nextdir, +- ctx->fs->blocksize - 12, 0); +-#endif + } + status = 1; + } +@@ -478,11 +550,12 @@ static int check_dot(e2fsck_t ctx, + * here; this gets done in pass 3. + */ + static int check_dotdot(e2fsck_t ctx, +- struct ext2_dir_entry *dirent, ++ struct ext2_dir_entry *dirent, unsigned int offset, + ext2_ino_t ino, struct problem_context *pctx) + { + problem_t problem = 0; + unsigned int rec_len; ++ int dir_data_error; + int ftype = EXT2_FT_DIR; + + if (!dirent->inode) +@@ -494,6 +567,8 @@ static int check_dotdot(e2fsck_t ctx, + else if (dirent->name[2] != '\0') + problem = PR_2_DOT_DOT_NULL_TERM; + ++ dir_data_error = e2fsck_check_dirent_data(ctx, dirent, offset, pctx); ++ + (void) ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); + if (problem) { + if (!ext2fs_has_feature_filetype(ctx->fs->super)) +@@ -594,7 +669,14 @@ static _INLINE_ int check_filetype(e2fsck_t ctx, + { + int filetype = ext2fs_dirent_file_type(dirent); + int should_be = EXT2_FT_UNKNOWN; ++ __u16 badness = 0; + struct ext2_inode inode; ++ __u8 dirdata = 0; ++ ++ if (ext2fs_has_feature_dirdata(ctx->fs->super)) { ++ dirdata = filetype & ~EXT2_FT_MASK; ++ filetype = filetype & EXT2_FT_MASK; ++ } + + if (!ext2fs_has_feature_filetype(ctx->fs->super)) { + if (filetype == 0 || +@@ -604,16 +686,18 @@ static _INLINE_ int check_filetype(e2fsck_t ctx, + return 1; + } + ++ if (ctx->inode_badness) ++ ext2fs_icount_fetch(ctx->inode_badness, dirent->inode, ++ &badness); ++ + if (ext2fs_test_inode_bitmap2(ctx->inode_dir_map, dirent->inode)) { + should_be = EXT2_FT_DIR; + } else if (ext2fs_test_inode_bitmap2(ctx->inode_reg_map, + dirent->inode)) { + should_be = EXT2_FT_REG_FILE; +- } else if (ctx->inode_bad_map && +- ext2fs_test_inode_bitmap2(ctx->inode_bad_map, +- dirent->inode)) ++ } else if (badness & BADNESS_BAD_MODE) { + should_be = 0; +- else { ++ } else { + e2fsck_read_inode(ctx, dirent->inode, &inode, + "check_filetype"); + should_be = ext2_file_type(inode.i_mode); +@@ -625,8 +709,7 @@ static _INLINE_ int check_filetype(e2fsck_t ctx, + if (fix_problem(ctx, filetype ? PR_2_BAD_FILETYPE : PR_2_SET_FILETYPE, + pctx) == 0) + return 0; +- +- ext2fs_dirent_set_file_type(dirent, should_be); ++ ext2fs_dirent_set_file_type(dirent, should_be | dirdata); + return 1; + } + +@@ -648,7 +731,7 @@ static void parse_int_node(ext2_filsys fs, + int csum_size = 0; + + if (db->blockcnt == 0) { +- root = (struct ext2_dx_root_info *) (block_buf + 24); ++ root = get_ext2_dx_root_info(fs, block_buf); + + #ifdef DX_DEBUG + printf("Root node dump:\n"); +@@ -658,8 +741,8 @@ static void parse_int_node(ext2_filsys fs, + printf("\t Indirect levels: %u\n", root->indirect_levels); + printf("\t Flags: %x\n", root->unused_flags); + #endif +- +- ent = (struct ext2_dx_entry *) (block_buf + 24 + root->info_length); ++ ent = (struct ext2_dx_entry *)((char *)root + ++ root->info_length); + + if (failed_csum && + (e2fsck_dir_will_be_rehashed(cd->ctx, cd->pctx.ino) || +@@ -667,7 +750,7 @@ static void parse_int_node(ext2_filsys fs, + &cd->pctx))) + goto clear_and_exit; + } else { +- ent = (struct ext2_dx_entry *) (block_buf+8); ++ ent = (struct ext2_dx_entry *)(block_buf + 8); + + if (failed_csum && + (e2fsck_dir_will_be_rehashed(cd->ctx, cd->pctx.ino) || +@@ -675,8 +758,7 @@ static void parse_int_node(ext2_filsys fs, + &cd->pctx))) + goto clear_and_exit; + } +- +- limit = (struct ext2_dx_countlimit *) ent; ++ limit = (struct ext2_dx_countlimit *)ent; + + #ifdef DX_DEBUG + printf("Number of entries (count): %d\n", +@@ -850,7 +932,6 @@ static void salvage_directory(ext2_filsys fs, + } + } + +-#define NEXT_DIRENT(d) ((void *)((char *)(d) + (d)->rec_len)) + static errcode_t insert_dirent_tail(ext2_filsys fs, void *dirbuf) + { + struct ext2_dir_entry *d; +@@ -860,11 +941,11 @@ static errcode_t insert_dirent_tail(ext2_filsys fs, void *dirbuf) + d = dirbuf; + top = EXT2_DIRENT_TAIL(dirbuf, fs->blocksize); + +- while (d->rec_len && !(d->rec_len & 0x3) && NEXT_DIRENT(d) <= top) +- d = NEXT_DIRENT(d); ++ while (d->rec_len && !(d->rec_len & 0x3) && EXT2_NEXT_DIRENT(d) <= top) ++ d = EXT2_NEXT_DIRENT(d); + + if (d != top) { +- unsigned int min_size = EXT2_DIR_REC_LEN( ++ unsigned int min_size = EXT2_DIR_NAME_LEN( + ext2fs_dirent_name_len(dirbuf)); + if (min_size > (char *)top - (char *)d) + return EXT2_ET_DIR_NO_SPACE_FOR_CSUM; +@@ -879,7 +960,6 @@ static errcode_t insert_dirent_tail(ext2_filsys fs, void *dirbuf) + + return 0; + } +-#undef NEXT_DIRENT + + static errcode_t fix_inline_dir_size(e2fsck_t ctx, ext2_ino_t ino, + size_t *inline_data_size, +@@ -898,7 +978,7 @@ static errcode_t fix_inline_dir_size(e2fsck_t ctx, ext2_ino_t ino, + */ + if (old_size > EXT4_MIN_INLINE_DATA_SIZE && + old_size < EXT4_MIN_INLINE_DATA_SIZE + +- EXT2_DIR_REC_LEN(1)) { ++ EXT2_DIR_NAME_LEN(1)) { + old_size = EXT4_MIN_INLINE_DATA_SIZE; + new_size = old_size; + } else +@@ -1185,7 +1265,7 @@ inline_read_fail: + if (((inline_data_size & 3) || + (inline_data_size > EXT4_MIN_INLINE_DATA_SIZE && + inline_data_size < EXT4_MIN_INLINE_DATA_SIZE + +- EXT2_DIR_REC_LEN(1))) && ++ EXT2_DIR_NAME_LEN(1))) && + fix_problem(ctx, PR_2_BAD_INLINE_DIR_SIZE, &pctx)) { + errcode_t err = fix_inline_dir_size(ctx, ino, + &inline_data_size, &pctx, +@@ -1235,7 +1315,7 @@ inline_read_fail: + (void) ext2fs_get_rec_len(fs, dirent, &rec_len); + limit = (struct ext2_dx_countlimit *) (buf+8); + if (db->blockcnt == 0) { +- root = (struct ext2_dx_root_info *) (buf + 24); ++ root = get_ext2_dx_root_info(fs, buf); + dx_db->type = DX_DIRBLOCK_ROOT; + dx_db->flags |= DX_FLAG_FIRST | DX_FLAG_LAST; + +@@ -1396,7 +1476,7 @@ skip_checksum: + memset(&dot, 0, sizeof(dot)); + dirent = ˙ + dirent->inode = ino; +- dirent->rec_len = EXT2_DIR_REC_LEN(1); ++ dirent->rec_len = EXT2_DIR_NAME_LEN(1); + dirent->name_len = 1 | filetype; + dirent->name[0] = '.'; + } else if (dot_state == 1) { +@@ -1404,7 +1484,7 @@ skip_checksum: + dirent = &dotdot; + dirent->inode = + ((struct ext2_dir_entry *)buf)->inode; +- dirent->rec_len = EXT2_DIR_REC_LEN(2); ++ dirent->rec_len = EXT2_DIR_NAME_LEN(2); + dirent->name_len = 2 | filetype; + dirent->name[0] = '.'; + dirent->name[1] = '.'; +@@ -1416,10 +1496,10 @@ skip_checksum: + } + + if (dot_state == 0) { +- if (check_dot(ctx, dirent, ino, &cd->pctx)) ++ if (check_dot(ctx, dirent, offset, ino, &cd->pctx)) + dir_modified++; + } else if (dot_state == 1) { +- ret = check_dotdot(ctx, dirent, ino, &cd->pctx); ++ ret = check_dotdot(ctx, dirent, offset, ino, &cd->pctx); + if (ret < 0) + goto abort_free_dict; + if (ret) +@@ -1435,6 +1515,10 @@ skip_checksum: + if (!dirent->inode) + goto next; + ++ ret = e2fsck_check_dirent_data(ctx, dirent, offset, &cd->pctx); ++ if (ret == 2) ++ dir_modified++; ++ + /* + * Make sure the inode listed is a legal one. + */ +@@ -1499,26 +1583,6 @@ skip_checksum: + } + } + +- /* +- * If the inode was marked as having bad fields in +- * pass1, process it and offer to fix/clear it. +- * (We wait until now so that we can display the +- * pathname to the user.) +- */ +- if (ctx->inode_bad_map && +- ext2fs_test_inode_bitmap2(ctx->inode_bad_map, +- dirent->inode)) { +- if (e2fsck_process_bad_inode(ctx, ino, +- dirent->inode, +- buf + fs->blocksize)) { +- dirent->inode = 0; +- dir_modified++; +- goto next; +- } +- if (ctx->flags & E2F_FLAG_SIGNAL_MASK) +- return DIRENT_ABORT; +- } +- + group = ext2fs_group_of_ino(fs, dirent->inode); + first_unused_inode = group * fs->super->s_inodes_per_group + + 1 + fs->super->s_inodes_per_group - +@@ -1561,6 +1625,25 @@ skip_checksum: + } + } + ++ /* ++ * If the inode was marked as having bad fields in ++ * pass1, process it and offer to fix/clear it. ++ * (We wait until now so that we can display the ++ * pathname to the user.) ++ */ ++ if (!(ctx->flags & E2F_FLAG_RESTART_LATER) && ++ ctx->inode_badness && ++ ext2fs_icount_is_set(ctx->inode_badness, dirent->inode)) { ++ if (e2fsck_process_bad_inode(ctx, ino, dirent->inode, ++ buf + fs->blocksize)) { ++ dirent->inode = 0; ++ dir_modified++; ++ goto next; ++ } ++ if (ctx->flags & E2F_FLAG_SIGNAL_MASK) ++ return DIRENT_ABORT; ++ } ++ + /* + * Offer to clear unused inodes; if we are going to be + * restarting the scan due to bg_itable_unused being +@@ -1575,15 +1658,19 @@ skip_checksum: + problem = PR_2_UNUSED_INODE; + + if (problem) { +- if (fix_problem(ctx, problem, &cd->pctx)) { ++ int next = 0; ++ ++ if (fix_problem_bad(ctx, problem, &cd->pctx, 0)) { + dirent->inode = 0; + dir_modified++; +- goto next; ++ next = 1; + } else { + ext2fs_unmark_valid(fs); + if (problem == PR_2_BAD_INO) +- goto next; ++ next = 1; + } ++ if (next) ++ goto next; + } + + if (check_filetype(ctx, dirent, ino, &cd->pctx)) +@@ -1848,8 +1935,17 @@ static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf) + struct problem_context pctx; + __u32 count; + struct del_block del_block; ++ int extent_fs = 0; + + e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode"); ++ /* ext2fs_block_iterate2() depends on the extents flags */ ++ if (inode.i_flags & EXT4_EXTENTS_FL) ++ extent_fs = 1; ++ e2fsck_clear_inode(ctx, ino, &inode, 0, "deallocate_inode"); ++ if (extent_fs) { ++ inode.i_flags |= EXT4_EXTENTS_FL; ++ e2fsck_write_inode(ctx, ino, &inode, "deallocate_inode"); ++ } + clear_problem_context(&pctx); + pctx.ino = ino; + +@@ -1878,6 +1974,8 @@ static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf) + ext2fs_block_alloc_stats2(fs, + ext2fs_file_acl_block(fs, &inode), -1); + } ++ if (ctx->inode_badness) ++ ext2fs_icount_store(ctx->inode_badness, ino, 0); + ext2fs_file_acl_block_set(fs, &inode, 0); + } + +@@ -1937,8 +2035,13 @@ int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir, + unsigned char *frag, *fsize; + struct problem_context pctx; + problem_t problem = 0; ++ unsigned int flags = ctx->fs->flags; + ++ flags = ctx->fs->flags; ++ ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + e2fsck_read_inode(ctx, ino, &inode, "process_bad_inode"); ++ ctx->fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | ++ (ctx->fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + + clear_problem_context(&pctx); + pctx.ino = ino; +@@ -1971,8 +2074,8 @@ int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir, + else if (LINUX_S_ISSOCK(inode.i_mode) + && !e2fsck_pass1_check_device_inode(fs, &inode)) + problem = PR_2_BAD_SOCKET; +- else if (LINUX_S_ISLNK(inode.i_mode) +- && !e2fsck_pass1_check_symlink(fs, ino, &inode, buf)) { ++ else if (LINUX_S_ISLNK(inode.i_mode) && ++ !e2fsck_pass1_check_symlink(ctx, ino, &inode, buf)) { + problem = PR_2_INVALID_SYMLINK; + } + +@@ -1985,6 +2088,12 @@ int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir, + } else + not_fixed++; + problem = 0; ++ /* ++ * A large value is associated with bad mode in order to detect ++ * that mode was corrupt in check_filetype() ++ */ ++ e2fsck_mark_inode_bad_loc(ctx, &pctx, problem, BADNESS_BAD_MODE, ++ __func__, __LINE__); + } + + if (inode.i_faddr) { +@@ -2062,10 +2171,18 @@ int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir, + not_fixed++; + } + ++ /* The high value from BADNESS_BAD_MODE should not delete the inode */ ++ if (e2fsck_fix_bad_inode(ctx, &pctx)) { ++ deallocate_inode(ctx, ino, 0); ++ if (ctx->flags & E2F_FLAG_SIGNAL_MASK) ++ return 0; ++ inode_modified = 0; ++ } else { ++ not_fixed++; ++ } ++ + if (inode_modified) + e2fsck_write_inode(ctx, ino, &inode, "process_bad_inode"); +- if (!not_fixed && ctx->inode_bad_map) +- ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino); + return 0; + } + +@@ -2085,7 +2202,7 @@ static int allocate_dir_block(e2fsck_t ctx, + char *block; + struct ext2_inode inode; + +- if (fix_problem(ctx, PR_2_DIRECTORY_HOLE, pctx) == 0) ++ if (fix_problem_bad(ctx, PR_2_DIRECTORY_HOLE, pctx, 0) == 0) + return 1; + + /* +diff --git a/e2fsck/pass3.c b/e2fsck/pass3.c +index cedaaf5..94d1ba7 100644 +--- a/e2fsck/pass3.c ++++ b/e2fsck/pass3.c +@@ -22,7 +22,7 @@ + * will offer to reconnect it to /lost+found. While it is chasing + * parent pointers up the filesystem tree, if pass3 sees a directory + * twice, then it has detected a filesystem loop, and it will again +- * offer to reconnect the directory to /lost+found in to break the ++ * offer to reconnect the directory to /lost+found in order to break the + * filesystem loop. + * + * Pass 3 also contains the subroutine, e2fsck_reconnect_file() to +@@ -304,7 +304,7 @@ static int check_directory(e2fsck_t ctx, ext2_ino_t dir, + * If it was marked done already, then we've reached a + * parent we've already checked. + */ +- if (ext2fs_mark_inode_bitmap2(inode_done_map, ino)) ++ if (ext2fs_mark_inode_bitmap2(inode_done_map, ino)) + break; + + if (e2fsck_dir_info_get_parent(ctx, ino, &parent)) { +@@ -319,13 +319,18 @@ static int check_directory(e2fsck_t ctx, ext2_ino_t dir, + */ + if (!parent || + (loop_pass && +- (ext2fs_test_inode_bitmap2(inode_loop_detect, +- parent)))) { ++ ext2fs_test_inode_bitmap2(inode_loop_detect, parent))) { + pctx->ino = ino; +- if (fix_problem(ctx, PR_3_UNCONNECTED_DIR, pctx)) { +- if (e2fsck_reconnect_file(ctx, pctx->ino)) ++ if (parent) ++ pctx->dir = parent; ++ else ++ ext2fs_lookup(fs, ino, "..", 2, NULL, ++ &pctx->dir); ++ if (fix_problem(ctx, !parent ? PR_3_UNCONNECTED_DIR : ++ PR_3_LOOPED_DIR, pctx)) { ++ if (e2fsck_reconnect_file(ctx, pctx->ino)) { + ext2fs_unmark_valid(fs); +- else { ++ } else { + fix_dotdot(ctx, pctx->ino, + ctx->lost_and_found); + parent = ctx->lost_and_found; +@@ -464,7 +469,7 @@ unlink: + pctx.errcode = retval; + fix_problem(ctx, PR_3_ERR_FIND_LPF, &pctx); + } +- if (!fix_problem(ctx, PR_3_NO_LF_DIR, 0)) ++ if (!fix_problem(ctx, PR_3_NO_LF_DIR, &pctx)) + return 0; + + /* +@@ -704,6 +709,7 @@ static int fix_dotdot_proc(struct ext2_dir_entry *dirent, + struct fix_dotdot_struct *fp = (struct fix_dotdot_struct *) priv_data; + errcode_t retval; + struct problem_context pctx; ++ __u16 dirdata = 0; + + if (ext2fs_dirent_name_len(dirent) != 2) + return 0; +@@ -723,11 +729,17 @@ static int fix_dotdot_proc(struct ext2_dir_entry *dirent, + fix_problem(fp->ctx, PR_3_ADJUST_INODE, &pctx); + } + dirent->inode = fp->parent; ++ ++ dirdata = dirent->name_len & ((__u16)~EXT2_FT_MASK << 8); ++ + if (ext2fs_has_feature_filetype(fp->ctx->fs->super)) + ext2fs_dirent_set_file_type(dirent, EXT2_FT_DIR); + else + ext2fs_dirent_set_file_type(dirent, EXT2_FT_UNKNOWN); + ++ if (ext2fs_has_feature_dirdata(fp->ctx->fs->super)) ++ dirent->name_len |= dirdata; ++ + fp->done++; + return DIRENT_ABORT | DIRENT_CHANGED; + } +diff --git a/e2fsck/pass4.c b/e2fsck/pass4.c +index 8c2d2f1..f048fff 100644 +--- a/e2fsck/pass4.c ++++ b/e2fsck/pass4.c +@@ -17,6 +17,7 @@ + #include "config.h" + #include "e2fsck.h" + #include "problem.h" ++#include "ext2fs/lfsck.h" + #include + + /* +@@ -26,7 +27,7 @@ + * This subroutine returns 1 then the caller shouldn't bother with the + * rest of the pass 4 tests. + */ +-static int disconnect_inode(e2fsck_t ctx, ext2_ino_t i, ++static int disconnect_inode(e2fsck_t ctx, ext2_ino_t i, ext2_ino_t *last_ino, + struct ext2_inode_large *inode) + { + ext2_filsys fs = ctx->fs; +@@ -34,9 +35,12 @@ static int disconnect_inode(e2fsck_t ctx, ext2_ino_t i, + __u32 eamagic = 0; + int extra_size = 0; + +- e2fsck_read_inode_full(ctx, i, EXT2_INODE(inode), +- EXT2_INODE_SIZE(fs->super), +- "pass4: disconnect_inode"); ++ if (*last_ino != i) { ++ e2fsck_read_inode_full(ctx, i, EXT2_INODE(inode), ++ EXT2_INODE_SIZE(fs->super), ++ "pass4: disconnect_inode"); ++ *last_ino = i; ++ } + if (EXT2_INODE_SIZE(fs->super) > EXT2_GOOD_OLD_INODE_SIZE) + extra_size = inode->i_extra_isize; + +@@ -75,6 +79,7 @@ static int disconnect_inode(e2fsck_t ctx, ext2_ino_t i, + if (fix_problem(ctx, PR_4_UNATTACHED_INODE, &pctx)) { + if (e2fsck_reconnect_file(ctx, i)) + ext2fs_unmark_valid(fs); ++ *last_ino = 0; + } else { + /* + * If we don't attach the inode, then skip the +@@ -87,20 +92,23 @@ static int disconnect_inode(e2fsck_t ctx, ext2_ino_t i, + return 0; + } + +-static void check_ea_inode(e2fsck_t ctx, ext2_ino_t i, ++/* ++ * This function is called when link_counted is zero. So this may not ++ * be an xattr inode at all. Return immediately if EA_INODE flag is not ++ * set. ++ */ ++static void check_ea_inode(e2fsck_t ctx, ext2_ino_t i, ext2_ino_t *last_ino, + struct ext2_inode_large *inode, __u16 *link_counted) + { + __u64 actual_refs = 0; + __u64 ref_count; + +- /* +- * This function is called when link_counted is zero. So this may not +- * be an xattr inode at all. Return immediately if EA_INODE flag is not +- * set. +- */ +- e2fsck_read_inode_full(ctx, i, EXT2_INODE(inode), +- EXT2_INODE_SIZE(ctx->fs->super), +- "pass4: check_ea_inode"); ++ if (*last_ino != i) { ++ e2fsck_read_inode_full(ctx, i, EXT2_INODE(inode), ++ EXT2_INODE_SIZE(ctx->fs->super), ++ "pass4: check_ea_inode"); ++ *last_ino = i; ++ } + if (!(inode->i_flags & EXT4_EA_INODE_FL)) + return; + +@@ -134,6 +142,73 @@ static void check_ea_inode(e2fsck_t ctx, ext2_ino_t i, + } + } + ++static errcode_t check_link_ea(e2fsck_t ctx, ext2_ino_t ino, ++ ext2_ino_t *last_ino, ++ struct ext2_inode_large *inode, ++ __u16 *link_counted) ++{ ++ struct ext2_xattr_handle *handle; ++ struct link_ea_header *leh; ++ void *buf; ++ size_t ea_len; ++ errcode_t retval; ++ ++ if (*last_ino != ino) { ++ e2fsck_read_inode_full(ctx, ino, EXT2_INODE(inode), ++ EXT2_INODE_SIZE(ctx->fs->super), ++ "pass4: get link ea count"); ++ *last_ino = ino; ++ } ++ ++ retval = ext2fs_xattrs_open(ctx->fs, ino, &handle); ++ if (retval) ++ return retval; ++ ++ retval = ext2fs_xattrs_read_inode(handle, inode); ++ if (retval) ++ goto err; ++ ++ retval = ext2fs_xattr_get(handle, EXT2_ATTR_INDEX_TRUSTED_PREFIX ++ LUSTRE_XATTR_MDT_LINK, &buf, &ea_len); ++ if (retval) ++ goto err; ++ ++ leh = (struct link_ea_header *)buf; ++ if (leh->leh_magic == ext2fs_swab32(LINK_EA_MAGIC)) { ++ leh->leh_magic = LINK_EA_MAGIC; ++ leh->leh_reccount = ext2fs_swab32(leh->leh_reccount); ++ leh->leh_len = ext2fs_swab64(leh->leh_len); ++ } ++ if (leh->leh_magic != LINK_EA_MAGIC) { ++ retval = EINVAL; ++ goto err_free; ++ } ++ if (leh->leh_reccount == 0 && !leh->leh_overflow_time) { ++ retval = ENODATA; ++ goto err_free; ++ } ++ if (leh->leh_len > ea_len) { ++ retval = EINVAL; ++ goto err_free; ++ } ++ ++ /* if linkEA overflowed and does not hold all links, assume *some* ++ * links exist until LFSCK is next run and resets leh_overflow_time */ ++ if (leh->leh_overflow_time) { ++ if (inode->i_links_count > *link_counted) ++ *link_counted = inode->i_links_count; ++ else if (*link_counted == 0) ++ *link_counted = 1111; ++ } ++ if (leh->leh_reccount > *link_counted) ++ *link_counted = leh->leh_reccount; ++err_free: ++ ext2fs_free_mem(&buf); ++err: ++ ext2fs_xattrs_close(&handle); ++ return retval; ++} ++ + void e2fsck_pass4(e2fsck_t ctx) + { + ext2_filsys fs = ctx->fs; +@@ -180,7 +255,8 @@ void e2fsck_pass4(e2fsck_t ctx) + inode = e2fsck_allocate_memory(ctx, inode_size, "scratch inode"); + + /* Protect loop from wrap-around if s_inodes_count maxed */ +- for (i=1; i <= fs->super->s_inodes_count && i > 0; i++) { ++ for (i = 1; i <= fs->super->s_inodes_count && i > 0; i++) { ++ ext2_ino_t last_ino = 0; + int isdir; + + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) +@@ -210,7 +286,7 @@ void e2fsck_pass4(e2fsck_t ctx) + * check_ea_inode() will update link_counted if + * necessary. + */ +- check_ea_inode(ctx, i, inode, &link_counted); ++ check_ea_inode(ctx, i, &last_ino, inode, &link_counted); + } + + if (link_counted == 0) { +@@ -219,12 +295,13 @@ void e2fsck_pass4(e2fsck_t ctx) + fs->blocksize, "bad_inode buffer"); + if (e2fsck_process_bad_inode(ctx, 0, i, buf)) + continue; +- if (disconnect_inode(ctx, i, inode)) ++ if (disconnect_inode(ctx, i, &last_ino, inode)) + continue; + ext2fs_icount_fetch(ctx->inode_link_info, i, + &link_count); + ext2fs_icount_fetch(ctx->inode_count, i, + &link_counted); ++ check_link_ea(ctx, i, &last_ino, inode, &link_counted); + } + isdir = ext2fs_test_inode_bitmap2(ctx->inode_dir_map, i); + if (isdir && (link_counted > EXT2_LINK_MAX)) { +@@ -236,11 +313,18 @@ void e2fsck_pass4(e2fsck_t ctx) + } + link_counted = 1; + } ++ if (link_counted != link_count) ++ check_link_ea(ctx, i, &last_ino, inode, &link_counted); ++ + if (link_counted != link_count) { + int fix_nlink = 0; + +- e2fsck_read_inode_full(ctx, i, EXT2_INODE(inode), +- inode_size, "pass4"); ++ if (last_ino != i) { ++ e2fsck_read_inode_full(ctx, i, ++ EXT2_INODE(inode), ++ inode_size, "pass4"); ++ last_ino = i; ++ } + pctx.ino = i; + pctx.inode = EXT2_INODE(inode); + if ((link_count != inode->i_links_count) && !isdir && +diff --git a/e2fsck/pass5.c b/e2fsck/pass5.c +index c1d45a5..23a4746 100644 +--- a/e2fsck/pass5.c ++++ b/e2fsck/pass5.c +@@ -76,6 +76,42 @@ void e2fsck_pass5(e2fsck_t ctx) + ext2fs_free_block_bitmap(ctx->block_metadata_map); + ctx->block_metadata_map = 0; + ++ if (ctx->flags & E2F_FLAG_EXPAND_EISIZE) { ++ int min_extra_isize; ++ ++ if (!ctx->expand_eisize_map) ++ goto set_min_extra_isize; ++ ++ for (pctx.ino = 1; pctx.ino < ctx->fs->super->s_inodes_count; ++ pctx.ino++) { ++ if (ext2fs_test_inode_bitmap2(ctx->expand_eisize_map, ++ pctx.ino)) { ++ fix_problem(ctx, PR_5_EXPAND_EISIZE, &pctx); ++ ext2fs_expand_extra_isize(ctx->fs, pctx.ino, 0, ++ ctx->want_extra_isize, ++ NULL, NULL); ++ } ++ } ++ ext2fs_free_inode_bitmap(ctx->expand_eisize_map); ++ ++set_min_extra_isize: ++ if (ctx->fs->super->s_min_extra_isize) ++ min_extra_isize = ctx->fs->super->s_min_extra_isize; ++ else ++ min_extra_isize = ctx->want_extra_isize; ++ if (ctx->min_extra_isize >= min_extra_isize && ++ !ctx->fs_unexpanded_inodes) { ++ ctx->fs->super->s_min_extra_isize =ctx->min_extra_isize; ++ ctx->fs->super->s_feature_ro_compat |= ++ EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE; ++ } else { ++ ctx->fs->super->s_min_extra_isize = 0; ++ ctx->fs->super->s_feature_ro_compat &= ++ ~EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE; ++ } ++ ext2fs_mark_super_dirty(ctx->fs); ++ } ++ + print_resource_track(ctx, _("Pass 5"), &rtrack, ctx->fs->io); + } + +@@ -856,11 +892,11 @@ static void check_inode_end(e2fsck_t ctx) + + /* protect loop from wrap-around if end is maxed */ + for (i = save_inodes_count + 1; i <= end && i > save_inodes_count; i++) { +- if (!ext2fs_test_inode_bitmap(fs->inode_map, i)) { ++ if (!ext2fs_test_inode_bitmap2(fs->inode_map, i)) { + asked = 1; + if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) { + for (; i <= end; i++) +- ext2fs_mark_inode_bitmap(fs->inode_map, ++ ext2fs_mark_inode_bitmap2(fs->inode_map, + i); + ext2fs_mark_ib_dirty(fs); + } else +diff --git a/e2fsck/problem.c b/e2fsck/problem.c +index 3bc2910..78a6ca6 100644 +--- a/e2fsck/problem.c ++++ b/e2fsck/problem.c +@@ -526,6 +526,14 @@ static struct e2fsck_problem problem_table[] = { + "not compatible. Resize @i should be disabled. "), + PROMPT_FIX, 0, 0, 0, 0 }, + ++ { PR_0_MIN_EXTRA_ISIZE_INVALID, ++ N_("@S has invalid s_min_extra_isize. "), ++ PROMPT_FIX, PR_PREEN_OK }, ++ ++ { PR_0_WANT_EXTRA_ISIZE_INVALID, ++ N_("@S has invalid s_want_extra_isize. "), ++ PROMPT_FIX, PR_PREEN_OK }, ++ + /* Pass 1 errors */ + + /* Pass 1: Checking inodes, blocks, and sizes */ +@@ -1279,6 +1287,47 @@ static struct e2fsck_problem problem_table[] = { + N_("@h %i uses SipHash, but should not. "), + PROMPT_CLEAR_HTREE, PR_PREEN_OK, 0, 0, 0 }, + ++ /* expand inode */ ++ { PR_1_EXPAND_EISIZE_WARNING, ++ N_("\ne2fsck is being run with \"expand_extra_isize\" option or\n" ++ "s_min_extra_isize of %d bytes has been set in the superblock.\n" ++ "Inode %i does not have enough free space. Either some EAs\n" ++ "need to be deleted from this inode or the RO_COMPAT_EXTRA_ISIZE\n" ++ "flag must be cleared.\n\n"), PROMPT_NONE, PR_PREEN_OK | PR_NO_OK | ++ PR_PREEN_NOMSG }, ++ ++ /* expand inode */ ++ { PR_1_EXPAND_EISIZE, ++ N_("Expanding @i %i.\n"), ++ PROMPT_NONE, PR_PREEN_OK | PR_NO_OK | PR_PREEN_NOMSG }, ++ ++ /* delete an EA so that EXTRA_ISIZE feature may be enabled */ ++ { PR_1_EISIZE_DELETE_EA, ++ N_("Delete EA %s of @i %i so that EXTRA_ISIZE feature may be " ++ "enabled?\n"), PROMPT_FIX, PR_NO_OK | PR_PREEN_NO }, ++ ++ /* an EA needs to be deleted by e2fsck is being run with -p or -y */ ++ { PR_1_EA_BLK_NOSPC, ++ N_("An EA needs to be deleted for @i %i but e2fsck is being run\n" ++ "with -p or -y mode.\n"), ++ PROMPT_ABORT, 0 }, ++ ++ /* disable EXTRA_ISIZE feature since inode cannot be expanded */ ++ { PR_1_CLEAR_EXTRA_ISIZE, ++ N_("Disable EXTRA_ISIZE feature since @i %i cannot be expanded\n" ++ "without deletion of an EA.\n"), ++ PROMPT_FIX, 0 }, ++ ++ /* invalid inode creation time */ ++ { PR_1_CRTIME_BAD, ++ N_("@i %i creation time (%t) invalid.\n"), ++ PROMPT_CLEAR, PR_PREEN_OK | PR_NO_OK }, ++ ++ /* Bad extended attribute value in inode */ ++ { PR_1_SYMLINK_NUL, ++ N_("@i %i symlink missing NUL terminator. "), ++ PROMPT_FIX, 0}, ++ + /* Failed to goto block group */ + { PR_1_SCAN_GOTO, + N_("failed to goto block group"), +@@ -1336,6 +1385,11 @@ static struct e2fsck_problem problem_table[] = { + " %b--%c", + PROMPT_NONE, PR_LATCH_DBLOCK | PR_PREEN_NOHDR, 0, 0, 0 }, + ++ /* Inode is badly corrupt (badness value = ) */ ++ { PR_1B_INODE_TOOBAD, ++ N_("@i %i is badly corrupt (badness value = %N). "), ++ PROMPT_CLEAR, PR_PREEN_OK }, ++ + /* Pass 1C: Scan directories for inodes with multiply-claimed blocks. */ + { PR_1C_PASS_HEADER, + N_("Pass 1C: Scanning directories for @is with @m @bs\n"), +@@ -1386,6 +1440,14 @@ static struct e2fsck_problem problem_table[] = { + /* xgettext:no-c-format */ + N_("Couldn't clone file: %m\n"), PROMPT_NONE, 0, 0, 0, 0 }, + ++ /* File with shared blocks found */ ++ { PR_1D_DISCONNECT_QUESTION, ++ N_("File with shared blocks found\n"), PROMPT_CONNECT, 0 }, ++ ++ /* Couldn't unlink file (error) */ ++ { PR_1D_DISCONNECT_ERROR, ++ N_("Couldn't unlink file: %m\n"), PROMPT_NONE, 0 }, ++ + /* Pass 1E Extent tree optimization */ + + /* Pass 1E: Optimizing extent trees */ +@@ -1835,6 +1897,15 @@ static struct e2fsck_problem problem_table[] = { + N_("Duplicate filename @E found. "), + PROMPT_CLEAR, 0, 0, 0, 0 }, + ++ /* Inode is badly corrupt (badness value = ) */ ++ { PR_2_INODE_TOOBAD, ++ N_("@i %i is badly corrupt (badness value = %N). "), ++ PROMPT_CLEAR, PR_PREEN_OK }, ++ ++ /* Directory entry dirdata length set incorrectly */ ++ { PR_2_CLEAR_DIRDATA, ++ N_("@E dirdata length set incorrectly.\n"), ++ PROMPT_CLEAR, PR_PREEN_OK }, + + /* Pass 3 errors */ + +@@ -1856,7 +1927,7 @@ static struct e2fsck_problem problem_table[] = { + /* Unconnected directory inode */ + { PR_3_UNCONNECTED_DIR, + /* xgettext:no-c-format */ +- N_("Unconnected @d @i %i (%p)\n"), ++ N_("Unconnected @d @i %i (was in %q)\n"), + PROMPT_CONNECT, 0, 0, 0, 0 }, + + /* /lost+found not found */ +@@ -1993,6 +2064,12 @@ static struct e2fsck_problem problem_table[] = { + N_("/@l is encrypted\n"), + PROMPT_CLEAR, 0, 0, 0, 0 }, + ++ /* Recursively looped directory inode */ ++ { PR_3_LOOPED_DIR, ++ /* xgettext:no-c-format */ ++ N_("Recursively looped @d @i %i (%p)\n"), ++ PROMPT_CONNECT, 0, 0, 0, 0 }, ++ + /* Pass 3A Directory Optimization */ + + /* Pass 3A: Optimizing directories */ +@@ -2228,6 +2305,11 @@ static struct e2fsck_problem problem_table[] = { + N_("@g %g @b @B does not match checksum.\n"), + PROMPT_FIX, PR_LATCH_BBITMAP | PR_PREEN_OK, 0, 0, 0 }, + ++ /* Expand inode */ ++ { PR_5_EXPAND_EISIZE, ++ N_("Expanding @i %i.\n"), ++ PROMPT_NONE, PR_PREEN_OK | PR_NO_OK | PR_PREEN_NOMSG }, ++ + /* Post-Pass 5 errors */ + + /* Recreate journal if E2F_FLAG_JOURNAL_INODE flag is set */ +@@ -2410,7 +2492,8 @@ static void print_problem(FILE *f, problem_t code, int answer, int fixed, + fputs("/>\n", f); + } + +-int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx) ++int fix_problem_loc(e2fsck_t ctx, problem_t code, struct problem_context *pctx, ++ int badness, const char *func, const int line) + { + ext2_filsys fs = ctx->fs; + struct e2fsck_problem *ptr; +@@ -2421,6 +2504,10 @@ int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx) + int suppress = 0; + int fixed = 0; + ++ /* ino is always set in pass1, where we will hit most badness */ ++ if (pctx && pctx->ino != 0 && badness && code < PR_3_PASS_HEADER) ++ e2fsck_mark_inode_bad_loc(ctx, pctx, code, badness, func, line); ++ + ptr = find_problem(code); + if (!ptr) { + printf(_("Unhandled error code (0x%x)!\n"), code); +@@ -2468,7 +2555,8 @@ int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx) + if (ptr->flags & PR_LATCH_MASK) { + ldesc = find_latch(ptr->flags & PR_LATCH_MASK); + if (ldesc->question && !(ldesc->flags & PRL_LATCHED)) { +- ans = fix_problem(ctx, ldesc->question, pctx); ++ ans = fix_problem_loc(ctx, ldesc->question, pctx, ++ 0, func, line); + if (ans == 1) + ldesc->flags |= PRL_YES; + if (ans == 0) +@@ -2571,7 +2659,8 @@ int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx) + fatal_error(ctx, 0); + + if (ptr->flags & PR_AFTER_CODE) +- answer = fix_problem(ctx, ptr->second_code, pctx); ++ answer = fix_problem_loc(ctx, ptr->second_code, pctx, ++ 0, func, line); + + if (answer && (ptr->prompt != PROMPT_NONE) && + !(ptr->flags & PR_NOT_A_FIX)) { +@@ -2622,6 +2711,13 @@ void preenhalt(e2fsck_t ctx) + return; + } + ++void e2fsck_mark_inode_bad_loc(e2fsck_t ctx, ++ struct problem_context *pctx, __u32 code, ++ int count, const char *func, const int line) ++{ ++ return; ++} ++ + errcode_t + profile_get_string(profile_t profile, const char *name, const char *subname, + const char *subsubname, const char *def_val, +diff --git a/e2fsck/problem.h b/e2fsck/problem.h +index c09fbf9..880d527 100644 +--- a/e2fsck/problem.h ++++ b/e2fsck/problem.h +@@ -288,6 +288,15 @@ struct problem_context { + /* Meta_bg and resize_inode are not compatible, remove resize_inode*/ + #define PR_0_DISABLE_RESIZE_INODE 0x000051 + ++/* Invalid s_min_extra_isize */ ++#define PR_0_MIN_EXTRA_ISIZE_INVALID 0x000052 ++ ++/* Invalid s_want_extra_isize */ ++#define PR_0_WANT_EXTRA_ISIZE_INVALID 0x000053 ++ ++/* Clear EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE flag */ ++#define PR_0_CLEAR_EXTRA_ISIZE 0x000054 ++ + /* + * Pass 1 errors + */ +@@ -685,6 +694,9 @@ struct problem_context { + /* Inode has illegal EA value inode */ + #define PR_1_ATTR_VALUE_EA_INODE 0x010083 + ++/* Inode has bad timestamp */ ++#define PR_1_INODE_BAD_TIME 0x010084 ++ + /* Parent inode has invalid EA entry. EA inode does not have + * EXT4_EA_INODE_FL flag. Delete EA entry? */ + #define PR_1_ATTR_NO_EA_INODE_FL 0x010085 +@@ -716,6 +728,31 @@ struct problem_context { + /* Htree directory uses SipHash but should not */ + #define PR_1_HTREE_CANNOT_SIPHASH 0x01008E + ++/* Warning for user that all inodes need to be expanded atleast by ++ * s_min_extra_isize ++ */ ++#define PR_1_EXPAND_EISIZE_WARNING 0x01008F ++ ++/* Expand the inode */ ++#define PR_1_EXPAND_EISIZE 0x010090 ++ ++/* Delete an EA so that EXTRA_ISIZE may be enabled */ ++#define PR_1_EISIZE_DELETE_EA 0x010091 ++ ++/* An EA needs to be deleted by e2fsck is being run with -p or -y */ ++#define PR_1_EA_BLK_NOSPC 0x010092 ++ ++/* Disable EXTRA_ISIZE feature as inode cannot be expanded ++ * without deletion of an EA ++ */ ++#define PR_1_CLEAR_EXTRA_ISIZE 0x010093 ++ ++/* invalid inode creation time */ ++#define PR_1_CRTIME_BAD 0x010094 ++ ++/* Symlink missing NUL terminator */ ++#define PR_1_SYMLINK_NUL 0x010095 ++ + /* Failed to goto block group */ + #define PR_1_SCAN_GOTO 0x0100A0 + +@@ -750,6 +787,9 @@ struct problem_context { + /* Duplicate/bad block range in inode */ + #define PR_1B_DUP_RANGE 0x011008 + ++/* Inode is badly corrupt (badness value = ) */ ++#define PR_1B_INODE_TOOBAD 0x011009 ++ + /* Pass 1C: Scan directories for inodes with dup blocks. */ + #define PR_1C_PASS_HEADER 0x012000 + +@@ -781,6 +821,13 @@ struct problem_context { + /* Couldn't clone file (error) */ + #define PR_1D_CLONE_ERROR 0x013008 + ++/* File with shared blocks found */ ++#define PR_1D_DISCONNECT_QUESTION 0x013009 ++ ++/* Couldn't unlink file (error) */ ++#define PR_1D_DISCONNECT_ERROR 0x01300A ++ ++ + /* + * Pass 1e --- rebuilding extent trees + */ +@@ -1046,6 +1093,12 @@ struct problem_context { + /* Non-unique filename found, but can't rename */ + #define PR_2_NON_UNIQUE_FILE_NO_RENAME 0x020054 + ++/* Inode is badly corrupt (badness value = ) */ ++#define PR_2_INODE_TOOBAD 0x020055 ++ ++/* Entry dirdata length set incorrectly */ ++#define PR_2_CLEAR_DIRDATA 0x020056 ++ + /* + * Pass 3 errors + */ +@@ -1134,6 +1187,9 @@ struct problem_context { + /* Lost+found is encrypted */ + #define PR_3_LPF_ENCRYPTED 0x03001B + ++/* Recursively looped directory inode */ ++#define PR_3_LOOPED_DIR 0x03001D ++ + /* + * Pass 3a --- rehashing directories + */ +@@ -1273,6 +1329,9 @@ struct problem_context { + /* Block bitmap checksum does not match */ + #define PR_5_BLOCK_BITMAP_CSUM_INVALID 0x05001B + ++/* Expand the inodes which need a new EA block */ ++#define PR_5_EXPAND_EISIZE 0x05001C ++ + /* + * Post-Pass 5 errors + */ +@@ -1299,7 +1358,12 @@ struct problem_context { + /* + * Function declarations + */ +-int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx); ++#define fix_problem(ctx, code, pctx) \ ++ fix_problem_bad(ctx, code, pctx, 1) ++#define fix_problem_bad(ctx, code, pctx, badness) \ ++ fix_problem_loc(ctx, code, pctx, badness, __func__, __LINE__) ++int fix_problem_loc(e2fsck_t ctx, problem_t code, struct problem_context *pctx, ++ int badness, const char *func, const int line); + int end_problem_latch(e2fsck_t ctx, int mask); + int set_latch_flags(int mask, int setflags, int clearflags); + int get_latch_flags(int mask, int *value); +diff --git a/e2fsck/rehash.c b/e2fsck/rehash.c +index 8cc36f2..3dcdd67 100644 +--- a/e2fsck/rehash.c ++++ b/e2fsck/rehash.c +@@ -86,6 +86,8 @@ struct fill_dir_struct { + int compress; + ext2_ino_t parent; + ext2_ino_t dir; ++ struct ext2_dir_entry *dot_de; ++ struct ext2_dir_entry *dotdot_de; + }; + + struct hash_entry { +@@ -187,11 +189,14 @@ static int fill_dir_block(ext2_filsys fs, + return BLOCK_ABORT; + } + if (!fd->compress && (name_len == 1) && +- (dirent->name[0] == '.')) ++ (dirent->name[0] == '.')) { ++ fd->dot_de = dirent; + continue; ++ } + if (!fd->compress && (name_len == 2) && + (dirent->name[0] == '.') && (dirent->name[1] == '.')) { + fd->parent = dirent->inode; ++ fd->dotdot_de = dirent; + continue; + } + if (fd->num_array >= fd->max_array) { +@@ -209,7 +214,7 @@ static int fill_dir_block(ext2_filsys fs, + } + ent = fd->harray + fd->num_array++; + ent->dir = dirent; +- fd->dir_size += ext2fs_dir_rec_len(name_len, extended); ++ fd->dir_size += ext2fs_dirdata_rec_len(dirent, extended); + ent->ino = dirent->inode; + if (extended) { + ent->hash = EXT2_DIRENT_HASH(dirent); +@@ -585,8 +590,7 @@ static errcode_t copy_dir_entries(e2fsck_t ctx, + ent = fd->harray + i; + if (ent->dir->inode == 0) + continue; +- rec_len = ext2fs_dir_rec_len(ext2fs_dirent_name_len(ent->dir), +- hash_in_entry); ++ rec_len = ext2fs_dirdata_rec_len(ent->dir, hash_in_entry); + if (rec_len > left) { + if (left) { + left += prev_rec_len; +@@ -621,8 +625,7 @@ static errcode_t copy_dir_entries(e2fsck_t ctx, + if (retval) + return retval; + prev_rec_len = rec_len; +- memcpy(dirent->name, ent->dir->name, +- ext2fs_dirent_name_len(dirent)); ++ memcpy(dirent->name, ent->dir->name, rec_len); + if (hash_in_entry) { + EXT2_DIRENT_HASHES(dirent)->hash = ext2fs_cpu_to_le32(ent->hash); + EXT2_DIRENT_HASHES(dirent)->minor_hash = +@@ -653,47 +656,52 @@ static errcode_t copy_dir_entries(e2fsck_t ctx, + + static struct ext2_dx_root_info *set_root_node(ext2_filsys fs, char *buf, + ext2_ino_t ino, ext2_ino_t parent, ++ struct ext2_dir_entry *dot_de, ++ struct ext2_dir_entry *dotdot_de, + struct ext2_inode *inode) + { +- struct ext2_dir_entry *dir; +- struct ext2_dx_root_info *root; ++ struct ext2_dir_entry *dirent; ++ struct ext2_dx_root_info *root; + struct ext2_dx_countlimit *limits; +- int filetype = 0; + int csum_size = 0; +- +- if (ext2fs_has_feature_filetype(fs->super)) +- filetype = EXT2_FT_DIR; ++ int offset; ++ int rec_len; + + memset(buf, 0, fs->blocksize); +- dir = (struct ext2_dir_entry *) buf; +- dir->inode = ino; +- dir->name[0] = '.'; +- ext2fs_dirent_set_name_len(dir, 1); +- ext2fs_dirent_set_file_type(dir, filetype); +- dir->rec_len = 12; +- dir = (struct ext2_dir_entry *) (buf + 12); +- dir->inode = parent; +- dir->name[0] = '.'; +- dir->name[1] = '.'; +- ext2fs_dirent_set_name_len(dir, 2); +- ext2fs_dirent_set_file_type(dir, filetype); +- dir->rec_len = fs->blocksize - 12; +- +- root = (struct ext2_dx_root_info *) (buf+24); ++ dirent = (struct ext2_dir_entry *) buf; ++ dirent->inode = ino; ++ ++ dirent->name_len = dot_de->name_len; ++ offset = rec_len = dirent->rec_len = dot_de->rec_len; ++ memcpy(dirent->name, dot_de->name, rec_len); ++ ++ dirent = EXT2_NEXT_DIRENT(dirent); ++ /* set to jump over the index block */ ++ ++ dirent->inode = parent; ++ ++ dirent->name_len = dotdot_de->name_len; ++ dirent->rec_len = fs->blocksize - rec_len; ++ rec_len = EXT2_DIR_REC_LEN(dotdot_de); ++ memcpy(dirent->name, dotdot_de->name, rec_len); ++ offset += rec_len; ++ ++ root = (struct ext2_dx_root_info *)(buf + offset); + root->reserved_zero = 0; + if (ext4_hash_in_dirent(inode)) + root->hash_version = EXT2_HASH_SIPHASH; + else + root->hash_version = fs->super->s_def_hash_version; +- root->info_length = 8; ++ root->info_length = sizeof(*root); + root->indirect_levels = 0; + root->unused_flags = 0; ++ offset += root->info_length; + + if (ext2fs_has_feature_metadata_csum(fs->super)) + csum_size = sizeof(struct ext2_dx_tail); + +- limits = (struct ext2_dx_countlimit *) (buf+32); +- limits->limit = (fs->blocksize - (32 + csum_size)) / ++ limits = (struct ext2_dx_countlimit *) (buf + offset); ++ limits->limit = (fs->blocksize - (offset + csum_size)) / + sizeof(struct ext2_dx_entry); + limits->count = 0; + +@@ -771,6 +779,8 @@ static errcode_t calculate_tree(ext2_filsys fs, + struct out_dir *outdir, + ext2_ino_t ino, + ext2_ino_t parent, ++ struct ext2_dir_entry *dot_de, ++ struct ext2_dir_entry *dotdot_de, + struct ext2_inode *inode) + { + struct ext2_dx_root_info *root_info; +@@ -780,7 +790,9 @@ static errcode_t calculate_tree(ext2_filsys fs, + int i, c1, c2, c3, nblks; + int limit_offset, int_offset, root_offset; + +- root_info = set_root_node(fs, outdir->buf, ino, parent, inode); ++ root_info = set_root_node(fs, outdir->buf, ino, parent, dot_de, ++ dotdot_de, inode); ++ + root_offset = limit_offset = ((char *) root_info - outdir->buf) + + root_info->info_length; + root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset); +@@ -1083,11 +1095,10 @@ resort: + if (retval) + goto errout; + +- free(dir_buf); dir_buf = 0; +- + if (!fd.compress) { + /* Calculate the interior nodes */ +- retval = calculate_tree(fs, &outdir, ino, fd.parent, fd.inode); ++ retval = calculate_tree(fs, &outdir, ino, fd.parent, ++ fd.dot_de, fd.dotdot_de, fd.inode); + if (retval) + goto errout; + } +diff --git a/e2fsck/super.c b/e2fsck/super.c +index 3105dd5..6ffbf77 100644 +--- a/e2fsck/super.c ++++ b/e2fsck/super.c +@@ -1044,8 +1044,8 @@ void check_super_block(e2fsck_t ctx) + * write time is in the future. + */ + if (((ctx->options & E2F_OPT_FORCE) || fs->super->s_checkinterval) && +- !broken_system_clock && !(ctx->flags & E2F_FLAG_TIME_INSANE) && +- (fs->super->s_mtime > (__u32) ctx->now)) { ++ !broken_system_clock && ++ EXT4_XTIME_FUTURE(ctx, fs->super, fs->super->s_mtime, 0)) { + pctx.num = fs->super->s_mtime; + problem = PR_0_FUTURE_SB_LAST_MOUNT; + if (fs->super->s_mtime <= (__u32) ctx->now + ctx->time_fudge) +@@ -1056,8 +1056,8 @@ void check_super_block(e2fsck_t ctx) + } + } + if (((ctx->options & E2F_OPT_FORCE) || fs->super->s_checkinterval) && +- !broken_system_clock && !(ctx->flags & E2F_FLAG_TIME_INSANE) && +- (fs->super->s_wtime > (__u32) ctx->now)) { ++ !broken_system_clock && ++ EXT4_XTIME_FUTURE(ctx, fs->super, fs->super->s_wtime, 0)) { + pctx.num = fs->super->s_wtime; + problem = PR_0_FUTURE_SB_LAST_WRITE; + if (fs->super->s_wtime <= (__u32) ctx->now + ctx->time_fudge) +diff --git a/e2fsck/unix.c b/e2fsck/unix.c +index 96b9c1e..7539f60 100644 +--- a/e2fsck/unix.c ++++ b/e2fsck/unix.c +@@ -662,6 +662,49 @@ static void signal_cancel(int sig EXT2FS_ATTR((unused))) + } + #endif + ++static void initialize_profile_options(e2fsck_t ctx) ++{ ++ char *tmp; ++ ++ /* [options] shared=preserve|lost+found|delete */ ++ tmp = NULL; ++ ctx->shared = E2F_SHARED_PRESERVE; ++ profile_get_string(ctx->profile, "options", "shared", 0, ++ "preserve", &tmp); ++ if (tmp) { ++ if (strcmp(tmp, "preserve") == 0) ++ ctx->shared = E2F_SHARED_PRESERVE; ++ else if (strcmp(tmp, "delete") == 0) ++ ctx->shared = E2F_SHARED_DELETE; ++ else if (strcmp(tmp, "lost+found") == 0) ++ ctx->shared = E2F_SHARED_LPF; ++ else { ++ com_err(ctx->program_name, 0, ++ _("configuration error: 'shared=%s'"), tmp); ++ fatal_error(ctx, 0); ++ } ++ free(tmp); ++ } ++ ++ /* [options] clone=dup|zero */ ++ tmp = NULL; ++ ctx->clone = E2F_CLONE_DUP; ++ profile_get_string(ctx->profile, "options", "clone", 0, ++ "dup", &tmp); ++ if (tmp) { ++ if (strcmp(tmp, "dup") == 0) ++ ctx->clone = E2F_CLONE_DUP; ++ else if (strcmp(tmp, "zero") == 0) ++ ctx->clone = E2F_CLONE_ZERO; ++ else { ++ com_err(ctx->program_name, 0, ++ _("configuration error: 'clone=%s'"), tmp); ++ fatal_error(ctx, 0); ++ } ++ free(tmp); ++ } ++} ++ + static void parse_extended_opts(e2fsck_t ctx, const char *opts) + { + char *buf, *token, *next, *p, *arg; +@@ -712,6 +755,58 @@ static void parse_extended_opts(e2fsck_t ctx, const char *opts) + } else if (strcmp(token, "fragcheck") == 0) { + ctx->options |= E2F_OPT_FRAGCHECK; + continue; ++ /* -E shared=preserve|lost+found|delete */ ++ } else if (strcmp(token, "shared") == 0) { ++ if (!arg) { ++ extended_usage++; ++ continue; ++ } ++ if (strcmp(arg, "preserve") == 0) { ++ ctx->shared = E2F_SHARED_PRESERVE; ++ } else if (strcmp(arg, "lost+found") == 0) { ++ ctx->shared = E2F_SHARED_LPF; ++ } else if (strcmp(arg, "delete") == 0) { ++ ctx->shared = E2F_SHARED_DELETE; ++ } else { ++ extended_usage++; ++ continue; ++ } ++ /* -E clone=dup|zero */ ++ } else if (strcmp(token, "clone") == 0) { ++ if (!arg) { ++ extended_usage++; ++ continue; ++ } ++ if (strcmp(arg, "dup") == 0) { ++ ctx->clone = E2F_CLONE_DUP; ++ } else if (strcmp(arg, "zero") == 0) { ++ ctx->clone = E2F_CLONE_ZERO; ++ } else { ++ extended_usage++; ++ continue; ++ } ++ } else if (strcmp(token, "expand_extra_isize") == 0) { ++ ctx->flags |= E2F_FLAG_EXPAND_EISIZE; ++ if (arg) { ++ extended_usage++; ++ continue; ++ } ++ /* -E inode_badness_threshold= */ ++ } else if (strcmp(token, "inode_badness_threshold") == 0) { ++ unsigned int val; ++ ++ if (!arg) { ++ extended_usage++; ++ continue; ++ } ++ val = strtoul(arg, &p, 0); ++ if (*p != '\0' || (val < 3 && val != 0) || val > 200) { ++ fprintf(stderr, _("Invalid badness '%s'\n"), ++ arg); ++ extended_usage++; ++ continue; ++ } ++ ctx->inode_badness_threshold = val; + } else if (strcmp(token, "journal_only") == 0) { + if (arg) { + extended_usage++; +@@ -784,6 +879,10 @@ static void parse_extended_opts(e2fsck_t ctx, const char *opts) + fputs("\tjournal_only\n", stderr); + fputs("\tdiscard\n", stderr); + fputs("\tnodiscard\n", stderr); ++ fputs(("\tshared=\n"), stderr); ++ fputs(("\tclone=\n"), stderr); ++ fputs(("\texpand_extra_isize\n"), stderr); ++ fputs(("\tinode_badness_threhold=(value)\n"), stderr); + fputs("\toptimize_extents\n", stderr); + fputs("\tno_optimize_extents\n", stderr); + fputs("\tinode_count_fullmap\n", stderr); +@@ -820,7 +919,6 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) + #ifdef HAVE_SIGNAL_H + struct sigaction sa; + #endif +- char *extended_opts = 0; + char *cp; + int res; /* result of sscanf */ + #ifdef CONFIG_JBD_DEBUG +@@ -858,8 +956,17 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) + else + ctx->program_name = "e2fsck"; + ++ cp = getenv("E2FSCK_CONFIG"); ++ if (cp != NULL) ++ config_fn[0] = cp; ++ profile_set_syntax_err_cb(syntax_err_report); ++ profile_init(config_fn, &ctx->profile); ++ ++ initialize_profile_options(ctx); ++ + phys_mem_kb = get_memory_size() / 1024; + ctx->readahead_kb = ~0ULL; ++ ctx->inode_badness_threshold = BADNESS_THRESHOLD; + + #ifdef HAVE_PTHREAD + while ((c = getopt(argc, argv, "pam:nyrcC:B:dE:fvtFVM:b:I:j:P:l:L:N:SsDkz:")) != EOF) +@@ -895,7 +1002,7 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) + ctx->options |= E2F_OPT_COMPRESS_DIRS; + break; + case 'E': +- extended_opts = optarg; ++ parse_extended_opts(ctx, optarg); + break; + case 'p': + case 'a': +@@ -1062,8 +1169,6 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) + argv[optind]); + fatal_error(ctx, 0); + } +- if (extended_opts) +- parse_extended_opts(ctx, extended_opts); + + /* Complain about mutually exclusive rebuilding activities */ + if (getenv("E2FSCK_FIXES_ONLY")) +@@ -1081,11 +1186,6 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) + fatal_error(ctx, 0); + } + +- if ((cp = getenv("E2FSCK_CONFIG")) != NULL) +- config_fn[0] = cp; +- profile_set_syntax_err_cb(syntax_err_report); +- profile_init(config_fn, &ctx->profile); +- + profile_get_boolean(ctx->profile, "options", "report_time", 0, 0, + &c); + if (c) +@@ -1876,6 +1976,14 @@ print_unsupp_features: + goto get_newer; + } + ++ if (ext2fs_has_feature_dirdata(sb) && ++ ext2fs_has_feature_casefold(sb)) { ++ com_err(ctx->program_name, 0, ++ _("%s has both casefold and dirdata, aborting fsck"), ++ ctx->filesystem_name); ++ fatal_error(ctx, 0); ++ } ++ + if (ext2fs_has_feature_casefold(sb) && !fs->encoding) { + log_err(ctx, _("%s has unsupported encoding: %0x\n"), + ctx->filesystem_name, sb->s_encoding); +@@ -1912,6 +2020,52 @@ print_unsupp_features: + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + fatal_error(ctx, 0); + check_if_skip(ctx); ++ ++ if (EXT2_GOOD_OLD_INODE_SIZE + sb->s_want_extra_isize > ++ EXT2_INODE_SIZE(sb)) { ++ if (fix_problem(ctx, PR_0_WANT_EXTRA_ISIZE_INVALID, &pctx)) ++ sb->s_want_extra_isize = ++ sizeof(struct ext2_inode_large) - ++ EXT2_GOOD_OLD_INODE_SIZE; ++ } ++ if (EXT2_GOOD_OLD_INODE_SIZE + sb->s_min_extra_isize > ++ EXT2_INODE_SIZE(sb)) { ++ if (fix_problem(ctx, PR_0_MIN_EXTRA_ISIZE_INVALID, &pctx)) ++ sb->s_min_extra_isize = 0; ++ } ++ if (EXT2_INODE_SIZE(sb) > EXT2_GOOD_OLD_INODE_SIZE) { ++ ctx->want_extra_isize = sizeof(struct ext2_inode_large) - ++ EXT2_GOOD_OLD_INODE_SIZE; ++ ctx->min_extra_isize = ~0L; ++ if (EXT2_HAS_RO_COMPAT_FEATURE(sb, ++ EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE)) { ++ if (ctx->want_extra_isize < sb->s_want_extra_isize) ++ ctx->want_extra_isize = sb->s_want_extra_isize; ++ if (ctx->want_extra_isize < sb->s_min_extra_isize) ++ ctx->want_extra_isize = sb->s_min_extra_isize; ++ } ++ } else { ++ /* Leave extra_isize set, it is harmless, and clearing it ++ * here breaks some regression tests by printing an extra ++ * message to the output for very little value. */ ++ sb->s_want_extra_isize = 0; ++ sb->s_min_extra_isize = 0; ++ ctx->flags &= ~E2F_FLAG_EXPAND_EISIZE; ++ } ++ ++ if (ctx->options & E2F_OPT_READONLY) { ++ if (ctx->flags & (E2F_FLAG_EXPAND_EISIZE)) { ++ fprintf(stderr, _("Cannot enable EXTRA_ISIZE feature " ++ "on read-only filesystem\n")); ++ exit(1); ++ } ++ } else { ++ if (sb->s_want_extra_isize > sb->s_min_extra_isize && ++ (sb->s_feature_ro_compat & ++ EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE)) ++ ctx->flags |= E2F_FLAG_EXPAND_EISIZE; ++ } ++ + check_resize_inode(ctx); + if (bad_blocks_file) + read_bad_blocks_file(ctx, bad_blocks_file, replace_bad_blocks); +diff --git a/e2fsck/util.c b/e2fsck/util.c +index 7dd565c..6dff68e 100644 +--- a/e2fsck/util.c ++++ b/e2fsck/util.c +@@ -107,7 +107,6 @@ void log_out(e2fsck_t ctx, const char *fmt, ...) + int buf_size; + int msg_size; + int left_size; +- int fmt_length = strlen(fmt); + + #ifdef HAVE_PTHREAD + if ((ctx->options & E2F_OPT_MULTITHREAD) && ctx->global_ctx) { +diff --git a/lib/e2p/feature.c b/lib/e2p/feature.c +index 2291060..b532ec7 100644 +--- a/lib/e2p/feature.c ++++ b/lib/e2p/feature.c +@@ -103,6 +103,8 @@ static struct feature feature_list[] = { + "flex_bg"}, + { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_EA_INODE, + "ea_inode"}, ++ { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_EA_INODE, ++ "large_xattr"}, + { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_DIRDATA, + "dirdata"}, + { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_CSUM_SEED, +diff --git a/lib/ext2fs/Makefile.in b/lib/ext2fs/Makefile.in +index 2dca12e..ab85c6d 100644 +--- a/lib/ext2fs/Makefile.in ++++ b/lib/ext2fs/Makefile.in +@@ -27,6 +27,8 @@ DEBUG_OBJS= debug_cmds.o extent_cmds.o tst_cmds.o debugfs.o util.o \ + xattrs.o quota.o tst_libext2fs.o create_inode.o journal.o \ + revoke.o recovery.o do_journal.o + ++QUOTA_LIB_OBJS= mkquota.o quotaio.o quotaio_v2.o quotaio_tree.o dict.o ++ + DEBUG_SRCS= debug_cmds.c extent_cmds.c tst_cmds.c \ + $(top_srcdir)/debugfs/debugfs.c \ + $(top_srcdir)/debugfs/util.c \ +@@ -54,6 +56,7 @@ DEBUG_SRCS= debug_cmds.c extent_cmds.c tst_cmds.c \ + @TDB_CMT@TDB_OBJ= tdb.o + + OBJS= $(DEBUGFS_LIB_OBJS) $(RESIZE_LIB_OBJS) $(E2IMAGE_LIB_OBJS) \ ++ $(QUOTA_LIB_OBJS) \ + $(TEST_IO_LIB_OBJS) \ + ext2_err.o \ + alloc.o \ +@@ -216,6 +219,7 @@ SRCS= ext2_err.c \ + $(srcdir)/tst_byteswap.c \ + $(srcdir)/tst_getsize.c \ + $(srcdir)/tst_iscan.c \ ++ $(srcdir)/tst_read_ea.c \ + $(srcdir)/undo_io.c \ + $(srcdir)/@OS_IO_FILE@.c \ + $(srcdir)/sparse_io.c \ +@@ -229,6 +233,7 @@ SRCS= ext2_err.c \ + + HFILES= bitops.h ext2fs.h ext2_io.h ext2_fs.h ext2_ext_attr.h ext3_extents.h \ + tdb.h qcow2.h hashmap.h ++QUOTA_HFILES= quotaio.h dqblk_v2.h quotaio_tree.h + HFILES_IN= ext2_err.h ext2_types.h + + LIBRARY= libext2fs +@@ -297,6 +302,11 @@ tst_iscan: tst_iscan.o $(STATIC_LIBEXT2FS) $(DEPSTATIC_LIBCOM_ERR) + $(Q) $(CC) -o tst_iscan tst_iscan.o $(ALL_LDFLAGS) \ + $(STATIC_LIBEXT2FS) $(STATIC_LIBCOM_ERR) $(SYSLIBS) + ++tst_read_ea: tst_read_ea.o $(STATIC_LIBEXT2FS) $(DEPSTATIC_LIBCOM_ERR) ++ $(E) " LD $@" ++ $(Q) $(CC) -o tst_read_ea tst_read_ea.o $(STATIC_LIBEXT2FS) \ ++ $(STATIC_LIBCOM_ERR) ++ + tst_getsize: tst_getsize.o $(STATIC_LIBEXT2FS) $(DEPSTATIC_LIBCOM_ERR) + $(E) " LD $@" + $(Q) $(CC) -o tst_getsize tst_getsize.o $(ALL_LDFLAGS) \ +@@ -448,6 +458,41 @@ do_journal.o: $(top_srcdir)/debugfs/do_journal.c + $(E) " CC $<" + $(Q) $(CC) $(DEBUGFS_CFLAGS) -c $< -o $@ + ++mkquota.o: $(top_srcdir)/lib/support/mkquota.c ++ $(E) " CC $<" ++ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_STLIB) -c $< -o $@ ++@PROFILE_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_STLIB) -g -pg -o profiled/$*.o -c $< ++@ELF_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_SHLIB) -fPIC -shared -o elfshared/$*.o -c $< ++@BSDLIB_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_SHLIB) $(BSDLIB_PIC_FLAG) -o pic/$*.o -c $< ++ ++quotaio.o: $(top_srcdir)/lib/support/quotaio.c ++ $(E) " CC $<" ++ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_STLIB) -c $< -o $@ ++@PROFILE_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_STLIB) -g -pg -o profiled/$*.o -c $< ++@ELF_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_SHLIB) -fPIC -shared -o elfshared/$*.o -c $< ++@BSDLIB_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_SHLIB) $(BSDLIB_PIC_FLAG) -o pic/$*.o -c $< ++ ++quotaio_v2.o: $(top_srcdir)/lib/support/quotaio_v2.c ++ $(E) " CC $<" ++ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_STLIB) -c $< -o $@ ++@PROFILE_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_STLIB) -g -pg -o profiled/$*.o -c $< ++@ELF_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_SHLIB) -fPIC -shared -o elfshared/$*.o -c $< ++@BSDLIB_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_SHLIB) $(BSDLIB_PIC_FLAG) -o pic/$*.o -c $< ++ ++quotaio_tree.o: $(top_srcdir)/lib/support/quotaio_tree.c ++ $(E) " CC $<" ++ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_STLIB) -c $< -o $@ ++@PROFILE_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_STLIB) -g -pg -o profiled/$*.o -c $< ++@ELF_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_SHLIB) -fPIC -shared -o elfshared/$*.o -c $< ++@BSDLIB_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_SHLIB) $(BSDLIB_PIC_FLAG) -o pic/$*.o -c $< ++ ++dict.o: $(top_srcdir)/lib/support/dict.c ++ $(E) " CC $<" ++ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_STLIB) -c $< -o $@ ++@PROFILE_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_STLIB) -g -pg -o profiled/$*.o -c $< ++@ELF_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_SHLIB) -fPIC -shared -o elfshared/$*.o -c $< ++@BSDLIB_CMT@ $(Q) $(CC) -I$(top_srcdir)/lib/support $(ALL_CFLAGS_SHLIB) $(BSDLIB_PIC_FLAG) -o pic/$*.o -c $< ++ + xattrs.o: $(top_srcdir)/debugfs/xattrs.c + $(E) " CC $<" + $(Q) $(CC) $(DEBUGFS_CFLAGS) -c $< -o $@ +@@ -528,7 +573,7 @@ mkjournal: mkjournal.c $(STATIC_LIBEXT2FS) $(DEPLIBCOM_ERR) + $(Q) $(CC) -o mkjournal $(srcdir)/mkjournal.c -DDEBUG \ + $(STATIC_LIBEXT2FS) $(LIBCOM_ERR) $(ALL_CFLAGS) $(SYSLIBS) + +-fullcheck check:: tst_bitops tst_badblocks tst_iscan tst_types tst_icount \ ++fullcheck check:: tst_bitops tst_badblocks tst_iscan tst_types tst_icount tst_read_ea \ + tst_super_size tst_types tst_inode_size tst_csum tst_crc32c tst_bitmaps \ + tst_inline tst_inline_data tst_libext2fs tst_sha256 tst_sha512 \ + tst_digest_encode tst_getsize tst_getsectsize +@@ -537,6 +582,7 @@ fullcheck check:: tst_bitops tst_badblocks tst_iscan tst_types tst_icount \ + $(TESTENV) ./tst_iscan + $(TESTENV) ./tst_types + $(TESTENV) ./tst_icount ++ $(TESTENV) ./tst_read_ea + $(TESTENV) ./tst_super_size + $(TESTENV) ./tst_inode_size + $(TESTENV) ./tst_csum +@@ -569,6 +615,10 @@ install:: all $(HFILES) $(HFILES_IN) installdirs ext2fs.pc + echo " INSTALL_DATA $(includedir)/ext2fs/$$i"; \ + $(INSTALL_DATA) $(srcdir)/$$i $(DESTDIR)$(includedir)/ext2fs/$$i; \ + done ++ $(Q) for i in $(QUOTA_HFILES); do \ ++ echo " INSTALL_DATA $(includedir)/ext2fs/$$i"; \ ++ $(INSTALL_DATA) $(top_srcdir)/lib/support/$$i $(DESTDIR)$(includedir)/ext2fs/$$i; \ ++ done + $(Q) for i in $(HFILES_IN); do \ + echo " INSTALL_DATA $(includedir)/ext2fs/$$i"; \ + $(INSTALL_DATA) $$i $(DESTDIR)$(includedir)/ext2fs/$$i; \ +@@ -586,7 +636,7 @@ clean:: + tst_badblocks tst_iscan ext2_err.et ext2_err.c ext2_err.h \ + tst_byteswap tst_ismounted tst_getsize tst_getsectsize \ + tst_bitops tst_types tst_icount tst_super_size tst_csum \ +- tst_bitmaps tst_bitmaps_out tst_extents tst_inline \ ++ tst_read_ea tst_bitmaps tst_bitmaps_out tst_extents tst_inline \ + tst_inline_data tst_inode_size tst_bitmaps_cmd.c \ + tst_digest_encode tst_sha256 tst_sha512 \ + ext2_tdbtool mkjournal debug_cmds.c tst_cmds.c extent_cmds.c \ +@@ -1154,6 +1204,11 @@ tst_iscan.o: $(srcdir)/tst_iscan.c $(top_builddir)/lib/config.h \ + $(srcdir)/ext2_fs.h $(srcdir)/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ + $(srcdir)/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h \ + $(srcdir)/ext2_ext_attr.h $(srcdir)/hashmap.h $(srcdir)/bitops.h ++tst_read_ea.o: $(srcdir)/tst_read_ea.c $(srcdir)/ext2_fs.h \ ++ $(top_builddir)/lib/ext2fs/ext2_types.h $(srcdir)/ext2fs.h \ ++ $(srcdir)/ext2_fs.h $(srcdir)/ext3_extents.h $(top_srcdir)/lib/et/com_err.h \ ++ $(srcdir)/ext2_io.h $(top_builddir)/lib/ext2fs/ext2_err.h \ ++ $(srcdir)/ext2_ext_attr.h $(srcdir)/hashmap.h $(srcdir)/bitops.h + undo_io.o: $(srcdir)/undo_io.c $(top_builddir)/lib/config.h \ + $(top_builddir)/lib/dirpaths.h $(srcdir)/ext2_fs.h \ + $(top_builddir)/lib/ext2fs/ext2_types.h $(srcdir)/ext2fs.h \ +diff --git a/lib/ext2fs/dirblock.c b/lib/ext2fs/dirblock.c +index 54b2777..3563138 100644 +--- a/lib/ext2fs/dirblock.c ++++ b/lib/ext2fs/dirblock.c +@@ -50,6 +50,39 @@ errcode_t ext2fs_read_dir_block3(ext2_filsys fs, blk64_t block, + return ext2fs_read_dir_block4(fs, block, buf, flags, 0); + } + ++/* ++ * Compute the dirdata length. This includes only optional extensions. ++ * Each extension has a bit set in the high 4 bits of ++ * de->file_type, and the extension length is the first byte in each entry. ++ */ ++int ext2_get_dirdata_field_size(struct ext2_dir_entry *de, ++ char dirdata_flags) ++{ ++ char *lenp = de->name + (de->name_len & EXT2_NAME_LEN) + 1 /* NUL */; ++ __u8 extra_data_flags = (de->name_len & ~(EXT2_FT_MASK << 8)) >> 12; ++ int dlen = 0; ++ ++ dirdata_flags >>= 4; ++ while ((extra_data_flags & dirdata_flags) != 0) { ++ if (extra_data_flags & 1) { ++ if (dirdata_flags & 1) ++ dlen += *lenp; ++ ++ lenp += *lenp; ++ } ++ extra_data_flags >>= 1; ++ dirdata_flags >>= 1; ++ } ++ ++ /* add NUL terminator byte to dirdata length */ ++ return dlen + (dlen != 0); ++} ++ ++int ext2_get_dirdata_size(struct ext2_dir_entry *de) ++{ ++ return ext2_get_dirdata_field_size(de, ~EXT2_FT_MASK); ++} ++ + errcode_t ext2fs_read_dir_block2(ext2_filsys fs, blk_t block, + void *buf, int flags EXT2FS_ATTR((unused))) + { +diff --git a/lib/ext2fs/ext2_err.et.in b/lib/ext2fs/ext2_err.et.in +index 860b570..e7a872d 100644 +--- a/lib/ext2fs/ext2_err.et.in ++++ b/lib/ext2fs/ext2_err.et.in +@@ -554,4 +554,25 @@ ec EXT2_FILSYS_CORRUPTED, + ec EXT2_ET_SCAN_FINISHED, + "Scanning finished" + ++ec EXT2_ET_EA_BAD_MAGIC, ++ "Extended attribute block has bad magic value" ++ ++ec EXT2_ET_EA_BAD_ENTRIES, ++ "Extended attribute block has bad entries" ++ ++ec EXT2_ET_EA_TOO_BIG, ++ "Extended attribute too big for buffer" ++ ++ec EXT2_ET_EA_NAME_TOO_BIG, ++ "Extended attribute name too big for header" ++ ++ec EXT2_ET_EA_BAD_NAME, ++ "Extended attribute name is bad" ++ ++ec EXT2_ET_EA_NAME_NOT_FOUND, ++ "Extended attribute name not found" ++ ++ec EXT2_ET_EA_NAME_EXISTS, ++ "Extended attribute name already exists" ++ + end +diff --git a/lib/ext2fs/ext2_ext_attr.h b/lib/ext2fs/ext2_ext_attr.h +index f2042ed..5b560fe 100644 +--- a/lib/ext2fs/ext2_ext_attr.h ++++ b/lib/ext2fs/ext2_ext_attr.h +@@ -32,11 +32,40 @@ struct ext2_ext_attr_entry { + __u32 e_value_inum; /* inode in which the value is stored */ + __u32 e_value_size; /* size of attribute value */ + __u32 e_hash; /* hash value of name and value */ +-#if 0 ++#if 1 + char e_name[0]; /* attribute name */ + #endif + }; + ++struct ext2_xattr_ibody_header { ++ __u32 h_magic; /* EXT2_EXT_ATTR_MAGIC */ ++ struct ext2_ext_attr_entry h_first_entry[0]; ++}; ++ ++#define BHDR(block) ((struct ext2_ext_attr_header *)block) ++#define IHDR(inode) ((struct ext2_xattr_ibody_header *)((char *)inode + \ ++ EXT2_GOOD_OLD_INODE_SIZE + (inode)->i_extra_isize)) ++#define ENTRY(ptr) ((struct ext2_ext_attr_entry *)(ptr)) ++ ++/* Name indexes */ ++#define EXT2_ATTR_INDEX_USER 1 ++#define EXT2_ATTR_INDEX_POSIX_ACL_ACCESS 2 ++#define EXT2_ATTR_INDEX_POSIX_ACL_DEFAULT 3 ++#define EXT2_ATTR_INDEX_TRUSTED 4 ++#define EXT2_ATTR_INDEX_LUSTRE 5 ++#define EXT2_ATTR_INDEX_SECURITY 6 ++#define EXT2_ATTR_INDEX_MAX 7 ++ ++#define EXT2_ATTR_INDEX_USER_PREFIX "user." ++#define EXT2_ATTR_INDEX_POSIX_ACL_ACCESS_PREFIX "system.posix_acl_access" ++#define EXT2_ATTR_INDEX_POSIX_ACL_DEFAULT_PREFIX "system.posix_acl_default" ++#define EXT2_ATTR_INDEX_TRUSTED_PREFIX "trusted." ++#define EXT2_ATTR_INDEX_LUSTRE_PREFIX "lustre." ++#define EXT2_ATTR_INDEX_SECURITY_PREFIX "security." ++ ++#define EXT2_ATTR_PREFIX(index) (index ## _PREFIX) ++#define EXT2_ATTR_PREFIX_LEN(index) (index ## _PRE_LEN) ++ + #define EXT2_EXT_ATTR_PAD_BITS 2 + #define EXT2_EXT_ATTR_PAD ((unsigned) 1<= (sizeof(((struct ext2_inode_large *)0)->field) + \ + offsetof(struct ext2_inode_large, field))) + ++#define EXT2_FITS_IN_INODE(inode, field) \ ++ ((offsetof(struct ext2_inode_large, field) + \ ++ sizeof((inode)->field)) <= \ ++ (EXT2_GOOD_OLD_INODE_SIZE + \ ++ (inode)->i_extra_isize)) \ ++ + #if defined(__KERNEL__) || defined(__linux__) + #define i_reserved1 osd1.linux1.l_i_reserved1 + #define i_frag osd2.linux2.l_i_frag +@@ -969,12 +975,14 @@ EXT4_FEATURE_INCOMPAT_FUNCS(casefold, 4, CASEFOLD) + #define EXT2_FEATURE_INCOMPAT_SUPP (EXT2_FEATURE_INCOMPAT_FILETYPE| \ + EXT4_FEATURE_INCOMPAT_MMP| \ + EXT4_FEATURE_INCOMPAT_LARGEDIR| \ +- EXT4_FEATURE_INCOMPAT_EA_INODE) ++ EXT4_FEATURE_INCOMPAT_EA_INODE| \ ++ EXT4_FEATURE_INCOMPAT_DIRDATA) + #define EXT2_FEATURE_RO_COMPAT_SUPP (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \ + EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \ + EXT4_FEATURE_RO_COMPAT_DIR_NLINK| \ + EXT2_FEATURE_RO_COMPAT_BTREE_DIR| \ +- EXT4_FEATURE_RO_COMPAT_VERITY) ++ EXT4_FEATURE_RO_COMPAT_VERITY| \ ++ EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE) + + /* + * Default values for user and/or group using reserved blocks +@@ -1083,6 +1091,7 @@ struct ext2_dir_entry_tail { + #define EXT2_FT_SYMLINK 7 + + #define EXT2_FT_MAX 8 ++#define EXT2_FT_MASK 0x0f + + /* + * Annoyingly, e2fsprogs always swab16s ext2_dir_entry.name_len, so we +@@ -1092,6 +1101,9 @@ struct ext2_dir_entry_tail { + */ + #define EXT2_DIR_NAME_LEN_CSUM 0xDE00 + ++int ext2_get_dirdata_field_size(struct ext2_dir_entry *de, char dirdata_flags); ++int ext2_get_dirdata_size(struct ext2_dir_entry *de); ++ + /* + * EXT2_DIR_PAD defines the directory entries boundaries + * +@@ -1101,7 +1113,13 @@ struct ext2_dir_entry_tail { + #define EXT2_DIR_ENTRY_HASH_LEN 8 + #define EXT2_DIR_PAD 4 + #define EXT2_DIR_ROUND (EXT2_DIR_PAD - 1) +-#define EXT2_DIR_REC_LEN(name_len) ext2fs_dir_rec_len(name_len, 0) ++#define EXT2_DIR_NAME_LEN(name_len) (((name_len) + \ ++ EXT2_DIR_ENTRY_HEADER_LEN + \ ++ EXT2_DIR_ROUND) & \ ++ ~EXT2_DIR_ROUND) ++#define EXT2_DIR_REC_LEN(de) (EXT2_DIR_NAME_LEN(((de)->name_len & \ ++ EXT2_NAME_LEN) + \ ++ ext2_get_dirdata_size(de))) + + static inline unsigned int ext2fs_dir_rec_len(__u8 name_len, + int extended) +@@ -1114,6 +1132,20 @@ static inline unsigned int ext2fs_dir_rec_len(__u8 name_len, + return rec_len; + } + ++static inline unsigned int ext2fs_dirdata_rec_len(struct ext2_dir_entry *de, ++ int extended) ++{ ++ int rec_len = EXT2_DIR_REC_LEN(de); ++ ++ if (extended) ++ rec_len += EXT2_DIR_ENTRY_HASH_LEN; ++ return rec_len; ++} ++ ++/* lu_fid size and NUL char */ ++#define EXT2_DIRENT_LUFID_SIZE 16 ++#define EXT2_DIRENT_LUFID 0x10 ++ + /* + * Constants for ext4's extended time encoding + */ +@@ -1186,4 +1218,6 @@ struct mmp_struct { + + #define EXT4_ENC_STRICT_MODE_FL (1 << 0) /* Reject invalid sequences */ + ++#define EXT2_NEXT_DIRENT(d) ((void *)((char *)(d) + (d)->rec_len)) ++ + #endif /* _LINUX_EXT2_FS_H */ +diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h +index 06a1387..054b187 100644 +--- a/lib/ext2fs/ext2fs.h ++++ b/lib/ext2fs/ext2fs.h +@@ -621,6 +621,13 @@ typedef struct ext2_icount *ext2_icount_t; + #define EXT2_CHECK_MAGIC(struct, code) \ + if ((struct)->magic != (code)) return (code) + ++/* ++ * Flags for returning status of ext2fs_expand_extra_isize() ++ */ ++#define EXT2_EXPAND_EISIZE_UNSAFE 0x0001 ++#define EXT2_EXPAND_EISIZE_NEW_BLOCK 0x0002 ++#define EXT2_EXPAND_EISIZE_NOSPC 0x0004 ++ + /* + * Features supported by this version of the library + */ +@@ -647,6 +654,7 @@ typedef struct ext2_icount *ext2_icount_t; + EXT3_FEATURE_INCOMPAT_EXTENTS|\ + EXT4_FEATURE_INCOMPAT_FLEX_BG|\ + EXT4_FEATURE_INCOMPAT_EA_INODE|\ ++ EXT4_FEATURE_INCOMPAT_DIRDATA|\ + EXT4_LIB_INCOMPAT_MMP|\ + EXT4_FEATURE_INCOMPAT_64BIT|\ + EXT4_FEATURE_INCOMPAT_INLINE_DATA|\ +@@ -1267,11 +1275,25 @@ extern errcode_t ext2fs_dup_handle(ext2_filsys src, ext2_filsys *dest); + extern errcode_t ext2fs_expand_dir(ext2_filsys fs, ext2_ino_t dir); + + /* ext_attr.c */ ++extern errcode_t ext2fs_attr_get(ext2_filsys fs, struct ext2_inode *inode, ++ int name_index, const char *name, char *buffer, ++ size_t buffer_size, int *easize); ++ + extern __u32 ext2fs_ext_attr_hash_entry(struct ext2_ext_attr_entry *entry, + void *data); + extern errcode_t ext2fs_ext_attr_hash_entry2(ext2_filsys fs, + struct ext2_ext_attr_entry *entry, + void *data, __u32 *hash); ++int ext2fs_attr_get_next_attr(struct ext2_ext_attr_entry *entry, int name_index, ++ char *buffer, int buffer_size, int start); ++errcode_t ext2fs_attr_set(ext2_filsys fs, ext2_ino_t ino, ++ struct ext2_inode *inode, ++ int name_index, const char *name, const char *value, ++ int value_len, int flags); ++extern errcode_t ext2fs_expand_extra_isize(ext2_filsys fs, ext2_ino_t ino, ++ struct ext2_inode_large *inode, ++ int new_extra_isize, int *ret, ++ int *needed_size); + extern errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf); + extern errcode_t ext2fs_read_ext_attr2(ext2_filsys fs, blk64_t block, + void *buf); +@@ -1295,9 +1317,12 @@ extern errcode_t ext2fs_adjust_ea_refcount3(ext2_filsys fs, blk64_t blk, + ext2_ino_t inum); + errcode_t ext2fs_xattrs_write(struct ext2_xattr_handle *handle); + errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle); ++errcode_t ext2fs_xattrs_read_inode(struct ext2_xattr_handle *handle, ++ struct ext2_inode_large *inode); + errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h, + int (*func)(char *name, char *value, +- size_t value_len, void *data), ++ size_t value_len, ++ ext2_ino_t inode_num, void *data), + void *data); + errcode_t ext2fs_xattr_get(struct ext2_xattr_handle *h, const char *key, + void **value, size_t *value_len); +@@ -1525,6 +1550,7 @@ extern errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs, int super_only); + + /* icount.c */ + extern void ext2fs_free_icount(ext2_icount_t icount); ++extern int ext2fs_icount_is_set(ext2_icount_t icount, ext2_ino_t ino); + extern errcode_t ext2fs_create_icount_tdb(ext2_filsys fs, char *tdb_dir, + int flags, ext2_icount_t *ret); + extern errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, +@@ -2128,6 +2154,25 @@ _INLINE_ int ext2fs_htree_intnode_maxrecs(ext2_filsys fs, int blocks) + sizeof(struct ext2_dx_entry)); + } + ++_INLINE_ struct ext2_dx_root_info *get_ext2_dx_root_info(ext2_filsys fs, ++ char *buf) ++{ ++ struct ext2_dir_entry *de = (struct ext2_dir_entry *)buf; ++ ++ if (!(fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_DIRDATA)) ++ return (struct ext2_dx_root_info *)(buf + ++ EXT2_DIR_NAME_LEN(1) + ++ EXT2_DIR_NAME_LEN(2)); ++ ++ /* get dotdot first */ ++ de = (struct ext2_dir_entry *)((char *)de + de->rec_len); ++ ++ /* dx root info is after dotdot entry */ ++ de = (struct ext2_dir_entry *)((char *)de + EXT2_DIR_REC_LEN(de)); ++ ++ return (struct ext2_dx_root_info *)de; ++} ++ + /* + * This is an efficient, overflow safe way of calculating ceil((1.0 * a) / b) + */ +@@ -2147,7 +2192,7 @@ _INLINE_ __u64 ext2fs_div64_ceil(__u64 a, __u64 b) + + _INLINE_ int ext2fs_dirent_name_len(const struct ext2_dir_entry *entry) + { +- return entry->name_len & 0xff; ++ return entry->name_len & EXT2_NAME_LEN; + } + + _INLINE_ void ext2fs_dirent_set_name_len(struct ext2_dir_entry *entry, int len) +diff --git a/lib/ext2fs/ext2fsP.h b/lib/ext2fs/ext2fsP.h +index d2045af..9e4300c 100644 +--- a/lib/ext2fs/ext2fsP.h ++++ b/lib/ext2fs/ext2fsP.h +@@ -207,3 +207,6 @@ errcode_t ext2fs_add_exit_fn(ext2_exit_fn fn, void *data); + errcode_t ext2fs_remove_exit_fn(ext2_exit_fn fn, void *data); + + #define EXT2FS_BUILD_BUG_ON(cond) ((void)sizeof(char[1 - 2*!!(cond)])) ++ ++extern int ext2fs_is_before_linux_ver(unsigned int major, unsigned int minor, ++ unsigned int rev); +diff --git a/lib/ext2fs/ext4_acl.h b/lib/ext2fs/ext4_acl.h +index 8d4d974..8343086 100644 +--- a/lib/ext2fs/ext4_acl.h ++++ b/lib/ext2fs/ext4_acl.h +@@ -4,6 +4,12 @@ + + #define EXT4_ACL_VERSION 0x0001 + ++/* 23.2.2 acl_perm_t values */ ++ ++#define ACL_READ (0x04) ++#define ACL_WRITE (0x02) ++#define ACL_EXECUTE (0x01) ++ + /* 23.2.5 acl_tag_t values */ + + #define ACL_UNDEFINED_TAG (0x00) +diff --git a/lib/ext2fs/ext_attr.c b/lib/ext2fs/ext_attr.c +index efe4d29..04c560e 100644 +--- a/lib/ext2fs/ext_attr.c ++++ b/lib/ext2fs/ext_attr.c +@@ -18,6 +18,12 @@ + #endif + #include + #include ++#include ++#if defined HAVE_SYS_XATTR_H ++#include ++#elif defined HAVE_ATTR_XATTR_H ++#include ++#endif + + #include "ext2_fs.h" + #include "ext2_ext_attr.h" +@@ -127,6 +133,33 @@ void ext2fs_ext_attr_block_rehash(struct ext2_ext_attr_header *header, + header->h_hash = hash; + } + ++/* ++ * Re-compute the extended attribute hash value after an entry has changed. ++ */ ++static void ext2fs_attr_rehash(struct ext2_ext_attr_header *header, ++ struct ext2_ext_attr_entry *entry) ++{ ++ struct ext2_ext_attr_entry *here; ++ __u32 hash = 0; ++ ++ entry->e_hash = ext2fs_ext_attr_hash_entry(entry, (char *)header + ++ entry->e_value_offs); ++ ++ here = ENTRY(header+1); ++ while (!EXT2_EXT_IS_LAST_ENTRY(here)) { ++ if (!here->e_hash) { ++ /* Block is not shared if an entry's hash value == 0 */ ++ hash = 0; ++ break; ++ } ++ hash = (hash << BLOCK_HASH_SHIFT) ^ ++ (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^ ++ here->e_hash; ++ here = EXT2_EXT_ATTR_NEXT(here); ++ } ++ header->h_hash = hash; ++} ++ + #undef BLOCK_HASH_SHIFT + + __u32 ext2fs_get_ea_inode_hash(struct ext2_inode *inode) +@@ -260,7 +293,10 @@ errcode_t ext2fs_adjust_ea_refcount3(ext2_filsys fs, blk64_t blk, + if (retval) + goto errout; + +- header = (struct ext2_ext_attr_header *) block_buf; ++ header = BHDR(block_buf); ++ if (header->h_magic != EXT2_EXT_ATTR_MAGIC) ++ return EXT2_ET_EA_BAD_MAGIC; ++ + header->h_refcount += adjust; + if (newcount) + *newcount = header->h_refcount; +@@ -343,6 +379,7 @@ static struct ea_name_index ea_names[] = { + {2, "system.posix_acl_access"}, + {8, "system.richacl"}, + {6, "security."}, ++ {5, "lustre."}, + {4, "trusted."}, + {7, "system."}, + {1, "user."}, +@@ -987,30 +1024,19 @@ static void xattrs_free_keys(struct ext2_xattr_handle *h) + h->ibody_count = 0; + } + +-errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle) ++/* fetch xattrs from an already-loaded inode */ ++errcode_t ext2fs_xattrs_read_inode(struct ext2_xattr_handle *handle, ++ struct ext2_inode_large *inode) + { +- struct ext2_inode_large *inode; ++ + struct ext2_ext_attr_header *header; + __u32 ea_inode_magic; + unsigned int storage_size; + char *start, *block_buf = NULL; + blk64_t blk; +- size_t i; + errcode_t err; + + EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE); +- i = EXT2_INODE_SIZE(handle->fs->super); +- if (i < sizeof(*inode)) +- i = sizeof(*inode); +- err = ext2fs_get_memzero(i, &inode); +- if (err) +- return err; +- +- err = ext2fs_read_inode_full(handle->fs, handle->ino, +- (struct ext2_inode *)inode, +- EXT2_INODE_SIZE(handle->fs->super)); +- if (err) +- goto out; + + xattrs_free_keys(handle); + +@@ -1046,7 +1072,7 @@ errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle) + + read_ea_block: + /* Look for EA in a separate EA block */ +- blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode); ++ blk = ext2fs_file_acl_block(handle->fs, EXT2_INODE(inode)); + if (blk != 0) { + if ((blk < handle->fs->super->s_first_data_block) || + (blk >= ext2fs_blocks_count(handle->fs->super))) { +@@ -1077,26 +1103,46 @@ read_ea_block: + err = read_xattrs_from_buffer(handle, inode, + (struct ext2_ext_attr_entry *) start, + storage_size, block_buf); +- if (err) +- goto out3; ++ } + ++out3: ++ if (block_buf) + ext2fs_free_mem(&block_buf); +- } ++out: ++ return err; ++} + +- ext2fs_free_mem(&block_buf); +- ext2fs_free_mem(&inode); +- return 0; ++errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle) ++{ ++ struct ext2_inode_large *inode; ++ size_t inode_size = EXT2_INODE_SIZE(handle->fs->super); ++ errcode_t err; ++ ++ EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE); ++ ++ if (inode_size < sizeof(*inode)) ++ inode_size = sizeof(*inode); ++ err = ext2fs_get_memzero(inode_size, &inode); ++ if (err) ++ return err; ++ ++ err = ext2fs_read_inode_full(handle->fs, handle->ino, EXT2_INODE(inode), ++ EXT2_INODE_SIZE(handle->fs->super)); ++ if (err) ++ goto out; ++ ++ err = ext2fs_xattrs_read_inode(handle, inode); + +-out3: +- ext2fs_free_mem(&block_buf); + out: + ext2fs_free_mem(&inode); ++ + return err; + } + + errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h, + int (*func)(char *name, char *value, +- size_t value_len, void *data), ++ size_t value_len, ++ ext2_ino_t inode_num, void *data), + void *data) + { + struct ext2_xattr *x; +@@ -1105,7 +1151,7 @@ errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h, + + EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE); + for (x = h->attrs; x < h->attrs + h->count; x++) { +- ret = func(x->name, x->value, x->value_len, data); ++ ret = func(x->name, x->value, x->value_len, x->ea_ino, data); + if (ret & XATTR_CHANGED) + dirty = 1; + if (ret & XATTR_ABORT) +@@ -1719,3 +1765,905 @@ errcode_t ext2fs_xattrs_flags(struct ext2_xattr_handle *handle, + handle->flags = *new_flags; + return 0; + } ++ ++struct ext2_attr_info { ++ int name_index; ++ const char *name; ++ const char *value; ++ int value_len; ++}; ++ ++struct ext2_attr_search { ++ struct ext2_ext_attr_entry *first; ++ char *base; ++ char *end; ++ struct ext2_ext_attr_entry *here; ++ int not_found; ++}; ++ ++struct ext2_attr_ibody_find { ++ ext2_ino_t ino; ++ struct ext2_attr_search s; ++}; ++ ++struct ext2_attr_block_find { ++ struct ext2_attr_search s; ++ char *block; ++}; ++ ++void ext2fs_attr_shift_entries(struct ext2_ext_attr_entry *entry, ++ int value_offs_shift, char *to, ++ char *from, int n) ++{ ++ struct ext2_ext_attr_entry *last = entry; ++ ++ /* Adjust the value offsets of the entries */ ++ for (; !EXT2_EXT_IS_LAST_ENTRY(last); last = EXT2_EXT_ATTR_NEXT(last)) { ++ if (!last->e_value_inum && last->e_value_size) { ++ last->e_value_offs = last->e_value_offs + ++ value_offs_shift; ++ } ++ } ++ /* Shift the entries by n bytes and zero freed space in inode */ ++ memmove(to, from, n); ++ if (to > from) ++ memset(from, 0, to - from); ++} ++ ++/* ++ * This function returns the free space present in the inode or the EA block. ++ * total is number of bytes taken up by the EA entries and is used to shift ++ * the EAs in ext2fs_expand_extra_isize(). ++ */ ++int ext2fs_attr_free_space(struct ext2_ext_attr_entry *last, ++ int *min_offs, char *base, int *total) ++{ ++ for (; !EXT2_EXT_IS_LAST_ENTRY(last); last = EXT2_EXT_ATTR_NEXT(last)) { ++ *total += EXT2_EXT_ATTR_LEN(last->e_name_len); ++ if (!last->e_value_inum && last->e_value_size) { ++ int offs = last->e_value_offs; ++ if (offs < *min_offs) ++ *min_offs = offs; ++ } ++ } ++ ++ return *min_offs - ((char *)last - base) - sizeof(__u32); ++} ++ ++static errcode_t ext2fs_attr_check_names(struct ext2_ext_attr_entry *entry, ++ char *end) ++{ ++ while (!EXT2_EXT_IS_LAST_ENTRY(entry)) { ++ struct ext2_ext_attr_entry *next = EXT2_EXT_ATTR_NEXT(entry); ++ if ((char *)next >= end) ++ return EXT2_ET_EA_BAD_ENTRIES; ++ entry = next; ++ } ++ return 0; ++} ++ ++/* The unused parameter used to be the blocksize, but with in-inode xattrs ++ * the xattr storage area size depends on where the xattrs are kept. Keep ++ * this parameter for API/ABI compatibility, but it is not needed. */ ++static errcode_t ext2fs_attr_find_entry(struct ext2_ext_attr_entry **pentry, ++ int name_index, const char *name, ++ int unused, int sorted) ++{ ++ struct ext2_ext_attr_entry *entry; ++ int name_len; ++ int cmp = 1; ++ ++ if (name == NULL) ++ return EXT2_ET_EA_BAD_NAME; ++ ++ name_len = strlen(name); ++ entry = *pentry; ++ for (; !EXT2_EXT_IS_LAST_ENTRY(entry); ++ entry = EXT2_EXT_ATTR_NEXT(entry)) { ++ cmp = name_index - entry->e_name_index; ++ if (!cmp) ++ cmp = name_len - entry->e_name_len; ++ if (!cmp) ++ cmp = memcmp(name, entry->e_name, name_len); ++ if (cmp <= 0 && (sorted || cmp == 0)) ++ break; ++ } ++ *pentry = entry; ++ ++ return cmp ? EXT2_ET_EA_NAME_NOT_FOUND : 0; ++} ++ ++static errcode_t ext2fs_attr_block_find(ext2_filsys fs,struct ext2_inode *inode, ++ struct ext2_attr_info *i, ++ struct ext2_attr_block_find *bs) ++{ ++ struct ext2_ext_attr_header *header; ++ errcode_t error; ++ ++ if (inode->i_file_acl) { ++ /* The inode already has an extended attribute block. */ ++ error = ext2fs_get_mem(fs->blocksize, &bs->block); ++ if (error) ++ return error; ++ error = ext2fs_read_ext_attr(fs, inode->i_file_acl, bs->block); ++ if (error) ++ goto cleanup; ++ ++ header = BHDR(bs->block); ++ if (header->h_magic != EXT2_EXT_ATTR_MAGIC) { ++ error = EXT2_ET_EA_BAD_MAGIC; ++ goto cleanup; ++ } ++ ++ /* Find the named attribute. */ ++ bs->s.base = bs->block; ++ bs->s.first = (struct ext2_ext_attr_entry *)(header + 1); ++ bs->s.end = bs->block + fs->blocksize; ++ bs->s.here = bs->s.first; ++ error = ext2fs_attr_find_entry(&bs->s.here, i->name_index, ++ i->name, fs->blocksize, 1); ++ if (error && error != EXT2_ET_EA_NAME_NOT_FOUND) ++ goto cleanup; ++ bs->s.not_found = error; ++ } ++ error = 0; ++ ++cleanup: ++ if (error && bs->block) ++ ext2fs_free_mem(&bs->block); ++ return error; ++} ++ ++static errcode_t ext2fs_attr_ibody_find(ext2_filsys fs, ++ struct ext2_inode_large *inode, ++ struct ext2_attr_info *i, ++ struct ext2_attr_ibody_find *is) ++{ ++ errcode_t error; ++ ++ if (EXT2_INODE_SIZE(fs->super) == EXT2_GOOD_OLD_INODE_SIZE) ++ return 0; ++ ++ if (inode->i_extra_isize == 0) ++ return 0; ++ ++ is->s.first = &IHDR(inode)->h_first_entry[0]; ++ is->s.base = (char *)is->s.first; ++ is->s.here = is->s.first; ++ is->s.end = (char *)inode + EXT2_INODE_SIZE(fs->super); ++ if (IHDR(inode)->h_magic == EXT2_EXT_ATTR_MAGIC) { ++ error = ext2fs_attr_check_names(is->s.first, is->s.end); ++ if (error) ++ return error; ++ /* Find the named attribute. */ ++ error = ext2fs_attr_find_entry(&is->s.here, i->name_index, ++ i->name, is->s.end - ++ (char *)is->s.base, 0); ++ if (error && error != EXT2_ET_EA_NAME_NOT_FOUND) ++ return error; ++ is->s.not_found = error; ++ } ++ ++ return 0; ++} ++ ++static errcode_t ext2fs_attr_set_entry(ext2_filsys fs, struct ext2_attr_info *i, ++ struct ext2_attr_search *s) ++{ ++ struct ext2_ext_attr_entry *last; ++ int free, min_offs = s->end - s->base, name_len = strlen(i->name); ++ ++ /* Compute min_offs and last. */ ++ for (last = s->first; !EXT2_EXT_IS_LAST_ENTRY(last); ++ last = EXT2_EXT_ATTR_NEXT(last)) { ++ if (!last->e_value_inum && last->e_value_size) { ++ int offs = last->e_value_offs; ++ ++ if (offs < min_offs) ++ min_offs = offs; ++ } ++ } ++ free = min_offs - ((char *)last - s->base) - sizeof(__u32); ++ ++ if (!s->not_found) { ++ if (!s->here->e_value_inum && s->here->e_value_size) { ++ int size = s->here->e_value_size; ++ free += EXT2_EXT_ATTR_SIZE(size); ++ } ++ free += EXT2_EXT_ATTR_LEN(name_len); ++ } ++ if (i->value) { ++ if (free < EXT2_EXT_ATTR_LEN(name_len) + ++ EXT2_EXT_ATTR_SIZE(i->value_len)) ++ return EXT2_ET_EA_NO_SPACE; ++ } ++ ++ if (i->value && s->not_found) { ++ /* Insert the new name. */ ++ int size = EXT2_EXT_ATTR_LEN(name_len); ++ int rest = (char *)last - (char *)s->here + sizeof(__u32); ++ ++ memmove((char *)s->here + size, s->here, rest); ++ memset(s->here, 0, size); ++ s->here->e_name_index = i->name_index; ++ s->here->e_name_len = name_len; ++ memcpy(s->here->e_name, i->name, name_len); ++ } else { ++ if (!s->here->e_value_inum && s->here->e_value_size) { ++ char *first_val = s->base + min_offs; ++ int offs = s->here->e_value_offs; ++ char *val = s->base + offs; ++ int size = EXT2_EXT_ATTR_SIZE(s->here->e_value_size); ++ ++ if (i->value && ++ size == EXT2_EXT_ATTR_SIZE(i->value_len)) { ++ /* The old and the new value have the same ++ size. Just replace. */ ++ s->here->e_value_size = i->value_len; ++ memset(val + size - EXT2_EXT_ATTR_PAD, 0, ++ EXT2_EXT_ATTR_PAD); /* Clear pad bytes */ ++ memcpy(val, i->value, i->value_len); ++ return 0; ++ } ++ ++ /* Remove the old value. */ ++ memmove(first_val + size, first_val, val - first_val); ++ memset(first_val, 0, size); ++ s->here->e_value_size = 0; ++ s->here->e_value_offs = 0; ++ min_offs += size; ++ ++ /* Adjust all value offsets. */ ++ last = s->first; ++ while (!EXT2_EXT_IS_LAST_ENTRY(last)) { ++ int o = last->e_value_offs; ++ ++ if (!last->e_value_inum && ++ last->e_value_size && o < offs) ++ last->e_value_offs = o + size; ++ last = EXT2_EXT_ATTR_NEXT(last); ++ } ++ } ++ if (!i->value) { ++ /* Remove the old name. */ ++ int size = EXT2_EXT_ATTR_LEN(name_len); ++ ++ last = ENTRY((char *)last - size); ++ memmove((char *)s->here, (char *)s->here + size, ++ (char *)last - (char *)s->here + sizeof(__u32)); ++ memset(last, 0, size); ++ } ++ } ++ ++ if (i->value) { ++ /* Insert the new value. */ ++ s->here->e_value_size = i->value_len; ++ if (i->value_len) { ++ int size = EXT2_EXT_ATTR_SIZE(i->value_len); ++ char *val = s->base + min_offs - size; ++ ++ s->here->e_value_offs = min_offs - size; ++ memset(val + size - EXT2_EXT_ATTR_PAD, 0, ++ EXT2_EXT_ATTR_PAD); /* Clear the pad bytes. */ ++ memcpy(val, i->value, i->value_len); ++ } ++ } ++ ++ return 0; ++} ++ ++static errcode_t ext2fs_attr_block_set(ext2_filsys fs, struct ext2_inode *inode, ++ struct ext2_attr_info *i, ++ struct ext2_attr_block_find *bs) ++{ ++ struct ext2_attr_search *s = &bs->s; ++ char *new_buf = NULL, *old_block = NULL; ++ blk_t blk; ++ int clear_flag = 0; ++ errcode_t error; ++ ++ if (i->value && i->value_len > fs->blocksize) ++ return EXT2_ET_EA_NO_SPACE; ++ ++ if (s->base) { ++ if (BHDR(s->base)->h_refcount != 1) { ++ int offset = (char *)s->here - bs->block; ++ ++ /* Decrement the refcount of the shared block */ ++ old_block = s->base; ++ BHDR(s->base)->h_refcount -= 1; ++ ++ error = ext2fs_get_mem(fs->blocksize, &s->base); ++ if (error) ++ goto cleanup; ++ clear_flag = 1; ++ memcpy(s->base, bs->block, fs->blocksize); ++ s->first = ENTRY(BHDR(s->base)+1); ++ BHDR(s->base)->h_refcount = 1; ++ s->here = ENTRY(s->base + offset); ++ s->end = s->base + fs->blocksize; ++ } ++ } else { ++ error = ext2fs_get_mem(fs->blocksize, &s->base); ++ if (error) ++ goto cleanup; ++ clear_flag = 1; ++ memset(s->base, 0, fs->blocksize); ++ BHDR(s->base)->h_magic = EXT2_EXT_ATTR_MAGIC; ++ BHDR(s->base)->h_blocks = 1; ++ BHDR(s->base)->h_refcount = 1; ++ s->first = ENTRY(BHDR(s->base)+1); ++ s->here = ENTRY(BHDR(s->base)+1); ++ s->end = s->base + fs->blocksize; ++ } ++ ++ error = ext2fs_attr_set_entry(fs, i, s); ++ if (error) ++ goto cleanup; ++ ++ if (!EXT2_EXT_IS_LAST_ENTRY(s->first)) ++ ext2fs_attr_rehash(BHDR(s->base), s->here); ++ ++ if (!EXT2_EXT_IS_LAST_ENTRY(s->first)) { ++ if (bs->block && bs->block == s->base) { ++ /* We are modifying this block in-place */ ++ new_buf = bs->block; ++ blk = inode->i_file_acl; ++ error = ext2fs_write_ext_attr(fs, blk, s->base); ++ if (error) ++ goto cleanup; ++ } else { ++ /* We need to allocate a new block */ ++ error = ext2fs_new_block(fs, 0, 0, &blk); ++ if (error) ++ goto cleanup; ++ ext2fs_block_alloc_stats(fs, blk, 1); ++ error = ext2fs_write_ext_attr(fs, blk, s->base); ++ if (error) ++ goto cleanup; ++ new_buf = s->base; ++ if (old_block) { ++ BHDR(s->base)->h_refcount -= 1; ++ error = ext2fs_write_ext_attr(fs, ++ inode->i_file_acl, ++ s->base); ++ if (error) ++ goto cleanup; ++ } ++ } ++ } ++ ++ /* Update the i_blocks if we added a new EA block */ ++ if (!inode->i_file_acl && new_buf) ++ inode->i_blocks += fs->blocksize / 512; ++ /* Update the inode. */ ++ inode->i_file_acl = new_buf ? blk : 0; ++ ++cleanup: ++ if (clear_flag) ++ ext2fs_free_mem(&s->base); ++ return 0; ++} ++ ++static errcode_t ext2fs_attr_ibody_set(ext2_filsys fs, ++ struct ext2_inode_large *inode, ++ struct ext2_attr_info *i, ++ struct ext2_attr_ibody_find *is) ++{ ++ struct ext2_attr_search *s = &is->s; ++ errcode_t error; ++ ++ if (EXT2_INODE_SIZE(fs->super) == EXT2_GOOD_OLD_INODE_SIZE) ++ return EXT2_ET_EA_NO_SPACE; ++ ++ error = ext2fs_attr_set_entry(fs, i, s); ++ if (error) ++ return error; ++ ++ if (!EXT2_EXT_IS_LAST_ENTRY(s->first)) ++ IHDR(inode)->h_magic = EXT2_EXT_ATTR_MAGIC; ++ else ++ IHDR(inode)->h_magic = 0; ++ ++ return ext2fs_write_inode_full(fs, is->ino, (struct ext2_inode *)inode, ++ EXT2_INODE_SIZE(fs->super)); ++} ++ ++static struct { ++ char str[28]; ++ int len; ++} ext2_attr_index_prefix[] = { ++ [EXT2_ATTR_INDEX_USER] = { EXT2_ATTR_INDEX_USER_PREFIX, ++ sizeof(EXT2_ATTR_INDEX_USER_PREFIX) }, ++ [EXT2_ATTR_INDEX_POSIX_ACL_ACCESS] = { ++ EXT2_ATTR_INDEX_POSIX_ACL_ACCESS_PREFIX, ++ sizeof(EXT2_ATTR_INDEX_POSIX_ACL_ACCESS_PREFIX) }, ++ [EXT2_ATTR_INDEX_POSIX_ACL_DEFAULT] = { ++ EXT2_ATTR_INDEX_POSIX_ACL_DEFAULT_PREFIX, ++ sizeof(EXT2_ATTR_INDEX_POSIX_ACL_DEFAULT_PREFIX) }, ++ [EXT2_ATTR_INDEX_TRUSTED] = { EXT2_ATTR_INDEX_TRUSTED_PREFIX, ++ sizeof(EXT2_ATTR_INDEX_TRUSTED_PREFIX) }, ++ [EXT2_ATTR_INDEX_LUSTRE] = { EXT2_ATTR_INDEX_LUSTRE_PREFIX, ++ sizeof(EXT2_ATTR_INDEX_LUSTRE_PREFIX) }, ++ [EXT2_ATTR_INDEX_SECURITY] = { EXT2_ATTR_INDEX_SECURITY_PREFIX, ++ sizeof(EXT2_ATTR_INDEX_SECURITY_PREFIX)}, ++ { "", 0 } ++}; ++ ++errcode_t ext2fs_attr_set(ext2_filsys fs, ext2_ino_t ino, ++ struct ext2_inode *inode, ++ int name_index, const char *name, const char *value, ++ int value_len, int flags) ++{ ++ struct ext2_inode_large *inode_large = NULL; ++ struct ext2_attr_info i = { ++ .name_index = name_index, ++ .name = name, ++ .value = value, ++ .value_len = value_len, ++ }; ++ struct ext2_attr_ibody_find is = { ++ .ino = ino, ++ .s = { .not_found = -ENODATA, }, ++ }; ++ struct ext2_attr_block_find bs = { ++ .s = { .not_found = -ENODATA, }, ++ }; ++ errcode_t error; ++ ++ if (!name) ++ return EXT2_ET_EA_BAD_NAME; ++ if (strlen(name) > 255) ++ return EXT2_ET_EA_NAME_TOO_BIG; ++ ++ /* If the prefix is still present, skip it */ ++ if (strncmp(name, ext2_attr_index_prefix[name_index].str, ++ ext2_attr_index_prefix[name_index].len) == 0) ++ i.name += ext2_attr_index_prefix[name_index].len; ++ ++ if (EXT2_INODE_SIZE(fs->super) > EXT2_GOOD_OLD_INODE_SIZE) { ++ inode_large = (struct ext2_inode_large *)inode; ++ ++ error = ext2fs_attr_ibody_find(fs, inode_large, &i, &is); ++ if (error) ++ goto cleanup; ++ } ++ if (is.s.not_found) { ++ error = ext2fs_attr_block_find(fs, inode, &i, &bs); ++ if (error) ++ goto cleanup; ++ } ++ ++ if (is.s.not_found && bs.s.not_found) { ++ error = EXT2_ET_EA_NAME_NOT_FOUND; ++ if (flags & XATTR_REPLACE) ++ goto cleanup; ++ error = 0; ++ if (!value) ++ goto cleanup; ++ } else { ++ error = EXT2_ET_EA_NAME_EXISTS; ++ if (flags & XATTR_CREATE) ++ goto cleanup; ++ } ++ ++ if (!value) { ++ if (!is.s.not_found && ++ (EXT2_INODE_SIZE(fs->super) > EXT2_GOOD_OLD_INODE_SIZE)) ++ error = ext2fs_attr_ibody_set(fs, inode_large, &i, &is); ++ else if (!bs.s.not_found) ++ error = ext2fs_attr_block_set(fs, inode, &i, &bs); ++ } else { ++ if (EXT2_INODE_SIZE(fs->super) > EXT2_GOOD_OLD_INODE_SIZE) ++ error = ext2fs_attr_ibody_set(fs, inode_large, &i, &is); ++ if (!error && !bs.s.not_found) { ++ i.value = NULL; ++ error = ext2fs_attr_block_set(fs, inode, &i, &bs); ++ } else if (error == EXT2_ET_EA_NO_SPACE) { ++ error = ext2fs_attr_block_set(fs, inode, &i, &bs); ++ if (error) ++ goto cleanup; ++ if (!is.s.not_found) { ++ i.value = NULL; ++ if (EXT2_INODE_SIZE(fs->super) > ++ EXT2_GOOD_OLD_INODE_SIZE) ++ error = ext2fs_attr_ibody_set(fs, ++ inode_large, &i, &is); ++ } ++ } ++ } ++ ++cleanup: ++ return error; ++} ++ ++static errcode_t ext2fs_attr_check_block(ext2_filsys fs, char *buffer) ++{ ++ if (BHDR(buffer)->h_magic != (EXT2_EXT_ATTR_MAGIC) || ++ BHDR(buffer)->h_blocks != 1) ++ return EXT2_ET_EA_BAD_MAGIC; ++ ++ return ext2fs_attr_check_names((struct ext2_ext_attr_entry *) ++ (BHDR(buffer) + 1), ++ buffer + fs->blocksize); ++} ++ ++static errcode_t ext2fs_attr_block_get(ext2_filsys fs, struct ext2_inode *inode, ++ int name_index, const char *name, ++ void *buffer, size_t buffer_size, ++ int *easize) ++{ ++ struct ext2_ext_attr_header *header = NULL; ++ struct ext2_ext_attr_entry *entry; ++ char *block_buf = NULL; ++ errcode_t error; ++ ++ error = EXT2_ET_EA_NAME_NOT_FOUND; ++ if (!inode->i_file_acl) ++ goto cleanup; ++ ++ error = ext2fs_get_mem(fs->blocksize, &block_buf); ++ if (error) ++ return error; ++ error = ext2fs_read_ext_attr(fs, inode->i_file_acl, block_buf); ++ if (error) ++ goto cleanup; ++ ++ error = ext2fs_attr_check_block(fs, block_buf); ++ if (error) ++ goto cleanup; ++ ++ header = BHDR(block_buf); ++ entry = (struct ext2_ext_attr_entry *)(header + 1); ++ error = ext2fs_attr_find_entry(&entry, name_index, name, ++ fs->blocksize, 1); ++ if (error) ++ goto cleanup; ++ if (easize) ++ *easize = entry->e_value_size; ++ if (buffer) { ++ if (entry->e_value_size > buffer_size) { ++ error = EXT2_ET_EA_TOO_BIG; ++ goto cleanup; ++ } ++ memcpy(buffer, block_buf + entry->e_value_offs, ++ entry->e_value_size); ++ error = 0; ++ } ++ ++cleanup: ++ if (block_buf) ++ ext2fs_free_mem(&block_buf); ++ return error; ++} ++ ++static errcode_t ext2fs_attr_check_ibody(ext2_filsys fs, ++ struct ext2_inode_large *inode) ++{ ++ const int inode_size = EXT2_INODE_SIZE(fs->super); ++ ++ if (inode_size == EXT2_GOOD_OLD_INODE_SIZE) ++ return EXT2_ET_EA_NAME_NOT_FOUND; ++ ++ if (IHDR(inode)->h_magic != EXT2_EXT_ATTR_MAGIC) ++ return EXT2_ET_EA_BAD_MAGIC; ++ ++ return ext2fs_attr_check_names(&IHDR(inode)->h_first_entry[0], ++ (char *)inode + inode_size); ++} ++ ++ ++static errcode_t ext2fs_attr_ibody_get(ext2_filsys fs, ++ struct ext2_inode_large *inode, ++ int name_index, const char *name, ++ void *buffer, size_t buffer_size, ++ int *easize) ++{ ++ struct ext2_ext_attr_entry *entry; ++ int error; ++ ++ error = ext2fs_attr_check_ibody(fs, inode); ++ if (error) ++ return error; ++ ++ entry = &IHDR(inode)->h_first_entry[0]; ++ ++ error = ext2fs_attr_find_entry(&entry, name_index, name, ++ (char *)inode + EXT2_INODE_SIZE(fs->super) - ++ (char *)entry, 0); ++ if (error) ++ goto cleanup; ++ if (easize) ++ *easize = entry->e_value_size; ++ if (buffer) { ++ if (entry->e_value_size > buffer_size) { ++ error = EXT2_ET_EA_TOO_BIG; ++ goto cleanup; ++ } ++ memcpy(buffer, (char *)&IHDR(inode)->h_first_entry[0] + ++ entry->e_value_offs, entry->e_value_size); ++ } ++ ++cleanup: ++ return error; ++} ++ ++ ++errcode_t ext2fs_attr_get(ext2_filsys fs, struct ext2_inode *inode, ++ int name_index, const char *name, char *buffer, ++ size_t buffer_size, int *easize) ++{ ++ errcode_t error; ++ ++ error = ext2fs_attr_ibody_get(fs, (struct ext2_inode_large *)inode, ++ name_index, name, buffer, buffer_size, ++ easize); ++ if (error == EXT2_ET_EA_NAME_NOT_FOUND || error == EXT2_ET_EA_BAD_MAGIC) ++ error = ext2fs_attr_block_get(fs, inode, name_index, name, ++ buffer, buffer_size, easize); ++ ++ return error; ++} ++ ++int ext2fs_attr_get_next_attr(struct ext2_ext_attr_entry *entry, int name_index, ++ char *buffer, int buffer_size, int start) ++{ ++ const int prefix_len = ext2_attr_index_prefix[name_index].len; ++ int total_len; ++ ++ if (!start && !EXT2_EXT_IS_LAST_ENTRY(entry)) ++ entry = EXT2_EXT_ATTR_NEXT(entry); ++ ++ for (; !EXT2_EXT_IS_LAST_ENTRY(entry); ++ entry = EXT2_EXT_ATTR_NEXT(entry)) { ++ if (!name_index) ++ break; ++ if (name_index == entry->e_name_index) ++ break; ++ } ++ if (EXT2_EXT_IS_LAST_ENTRY(entry)) ++ return 0; ++ ++ total_len = prefix_len + entry->e_name_len + 1; ++ if (buffer && total_len <= buffer_size) { ++ memcpy(buffer, ext2_attr_index_prefix[name_index].str, ++ prefix_len); ++ memcpy(buffer + prefix_len, entry->e_name, entry->e_name_len); ++ buffer[prefix_len + entry->e_name_len] = '\0'; ++ } ++ ++ return total_len; ++} ++ ++errcode_t ext2fs_expand_extra_isize(ext2_filsys fs, ext2_ino_t ino, ++ struct ext2_inode_large *inode, ++ int new_extra_isize, int *ret, ++ int *needed_size) ++{ ++ struct ext2_inode *inode_buf = NULL; ++ struct ext2_ext_attr_header *header = NULL; ++ struct ext2_ext_attr_entry *entry = NULL, *last = NULL; ++ struct ext2_attr_ibody_find is = { ++ .ino = ino, ++ .s = { .not_found = EXT2_ET_EA_NO_SPACE, }, ++ }; ++ struct ext2_attr_block_find bs = { ++ .s = { .not_found = EXT2_ET_EA_NO_SPACE, }, ++ }; ++ char *start, *end, *block_buf = NULL, *buffer =NULL, *b_entry_name=NULL; ++ int total_ino = 0, total_blk, free, offs, tried_min_extra_isize = 0; ++ int s_min_extra_isize = fs->super->s_min_extra_isize; ++ errcode_t error = 0; ++ ++ if (needed_size) ++ *needed_size = new_extra_isize; ++ error = ext2fs_get_mem(fs->blocksize, &block_buf); ++ if (error) ++ return error; ++ ++ if (inode == NULL) { ++ error = ext2fs_get_mem(EXT2_INODE_SIZE(fs->super), &inode_buf); ++ if (error) ++ goto cleanup; ++ ++ error = ext2fs_read_inode_full(fs, ino, inode_buf, ++ EXT2_INODE_SIZE(fs->super)); ++ if (error) ++ goto cleanup; ++ ++ inode = (struct ext2_inode_large *)inode_buf; ++ } ++ ++retry: ++ if (inode->i_extra_isize >= new_extra_isize) ++ goto cleanup; ++ ++ start = (char *)inode + EXT2_GOOD_OLD_INODE_SIZE + inode->i_extra_isize; ++ /* No extended attributes present */ ++ if (IHDR(inode)->h_magic != EXT2_EXT_ATTR_MAGIC) { ++ memset(start, 0, ++ EXT2_INODE_SIZE(fs->super) - EXT2_GOOD_OLD_INODE_SIZE - ++ inode->i_extra_isize); ++ inode->i_extra_isize = new_extra_isize; ++ if (needed_size) ++ *needed_size = 0; ++ goto write_inode; ++ } ++ ++ start += sizeof(__u32); ++ end = (char *)inode + EXT2_INODE_SIZE(fs->super); ++ last = entry = (struct ext2_ext_attr_entry *)start; ++ offs = end - start; ++ /* Consider space takenup by magic number */ ++ total_ino = sizeof(__u32); ++ free = ext2fs_attr_free_space(last, &offs, start, &total_ino); ++ ++ /* Enough free space available in the inode for expansion */ ++ if (free >= new_extra_isize) { ++ ext2fs_attr_shift_entries(entry, ++ inode->i_extra_isize - new_extra_isize, ++ (char *)inode + ++ EXT2_GOOD_OLD_INODE_SIZE + ++ new_extra_isize, ++ start - sizeof(__u32), total_ino); ++ inode->i_extra_isize = new_extra_isize; ++ if (needed_size) ++ *needed_size = 0; ++ goto write_inode; ++ } ++ ++ if (inode->i_file_acl) { ++ error = ext2fs_read_ext_attr(fs, inode->i_file_acl, block_buf); ++ if (error) ++ goto cleanup; ++ ++ header = BHDR(block_buf); ++ if (header->h_magic != EXT2_EXT_ATTR_MAGIC) { ++ error = EXT2_ET_EA_BAD_MAGIC; ++ goto cleanup; ++ } ++ end = block_buf + fs->blocksize; ++ last = entry = (struct ext2_ext_attr_entry *)(header+1); ++ start = (char *)entry; ++ offs = end - start; ++ free = ext2fs_attr_free_space(last, &offs, start, &total_blk); ++ if (free < new_extra_isize) { ++ if (!tried_min_extra_isize && s_min_extra_isize) { ++ tried_min_extra_isize++; ++ new_extra_isize = s_min_extra_isize; ++ goto retry; ++ } ++ if (ret) ++ *ret = EXT2_EXPAND_EISIZE_NOSPC; ++ error = EXT2_ET_EA_NO_SPACE; ++ goto cleanup; ++ } ++ } else { ++ if (ret && *ret == EXT2_EXPAND_EISIZE_UNSAFE) { ++ *ret = EXT2_EXPAND_EISIZE_NEW_BLOCK; ++ error = 0; ++ goto cleanup; ++ } ++ free = fs->blocksize; ++ } ++ ++ while (new_extra_isize > 0) { ++ int offs, size, entry_size; ++ struct ext2_ext_attr_entry *small_entry = NULL; ++ struct ext2_attr_info i = { ++ .value = NULL, ++ .value_len = 0, ++ }; ++ unsigned int total_size, shift_bytes, temp = ~0U, extra_isize=0; ++ ++ start = (char *)inode + EXT2_GOOD_OLD_INODE_SIZE + ++ inode->i_extra_isize + sizeof(__u32); ++ end = (char *)inode + EXT2_INODE_SIZE(fs->super); ++ last = (struct ext2_ext_attr_entry *)start; ++ ++ /* Find the entry best suited to be pushed into EA block */ ++ entry = NULL; ++ for (; !EXT2_EXT_IS_LAST_ENTRY(last); ++ last = EXT2_EXT_ATTR_NEXT(last)) { ++ total_size = EXT2_EXT_ATTR_SIZE(last->e_value_size) + ++ EXT2_EXT_ATTR_LEN(last->e_name_len); ++ if (total_size <= free && total_size < temp) { ++ if (total_size < new_extra_isize) { ++ small_entry = last; ++ } else { ++ entry = last; ++ temp = total_size; ++ } ++ } ++ } ++ ++ if (entry == NULL) { ++ if (small_entry) { ++ entry = small_entry; ++ } else { ++ if (!tried_min_extra_isize && ++ s_min_extra_isize) { ++ tried_min_extra_isize++; ++ new_extra_isize = s_min_extra_isize; ++ goto retry; ++ } ++ if (ret) ++ *ret = EXT2_EXPAND_EISIZE_NOSPC; ++ error = EXT2_ET_EA_NO_SPACE; ++ goto cleanup; ++ } ++ } ++ offs = entry->e_value_offs; ++ size = entry->e_value_size; ++ entry_size = EXT2_EXT_ATTR_LEN(entry->e_name_len); ++ i.name_index = entry->e_name_index; ++ error = ext2fs_get_mem(EXT2_EXT_ATTR_SIZE(size), &buffer); ++ if (error) ++ goto cleanup; ++ error = ext2fs_get_mem(entry->e_name_len + 1, &b_entry_name); ++ if (error) ++ goto cleanup; ++ /* Save the entry name and the entry value */ ++ memcpy((char *)buffer, (char *)start + offs, ++ EXT2_EXT_ATTR_SIZE(size)); ++ memcpy((char *)b_entry_name, (char *)entry->e_name, ++ entry->e_name_len); ++ b_entry_name[entry->e_name_len] = '\0'; ++ i.name = b_entry_name; ++ ++ error = ext2fs_attr_ibody_find(fs, inode, &i, &is); ++ if (error) ++ goto cleanup; ++ ++ error = ext2fs_attr_set_entry(fs, &i, &is.s); ++ if (error) ++ goto cleanup; ++ ++ entry = (struct ext2_ext_attr_entry *)start; ++ if (entry_size + EXT2_EXT_ATTR_SIZE(size) >= new_extra_isize) ++ shift_bytes = new_extra_isize; ++ else ++ shift_bytes = entry_size + EXT2_EXT_ATTR_SIZE(size); ++ ext2fs_attr_shift_entries(entry, ++ inode->i_extra_isize - shift_bytes, ++ (char *)inode +EXT2_GOOD_OLD_INODE_SIZE+ ++ extra_isize + shift_bytes, ++ start - sizeof(__u32), ++ total_ino - entry_size); ++ ++ extra_isize += shift_bytes; ++ new_extra_isize -= shift_bytes; ++ if (needed_size) ++ *needed_size = new_extra_isize; ++ inode->i_extra_isize = extra_isize; ++ ++ i.name = b_entry_name; ++ i.value = buffer; ++ i.value_len = size; ++ error = ext2fs_attr_block_find(fs, (struct ext2_inode *)inode, ++ &i, &bs); ++ if (error) ++ goto cleanup; ++ ++ /* Add entry which was removed from the inode into the block */ ++ error = ext2fs_attr_block_set(fs, (struct ext2_inode *)inode, ++ &i, &bs); ++ if (error) ++ goto cleanup; ++ } ++ ++write_inode: ++ error = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)inode, ++ EXT2_INODE_SIZE(fs->super)); ++cleanup: ++ if (inode_buf) ++ ext2fs_free_mem(&inode_buf); ++ if (block_buf) ++ ext2fs_free_mem(&block_buf); ++ if (buffer) ++ ext2fs_free_mem(&buffer); ++ if (b_entry_name) ++ ext2fs_free_mem(&b_entry_name); ++ ++ return error; ++} +diff --git a/lib/ext2fs/fiemap.h b/lib/ext2fs/fiemap.h +index 33ab8fb..a157c41 100644 +--- a/lib/ext2fs/fiemap.h ++++ b/lib/ext2fs/fiemap.h +@@ -19,7 +19,9 @@ struct fiemap_extent { + __u64 fe_length; /* length in bytes for this extent */ + __u64 fe_reserved64[2]; + __u32 fe_flags; /* FIEMAP_EXTENT_* flags for this extent */ +- __u32 fe_reserved[3]; ++ __u32 fe_device; /* device number (fs-specific if FIEMAP_EXTENT_NET) ++ * low 16bits are used */ ++ __u32 fe_reserved[2]; + }; + + struct fiemap { +@@ -62,6 +64,7 @@ struct fiemap { + #define FIEMAP_FLAG_SYNC 0x00000001 /* sync file data before map */ + #define FIEMAP_FLAG_XATTR 0x00000002 /* map extended attribute tree */ + #define FIEMAP_FLAG_CACHE 0x00000004 /* request caching of the extents */ ++#define FIEMAP_FLAG_DEVICE_ORDER 0x40000000 /* return device ordered mapping */ + + #define FIEMAP_FLAGS_COMPAT (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_XATTR) + +@@ -89,5 +92,7 @@ struct fiemap { + + #define EXT4_FIEMAP_EXTENT_HOLE 0x08000000 /* Entry in extent status + cache for a hole*/ ++/* Network filesystem flags - use a high bit, don't conflict with upstream */ ++#define FIEMAP_EXTENT_NET 0x80000000 /* Data stored remotely. */ + + #endif /* _LINUX_FIEMAP_H */ +diff --git a/lib/ext2fs/icount.c b/lib/ext2fs/icount.c +index 48665c7..093f51b 100644 +--- a/lib/ext2fs/icount.c ++++ b/lib/ext2fs/icount.c +@@ -137,8 +137,9 @@ static errcode_t alloc_icount(ext2_filsys fs, int flags, ext2_icount_t *ret) + &icount->multiple); + if (retval) + goto errout; +- } else ++ } else { + icount->multiple = 0; ++ } + + *ret = icount; + return 0; +@@ -508,6 +509,23 @@ static errcode_t get_inode_count(ext2_icount_t icount, ext2_ino_t ino, + return 0; + } + ++int ext2fs_icount_is_set(ext2_icount_t icount, ext2_ino_t ino) ++{ ++ __u16 result; ++ ++ if (ext2fs_test_inode_bitmap2(icount->single, ino)) ++ return 1; ++ else if (icount->multiple) { ++ if (ext2fs_test_inode_bitmap2(icount->multiple, ino)) ++ return 1; ++ return 0; ++ } ++ ext2fs_icount_fetch(icount, ino, &result); ++ if (result) ++ return 1; ++ return 0; ++} ++ + errcode_t ext2fs_icount_validate(ext2_icount_t icount, FILE *out) + { + errcode_t ret = 0; +diff --git a/lib/ext2fs/inline_data.c b/lib/ext2fs/inline_data.c +index b62fb67..cd3e5bc 100644 +--- a/lib/ext2fs/inline_data.c ++++ b/lib/ext2fs/inline_data.c +@@ -149,7 +149,7 @@ int ext2fs_inline_data_dir_iterate(ext2_filsys fs, ext2_ino_t ino, + /* we first check '.' and '..' dir */ + dirent.inode = ino; + dirent.name_len = 1; +- ext2fs_set_rec_len(fs, EXT2_DIR_REC_LEN(2), &dirent); ++ ext2fs_set_rec_len(fs, EXT2_DIR_NAME_LEN(2), &dirent); + dirent.name[0] = '.'; + dirent.name[1] = '\0'; + ctx->buf = (char *)&dirent; +@@ -160,7 +160,7 @@ int ext2fs_inline_data_dir_iterate(ext2_filsys fs, ext2_ino_t ino, + + dirent.inode = ext2fs_le32_to_cpu(inode.i_block[0]); + dirent.name_len = 2; +- ext2fs_set_rec_len(fs, EXT2_DIR_REC_LEN(3), &dirent); ++ ext2fs_set_rec_len(fs, EXT2_DIR_NAME_LEN(3), &dirent); + dirent.name[0] = '.'; + dirent.name[1] = '.'; + dirent.name[2] = '\0'; +@@ -296,14 +296,14 @@ static errcode_t ext2fs_inline_data_convert_dir(ext2_filsys fs, ext2_ino_t ino, + ext2fs_dirent_set_name_len(dir, 1); + ext2fs_dirent_set_file_type(dir, filetype); + dir->name[0] = '.'; +- rec_len = (fs->blocksize - csum_size) - EXT2_DIR_REC_LEN(1); +- dir->rec_len = EXT2_DIR_REC_LEN(1); ++ rec_len = (fs->blocksize - csum_size) - EXT2_DIR_NAME_LEN(1); ++ dir->rec_len = EXT2_DIR_NAME_LEN(1); + + /* + * Set up entry for '..' + */ + dir = (struct ext2_dir_entry *) (bbuf + dir->rec_len); +- dir->rec_len = EXT2_DIR_REC_LEN(2); ++ dir->rec_len = EXT2_DIR_NAME_LEN(2); + dir->inode = ext2fs_le32_to_cpu(((__u32 *)ibuf)[0]); + ext2fs_dirent_set_name_len(dir, 2); + ext2fs_dirent_set_file_type(dir, filetype); +@@ -313,11 +313,11 @@ static errcode_t ext2fs_inline_data_convert_dir(ext2_filsys fs, ext2_ino_t ino, + /* + * Adjust the last rec_len + */ +- offset = EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2); ++ offset = EXT2_DIR_NAME_LEN(1) + EXT2_DIR_NAME_LEN(2); + dir = (struct ext2_dir_entry *) (bbuf + offset); + memcpy(bbuf + offset, ibuf + EXT4_INLINE_DATA_DOTDOT_SIZE, + size - EXT4_INLINE_DATA_DOTDOT_SIZE); +- size += EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2) - ++ size += EXT2_DIR_NAME_LEN(1) + EXT2_DIR_NAME_LEN(2) - + EXT4_INLINE_DATA_DOTDOT_SIZE; + + do { +diff --git a/lib/ext2fs/ismounted.c b/lib/ext2fs/ismounted.c +index 463a82a..0b87649 100644 +--- a/lib/ext2fs/ismounted.c ++++ b/lib/ext2fs/ismounted.c +@@ -52,6 +52,7 @@ + #ifdef HAVE_SYS_SYSMACROS_H + #include + #endif ++#include + + #include "ext2_fs.h" + #include "ext2fs.h" +@@ -341,6 +342,196 @@ leave: + return ret; + } + ++static int check_lustre_zfs(char *mnt_device, const char *real_devname) ++{ ++ char *real_mnt_device, *buf, *ptr; ++ FILE *fp; ++ int rc = 0; ++ ++ real_mnt_device = malloc(PATH_MAX); ++ if (real_mnt_device == NULL) { ++ fprintf(stderr, "Cannot allocate memory to store path\n"); ++ return 1; ++ } ++ ++ buf = malloc(PATH_MAX); ++ if (buf == NULL) { ++ fprintf(stderr, "Cannot allocate memory to store command\n"); ++ free(real_mnt_device); ++ return 1; ++ } ++ ++ /* Get the pool name from mnt_device */ ++ ptr = strchr(mnt_device, '/'); ++ if (ptr) ++ *ptr = '\0'; ++ ++ memset(buf, 0, PATH_MAX); ++ sprintf(buf, "zpool list -Hv %s", mnt_device); ++ ++ fp = popen(buf, "r"); ++ if (fp) { ++ int line = 0; ++ while (!feof(fp)) { ++ memset(buf, 0, PATH_MAX); ++ fscanf(fp, "%s%*[^\n]", buf); ++ /* skip the first line */ ++ if (line++ == 0) ++ continue; ++ /* skip empty line */ ++ if (strlen(buf) == 0) ++ continue; ++ ++ if (realpath(buf, real_mnt_device) == NULL) ++ continue; ++ if (strcmp(real_devname, real_mnt_device) == 0) { ++ fprintf(stderr, "device %s mounted by Lustre\n", ++ real_devname); ++ rc = -1; ++ break; ++ } ++ } ++ pclose(fp); ++ } ++ ++ return rc; ++} ++ ++static int check_lustre_ldiskfs(const char *mnt_device, ++ const char *real_devname) ++{ ++ char *real_mnt_device; ++ ++ real_mnt_device = malloc(PATH_MAX); ++ if (real_mnt_device == NULL) { ++ fprintf(stderr, "Cannot allocate memory to store path\n"); ++ return 1; ++ } ++ ++ memset(real_mnt_device, 0, PATH_MAX); ++ if (realpath(mnt_device, real_mnt_device) == NULL) { ++ fprintf(stderr, "Cannot resolve mntdev %s\n", mnt_device); ++ free(real_mnt_device); ++ return 1; ++ } ++ ++ if (strcmp(real_devname, real_mnt_device) == 0) { ++ fprintf(stderr, "device %s mounted by lustre\n", real_devname); ++ free(real_mnt_device); ++ return -1; ++ } ++ ++ free(real_mnt_device); ++ return 0; ++} ++ ++static int check_lustre_proc_vals(const char *procname,const char *real_devname) ++{ ++ struct dirent *direntp; ++ DIR *dirp; ++ int rc = 0; ++ char *mnt_device, *proc_val; ++ ++ mnt_device = malloc(PATH_MAX); ++ if (mnt_device == NULL) { ++ fprintf(stderr, "Cannot allocate memory to store device\n"); ++ return 1; ++ } ++ proc_val = malloc(PATH_MAX); ++ if (proc_val == NULL) { ++ fprintf(stderr, "Cannot allocate memory to store proc\n"); ++ free(mnt_device); ++ return 1; ++ } ++ ++ dirp = opendir(procname); ++ if (dirp) { ++ do { ++ int fd, numr; ++ char *ptr; ++ ++ direntp = readdir(dirp); ++ if (direntp == NULL) ++ break; ++ if ((strncmp(direntp->d_name, ".", 1) == 0) || ++ (strncmp(direntp->d_name, "..", 2) == 0)) { ++ continue; ++ } ++ ++ memset(proc_val, 0, PATH_MAX); ++ snprintf(proc_val, PATH_MAX, "%s/%s/mntdev", procname, ++ direntp->d_name); ++ fd = open(proc_val, O_RDONLY); ++ if (fd < 0) { ++ if (errno == ENOENT || errno == ENOTDIR) ++ continue; ++ fprintf(stderr, "Cannot open %s: %s\n", ++ proc_val, strerror(errno)); ++ rc = 1; ++ break; ++ } ++ ++ memset(mnt_device, 0, PATH_MAX); ++ numr = read(fd, mnt_device, PATH_MAX); ++ if (numr < 0) { ++ fprintf(stderr, "Failure to get mntdev info\n"); ++ rc = 1; ++ close(fd); ++ break; ++ } ++ close(fd); ++ ++ ptr = strchr(mnt_device, '\n'); ++ if (ptr) ++ *ptr = '\0'; ++ ++ if (strstr(procname, "osd-zfs") != NULL) ++ rc = check_lustre_zfs(mnt_device, real_devname); ++ else ++ rc = check_lustre_ldiskfs(mnt_device, ++ real_devname); ++ ++ } while (direntp != NULL && rc == 0); ++ ++ closedir(dirp); ++ } ++ ++ free(proc_val); ++ free(mnt_device); ++ ++ return rc; ++} ++ ++static errcode_t check_if_lustre_mounted(const char *device, int *mount_flags) ++{ ++ char *real_device; ++ int rc = 0; ++ ++ real_device = malloc(PATH_MAX); ++ if (real_device == NULL) { ++ fprintf(stderr, "Cannot allocate memory to store path\n"); ++ return EXT2_ET_NO_MEMORY; ++ } ++ ++ if (realpath(device, real_device) == NULL) { ++ fprintf(stderr, "Cannot resolve path %s\n", device); ++ rc = EXT2_ET_BAD_DEVICE_NAME; ++ goto out_free; ++ } ++ ++ rc = check_lustre_proc_vals("/proc/fs/lustre/osd-ldiskfs", real_device); ++ if (!rc) ++ rc = check_lustre_proc_vals("/proc/fs/lustre/osd-zfs", ++ real_device); ++ if (rc) ++ *mount_flags |= EXT2_MF_MOUNTED; ++ ++out_free: ++ free(real_device); ++ ++ return rc; ++} ++ + + /* + * ext2fs_check_mount_point() fills determines if the device is +@@ -420,6 +611,8 @@ errcode_t ext2fs_check_mount_point(const char *device, int *mount_flags, + if (busy) + *mount_flags |= EXT2_MF_BUSY; + ++ retval = check_if_lustre_mounted(device, mount_flags); ++ + return 0; + } + +diff --git a/lib/ext2fs/lfsck.h b/lib/ext2fs/lfsck.h +new file mode 100644 +index 0000000..5f182bc +--- /dev/null ++++ b/lib/ext2fs/lfsck.h +@@ -0,0 +1,122 @@ ++#ifndef LFSCK_H ++#define LFSCK_H ++ ++/* This is unfortunately needed for older lustre_user.h to be usable */ ++#define LASSERT(cond) do { } while (0) ++ ++#ifdef HAVE_LUSTRE_LUSTREAPI_H ++#include ++#elif HAVE_LUSTRE_LIBLUSTREAPI_H ++#include ++#endif ++ ++#ifndef DFID ++#define DFID "[%#llx:0x%x:0x%x]" ++#define PFID(fid) (unsigned long long)fid_seq(fid), fid_oid(fid), fid_ver(fid) ++struct lu_fid { ++ __u64 f_seq; ++ __u32 f_oid; ++ __u32 f_ver; ++}; ++#endif /* !DFID */ ++ ++/* Unfortunately, neither the 1.8 or 2.x lustre_idl.h file is suitable ++ * for inclusion by userspace programs because of external dependencies. ++ * Define the minimum set of replacement functions here until that is fixed. */ ++#ifndef HAVE_LUSTRE_LUSTRE_IDL_H ++#define fid_seq(fid) ((fid)->f_seq) ++#define fid_oid(fid) ((fid)->f_oid) ++#define fid_ver(fid) ((fid)->f_ver) ++ ++static inline void fid_be_to_cpu(struct lu_fid *dst, struct lu_fid *src) ++{ ++ dst->f_seq = ext2fs_be64_to_cpu(src->f_seq); ++ dst->f_oid = ext2fs_be32_to_cpu(src->f_oid); ++ dst->f_ver = ext2fs_be32_to_cpu(src->f_ver); ++} ++ ++static inline void fid_le_to_cpu(struct lu_fid *dst, struct lu_fid *src) ++{ ++ dst->f_seq = ext2fs_le64_to_cpu(src->f_seq); ++ dst->f_oid = ext2fs_le32_to_cpu(src->f_oid); ++ dst->f_ver = ext2fs_le32_to_cpu(src->f_ver); ++} ++#endif /* HAVE_LUSTRE_LUSTRE_IDL_H */ ++ ++#define LUSTRE_XATTR_MDT_LOV "lov" ++#define LUSTRE_XATTR_MDT_LMA "lma" ++#define LUSTRE_XATTR_MDT_LINK "link" ++#define LUSTRE_XATTR_OST_FID "fid" ++ ++#ifndef LMA_OLD_SIZE ++#ifndef LMA_INCOMPAT_SUPP ++struct lustre_mdt_attrs { ++ __u32 lma_compat; ++ __u32 lma_incompat; ++ struct lu_fid lma_self_fid; ++}; ++struct lustre_ost_attrs { ++ struct lustre_mdt_attrs loa_lma; ++ struct lu_fid loa_parent_fid; ++ __u32 loa_stripe_size; ++ __u32 loa_pfl_id; ++ __u64 loa_pfl_start; ++ __u64 loa_pfl_end; ++}; ++#endif ++ ++struct filter_fid_old { ++ struct lu_fid ff_parent; ++ __u64 ff_objid; ++ __u64 ff_seq; ++}; ++ ++struct filter_fid_210 { ++ struct lu_fid ff_parent; ++ __u32 ff_stripe_size; ++ __u32 ff_stripe_count; ++ __u64 ff_pfl_start; ++ __u64 ff_pfl_end; ++ __u32 ff_pfl_id; ++}; ++ ++struct filter_fid { ++ struct lu_fid ff_parent; ++ __u32 ff_stripe_size; ++ __u32 ff_stripe_count; ++ __u64 ff_pfl_start; ++ __u64 ff_pfl_end; ++ __u32 ff_pfl_id; ++ __u32 ff_layout_version; ++ __u32 ff_range; ++} __attribute__((packed)); ++ ++#define LMA_OLD_SIZE 64 ++#endif /* !LMA_OLD_SIZE */ ++ ++#define PFID_STRIPE_IDX_BITS 16 ++#define PFID_STRIPE_COUNT_MASK ((1 << PFID_STRIPE_IDX_BITS) - 1) ++ ++#ifndef LINK_EA_MAGIC ++/** Hardlink data is name and parent fid. ++ * Stored in this crazy struct for maximum packing and endian-neutrality */ ++struct link_ea_entry { ++ /** lee_reclen is a __u16 stored big-endian, unaligned */ ++ unsigned char lee_reclen[2]; /* record size in bytes */ ++ unsigned char lee_parent_fid[sizeof(struct lu_fid)]; ++ char lee_name[0]; /* filename without trailing NUL */ ++}__attribute__((packed)); ++ ++/** The link ea holds 1 \a link_ea_entry for each hardlink */ ++#define LINK_EA_MAGIC 0x11EAF1DFUL ++struct link_ea_header { ++ __u32 leh_magic; /* LINK_EA_MAGIC */ ++ __u32 leh_reccount; /* number of records in leh_entry[] */ ++ __u64 leh_len; /* total size in bytes */ ++ __u32 leh_overflow_time; /* when link xattr ran out of space */ ++ __u32 padding; ++ struct link_ea_entry leh_entry[0]; /* packed array of variable-size entries */ ++}; ++#endif ++ ++#endif /* LFSCK_H */ +diff --git a/lib/ext2fs/link.c b/lib/ext2fs/link.c +index d69b1e3..60d06fb 100644 +--- a/lib/ext2fs/link.c ++++ b/lib/ext2fs/link.c +@@ -197,7 +197,7 @@ static int link_proc(ext2_ino_t dir EXT2FS_ATTR((unused)), + if (ls->done) + return DIRENT_ABORT; + +- rec_len = EXT2_DIR_REC_LEN(ls->namelen); ++ rec_len = EXT2_DIR_NAME_LEN(ls->namelen); + + ls->err = ext2fs_get_rec_len(ls->fs, dirent, &curr_rec_len); + if (ls->err) +@@ -226,7 +226,7 @@ static int link_proc(ext2_ino_t dir EXT2FS_ATTR((unused)), + * truncate it and return. + */ + if (dirent->inode) { +- min_rec_len = EXT2_DIR_REC_LEN(ext2fs_dirent_name_len(dirent)); ++ min_rec_len = EXT2_DIR_REC_LEN(dirent); + if (curr_rec_len < (min_rec_len + rec_len)) + return ret; + rec_len = curr_rec_len - min_rec_len; +@@ -254,7 +254,7 @@ static int link_proc(ext2_ino_t dir EXT2FS_ATTR((unused)), + ext2fs_dirent_set_name_len(dirent, ls->namelen); + strncpy(dirent->name, ls->name, ls->namelen); + if (ext2fs_has_feature_filetype(ls->sb)) +- ext2fs_dirent_set_file_type(dirent, ls->flags & 0x7); ++ ext2fs_dirent_set_file_type(dirent, ls->flags & EXT2_FT_MASK); + + ls->done++; + return DIRENT_ABORT|DIRENT_CHANGED; +@@ -330,8 +330,8 @@ static errcode_t dx_move_dirents(ext2_filsys fs, struct dx_hash_map *map, + csum_size = sizeof(struct ext2_dir_entry_tail); + + for (i = 0; i < count; i++) { +- de = (struct ext2_dir_entry *) ((char *)from + map[i].off); +- rec_len = EXT2_DIR_REC_LEN(ext2fs_dirent_name_len(de)); ++ de = from + map[i].off; ++ rec_len = EXT2_DIR_REC_LEN(de); + memcpy(to, de, rec_len); + retval = ext2fs_set_rec_len(fs, rec_len, to); + if (retval) +diff --git a/lib/ext2fs/mkjournal.c b/lib/ext2fs/mkjournal.c +index 11d73e3..2be1009 100644 +--- a/lib/ext2fs/mkjournal.c ++++ b/lib/ext2fs/mkjournal.c +@@ -33,6 +33,10 @@ + #if HAVE_NETINET_IN_H + #include + #endif ++#ifdef __linux__ ++#include ++#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c)) ++#endif + + #include "ext2_fs.h" + #include "e2p/e2p.h" +@@ -347,6 +351,54 @@ out2: + return retval; + } + ++#ifdef __linux__ ++static int parse_version_number(const char *s) ++{ ++ int major, minor, rev; ++ char *endptr; ++ const char *cp = s; ++ ++ if (!s) ++ return 0; ++ major = strtol(cp, &endptr, 10); ++ if (cp == endptr || *endptr != '.') ++ return 0; ++ cp = endptr + 1; ++ minor = strtol(cp, &endptr, 10); ++ if (cp == endptr || *endptr != '.') ++ return 0; ++ cp = endptr + 1; ++ rev = strtol(cp, &endptr, 10); ++ if (cp == endptr) ++ return 0; ++ return KERNEL_VERSION(major, minor, rev); ++} ++ ++int ext2fs_is_before_linux_ver(unsigned int major, unsigned int minor, ++ unsigned int rev) ++{ ++ struct utsname ut; ++ static int linux_version_code = -1; ++ ++ if (uname(&ut)) { ++ perror("uname"); ++ exit(1); ++ } ++ if (linux_version_code < 0) ++ linux_version_code = parse_version_number(ut.release); ++ if (linux_version_code == 0) ++ return 0; ++ ++ return linux_version_code < KERNEL_VERSION(major, minor, rev); ++} ++#else ++int ext2fs_is_before_linux_ver(unsigned int major, unsigned int minor, ++ unsigned int rev) ++{ ++ return 0; ++} ++#endif ++ + /* + * Find a reasonable journal file size (in blocks) given the number of blocks + * in the filesystem. For very small filesystems, it is not reasonable to +@@ -358,8 +410,10 @@ int ext2fs_default_journal_size(__u64 num_blocks) + { + if (num_blocks < 2048) + return -1; +- if (num_blocks < 32768) /* 128 MB */ ++ if (num_blocks <= 8192) /* 32 MB */ + return (1024); /* 4 MB */ ++ if (num_blocks < 32768) /* 128 MB */ ++ return (2048); /* 8 MB */ + if (num_blocks < 256*1024) /* 1 GB */ + return (4096); /* 16 MB */ + if (num_blocks < 512*1024) /* 2 GB */ +diff --git a/lib/ext2fs/newdir.c b/lib/ext2fs/newdir.c +index 7f47285..f168d66 100644 +--- a/lib/ext2fs/newdir.c ++++ b/lib/ext2fs/newdir.c +@@ -64,8 +64,8 @@ errcode_t ext2fs_new_dir_block(ext2_filsys fs, ext2_ino_t dir_ino, + ext2fs_dirent_set_name_len(dir, 1); + ext2fs_dirent_set_file_type(dir, filetype); + dir->name[0] = '.'; +- rec_len = (fs->blocksize - csum_size) - EXT2_DIR_REC_LEN(1); +- dir->rec_len = EXT2_DIR_REC_LEN(1); ++ rec_len = (fs->blocksize - csum_size) - EXT2_DIR_NAME_LEN(1); ++ dir->rec_len = EXT2_DIR_NAME_LEN(1); + + /* + * Set up entry for '..' +diff --git a/lib/ext2fs/swapfs.c b/lib/ext2fs/swapfs.c +index 1006b2d..cd160b3 100644 +--- a/lib/ext2fs/swapfs.c ++++ b/lib/ext2fs/swapfs.c +@@ -244,7 +244,7 @@ void ext2fs_swap_inode_full(ext2_filsys fs, struct ext2_inode_large *t, + int bufsize) + { + unsigned i, extra_isize, attr_magic; +- int has_extents, has_inline_data, islnk, fast_symlink; ++ int has_extents = 0, has_inline_data = 0, islnk = 0, fast_symlink = 0; + unsigned int inode_size; + __u32 *eaf, *eat; + +diff --git a/lib/ext2fs/tst_read_ea.c b/lib/ext2fs/tst_read_ea.c +new file mode 100644 +index 0000000..1722dd0 +--- /dev/null ++++ b/lib/ext2fs/tst_read_ea.c +@@ -0,0 +1,239 @@ ++/* ++ * tst_read_ea.c --- this function tests the in-inode xattrs ++ * ++ * %Begin-Header% ++ * This file may be redistributed under the terms of the GNU Public ++ * License. ++ * %End-Header% ++ */ ++ ++#ifndef _GNU_SOURCE ++#define _GNU_SOURCE /* for asprintf */ ++#endif ++#include ++#include ++#if HAVE_UNISTD_H ++#include ++#endif ++#include ++#include ++#include ++#include ++#ifdef HAVE_ATTR_XATTR_H ++#include ++#elif HAVE_SYS_XATTR_H ++#include ++#else ++/* This is just a test program, let's try to work around the lack of header */ ++extern ssize_t fgetxattr (int __filedes, const char *__name, ++ void *__value, size_t __size); ++extern int fsetxattr (int __filedes, const char *__name, ++ const void *__value, size_t __size, int __flags); ++#endif ++#if HAVE_MNTENT_H ++#include ++#include ++#if HAVE_ERRNO_H ++#include ++#endif ++ ++#include "ext2_fs.h" ++#include "ext2fs.h" ++ ++#define NR_XATTRS 256 ++char tmpvalue[NR_XATTRS + 1]; ++ ++struct ea { ++ char *name; ++ char *value; ++}; ++ ++struct ea *ea_table; ++ ++static void init_ea_table(void) ++{ ++ int i; ++ ++ ea_table = malloc(sizeof(struct ea) * NR_XATTRS); ++ if (ea_table == NULL) { ++ perror("maloc failed"); ++ exit(1); ++ } ++ for (i = 0; i < NR_XATTRS; i ++) { ++ ea_table[i].name = malloc(i + 2 + strlen("user.")); ++ if (ea_table[i].name == NULL) { ++ perror("malloc failed"); ++ exit(1); ++ } ++ strcpy(ea_table[i].name, "user."); ++ memset(ea_table[i].name + strlen("user."), 'X', i + 1); ++ ea_table[i].name[i + 1 + strlen("user.")] = 0; ++ ++ ea_table[i].value = malloc(NR_XATTRS - i + 1); ++ if (ea_table[i].value == NULL) { ++ perror("malloc failed"); ++ exit(1); ++ } ++ memset(ea_table[i].value, 'Y', NR_XATTRS - i); ++ ea_table[i].value[NR_XATTRS - i] = 0; ++ } ++} ++ ++static int set_xattrs(int fd) ++{ ++ int i; ++ ++ for (i = 0; i < NR_XATTRS; i ++) { ++ if (fsetxattr(fd, ea_table[i].name, ea_table[i].value, ++ NR_XATTRS - i + 1, XATTR_CREATE) == -1) { ++ if (errno != ENOSPC) { ++ perror("fsetxattr failed"); ++ exit(1); ++ } ++ break; ++ } ++ } ++ printf("\t%d xattrs are set\n", i); ++ return i; ++} ++ ++void get_xattrs1(int fd, int nr) ++{ ++ int i; ++ ssize_t size; ++ ++ printf("\ttesting fgetxattr .. "); fflush(stdout); ++ ++ for (i = 0; i < nr; i ++) { ++ size = fgetxattr(fd, ea_table[i].name, tmpvalue, ++ NR_XATTRS - i + 1); ++ if (size == -1) { ++ perror("fgetxattr failed"); ++ exit(1); ++ } ++ if (memcmp(ea_table[i].value, tmpvalue, nr - i + 1)) { ++ fprintf(stderr, "value mismatch"); ++ exit(1); ++ } ++ } ++ ++ printf("%d xattrs are checked, ok\n", i); ++} ++ ++void get_xattrs2(const char *device, ext2_ino_t ino, int nr) ++{ ++ ext2_filsys fs; ++ int i; ++ struct ext2_inode *inode; ++ errcode_t err; ++ int size; ++ ++ printf("\ttesting ext2fs_attr_get .. "); fflush(stdout); ++ ++ err = ext2fs_open(device, 0, 0, 0, unix_io_manager, &fs); ++ assert(err == 0); ++ ++ err = ext2fs_get_mem(EXT2_INODE_SIZE(fs->super), &inode); ++ if (err) { ++ com_err("get_xattrs2", err, "allocating memory"); ++ exit(1); ++ } ++ ++ err = ext2fs_read_inode_full(fs, ino, inode, ++ EXT2_INODE_SIZE(fs->super)); ++ if (err) { ++ com_err("get_xattrs2", err, "reading inode"); ++ exit(1); ++ } ++ for (i = 0; i < nr; i ++) { ++ err = ext2fs_attr_get(fs, inode, EXT2_ATTR_INDEX_USER, ++ ea_table[i].name + strlen("user."), ++ tmpvalue, sizeof(tmpvalue), &size); ++ if (err) { ++ com_err("get_xattrs2", err, "getting xattr"); ++ exit(1); ++ } ++ assert(size == (NR_XATTRS - i + 1)); ++ ++ if (memcmp(ea_table[i].value, tmpvalue, size)) { ++ fprintf(stderr, "value mismatch"); ++ exit(1); ++ } ++ } ++ ext2fs_close(fs); ++ ++ printf("%d xattrs are checked, ok\n", i); ++} ++#endif /* HAVE_MNTENT_H */ ++ ++int main(int argc, const char *argv[]) ++{ ++#if HAVE_MNTENT_H ++ ext2_filsys fs; ++ FILE *f; ++ struct mntent *mnt; ++ char *name; ++ int fd; ++ errcode_t err; ++ struct stat st; ++ int nr; ++ int tested = 0; ++ ++ initialize_ext2_error_table(); ++ ++ init_ea_table(); ++ ++ f = setmntent(MOUNTED, "r"); ++ if (!f) { ++ fprintf(stderr, "failed to setmntent\n"); ++ return 1; ++ } ++ ++ while ((mnt = getmntent(f)) != NULL) { ++ if (hasmntopt(mnt, "user_xattr") == NULL) ++ continue; ++ err = ext2fs_open(mnt->mnt_fsname, 0, 0, 0, ++ unix_io_manager, &fs); ++ if (err) { ++ com_err("tst_read_ea", err, "opening fs %s:%s", ++ mnt->mnt_fsname, mnt->mnt_type); ++ continue; ++ } ++ ext2fs_close(fs); ++ ++ printf("type=%s, fsname=%s, mtpt=%s\n", mnt->mnt_type, ++ mnt->mnt_fsname, mnt->mnt_dir); ++ ++ asprintf(&name, "%s/readeaXXXXXX", mnt->mnt_dir); ++ fd = mkstemp(name); ++ if (fd == -1) { ++ fprintf(stderr, "tst_read_ea: mkstemp failed on %s: %s", ++ name, strerror(errno)); ++ continue; ++ } ++ if (fstat(fd, &st)) { ++ fprintf(stderr, "tst_read_ea: fstat failed on %s: %s\n", ++ name, strerror(errno)); ++ exit(1); ++ } ++ nr = set_xattrs(fd); ++ ++ sync(); ++ get_xattrs1(fd, nr); ++ close(fd); ++ ++ get_xattrs2(mnt->mnt_fsname, st.st_ino, nr); ++ ++ unlink(name); ++ free(name); ++ tested = 1; ++ } ++ endmntent(f); ++ ++ if (!tested) ++ fprintf(stderr, ++ "\tno ext2 based filesystems mounted with user_xattr\n" ++ "\thope it is ok\n"); ++#endif /* HAVE_MNTENT_H */ ++ return 0; ++} +diff --git a/misc/chattr.c b/misc/chattr.c +index 644ef4e..c7382a3 100644 +--- a/misc/chattr.c ++++ b/misc/chattr.c +@@ -86,7 +86,7 @@ static unsigned long sf; + static void usage(void) + { + fprintf(stderr, +- _("Usage: %s [-pRVf] [-+=aAcCdDeijPsStTuFx] [-v version] files...\n"), ++ _("Usage: %s [-RVf] [-+=aAcCdDeijPsStTuFx] [-p project] [-v version] files...\n"), + program_name); + exit(1); + } +diff --git a/misc/filefrag.8.in b/misc/filefrag.8.in +index 6d56c13..7b7e424 100644 +--- a/misc/filefrag.8.in ++++ b/misc/filefrag.8.in +@@ -8,7 +8,7 @@ filefrag \- report on file fragmentation + .BI \-b blocksize + ] + [ +-.B \-BeEkPsvVxX ++.B \-BeEklPsvVxX + ] + [ + .I files... +@@ -57,6 +57,9 @@ Use 1024\-byte blocksize for output (identical to '\-b1024'). + Pre-load the ext4 extent status cache for the file. This is not + supported on all kernels, and is only supported on ext4 file systems. + .TP ++.B \-l ++Extents are displayed in device-logical offset order. ++.TP + .B \-s + Sync the file before requesting the mapping. + .TP +@@ -72,6 +75,10 @@ Display mapping of extended attributes. + .TP + .B \-X + Display extent block numbers in hexadecimal format. ++.TP ++.B \-V ++Print version number of program and library. If given twice, also ++print the FIEMAP flags that are understood by the current version. + .SH AUTHOR + .B filefrag + was written by Theodore Ts'o . +diff --git a/misc/filefrag.c b/misc/filefrag.c +index eaaa90a..9dab747 100644 +--- a/misc/filefrag.c ++++ b/misc/filefrag.c +@@ -61,12 +61,14 @@ int xattr_map = 0; /* get xattr mapping */ + int force_bmap; /* force use of FIBMAP instead of FIEMAP */ + int force_extent; /* print output in extent format always */ + int use_extent_cache; /* Use extent cache */ ++int device_offset; /* extents report device-relative offsets */ + int logical_width = 8; + int physical_width = 10; + const char *ext_fmt = "%4d: %*llu..%*llu: %*llu..%*llu: %6llu: %s\n"; + const char *hex_fmt = "%4d: %*llx..%*llx: %*llx..%*llx: %6llx: %s\n"; + +-#define FILEFRAG_FIEMAP_FLAGS_COMPAT (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_XATTR) ++#define FILEFRAG_FIEMAP_FLAGS_COMPAT (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_XATTR |\ ++ FIEMAP_FLAG_DEVICE_ORDER) + + #define FIBMAP _IO(0x00, 1) /* bmap access */ + #define FIGETBSZ _IO(0x00, 2) /* get the block size used for bmap */ +@@ -125,10 +127,10 @@ static void print_extent_header(void) + { + printf(" ext: %*s %*s length: %*s flags:\n", + logical_width * 2 + 3, +- "logical_offset:", ++ device_offset ? "device_logical:" : "logical_offset:", + physical_width * 2 + 3, "physical_offset:", +- physical_width + 1, +- "expected:"); ++ device_offset ? 5 : physical_width + 1, ++ device_offset ? " dev:" : "expected:"); + } + + static void print_flag(__u32 *flags, __u32 mask, char *buf, const char *name) +@@ -163,6 +165,8 @@ static void print_flags(__u32 fe_flags, char *flags, int len, int print_unknown) + print_flag(&fe_flags, FIEMAP_EXTENT_SHARED, flags, "shared,"); + print_flag(&fe_flags, EXT4_FIEMAP_EXTENT_HOLE, flags, "hole,"); + ++ print_flag(&fe_flags, FIEMAP_EXTENT_NET, flags, "net,"); ++ + if (!print_unknown) + goto out; + +@@ -200,13 +204,13 @@ static void print_extent_info(struct fiemap_extent *fm_extent, int cur_ex, + physical_blk = fm_extent->fe_physical >> blk_shift; + } + +- if (expected && ++ if (device_offset) ++ sprintf(flags, "%04x: ", fm_extent->fe_device & 0xffff); ++ else if (expected && + !(fm_extent->fe_flags & FIEMAP_EXTENT_UNKNOWN) && + !(fm_extent->fe_flags & EXT4_FIEMAP_EXTENT_HOLE)) + sprintf(flags, ext_fmt == hex_fmt ? "%*llx: " : "%*llu: ", + physical_width, expected >> blk_shift); +- else +- sprintf(flags, "%.*s ", physical_width, " "); + + print_flags(fm_extent->fe_flags, flags, sizeof(flags), 1); + +@@ -244,6 +248,7 @@ static int filefrag_fiemap(int fd, int blk_shift, int *num_extents, + unsigned long cmd = FS_IOC_FIEMAP; + int fiemap_header_printed = 0; + int tot_extents = 0, n = 0; ++ int previous_device = -1; + int last = 0; + int rc; + +@@ -262,6 +267,12 @@ static int filefrag_fiemap(int fd, int blk_shift, int *num_extents, + if (use_extent_cache) + cmd = EXT4_IOC_GET_ES_CACHE; + ++ if (device_offset) { ++ flags |= FIEMAP_FLAG_DEVICE_ORDER; ++ memset(fm_ext, 0, sizeof(struct fiemap_extent)); ++ } ++ ++retry_wo_device_order: + do { + fiemap->fm_length = ~0ULL; + fiemap->fm_flags = flags; +@@ -276,6 +287,10 @@ static int filefrag_fiemap(int fd, int blk_shift, int *num_extents, + "flags %x\n", + fiemap->fm_flags); + fiemap_incompat_printed = 1; ++ } else if (rc == EBADR && (fiemap->fm_flags & ++ FIEMAP_FLAG_DEVICE_ORDER)) { ++ flags &= ~FIEMAP_FLAG_DEVICE_ORDER; ++ goto retry_wo_device_order; + } + return rc; + } +@@ -294,9 +309,10 @@ static int filefrag_fiemap(int fd, int blk_shift, int *num_extents, + fm_last.fe_length; + expected = fm_last.fe_physical + + fm_ext[i].fe_logical - fm_last.fe_logical; +- if (fm_ext[i].fe_logical != 0 && +- fm_ext[i].fe_physical != expected && +- fm_ext[i].fe_physical != expected_dense) { ++ if ((fm_ext[i].fe_logical != 0 && ++ fm_ext[i].fe_physical != expected && ++ fm_ext[i].fe_physical != expected_dense) || ++ ((fm_ext[i].fe_device & 0xffff) != previous_device)) { + tot_extents++; + } else { + expected = 0; +@@ -310,10 +326,23 @@ static int filefrag_fiemap(int fd, int blk_shift, int *num_extents, + last = 1; + fm_last = fm_ext[i]; + n++; ++ previous_device = fm_ext[i].fe_device & 0xffff; + } + +- fiemap->fm_start = (fm_ext[i - 1].fe_logical + +- fm_ext[i - 1].fe_length); ++ /* For DEVICE_ORDER mappings, if EXTENT_LAST not yet found then ++ * fm_start needs to be the same as it was for earlier ioctl. ++ * The first extent is used to pass the end offset and device ++ * of the last FIEMAP call. Otherwise, we ask for extents ++ * starting from where the last mapping ended. */ ++ if (flags & FIEMAP_FLAG_DEVICE_ORDER) { ++ fm_ext[0].fe_logical = fm_ext[i - 1].fe_logical + ++ fm_ext[i - 1].fe_length; ++ fm_ext[0].fe_device = fm_ext[i - 1].fe_device; ++ fiemap->fm_start = 0; ++ } else { ++ fiemap->fm_start = fm_ext[i - 1].fe_logical + ++ fm_ext[i - 1].fe_length; ++ } + } while (last == 0); + + *num_extents = tot_extents; +@@ -337,6 +366,7 @@ static int filefrag_fibmap(int fd, int blk_shift, int *num_extents, + memset(&fm_ext, 0, sizeof(fm_ext)); + memset(&fm_last, 0, sizeof(fm_last)); + if (force_extent) { ++ fm_ext.fe_device = st->st_dev; + fm_ext.fe_flags = FIEMAP_EXTENT_MERGED; + } + +@@ -471,6 +501,13 @@ static int frag_report(const char *filename) + is_ext2 = 1; + } + ++ /* Check if filesystem is Lustre. Always print in extent format ++ * with 1kB blocks, using the device-relative logical offsets. */ ++ if (fsinfo.f_type == LUSTRE_SUPER_MAGIC) { ++ device_offset = 1; ++ blocksize = blocksize ?: 1024; ++ } ++ + if (is_ext2) { + long cylgroups = div_ceil(fsinfo.f_blocks, blksize * 8); + +@@ -580,10 +617,11 @@ int main(int argc, char**argv) + int rc = 0, c; + int version = 0; + +- while ((c = getopt(argc, argv, "Bb::eEkPsvVxX")) != EOF) { ++ while ((c = getopt(argc, argv, "Bb::eEkPlsvxXV")) != EOF) { + switch (c) { + case 'B': + force_bmap++; ++ force_extent = 0; + break; + case 'b': + if (optarg) { +@@ -648,6 +686,9 @@ int main(int argc, char**argv) + case 'P': + precache_file++; + break; ++ case 'l': ++ device_offset++; ++ break; + case 's': + sync_file++; + break; +diff --git a/misc/fuse2fs.c b/misc/fuse2fs.c +index c595721..f73ceba 100644 +--- a/misc/fuse2fs.c ++++ b/misc/fuse2fs.c +@@ -2496,6 +2496,7 @@ out: + + static int count_buffer_space(char *name, char *value EXT2FS_ATTR((unused)), + size_t value_len EXT2FS_ATTR((unused)), ++ ext2_ino_t inode_num EXT2FS_ATTR((unused)), + void *data) + { + unsigned int *x = data; +@@ -2505,7 +2506,9 @@ static int count_buffer_space(char *name, char *value EXT2FS_ATTR((unused)), + } + + static int copy_names(char *name, char *value EXT2FS_ATTR((unused)), +- size_t value_len EXT2FS_ATTR((unused)), void *data) ++ size_t value_len EXT2FS_ATTR((unused)), ++ ext2_ino_t inode_num EXT2FS_ATTR((unused)), ++ void *data) + { + char **b = data; + +diff --git a/misc/mke2fs.c b/misc/mke2fs.c +index 04b2fbc..3c77bef 100644 +--- a/misc/mke2fs.c ++++ b/misc/mke2fs.c +@@ -24,10 +24,6 @@ + #include + #include + #include +-#ifdef __linux__ +-#include +-#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c)) +-#endif + #ifdef HAVE_GETOPT_H + #include + #else +@@ -165,54 +161,6 @@ int int_log10(unsigned long long arg) + return l; + } + +-#ifdef __linux__ +-static int parse_version_number(const char *s) +-{ +- int major, minor, rev; +- char *endptr; +- const char *cp = s; +- +- if (!s) +- return 0; +- major = strtol(cp, &endptr, 10); +- if (cp == endptr || *endptr != '.') +- return 0; +- cp = endptr + 1; +- minor = strtol(cp, &endptr, 10); +- if (cp == endptr || *endptr != '.') +- return 0; +- cp = endptr + 1; +- rev = strtol(cp, &endptr, 10); +- if (cp == endptr) +- return 0; +- return KERNEL_VERSION(major, minor, rev); +-} +- +-static int is_before_linux_ver(unsigned int major, unsigned int minor, +- unsigned int rev) +-{ +- struct utsname ut; +- static int linux_version_code = -1; +- +- if (uname(&ut)) { +- perror("uname"); +- exit(1); +- } +- if (linux_version_code < 0) +- linux_version_code = parse_version_number(ut.release); +- if (linux_version_code == 0) +- return 0; +- +- return linux_version_code < (int) KERNEL_VERSION(major, minor, rev); +-} +-#else +-static int is_before_linux_ver(unsigned int major, unsigned int minor, +- unsigned int rev) +-{ +- return 0; +-} +-#endif +- + /* + * Helper function for read_bb_file and test_disk + */ +@@ -1165,6 +1113,7 @@ static __u32 ok_features[3] = { + EXT4_FEATURE_INCOMPAT_FLEX_BG| + EXT4_FEATURE_INCOMPAT_EA_INODE| + EXT4_FEATURE_INCOMPAT_MMP | ++ EXT4_FEATURE_INCOMPAT_DIRDATA| + EXT4_FEATURE_INCOMPAT_64BIT| + EXT4_FEATURE_INCOMPAT_INLINE_DATA| + EXT4_FEATURE_INCOMPAT_ENCRYPT | +@@ -1488,6 +1437,9 @@ struct device_param { + unsigned int dax:1; /* supports dax? */ + }; + ++#define OPTIMIZED_STRIPE_WIDTH 512 ++#define OPTIMIZED_STRIDE 512 ++ + #ifdef HAVE_BLKID_PROBE_GET_TOPOLOGY + /* + * Sets the geometry of a device (stripe/stride), and returns the +@@ -1518,7 +1470,19 @@ static int get_device_geometry(const char *file, + goto out; + + dev_param->min_io = blkid_topology_get_minimum_io_size(tp); ++ if (dev_param->min_io > OPTIMIZED_STRIDE) { ++ fprintf(stdout, ++ "detected raid stride %lu too large, use optimum %lu\n", ++ dev_param->min_io, OPTIMIZED_STRIDE); ++ dev_param->min_io = OPTIMIZED_STRIDE; ++ } + dev_param->opt_io = blkid_topology_get_optimal_io_size(tp); ++ if (dev_param->opt_io > OPTIMIZED_STRIPE_WIDTH) { ++ fprintf(stdout, ++ "detected raid stripe width %lu too large, use optimum %lu\n", ++ dev_param->opt_io, OPTIMIZED_STRIPE_WIDTH); ++ dev_param->opt_io = OPTIMIZED_STRIPE_WIDTH; ++ } + if ((dev_param->min_io == 0) && (psector_size > blocksize)) + dev_param->min_io = psector_size; + if ((dev_param->opt_io == 0) && dev_param->min_io > 0) +@@ -1637,7 +1601,7 @@ profile_error: + memset(&fs_param, 0, sizeof(struct ext2_super_block)); + fs_param.s_rev_level = 1; /* Create revision 1 filesystems now */ + +- if (is_before_linux_ver(2, 2, 0)) ++ if (ext2fs_is_before_linux_ver(2, 2, 0)) + fs_param.s_rev_level = 0; + + if (argc && *argv) { +@@ -2058,8 +2022,7 @@ profile_error: + * be appropriately configured. + */ + fs_types = parse_fs_type(fs_type, usage_types, &fs_param, +- fs_blocks_count ? fs_blocks_count : dev_size, +- argv[0]); ++ fs_blocks_count, argv[0]); + if (!fs_types) { + fprintf(stderr, "%s", _("Failed to parse fs types list\n")); + exit(1); +@@ -2162,7 +2125,8 @@ profile_error: + + if (use_bsize == -1) { + use_bsize = sys_page_size; +- if (is_before_linux_ver(2, 6, 0) && use_bsize > 4096) ++ if (ext2fs_is_before_linux_ver(2, 6, 0) && ++ use_bsize > 4096) + use_bsize = 4096; + } + if (lsector_size && use_bsize < lsector_size) +@@ -2192,24 +2156,25 @@ profile_error: + * We now need to do a sanity check of fs_blocks_count for + * 32-bit vs 64-bit block number support. + */ +- if ((fs_blocks_count > MAX_32_NUM) && +- ext2fs_has_feature_64bit(&fs_param)) +- ext2fs_clear_feature_resize_inode(&fs_param); +- if ((fs_blocks_count > MAX_32_NUM) && +- !ext2fs_has_feature_64bit(&fs_param) && +- get_bool_from_profile(fs_types, "auto_64-bit_support", 0)) { +- ext2fs_set_feature_64bit(&fs_param); +- ext2fs_clear_feature_resize_inode(&fs_param); +- } +- if ((fs_blocks_count > MAX_32_NUM) && +- !ext2fs_has_feature_64bit(&fs_param)) { +- fprintf(stderr, _("%s: Size of device (0x%llx blocks) %s " ++ if (fs_blocks_count > MAX_32_NUM) { ++ if (!ext2fs_has_feature_64bit(&fs_param) && ++ get_bool_from_profile(fs_types, "auto_64-bit_support", 0)) ++ ext2fs_set_feature_64bit(&fs_param); ++ ++ if (ext2fs_has_feature_64bit(&fs_param)) { ++ ext2fs_clear_feature_resize_inode(&fs_param); ++ } else { ++ fprintf(stderr, ++ _("%s: Size of device (0x%llx blocks) %s " + "too big to be expressed\n\t" + "in 32 bits using a blocksize of %d.\n"), +- program_name, (unsigned long long) fs_blocks_count, +- device_name, EXT2_BLOCK_SIZE(&fs_param)); +- exit(1); ++ program_name, ++ (unsigned long long) fs_blocks_count, ++ device_name, EXT2_BLOCK_SIZE(&fs_param)); ++ exit(1); ++ } + } ++ + /* + * Guard against group descriptor count overflowing... Mostly to avoid + * strange results for absurdly large devices. This is in log2: +@@ -2289,13 +2254,13 @@ profile_error: + fs_param.s_feature_compat = 0; + fs_param.s_feature_ro_compat &= + EXT4_FEATURE_RO_COMPAT_METADATA_CSUM; +- } ++ } + + /* Check the user's mkfs options for 64bit */ +- if (ext2fs_has_feature_64bit(&fs_param) && ++ if (fs_blocks_count > MAX_32_NUM && + !ext2fs_has_feature_extents(&fs_param)) { +- printf("%s", _("Extents MUST be enabled for a 64-bit " +- "filesystem. Pass -O extents to rectify.\n")); ++ printf("%s", _("Extents MUST be enabled for filesystems with " ++ "over 2^32 blocks. Use '-O extents' to fix.\n")); + exit(1); + } + +@@ -2394,7 +2359,7 @@ profile_error: + } + + /* Metadata checksumming wasn't totally stable before 3.18. */ +- if (is_before_linux_ver(3, 18, 0) && ++ if (ext2fs_is_before_linux_ver(3, 18, 0) && + ext2fs_has_feature_metadata_csum(&fs_param)) + fprintf(stderr, _("Suggestion: Use Linux kernel >= 3.18 for " + "improved stability of the metadata and journal " +@@ -2404,7 +2369,7 @@ profile_error: + * On newer kernels we do have lazy_itable_init support. So pick the + * right default in case ext4 module is not loaded. + */ +- if (is_before_linux_ver(2, 6, 37)) ++ if (ext2fs_is_before_linux_ver(2, 6, 37)) + lazy_itable_init = 0; + else + lazy_itable_init = 1; +@@ -2623,15 +2588,11 @@ _("128-byte inodes cannot handle dates beyond 2038 and are deprecated\n")); + unsigned long long n; + n = ext2fs_blocks_count(&fs_param) * blocksize / inode_ratio; + if (n > MAX_32_NUM) { +- if (ext2fs_has_feature_64bit(&fs_param)) +- num_inodes = MAX_32_NUM; +- else { ++ num_inodes = MAX_32_NUM; ++ if (!ext2fs_has_feature_64bit(&fs_param)) + com_err(program_name, 0, +- _("too many inodes (%llu), raise " +- "inode ratio?"), +- (unsigned long long) n); +- exit(1); +- } ++ _("too many inodes (%llu), reduced to " ++ "%llu"), n, MAX_32_NUM); + } + } else if (num_inodes > MAX_32_NUM) { + com_err(program_name, 0, +@@ -3082,6 +3043,19 @@ int main (int argc, char *argv[]) + exit(1); + } + ++ if (ext2fs_has_feature_dirdata(fs->super)) { ++ if (ext2fs_has_feature_inline_data(fs->super)) { ++ printf("%s", _("The dirdata feature can not enabled " ++ "with inline data feature.\n")); ++ exit(1); ++ } ++ if (ext2fs_has_feature_casefold(fs->super)) { ++ printf("%s", _("The dirdata feature can not enabled " ++ "with casefold feature.\n")); ++ exit(1); ++ } ++ } ++ + /* Calculate journal blocks */ + if (!journal_device && ((journal_size) || + ext2fs_has_feature_journal(&fs_param))) +diff --git a/misc/tune2fs.c b/misc/tune2fs.c +index e3d1362..11941f4 100644 +--- a/misc/tune2fs.c ++++ b/misc/tune2fs.c +@@ -159,6 +159,7 @@ static __u32 ok_features[3] = { + EXT4_FEATURE_INCOMPAT_FLEX_BG | + EXT4_FEATURE_INCOMPAT_EA_INODE| + EXT4_FEATURE_INCOMPAT_MMP | ++ EXT4_FEATURE_INCOMPAT_DIRDATA | + EXT4_FEATURE_INCOMPAT_64BIT | + EXT4_FEATURE_INCOMPAT_ENCRYPT | + EXT4_FEATURE_INCOMPAT_CSUM_SEED | +@@ -188,6 +189,7 @@ static __u32 clear_ok_features[3] = { + EXT2_FEATURE_INCOMPAT_FILETYPE | + EXT4_FEATURE_INCOMPAT_FLEX_BG | + EXT4_FEATURE_INCOMPAT_MMP | ++ EXT4_FEATURE_INCOMPAT_DIRDATA | + EXT4_FEATURE_INCOMPAT_64BIT | + EXT4_FEATURE_INCOMPAT_CSUM_SEED, + /* R/O compat */ +@@ -1482,6 +1484,11 @@ mmp_error: + } + + if (FEATURE_ON(E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_CASEFOLD)) { ++ if (ext2fs_has_feature_dirdata(sb)) { ++ fputs(_("Can not enable casefold feature on " ++ "filesystem has dirdata.\n"), stderr); ++ return 1; ++ } + if (mount_flags & EXT2_MF_MOUNTED) { + fputs(_("The casefold feature may only be enabled when " + "the filesystem is unmounted.\n"), stderr); +@@ -1526,6 +1533,25 @@ mmp_error: + } + } + ++ if (FEATURE_ON(E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_DIRDATA)) { ++ if (ext2fs_has_feature_inline_data(sb)) { ++ fputs(_("Can not enable dirdata feature on " ++ "filesystem has inline_data.\n"), stderr); ++ return 1; ++ } ++ if (ext2fs_has_feature_casefold(sb)) { ++ fputs(_("Can not enable dirdata feature on " ++ "filesystem has casefold.\n"), stderr); ++ return 1; ++ } ++ if (FEATURE_ON(E2P_FEATURE_INCOMPAT, ++ EXT4_FEATURE_INCOMPAT_CASEFOLD)) { ++ fputs(_("Can not enable dirdata feature with" ++ "casefold feature.\n"), stderr); ++ return 1; ++ } ++ } ++ + if (sb->s_rev_level == EXT2_GOOD_OLD_REV && + (sb->s_feature_compat || sb->s_feature_ro_compat || + sb->s_feature_incompat)) +diff --git a/misc/util.c b/misc/util.c +index 48e623d..d14305b 100644 +--- a/misc/util.c ++++ b/misc/util.c +@@ -44,6 +44,7 @@ + #include "e2p/e2p.h" + #include "ext2fs/ext2_fs.h" + #include "ext2fs/ext2fs.h" ++#include "ext2fs/ext2fsP.h" + #include "support/nls-enable.h" + #include "blkid/blkid.h" + #include "util.h" +@@ -270,6 +271,14 @@ void figure_journal_size(struct ext2fs_journal_params *jparams, + + if (requested_j_size > 0 || + (ext2fs_has_feature_fast_commit(fs->super) && requested_fc_size > 0)) { ++ int min_size; ++ ++ if (ext2fs_is_before_linux_ver(3, 10, 0) || ++ ext2fs_blocks_count(fs->super) <= 8192) ++ min_size = 1024; ++ else ++ min_size = 2048; ++ + if (requested_j_size > 0) + jparams->num_journal_blocks = + jsize_to_blks(fs, requested_j_size); +@@ -280,12 +289,12 @@ void figure_journal_size(struct ext2fs_journal_params *jparams, + else if (!ext2fs_has_feature_fast_commit(fs->super)) + jparams->num_fc_blocks = 0; + total_blocks = jparams->num_journal_blocks + jparams->num_fc_blocks; +- if (total_blocks < 1024 || total_blocks > 10240000) { ++ if (total_blocks < min_size || total_blocks > 10240000) { + fprintf(stderr, _("\nThe total requested journal " + "size is %d blocks; it must be\n" +- "between 1024 and 10240000 blocks. " ++ "between %d and 10240000 blocks. " + "Aborting.\n"), +- total_blocks); ++ total_blocks, min_size); + exit(1); + } + if ((unsigned int) total_blocks > ext2fs_free_blocks_count(fs->super) / 2) { +diff --git a/tests/d_print_acl/expect b/tests/d_print_acl/expect +new file mode 100644 +index 0000000..03dea43 +--- /dev/null ++++ b/tests/d_print_acl/expect +@@ -0,0 +1,13 @@ ++Extended attributes: ++ system.posix_acl_access: ++ user::rwx ++ group::r-x ++ group:42:r-x ++ mask::r-x ++ other::r-x ++ system.posix_acl_default: ++ user::rwx ++ group::r-x ++ group:4:r-x ++ mask::r-x ++ other::r-x +diff --git a/tests/d_print_acl/script b/tests/d_print_acl/script +new file mode 100644 +index 0000000..d5cbd62 +--- /dev/null ++++ b/tests/d_print_acl/script +@@ -0,0 +1,55 @@ ++test_description="decode and print Access Control Lists in debugfs" ++if ! test -x $DEBUGFS_EXE; then ++ echo "$test_name: $test_description: skipped (no debugfs)" ++ return 0 ++fi ++ ++if ! setfacl --help > /dev/null 2>&1 ; then ++ echo "$test_name: $test_description: skipped (no setfacl)" ++ return 0 ++fi ++ ++MKFS_DIR=$(mktemp -d ./$test_name-XXXXXX.tmp) ++OUT=$test_name.log ++EXP=$test_dir/expect ++ ++mkdir $MKFS_DIR/acl_dir ++ ++setfacl --restore=- < $OUT.new 2>&1 ++ ++$DEBUGFS -w -R "ea_list /acl_dir" $TMPFILE >> $OUT.new 2>&1 ++sed -f $cmd_dir/filter.sed $OUT.new > $OUT ++rm -rf $MKFS_DIR $TMPFILE $OUT.new ++ ++cmp -s $OUT $EXP ++status=$? ++ ++if [ "$status" = 0 ] ; then ++ echo "$test_name: $test_description: ok" ++ touch $test_name.ok ++else ++ echo "$test_name: $test_description: failed" ++ diff $DIFF_OPTS $EXP $OUT > $test_name.failed ++fi ++ ++unset MKFS_DIR OUT EXP +diff --git a/tests/d_trusted_fid/expect b/tests/d_trusted_fid/expect +new file mode 100644 +index 0000000..e601771 +--- /dev/null ++++ b/tests/d_trusted_fid/expect +@@ -0,0 +1,4 @@ ++Extended attributes: ++ fid: parent=[0x200000402:0xc:0x0] stripe=1 stripe_size=1048576 stripe_count=2 layout_version=0 range=0 ++Extended attributes: ++ fid: parent=[0x200000402:0x8:0x0] stripe=1 stripe_size=1048576 stripe_count=2 component_id=65537 component_start=0 component_end=18446744073709551615 layout_version=6 range=0 +diff --git a/tests/d_trusted_fid/image.gz b/tests/d_trusted_fid/image.gz +new file mode 100644 +index 0000000000000000000000000000000000000000..9447f6fcd363d128c35eeb5b4a64fe04f3b85b3e +GIT binary patch +literal 8361 +zcmeIzX;9Ni+5m7y)?;Lma$J!Skzo}W5ec9OiV#OsK*Vr}h+HBla)nDS1N?PRB66vK +zkuy7T8#E|K2uGqE0l5MO5W*2T!yQRNLPGNIW%uj*R_#{phpnxmtGYjRS3mu$ex64) +zamS9!r=H!Ek@X4i@V+gxG%EMZVLC?UJ7=t+d|``@sa@~jlT>Xj?vt{szx{RM$q`d? +z>st;JKkePAle%(hkLKQ_lLohM9-_<}1)rF&JbjX;q`^?^8!U04mGnJ-y}H{n_?PDw +z3p{n>W7($RoDcgVDsXiXLsID-7}IS+~w_Uee9r$TiR +zUWIQs{a0`LqdMjtyDK{Ci`TnL;5{ +zGpWj2=-?{Uhle^UV27ERmdVLop_6m`!8H$y11w};v9qFE*y`+%9MLJrX-CsU{bK5P52@wM`oO&2(JQJyot^irB#ikKK#e$io&%F=~JUM?{9;f0N9^)Dvj8Ng>nH@dEPY8V>WD_KvQ+g%_m +zW=jT5rO&MbDXU2ps!0E)MVukg`8`AbvHa5Ry!+w@0sUj!ONydl#FWtT@mv~ZMcnyQ +zVli*`E=my7Avoy%I4^=CnQooDd2yUq8`F&%P<36aU#tv3winyuqbcio)Ekb^Ww+E$ +zza3^#LR!`O#}et+mW26#xcila?*jh)@akD8{9fB$aoX<~&nENCdz5Wpk~#v9m}g>R +z8wkv-SCkTD|@qpHQ`sP=?3(@as6K6V;&qkAUN% +z?tIVo%fQd-T;xqlbhPNvz|6U+qQ7K0EQBO$IAg}DYgb;c2I8_}zdbpKeimEI6S+qj +zN=zTIG(?CrE9#`kJcHl${>I +zAyO6m=X<8WemqB?L@iAe`4Q>Gs`0oss8sT{I0%%^1;Lt8lWP*)(neIudsNaf12zBU +z88|mnE1K;tqyPk&ZQ^d9c6!-rPhIAgo_*?4fEx+zTlKK9(7!JTVJIOE59=F;&8Gg} +zoN{z=`?U<`VyxI|L2+3einJyF)t*a!xQpg$0`=CAdEQ;*`kegz{XUmmd)G#J?4-N_ +zqcE{F8Q%vnxs8dXeSM1t$EH&AC4P(Fuh`qEzie+#FkH4&xOA^6D>nR$>?dZTVRxqx +zXck8b5Jo@&3{Nv2biLh!W-WX^v|PrAf5>p)OHg({S=9dUfz-L4C+e>2A3^->!xbZT +z5%DiH!YCXOSS;YQlYo>>Y9Be9SqU5rW0s%*A@Dl>S&Hn;5g?F@z75x5s9f+Z0rYfv +zJurP!B0(BWwF9T^?_7Ak2`$5U?7-T!0%fyh5m@9&ta*82{8Ns0`LO@#=)2Cl3lZtS +zk$uRJ)F8p1u(+l*z7FKo2r&~&?wQ~dz5&CJTEv(=%%^iufTc)bJ$l~l +zq)&Rjo_#HYM=!=Csp-YjloUNVO7eQ~t%I60ik={GqaDy&)+&^?H!JO){HV0OWi2`> +z&QlVVglIN8OlwoZ(u}le<9aDiR$7#j^)9v;>C$n3M!gv{Y3?_ +zep=2Kk67qj&+oVlwb%cDsZ0BPWP +zd~Zbkolm#PrVsx3LnCYir%|0uN0ar9;p^4`zP*bttzOX2vJ`oX&I(k1P;J)w_i;@B +zWs^tt*P6vBJ6Os6jU=sG;8E=k8NWon@Eg;+T?DEkm!N-?%qYrYMg3bzT06o4r$S)u +zKV1Nd2P1pMBr9u(L)`eJ;^fx?>SBVa&u2QQB7|)Klo8g4Roxvol0=J8A`K+=#4>(V +zW*smkH&0k%+^ajk_hjQz665ma@L-M4jN?uY(W!OIv(gC_znC_X0xTRwy4aKRW#Fr- +zNj1xIL$s=?@rGACW#w~&FOSsjIDB#DkWNI)T49%EK~stfJHYZb?kF0eU52Yv(M}1z +zmE=9y|Lti_*AhdO%%5?l8?CQ2o$QQ_;??do=5*8$*oggx5pdZl94_>H{%Pydqx-2C +zIH#AfzxWE3x{@YFIlD#bWn^U?YsE@}(^)kAdPe%yghKt`iDZ*wokCkb@zBbj|Kx`l +zGpfkiNOEj>NEG@^sSv2qM6J~%peRO$n@gdXgbeq9x$$jthT(iygMN6_CODB0^Fscf +z<q944Zwc&%3)JMljMbQ7Nooyx^`d2=Rr^GxYhT-1r}k=K65TJE{=!3N0$4 +z#~93)bB0F9w+$-VU(vYFM4LWOOSclzZdjyn^Bs?V+auX-yDw4D5)S$${M +z=(I97JKp~*=1=@rFqjvDeP2+W0b2E#ats4P7J-Wi84Gp(KCemq$3iHLN0c7$hk&6^ +zQ(5ym^^mFK%(nI^DQmunBW2NJK?KMh1J;ypp68X)Z}jQ=E&u*a>ON?%&H?WZR!s1H +zNyzAUrY}e-F`@$prxhL&MP%l{lj6XLH8*MsUFh +zX9kKMV@!0H@mlZkXE{gi!`>FZ-gjMHCaF{7(AHL;30@{4Iq%K +zO2dd8B<7sDV9%_{g(b+$%rmwZ}^@Fdjx_+*lMKzlr>GZ+svKknFh9&%% +zn`RvSFfdq3{Vq}M5%Q)L(wKukMEC0N|81 +zu(Mp@K;8dN8{WKiQ(#lzKNJw>^NX%ZGSA1%j0{8NQ9ZN?vO%VS!RPWLNNA(ez9~;V +z>-Z&8Dfs%n5Yeee<3seV#$3DL $TMPFILE ++ ++$DEBUGFS -w -R "ea_list /plain" $TMPFILE >> $OUT.new 2>&1 ++$DEBUGFS -w -R "ea_list /pfl_flr" $TMPFILE >> $OUT.new 2>&1 ++sed -f $cmd_dir/filter.sed $OUT.new > $OUT ++rm -f $TMPFILE $OUT.new ++ ++cmp -s $OUT $EXP ++status=$? ++ ++if [ "$status" = 0 ] ; then ++ echo "$test_name: $test_description: ok" ++ touch $test_name.ok ++else ++ echo "$test_name: $test_description: failed" ++ diff $DIFF_OPTS $EXP $OUT > $test_name.failed ++fi ++ ++unset IMAGE EXP OUT +diff --git a/tests/d_trusted_link/expect b/tests/d_trusted_link/expect +new file mode 100644 +index 0000000..5c2bbda +--- /dev/null ++++ b/tests/d_trusted_link/expect +@@ -0,0 +1,12 @@ ++Extended attributes: ++ linkea: idx=0 parent=[0x200000007:0x1:0x0] name='file' ++ idx=1 parent=[0x240000404:0x1:0x0] name='file-link-1' ++ idx=2 parent=[0x240000404:0x1:0x0] name='file-link-2' ++ idx=3 parent=[0x240000404:0x1:0x0] name='file-link-3' ++ idx=4 parent=[0x240000404:0x1:0x0] name='file-link-4' ++ idx=5 parent=[0x240000404:0x1:0x0] name='file-link-5' ++ idx=6 parent=[0x240000404:0x1:0x0] name='file-link-6' ++ idx=7 parent=[0x240000404:0x1:0x0] name='file-link-7' ++ idx=8 parent=[0x240000404:0x1:0x0] name='file-link-8' ++ idx=9 parent=[0x240000404:0x1:0x0] name='file-link-9' ++ idx=10 parent=[0x240000404:0x1:0x0] name='file-link-10' +diff --git a/tests/d_trusted_link/image.gz b/tests/d_trusted_link/image.gz +new file mode 100644 +index 0000000000000000000000000000000000000000..b3b7e1ce67ff4b4177e581d5574f71625b4173eb +GIT binary patch +literal 10740 +zcmeI!ZB!Fi8USEcENBsEx2;wb*{&{}u8SX~K?DJ7TR2FOkAwh$BnS#P10uyyi3V+H +z#V)0+TEC_nJ~iZPGJH57i3z1ts8Udt%uEfEs0h@FC>1B_NRn;;^zg&ebNbudANSlp +z_nz}U?|a|#`c=%E7vOOybB^ndf~~pRUG9zKe!Xq`Cx>pq)o)Gwx7h7++Q#=Tub)^k +zXY(tZjjzAz_WEn}M{4h^nDg@Hg#XlTb6x+>#AEX|zj7_{6^>Q%#sZH4O)k#&x?0R2 +z3cWd;&wp%sptQ3a-Cb{bf~ozXZ!R6Ooe5gt)*vuF%5Bx(=v&gexbTj(tSfeP!J|h_ +zjvKqbofX!OfwIG7Onbqe0SH8%d|wo#KJe3c!&g5&6i#R5l;9_e9MmtZ +z0V5i7wpK0vq0YT#!-HEXktLU!N^i{S`VA@#Ura}OVQQC$~9$w$+kgSYCBP%WvOwhZh +zt-ro_j*H*`&1)c37%<6eBoG>~Il886_FSvE@8`Ssjum}$<*6SNpdaXu3L*bE8pn}A +zN4Ds@uBN)r?KAuG^6K(A+@I7+qB)M&CgwpZEvgf7bkB_a35 +z1Y>81gTp2?827;K3yV`C@~0D{^PfJpy3PvJUeczVwD@B0>st4y1|2tZCqyYa?H)NF +zY&Ysm?EQvn+9VR{I;{#FSi@|bO!rfHfpDxPKUOAr5v?<7TUZ;aoqBCD5lS7#8aq8 +zp$!8nlprZps8%m9%ZjNRq38fwNVHR*YMS)?MffEshR-w09}wH25`JO|kqkk6wpsar +z^rp(80)7ffdP3PFoONU%1dedqNng5wDH=)Ji;qC@Bk7Ovc*-uSU8X9hZZSK;lOmPT +zmS(2JR=*4lpe~CPrD^eG5S?#Rl=2&>b@Z@EU5%P?4?4@Hwot4`c?|74yADO>qU+=ZdrtV$6b4+=r!5MR%DJ_iHf)(qOCcf67#?mJR59Hy% +zRZ*c1H3|3QCM;fDYel??a-fshH7WFyyHel!q`Bi=^dOV!o8*Va8v-nB`flj?2zEK1 +zYbl2IiS=K}RvV5&9C5Rr6HTs#@_kc!$@x&0gcCr%4FTegElSjI7mAXk2@w=egZ7AZ +z`osxC2PBXP&8kBDC1|TyyGl`EIi@+UXPc2e>Y=7ytx{5yMygLSqkaZ&i&3Liqf4kB +zjeMs%ogy^IPBe^)rbjic_Z3=8wWj^Pvc_PeH-@Kr^jE4w7 +z1B`JIzQv%y1c-2n;V_n1knxQ{ilr3@(hVoE$+}A +zuu$HX(rhNVpMpBdZ%Gm|NnS(V!mshCHQ9e +zAyxQW^e@Z@;+BZy8uj~@AShMb7Lig;PFRjGn|#xv@kN$cXtyuBmneb`ND=~w80ce3 +zQX_H7a-P{N5#$=q&^W`BB{VG09YejVem6`OTs^}!o +z!`^P)z^`M_5g%obx(K-8gZ7~Ff$w0Mzd8o^AFT36-v+M03aNSrV1(6DbTQBa%X8Fe +z00AR8=z3rPR*tJn027Rkqc2f$SY{x{gZw*|7s#z3|B7u3OpYbr!SZz-CzWI1=b~60 +z##No53TP{@gDX!4F`kZ)u|R~UCFBsO<8=nhJi*x`RUoJ|YTD!lpw_52t-Zmxzjzfq +zE8>gBuySuVXIFlHSI+!CbB*dSu&+|q4BYc+>_L73X5d87?cybfB5Iq5&;9*=P4p#D72?Yj9cyw|+FYGi4Uef5T^d!xtWrXFHX)=8I%7n31q +z#t&f+TApnwI}=sNZ(jKXZC@3_%n|GwTQ(>% + +literal 0 +HcmV?d00001 + +diff --git a/tests/d_trusted_link/name b/tests/d_trusted_link/name +new file mode 100644 +index 0000000..d776f73 +--- /dev/null ++++ b/tests/d_trusted_link/name +@@ -0,0 +1 @@ ++decode and print trusted.link xattr in debugfs +diff --git a/tests/d_trusted_link/script b/tests/d_trusted_link/script +new file mode 100644 +index 0000000..0d93015 +--- /dev/null ++++ b/tests/d_trusted_link/script +@@ -0,0 +1,26 @@ ++if ! test -x $DEBUGFS_EXE; then ++ echo "$test_name: $test_description: skipped (no debugfs)" ++ return 0 ++fi ++ ++IMAGE=$test_dir/image.gz ++EXP=$test_dir/expect ++OUT=$test_name.log ++gunzip < $IMAGE > $TMPFILE ++ ++$DEBUGFS -w -R "ea_list /file" $TMPFILE >> $OUT.new 2>&1 ++sed -f $cmd_dir/filter.sed $OUT.new > $OUT ++rm -f $TMPFILE $OUT.new ++ ++cmp -s $OUT $EXP ++status=$? ++ ++if [ "$status" = 0 ] ; then ++ echo "$test_name: $test_description: ok" ++ touch $test_name.ok ++else ++ echo "$test_name: $test_description: failed" ++ diff $DIFF_OPTS $EXP $OUT > $test_name.failed ++fi ++ ++unset IMAGE EXP OUT +diff --git a/tests/d_xattr_edits/expect b/tests/d_xattr_edits/expect +index 6a4d912..b961946 100644 +--- a/tests/d_xattr_edits/expect ++++ b/tests/d_xattr_edits/expect +@@ -36,7 +36,7 @@ ea_set -f d_xattr_edits.tmp / user.file_based_xattr + Exit status is 0 + ea_list / + Extended attributes: +- user.file_based_xattr (108) ++ user.file_based_xattr (108) = "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567\n" + Exit status is 0 + ea_get / user.file_based_xattr + user.file_based_xattr (108) = "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567\n" +diff --git a/tests/f_bad_encryption/expect.1 b/tests/f_bad_encryption/expect.1 +index d743e66..7027095 100644 +--- a/tests/f_bad_encryption/expect.1 ++++ b/tests/f_bad_encryption/expect.1 +@@ -54,13 +54,13 @@ Encrypted entry '\M-ggCeM-/?M-^BM-{(M-^OM-9M-^QQAM-^N=M-c^Mo' in /edir (12) refe + Clear? yes + + Pass 3: Checking directory connectivity +-Unconnected directory inode 18 (/edir/???) ++Unconnected directory inode 18 (was in /edir) + Connect to /lost+found? yes + +-Unconnected directory inode 24 (/edir/???) ++Unconnected directory inode 24 (was in /edir) + Connect to /lost+found? yes + +-Unconnected directory inode 27 (/edir/???) ++Unconnected directory inode 27 (was in /edir) + Connect to /lost+found? yes + + Pass 4: Checking reference counts +diff --git a/tests/f_badroot/expect.1 b/tests/f_badroot/expect.1 +index f9d01e5..ff92426 100644 +--- a/tests/f_badroot/expect.1 ++++ b/tests/f_badroot/expect.1 +@@ -9,7 +9,7 @@ Entry '..' in <2>/<11> (11) has deleted/unused inode 2. Clear? yes + Pass 3: Checking directory connectivity + Root inode not allocated. Allocate? yes + +-Unconnected directory inode 11 (...) ++Unconnected directory inode 11 (was in /) + Connect to /lost+found? yes + + /lost+found not found. Create? yes +diff --git a/tests/f_badsymlinks/expect.1 b/tests/f_badsymlinks/expect.1 +index b28b57d..f300fca 100644 +--- a/tests/f_badsymlinks/expect.1 ++++ b/tests/f_badsymlinks/expect.1 +@@ -1,4 +1,8 @@ + Pass 1: Checking inodes, blocks, and sizes ++Inode 13 symlink missing NUL terminator. Fix? yes ++ ++Inode 14 symlink missing NUL terminator. Fix? yes ++ + Special (device/socket/fifo/symlink) file (inode 18) has immutable + or append-only flag set. Clear? yes + +@@ -19,12 +23,6 @@ Pass 2: Checking directory structure + Symlink /empty_link (inode #17) is invalid. + Clear? yes + +-Symlink /long_fastlink (inode #13) is invalid. +-Clear? yes +- +-Symlink /long_link (inode #14) is invalid. +-Clear? yes +- + Symlink /high_fastlink (inode #15) is invalid. + Clear? yes + +@@ -49,13 +47,13 @@ Clear? yes + Pass 3: Checking directory connectivity + Pass 4: Checking reference counts + Pass 5: Checking group summary information +-Free blocks count wrong for group #0 (1000, counted=1001). ++Free blocks count wrong for group #0 (999, counted=1000). + Fix? yes + +-Free blocks count wrong (1000, counted=1001). ++Free blocks count wrong (999, counted=1000). + Fix? yes + + + test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** +-test_filesys: 13/32 files (7.7% non-contiguous), 23/1024 blocks ++test_filesys: 15/32 files (6.7% non-contiguous), 24/1024 blocks + Exit status is 1 +diff --git a/tests/f_badsymlinks/expect.2 b/tests/f_badsymlinks/expect.2 +index 1499551..f361d8d 100644 +--- a/tests/f_badsymlinks/expect.2 ++++ b/tests/f_badsymlinks/expect.2 +@@ -3,5 +3,5 @@ Pass 2: Checking directory structure + Pass 3: Checking directory connectivity + Pass 4: Checking reference counts + Pass 5: Checking group summary information +-test_filesys: 13/32 files (0.0% non-contiguous), 23/1024 blocks ++test_filesys: 15/32 files (0.0% non-contiguous), 24/1024 blocks + Exit status is 0 +diff --git a/tests/f_badsymlinks2/expect.1 b/tests/f_badsymlinks2/expect.1 +index 939edce..3e059ea 100644 +--- a/tests/f_badsymlinks2/expect.1 ++++ b/tests/f_badsymlinks2/expect.1 +@@ -1,17 +1,21 @@ + Pass 1: Checking inodes, blocks, and sizes ++Inode 15 symlink missing NUL terminator. Fix? yes ++ ++Inode 19 symlink missing NUL terminator. Fix? yes ++ ++Inode 40 symlink missing NUL terminator. Fix? yes ++ ++Inode 44 symlink missing NUL terminator. Fix? yes ++ ++Inode 65 symlink missing NUL terminator. Fix? yes ++ + Pass 2: Checking directory structure + Symlink /default/empty (inode #13) is invalid. + Clear? yes + +-Symlink /default/fast_isize_too_small (inode #15) is invalid. +-Clear? yes +- + Symlink /default/fast_isize_too_large (inode #16) is invalid. + Clear? yes + +-Symlink /default/slow_isize_too_small (inode #19) is invalid. +-Clear? yes +- + Symlink /default/slow_isize_too_large (inode #20) is invalid. + Clear? yes + +@@ -45,15 +49,9 @@ Clear? yes + Symlink /extents/empty (inode #38) is invalid. + Clear? yes + +-Symlink /extents/fast_isize_too_small (inode #40) is invalid. +-Clear? yes +- + Symlink /extents/fast_isize_too_large (inode #41) is invalid. + Clear? yes + +-Symlink /extents/slow_isize_too_small (inode #44) is invalid. +-Clear? yes +- + Symlink /extents/slow_isize_too_large (inode #45) is invalid. + Clear? yes + +@@ -87,9 +85,6 @@ Clear? yes + Symlink /inline_data/empty (inode #63) is invalid. + Clear? yes + +-Symlink /inline_data/fast_isize_too_small (inode #65) is invalid. +-Clear? yes +- + Symlink /inline_data/fast_isize_too_large (inode #66) is invalid. + Clear? yes + +@@ -110,5 +105,5 @@ Pass 4: Checking reference counts + Pass 5: Checking group summary information + + test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** +-test_filesys: 36/80 files (0.0% non-contiguous), 31/150 blocks ++test_filesys: 41/80 files (0.0% non-contiguous), 33/150 blocks + Exit status is 1 +diff --git a/tests/f_badsymlinks2/expect.2 b/tests/f_badsymlinks2/expect.2 +index 3da98a8..dfd000a 100644 +--- a/tests/f_badsymlinks2/expect.2 ++++ b/tests/f_badsymlinks2/expect.2 +@@ -3,5 +3,5 @@ Pass 2: Checking directory structure + Pass 3: Checking directory connectivity + Pass 4: Checking reference counts + Pass 5: Checking group summary information +-test_filesys: 36/80 files (0.0% non-contiguous), 31/150 blocks ++test_filesys: 41/80 files (0.0% non-contiguous), 33/150 blocks + Exit status is 0 +diff --git a/tests/f_dir_optimize/expect.1 b/tests/f_dir_optimize/expect.1 +new file mode 100644 +index 0000000..4457fa7 +--- /dev/null ++++ b/tests/f_dir_optimize/expect.1 +@@ -0,0 +1,511 @@ ++ ++ 94 40755 (18) 0 0 4096 25-Aug-2012 06:09 fid:[0x5e:0xf6d09ca7:0x0] .. ++ 105 40755 (18) 0 0 36864 25-Aug-2012 06:09 fid:[0x200000400:0x1:0x0] . ++ 106 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2:0x0] file0 ++ 107 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3:0x0] file1 ++ 108 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4:0x0] file2 ++ 109 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5:0x0] file3 ++ 110 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6:0x0] file4 ++ 111 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7:0x0] file5 ++ 112 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8:0x0] file6 ++ 113 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9:0x0] file7 ++ 114 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa:0x0] file8 ++ 115 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb:0x0] file9 ++ 116 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc:0x0] file10 ++ 117 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd:0x0] file11 ++ 118 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe:0x0] file12 ++ 119 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf:0x0] file13 ++ 120 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10:0x0] file14 ++ 121 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11:0x0] file15 ++ 122 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12:0x0] file16 ++ 123 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13:0x0] file17 ++ 124 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14:0x0] file18 ++ 125 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15:0x0] file19 ++ 126 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16:0x0] file20 ++ 127 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17:0x0] file21 ++ 128 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18:0x0] file22 ++ 129 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19:0x0] file23 ++ 130 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a:0x0] file24 ++ 131 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b:0x0] file25 ++ 132 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c:0x0] file26 ++ 133 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d:0x0] file27 ++ 134 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e:0x0] file28 ++ 135 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f:0x0] file29 ++ 136 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x20:0x0] file30 ++ 137 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x21:0x0] file31 ++ 138 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x22:0x0] file32 ++ 139 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x23:0x0] file33 ++ 140 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x24:0x0] file34 ++ 141 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x25:0x0] file35 ++ 142 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x26:0x0] file36 ++ 143 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x27:0x0] file37 ++ 144 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x28:0x0] file38 ++ 145 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x29:0x0] file39 ++ 146 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2a:0x0] file40 ++ 147 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2b:0x0] file41 ++ 148 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2c:0x0] file42 ++ 149 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2d:0x0] file43 ++ 150 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2e:0x0] file44 ++ 151 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2f:0x0] file45 ++ 152 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x30:0x0] file46 ++ 153 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x31:0x0] file47 ++ 154 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x32:0x0] file48 ++ 155 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x33:0x0] file49 ++ 156 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x34:0x0] file50 ++ 157 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x35:0x0] file51 ++ 158 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x36:0x0] file52 ++ 159 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x37:0x0] file53 ++ 160 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x38:0x0] file54 ++ 161 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x39:0x0] file55 ++ 162 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3a:0x0] file56 ++ 163 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3b:0x0] file57 ++ 164 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3c:0x0] file58 ++ 165 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3d:0x0] file59 ++ 166 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3e:0x0] file60 ++ 167 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3f:0x0] file61 ++ 168 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x40:0x0] file62 ++ 169 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x41:0x0] file63 ++ 170 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x42:0x0] file64 ++ 171 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x43:0x0] file65 ++ 172 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x44:0x0] file66 ++ 173 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x45:0x0] file67 ++ 174 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x46:0x0] file68 ++ 175 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x47:0x0] file69 ++ 176 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x48:0x0] file70 ++ 177 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x49:0x0] file71 ++ 178 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4a:0x0] file72 ++ 179 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4b:0x0] file73 ++ 180 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4c:0x0] file74 ++ 181 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4d:0x0] file75 ++ 182 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4e:0x0] file76 ++ 183 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4f:0x0] file77 ++ 184 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x50:0x0] file78 ++ 185 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x51:0x0] file79 ++ 186 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x52:0x0] file80 ++ 187 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x53:0x0] file81 ++ 188 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x54:0x0] file82 ++ 189 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x55:0x0] file83 ++ 190 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x56:0x0] file84 ++ 191 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x57:0x0] file85 ++ 192 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x58:0x0] file86 ++ 193 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x59:0x0] file87 ++ 194 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5a:0x0] file88 ++ 195 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5b:0x0] file89 ++ 196 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5c:0x0] file90 ++ 197 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5d:0x0] file91 ++ 198 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5e:0x0] file92 ++ 199 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5f:0x0] file93 ++ 200 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x60:0x0] file94 ++ 201 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x61:0x0] file95 ++ 202 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x62:0x0] file96 ++ 203 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x63:0x0] file97 ++ 204 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x64:0x0] file98 ++ 205 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x65:0x0] file99 ++ 206 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x66:0x0] file100 ++ 207 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x67:0x0] file101 ++ 208 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x68:0x0] file102 ++ 209 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x69:0x0] file103 ++ 210 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6a:0x0] file104 ++ 211 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6b:0x0] file105 ++ 212 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6c:0x0] file106 ++ 213 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6d:0x0] file107 ++ 214 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6e:0x0] file108 ++ 215 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6f:0x0] file109 ++ 216 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x70:0x0] file110 ++ 217 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x71:0x0] file111 ++ 218 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x72:0x0] file112 ++ 219 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x73:0x0] file113 ++ 220 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x74:0x0] file114 ++ 221 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x75:0x0] file115 ++ 222 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x76:0x0] file116 ++ 223 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x77:0x0] file117 ++ 224 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x78:0x0] file118 ++ 225 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x79:0x0] file119 ++ 226 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7a:0x0] file120 ++ 227 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7b:0x0] file121 ++ 228 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7c:0x0] file122 ++ 229 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7d:0x0] file123 ++ 230 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7e:0x0] file124 ++ 231 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7f:0x0] file125 ++ 232 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x80:0x0] file126 ++ 233 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x81:0x0] file127 ++ 234 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x82:0x0] file128 ++ 235 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x83:0x0] file129 ++ 236 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x84:0x0] file130 ++ 237 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x85:0x0] file131 ++ 238 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x86:0x0] file132 ++ 239 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x87:0x0] file133 ++ 240 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x88:0x0] file134 ++ 241 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x89:0x0] file135 ++ 242 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8a:0x0] file136 ++ 243 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8b:0x0] file137 ++ 244 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8c:0x0] file138 ++ 245 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8d:0x0] file139 ++ 246 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8e:0x0] file140 ++ 247 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8f:0x0] file141 ++ 248 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x90:0x0] file142 ++ 249 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x91:0x0] file143 ++ 250 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x92:0x0] file144 ++ 251 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x93:0x0] file145 ++ 252 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x94:0x0] file146 ++ 253 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x95:0x0] file147 ++ 254 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x96:0x0] file148 ++ 255 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x97:0x0] file149 ++ 256 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x98:0x0] file150 ++ 257 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x99:0x0] file151 ++ 258 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9a:0x0] file152 ++ 259 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9b:0x0] file153 ++ 260 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9c:0x0] file154 ++ 261 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9d:0x0] file155 ++ 262 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9e:0x0] file156 ++ 263 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9f:0x0] file157 ++ 264 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa0:0x0] file158 ++ 265 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa1:0x0] file159 ++ 266 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa2:0x0] file160 ++ 267 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa3:0x0] file161 ++ 268 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa4:0x0] file162 ++ 269 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa5:0x0] file163 ++ 270 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa6:0x0] file164 ++ 271 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa7:0x0] file165 ++ 272 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa8:0x0] file166 ++ 273 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa9:0x0] file167 ++ 274 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xaa:0x0] file168 ++ 275 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xab:0x0] file169 ++ 276 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xac:0x0] file170 ++ 277 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xad:0x0] file171 ++ 278 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xae:0x0] file172 ++ 279 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xaf:0x0] file173 ++ 280 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb0:0x0] file174 ++ 281 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb1:0x0] file175 ++ 282 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb2:0x0] file176 ++ 283 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb3:0x0] file177 ++ 284 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb4:0x0] file178 ++ 285 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb5:0x0] file179 ++ 286 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb6:0x0] file180 ++ 287 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb7:0x0] file181 ++ 288 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb8:0x0] file182 ++ 289 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb9:0x0] file183 ++ 290 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xba:0x0] file184 ++ 291 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xbb:0x0] file185 ++ 292 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xbc:0x0] file186 ++ 293 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xbd:0x0] file187 ++ 294 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xbe:0x0] file188 ++ 295 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xbf:0x0] file189 ++ 296 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc0:0x0] file190 ++ 297 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc1:0x0] file191 ++ 298 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc2:0x0] file192 ++ 299 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc3:0x0] file193 ++ 300 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc4:0x0] file194 ++ 301 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc5:0x0] file195 ++ 302 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc6:0x0] file196 ++ 303 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc7:0x0] file197 ++ 304 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc8:0x0] file198 ++ 305 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc9:0x0] file199 ++ 306 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xca:0x0] file200 ++ 307 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xcb:0x0] file201 ++ 308 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xcc:0x0] file202 ++ 309 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xcd:0x0] file203 ++ 310 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xce:0x0] file204 ++ 311 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xcf:0x0] file205 ++ 312 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd0:0x0] file206 ++ 313 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd1:0x0] file207 ++ 314 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd2:0x0] file208 ++ 315 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd3:0x0] file209 ++ 316 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd4:0x0] file210 ++ 317 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd5:0x0] file211 ++ 318 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd6:0x0] file212 ++ 319 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd7:0x0] file213 ++ 320 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd8:0x0] file214 ++ 321 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd9:0x0] file215 ++ 322 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xda:0x0] file216 ++ 323 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xdb:0x0] file217 ++ 324 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xdc:0x0] file218 ++ 325 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xdd:0x0] file219 ++ 326 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xde:0x0] file220 ++ 327 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xdf:0x0] file221 ++ 328 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe0:0x0] file222 ++ 329 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe1:0x0] file223 ++ 330 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe2:0x0] file224 ++ 331 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe3:0x0] file225 ++ 332 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe4:0x0] file226 ++ 333 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe5:0x0] file227 ++ 334 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe6:0x0] file228 ++ 335 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe7:0x0] file229 ++ 336 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe8:0x0] file230 ++ 337 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe9:0x0] file231 ++ 338 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xea:0x0] file232 ++ 339 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xeb:0x0] file233 ++ 340 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xec:0x0] file234 ++ 341 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xed:0x0] file235 ++ 342 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xee:0x0] file236 ++ 343 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xef:0x0] file237 ++ 344 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf0:0x0] file238 ++ 345 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf1:0x0] file239 ++ 346 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf2:0x0] file240 ++ 347 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf3:0x0] file241 ++ 348 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf4:0x0] file242 ++ 349 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf5:0x0] file243 ++ 350 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf6:0x0] file244 ++ 351 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf7:0x0] file245 ++ 352 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf8:0x0] file246 ++ 353 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf9:0x0] file247 ++ 354 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xfa:0x0] file248 ++ 355 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xfb:0x0] file249 ++ 356 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xfc:0x0] file250 ++ 357 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xfd:0x0] file251 ++ 358 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xfe:0x0] file252 ++ 359 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xff:0x0] file253 ++ 360 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x100:0x0] file254 ++ 361 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x101:0x0] file255 ++ 362 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x102:0x0] file256 ++ 363 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x103:0x0] file257 ++ 364 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x104:0x0] file258 ++ 365 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x105:0x0] file259 ++ 366 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x106:0x0] file260 ++ 367 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x107:0x0] file261 ++ 368 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x108:0x0] file262 ++ 369 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x109:0x0] file263 ++ 370 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10a:0x0] file264 ++ 371 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10b:0x0] file265 ++ 372 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10c:0x0] file266 ++ 373 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10d:0x0] file267 ++ 374 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10e:0x0] file268 ++ 375 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10f:0x0] file269 ++ 376 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x110:0x0] file270 ++ 377 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x111:0x0] file271 ++ 378 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x112:0x0] file272 ++ 379 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x113:0x0] file273 ++ 380 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x114:0x0] file274 ++ 381 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x115:0x0] file275 ++ 382 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x116:0x0] file276 ++ 383 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x117:0x0] file277 ++ 384 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x118:0x0] file278 ++ 385 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x119:0x0] file279 ++ 386 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11a:0x0] file280 ++ 387 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11b:0x0] file281 ++ 388 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11c:0x0] file282 ++ 389 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11d:0x0] file283 ++ 390 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11e:0x0] file284 ++ 391 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11f:0x0] file285 ++ 392 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x120:0x0] file286 ++ 393 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x121:0x0] file287 ++ 394 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x122:0x0] file288 ++ 395 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x123:0x0] file289 ++ 396 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x124:0x0] file290 ++ 397 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x125:0x0] file291 ++ 398 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x126:0x0] file292 ++ 399 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x127:0x0] file293 ++ 400 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x128:0x0] file294 ++ 401 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x129:0x0] file295 ++ 402 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12a:0x0] file296 ++ 403 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12b:0x0] file297 ++ 404 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12c:0x0] file298 ++ 405 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12d:0x0] file299 ++ 406 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12e:0x0] file300 ++ 407 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12f:0x0] file301 ++ 408 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x130:0x0] file302 ++ 409 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x131:0x0] file303 ++ 410 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x132:0x0] file304 ++ 411 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x133:0x0] file305 ++ 412 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x134:0x0] file306 ++ 413 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x135:0x0] file307 ++ 414 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x136:0x0] file308 ++ 415 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x137:0x0] file309 ++ 416 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x138:0x0] file310 ++ 417 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x139:0x0] file311 ++ 418 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13a:0x0] file312 ++ 419 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13b:0x0] file313 ++ 420 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13c:0x0] file314 ++ 421 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13d:0x0] file315 ++ 422 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13e:0x0] file316 ++ 423 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13f:0x0] file317 ++ 424 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x140:0x0] file318 ++ 425 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x141:0x0] file319 ++ 426 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x142:0x0] file320 ++ 427 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x143:0x0] file321 ++ 428 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x144:0x0] file322 ++ 429 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x145:0x0] file323 ++ 430 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x146:0x0] file324 ++ 431 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x147:0x0] file325 ++ 432 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x148:0x0] file326 ++ 433 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x149:0x0] file327 ++ 434 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14a:0x0] file328 ++ 435 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14b:0x0] file329 ++ 436 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14c:0x0] file330 ++ 437 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14d:0x0] file331 ++ 438 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14e:0x0] file332 ++ 439 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14f:0x0] file333 ++ 440 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x150:0x0] file334 ++ 441 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x151:0x0] file335 ++ 442 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x152:0x0] file336 ++ 443 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x153:0x0] file337 ++ 444 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x154:0x0] file338 ++ 445 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x155:0x0] file339 ++ 446 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x156:0x0] file340 ++ 447 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x157:0x0] file341 ++ 448 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x158:0x0] file342 ++ 449 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x159:0x0] file343 ++ 450 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15a:0x0] file344 ++ 451 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15b:0x0] file345 ++ 452 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15c:0x0] file346 ++ 453 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15d:0x0] file347 ++ 454 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15e:0x0] file348 ++ 455 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15f:0x0] file349 ++ 456 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x160:0x0] file350 ++ 457 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x161:0x0] file351 ++ 458 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x162:0x0] file352 ++ 459 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x163:0x0] file353 ++ 460 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x164:0x0] file354 ++ 461 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x165:0x0] file355 ++ 462 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x166:0x0] file356 ++ 463 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x167:0x0] file357 ++ 464 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x168:0x0] file358 ++ 465 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x169:0x0] file359 ++ 466 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16a:0x0] file360 ++ 467 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16b:0x0] file361 ++ 468 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16c:0x0] file362 ++ 469 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16d:0x0] file363 ++ 470 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16e:0x0] file364 ++ 471 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16f:0x0] file365 ++ 472 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x170:0x0] file366 ++ 473 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x171:0x0] file367 ++ 474 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x172:0x0] file368 ++ 475 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x173:0x0] file369 ++ 476 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x174:0x0] file370 ++ 477 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x175:0x0] file371 ++ 478 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x176:0x0] file372 ++ 479 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x177:0x0] file373 ++ 480 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x178:0x0] file374 ++ 481 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x179:0x0] file375 ++ 482 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17a:0x0] file376 ++ 483 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17b:0x0] file377 ++ 484 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17c:0x0] file378 ++ 485 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17d:0x0] file379 ++ 486 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17e:0x0] file380 ++ 487 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17f:0x0] file381 ++ 488 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x180:0x0] file382 ++ 489 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x181:0x0] file383 ++ 490 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x182:0x0] file384 ++ 491 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x183:0x0] file385 ++ 492 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x184:0x0] file386 ++ 493 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x185:0x0] file387 ++ 494 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x186:0x0] file388 ++ 495 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x187:0x0] file389 ++ 496 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x188:0x0] file390 ++ 497 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x189:0x0] file391 ++ 498 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18a:0x0] file392 ++ 499 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18b:0x0] file393 ++ 500 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18c:0x0] file394 ++ 501 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18d:0x0] file395 ++ 502 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18e:0x0] file396 ++ 503 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18f:0x0] file397 ++ 504 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x190:0x0] file398 ++ 505 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x191:0x0] file399 ++ 506 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x192:0x0] file400 ++ 507 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x193:0x0] file401 ++ 508 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x194:0x0] file402 ++ 509 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x195:0x0] file403 ++ 510 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x196:0x0] file404 ++ 511 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x197:0x0] file405 ++ 512 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x198:0x0] file406 ++ 513 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x199:0x0] file407 ++ 514 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19a:0x0] file408 ++ 515 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19b:0x0] file409 ++ 516 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19c:0x0] file410 ++ 517 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19d:0x0] file411 ++ 518 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19e:0x0] file412 ++ 519 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19f:0x0] file413 ++ 520 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a0:0x0] file414 ++ 521 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a1:0x0] file415 ++ 522 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a2:0x0] file416 ++ 523 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a3:0x0] file417 ++ 524 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a4:0x0] file418 ++ 525 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a5:0x0] file419 ++ 526 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a6:0x0] file420 ++ 527 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a7:0x0] file421 ++ 528 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a8:0x0] file422 ++ 529 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a9:0x0] file423 ++ 530 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1aa:0x0] file424 ++ 531 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ab:0x0] file425 ++ 532 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ac:0x0] file426 ++ 533 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ad:0x0] file427 ++ 534 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ae:0x0] file428 ++ 535 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1af:0x0] file429 ++ 536 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b0:0x0] file430 ++ 537 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b1:0x0] file431 ++ 538 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b2:0x0] file432 ++ 539 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b3:0x0] file433 ++ 540 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b4:0x0] file434 ++ 541 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b5:0x0] file435 ++ 542 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b6:0x0] file436 ++ 543 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b7:0x0] file437 ++ 544 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b8:0x0] file438 ++ 545 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b9:0x0] file439 ++ 546 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ba:0x0] file440 ++ 547 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1bb:0x0] file441 ++ 548 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1bc:0x0] file442 ++ 549 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1bd:0x0] file443 ++ 550 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1be:0x0] file444 ++ 551 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1bf:0x0] file445 ++ 552 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c0:0x0] file446 ++ 553 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c1:0x0] file447 ++ 554 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c2:0x0] file448 ++ 555 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c3:0x0] file449 ++ 556 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c4:0x0] file450 ++ 557 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c5:0x0] file451 ++ 558 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c6:0x0] file452 ++ 559 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c7:0x0] file453 ++ 560 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c8:0x0] file454 ++ 561 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c9:0x0] file455 ++ 562 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ca:0x0] file456 ++ 563 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1cb:0x0] file457 ++ 564 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1cc:0x0] file458 ++ 565 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1cd:0x0] file459 ++ 566 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ce:0x0] file460 ++ 567 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1cf:0x0] file461 ++ 568 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d0:0x0] file462 ++ 569 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d1:0x0] file463 ++ 570 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d2:0x0] file464 ++ 571 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d3:0x0] file465 ++ 572 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d4:0x0] file466 ++ 573 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d5:0x0] file467 ++ 574 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d6:0x0] file468 ++ 575 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d7:0x0] file469 ++ 576 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d8:0x0] file470 ++ 577 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d9:0x0] file471 ++ 578 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1da:0x0] file472 ++ 579 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1db:0x0] file473 ++ 580 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1dc:0x0] file474 ++ 581 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1dd:0x0] file475 ++ 582 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1de:0x0] file476 ++ 583 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1df:0x0] file477 ++ 584 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e0:0x0] file478 ++ 585 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e1:0x0] file479 ++ 586 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e2:0x0] file480 ++ 587 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e3:0x0] file481 ++ 588 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e4:0x0] file482 ++ 589 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e5:0x0] file483 ++ 590 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e6:0x0] file484 ++ 591 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e7:0x0] file485 ++ 592 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e8:0x0] file486 ++ 593 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e9:0x0] file487 ++ 594 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ea:0x0] file488 ++ 595 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1eb:0x0] file489 ++ 596 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ec:0x0] file490 ++ 597 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ed:0x0] file491 ++ 598 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ee:0x0] file492 ++ 599 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ef:0x0] file493 ++ 600 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f0:0x0] file494 ++ 601 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f1:0x0] file495 ++ 602 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f2:0x0] file496 ++ 603 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f3:0x0] file497 ++ 604 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f4:0x0] file498 ++ 605 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f5:0x0] file499 ++ 606 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f6:0x0] file500 ++ 607 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f7:0x0] file501 ++ 608 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f8:0x0] file502 ++ 609 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f9:0x0] file503 ++ 610 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1fa:0x0] file504 ++ 611 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1fb:0x0] file505 ++ 612 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1fc:0x0] file506 ++ 613 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1fd:0x0] file507 +diff --git a/tests/f_dir_optimize/expect.2 b/tests/f_dir_optimize/expect.2 +new file mode 100644 +index 0000000..3649a36 +--- /dev/null ++++ b/tests/f_dir_optimize/expect.2 +@@ -0,0 +1,511 @@ ++ ++ 94 40755 (18) 0 0 4096 25-Aug-2012 06:09 fid:[0x5e:0xf6d09ca7:0x0] .. ++ 105 40755 (18) 0 0 28672 25-Aug-2012 06:09 fid:[0x200000400:0x1:0x0] . ++ 106 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2:0x0] file0 ++ 107 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3:0x0] file1 ++ 108 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4:0x0] file2 ++ 109 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5:0x0] file3 ++ 110 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6:0x0] file4 ++ 111 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7:0x0] file5 ++ 112 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8:0x0] file6 ++ 113 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9:0x0] file7 ++ 114 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa:0x0] file8 ++ 115 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb:0x0] file9 ++ 116 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc:0x0] file10 ++ 117 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd:0x0] file11 ++ 118 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe:0x0] file12 ++ 119 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf:0x0] file13 ++ 120 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10:0x0] file14 ++ 121 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11:0x0] file15 ++ 122 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12:0x0] file16 ++ 123 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13:0x0] file17 ++ 124 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14:0x0] file18 ++ 125 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15:0x0] file19 ++ 126 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16:0x0] file20 ++ 127 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17:0x0] file21 ++ 128 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18:0x0] file22 ++ 129 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19:0x0] file23 ++ 130 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a:0x0] file24 ++ 131 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b:0x0] file25 ++ 132 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c:0x0] file26 ++ 133 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d:0x0] file27 ++ 134 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e:0x0] file28 ++ 135 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f:0x0] file29 ++ 136 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x20:0x0] file30 ++ 137 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x21:0x0] file31 ++ 138 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x22:0x0] file32 ++ 139 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x23:0x0] file33 ++ 140 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x24:0x0] file34 ++ 141 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x25:0x0] file35 ++ 142 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x26:0x0] file36 ++ 143 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x27:0x0] file37 ++ 144 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x28:0x0] file38 ++ 145 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x29:0x0] file39 ++ 146 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2a:0x0] file40 ++ 147 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2b:0x0] file41 ++ 148 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2c:0x0] file42 ++ 149 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2d:0x0] file43 ++ 150 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2e:0x0] file44 ++ 151 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x2f:0x0] file45 ++ 152 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x30:0x0] file46 ++ 153 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x31:0x0] file47 ++ 154 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x32:0x0] file48 ++ 155 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x33:0x0] file49 ++ 156 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x34:0x0] file50 ++ 157 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x35:0x0] file51 ++ 158 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x36:0x0] file52 ++ 159 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x37:0x0] file53 ++ 160 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x38:0x0] file54 ++ 161 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x39:0x0] file55 ++ 162 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3a:0x0] file56 ++ 163 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3b:0x0] file57 ++ 164 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3c:0x0] file58 ++ 165 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3d:0x0] file59 ++ 166 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3e:0x0] file60 ++ 167 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x3f:0x0] file61 ++ 168 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x40:0x0] file62 ++ 169 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x41:0x0] file63 ++ 170 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x42:0x0] file64 ++ 171 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x43:0x0] file65 ++ 172 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x44:0x0] file66 ++ 173 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x45:0x0] file67 ++ 174 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x46:0x0] file68 ++ 175 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x47:0x0] file69 ++ 176 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x48:0x0] file70 ++ 177 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x49:0x0] file71 ++ 178 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4a:0x0] file72 ++ 179 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4b:0x0] file73 ++ 180 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4c:0x0] file74 ++ 181 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4d:0x0] file75 ++ 182 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4e:0x0] file76 ++ 183 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x4f:0x0] file77 ++ 184 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x50:0x0] file78 ++ 185 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x51:0x0] file79 ++ 186 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x52:0x0] file80 ++ 187 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x53:0x0] file81 ++ 188 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x54:0x0] file82 ++ 189 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x55:0x0] file83 ++ 190 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x56:0x0] file84 ++ 191 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x57:0x0] file85 ++ 192 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x58:0x0] file86 ++ 193 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x59:0x0] file87 ++ 194 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5a:0x0] file88 ++ 195 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5b:0x0] file89 ++ 196 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5c:0x0] file90 ++ 197 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5d:0x0] file91 ++ 198 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5e:0x0] file92 ++ 199 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x5f:0x0] file93 ++ 200 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x60:0x0] file94 ++ 201 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x61:0x0] file95 ++ 202 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x62:0x0] file96 ++ 203 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x63:0x0] file97 ++ 204 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x64:0x0] file98 ++ 205 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x65:0x0] file99 ++ 206 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x66:0x0] file100 ++ 207 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x67:0x0] file101 ++ 208 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x68:0x0] file102 ++ 209 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x69:0x0] file103 ++ 210 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6a:0x0] file104 ++ 211 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6b:0x0] file105 ++ 212 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6c:0x0] file106 ++ 213 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6d:0x0] file107 ++ 214 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6e:0x0] file108 ++ 215 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x6f:0x0] file109 ++ 216 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x70:0x0] file110 ++ 217 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x71:0x0] file111 ++ 218 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x72:0x0] file112 ++ 219 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x73:0x0] file113 ++ 220 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x74:0x0] file114 ++ 221 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x75:0x0] file115 ++ 222 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x76:0x0] file116 ++ 223 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x77:0x0] file117 ++ 224 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x78:0x0] file118 ++ 225 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x79:0x0] file119 ++ 226 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7a:0x0] file120 ++ 227 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7b:0x0] file121 ++ 228 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7c:0x0] file122 ++ 229 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7d:0x0] file123 ++ 230 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7e:0x0] file124 ++ 231 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x7f:0x0] file125 ++ 232 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x80:0x0] file126 ++ 233 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x81:0x0] file127 ++ 234 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x82:0x0] file128 ++ 235 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x83:0x0] file129 ++ 236 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x84:0x0] file130 ++ 237 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x85:0x0] file131 ++ 238 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x86:0x0] file132 ++ 239 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x87:0x0] file133 ++ 240 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x88:0x0] file134 ++ 241 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x89:0x0] file135 ++ 242 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8a:0x0] file136 ++ 243 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8b:0x0] file137 ++ 244 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8c:0x0] file138 ++ 245 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8d:0x0] file139 ++ 246 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8e:0x0] file140 ++ 247 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x8f:0x0] file141 ++ 248 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x90:0x0] file142 ++ 249 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x91:0x0] file143 ++ 250 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x92:0x0] file144 ++ 251 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x93:0x0] file145 ++ 252 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x94:0x0] file146 ++ 253 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x95:0x0] file147 ++ 254 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x96:0x0] file148 ++ 255 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x97:0x0] file149 ++ 256 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x98:0x0] file150 ++ 257 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x99:0x0] file151 ++ 258 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9a:0x0] file152 ++ 259 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9b:0x0] file153 ++ 260 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9c:0x0] file154 ++ 261 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9d:0x0] file155 ++ 262 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9e:0x0] file156 ++ 263 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x9f:0x0] file157 ++ 264 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa0:0x0] file158 ++ 265 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa1:0x0] file159 ++ 266 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa2:0x0] file160 ++ 267 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa3:0x0] file161 ++ 268 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa4:0x0] file162 ++ 269 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa5:0x0] file163 ++ 270 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa6:0x0] file164 ++ 271 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa7:0x0] file165 ++ 272 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa8:0x0] file166 ++ 273 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xa9:0x0] file167 ++ 274 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xaa:0x0] file168 ++ 275 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xab:0x0] file169 ++ 276 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xac:0x0] file170 ++ 277 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xad:0x0] file171 ++ 278 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xae:0x0] file172 ++ 279 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xaf:0x0] file173 ++ 280 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb0:0x0] file174 ++ 281 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb1:0x0] file175 ++ 282 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb2:0x0] file176 ++ 283 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb3:0x0] file177 ++ 284 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb4:0x0] file178 ++ 285 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb5:0x0] file179 ++ 286 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb6:0x0] file180 ++ 287 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb7:0x0] file181 ++ 288 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb8:0x0] file182 ++ 289 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xb9:0x0] file183 ++ 290 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xba:0x0] file184 ++ 291 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xbb:0x0] file185 ++ 292 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xbc:0x0] file186 ++ 293 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xbd:0x0] file187 ++ 294 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xbe:0x0] file188 ++ 295 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xbf:0x0] file189 ++ 296 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc0:0x0] file190 ++ 297 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc1:0x0] file191 ++ 298 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc2:0x0] file192 ++ 299 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc3:0x0] file193 ++ 300 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc4:0x0] file194 ++ 301 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc5:0x0] file195 ++ 302 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc6:0x0] file196 ++ 303 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc7:0x0] file197 ++ 304 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc8:0x0] file198 ++ 305 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xc9:0x0] file199 ++ 306 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xca:0x0] file200 ++ 307 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xcb:0x0] file201 ++ 308 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xcc:0x0] file202 ++ 309 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xcd:0x0] file203 ++ 310 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xce:0x0] file204 ++ 311 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xcf:0x0] file205 ++ 312 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd0:0x0] file206 ++ 313 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd1:0x0] file207 ++ 314 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd2:0x0] file208 ++ 315 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd3:0x0] file209 ++ 316 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd4:0x0] file210 ++ 317 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd5:0x0] file211 ++ 318 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd6:0x0] file212 ++ 319 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd7:0x0] file213 ++ 320 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd8:0x0] file214 ++ 321 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xd9:0x0] file215 ++ 322 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xda:0x0] file216 ++ 323 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xdb:0x0] file217 ++ 324 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xdc:0x0] file218 ++ 325 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xdd:0x0] file219 ++ 326 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xde:0x0] file220 ++ 327 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xdf:0x0] file221 ++ 328 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe0:0x0] file222 ++ 329 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe1:0x0] file223 ++ 330 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe2:0x0] file224 ++ 331 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe3:0x0] file225 ++ 332 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe4:0x0] file226 ++ 333 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe5:0x0] file227 ++ 334 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe6:0x0] file228 ++ 335 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe7:0x0] file229 ++ 336 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe8:0x0] file230 ++ 337 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xe9:0x0] file231 ++ 338 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xea:0x0] file232 ++ 339 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xeb:0x0] file233 ++ 340 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xec:0x0] file234 ++ 341 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xed:0x0] file235 ++ 342 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xee:0x0] file236 ++ 343 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xef:0x0] file237 ++ 344 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf0:0x0] file238 ++ 345 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf1:0x0] file239 ++ 346 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf2:0x0] file240 ++ 347 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf3:0x0] file241 ++ 348 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf4:0x0] file242 ++ 349 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf5:0x0] file243 ++ 350 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf6:0x0] file244 ++ 351 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf7:0x0] file245 ++ 352 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf8:0x0] file246 ++ 353 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xf9:0x0] file247 ++ 354 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xfa:0x0] file248 ++ 355 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xfb:0x0] file249 ++ 356 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xfc:0x0] file250 ++ 357 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xfd:0x0] file251 ++ 358 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xfe:0x0] file252 ++ 359 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0xff:0x0] file253 ++ 360 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x100:0x0] file254 ++ 361 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x101:0x0] file255 ++ 362 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x102:0x0] file256 ++ 363 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x103:0x0] file257 ++ 364 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x104:0x0] file258 ++ 365 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x105:0x0] file259 ++ 366 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x106:0x0] file260 ++ 367 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x107:0x0] file261 ++ 368 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x108:0x0] file262 ++ 369 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x109:0x0] file263 ++ 370 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10a:0x0] file264 ++ 371 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10b:0x0] file265 ++ 372 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10c:0x0] file266 ++ 373 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10d:0x0] file267 ++ 374 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10e:0x0] file268 ++ 375 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x10f:0x0] file269 ++ 376 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x110:0x0] file270 ++ 377 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x111:0x0] file271 ++ 378 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x112:0x0] file272 ++ 379 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x113:0x0] file273 ++ 380 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x114:0x0] file274 ++ 381 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x115:0x0] file275 ++ 382 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x116:0x0] file276 ++ 383 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x117:0x0] file277 ++ 384 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x118:0x0] file278 ++ 385 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x119:0x0] file279 ++ 386 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11a:0x0] file280 ++ 387 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11b:0x0] file281 ++ 388 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11c:0x0] file282 ++ 389 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11d:0x0] file283 ++ 390 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11e:0x0] file284 ++ 391 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x11f:0x0] file285 ++ 392 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x120:0x0] file286 ++ 393 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x121:0x0] file287 ++ 394 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x122:0x0] file288 ++ 395 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x123:0x0] file289 ++ 396 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x124:0x0] file290 ++ 397 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x125:0x0] file291 ++ 398 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x126:0x0] file292 ++ 399 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x127:0x0] file293 ++ 400 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x128:0x0] file294 ++ 401 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x129:0x0] file295 ++ 402 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12a:0x0] file296 ++ 403 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12b:0x0] file297 ++ 404 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12c:0x0] file298 ++ 405 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12d:0x0] file299 ++ 406 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12e:0x0] file300 ++ 407 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x12f:0x0] file301 ++ 408 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x130:0x0] file302 ++ 409 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x131:0x0] file303 ++ 410 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x132:0x0] file304 ++ 411 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x133:0x0] file305 ++ 412 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x134:0x0] file306 ++ 413 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x135:0x0] file307 ++ 414 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x136:0x0] file308 ++ 415 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x137:0x0] file309 ++ 416 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x138:0x0] file310 ++ 417 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x139:0x0] file311 ++ 418 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13a:0x0] file312 ++ 419 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13b:0x0] file313 ++ 420 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13c:0x0] file314 ++ 421 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13d:0x0] file315 ++ 422 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13e:0x0] file316 ++ 423 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x13f:0x0] file317 ++ 424 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x140:0x0] file318 ++ 425 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x141:0x0] file319 ++ 426 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x142:0x0] file320 ++ 427 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x143:0x0] file321 ++ 428 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x144:0x0] file322 ++ 429 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x145:0x0] file323 ++ 430 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x146:0x0] file324 ++ 431 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x147:0x0] file325 ++ 432 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x148:0x0] file326 ++ 433 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x149:0x0] file327 ++ 434 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14a:0x0] file328 ++ 435 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14b:0x0] file329 ++ 436 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14c:0x0] file330 ++ 437 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14d:0x0] file331 ++ 438 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14e:0x0] file332 ++ 439 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x14f:0x0] file333 ++ 440 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x150:0x0] file334 ++ 441 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x151:0x0] file335 ++ 442 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x152:0x0] file336 ++ 443 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x153:0x0] file337 ++ 444 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x154:0x0] file338 ++ 445 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x155:0x0] file339 ++ 446 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x156:0x0] file340 ++ 447 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x157:0x0] file341 ++ 448 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x158:0x0] file342 ++ 449 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x159:0x0] file343 ++ 450 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15a:0x0] file344 ++ 451 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15b:0x0] file345 ++ 452 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15c:0x0] file346 ++ 453 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15d:0x0] file347 ++ 454 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15e:0x0] file348 ++ 455 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x15f:0x0] file349 ++ 456 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x160:0x0] file350 ++ 457 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x161:0x0] file351 ++ 458 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x162:0x0] file352 ++ 459 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x163:0x0] file353 ++ 460 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x164:0x0] file354 ++ 461 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x165:0x0] file355 ++ 462 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x166:0x0] file356 ++ 463 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x167:0x0] file357 ++ 464 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x168:0x0] file358 ++ 465 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x169:0x0] file359 ++ 466 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16a:0x0] file360 ++ 467 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16b:0x0] file361 ++ 468 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16c:0x0] file362 ++ 469 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16d:0x0] file363 ++ 470 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16e:0x0] file364 ++ 471 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x16f:0x0] file365 ++ 472 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x170:0x0] file366 ++ 473 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x171:0x0] file367 ++ 474 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x172:0x0] file368 ++ 475 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x173:0x0] file369 ++ 476 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x174:0x0] file370 ++ 477 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x175:0x0] file371 ++ 478 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x176:0x0] file372 ++ 479 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x177:0x0] file373 ++ 480 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x178:0x0] file374 ++ 481 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x179:0x0] file375 ++ 482 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17a:0x0] file376 ++ 483 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17b:0x0] file377 ++ 484 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17c:0x0] file378 ++ 485 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17d:0x0] file379 ++ 486 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17e:0x0] file380 ++ 487 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x17f:0x0] file381 ++ 488 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x180:0x0] file382 ++ 489 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x181:0x0] file383 ++ 490 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x182:0x0] file384 ++ 491 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x183:0x0] file385 ++ 492 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x184:0x0] file386 ++ 493 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x185:0x0] file387 ++ 494 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x186:0x0] file388 ++ 495 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x187:0x0] file389 ++ 496 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x188:0x0] file390 ++ 497 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x189:0x0] file391 ++ 498 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18a:0x0] file392 ++ 499 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18b:0x0] file393 ++ 500 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18c:0x0] file394 ++ 501 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18d:0x0] file395 ++ 502 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18e:0x0] file396 ++ 503 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x18f:0x0] file397 ++ 504 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x190:0x0] file398 ++ 505 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x191:0x0] file399 ++ 506 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x192:0x0] file400 ++ 507 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x193:0x0] file401 ++ 508 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x194:0x0] file402 ++ 509 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x195:0x0] file403 ++ 510 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x196:0x0] file404 ++ 511 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x197:0x0] file405 ++ 512 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x198:0x0] file406 ++ 513 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x199:0x0] file407 ++ 514 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19a:0x0] file408 ++ 515 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19b:0x0] file409 ++ 516 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19c:0x0] file410 ++ 517 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19d:0x0] file411 ++ 518 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19e:0x0] file412 ++ 519 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x19f:0x0] file413 ++ 520 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a0:0x0] file414 ++ 521 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a1:0x0] file415 ++ 522 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a2:0x0] file416 ++ 523 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a3:0x0] file417 ++ 524 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a4:0x0] file418 ++ 525 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a5:0x0] file419 ++ 526 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a6:0x0] file420 ++ 527 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a7:0x0] file421 ++ 528 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a8:0x0] file422 ++ 529 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1a9:0x0] file423 ++ 530 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1aa:0x0] file424 ++ 531 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ab:0x0] file425 ++ 532 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ac:0x0] file426 ++ 533 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ad:0x0] file427 ++ 534 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ae:0x0] file428 ++ 535 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1af:0x0] file429 ++ 536 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b0:0x0] file430 ++ 537 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b1:0x0] file431 ++ 538 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b2:0x0] file432 ++ 539 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b3:0x0] file433 ++ 540 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b4:0x0] file434 ++ 541 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b5:0x0] file435 ++ 542 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b6:0x0] file436 ++ 543 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b7:0x0] file437 ++ 544 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b8:0x0] file438 ++ 545 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1b9:0x0] file439 ++ 546 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ba:0x0] file440 ++ 547 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1bb:0x0] file441 ++ 548 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1bc:0x0] file442 ++ 549 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1bd:0x0] file443 ++ 550 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1be:0x0] file444 ++ 551 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1bf:0x0] file445 ++ 552 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c0:0x0] file446 ++ 553 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c1:0x0] file447 ++ 554 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c2:0x0] file448 ++ 555 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c3:0x0] file449 ++ 556 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c4:0x0] file450 ++ 557 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c5:0x0] file451 ++ 558 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c6:0x0] file452 ++ 559 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c7:0x0] file453 ++ 560 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c8:0x0] file454 ++ 561 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1c9:0x0] file455 ++ 562 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ca:0x0] file456 ++ 563 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1cb:0x0] file457 ++ 564 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1cc:0x0] file458 ++ 565 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1cd:0x0] file459 ++ 566 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ce:0x0] file460 ++ 567 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1cf:0x0] file461 ++ 568 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d0:0x0] file462 ++ 569 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d1:0x0] file463 ++ 570 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d2:0x0] file464 ++ 571 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d3:0x0] file465 ++ 572 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d4:0x0] file466 ++ 573 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d5:0x0] file467 ++ 574 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d6:0x0] file468 ++ 575 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d7:0x0] file469 ++ 576 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d8:0x0] file470 ++ 577 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1d9:0x0] file471 ++ 578 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1da:0x0] file472 ++ 579 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1db:0x0] file473 ++ 580 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1dc:0x0] file474 ++ 581 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1dd:0x0] file475 ++ 582 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1de:0x0] file476 ++ 583 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1df:0x0] file477 ++ 584 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e0:0x0] file478 ++ 585 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e1:0x0] file479 ++ 586 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e2:0x0] file480 ++ 587 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e3:0x0] file481 ++ 588 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e4:0x0] file482 ++ 589 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e5:0x0] file483 ++ 590 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e6:0x0] file484 ++ 591 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e7:0x0] file485 ++ 592 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e8:0x0] file486 ++ 593 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1e9:0x0] file487 ++ 594 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ea:0x0] file488 ++ 595 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1eb:0x0] file489 ++ 596 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ec:0x0] file490 ++ 597 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ed:0x0] file491 ++ 598 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ee:0x0] file492 ++ 599 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1ef:0x0] file493 ++ 600 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f0:0x0] file494 ++ 601 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f1:0x0] file495 ++ 602 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f2:0x0] file496 ++ 603 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f3:0x0] file497 ++ 604 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f4:0x0] file498 ++ 605 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f5:0x0] file499 ++ 606 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f6:0x0] file500 ++ 607 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f7:0x0] file501 ++ 608 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f8:0x0] file502 ++ 609 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1f9:0x0] file503 ++ 610 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1fa:0x0] file504 ++ 611 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1fb:0x0] file505 ++ 612 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1fc:0x0] file506 ++ 613 100644 (17) 0 0 0 25-Aug-2012 06:09 fid:[0x200000400:0x1fd:0x0] file507 +diff --git a/tests/f_dir_optimize/image.gz b/tests/f_dir_optimize/image.gz +new file mode 100644 +index 0000000000000000000000000000000000000000..d457d3b67019f0047fd626bc90ee55f2724a73c6 +GIT binary patch +literal 102520 +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 +zCz^()vp%c|JW$gZ?tm%if +zU#i-E+%x?s@!LO#$Jv<8`uWt{zqEh4f6~VCmvbjwjm8}{`q9Q{Vu{fY+UJk$zP{tv +z6|NIE7)@<4)KWWl;?UZsK39%S+`Vhz%^mY^?lgDbF~@zUNtEqWyFX3ZXDH=9x3O;D +zr8VKetoCa^FW>slu1h;+uKxIsn%mZ67w`SH=H9P5Ex#@(xotM7;{Fe*EfW(@T{ctp +zaGg^9IM+;7*z&{O(&IVf)Lkd(KfaMOF}7vG-Dj6`COEiiW;}kFqtfMLwZHi6+kX-c +z81H|);{EBy0~S5SNjb^^u4+Ax3v*N@E#F(7jQDD(_4r!g#ORjsmZwthO>_FXDEV<_ +zpbEcbY{ALcuM1rsrv*;py6QgKY0+Gq5U9*<(JY9Re6_YNRtY^B{nf~N=@S24>ekOZ +z-k#<6jxBoXF!a0NgHvdPsCUfZ2V49Y=e{~`2P6C$dq@-eV2>Z?^{URl8ZRD-_+Lo; +zKM)dk#ztfRKZV58NMGOo76fOM{je3TxeHmHOr5Pf#y{)2yQUWCT&+uZd$u#U#U!I~ +zx%BOuJEu=~zp>7KIZO~^A`d1Vf0kTuE7mK*yf4vhw$}Tbd)rF;(uV_bb?fq{oLsMx=gM1cdv&B?v`KNc(EzlRLCpOL3b)XW^%gs6%o6zMxVMe?*8EbW{&mY +z%)TmVKQF-{mp>d+Te-dZpj%N-iMZv-;<~cqcS5bo!(*@2g`^jjn(4<++b9|A-6!wo +zX@tKIDGF`K%}v?&E1$h*Q^xzQhg);Q$KLrp_bL)114*!B;AF7Z&t=w@{cW +ziDW;N4)=Hzy|@w(Vczak-@B{Yqi{p1@Yi~jvp1uXZ+JWOOq|RgiPN|9Pdaj0x!a|s +z^;K>29eVgx1MOzU4BKJ!v4M}mg9UGpSzmDPCD&8hmD~Qlf!S$HND_!cllhCH0$ +zIWbx}I!|&Uj$E*`eZ0Zo(Z<|^+*qPWtt0PxU*NbqLSBoeBonV|`~8<`lP~_P!Eji@ +zuoBF04NuIIr^SMy|4V4 +z6)f-E6ITSoRnkiu*%J2(wLcUy>WAltpO{{EJH4b-D9Ax~*=7)=nY +zaM|#!%=-WSKX=qWhjV!c+nS`v`p!~eZR@X71O1b0c-idhVx+FiuSWI4v<|W6ySR$= +z-d1;#B%-2%7eW2)xXFBewWMC0v_&3%mK)-ejGb+}lbjpc_99=5hiy7qEoQ%xV>5)( +zu11ruL;8Jt<)>9b{p~K@Lv`ZXGW!8BZe>|i*tp+sfx|#$o36uR +z7Ne#{E+}rvFCRpQ3yS_^SSTUC1xu0zHMh3s)~{h0zhSXz3SJDSf8qIL=DN2Jce+|E +zG@8F)q5jMTbIcbkG!M=(E_++kF4uFoEF3Ux^|>a>j44~!CcRgBCm!AEGFvPRIe$lL +z{!gA3vmLkj-4NxuWN)Y+G>mmEyc5(M{yf~pR_)e&mhH7T&J@QM*(xjUwNrO}!`{~~ +zj!oOXIXOVo=@V|qXL_G$!T+ol*9#&w1_ie*4XX3n1M57zBBsWgX}Y}Mx;Z135Ul|9 +zx`Lgr1QmJinDVCnS}EV{O_YUicrei}l_c-4KM{u5dELP?gt9JCdc<%Sw;z0bAz$L~ +zx!47JQ=P*S|?v +zeAbMsf37r`_4|zeshumw&m6n!hw<}%T|R#P$w`wJ+`4sZ?#Wwk?;kBxHu+MTakATL +zc_?2ZWcrHMKClQdvGACausuQ)%RjKtL$bC(P~F^QtoNdNie5nYUwsWP4-%WZL^)5y +z84o(Ss~a~5X|BNw8?JI&T3$Us?7@!1!+0+$_c)N$g0fXui@u}(nen<~aT(^Ygur$$ +z>W^lujxpGF>&p^GKCwMS=;?qi()3gyKDX_5LON&m52ToNm-AIm +zBU7u>MGp^ruH5%q;O?#dUgyHgt^T|a;yGKg{M~NNYE1ZkDEpxBag9^-AJXXGb3|)Q +zCR#4M+x^eIRQC2Tt$NmQuHaDcf^tj{lEE|6xPUY8-Z^jBw^p2U$~ZI3E;ThnMQ>^v0%&Tn?8meu!+TaA)k$6XP4L)G56oc>$wja(c{IB&_;HiB*iXzwp0+(-CdD6 +zGY;FZg`+WZI2+vxl(8J_x-Ot<^=j7nN#*#(gGp714_EgwtcuLgOFh2Df@VTBIzs!? +z$1BDBBenUhyxk4a4!dm@qU#e~Chwhw%Q?13nKv-RTf9fcXc(069O{2s`v_?dSMwH5 +zyWk^Ye)mtaV_axgUP$m`2`cK-`7z)?-@U=!f3?QSk;WE`SRaAga)Vs@Tvn?5Y_IZz +zeUA@k`^N>jC$=4I%4!YnEMH#t=u|}6Q=5a{17$IZJp6l;i891!dLYM`(JTo&wWL_P +zi;d7x)kKrU(;f{yZD&0|0rCe3z4V^@1#tq=8_ueqWT>7=esuxo;pFG(b!CI-uD(?8 +za93F*1xQ9_T;`Tl1QzBf=|<-Q6F8GqBT7rk4>zJ|eT)YeaK0d4CPCUQmC>gouIYxV +zT4t^x(#tR%vHgp$xqmP3k|4%S5T#pyRBzum?trziJfd`_N{E^TzVs1agyjpiJ$PYN0y=*GgR{FW93jt@!dc( +z9WD1*-0naI9&wkzZPkU$J8eM`Wetq=y~aDD;9owFGNyT8o1Wo9|1KnL>2h$l!I1s- +zEeUEVFWRv~iE^VUVvY`)nYNE8D{Wvn7$GU(0FOcw<&~$UBairJGMOp62w?^Ge0~Bt +z3_H@Jk(Z8kyMdfm+g?d?o!R;$(HvMRQ +zqWl%CKA&2>;?tK{hf1_is=Cch%$n?h`G8v5)T7v^4J=0^Bz!^b<>oWUhc()$HPCxA +zS%q#pD$tkmf-9KZ$`iYZRolGnjsZ|0FNX!6(XdVN8Po*;j#DDCrg@+vr=?sP0QJ%a +z-mP7P1HJxcpFsx@WGub@Co`GX{C2dA5(`_EC|?7+&7yzWmMDk4vCGtwyjj)6JJ6$?c{IqIkA(gwk1 +zBVMPZ6>n^>r~O0#F@$R!5&j7 +zk$F1RL?*b}HcBj}x(AYikejKWct3lfXYf<{L83(KH=|wqSbbdiE1`kofsar2uIcUg +zD&|?;Ti17_I~MzJzt?cV>Ro65)w_6F8ri;Lj8ydV6rtdENw0t=TS3rs-ZWjFY- +zn8&ukmOfQW>lbdkea*`=WAqBm=5vtG;y&JuHH5Jw +zR>-67InwN!fyQ@=+XUNU&@p_B#qwNSSn0Abr0z*jtX?E>=x0 +z>LdFaQKe0Ef={bYL>by!g{3YZQ}XAv$?(SZ-h9@lI(@0fX)yyRZcbPfUaudbdZwIt +zFYHo?YT^OBSLcQRUHimGer=B&8&R`ddEw%)B0SP9*S?BrX#S$DXbWemt+_J!_=#a~z +zdvfmdCb|~E=#ar@32rp@Nza{tZg7Rk5a8g3w|+ru+;BMb~e(;X5!CxU!l@TjP|@V{@I_)2bq24>-)Qp-~oGrn#cDFiBr7?HXP?8iGMlz +zxFlPJPlo(7YxO%T`>;TMj})8TOxT~wWIkL*h#==uDT@+*X#1^CJ!YuWM_MxE$3Jn{ +z_8k-1r@chJ9EqoYfk#6aGS$Y4w5y^xod@ZgD3=YY&AA?GJhBq=5YdhpDm8fOAayR +zvBkR|N4QPVet<=ve)rk;fuxv_DruS4?D?xtL^$jwjw~0KW&~L#g{OAQ6kPK3W-Bkaao%}s10x2j&{=LSukn7kmPq)?&RC>NSY8YRmdr +z=xaCjD!#0?lYN0*zdR0SXuwL*O6^#Sr$JoZCEP)h0xR_|(TqW@i=$I(Rh!m1%t4wH +z-W?zMYX=b-C4IXw;R5#MAU9fcA10jO1$O@dBfSh0GFWl0bbV5SV@di?LphbS%-#GcyB6NdA1)GiLKSH +zptqZilV4uKvnyd;L7qIe5?iOV!(6UMuk3QTwld$s5KTs*1N|W6W=cp&e=%Nv=)0S> +zg88(Nvq4D7vHhsb<ico-(_S3#8Hc-P%-i +zB{X0EMJqG?s`E($us{{B$MWtxDLZy^YoF+~J%B<9-q=R@SL#^s!ZnAbjQh0-s%-Eb +zNz&!#yeES^_u93oj680}T7o|=(Y-m=MuI|dFWW`4QFrEP5NWvcNgsoG3$bO?cGv+x +zyy%xJNJlWxsSQriGUBK$N(0DBp8}HcJ2(XwU}_4$KHmZWf(1bUlRWFNRP{4bZgODF +zLE5ChKP<+hgW5x)_OB)yQeZz6=pwmBdNIz#>RgOLBmHg5PvN@z(9vP!U!L9d?^+_24B_S)LSSH3 +za|L%`Sj2*lhvyaJp!0F9Gzb+B65gU>JRm3d-S~CoSpD696>{X$l4g>-bQj~2x1nij +zuuI3?S+Q8EJZq=a{xuaMDQNfsro3Z{~qGlK+S!q<|Ys;u5}t +zaQgC4d>h^vxG#ofG*c&EL01W0jq3me*IY6lfFvrK91?*fIF~kGB3%ZM6Ro26@qvB9 +zf4+iBP)L0ztiq?1YB}_SnDH8Adr)>{Io9YuRkevm=I#Q@(|tWwx3YH1;0^WQ47)ho +zfz-(MuvBE>FC_7ArUnA;gsZYQISsZN?(cv#BpF3IPE5z_ccdL!bnI&$;e +z`Y;liEo0j;;ny_2H@qM!A$`Utj|u^eLjoRzE=#ft=Z&jGiTNt=u#*F;ELGt&M>8~D +z15dLigFmoNgddActt3s4z2_|bP{;^-p%Dy>G$tlnzK1qUaNxKLyRDle6& +zbb$AolK9rAl%YiVSt)61^?nK%+GB<&e9=1+m^p?hftxEUAkk9}Rs_K^?i<*rUI|vo +zhBP)*`cVi8>J6)gl*L|q0a^v#Ifn)&fs`h{hKKT-bFM0+A(Ib?L;DQUBRwyyqn8=5 +zT};_YIT*-6*hz=(qlGDH7=Z@F>TqR8kznm;|!0#)z>2jVRVTkR=&pVKk*UZzV30 +z)M`Z$1ZD{_i79uZZT(N&sJ)EWP>EEFjHdMJg;H!jyn&`%K`ef5P|(IcY8`A>gg@nZ +z3CWaBl;T)~7Lq=<)&+5v{zse_lsFt^5JxaZ%{qGtQFmWv=d{v7Hi##5iz2oF+GGo<^l^ +zG65Dk*v8=)8QMra51~BYEs)z?ACTELqxM&dfL&?N;*y@Vat}gT9xe@+@aU>heD~4# +zI)7NC6trphjJq*6(%R1Ydmf_(fcwMcx2Qfb?NRC0*Jkp&>E{eu_{ +zmlYlI+t|mPNoMR$^DxM9ny*p7GD>98Z!W7e#)37|B3SP);r3+7MwWu)8@p(w9KdNz +zR4TDg{+xoFz#>HfE_k +zYuY9EfgLeNdKE`{6-P>5#x`SAHAc+x8{qwZ5p|BDYe%D-P+y5f7UQCv@E%=~#6yHo +zY#&N$rt631wCuHn)0;}Hq8R4~J=U)W{Ef-HL^D;=c`DShZ^xl6hoyqh3bD(ZOE|xh +zjsf4TMD0%lC@GG9DJ>4w0iA`vt>uz6o+!zgD*fM)`7gvTwjBCwF$1_ENfg#N2|)V- +zu8XdQZls*W!h(tu(N<&R4MwcFQP0bRkbUvZ=S+3!7dF5PFp@)`Z*ZXt5$+}n5a(1Y +zih6}~Out+##@6m2Tm#J89|BGJk8)-MT{%eNrEK+KDG#0Hdchj*^cqZh4LZ)OyxP%Q +zD9eI|EA~SY@EygZiZ09SGvd%7*6aMb|a+dvieHYna?t`$nJ&=d~t6( +z5Au*I)`I*=MN!#bN@@9|)&gE`+CS)}epk6{vyI0+tNwt$U6d=!H7Sg+wdOqdkO;{*b9tK_y5ve7y0csp(8~ob<=E +zeaM@m-Dx?soqFZy-gb1XhL2M1!@bn{SeK}@7k#q^Z)~=Om)fY8rh(@#Hbi&@5P|NB58lA3Nr +zd=%|lMyR{dz9A{Ic>H|oRPZ^RFgIkQJViICSD{t0_ +ziJ(edUgQmpA7`^MDukTbyOC8?I3AjfBS7grFQ>(0>w&f$A^zUSL+P4@*iw(?renAP +zl`q|7AY}d@lp1`9;Eg|snW#|2yEb0Rq6?Dfx*9xk80lA0LI}aWoMPM~v?EF6xr~UV +zz<3}BDV<{|P1Qk40r>QANtdAU7|yv!n-}<|3|_L*p>|>cU~&lauKnClmRcXSeC72g~Ht2oNtstOR~EWz;ebw4(`u9YZ_h%;v!) +z)x|T>Wzx}(nrA6j@c?=^3VIfB@c0xd3;!AcOTZhH&%+)Lv@RqjyE+I?Kq#&ap);0R +z!h&8xG!kB)p@~7s?lFWy+bpS6L7$p8Zl;F +zROSKJ(WO|JR_8pW4m&*#_1DOFq3)@C0M?6~JlG!E10C#B*vX3~$nM2r=G=Zl#DCu> +z2J=uhhBjS|L?w<|MgXWBwc(;L;a3BYrHd@7Z2kABlkq3;quHi9Uds4oSkC4}02QbG +zN0Q6b5=;n-X^=uC<3qx31F)pOGVdsWrTvuwZjb`?YS1S&-uq)X`#DW&WK_(goF2RD +zPDC7cLGqjFyjK8h61hm80$AF_OmNr|kk!B5g7*&Ixj1T_c-lH~AnD|H$fCE73z*cC +zDKZ+IjRLlw_G&(W|GY+kakdT(fOYalty521$KZ7(x&>4q{S+tIvy3pM7U?EEb`^N6 +zDZPpTq_B>f7Hq#|Zvp^2Kn4#0d+{^?OD8$r7GvbPOoWCiZFt~Hf^(!o86yfcpQDiD +zfkLh}h!7m?Duh+ej)owcjvmRIN(l279yVAi1E*d`hG2^#1aHzhH-XNKU;>5Lhvko# +z^5%VGSkXG#d_=sIKd}%snz{@ofyV7*0aK~cO%Z*FFGU4teHG4`b_MZxS>+Pg$Z6Eb +z&2%=w9F370uxuv_+y56~O1dnkVT6-RX_ws$&Sun)N2{TJIqXw6iflFw8Vj_!UW{Yd +zSG8~;HbD#tNebB?=>W+V>QRn>9=Q`b&}K>M^su+^Qu4?IB^O30-Lyigu+eNo#92FJ +ztKG+&4M~S=)+jP)qNQcrjYGFn$}mfrDswN)=SSTw#FkcgO%-mhTu9VzwjizpYR2Ru +z8%7o>G^QnSfOk}_2;nmedDeKTApV=X1$fbm*aB)(g5{|J7{MfXCU1S`Hf8qlcn$!HvJC7X{L<`9eixX+YiW+#T!&75Xd1c +z`h^Fu$cbbW#Mk0^FCzlT@Ud5rn*~ivx4l};yQ +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 +z6b<8YKzRjxJIRU=-)F)>jkS!s?1cm-p(3Coq +zHEI9^+&k0J%xv|Ap!bZxnTo^gH4yakpjqDl#XUDpCIxL4C~$fJH~|b25U4%LPPPp0 +zTtFJJr$$0#5#9z!RKhigDZzxqD|zr4d^_t~g+2vv*a9CzQ?W*%%!8SfLC-m)qj2O; +zu=akKYfc}QVee%{P`nt7SL6{=8wWTkhMK4xEBulM>bwHeD$Xf$aV3HYK=5w#&MP=L1bKmC2rdB^91w_r|1JZeD~9-6Ak9FP +z$ASCGk;#%*BG^|~A+d7|x(E5c2or_Hb(^1Uv%+`s2W$<)lV4o(TmN=^6J& +zg5HHJsK}##8$ObLbY_C}4HQ%(0dGciurmx;kURoG`3RFdg7tZ%0gD9!q)z-{ysfnk +zhw>3yu1K5?P<%K67*_qm_6DIZxZpJpfiMn^p&WPOh%-xG +zz_!V7K0JL`ie9+FVGz#kg5v^3g^>p)@~Fa9$2TEKZ6|qL$5qr*k~{F}V>m+_*NrR= +zi39+17r^|6s?yCKfm;p33+G|&-}8`AV2fbXAo%$lHZ;ie*#~?-37pOq&S@7IqA+G* +zIRm67&Gc}@Od)=dcXz|qs#d5=Vt`!*K%l{Le*Z8B4ZY&PzGnd~#buGEtwzZCQ@xeOPkZau +zc2vNN=Hzjl&>(0zkOYe{Qh197U>PrX3U_(*^g~_A+deiCI8Sln&4#cMfTO@Q9s8u9 +zrhDKDr3%htLx!c!?crA&tUpJQ$8R^mP2i9ZE)z|GBdga?Fan*nz!edBIgcDWu>p1X +zC4me;bscO>9oSc*EM3z^$X8IY6W=m_LdZE34V8B#42_(I<5skym~Z<+CS*dY8xIUW +zbcXE>w^dSMC*@dXNjI#ms5LK4M43k<_njBg}$V9PW(>-_Z!met85kI>lQC)o<( +z@&=)@0gWa75uWg +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 +zjzKexi&TJvb-#9Lr&33mu&}3S +z=Bn=~YbmvmXmjtgg$4eMXy(p-SXKvKNNF&%a2{!zp73pi<+1q@;cw@{vZNLZi=oQt +zi5eRpEfVk6^u)8q4r-=Glc9z0$Q#%TC3h_?Yz8d+02WsE&>{tdh-Uh<+o_rAZ59^% +zr_&SemW8)%R)rlD%@nzGP^nrB3yYqa>4}@$U~kQHBf@!$U=OT4wMd~yMKgKv9o0HS +zb2y03XRvk~SmDJ`;7T8_kOCso4-}T4o7BIT?>Y3oUR96fpI{JGcMxkc@F#rXTBBTy +zuH;iPe$aPY3}$S6a0DH?y)x+S1eJ8B^Nv5ews6>fJJJTzX4E;Bh4jqNP1OHRlnQ}_ +zFM+ecIvQGy(J?@^g=v|f`h&9C`(1vsltT{#EdlrX@o6DqL%!HW{lrfsj2WeAdX%Hb +z{JN-XfFe>>lM0!CH{esMgD5C_Tdz2iTJ_8FZbhSj8c>?4>2JGL+$UnKpdpftr4lU% +z7ZEm}#;1&xPfz#DkO`$=gB+F+$qcMP*o)cZ4}YKanz&Rjn84Op;RB;&s(zTbc<_ts +zn;}OYE@y-)pS=sn3-5aVu$&8QVn+8(zjk~T^8Ol)UFT$Bw#vB9rPM9D!d4}<(35h` +zD#5_6mt +z+_TdSZ7OR-`~qT};Dcd=e;p~J2S2$&&%&oAHN?4hYc}G5`P3T9NuZwClu{VbwjgBr +z+&ObjyKzbft8r<9Yr9+ty|KF4UE<*?LSi#%eAJdY1`09RDKJ)tq#2!HA^y(0ixh2qeTBs3i#X-8Lh=-VBmk-(W>64-#*)x>-;6Q!tFQOq_w8%p3GY>4T-MI0Pe0d%?=aIF`*3D7lJjv +zG}QSO;wuPXL3A#Hhhvfh6`zC%(Dqxvi_$*iooYt*-%*}*StH~ZFbqacP6*!2faF{y +z2LxVShc+*tL~e>BH+?0D3Htv5qx{K#-o;x{=HU7gpPr`Vw$0=FaN8j~I9XM74_U+3 +zOVglys5{csyucr$?pys-R}MZa0|o~r#v(P{fv*z>iAa^GZ5#l8vN0hpsggr*OmZA+ +z%7!|$7EYG0NX$RFBL0wqa<1^Xor~B*3dYO0u8`WsJh}y(gv*eh7%N*Rzb+;J&9mgs +z!T-lE`g1w_^%Vo#pbo8rc+b|dRfMVK3NA;@GUW@c +z)~#G{7?KI@KL7VDBav{=wcL9mg{tN)OCvC4W|JPMn1p*WDrS9Mgl*opAtexWJ3+<<^mlDc$1R{xzOR@= +zm~99*{uNBS*jPk|b0-Uu`s?<>{<@m{&#b5a#3`lyA7_w^j6tdW;XDNSkEnl|z>aV} +zyDY-@Y(Bnh^e>fcH**%^=)>(+JtUx2L3{75QSSX#g9!BDd=>qd1VP`2W8t?!DM9(&(@koClr!&_lg48yv^K?67 +zZqB)Sl2TOM@8DaW){1xX@1t23HOqg0j*X+p%Ml%C}$ll_wDW+9rT@hK7&` +zu+MzPCqT^iaEf07o?rJzGu;C*Z-zR84(1)o8`v3pNT_91O(^HT@}lNpi~1MX{RT_l +zf0&!`5auS-5zR_u^3+ASt%T6wb3$$_QH$vRz~p;BlU5zLK_VfIFqoLAy@Y2~jd8S_ +zO3@E*6Rl`0#gDOynNpP;rPb;5kLPvj>E%8!&?`KYxow*sDY=E49)mU4u(>mq2> +zmA15>2h4%1Ng=Jrwbws?M!xqvDn?E94bbj(ZIC1{t<>oE!~K&&2jS+x<5eA?bR!OQv5_13 +z1XSk)v)rflh^WTiCHkpPYf>}NH1s@($-%>*i-)z>_3X+#XDudG$VC^ud8c?M+Ww*U +zuk>2JmZDLh8PplO&DwM($u?6x^zBVcO{DXtZ|P;W1~PsmQq!;DrUYwV7;QLepEuKM +z8%>XxzEWIY=@WCL{@<$p;AGMc7E8o5@~GC?U7B~>=2rS=LyHaV`Cj3E;QZ_J;RmMP +z6-+#<_x55nKJ04z|EuQz=;W~NP(dR9Xlnh|bnylAZ4!*_r0%+?x&v7M9G?PLfsN0* +zSAF(%FHw3*marZ0_SBCQ5#9}??2SHeU~l0ulp4)mfxMhIXD2J%Ln;uxf)+Zy4hP}^ +zLrBM1F9{;GHnm7VO_4xr&Q71KgB5{Y=H*{Rh-d% +zTIB=ynlR_akk(DBT8&ai7F#Rn?3zI}wNGEA9_ +zSNjbrP;)?WoPLQHYqd$Ygd$w$)7Z{7!l$SnyC8YG0N%ZRwWZ>clLqThhUe4ljqt*S +zl||owAyDg#-90^9YIL+rGFZx#iYtguEE>k{+j-^eN{v0b9%yBN|1Yrg;O!A3LE1_4 +z@QEHvF29+vN6~>-pIcbcbAwCa80)4^Q|WuQlK;2^M4lCkuFNeyo4xJGn=xXy|~sJ(21ex!AmjFwxLvz{7x +zn)w5>Zb1VUN8q??;UOjjo~l4o#*dsNNXA^8%0#{_WedE7EM4a2Y-e=UNVJ})bOD!B +zzHlLnfeW3MQZn2u$D$B`&pLMVLa+^%?imb=Bqx!M3oSjd$uNR +zQ4j>}8+#q`rgyoDKFKT$??)cV5^)L!Qv%=MY18%vXJ;Qiwi;L?h-h8io?~E6JYDy2 +z{-pjvi?YI-4PoBOO__AfqL$NE5ux30DkHT2GQ9}+-4+MBwL7M2O_1qp>{__Yl-c_C +zUb{&vLVYJ*`Q!!CTyzs^?MpV979u7_Tq{@8^Rx4nb#Cb;EOZVV3 +zRQFi*!ejfJqMQ=aYvLX2GQb&4UB&c7zOph=6W{laGR5bvcI(2CMz^$L(kdH!&#=5Q +z1~2u!j`kKe<8j6T13H?;z3sJRi;>`2lp@J!EGR#JAfQ&8I3kE9m;anx$tBLb&pV3= +z9o;YC>rzJvJC9mpIf*Ij`s2dr6qDjBHJ@rxG->djHHT56%sIp!$ze1RHT>8#l7Ii* +z$(XV}qlgFv3F%0QCZFqTCikX1EMH&qdKsOQR|&VqT`+CeXtmpy7wEvbj!&s2;}z!V +z_@Rn&d+Cfh?RWqII;GFzx*R)#LhN`U4VHhTt$QWfSv>Kk{+{Et6h6TnPQ*(a?YQ%c +z^vRq(E?!A$$03OhTjj7U+J-3h7;%wO)AK*Q +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 +zY7%BbYW%+ +zyU(4>YVi9)*bf)D@D+(7vmNBO$1n8?{Qda%>!TAl;Z8j8%{yNnM^RH?I<&lGuJb5H +ztnxD1_4Jkp6)>L``KB{d=VW^^amUaSZ=&ugxUQT0V_g@%Xb3v) +zMCJQC77oLV%nx@kYDz_y+>Q2nI6Xgl-r8|yw4!DkqHYlk8SeD1eNdlr#O^O_OIqLI +zD78{-uhu)cR}u!|S<7;y?&*RUC<$9HsF27k<){3}c_~3!6IcF`!&YwmHY@ +z8~+L@3S{3^&>+-s(9wXEA&(+N!0)!x8>k_HeljJP^UvuR5rL)xb<4mc^Fcpe=N$>? +zR9Ed^jw+QETA|AH;=mADj>Pd|sLAbx?iKq)uXuHUJu`Dl>rcz^vwi`1n&Txz039=; +z@Tac5qTG4aZ^ +zG$qJF?_j*$pP_d;kNR)ATE<=%{uU}<{kO{=3I)YgP6Mx%APBKl5;9^bBXqw0AIHQRb(?OzDBcH0hpFb?vabx0nHyi&kjyV;|6(P1 +zz0G=+TJ%F|o{ekG$m3jtQ!5x=T5GwnUc!M?tmy6JfSz4=_e+zBx9`q5fTECAqxO>i +z*UO<$>9``TgOZvec)U#`SA1oyBrxOQp_~#oZ;_uma;8LmvR6p)zWYL}Fnt$XPcH>} +z?!qCbHJ(GIH*A-IIegbshlBp0=EbwumGUx1X6Svb4yR+WVPl>tuhO;Ct+FFNU+`8#Nw$|pKD4Nmq +zG&AJQLkJPJ!oq^n7f(#B$B}A-_nUUL%qnwX5|1Hqu1D4qT^MqMR}o-?XU|#1SuNi^ +z*;vpP4m&ilss}$!)WPrdh*7Bd?i$AOQU6|VV_3okR+Z&#ry|Q>f&*_Ml +z#>qVj(jBj||9IUfR#V58a)`z6$i9E5fM8!p2bB{pjDtGKW9wwQQZqMlwJy5b8j7i%@jjh-6EMOq +z-Sm9#)h(=b2a_to>*6j`<6IQtL|jLeJwp*!Xc{=mvF#TzZ>-%NMH0cZeVJ$7y|8)f +zdZSv{kBOtfZ#w&_PA1{%7K1r&pM?I+k4ryojk`504f1+p$TUELyzv3%#^^a$j_d +z!ijm|M`iK~5*8`M<7z_JF3yK>6B0V#ym4sku2gYbHO!6}Z64h}Cm>K7%IepN7=G6@ +zm6ePC8pwKzmokvO+{`KUZ@K3woM&?5>gow%x$4A4H%w}oZ!4w_CTG6ehYh0l%JS{T +z`VLsWud2V?rc*Z(2Py;(i0{{x@9=wV#XXX=Fljt1qMY<;wRW^!qW_6Rv4I9*a{1pP +z>bRf{dX!r%(Oj6@8OF8JhoCJ)6fF1h`=!;U<{#kU+D@h-9Fkad2a3|i;=pVoE=Lyd +zdJfw2&Q9%&#R7!lrjZIL98;$gU%Bpn*Wmj0LZIc$j`UK^C)pGZgv8Drn!N&r(Ur!; +zEx&bMkSkiXwq?C<$Nk@(*rULhYmBw?*SNHPl`+YilmC)=qQ26kcDA3cN59?^@=GOb8=Xdb)hrVm%BR`Jn(damJxZ0{ +z?~E8L8@ep8q|G+8g~v}mnPl_Hqv1nmD?BJldyhm2CLiVY?@Q1{G|~3D`0kAxF*c#K +zLAJaS6{&3cJ3Zb&WC2C;@|9@`vy*(Se^TCjeu$r)#bcSYLz&nmDOn-oH5)0fjYc#K +zotW*)vD!XG_IT~XZ`-vaLorG`0aEttAOfw5n8c-D-^xnQfMs5*mZ%4Bz4(~^isc?h +z`=vnBD3tjv_jI +zm=zHEfXq0IjR|4pbv}~y&foI7aN?%4cRMb+cL=$Wu|okyhvf1$YpGF|RDHP~1=W`z +zF*055KlyY3cJw8yU%JstKMT~%FW#mcKa$S^g)uEue%A|)7x$zh_D8qc32-i(o$~S| +zujDKh3@}_Kiv8IJr}DzP8{SeG4s^p5Zk*fr?7XyWw%N~V$WiZQ`Ht9NzL;I7R-{(R +zqa{pfEx};DQlQ%X+vtoWD}(QwHW`YK*+(0hk^I5$&|f8F>#U(AZaNrb@e2=_QZpDP +z1ft8vdXxoKY$- +zs+}ZJM~%8fhcl@`F_HhL@?!Ov1op?lj^35rEM!w9xajJrAF6{gR^q;$)UUj&y|8ywU(IkT=M^d*x(~x&7Vvz41e-I;MaUI@=#YTr +zR2p(_>l#)!4C^b;-#Xh8D44p!1)~z|@l?#qh_a`a&g{-2F2Xs9phqIbmSnsWV$ +zs-mQhfr(dpFrKQ)_V24&jsTk*ZYgeGe&*F&>(jLNLwU?safbr_;fDW|bomx^ovRhN +zP2}{8KH=bsS*(yuj51UW`Y=J&2_)fwbdPZ6C +zL^myx-&xU2QwDrMqs!33ePjy^rH}E_(n1{I2>=$XunvaXPkn+>{W`E2lh+a9!|)hD +zqqVmh2{R1`;hR}NBx18*RR55KWL_m2Fu12?uG=-8P+RKOlJi)_(lzgvG$hFsy5f_! +zh1HDME@nFxY|_O37qR!-Ux3N;FDmv-Cf3>-b2{Hgt2k{A8+yC`p84i9xB8KDG*`Ve +ze_vklcC02^()OWZmy+qweU})l_}wMqQK(PxTBs9D`mmpv?x-77X8f1>c()H>9E+aR +zf?Cfm!}D;2I#N8Q9803SqcV?8pnBEWU&X5R*zG%S9s)!n~NqwtqRY0&7PH`F68YCLatp5-nnpMqCD?_&286v?A@Y4ArS +z@}yKbDad8}#X%4x_lHK7M)(fph80Sqt13(Gpr}nunvH%V#Vay%Em0@p8xQ@ZpK&pm +zv-dlVi&F*XInKUPedXJB>jkZ!7gr%ymIOSJF6Du1%qHX0&>G1Y_-quE5?gIp4ncpa+xtv;0D(+;w9}%1^yamo^u$PrTsW1RXF+!63O2T+A0PP+^1-{R2NM_l +zz64+12BlDVjH@dbo}l7_KbdkyGvs`tSWwOuM#})HGR-GM`=+cK}q`Lxdvx +zZlk2!1E@r1D_%p3z0=IzdxJkA03-UdI(XOL#SAh(7Hop1Xvm%ZC4Jao)KMO&2qV&5 +zv*N@jrvsVL-BHbyGBOtMtWLQ(K6I9MQ|vc*EAc?j!83Qclt``lD-z-uBMmX;_D7;A;bK{F6#_I +zPo+)z6Un2el;D-qZU?v^aYTrCwi!Y%uefK7>KM59&uvmFDb!eWP^*%ZY}68zA{6?o +zGc#GGnXIqImXFptD_3H->JbmnG8%bT^DtZVY*wweB&^lIuGO^+YN{$vi>~-ksc-)5rWKAM5|YU9{Eyz5ST;S+Q2 +z-z!y)657m>w0u3@;am?7_^h>@@3l<1#{GWE%c@y!sv2$^(h_MIC$`*EPghI><}XLZ +z%uI%{%z?|8FwSY2q!iA)8^9glA>-7PPtV}1oWg-~o)dhW9UUP5E)Jk=8fy%uN5K~u +zCHKs+4jjrB#Ql@;hJl!7S)pb)V`Ps^>-x&rG&=Ni1kfgxq63-YKfPN775b#j5wodl6^Lu8 +z3o!bc+0l`gS>Mn#?vC)d(VFeWT(bSLx~;`KfpvZ5#5ZP-1OGhWL?wkZw6+qW6KmVJ +zt*R2B8G^}ni*ORQ5>!4pR=7>P&$YIg{h+EqrzNneLqfv6@z;ZG(?=Tu^>Q(zM6&HA +zYx1!I4C7su)Z>v;<+qkhpC0mCVioz8kE8J(MXTMmqIse(PEe*j5?p?Z?Ee5yepyN) +z7b@K%YIWnFgElotD$> +zcUrRXpB$-5UJgE}ch>izCW~ +z$_i?4$&959ehisa*rG#7y!0sx_heLJq5o}xem55?FQlprkq5Lw@73d+?1!4a6Av$Z +z*BPLTWD{Qqiqkh)@=QwXz4057Y!#`kqu+uN-@o7DWH4QiVG1049Mc2rpsl$^3{^PI +z;{Np_3j;}U#pP~x*rWbGR(R4c8B*N661WafPdCSGmk^{er2y +zYl`2lt0x$fnKOKT<%oLN=BFsG1{TovVyi-TvU?zrIwJAasNNpxy0=dQZqJq?iZA43>${-h_K6;==5uonlE_%y@l +zh5f}xnu3t0&66ZEpDzuAGz0qv+b?^6s@*_P6mH2Tk4aT-ey9CaO?U6k_pT#%UX +zL3lex`b$cM#b?=zcGn9{u&d2%F46)j9*{YQVP!OLn|YU>sG1+{BLbTWk0w(Ti4QDG +zmA}wAm8UZp>ISy`Ghj615(`kT8Fc@FK@o>U_&|NGq2}Smp8j12L33Ex_ck$~mbz{3*_<@y52k1rN6zh +zc5(p5;yBN|e)FQ&IWoi;tEtJvHA;%w&PocRBE1$TU<)yd=MyXFPe`A9r~wua$Sxe; +zoLv)vom=#Rhow{9>mlD4xna_?S>uV$;Qr~iWV(>VnE70`{lJ~s4mMnu`_@X)V+Ue?GNtBZb-zmefje?Ygx=xWa062S~>JJ +zii^#&tDtSnkJJ(Nn3f;xjc;jV2XXu!HM&VUtp`dsYNn^AAZ-F)F5UH|zyhK-{LMNR +zUM=lSdnW7+d)i_sK=9T6G^r{$M3czZ-xR|px+`?En@}zuL~4a*B;SLkU?U|sI2y9) +zEzwC*#8*6u6TYGxFR90mqlfU`B{GuqAVa*;l)_PDXHfUlS5uc`J^EBKP>Ul +zO20(re-|;tqDMJ6NyFi;r~gnt)u$-dCKjEM>MGlt;Yo&W`ALR~PM4~N(r;esXOb&C +zqMHs_r&_>aC)HZ1n8#X6T*L13;`o^xm*VKRNu3$ +zx94++F`o4bpSl{X)`f~$d9=)n_*Dp3JWn#twL(SR{*w1H`*9Wf*X2a@Wx%ItCyG57 +zdD-&%9&LMwyzt>+OMfbq_?5F}rfBg!e_!b^b{oL{$m563Ml_x +zWkhGO|EX+_X;4pT!fT-A4-z#Y`9jwhPviWUqCSgA3P-K9_CvztG}U|Z9eBS%NSqI#9Z;xob?z9qKy02pw1DFpw{I^M{fO0`V{)ZcN2Bu+AD4e%GPUIwHgaFRa=nn!?tfU-yF_bf6roTlu}e= +zZZAU8P-a(GrG_M_DNh=XVTj7zU(b3QrEj9vam&4!6_?M2oSwN+F9E6P78Qe6+Ujro +zpgax298MH|d3$X&2lJam?4#@%|8k@Vp8c_*`B|s{FGTy +ziSPF7-TwXZJMs$PxPp>uJqaEU08HSj89A@hLw~s%*Mv6jaO7Zb|)P>BEDlM_ZoN +z>_wQv0fx`sJXC}53y%E^9$9Px2{usy!Ur7}l3~WM)brhzFujZDu8Q@A1L%veM*rF1 +zj~h0D2@g%1Ozh9h?C7ntK0g@OmJt^W0G +z2}|vUa|>sCi%=Ime%r9YO%AsEC@JDv`TA_I+bSX`d#0fXjo0I+Wb$dfLK|2i?pgws +zPx5}o+?s{^fq^`EOn8xp!so|et2V=HeI@34{EP;n6-!7jX!40~!L48**^ezmZUk!w +zFqGq6nq3^Vef#g0WB<7*di%@$#zRf-k +zIfldadPcWCj`wvya8{DRJoH`>+5zt!>UrDh2aIg(W+EMaj0x=Km +z_mv3jhe>x@C_iUYD31yBJhZ(CRn+5$J?4{dagf%dlwdo=(E(&62z4^~QwBlPRhS|7gNaM0{{cNzuDx&3q +zuZshq!J$TuLFf$}q%rnV_xB7?0;zUJTwR13!B?a5B&Ao#gk(VWF_$rbl%kg+{2hQO +zLAb$PV&5yo!dHtBykj_8ZqG;wEtDPEz{N^(tWj9_p05l+H2!Fzm}i4yR+7dBp|p5m +zlU7m-MLQc^g5)=8K{DuO18#!w_eNm{OGtqa +z#QLh04`@z&MH=v;z-{PyoxPv>?XW$fL(-Q68$T+$DPQ^f5Y< +zhi3Rj;H)BqUAiT@*;*|}!KXab#aA+(AY9rYBvSd>cEj++Vt-)xG#y2b+QB1K1QsN! +zRb^(c@DRMWpM%w45Md8@WPyVY6n86$ySt>zS8`sDpP9*ry-z7@!s=!LPY22#D~YPR +zgxxFDvmd6zI<;Ul%yjp>gHbMFo#{@U=Ek-Qy`3Xe7JuK_^}EN#CGhLYu8W2DFMoeU +zaiP+it}F9@jJv;RHFKz~k@l>8%q-%`HUWb0NAa3LNrg7hd11E0?@5X2h91&S&;qda +zZOTvBg&32bL$O-((yxr4|Ddd3vp>YY4?D+ZPsrjv%S)N-%GUBSDjUD={&sfD7w!+; +zt7d(_OvO8?_32#7)GpKG#aA{i?N*xI@I`f@4^g~*{MJ<@O8njU!K-SNOz}d@wjPaG +z(){#m_k3wv$h|K9aa?(!5n*2OcNnuC^FMHN +z(|;dN|3IEc-ydSo$GF7)xpU@6UyTs&x7b|-g%HiRqMs;>Fa|vlvCMht#Bst09|gM2 +z4EqCjj=|0lq%Zig%9`*wJklj(-^|WF!6lWS!@uW=Dis!L-4f3o-}!dJ{vl`e_)l*m +ze@4E+B#k?NKo)5JI&-m)cscS%i+Qt4zc^nd?nW1nUwmu18Y~a_rY9p7JKrg3e9H$! +z!RhMw>ko*c)17hO4`7bdt?`Kuq`3yxGvD;lFC)8WcJ~=vO8hDOM_yv3)sGgcv$|g% +zFC<+N?-(a8GOBh3i^{h5;C=#&LsZ{pu0|BfHuW^df+c0@J=^}E%y&v3PyPVrI$a*O +zjXmW*m%MMrvv1Y-fvfai#uUr8_V~wA=Q&*)$A559ARm}X{J@$+-a8ZC=X?32PWW72 +zNTtX372o5-zwB6qyNa1RZgTDcu +zWo7$$5A91VR={~bSz04Lx?o>E5nKT8xNFYk!t)+75q*t_&Ek2n^av2v)O3+bGH4mp{+EHoyV94}4DBq^y!)skCA6 +zmjug&H0{V0Qvn7;$oMblREXX$8f8^~L~@F`Q)dhY8>verkcf0ebqMLil) +z5;pF)>4~gB4lse +z_Qfso?kusDcE<*2(DGwsmA?ECDz8)TtBNV8`3H0ah1KE1BQ?V +z;Oo(A`&Bli>a)7?0`X+|h*CW>WE~F6Nt4z6-A5z&lShL7=r7cE|IhwY=4h +zOnIxv+vIQb{5d08ovnAx<&U14mcR0IZI-e|pPZAj6;{CYQT)JLC?!)-xQ*;iOaD)@ +zJ4uPVxRf2-A{{bd{g{;6_W+_IS2R;sH>AgoZn +zzr}6f(I48HyItngZdh%J`J?*uy~bZ-LN?#Nyu@xV^X_v!w^WlRZs^_FdZ?_aaJo8;k@tVFH)V7sH{)nC#*U<;|YFIzCKsZSWI{Z8;+XwvIzxL{5fY>DOh-GY*}vIN~AV +z67sA_dAsuT%a6rq#kVYR>^$B)^=pIrqeZ$4 +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 +z=!jRZmgvFX0Kq84AMUSv6KICEjhQ@D +zai;X3LbMpyl_y|_01ctB9cXC*A4IEQ<}V$yS49dB1u2eqp_(IG6Wj21Qz?5({p4`OFQ8&-=Md{M0$+2|0>OxTsj_?t$+T>PW|GSB?78EcL!g_jP(n?Y>EIIceq0aHIvlH!h%sn@9NB7H{FAAZv=BcJqw+&`aU +z|J}VkVs>H}@3z$0AFX9rp`}*RK=uH4*N*n**CbI}e~DDK%Cq%rj`I53OHd}<|C#ds*v<_6xT~Bfa`IWDJm8+fZrg#~u59{tuZ?`e +z7d=0XyIrTq(jD<45NcurNmt=HP)wBwA|Lcce-z>s1E=SLVp%a}#AY+DD*255@fq>K6Ivlla0_i~#xMl}4HdZltD0`|@fOA-J2 +zX#j7t5_@tb_MBA!78}b;H%qx6H#JXNBdeJ8OBzq9ptH`vxotV<`Ksu9j(G4yu$24G +z>MF^%R`o)12Hv>0n;i4@6^KFPFENO8RyjVMud%t8(Mifw`Y>Hi-jBGF(Pmxby{BFv +z9du}Tj&5Fa@Wu;|qlrImpG&@ZWk-*;p#jIFd9lU)8{nXlU!Ow*%~CFJUH@tk_dUSY +zSRK{G%**(^!>M8rjA#Zxm)eEi^^#ADxUUr6NaUSpxe?ta#^Q(Ip2BO7&cJ8xt%V=( +zqE;K?pDlnpqohpHM6HT9p?kU^q#(7v#-?6I5vR+h{aJ%b6^_})3mM%MDzRpFqNDN< +z^SDm(%tow@>*&0?2Gdi3xB{7n`bAqIVYKz0Lg*AW9+!wpO +z!Ck*(CB^7n&-dPm<_zBgDAn{CX%W1~5!tnag-nM|zk3tI-T+foWab-h$y0eVpv_C78nsEkM6NdTME +z)G3g{3o*pIR>&EEdwc^8Ha}XdgXj}gBwQ~S&QzU!*B8Z~#y{WSR<6}SNu!l#J1Ni3 +zRh|9n97%pUl%}C-g~cnvqt>Es6$`~hcaq7Cs4C-jQyGs*SLn#5&TUcx^o3G&>hfHXKVpD<;d$Rb3)p)h={ev6Wz;;=_w7D5{D +z$CrY+pCOt0IgVl&=CIz{SWu8*SRdSp?Wr7y +zOnTG1)0OKX0baP +zizml;=e`NjJ7a3=h22?K*qGf;(>3rgm|mKZXJ_f_Y|=iu)MHD=+Zmf*EwSfUEA_%4!l9%S$I3E +zeN^WmPt*77m0I4!H{2Tx +z%)}jD?I+H891}+tu1asGWqpc3gES +z?2mesYw+37RD7SlKA^I)WV7NgM8nVHm=hvQT|2l3I2S(~x=cAh-+so<=jZ9m9<4qc +z=-hh5acuzjLSEkN_aR;PlO+S^S;}wEGa%4)u2%mTNft# +zjh`{@K>;E5(Xg@Q@8z}^@Qw-VU6Ow6jk}+;HNLX4Sw7A+YnnMZbYZ~pnTMvCQ$jcP +zRJ;t`8lO_>br|okxaGB6HaEx@^_#(}ch03~{gP8zq(Ab%Ucvt!Zf*0wfhGouDZ7Np +zp4dXG!$Q~cbDfbQ +zn-}{8A0K~qVBEtq@5aJLft49j`qcZE=Unt?9WLvRtGNEXynR8Aq*8Qd*VPTcJZ(~= +z+(611yGOMbS;Zt8C#$tXw{63ktaMIjYxi~6%Sos6?5bZ)Y71QpFL!S+c=_@7#PV_C +zQmytxyF}}86>GF(_vj1Hwsv3m3mXQhpfIwzjXeg!_}1aP-lF;>MGkxMMm#^yE*YOL +z?IS@hJ8|)rSF8AsRyEV#6!t&Nvy)EB^58&jdqM!KI7k8Gan}wgNNz~{{;Zo5Y~z>s +zedct(3&O1Qg~Hpe4mqNhKlap9vyYGjnV&agdOY8eGvK{hr+td~-X~#|<6_^!J^MSH +zUM}^EeX`)ep}T(u>4HSQpZfB-tss+bQT?o#04we{Q#Ur)2r}iZo-d#O0r~T2^Y&4% +zEqmn)hBafgG+${2l9mbNqh><`WAI*@jebMBdN!TwN2`rs1zlL@6V=Fc-Q!J7Ah`>pV6CfO@ua7FAw +z^XwI|Pm=H_)BLUl-<{Q9BEJ7&0?V$i22mGns{O_bs$?{Ete!;T4*w +za;FIA3>;_+0aY0Hi2B%kO)|9y}DyhcQBhHy65`4gm5PoG6I +zLzM0tQTQ60AeJ)mWKYSw~6kwWUk(`gIE9>WRYd +zD7_1E{W)a29379M3%`KKTL&!`(WI^mY}A#?=EICzjw#%(KhE#G4djS +zV674YIzRxqO#x|R!fH{JEMQYD(@oC3j=KdYA5#Rcv6#!~O_@`<6zkui +zXDa8yADoL!Pt=j~eOR$xcgM*3`KtB&*O;5%Vb!kjX+;)K%s +z3Ig}$SQj%qdx{>Q@VOd=4d1ZiDhT!&%L`gVQG)Mv;TloYQDL4u=-(Z+gWy3GO;b`S +z3TD5;dODa|q!S{t+Bt>gt5nMyVEJ|_xyZiB#!MCn@gMX2BF}R09l5KO6oQ|x#p|OP +z=-BM;&48ioFSphH+3*4-0O;8{bgQ|W$?^Yr&=4<$2!!%nLBjR&s543mFdNUIz3{?r +zO7cP-^sF+(Q|(@LsobkQuzzefv&Jds8jm|6)_It*>rGC#0>i$_1GpWpF`XVUGs@F) +zRSjDH%Qp5R)B8WjGQC!RZZfN~llwCouUz{Rz|#n+Tl@C}Pqp~%!&9>lLkq>VA)JwGd+ +z1cil01Q?7}v1lVa{+ffTeZ+SR@eTz78q^3VQ6d0)e-7;wSB`mbY?la +zOF`#pC>^4krs+}7eggS}e^-*9`*$aEJftZ%1ik_UmyvL)X@z8NcY~tn%KmeVy>@+IXqS#Bvaz`#`_D +zN&$R_PN@Wl={dkn@x;SdKZ|sfxV1BGx2fWTU>hZPWT3wdte@R+LPVVHc22;|QS
  • }McI{u%&-hb8IN0N#8oN)z}`tE_D}&lzCTFUyuSz7ukzKY@62-b`kkuvkRYG~ +z_BZ4YoifCm{s;Tn%JqyP*C5A5radwWow0_E{a5w)7&@TH={<(nE>cC{55{u0ZBp)^ +zF`sq=1I8}lFaJkLc-eW<=%>}tp +zx3nzY%y@>-t`CD0&E}wix0n+FuRvZ2|MmuQtCPFGoZ6CRv0omfB|iCRfIC4jV3MQhnDj0Ec;K@(&gqdJ7E%aF+01yzC^R+u*kR$8&z^z +zlvBsi;w+##2s%=jft4{4pZZyH17Vs>OLUzUw6&3}+vQ!~c;SPq5p&H;WH +z2eiD7Mz`Hs%+w$_G*>n^Fj#i_ZY~G=exq)N9m8b0Rr>sA+f0+8xhpzsuAH1=Zr5D6 +zT|QCNO0#H;BJ1HM{AYJwD*C&c3(Lj!qGRyq%4)69Bhg_8I87|_)aJsUy@9+-25y(N +zWr`NB?1sWRY8`fs1orLJQ4 +zhA;i$&1=xFrI+2g!zwb(A&2egN~xHfXxBHu3LckJu=@QBji^PE?ShG^6;l(9`j)dk +zkF7R~-_F}@P+RXBxjv=BF43Y-oLb?K=(!i;(P7E1_qVi!^CZTCk126eEJ@t!Ng7qA +ze9!!Fy_VA=VP1zuOS))dU96UHnPiXPeoCBOBB8ID_0Y81Jl>k;tged%@*1+Mkng>$uRehO(<>ix~P?R@Ip3&6%v@*^woklqbg@wmzJh`@job +z$+h!6y3ayq)Qe`i!~Kfmi7Bx;utZx4~@sM4EPEu~RUz0vJW_w^hl+^t~aeU%nC07TD-)rIXu$ZZ1;Vcn)~M!I#ks +z&rb+aU^mn$usNu9t;&WbW#FGpL^qXjl?Wb>`DOIj$nhy;{NjEk +z1cy~20|Aij1o>)%r)}Wz6aY3G)FH!ul}naxB^5p!;Kushqyo8i|2qDQD&6Rsfj^un +zk2_j46H?}4#q}W@-H6e^r%`28DeQB|dO2z{^;*kDp{jgnF65GboK%8O-rvb|0AlZJ +zG6hsCGOEt%^M9(&-v;MD9T4seoska*sB`kLJ5%ZLP-@PhmgOjX)hGw>=QJT=30CJb +zt@4!nJ9!SEiH+!8?B|mr^yrtrS*@Z?86ZC+7)9K+KWvB-6v%s_LZ0v+)%FlBR5uGT +zO{3%2cqs4Ja%0uq_E}1WwFAsPe*acS30dK;Myj3V$13aqtC7Q{r2Mu5fujV~s9E_N +zMpk9wvtd1Ffa39!@yBWr_5^&bIpcp&ac!g1?@*5Fl@*p!B5QygiP}%V5jz3>(4Fva +z9%QtyC~wGZK8I45Ba0dT1>Q(QVc>CB+*Ji!o~p38Vs9rl7E;!i!rortp~_z%ve}UkjV!r@mIboX=o6|OL +zu9=KJ1BB_3+GG7gDQ(O$U-Y;TZ_>TKgpr0Cf3csZv(jM}M|WcGP1rYV23+naoK9Dh +z@2pBX5#*YF5-~2kAtkNY(aQo+SS==`G@hTZz5icH8h_VI*jO$g$Gkwv8 +z$~G)$>#Or=C{}SiwCZeHi##2a=Mw-svnuf89!0=PD&F`r1FxMfCx<31 +zG(hHxLcTKIj#I_UME+~Eu4jmu?ep?l8p;CX$K6sP|Dh_}$=%`C|$>PZchIo{^RQeAv-XSI9p-aAK)%||>G1Wb<>29x|3X;T{7UzmQzlIpVnu +zsZkqd)l#?Hmkygcw)1ofH(pv2@XsCVwuhfKKDaTjS2EH30LpG3m9Fp6lXXU$V?)(9 +z-Fq}X^_70E_qsaQT7{XOv&NB7YvWCDVHRIpK}1o|{{J +z-!cY&RJ&K)^qR6{T@U`PzbqR18vm*!mZsM_wNGf9?qX2>RBzY7J8t^!!`5HSb2Cc+ +za;>>rY26k#afQ3f7UNLMFF$IyX0>PSd_3(ai?q7-U+iGG;!LOY8I={iU+U}M>|1iS +zfl9a<5S#Yo2Ty1FM&}(l|1o;cUoL+&%VG7p-0dN|?_}lKea{_Fh<#w>!R`<6&-8di +zvph%Gv2=R4CFJ%?iazNT&P;7zm^pl0J9es}#{%ZNy<1+5K4v=Q!CS*EulAm?t6se0 +zscX1)gTZgHFT!4hLbBMaX|{N_-`<8L(S_}_%;Co6oHw@~CSUY8W+aX(*ywWU!S9f# +zY{L`V3cl=v{^1gfGs%C&GxB3*QJV^X)-ipc_f(y}wd`?`5F!!BhpVa_*?o3|d`YAoIq6YL3vl19tt +zPc=gVZ6G5X(i1CxkNszp)=oRp@};e2T+X+(sqM7GoT1JB!(aL +z&DOYugTY-h8-g1xW6;su$54Hky&1cRpPB$I59|{1?rKesx1QzPL=70IyMgjp1Ea4}+t2=J`gQN-}ysT=uVXSA1vr +zsOuZoK&=A`C7WWf=GZ@6zPuA~575WoGqaV>J;Dk16nCARGM*d8xeAIFA8j +z--vD+#vWWPLbrb@=VX-&DTd|r;UUJis2WEJ2Ce}LSEo^ORq9pSSWem`C5W+!V3-_! +zDdz-R<@JbQmu$o`I{h{c42L=RHN(nOav74VUx?|%Od7GDWTGP<1^von$yKRxB0%Tb +zh<)F;%@!{AA87Y#_344C(^tXio25}f``1Ap6>b0J)p1q$Ct67l_4 +zf)i@aqF&C@r)xw=*@>b|V{%mYvoMx3wn_sZC4TUORQiF}#}KXt;FR7cTj;s^@ftbq +zku!zI#{qhky=}@Wd4Y=k0%3XkE3|rQ>>p+_CJ+xxQJY35CI2DlL5M8GXIj;ZAO@iP +z@+yUQRkrOmJU)$AfY#ptS;isZEtIN09#e4#(|v%MGd#>mX3hY=r2dy*f~lZmdJHg2 +zpcZi%T1|-is_zT1JcVB}7W@)bvkE%xizu#ghdB8LXhgsi7l6jsOt7v|stba3wW#bz +zCm*hZO2J>TOPAn!!Ky<2BbDQfz?}}n!gXGb$S%XPO +zSoDf##oi)LVgHKa(7H7gv?{BIF{`5};d|sGOMlLrAHR+3sF~T`f-Q;FdTRMNaKE(j +z(%FxPJ$&nM-6Ib#1jn8{H|%6(E)IG0^;A%qo!8V}$%ESd2)w*ut7q#8f{S>-+535) +zM$EN2;(>WdoqJfwifu0;JFNqaIk+ML8o4~r%|Y3oYfoO|-i$pY)xn4GCiK3?tgH-k(1JElA?-aN}8 +zqxmCNGnWN$Fa +z;``IuEzf(@wEDO`ExrwAznR$fU_l3T5hPD&8zkK$p3U$pZrpA?H;LXp>TqskQHg2u +zmWVlL>;fj2E&4ed3-VEz&fzZ}A2-&_a#&c5J^w;SE=yzC3rl+< +zFHE}t+w(%=I +z*y+;~Xa#>f-kzNMA^-b|jf$ctsj}qq6o-WeUOmJ-wOS^z+OBvEE)-&60sqXhagsL= +z?P>AqjqjOJpWpsz*^&AmRcrOT7609H#?Jcq2}NPObWVeb)uo!R`$Hc>&A#73TJ&{c +zrrgck1u-R)mJoyT+}&<(mz~<&v2W$Nz<)Z=7q8Em#R#$k3p}`XU0`Nq$$Qu(EGi4? +zlTEuf2fww<{ql0}#imO*luRvieV4~R*_}Ndj_)kKNNR40J#kh%=|Rb+2$v_@q->~K +z8+yDA$*dntf14Or^ENgtyIK@*VF;?%Rtr9V4?T#OKU*AjIjsxfgeLJ{^+!St)DO;x +z{r+3I-%FF>g5ghZ%-V&w`hA?r6&}m|a?iD%zYCTyIOZ|lV4Uw(I`_uhXB=+a)*tUF +z?1Juu+OH+%34UA)lqDQqM8HLY^C5arOYESWa%tbXkb+9@k)I6LM6=By`jp$Qk1m{Nn-adsS?Dhqx>UWabW +zS<$1qehuM#iH{&YRXin;+?U8oFiF;kPv$)`K-Te^Ji1Bp*!cOpBz-bX=F3YmARnz7 +zD@vxJ6fX@)2d!;jXv1U?P9rX|9+jxUug%lbCN7c02y9q-Cdpdyzl&;U^o7>CiTeD~ +zybNvPGD(EMgq2~EtQ)_X_ZZTZ?8rqaxsxqP=H+HOKF6Y~LQ>a`mi*4{?PG6HB>HOW +zU+pAn5`Eo6b5=WPCQjp1PcOSMMHEA8vv<9-l2vP(Q*gJ@N7pAcx~lo~+DVdy?A{sc +zHcaFl*RQR&i%{hJEJ^YIoYeM77ZugjYtxrWoCRhn*nG)ufmv#xon`6QMn_G0fMlcK +zWGZK}Wohr*YZ~;W?g7G!YasC#UHsFpOgC{3-`(oyS}TbqJLb&T8@i(V0JX^mMfR^Y +zLg&r~7ITVapj*>UZF-=4$)W4-G^( +zL}P#<;%+#LvW1nsCpSjwC7SXp=S30{XY!Nl$U4>OqIGqi8r)^nT>`6AYz5U)a5g0h +zaPqEct~NKoJ>U{!pC&$r-lVe!7*V-gAcb#Gt$Xjd0RPYc_Tlp?hA(&?*aiA{6t$J`)_v}vUaa1W8t +zptkSOd!l4M`{u=SV>FU8qpKFC%o!`$%x<(Lj*{uI8*PZAW%~TCe1c~33DM}f3@!3v +z_fvs)HnVaeDNfw^IF$~Zv+AF0jpSpZX?1>Ddc+f +ztSFP5ulBpgi$2rZ0xy2r#f#IgwK4f*$%`|nrN6j)pM}|4Vhi52Ycl=ZPhG!5O659O +zW`socr;;aI)(3sk;t}Az3wP65M3Wp}@ts91Y--i?zNajrY3Qh-alAl%(vieJL==6} +zp~Q(Iib1V^;EwuKvc1es;FN+EQw;=8sVIQDR8W?J=2QO=l%Oc4Mc3lody;H +z3CcRRTN6Jea;&S+LK&iKbKQ78j{S(eZOC%J +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 +z2(jaN9a^FJ(Zz;e0<}XAM;F_EtR+DU8s +zZF#cdV`-M9+k3P0s&x5Kk<|-5E?QJ)s=-(!*&;AVZJKHsDDU(CpYNqbTRQd>jG}t8 +zWAv|5R`Lc7YR_#;exBks*)pS8Vy~AYypg}T6gMT`tN&}tmiL&Y62XB#hgL5~@I}iH5N5S2P2kwu@CYobHf%XlF82600^IW8bTHxK?K?L +z8k^M9jY@75!Cj82UBAdKZ4_@Q#UQFnmahqhQN`C1x! +zKjI-pf)fp6xPLeIlbe$9yD&rxhiy?Am!@ZWxHdq*@kafPk3Peer$!Fz)E|tmiiND^US3|un;>9PPStv%vN_-LU|q0;8==O> +zXFWU^0LU1YlX+#2q1JU&jgVo8`-6cn1zlK2cZ?s9vzCqG)SxB7RnGdNA?UnGZjOc+ +zAZa9mtcCy#dbVWC(S?rkxtG&WGJvLz4hF%Wd<7#go22B=;^#5Y?eZ_ZrJHT;)*_{a@{2;%FqGUJTyf +zlnneawBPuY>;?DV&RIrO&)HajD9XDx=a{?5RS;9EA1Z(G6p +z_Y0PwmXU6~I|LbLZzoewsMQtsH+TZ=kr8|3jO9Jh07l=*M^Gj$ +zLA(XP2UmSW3eS97B@KuH(Ry&3vTFI!d{t;WEnUA_?bFBN4DX +zRjowa8uf7HU{M^->BuO7Hpx@zs7;Ok+f@Vfi8&8@Nyn;!-)zpnom^$zpQD=gr2)ck +zj|kmIh>-p}hh8j4hdnv(U~mgWb!2SZ1D-*PrsHzNf9Eg^baxp!wn+~UgmJHvUGVXj +zyEkDKhmDphf-X%!PCP7o52HlO5$;KU3bIw8v^a{+y8?IwBK~bT8qAn-6ymX=@pzzG +z#2Wwu^)R9XpN;yMR51=WAECPugh9}+Hv2Rlp7i$&NIsfxkdW2M#|p?$L;(Y4K}G$O +zyce2+M=}(_KzG&5kZ_sED-~7+OUPj=)m8C94;Ok2P(XE&-aMwkJP}*1O`IW(tC|xE +zwBGLxZKVaEDBq~;P1IG0{h%k+x&o(*x}U(RXCtdXJ5gYIi!(s36v(H*6Ubsg!tyej +z2SD!y%LnNwU9gEoRm;F8nkn(2cm#<~tmif6dl~((u(n@SgO(Yg4s}Gn7UDvu3~(ys +z1>}5Jh{l3O;=(dO2nn9VGSNwWe`w%)Hy-DxHNy?iLKTp`W)C38-OpFURUWG^d80QK +zb2f(1Z`Nk1a245ir +zeUDhCCM{!!e0YZqqG*X^(G;57;$#i#N;Y{u?k(C%bDN($mb#Z+WJ@09rNeK?BkGnM +z6Sdc28YM?WBmwr^1Y)W+B_cxzx +z$U0uy{2%#r-I9D!U_Sl-G&e&H7j&c!o3`i->G0MY2#?5YMZ0KmzR3m>JzAV!@ +zcEV()mX{viJD;Lca$FQz$I#>~a<8u2(UjUTRW?)be>pazHyIg7GH8T_$poqmThE3` +z@JbQY)DblZQ!KfQ?qskI>JyL1OhlX588&DlRiFPjpR8-WOrkFcOvy0u88<{?JvJbw +z%Yt|&wA{tGVqT_pG8#iQVb|IsE9zhDS{tNIb!FGuVY*fBeA7G#rcL;!`Am(_G||#J +ziWX_9WUGLYQec~C*r#y!6CL}=sRdJIMgmNe- +z(`t=)FWzi@N~V{O=nRdtphSb}%r>_R)UTSu_s?^H(HPOCI#X?izhs7BX-bn_qDS9F +zR<~)jR{RX!7=6lNFAvcn8e>6;7S)a&WEW^q<;suDD^*OyMCO<3w$McT>KZkomPrl> +zgql%{B|&wKT2TQKUBUlj7UuuHQ2sf8SR0)XMdgL-w4{ox>TYWamq;q=$Qmt&qpR*z +zQug!CLOsoR_$y4pL|6TGl@h?)2!HrZ`c}&=7I-Yp<@B8)^xC-2-lRifu&Iw6^~ulhaegP*~mCXQY99 +z@ZHyBQ4}@vw%?4C=d<+2=9KOq)`7CQdr4oHxmMy>KGm_1qNtp={b8HDnUyg%$G29_ +zP9@k|W}J{N(jYE&H=f<^G&<3p?>_1&LtkV9)yBqT#gvRCcB{`xH}Nq{oEd&?LU174UxEn{J_eQK_qY(}4=dY-H^RLgQ0n`{;z!80{r9;zBGT1un% +zg^rhOWk*dW=_MNS-SP|cd`^mj>zp)Dn&@+#lNNok#7b~7CD1|U()WTDJ{C9ab7X~& +zOD4px;oa6}=2lG-eWa1+g(?c>L|cYtq6Yedr>Gx^4~1 +zJPE0;TZ^(p!l>)kq%4%I5)7u2rpnv|V^T;qvN*w*RFb`nAjnQ3*~upMDQe`n<&Xm_ +zXl%~DG0dr~pmF%P_*J|zeJs6dqUarsxwyqrGKq~AwrEKVd+SkPm5AklUZ>ucu)6X)!|G7I*@V%Vc^HnodbAfL1 +z(il!$#4bDAbxR^Hqd&?Y1^aE9_fOs?+1j6ld!U6hZ>DAJ{^NtAbc}|_t^6aJyngki77o-v&& +z*wN+c;QFOQBPQ72HQe|MeLu#JIcJv|N&5fZD^*Q`MH+vtn3tF{v +z>c@gjF_ZyeV|npFyqSxSb=v_U*N~GjeKTbzzq-mKhxyvvmRSt4L5$1noI9tzlGgFB +zsL+;4)8zPyJr;a_C`o-~mfKF#AO5}HZdm03w@d1IjcHqk#$4vo}O`9=p?8_D|koJwL_-Q2V%4V{C&O)F}0CA25DC1u+2Em@BoP9+S*KFFEe8=tFl +zZrM#*vSal<&eNpb%W}>KmVvhQ8f>SeWE8ZR-8u|Ha;WM>Uyz0mCZ0Vue)}QE9Rw +ztfC?oij=Id$|6k{Dbk`MT{;p%No;_M6hXR>RTPvK0U`9LNCzVzgdTxFgb)G=A*4Rv +z1jYB9@4WxN|NJ<5GH0Hdd+*%ow@vU9*y2Dfl}_)D-26L6Y~?JlD4YI=kQ|vVWeDP` +zv|R6uWbOdrRDvFnTGYCMMRJ8K?5|p{%{mid3q}Qn3c%VK1Ff9twT8FuAjvKoVOKu?36l5WLL?h!}|7=_txj>w|JK=B#-iRMsnhAKEH8dV5}GSY>IzX +ze-OX>()_Uz`ktLw{;4Xc!1x2h;hB?P@mY?xKi-WTUN|$8cg~?u8+;bRK +z5$M?z_okt}+{*UQCbkvIzo-XQrKm-EeO`7ScA|77CF_F^yWyo;OU!b3zuap*g?Za} +z_A7=*6&>;HLf@W5__dx_1y18ajP?AbVsW-xv$2G!p5t8iE&&f7hTr%x;?DBn3mS7VgLZ;ar4b7KWI +z3Suc?U&6&`M)NHh>El=Rwfxy|Z+QgVb!_bn#{O +zz=ZgA!kMuL3huJ*cUbaj_%f3n;J7{7cU_De2g2^ps8x|_eV6liOOs50WUpzWR`Ix& +zx$0lF+yfz}OvRDCM?Jc1-!W>_{?%095<$Cf*wwg?4kE+Z7v1Ag{N}whew~-pAIo#~ +zt1@S|)TPq);Rk2yi#NU(u;W#|t)zUz$2isIs#Ua{eOAN6{^3m2bY;-j%JG5Em0efB +z6Vbt5wOi-mpN?1fz&zl>p`^n>D|-P}pPR*+WzUmc~479W#}Jy*_u` +z46Pst%QMxj!swCzP21_OTV*A +zL96?1&g)z1qbmq(k3U`*MaBrWv191+pWWA!qjuSiQhqP;V+rWIyk7mcv!DHRM-(If +z@P&W?RMRMTeZcKnx70nCHVkpxC3ic@g!X01Z?wHV{F;rCoEPJ;^DgaXoV3|&%ib0q +z{h|+p$vQ15FF{kN&on4{+z=@{2}{zIgSwM+gf8|o%o*$5Q0Ze0VPotf?2H=)y77hF +z4C&0RSWbOLtAQK6j)L2T_mIj~C~Z~olMR)(i3@)?G?t6W90xvjCsq&7z+j{ch|$KL +zL7HaJpzd5da8*3AONd0|sFbxN+0KjXPeS2fXg^ +zl?&)qX&DG40ta$OP2k^nLg0std=LK>8vcGA2b6;A%c{5H61sHcbrJC81J{?#)hjX+ +zT?wjz&=xTLAkGa1Ytq3oYEb +zT@5V6<=1W$B5@yZ%1fESFNX^P0lKs(DC@^vw-!j1-WWlnRU}B^ODE9Gj;>wgeSx6{ +zkn|w(ApN*=Wb5~k!d3|POh7e0;x$sNtqF&bdit^sr$xV>r4Vb&dIEwbb{kK= +z&?J)f%1{0ok8hMR9i1%7Z4Q1o+)eOCz=?WZ+g_X$YN?mx#!^Q^%>tfW*JCpt?Uj!? +zEOG0j)CMQ+gWdGzix0(&@^|yjv(L&E6}@bH`u9@RFZW##i)2gUpWO7O@n>8eMhWcX +z>FLXQzM&h+yp^3|w9Twx(3l`1RI9{RuKa$oMpf$LoA(<}IdQAI=EIt5OW#a9ZjzdG +zO8KS%oOVWBPHiok?|re)1D+2j(fnpo4H7@1;0@|UFeon!B}lk1=>!3hyGwjO-X0L!S(O&k6S;%1<3XKo_B7pqq%y0cs&I|n +zfsCw?m>H2^+YP~}3ay5`YgM6+3oq=66hoL426}x=HTiRXlh1ftU5VI-fF1hd_mt+T +zD)qWr=azixJ_%Kpj05zJTkQLKdcPj-UW=<)-Z(1aBDQ*Bv6pZek)20PY_^>ITfSsv +zDIk`zyK2|9PnXAa_WN#9o%Kh`wLHBCAhZxGb_d08X|aqL`}$F>Wch>eKIP7Czh|a1VH-XYA3RTI +z-cy*|S4y9FAzgCj1JiCU%~K=4UFqNFR@i$i2ZAd$yg5GWxPI}JxMk0y +z2k93K{`ITVGov4AOX%9&0PmO&s}aQRXmfEzj2h&)UfK|PDi&W)dG))07Vg92i>%u+ +zT<)h=Uj954r`hhU;~~y9yIk_Pu886Yu3P8dRe0>j_)=@uVs9ZY-c*w2{BrD=@6p5P +z-|GTKwtaOdP*lY2@D+FVK8ZTGP!Is^fo&K{kucL$QX|77P@aa4cEY^b!p)=O%M3q^ +znVc9>S`C+xE}rUMRS|g&-Ad|RqJ6yPpLG?gG4Z=v4NrEo61&3rYU+vi*v>Y#z^|Ou +zv>Thvx9zq45cUxL6y^5Yh~{B?H@9ENEKbc>C($1tT=wgU1nQ(f96H7f5};}im1i~z +z7_YNFg_R`O`VC#P(W^ou$9o2mSCJl5`Qfxk0zdG+PtSt6uj*SxeW +z$f4+YNi$+^7hZxtXA1o)eMP_4YuWySm@kgxfV;9`0sb%Ma-tQC@bzQ)uiI}~E)Q3} +z(HY4rjJz_w9fZKFB*qRk3ZDPkd}L-L&dO@UnXxW(a9cnss(@FJ=Hdze%B1#P9@^c{ +zJY3b(qf|qZ3_Dz$kA>Zs?+Nzj{oyj^dVsY^sntE4wV76v=3IMY8`(OW)x;?CN85g? +zQp@K#;nv)Kb|E5g)U+lnMyMBxZJh0UXDV0qhU?&gLs2*t +zSzl380h{~vqo#0Kns)5nLkP!OAEzUu4w+t5tuw$K3{yl}Pp$q&nknQZ62T+T>_$Q1 +zUBnITZAkXH1B0R4`k6P{T4ZJ3G2UtRY3B4PB8rEyKD`$_muC9-O5zf5QzV8G*)QX_ +zs+W64EJG1X{i9rFKyNWtx6xOp@S{O_B~_( +zHj&kBJPsP9h(WHap6H6Y6X(}U^XcwC6mx?>lr0VRxh{REu;T%6SA$&{hd|UHk+;tx +zOdM=kWguox015K*2EJ$z&|U$p%SYe|#|BCs5G~1Igo$<&KD!4b>O%UemO&N@0s>EO +zAaP6671HD3{{h$ZHKn5*P&%HL5U^din3TnrJB5-!gufc$3TQGL0YIRZBV-7z5S{Yi +zJfZk~?*}>eq&vG<$DcdWN|!vP+4{?1Lf0;kDP`bcEMjv=le_BFU_9XycGj#I@X#WpA +zc$p{c`S8+`st_W0bSR-hEhS2mWA1Hs^kMN-%fxZyn+`3JevHKO0S<{1T1z&)G +zz0?e9(VRO3ob+RN2{CpeZ#ock$!X~})GZ-MaN#OCh6e2ce%wG?0~i7V02~GC8g1Zx +zE(-2Yjs>bFbe4uf} +z{y0F{0%eWJDZGk;rjZd* +z%&XGM`@kvNX)A>Op%fiu-G(Y81O)OY$e9PG1$s^Ag#zFEti$VKhWj1~0e%maTg|f>a|8idHj%<+AH$1XFOZDk@C-Y-V58xNLlX<-!&! +z+TbPdf%?q%m*0P{<ztY41Q7RJ3fvUsbmiM8}X=h=i%x%p{m +zu){>q8HfK=S6mU1hxOne?|M7N=)fY60=Mp3vGnpNa5@S=&9tZY0?*}%p!ReoGUkl} +z2*CP9>Y6KpJ^l)~Wh*SbpO?4X<$Phl{o=PXBmH(0jLQ~6^I^RZ2+t@RVkV-kDI!yW82SRpR)?=*`OB +zdI!Sgn!>i<10OYY?5kpYL-&X(v)NK +z!Qf&xE~T63dVYDL+S8(BARRc1-rMV<#5rM*R{6_{ruxQB3XlA`N(VGSZs +zS;W(RMUwkS*v6N3UE`?6I)Y2r-KkT!FR}W+_*&&;?$uR%JDgl-{q#yzG29>d6dc=J +zN83VOS)7q9i3jlQzNFC`&!Xw +zvizmV(w3L@T@11tJ7ksix65s<61++`P!VX&CRW85Bt-18O|oPOay0juNLGy+Xjt|L +z{dqGFOxw=A6Ha5(_iF4l&eowoc?lH`<{1FW9>O! +z>&Y-$n6kBjouA-n+P}rOc$3LR=8-atEd*>%<<^mApMHHB($1ioR{a)!rgr$j{0seD +z0*`c5&uLdxG2iNS@bGQ6r>^#>a}{eV|Inymt73%z1+JHWc*QsBlJPBQ>;y7eaa>dH +za?`dGw^apS|BWsLmVpoR_Mq?bI?yILGpYlq2Rk+&hpji@2D3ZWzY3T6CS`R|g!!2b +zdDoGJ>U3Uss%8zr9EMkv9C~SHaI6sJ6eaAia_^;N6AYO3H@JGx=3#~Qkaekqf}4M2 +zq4e+MR3u0K2dC^qB)wHM`$DN!e8afAuZtutRQ6r|!=Ja@-!ce`cEFco%b?eE($ZU< +zL+=F>3CUB3x3bZ6yZw|+Rondn_fez=Pc@t3bAw6LgRZ|AH%^vO*LDXLd?EtD#4->_?j>Qtt7MS8??RQa%n +z)JTc^N!Y8MRAB9NpJ_+dg^B=A`hyil%E81Ww)=ta{k3uEyJ_(v3=hmYcEku}Gz6IT +zOD}+tFnZ1Ui_<4AOwe7zr|Uv~!gdgp3VIy{5m$G05Rd?Dej<%05O_l5_v3|7Jvf671GoGMp)lyh4G`iNe_iwtOQOiq0$2<{$wp9NH4(kp>kIIF +z!5-#AKa~IMhcj?Y?DD9cd4SpYvCcik-2tSDDtmM%=X|cqsV0rPQ^)d;I9cA;US3x0 +zH2FJlgJDxZs_8Mx=24p}?dFJIrj>UzN5{HcPMg_m9%x>Co~?R8&Q2B?cN9%@FF{Nm +zd^!H1Z3#9WtUIyJllCNBe$Yv_?evRhxzZ!NLwarj`#TmEPv-IV9+vnRk}&)zWwg&; +zyI~^w5yjE->fuUl=jDQ&&#p{P_=g}vxmTxuBU)Y54!QQpM=wP6wd#!Ht;(vL8S=m{ +zv6A(-gsKV0LTnwulYUph&8&W=;l9|5iWgPco3HDhnMfpqfELGUBmz1MsV{`8Uj={c +ziCP?)&|dCZNmuP=-B2VCq?eC^zl#WhnAjEe-q!}-4-Bk`#N{s;tKoY)5#Bu +zGQ8{Foyb3z4g{bVi{GF6Yd|qT-}6|$O4nlxO@9Ic%c=dhds4OjTv2z>{K-sGnq1bp +zi+6=+Tb*%^nt`J4x6QiTF}w5qJN^ivKIdZC9%w1T0srEbmU4`OjAv)){?5x5`VS{7 +zVyS5E))w;+}XnB2YMkN>?dl{ +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 +zY>{u^VYbd>(6GU`k6mz<(o1SzE{#Bk1=AhCxJ +zydijn?Q1Z`#?s^SI38YXQmQKLn=BoH)Ciyn3fZF#$hv?P<+n@-JLA=#-Vo6AqJoJj +z_;vv(c4sJ%^$^DvJ^Y>(jy1`|*Eewa=I3=G^~-oFvpYTOu%A7?kX_i1nGO+3RiiA2 +z0(p0S071hQKX()Gcd2Y>jtLzi%3Pv;BBJFxY`t+dpnpD{gu{=SA4eM>4dM(mKRq># +zwa0~T|2CRyix=v1muI>QEit!q5pi2$<}AOQh?-_UOBH{4 +zbFBJPOl27uptg_v5U^4zhd3w<4lJU;UuL5#j?53xzkD|FxGCRHDX0j+?chC9IJFt= +z_y~iYMdVgzLo!Y>{T_a&y%|`ffzTUYEZ +zxHZ$-+$^^q&04W8!Ds5nN&wRK*C9{o!V~ +z;zb|bBr3LNvMK~y>-7ljxJaT+>DI{UE`&2-PVqr4AaYpTM|{mE^J$beG~8snr5=9Ag? +zsIilb%k#|3K72|n7wJ*wchiY}$D9t^Oq79$JPNXH^_prS%enD-^A5XJ^}NVV33p$kCq% +zL`c=vkOtywo_4#SpzL(mB0x=Aek0|eK726 +zOLy>5PxANy +zX$qWomm98J0;BTX6R+88S8iUxEUSvP;kT(V?hk3Q6G+j3{f`yVEkI^P9y8Cyywi+> +z2yzgqBH+C(uF@OV@G$VhSy1Md$!G0pA?vXs4L^3ybOhm6%3zm}Jo~MP=!p-uGU-&B +zjGJ1*;4E8m8}jS?)bxNGE}Wz*$kjs7*cSsjrg&qa?{7w?!2>FrL-+b@l4uC3E>&~% +zpTaITTwghiK0SZi#l~rNY*KxWu@IehBQzwfD-F-EZ4uDEc2wehVSuI-qv?huF6fD5+An_k(ih5Y{IefY`tYo<553u7p8PC-ZzZn&$v61ev@QLz1 +zRc5g0R3-X@iXDdI_|4LBm5>wy{?VdID*(+lsZDcpb$r^Ofw4ri%u^h?h>y-Las(z> +z6qk=jjY4EKBbGitrb#H0(1w$d?1OvRrB4?G5&7|SxW1*;bv8l37sPBE#XE;A-R6Cv +zpRRV`4>$83sqLkKjh@Np(u0J3287p>z!-B%N(UYEyOl8VQ{haZN*)Tm*yfKP@th3J +zkDbgK04oED5>d0F7rDAm&mYu%NrF{pV!fWby;6loMy4ypBbv1v9ymE$aRtflj|eCF +zk{@K@eVd-3Aueo8^1!f-xqsz#3Va>c>znj +zHKrfNqLOm`FbehDr9IkV#K@s&YvRUEd7(g?pOv2zJhxIaB$IL4z?L!DK6UQVP(`=Q +z)!~KTUQA8AnOfd^JZ$B@AbEa^Y;SDM2 +zKMU(w+nCGM0mQG4^hc{80c?rCTLCX=8BV{5>8}^3!5xNQvdRf@n +zYHtw-sQ;RADB=a20u{I0VT`^6ahdy*PRHW?R@ZRUmG>)k7giZn=_7A|A1qAwNOpY;_Pgp(ie^X9$X-K@ICVHTLeWBLZ_HkK;B!UEFRL4n@t +z8hpgrvVj{Cxu`vMU}8lj1Zh4);iTRtnD&c0W>)L!c^JXA%l77&&uh^XrZ^mGfO-}q +zRYR&RLiEr=q%BxgT<My&F=JCV++oLL= +ztzRc34A;-F`X~ncGu*I*ym8{m?IO(fExg{heQ8emlLJ`^nO>O$rsOr0kCg=YWTs=_ +z9VXh?>@JoJ}TrUs27zO3&&H99~GB)JB7t| +zV2a1Qa90~+mOqWv(q>up4+~=Nc)Arvv)iI^6&eG&d&ab6$3j?3_ph&P8C<9=e8x73 +zW_Lv6oXqR|jz=`z2p#UL+MhfwC?EH+O^ZJtE!i548_o6#j$C=m8m|v?`*l`ka6V0f +zp0XVaAF4&4)`QLEQa_xTS%_F~JHUP~%IR0X37rvD53-SjnMJcdrNR4B&IJ4evQXA(M3!)mfntt2o=ZC{VID*2 +zz@ow*H1>>h7=@(i@dW^yKkM{D@v#IU4K7&z)i|$_Ib};1La$c8jB*sSMPKT5`7TN0 +zk&G!~ahSHIJOCGlTWEQ?S~gFx^1bX!OyX);S*BF42tGm#^{(CIUt+q-* +z!V1hp)Sxk5%OGF`hgG8RX*I)=e6p3aU2X9hmcO~EtgMYBag`?*SqoXBvYI6ds4Nj!mA=NCBCtO8`i>Y;hFf3b +z_EkJQYL$kl8Al3YvXaIHfNWRRLanHBWr2dPg@|hE?0D*G#%l#%(SYz9o*ieeLbKI> +zv^qj+emx)HAfkW->Z~>_W_CPYRHwm7e5t#Bsa+Quqg8#*RsL-CZR+JOTOYRmksou{;82 +z!;Pf}td=6PhTmj~`mm=dZ8FyzcMg{(+ +z(Ium$9F!PUOGW;nmaP7@-X%j7WEd*!=+H|^^*nvy0q(=WoKNlK4kXELIs<@zDl1sg +z%SvfWW4^MRu3pX1HxcN7$`rx13<{_mI0j2aDv2`aO~)qz0f7elQjr>>3^A9Cw4USU +z;wQzMj;p)7GN$+fyXlnYL$|%30D$kC(8K64?)1sw%8j^)g$2ueQ-+TV%DXk+l0myB +z+ +zQpj;Rr3%|PBPL@5FZ6$BAd~7!_wZa=DdvpkJnDENA&nf@)wf>>18bAbdSz@hb_)Ey +zghfT%R`$E`P+=?Q4yef2Q(#1aifzb0$fMvl19_ahRTb&d%ed4kW5Q^jCeI|QXOiR0 +zTTdv_a{$2RawYg-0O%pbupu-_OH&dp!PyA_DT7FQ2a*8=p-N=a1IWoj*io{nDsqx4 +zyw;iq0NL_iCaPzVCBw{nksvr6FiP%)KYBOJu +zh|M9ZHu3K!N}4egoA`~1*vDj8JjYlGexl7Xp3|ZPS8KC;z`+|fgd}11GSM*+*~+jZ +z)0le^qslP-X=pPi%mj6=6SkehH9@&`!nSfYnxJeP9Cs;^jpOjA6$)F|id(sJe8MI`*oLF_;D87RU +z3fZX}6A_~fAv@hci0)+m!*s-EPP~aQHl3irpeu7yG%)+gx(7JwE(Y$c;s-d^8W=UQ +zt||w6%>dCV4t`w>EL#yKj6xR!zgC1f!~2>6yfsFdQ=x%@k&Tl1S{n4djL{@MP6NJ= +zT&v2tsR2Jm4p-)|G~j=d84>cyL^8iQU0sf$pUlroSKrAPHxbsRtM6shC-JA# +z5t5uS6O?JE%vR2QW&Ek>*q8{6G8EaFwu#eVVxT!~8Xa*xiL{IP($L^gn_mK_M@cc8 +zjQALlkw{M?Bbp-y6X_W6N(v`X335&%Ni!9cVEfwW@f?N{>{uK90g{lY_=L=EuCr~$ +zW612LIz+3a1%u}@rb>qW!w|nVrbULCF~nUO3|l2l7%|tz)X6SM`~(fS202EB)2KmL +zWPoNoPM6%o0c3l0+HT?OFcIdbW91n8lli6T*qw~rB>rMLb}u70ng1XiyNdzpx20nh +z7%s{D*XfemH~}WY;7;Nu&Z3FXtdqEnv)M#=qm#IW^T0&t*h!S&fCuL(=~yX-;sFj* +z0}kl1V8~o+aBj7ChnkNzPa0sA-V2$?nRW +zLJg8K*twB0Tc0a(OYLE_-VI~Z%YYoU&f&~NrF(Nh*lT7w&j_63lWRcNv92+Ib +zGYK!vEH*+pC*kFpK87e%5_DvGIGTS)84B;jZRJFn2rW8slAN<9!i03R8X0EFK)5s* +zwW?b%(9Qf|CA@MQDV7tjgg@CvO5h+2QJ0fi4Cw9IhA3nbdN=co5(IvKXJ#9r&L*Md +znD3RKvq_NJbnQKUyE266L~Q4%C-aljB{y@dO@x?q$?Y6$62CW{zKgLkJmhA`va2|* +zL-~BEdnaP(p|58~UUKzf%o~ICm^9CVV-I!HDmM2G9?fX5>^12vU5q>(Xi>PIBB2|I +zdKGk9-#le^fOwJJiG#hho_Ybfwxr#`n0Go^=ohY;hyJFDp90GlPmaN~4ruw$h;mT% +z5@HEESKisu9kTB@?Z%1gRCA%u$Lw!I_hz+KF2%6fH!{e-#>e+|KMuml>!3Nl%g!8% +z9V~QPVRylxdv=1V@J;l7OmH>Xb>jU+L6FB=`8MJw`^ZrGQeF^~U>FriKpkM_))bdaU#Q=hCe%EA}(-fXA8hPGTw@R4@(pazb-oV%dx*x8c-$d-r1>xMoh>_+L7<;Q&25 +z@ODTCnUowgvEUb|n`Lh4{LJyFYz*SM!_)YDOJ`$;WlyY`P!}$7zfrf$oY0c2jyW}? +zmQ385>fJmp&+%z(NyZb;(Nfyb^p3dUBgsHOAHCl=vgeWtCMRq%@r@G?zv7V6Wjprj +zm7FxCa6jICFqF}3G$jnsLuN$i5Y^I9+8&&E{!zC{;5pi^(f7_>mxXb}XU~MQx~TLH +z=H!xD35hsYpV{BYZ5vfXH<%lv?v^i-w;$->wspt)jd}(OEZpfST3Zg&6R1JPs1EQk +zuA`m1xxCEbqF_v2=QfGgFwXpzEN@C~Sfd0IKvuvAH4z{ETgODlE0ql;kjq=q@odQqN#@b;RXSg)|PkOwb#V_2poy +zj^40)Cr-d@IS%`@EY9?yC6#v0fPqw>8teM06XdY%4N`T~)RLj-rAMwPa2CZ;)jl4# +zb>(?*PGV&{MzU#AQ@tY|ua@j8F-evL3QY`*Il7SxPwVEg?o%i)TNc(ERYn?*Xqc78 +zL?Ws~AJ1uNDq0RBiXBSLY*aAV$}Jz}LDSeLNKgS;R!2LT +zw-4JgGpKT;H~8r#D6Z;tuj;UyD}&8-kR$x}qH~KmHKP9bezK9#LO-SD3x@){+42y* +zn+M-Q|1Gw3al)M6+U9w}!~3=C_76Y2p=Zt;$_ArXJ^3gtwJjeR59S1>`)NR^ai!B> +zXyzwOus7ChEVS0~4+#igwcU(TXz8qFRk9n*6WxqBReV*6BewpyIgb^0?xpbg?MuCjzNEaHxnt=wQ+}AVl(qz=_R5V$qbkFGaIiQ> +z1yA|(z01N>1qKQX+~|F8fVMyr^^|6G^SO6 +zUNV(^8jS@#7kBoYBkylxRPXmfGPN`BWb!_e1lB4GwdnR6s%S2KA%fI%0=1lWEK+NZ +z&vjS4M>n~(nj^D(I +zGckzlWN+q}n-~~%vbS^SNqRQ8wEae?pd`ZY%!^9+18pvS;X0=Q6Ol!}>g=r?Iyf7S +z{mGW(3@9h$pKPZ`@hd?>qg~7p6`n-c#S}9_87H+^?VUQKgg?>dp1@%n31dJBt@gV{ +zDBIO9l7=WmQj5xlDM=%gWfDQ2X=I4qQ^n=yWML0xK9v|tQef2MbuoS=-vr7KD?jFThA(-mbI +zumhYwG{Eg4;Q;c+`~?L?MoV&Cc&Ftij+BW)mcbL%Xnvb=LYI7dvZ3%&QcJJlRDz)} +z7|?fSD#1u-mZUDtOg0kUNK%()S{Vu*lhmb{Rz^aKa)P;9d#|A|0#q@bno&Y4wYi*# +zWjsnuFlB@myw*EGR#!pl)nCeyW~3$6*><9LGSZUk5S;`GjvB!0`-F0j-=|EMWd<1u +z?EyBMDN7?^SQ0yygH%HA2aPRc@Drf}ZM+u#okV;FxisS+A*;3U +z-IdU~ZMF|MO-hhM5_T`s)KJIFWjOl4aq=ka&*1k|kH{ +zka!D!EKyakKBe{}zhN~|3j2>CTum8W6aKYY%er&w?rP~t*N0O^qLkMqtu*wuH5wEp +zR#WP?)fB(eum0;{#h1%OS3^ +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 +zvlQnp=w6w|)SQnyq3BxXZf*#H +zV?L|j*az>BCt&?vJ#2s5Ab3=%$>%*}^k0@u8otZb-$I_S)wI^YeBCOznvdH>kS +zgL6Z_!jb!jf7+Anrek)!~td{!$;bO +z3+ti1tM2&XwN(S#!K(an+wRd+N(@G!)|thuM +zcO7dFUJI@D`-c@>eyikiHw(w>mSG>gcs~13OJKGjgT-c?L+?s1>X$f{P4VTB+%#B`KYM8QR|Q(;*So#&`$M5U`ueaE +z|1YU@%-dtEw9|I**o?PJsv?H&d)6VS(%fzKDOc-uU`%@#X2jIK$lXATuu_I%UdJ +zcUf!~5hWg4cY9(TKMgg@nqC>J=fG7@7V>aIv?MH}fX3RLWVwONCndayl1H*yF6ACh +zd8E)1%=a1Dug>H#ZU7)#697})x8uTgQ0+Bj0w;fm1@4aSsrY*Htckr&+`6$J2OhSq +z&q~Upv2Kso=~N2H7Kp0v4avhwFN-<%!o~3Pz1T+=S9Mt^xUNYRAvO<1$f>xH2j92P +z3<5AYSO!<0p{Tt7G1HSXXy5=l`~bz68yD^_#MREcRN0U@o_@l +zT&cIA{$R&Pn3k?EpGv~3e2qyu>u^S{d=}nGo0rIWoIcfMvDGX>TYj*41_0#wY{Ins+cu177o>kJF=ye9q=--1 +z2a_i5!Sl^!2jq$TE1B!X0%Hg1GQZHTpkHJYVc0_Vl5F-4mpq9njLSHZL&b_KBK7<9 +zli}X*4AH@nC2+}8udLs%zw-^C6-7_W@rZnb8>JaWIqcoLaO(%zq&pIkb7Bkk#H3m~ +zBDp>BWLmRQqR{rZdmFUGA7l?2l6thi>?dll-J>I7{4@4>KwiC@U#laEyFegD~BqA+?E>$n3YrkoZhzgIZSW1>HOz +zrBi_6jYK(G!vtJ^aOH;=*YZDwHu1WoN&R;@FyXEFbi$W@!2X{eME747_p0HNs?am5 +zn=iRh@8I$<5)cI_zs{q*{X{&e#cq+O$D$l`Bn37+u!Af4NEusHP$_)aioI*l{g7H` +zrxW?^CO?yY{lLl-3;z<1y)ZFRIGPIVgR8Gv+A%r{v~l^d5e=I<-qocd=!U|FLpSZb +zg}R$736wHid1w}|{cOWN^;{}IG3ee-RJzPGw!M^ur@(`X#Q3x$AsCIc7Y`|Qhz=bT@JtkL#w +z5;M+pFOD(HPV%$qjJNg&O+igf^MeSu_cmBn%Pa1`NOjsAg(`8p108!l5uPKG1oI}qYq8}E1{<`q@6ocbvootJe`dp!;kT!f21*3(7mZ+Fe`#OagD#T^o!?i4|6tSd +zYp+ggf2O>@H4J$==5t~S{O)ObuCvTyTr|(Dn!6uc^;MENmvMMyF_W&)KXa~q{mJD_ +zGdb>bn(n?SSN7sg)9C}hlcnJD$xAKTsXG8^VPZde5J>f2xgGAWW;TV;LRNd*gDnV+ +z$h;{!>khAV8_`A&)v$=B_z-Qg=ay@)h{LRWlC=3u0D)Q#=D8iWYucC5Z!wP7S60{% +zGKLieOY7CQmb3~#)|>T7`ux3=v5>*x1BWaeUgbOsVO>G9q&Rn;Jb-SbXzKD$=4|iz +z$$b#jG7poQbzc9B>s{CNy44IXmcy2_n|3mn_w`O&)Wd6%+3)^zcgTjh3lp?Rzj4|b +zKe=5;SoJ-o>NU$B5M3|huEuMipY;;~0x?}s{prjk_8G4eVI4=>KUkSX{rvg8?5WwT +z(!a)R7X311d!8yB&2%st9oqw +z@A_~IPejG)FMBr|0Ajc9`83FblG^l$yf%OJaSbk=Mb{FwenN*#*y?>eicOZAEZ%J_!GjEfJj6AXd!C{%E0 +zQ%N!I3nJq1(yYj#m1DK|2*GU$=$UUi-OP`2gr{FYt~|QGP0mf1uBa3RCG`=DS;z9| +z$}*KU^^52A?JrU><@$64te=m +z;Y5|29V}+Xbv==ht(>sbZ6zCtR%9+r)@meQ5j)2nMm`3fs?NxNcXox~52-XgcK(v$ +zQSwf2EW#CNx@t3T%{t4%NP*7TNCEw{PIFe^?+Z&d8NcyN6n~&Jw0=ti#|2Brb(&p- +zUA|taChU&dbF6(}Nlx@+Amv@*ksrn7VVN{C-56zeRHvDE=(F`GuPuRQx*OGz&jFm` +zR-+bcMmCDg;#Uma_cvG!S0RnxE`3-QFI_yIF+NI?WC6crN<2kyhIl(zpx$;CO4S|MoIFRyPjOB7VjFYrd$Yebc3PPf|e&PX2Gk +zS>TRZzJB>qYQfqzSS4r=qGLxTbI;TJ7Uz|^Ukg>+Yg}p@8+VVGidQ;TpnFhfOx^W{ +zyUEnJG~dWvm+G*ThI*CVd?xs-?r7{SYzeq@nueoY>J*I{F@14tPD&S!+=zO`^?~=h +z#^XQf;|baeb($+odevLcgmV-Jo; +zbmO>x_;;k8(rHR-4@Q@cF|1y1n)gWY!Sl|~bjEgbX2t(nkUnL4t^Bd*nQAg-tnbX} +zFzB{pYOpZGMN(^JhlppS5jb2<8U<(dpeK-!*o15az;6%su3EiKS!TMHZi!B7kJy^K +z^rjiMTF+`^+-nB5d#Im{H*243N}?4dTc0WpmrSgdG~1(}FwzT-hLeqo$2|Gm=gND! +zsZ5rBI`Yo=Z={LiBRJ9$IZfWmF}vP##sojfG89v_FCCg^jFFt0rMBj&LWy${wWS&G +zchy&&6t8RB24hZ+GBNFUjwY*Hl`t-7h?WHDy=n^+lnp^#-c=FSqRBb1XD0`%YzIz?k6L48?X^tR?4(V;o}-}hp6r3eJ*a+z)#x0^3pZH% +zG;=fIx}S|!7MOR?XT#|;aMO~)Z^Z$Q?r3(1%YD5qEPO@bc8?}H5w5#_%*tPXx7qI5 +zHyCSNV=^M+X|cJV4!xJLY+VhH9zn|C<4EGYu?sGAUOJa%ubh`}HBR_K3?&doY#H-j +z>>M2CVz$SH6>`nEBTtvkQ!b1eR3VU$L2IMQ!>Se9Uk&^6=_xs|>1#G5@))YsRy}TQ +zPG%Vv6gJIj3tx)@>6PZ#C!@4R2mVfBUv2R9mN6R(xleA)i2b{sdauHazWwx!OGwOx +zmHm2xhJ)>CMgWhT9=d8<K%h +zIp6p*1^Uo@f(SE7F-%pm#Izu7HVg=ws4Em`YP@A=422^yAvKnx)%`MUD1tBXQ7vi< +z_(TF9XKx)x?&8&&TE`;mloND$q|{?-YY)ea6)6sC>``ChJzbrm=E|(NmSohJf#MJ$ +zU7s7RTP=0F+gSKZC!F5wW2IOwGPRB2TYHQc6CL)uJo7|T7}h~q+!kwsYcBJ}vL47Q +ziWi4fLs5nk)A^*Pu+{7sL9U76{k&Ue3YYF^Ui*InVk`ds`&)s(75H0$zZLjffxi{_ +zf2Bap0r)>mk2do--Q)MC0}Czpo-=n#IpUsk@H}T>y5?*ii6~H{k1$JLO*@}sR{v!m +z8eF82)>|UF3m)#@N`DFwhU-R{2ic0vDh6=B;33S8$S^_B*DzaQ1OX&OW!>5!ueAia +z3swU?&|i~NS5eJt(3PQMy7#1&+hyEj@%&g7l8pY4VFSN}YfQXl{cb7kNHXb8qITBd +zHDP7PG$ZlHb650CpO!Sg=r9P2+OtYsa1?qrC2B?H(s!$IoeVdpCk(588D+u-)fN_JyU%>Jswj;@~nijEwVwGXkOlx;!PwM1XOHUSM|885nLk)1ZSQHO(p8gbx{pM!y1-6^WZ}U +z`<#Y}{Z$ZJ*BGXr{L=fk#5Tx0%j>-0l7(3t>2N$D8X75dTAE8%A(S_mKwV9g9UE*d +z3sb#4HTw(H5Ye%Hhy-23?2N$eJuXIuoArAjA*scZ{*CQJK&OX5L-X^g0uMn0cgxCj +zQIY=)0f?Z7->xb`d)4prm0?^cBa#Z`%U8tW_K<1_PO~6i9k2TM6{L|!HGZlw8Z!S{ +zA+IJ@g$ynaH|3|g@OHX(2GH%NHV?XxD%oO*tb2zj`2qn8F8gg9Y^{J$f(g_1!PN4q +zc@l%)(msR=P(1Hyhur;ItcxcyW~w5k_muw)w+du}bx9(fotEU|k13etP54$3V#Xmm +zIV4?YrVH<8+C?wo6xe;{-l@iL3Qs^4>&itD?>)ehQ;j>vb*X+B6*#u9YJLD203)Ic +za<3)&D0^?-Xu4qA84R5dRH6MqEj79~QF&piVa)@4VrM*oz2aL%<6i?0IJ}M{7{R;^ +zrHQ-w@-vWE_m|`OKe~AKU_E)7g>g^QL|6(X1SU^fvkK34j=4f!|0D|ZoSYR;DA9A0 +zAXB{6^Wp?TGUBJVAE`g4&%OD#vPtM)AR4^$#93B3yTR~ +z2riwO|m +ztG}3Dyf7UJofkN{(u_ARp9Xi|`ODO0S4YRea9Jm<_Wa2snJ@;iet6mQIWFNE^Ig)i +zyekCI2Oc_DMfl2B%^j_LS9j{%t+gpb>i6hOWEny58j0m$p2S)N3n#Y>xi~qicnUZY>{$x61n7Lfs-9D8t&tUdRUyYEdyTGiYDHCY&oy +z3>}7k6W&mi7*8nfz>v|ty+68S1x4%zIBnYoV~CLHJq6+)TRIKR=mM{+iRnXXyizl^ +z17an0(jiLe4Hc3MH7Q-OiYM?p0ID7}hi@N}Kuhzm!{>ukLM2-R-v)>n5Wp$QI_aVc +zRgV+GxbE#ky=%yZ&%UaBIJ7{Sn-U165OcY#KU4*x)V}rH!UUb_0<;D-p78_^L+l~} +zCxic%*vQ8Esx--|4ULdFL!R@E3-8M{kNd?a7v37n$s9}|^gyC%RV}B^5xYXLJ80L% +z0mUHHa$)SIK^G`1sIhG;PPB%A6KS<~cS|ueEP0=6`_MaRz+0!b4K9B_C}h}(Xzd~L +zf7bcNHb6UtrqAOBpU2|c3C@N0SF^=u)R6yO!kd8B0bia!=FD3*kjRq|Y+?<;AUy2S +zt2JYM-+Z3-fE2GThQJUSr=Pd%AGK=(=~ef<;DCnBK#q4s?k4AbML|+Rj8Thk(h2BW +z3?5{BS4H%`pX_I(mGjl)1RxDMo-eh-n@sxJYF85VX`7$d2Kj(I9$IZ%`+a(l%M{Og +zBK??nA+(g))CKTUZ`E=}3@#fWNaTs2aD~Gdj9hDwi0Gd_F^0_d8a_7uh+EnaaR2#7 +zSb1@x7E=%*xc5dpzX@j8>qqh!XOrwVmH4!%QeumtvL5}2@XCR{t`+#*5j@1&515UX +z5>Rch>i9>eOaD`(?ELXGX8PQL*y{Inxja(O=5GJd8oG}@HvJgB&Oht;Xu%h0W~-CM +zr(L(pZNhD<@~?3c$?FU{P4sQeXa13MFI!OZbu<*&G#rx1*c>@_4=5w9&z-yzNn0GQ +z4;W?KTrnazpF<74_;W(jT8%O>eQHgz&cM)H^MB&$zypae +z6jNI0G#?ut-&O)Rj2m%;H$=uuDz0{Q$M8a|#j(nyaGTsTlPxYkfYy8S0$rQBcHc+D +zoAN1O$CKe|g_Z8@bQbxTGVcunGORL!lzDTA#jQ#JvV-g0itzeJPRP0s-#82T5Y2k_ +z*_0#0k=;}bUM&M^gg0cD)c>OgAKhP5Y5@)h!A=Yvy`ryjA|0M>2*jq8b3a!Z0*pE* +z(!p6B9-Uf_x&~?ju+inH5^$X(!=G&%Yj3wj>03?>9JVl>rb>D=Y86tfxDXyl3%6dZQCEyFUBWfWvo6Faeu4 +z;1Hs0bBFH`TI~Wqbcg>>-uo-@*z5s^AZ5Bce7CT4H~7>Y?j^*1ul$x0%DSR&cS0PP +zW#RQpPI7zIrU2uAmAhH1HU%2bmb=-j-W%`THmabXFQ0cpc+A2#fSy70lS5$}z)omn +znG3&{!6EiIy)o1hBvqgVH6&}LxB}f%L$X)elv9rmasL56bV9&plZy0xPV%j)&H&?& +z<(g|?Sb#CJ+ +zRT-l~*uv6xl$mz2&HDAqGDfX1<(XdWXi6$4Z&f)57~{&xn^lO*dV>?fcQ&#}f5{24 +zXO>|B;)CevL+}0e^td71W@Tvw+E8Qi5t<b58CW>ZSQ +zVMme|+tzm-?3moDjDiH*Jnj%M^(7mc +zg|UwEI^m^wENXz)cI~~1US2M|lz>GJB!wwsn0VuRyF4brm_1-~ObOB5yM>b#=#xVvOE5kN +z<}=H^f?je0+-BcX=XBf<$qFooF8y2il`^+Vq1iKZ%s_Rha(%*osPjwl#vcc&k16FW +zy{OEsS_shrm1P>}imEZ>A~Xoi2%hHjK;iEEh7|h$4R)U2AYm}BP;uoBb}9xQ{WWyy +z>(Fc5`Pu>8WwZ$DL8EyOo_}kDGg*MmLD+yHz#L45#w?TnZ^`o;`_{q#yZaqH9fbXU +z=)L!y`ZDb;Baj|iPO?^o1<=!>zW%8X8{h{+@6Ru!BDBE??m0`kg1+QbO4;gMT!yR> +zwx>MlumHae!sZU8I0A>*2`HiHq$A+O=H38bI|2vT36#sC1CD?Tn_CQaIRbucZYh}U +z2<%|HT?LmN0S~s@bKc9<9#oF7w7lON_lnMnuR}qaNCS-vzLuPLU&!%Z*xv^~_*;avY4Z0>`2QyY`M3#=aSx*zaS|m% +zVybt91pnDIt|p +z;WfTjaOCXfocWht_w6wXMNhTCt#K3d;+kxpp1cQo^1-S$C#7)P{oyjsh^nDb4Nwc( +yv>&~JSzqW90y)p7dM(E>FR(gGTaPC%v0jsBiJ@y $TMPFILE ++ ++$DEBUGFS -R 'ls -lD /ROOT/testdir' $TMPFILE 2>&1 | tail -n +2 | \ ++ sort > $test_name.1.log ++ ++cmp -s $test_dir/expect.1 $test_name.1.log ++status1=$? ++ ++$FSCK $FSCK_OPT -N test_filesys $TMPFILE > /dev/null 2>&1 ++ ++$DEBUGFS -R 'ls -lD /ROOT/testdir' $TMPFILE 2>&1 | tail -n +2 | \ ++ sort > $test_name.2.log ++cmp -s $test_dir/expect.2 $test_name.2.log ++status2=$? ++ ++if [ "$status1" -eq 0 -a "$status2" -eq 0 ]; then ++ echo "$test_name: $test_description: ok" ++ touch $test_name.ok ++else ++ echo "$test_name: $test_description: failed" ++ [ $status1 -ne 0 ] && ++ diff $DIFF_OPTS $test_dir/expect.1 $test_name.1.log \ ++ >> $test_name.failed ++ [ $status2 -ne 0 ] && ++ diff $DIFF_OPTS $test_dir/expect.2 $test_name.2.log \ ++ >> $test_name.failed ++fi ++ ++if [ "$SKIP_CLEANUP" != "true" ] ; then ++ unset IMAGE FSCK_OPT ++ unset SKIP_CLEANUP ++ unset DESCRIPTION SKIP_UNLINK ++fi +diff --git a/tests/f_dirdata/expect.1 b/tests/f_dirdata/expect.1 +new file mode 100644 +index 0000000..17e2432 +--- /dev/null ++++ b/tests/f_dirdata/expect.1 +@@ -0,0 +1,15 @@ ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Entry 'foobar2' in /ROOT/dir1 (439) dirdata length set incorrectly. ++Clear? yes ++ ++Entry 'foobar1' in /ROOT/dir1 (439) dirdata length set incorrectly. ++Clear? yes ++ ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++test_filesys: 543/5000 files (0.9% non-contiguous), 707/5000 blocks ++Exit status is 1 +diff --git a/tests/f_dirdata/expect.2 b/tests/f_dirdata/expect.2 +new file mode 100644 +index 0000000..84cce85 +--- /dev/null ++++ b/tests/f_dirdata/expect.2 +@@ -0,0 +1,7 @@ ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++test_filesys: 543/5000 files (0.9% non-contiguous), 707/5000 blocks ++Exit status is 0 +diff --git a/tests/f_dirdata/image.gz b/tests/f_dirdata/image.gz +new file mode 100644 +index 0000000000000000000000000000000000000000..ccd900e1c6da30a76be4334767922b2babf0f88a +GIT binary patch +literal 72169 +zcmZ^Ldt6NEA3u`N5?b12nYGv=X|YM09M_Fpa#<>2C<$S#q*d~eOLFVGx=9!$EsgEQ +zMyaC}EzxvgQmF}>shw(~xzssxp3m<&XZrpA`~By2=IJ?~`{(_+9HP_x`#*Fq@a$u@ +zeb?r|fL^Wj7T&*9|7FoJH|waM`;!LO0`DyQ@9gxa`u|~fs*j&$(C~0gfnnpyR~NR; +zJ9G1o7RGP)k5dmkdug-GZ}&k}FYDi1+wLoB-!=W&8ZS{Uj+;5

    %i*C$-Laa(zkS +zpJ>N~5zEB%NQ9m|^NXHz34d^zmJr~jGY;>C8AZ}qT4n71G+Rhp=Q_lqttWn7Am&7OMPI%zg|A1u1rdsJnDAc5;^P9;It>Cf~x2?LV~ci;WAarRSh|FcfZH;?%De3LW; +zUntN`9tZhB2bEHMu~3GSI_UuqKFK#jbDL=6N6}@qVrg(&XS>s5t>;L}7~~M^cJJjw +z9D2`tsUc=enxp!4UhvI~E5!Hy*O`!8d%7qxlA$Ij%Kb>Fkb)gy1P%7|x1Av-OjrCwR+YbeELm? +zr<+U4u1)zTtv^naDi6MzR-@9aTQ&=lGGOc1A9K#epS+LlcRZ##j+DAY#pGUc@~UO& +zPk#ht8;pti2z0S1*f*b)0BjF!JOCM3Fu8lkRpCRCz-Y5>)Ck1uCD6nTkOq{B)Mev +zj-;JhDz07G@$58qn-)<&%O8m74*EO%pqS_HFiqj-?=V&2`_#ipQ5R_#5a`>fapC4_ +z-yOdtaP#7RzwX+G!sWG=6%HTNDJdtcUhjC%7^5;Q>jIdK0k>4r+PG|Qzw7@!IN;0K +zpHxwuoM_3Q>VSWO4zK#F3@E&({#~8_cKbF){@cNJ&Bc#mF?)2QnQm7>KaX{j%~Hly +z8ZS>^(ML6X=a`zVoMDXJe=K51S5QId3&Kv|tgV-kRU16lkNK;$)O+%;zmJ>$!OwbQ +z4RR==&)n%2XR9LGq#S#!P;0_`&ph@-6@UeRA#MNQM!Nbu1d~zWc7aHE|;%NvE0Lq +zgPhz~nK$SeGrp#q2R=skvJ_thUCvUNZM16I+2xzQ{7U)3?JBfH>*|ud9vN6oj--%x}?Z&q#kt@`g*N}(F>rW7wYUDJ$R=>Sq)|L +zNIAGkGv%{fHw{9kbKOV|U(Cs=L@C|q;3xCDE}=K2GYIU{6WG +z2Z;vfKHVSQZB%hpZkt`&B*r!s9CvHXo%grfw~0+nn%?KxyeonEA0syGz7py7zNr(Y +z!Nvs;HV53THsl8zzmJ^FFHbByceH(lVhVbQqK#lLXmqkn(fr7nbHwj +z%y^B}w+<@6OAh|iK!5v4G!@45fkQR&_&?yFWNzX_hd4YL7N_$_zZ!#MiY3p(QwZKpurW~qLj12@EDatx0BI^18- +z(ns`H3M%1Eu>Vzb_rsAN+VPVK_?*W_<%T#IUcz{e*T3z15!Rmh=21P}_mOBev|l$8 +zU!s106TG^)TUk2cQa)N7jpjOaIz9&vKQ3`txIXF%)D@I8D8Fuuxqwz;)frtHrtdfr +z2I_xWu*cvy;gjQyt$1O#c%lq;`^jHkV_^ups2!*FCJfs&q0}r~a?&mLa6817Wg8sF +zeF|MQ9ms3HP(Yt7RYJKj^w-uo?RZKrRBSx`nX-{lIxGL(<}Xoh^*6=!w5*uUyvW}Z +zkcCAq0yD|%i}XBX2K1ft@zaM=Qw(~QMxS3O?C>zI(bCKJa;cmI-_k~fxhKwnn9Ipuy4UwTG +z*O7ZO7CB1`(4fPVA1~)YGUR?8**0S;Kj4c{xHt^X6AiD9gV)7O=yy!i90NFc*09xm +zx*n^9$A2?XLpay@6u9o$(l-=phoL}0!8`mpS8FbR4h8vNI-So)qkCR3T83<{Bd=x* +zWj3vx+QYcymO#CYS{dK09Fzwr>-&U!nYnU{2hT*hjY?_xL2IMUd^1y>s-u- +zc4aSEWZ3D4egT#qwiZy37(?3%mj4~zBq<#-(bniq1=37yD8E9z4Z +zY~HeW?aFU@$p1zyTBa2ZtOxhmn>5OK@5KvwZs`%;uz3M&BSH)Q@Jl;(=(*e>3qOv= +zkFR!X{@Y!3pUpkr<+Vm|_2CNYL^JixMQ9JcR8~(r@u8DM04D_+UqSV|2sa--ZJ^H< +z(-#S|Lz~d9Oq{g>7W?&EuC9;qU8iQ;bEx&>KAgnkNPsDjzF~7?yS%)F>qjf7 +zE6pOydO)?#vH7T%>3YXrYU)(8$bvIEii;<=s$Q#C&8MjdqdrXa5|2+RWJw +z<4VYTYm}J=tKPiRdd0!+h^(8uH^ +z>PVe*o>tnw06t__9c;%NCg2c3wdzwksfSkDmosYgqguKA-X^=x+svg6uB+N4ds_wiz593T%ip9X^GwnFfc5(w#}RX{OA=IGbO#3mlDP6I({(&Z`D624RnO{B9WX6x{0XEPVPTUR-X}R41h0XWe_m^WDxK +z^pR_;pC!5o!;LRb&=IvU4+W}8U_b}T{InYz1#35>%N)m9LjF&;|4M7@1M(oA&050 +zxS$x%&&1u)5st^NK;T~+N(eG{1IoC^IuM5Py3AkvnI7s5e-{^e5o0X5>>R8YP5dPJV;i2( +ztz0BSL;aLNSGy&+kMB&jqz~cP@frAK;f2u=8OPh9X-bwpCbr9Y)sJxA=r~v{KJ&)# +z(>AQ0vEM!re&ZRK&@G;&pl4=jbmhj}c=e1joH8DtB?27}qXJ5mQy(j*o<;-wl%vQ? +zZ6IU~gPS`D@H!7?pD>AI^#$f(SQ(LY4`%Wap`I`|Q$|~6Y3>kp +ze!joq5?8Xs$eGBB(K!-*j?x;@<6X{yFrXKDVO;W=9^egoiwkq-%fTSZ)JyF?Np1>4 +zS|CFQ{FJUl4N~X!cdZn`EJA9-U~PH^2dc4HZioq%5o_a~pxWh`n9x6v{g +zVQj=DF0F^-o0~ZMp=`sT%dmBsAy_Y+^ht6}c)>3+6yT=}zuGOXE|GC*y-fnTxtU8J +z#x_{KgzI`yV=J}cy>it{WB8)abc;9aC@wV2?WCiJTDY+CUObeYe;!^wV!Uki1)?x6 +z_x_8qWqA4oeCJDE5y{cIjJd6BuOFdKKP3o!dKmWchKt38R`WXP)xm=aK@OiJcLaiV +z%8-MfGKvs%8-|wQ=$`XL5WC1@k{_Z1y;=G1UAZfHvyco{(1WuyIzC}Dw;?)06!npI +z@*1ORrNr-*%L%_8pXqLI=Fe|ax5dCe*rP2xl_;rGq$>6f^~9)%@r<|3ja +zY>EAN9hL9Zi>G|jTouH*S4NAnG@T@t&VCj_0>wa+-zW#l(0o6o%~b=6kiMuzsm0VH +z!Z7jIcyIW*xNtT3p(e)TV=Fz7&xwwN;el%9g*S$U+puqT*?}^gJ^>e<;zfPuDdRj= +zA2A>dXK?00;MAiqCvUh}T5yif@|Dt?mGm+RXxAeq_gg*JPs>QUE0$d1 +zoIQ;5h4XbMb&|!c?4*6z^DX_N23bE6P3JAeT0uKyX@bhTQE*!jIlsi{N`SkBaQ3xY +zdE$*Bx!ee)$Gv8<5}`cvJrBEznA{0^Zp4oOsXFx~F4x1DZ+DTnU+!?V^4y!yNk2lU +z@$x;G(Ie9tGSn+elY6b(Q-|oH8kAp5rwcl+%ffBZ5#p$i)SystQ!8y|^5R@GwP;Z* +zJGxmX-UEcBP;&o7;eKni@<^?-mT`ReZ!&q_qvZXYxuYi|l*cy0*}}3~lv_;a3)kmo +z;iBR~+$!<6De2|+T3+v`=Wh`0eCheCUivf+(k +zS93SGszPV7qPQ-D5Uw@fD(F#J8dqYcEyENzs>chWGI4!$1nU11S(?9XY(?JhmA=CL +zkG)|`aUn$tg!s1Id-YTwlTo-v>NG@`{v_%LpSlMtqmgJKpCr!tap6N*OzPdgVh$wc +zz|o>4fWwU783^gsFg8q +z3@QRmx}BATu~qMto&rU&-mtZa`aSB>To43kU6caB{^@)N`m#2{U=R^;F&%$L^2mk-fWw!*`ud= +z{J=Fz7enlNg0@o>o@nL5+Ac9Z7VLV-Q^tK5i*3jcDuXvGwJ`a?>@zT22k +zGxCukA#U){8>#+g`A6G#4>2D;Id1oj{QT6^{QTrWJKyY!-WQruIryjPsxzvGOA0i) +zgEIqv-4H&zYh&=c_a&TB8bZU@O>aX<%Jj|)PT)fO;HCIDme{J5zqlAS>;vhqFYcln +zjbi0W^4RgbPIB`SJ0=e@zTVf64O1RTpV8&e=Eo)5s|sWEGyB-QZKmrN=HRxtU^vze +zPomam5ohX}Or*ydWe+Nk`8 +zCtdTcTDj82uzDY8@{AV)V1CbO(hpcw#(lwI_~%5m11lO~9Oe3)h+y*Ipy1r$iM4+Co8t42@L +z^DJB+A571qK>YLDzlbMwNdDuA551(*T)V_NG2POxYumxPhngbB@JktIPo5rVA6<%V +z&0*^~{Zg>qZ(Tv(jP4WP$k0%yifS +zdp$qCQ@Xntd=G7B#(% +zE@#E5%%{n$*vuqWQgq+l+g`j4k9u`ZQUiI7a3|SlF@RHsDA1X`?c{N!RqS-4l^SLnVt;uraH#&d1i<$(oIAaYF# +z01K1Jg+F3ESC(;O80;(wt-@C3uzdGt(PS;M@_}3Ao)jfGj7fN#4dZytW|o7SAD1>! +zwVY&td+kYjG`TBuKYxAr3&zu{?DB|u81*u&Bpa+v&g-_B3$#-$k7|dAr)in35ZkDH +zBDfaqS>+Jp7T2KAD3M1!=QAP+t~o{ +zibPg|;dsg5yQa6Kv=+aq+wQ>9{Y;t-QlPB8?X9HMxjB71h|S@OpeZ^VFNq6Q%~8Uu +zpv1ClTAog8COCwJF-%wl{AFTS>0MW72y!A0-y9`7D8Z3A2r>5t*Ttm~GtCH;)i#;7pz@+=>4dj6o3 +zR0((VNt4-i)ApQ>Fv8_R+{7!ypFG0tcB;}Ww5{L?NHM3+j(j` +z+=zs41!8WZNSj5M$I#KE0%F;zI3JQ_eI%<=ub$YhZ)PpbJVF +z&C0S3q*vJ)AP=gcQX8pPLY|(W7NuUwx66aXnSr&`a8qblm4#Vy_k0?<-(5JEz$vYb +zQ4gM>`{htj!nl*`&lQ4XeT6a`?ckl4JWt)q8OZY^?XbbWueaWFT$fcS@4ZVNGolq` +z8-_&ywYOk9-0hKMDI@x&Yy;_S2IhWow^h2lLnI`L#B)08#-;op32KlJ-BLrjnaHWk +z!BO$Si3Hr5sg|*ULyYdkXv!gA6BlErnsT}wQCJnAr3-zJkkWx!=DO*YxQ0 +ztPWPXgbvqol9)-|4s4)}kq+kNQd-7H*OqM$4}u70xc2t=WL7o8SR!!Rw3UpGE%?5OBa7O36LfSQNQqA-Tug7%_mS +zv6K;$2tGCs0?+uq%0{z`P^4gxvlVcAZ+lERNBwqsJ3=N4>(0T|alzF;%fWBxlgX?_ +ze{4OPhhBZWLH+!Jnt)RatEH@k2{k(YPe&7!;;%JIW~SW_fNzV?dEx3IYP8zLV7m?K +zQg;t1#YHB2vE0f@CaUn4Z73?uZhH;2phMcqhhv++86}aTO&bdQIazOIE(A-lof>($ +zgu2~@4Rz^p0q{c+gcCO%!q7h`;L6^1d3h)GIet6r;Z65&IULWyhWKD~?h2%>P57%- +zG`7q0S6)S@H*q366(%h_&5SAjH56r1(dQg&MUIom+WB(5A{+HCLbnCdkI-sqGwPxU +z>KlF$mO7RC=pB1NQ6y@TF6uzCOZl@DOR7mY1K7lpqXtAOae?HLuUIC^%I18ZXn +z_~Ok9ux)y)ysAO}?f+v_4Slkas^|SRqrVzRWa>u(*(d)hys)=`L%ia2==P=ju?(i` +zjHeQ~(*y8y0v`#CI+caxaly{>u+8Tog*L7UjSQNMvQ(;j_sY?Bz_!3MThwR{32@khebL+b(%XEPQ(n +z(jPG;zc9ITDR4Z){+*2$@(TW6Ijq^j`A_8Pu1mr5_QCBn^!Y|gF3>YfE%I#v2c}!( +zT;`R)*_#PDBx9OdjvAD@mJ!sKghNh(=E7H%I +zo|Y8=wUIDPpruxZ_NF4wyAZJ=H#z`*>Y?Q^L#Jpp@pVMJS1vqB2c}JW`SPE;y{a`XB)EdTuXe=rpZ{ +zpgE^8N%{=iE=Lo7N-ts3)-ne7PUVc?C8b!}n*`zc$FOF)f;wA?dR-)Q$%}ee-ys&# +zhrvZHUE4wpX@l?2ZX>mlr71E+6ftS58LN3Lof_cltA|w`;uZnSO;AfWwoqTS!G64> +z7VLXYKVbq_Fjl1f^>}nGF)zoijJ2jw{T#g;*epQA3Gt~O%C3amIzsACfYY_Ag +z6S#(nSs;gpQA=6pK0II=$ce`(sN_oYWf->6R5xTJ{~~lputk3bm0yW|B>ukk-QWZ+ +z*#u`Y2B@X;Tc~~!plr6S!pqDdM1YCQeBhD?Xvz&}gU$ZCt;#P<>Eoq0toMMdW|kf* +z-k;s7Bx2O?a;d(gli$&b$nL@FvWt4sZ4(N+5i(j@iDr>5;#c)G*=R`-Ix3K|L_x(= +zqCR0*bG!UWHtLb$JwL8MD1zC%#@EvnFOS0Uj +z!v15%!j7{g7JB;X?gXxGAWjzQ_S$TGgiv0gLE{T|)q-!2ib@%aiCo%M4NUXY?5?3N +zH_|nNLyuOAWLoK|LayAa`WSG6=8q)c`adoZin){z~>R2)f&drT@Eq* +zF6uQsvHF}0U8qF;!m#s1MQJv&Ekfx6pSB8WeG6sn2KkgzoAPUu2rv79(F1&%4b;z$ +zExT&y(~b1YW%x0P)0S%SoEBOfU}&$sYo`wZF!T+AAsuwbIHrX +z$K!A?L4-SYic4|5DKb`H);SV>qV#m4g)XO6Iln_G*m*S>cU;#>V+tYst8_X5u9%!i +z{fx0$!#K`S!jrdKYU#vA+7!}l)Z(Qr^bj{#eeY|MN}NrBD=Y^;iN~kQakZmiPAQJ) +z3yTDIo-IQIQo&DajJXg{OFNnlGub#b4lf~{s!H3VlUakcF_hrJW96Xp=a$%WiA2w; +zXBNJCjTJ$@F(lPu8TvXErfE5GUBOL`fPs90&wiOWARd=ibkc#(#wKt*Xh8C%F1mv?=yW +z?pLGk-C531@pnn!&ZK2)3V-{6pP(9AC#Oos&z_y5G=BU&E8^h(g6Yw2W?YTIuP1l9mMFs=<2qHZDDdJeoVGwhp7d3t8T=RHs?=g5B +zo($be;{#w-G<@Vbz4Tw@A%kuXMl5IFAe#QxAn8)E^RX2tl>@rcd))Eqo0MYmNEw5h +zlRxK9f234*FH%rxmB_4_n%UU0NR3l^A@LjPk-FPXLFHDWam^^L;Y@{sbGO751nf2I +z4*sZ?y0_2++#qT#F3W?j9*N}Wf7P9&F*`dIww5b3|JMJi;Am^3!Sxv;+m#w`=#>g1 +zw4IcqYk-0)>4Sg6^B-P`3E+;#Vc(Ttbo<`NAhPWe?KuxCGE}6EJ0ulmkizMaCR~j_ +z^hUE_^G10|4&LkmZKNn~eKt|S+4jd4m;a^Ss=LYl)4UeiOe_AXCir3qL?5QEK>rMt +zwGZ_1fXk$7bL(UaDp3Mt!T2H=(g3)EdadDN=#tLGGBh?7jc=AVF23?Lxzh|6-lx5Q +zO5&YENv6v0*E?yTpb@=UhRxirAUR{Rn$h&*QmU3-++I)m#UyF|^P&4o1%0d%SrJ_3 +z<)07&w<2LEL5up|X2q-4JJq;~@5ziEBTvi10dY9I!id&vIu`;hk+71l +zd4HQtd^Jt0B>ki|QIbL0o38*nf17<&mvL1a(~nF3;)-*19xN?_3(3Z)@LAGljMpkg +zcQRa*d9bqx?#CJ}!gMId2X=VC(QS~cI(z_J +zcsb3KZHIcS`ks^9@c?(3;Ln}%$NJ@tVh=x +z;iz!Cr4M+<BlJ1Q~gvzOEcu)!B +z8JyO#yb~|sMY)kv4pYFARIqBs%9N^UYP`f8M8qimNeAEOOtlvyou`B|1J>`ZM`Zg= +zB|Lx1pcE|(tp`>8j~aS?2i5jHf6-nAeXSBm)hM}`_jeu)?4dqVCy{9>vMU!wttSdk +zZA4F(@j{4~q1CD2vk&O=+u}oD4aq?~kz{7Hz6A}g2kFlj4Pu8bX^23(lUli|1(B-J +zdY{j(dNhcbjgpY~n8{tsh{;s&Oi_@G%@}T!KX}HAEI}tp*U~53p(ytyn_))sIMIgM +z8}@s^64Jie&#Y5pwK;SWZ)|-HcLF(AJI*nM1>1YoJ_cp4t`Efa{(~8r_;MWfB2Aiw +z=XDCsc_6lV%fGhnA0~7qBPM;7jrlKG2@ey<^~v6_+XI4{G4+?apBg8d!)ZaQyS8%S +zc3cLzJ@S8N6-+WXLfU2JHjo-jau~wg}D(O7-=D*&dMGjM2WQ->Y$5kCtXA +zNZyALc_7ZnsmX)=MUX8Vuk(T49#BWh$?sZ5sIhC$@xco8ze*UK2e#*?Y3S7*^!xEJ +zmgs1?0-dacDWsPCukdvq8qce=I2}%tHta-BLrTwWZ)T`*eqTrzNGF2=cRNm#!lLf* +zk6fskiSl|G*rfuQ5@fgr<%fV@yVcl&kAT;R0Ol&t +ziAtE52Q;%UCIse3f`dTJ;4GXIhvnr4SiE|HkAeDvL=M8z;2a!G9#t88fui} +z^Y#^bOeam#q9a$}NUC9-ff{H!O{N5vaoCaMRjqv|F6j%df)q#lb2bw>@ii5?9M8&F +zk%h@#N_=2~2UIs3=!;J0{%S|_I%u`vNYQAIL|Wvds2drzxWC(wbbhZJ8Mt|f!^g@2bZynF+lrpX72+IaYI(^RDKsj_N +zL$XQu$DtQ>%IjJ~Z*IvHi9S69rXQvXh36-9%G+9lImhMRblXu6vPL9-NlaSlqd>`( +zluH;Gmj9qZgF9^XBpj7x;ktNysF|ZS;0qzp8404@!t)&L8iyyAvr=u^0kAwwWfAue +zB^2J$dJbT03pR$l&4YzSP?*ex>*&*Dvo;k?Du+D@%}No5Fcy(`>fD88z6RQ?>jN9} +z`9Bou4Zo!#f))}tY;Ax)8{w5e_yz?vw?#U-fP5n%&LjgGlRDe8uvZ**DQA^GHC_(^ +zsxJfz>cpEk>v-%^p+ZyHm#mW5IIlKV1|g|v%3U}&dbp$>Jd5CgAVbOrl0D#UGbhDw +z9s()Lc>R!Bg>o&UnyZ2A3`ZXWEa^b+1a&$p;9Mo;7zVlfmSwiX5ECV1vaul!cbBV> +zMdx~~!iS*K5D78x4t@i=O*BC72v77!AwHrEy|GAiP;*IS12G~M9nxZ$U40k)A1R|c +ztn~PWzXFa_(!Ih!;&k7y2BI6`c?CgNROc}r`a|nT2A^Jsyc}4HG`6^?F!XVvn&e~X +z$6)uHqNOZlZ4|rKq6>z=D_NN2i4#xaEUy`8g-!KjmhMYl;Qkx>I6)2TTEt&PK*p|obpj_IfM=i6i(0rO +zFBu&pZCB>^4}VCdQodV9E{Dv6XWoc +za+b`sDqI+e_PVo%c78U2My8?xT8_RmO5&sU +zB-0h)`7B&T{idST2 +zls3Y+`X}N3Wt`kt3I=4LfdRf0-Sh}VU_AfqqHRvAv>y?IhHzSyiEHBV*sC;B?3}m)muvh1?~ri-0YhWuFdD)izT8m%iYEa-s!Sy_;pzGMB;R!&DA`%Vutg9cND#k6=#~_Ay7unY9|u +zh}SCUxJvrFFp&34Bkj}vB+l@UNlo{2i+Df*gi0>x<==Oug$ktjb4TNG{9M>xxTMNk +zFXuH(xY@6uerXY#Yh#`%Cfx~uZz54Yfy=>s(JdZc0CP*0u`1q5iAZeKqHEfW6Af_k +zSqte_4>Ov5(?)nF-Eg~96hcam^j1j?Mao=WA`g7vvj>bMrZZYZL^7@`a34=c(`L?o +z5*Kt`gTC-iB%PIw#AV2g;Bz)#72YGB9h$9JFW)6^++^>sFJ8*rGh?QNe>`*=dGJjil6X#`rSORf6C;pVw@LB +z!76M=Eq%XHS}$;Ui7a7gB}5Shi!HgW;y%P39JTZ?8FEcU!CEYLxI#k0;vy=FC!F+< +zm2+E^eF`AmdMTSonvnd%FUj&mi;|3o)Fs_64s7BGW3WKCM-Hy=fVCtY#knK~z%-Ky +z#&0IO6P#~~fx=g}Lv|#ZB3Ox!f=;ib2h}2J+dsQ%sIN?PY*Ntqm9#@1$dW&M>q(m+ +zIKKwDT!Z78*exEnm21$#@Q?ReMFc{zj<#BQg@Vo{{apro9q-dUnI)Zq1A<*`mLX9p +zve0rFPk+71J?>3n%sj9R`h`muI6dO%}USMoMU8OWt=cl`M!rLZej4 +zi`y_lO)YIvejR~n^=+XW&UxD{0#>I4zmlCLV4Q_-z@CPeqPe>~(6QUk!b+QS>h#Ptu=~ +zMF7U|vj$aNy`I3Oo0**9vQBzi8#7l5A+ABS^od5eDOgEAHMOBdX%T^)53ZeBik*50 +zdB(_pVGIj3aAV&S2ez7!{h$WjDCb+=1U+XpbKo@1{W5SKZO +zc-jb~rK{j+Tgh0TV@X%Gb)s)&HX3bG&wrV?GY)G=7J0Ly3Wu1(cjtIR&XYl(ROqF} +z;;0r`j>~Z4}WWb&Z+q4*|Mv)$C +zYNME76LR-?9?6T2Ho#*t+0X59K3fiODwwBA(-4!!brRr +z&p8@Yab_iH4qM^?!PnY+V6+EBlTp~7M|Y8hiOHWbv1>dQU6sSgm_w!6;2KG$=zQE9 +ztw5wBHjGhGdB+lSTa{#5%q#hv4929w7A-c2CAF}jh$U$Df4=Wd^p^JbvN0p +z%}X-OX3)vmAPyzb)V7FvC5R+iNBu$C&WC_4+&rNaUpCpS`UN9e#dyxwK*q#Lq&50o +zR}`^XvgneRiQP#*x`NcU7FC%17XyA!G>;5P8POU>PJE3Txq>v(or|cq!tG~u)Sp^u +z^lb3-y-v2#+D)M_B#`s8e#lm+YBP&tLK&r#eyRxq^`s?*G1Wk8FDI;fFl7 +z;b+Q>++71qpL-5`BU!mupv0dC@s?x_+P3U2KT_tiF+)bm@mP9Y4)3=<+*Jc^Mf5{K +zmu?EUS&7KnRmROf{cHX&_%ZW_IuBS#JTtrMF3c&SBl*Lmxr|81lkkq`|F=%xlUK!_-QcdbhG0B?5ps6lV6Vdo1s=PjwF`8KBsda@WyCQ +zRQX3aoX94_U|dQ>^_{O-DSpf+%xm*t)Ki99%b;_GP~CZQJG_fT0le2M_bA|2B_d_2 +zMfL7&HK?!29maWs$^#tBS$IcYInEp=3E}5=8Q&foNF4C5)ZYVOrAhB+{W!5bM=wx9 +z-IrBwvPqkQzAdo%qgoR?&!8zFxm1EySeIh|9@-x>wq6V({ZQ-E%h;IV#&iOm%i(D@ +zkIvJ}SyXUfbtxt#IUlb^k$KxHCWFA7&V4UQUEtW|6`I2jXvp$J+Day4E&_}1gLc=T +zS)}5lmNugg0y4kXtN}mYWvu5AV~_x8zR$!h@mNiA>~Qw4%vP$$*`j6Wa3ut3S#j(< +z2QowZwyRnQK@pFbK=N95vWn&=sYSy~av>YOlRaQivlPDiDL*~{o<$-DL5y1z)QT2* +zXat0=t5+nDZzzO};(S~u|5K|xRtWcArJW4`vT;@`2+~SG;V(&!aQ^!){9>}Lo7wn5 +zJXR7k8@kB16j$|y-1=5(eKV@^hKC;DK#)fWv7&vXK;-vZZsy=_a{M}H_*l6=feY-9 +zLj-@D?hTP1aEI7jTzWwOB$<@-atq%bS6(wvZ4xqY9cEMuwl$l4<1>-VC6ASHWNH^^ +zf^N>Ic^nR7BCyS>CbF9;vcx*!ZV{Q##Nj$p*xnnHte293BX2`H`F=H6kexualGJ*( +zktjkCimePyOohQ(9O}sY8Nhdld3f-0GgoTIp#>T^`CAnZHiv$@_2T8te1CXTDl8|h +zgx%J=YS0*>PWn}_jX3ldx(edw%$~Sy?%RQ;f +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 +z9QZ{+@K#exrSvpdKn?MbPg+ +z=vfqifiYc(Rq&kz;7)-p9M~$;fIuBaR|2OJA5M3(FU2CvR<0byoRGt!ZZqKVN+bX$ +zKou +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 +zvoVsKDOJlX(Q@`0DyiR^=9)NC>K4zFs17SI +z8E_x|Wf_Ok%Mhg6DwkQOy)1Thx6az(cQ`WI$dw=%c0Ekw`J_ieCxX>6A3vb1-)>kvURZ6A}lAo8osY6 +zT+$;7Y!8ZJcgS2Xdk|>@G+5D96Z4?CHuN2EoZOO0SY;jN|6DE!Y8df660LMU5XqvG +z*-7w#WWPGL_DE0fqafW=AN%+)Yt`znQ?ReYv)Q<)p|KOX6&VJ_Fg7^z^_lWoNDXiC4sfuyQ?yw{n&QAMM)yWo}X`)vNl +zGF#*P_i!I@Il)=$0d{!ISV3h}-+)Qjq@gD}JW&ZM0D#!q6>IfiaoHbm7iClK7< +z^j11vC&oYPuFHgZrxR?7o0A&SZt8OGD|(t4;StiZ)*MFX1I*e^AHrG9&>rX)Ht%!~ +zKWQS8oHZ`C9KQ~;SOSLN1nm-kl3IReT=68vQo*1rdah7;@RZF)$u$G&=wOvkNVKlw +zm%I$+gb#+g!-nAVrZ&KGZTwC-8rL1zxy!MHy*x9o!^B1~0m?|GqKZ8+78HLeI?7X0 +zugPhyCHrRdPCS8|L^1KZnnrgGjV+1n>fV;56@F(t!V*RHDYFdZ=qIIH9+{fTBy^Un +zN$M;a1wPK3q=sdUD-L%ARVr=Lg1fqR4^-RN^2Xi-MU{nPm1CB@qD$$M6uLPQN-POP2E`VaW&o@_pbWG&shH69ZxEo +zGO7ji630$#TRX2RkexDOp4_-o6-1Mo6!8G7%OaBTYDljzF_We^)3ri6ksz6Wz)>r~ +zb2FYcc_fp)bqanY_JP(YAS3bFA!;`5e3iJG^x+N@8Sy&6BwPvF%`bm$GG*|?x*JT@m!_N$)?8A`Of&meY|w} +zD?@ZxPyYeBX@O8?i$6^_Ef)4}pyl@wo(OyOXq3KmC+Wgu^z%MKfpD1~EvGNtMXJ65 +za-yR=`!y5f%oL1E|1$KVp=NzrRXu9C^sGMZVLfWCv|pe0ydL$FbcH^xpdPhGnyOE$ +zs7I}oI_uLO)uVK!t@_a6R7RrwZVI}*9`&Qt`;d}ih~6!%O_Pr~;}7)_jHJtem48ZV +z)8$v4ZN}6eWc@DmD~#^BHf)e4w{yn3^|8|AbZ2~IpQEAlc!4~jj_4uGbCLd8M?5CX +zbC%voMwj(Dl7uB2AU8VkX#Zk8D3VSp6qe{g2k69;{k(m6Pdd@L|M~{#9G&P1j2IA~ +z)Q22WiCWSUdu5j)X00^%kh02+3@&Q!#6#_V!Al +zAr#VQY9uu(kUy`(cnMuyr2WaXhkfQQ(iO?H=Y6CCp^+Z#Ss$rbShxXlreluxyV@#; +zQ#eljtbNM6DKr4wGU*Y0$TJnaQwY!yJ1Z%57+0aWleAY4ilJkRg$DbSS5j!t>WQnQ +zjr!2>RE)M%+g>?f2p#Lg8cN*@Ts=Qhs +zf>P1uLP@Gz-C0>x$H53SU8EvC_*XjGso(S;`DJ|=mrC0z)J&D@IV&I5p*@5I7wL69 +z_#hqa($BJ0HmAUjunfK`k&>g_2jEefUx;?PnppS!z%q&rOD^ +z`iM`2>HC#eQ=o!+jIPwcUO8k4?e8NRN_`5z&r6|-K4OtjTMs@=N4xfuuE|UE;pkMF +zg^-adU+k>BTZhI7OPgD=o&Uj5hvxt~6KAeFXRNJ^JyI4cM0Xh(%uXQ}%J_#B<)*^f<>yX(UasWf9D +zHeFuntemK$9Tx)Jb&?@6cwPKCZ`{={_Q=wf#V!Axt +zS(#i19TmD4%CnQ<=Y6ySAz?q>j}C!IC$S-CA;(Ets|SbD!RKxf|B;*P!=9rt85`bogXH=BgZ}54)y9Wzq@qrz@e-{c}8+xiesS=yFbgGdMp*P6#D98Uewc;Ne}5`a_ec@(t3SN +zSv~e@bZQF8rJr*>x;2I5)z2YBm!*)7_M`ua7N?L-_M;P`6H`de{pf4ajVUD0esofF +zQ3~mJKl*C)ND9flADtMTnF7iKaX&SX&MFiVZEdRi_^wjZ4H#0Nwv*IU4@2wIc99k( +zV}BPW7RX(bu_uIyg>qIh)=7AzKyIFl^$;E@l#`RO$Apaq^6+G=o3OD^E=k6^2#pKm +zn#ou%p>d&{kc>SlEDGc);6AiLdPD!k7txnQ=>1es)r*B_TPi5?kA<{-)KI#QlN6)J +zdDJHk4TG*nAE1*9g*01g0G&({Li?zm^zeKkbbuN|4}T(r_EY!L1;_fy`>Eda@ZtVt +z>FSRvZ$U5gv@&6NV9?*523nn_8Zv2t50P +zbk5%O6vh-pkJL#_q*Q0BL!azcv_mRMTT0dEkm~bnZSwkLuF}Y4fvZrxAX-r;F_n52 +zS_MYkUb;!jF0cwTO&@g=R=P?LBy)=TG+dKj4d|zRK#3!IG+Vl6fv|A{ +zc%yO6Vqv2mI=@d+AT-{9ru4--Nz;-!g?;fZ5mjN1@wenp4LKIVz4my4A!noT^&$MF +zRK`E@Zhe|#Dpp(iSs(qdo_t+yqmO=GPbSF!N#T&|!~c=jr2tLC6XaBVbV0q~C#m8P +zJ|tDJTzXU={ir@XNj{i@a__I)hd)dgVEQW$;Qi@@LLqwt4WbiBLdpt^MRA{jlTe2WdeA{S%B4Se19YB_^6HoES3XT)6bTi2&?P$RXurlj8*-n4tJG5u+DCVM +zEUes*zewjfOWAtp+&<9h;*uFgQn?|`wl6PDUTR45=@Z%GBU3>W_SHvc*J~!p$5Tx6 +zg;D$Q2k49^!o3?nvnnaD8Xdmdv_%Tq{uW`$A$(XW$5QyWK02>nlOX?+qM8Es;T`Be +z4ZRH*C!q-Nhumi7!tV3^OKg8=q0L3LY2&K;^sajlMBUL9LX>2o$+x8HP~@#cuu +z#Rr=gAGEjk6002>S7S=`Ns)6m1KvMpc|%Uq3%!25=Jjhu{_G)74`G4UjfYw{bWhF_ +zCdf4e!`b`N)2fE&=M2uzu}z;P8V=1$=tm@6LnNFgb*PRFvsg>S3tR@@N61tGi;;wVBO;nNL1 +z`*Av;x)Hy3A4gW)5yBNAFtdcs?+AhDV}s~pgXm*(Oh^#Zz7#}wf)MR-UE +z4+-HRAv`362aE7v5gshUgGG1*2#)~aaYqc4d?OIsHIWrfWQBmN5Rer|WW^C#VIV6E +zWW^L&F`ZrkrJjsP#~>PF5Dhtqh8%>4gYa+=9yG#(MtIN&4;ta2Av`pMhlcRb5FQBO +zfe;=@r<(C_O5p@TAYeApB64OUJa0C2?#|CmB=+noU@Q?T9DI`$Y}*~de7|X?x(Y-!CW(wH|8cYwXiN@*51A& +z$TjDXYeXs74)Aw3Z+;}HS1tW&QNy1zLvZ0j*4!90CQlxA9g&0-B{3MZ_mzDX$qEXKIN*+a+FVI +zd(JNX`l)DUX;lt;cImfI*)vPKa_*=ENA%ck7@4jk*;+Rws_s+QytuAJCFbI|nsB-} +zudR-)3Rmfr{3s&1xIU7~WOiilUmuu3l( +zqM#n4U^1d06(R5lk&oyVf{1!FYcL8iSTJ2cfz0U+suER;h+2k7xQg627a`&hB4<{D +z{60c(5#k0yd_ah&2=R56up-Z@gMK(mfY$&(5Ce4_RiUL)XS!{wyf@vMfg>XDh%wXg +z0B|EtHxqD(v1#_ubZ1o^nhpz<_oh3v%J-x%o5b;c>rLBp3YMhFgq;i*R^qd@U=FM^3M*u(7Tc4@q_ONyUzgpqNNJC^Gz(U=^D) +z!WRCG&H5V~_8Xfk!Y28~rjD>FK@pp|4ef-mX{O7w#WL6(i*GE-#tL1uJ3_uVW^D~B +z%s8|L{6KV$(iFTh>Ki^zcr@JGcU*0mq_fDT*uNM2X` +zzonkw#HriM^_ckHpmub(` +z4trNuDt5>)^UJAt$$Y+1Vbaj%BPnw9h;th^>ay4~X!b?nrn+!UE;J>8~4=_-e6o$*M%TB8soj-g;N6 +zG2SLKKlRJF;M4R4A8A0N4n?Qw8dprqqb$|6LA==PX?dgTa3M2i<|Umhr#iwD*DV*V +z?VRTEiIYw1(si0k0rrBOC2Kj;JGF7krcWpJ8%(IQ?TX{hoe{L*(y19i3mt~1RoLhkw&m78mnm>IgX%TPc(8zpo}?+lu2 +zbyX3G4>E{vn9*qv7cp~2r}zX2VU=^NJUXU%^5P3;cqVb7Gd!r`nS0gWc&l~7C*Ier$5af_+vGrj2#@(Q&OiCgO`Y7+$cJcJ@tKD~SBHw9q#<3qZ*4!Y{sR +z;0j_MCwKYD@i7Q`?xeAPmK#vNX3X8*s>luGPcQlQrN}anK($!2v4jgCgOWHGdn#s# +z$eugZVms`w@34Euo`5A;BIjC92M{u$P1AoH41|oB;xYd?3DuV+K$Yp3ypuVqM-3mS}y9(BrGbi@5S+l%EC`$F3D?gKsO1Don!nvs#M>E1Fh#roVW|H*^j0 +z?7LPR<AX1m#ZbSH*<9-kx_N^xb~@MJA?hHeYkY9U4YRBa^xrbz&++Tx5-GAksa+*=3q1H6js+A_QJ+6mwoZ{=A%c894nrR6o4vflhKqKwQZ1B +zk%Yl}?ailQ%59>Up;w9EfDbqj8jjI%hh2e8DQ#yt-d!b}YEw=<#6-Em5M3efVYa8HRYx@)1?U(;>y6(I07H`rTh5NW1^=`;_FTYHB}e{A_>X;*F>Kl6!I6?uTnoHpJ&WEPjRh@oUxH +zV$PRnsD#!r1~EkJN>`d>A|`x5HZ(dsoHbfdTx=L~Ib?pc@{h8;9PZsXhLH0Bi!*-d +zGZa3Ugbq-*fwpykg^`!MA(r`52X2Wxcu>2&g)36Dm_PLzQufNLPsER|5+1AJ>0sAR +zy%o6D@MI)RSC;PAh}xgxsj&<-VkT;-;t!$!SE+Jnv0NU@AfcB=ny!kb#;E?!qD@tE +z&1-nlY?8npd@1BKc&_{^UDE!5Q|LM0hJ%h2tN^TvZvLZK2Bs=}aC38cETdSk)O!A> +zPOfO2|M)}seEEIRamSc)dug%%CtfE}ROx{+{wfu~AvZ8agVp1b?UV8;$mBAkC0uFl +z$q9pfPh7SzQGSi@LIugHqQlMGHHRl9Tyr+&wDdmTZ-UdWT+HX`)UK88n3OAz +zZ*Ax4-odKS!ne`KmG6=<3z!`Qj2o> +z5)<-u&BG4A8r&0xUE#P<@%5EhUGN7>x>s^}35)TmxNP5Fqw!`o)-e~+WSk-)J~z*C +zw02c7>Y1Q;IP9-c1J*kmuLrV|@qC}3iiy!nD$o5CdG9h#5j*t=Fve>aqg*NY;Xor1 +zzWnpl`l+eMFD}N9=1q7+PW9u9KTm!BOS|@!tKp%h6%|Czf)i-R`?l$MYWUx6V+VYD5e0YQvAc2!Ap}7)NR3$}9sMR5SuFjLw4j#?WJi +zKqTj!lG=yji2}~X2225X!wYUF=YrJ!ES`vk;`>cgr7>AF%K&)0m4M6V_{c!q@i_QS +z+9De?RbvbExKSWdpwGxyARM7~VS0hQKa>g?1i%|7qa&=1N5i=yQSXy}Q!{BpOEj!J +zBema;Cz8-_CrW;cNa1muI~faXFtATK5f~IreX8&Pc3{YgSHEZVDZ|S#YwLrfWn_Qa +zyh-^ayG;`HHA2ZQQEdM`tCvQSm1A_H!5fx*!tehY5#xwK8^tji_O8kQ-o{jOXl0@; +z2&_HU$BwS}+M(P%zJh9T%OE1+2;t}DOKcozx|{P?PFlrO?8(K~@MxI$z#k%hil*W{ +zV=v4DsbKws!|_dyLg90hU(Ga#Sd8YrmbqDyuL{=u9N?8&TdmkXRN1F-Z0LI%24wyF +zA=gV;ZyH*ra@)GOA~8Siz|@}%7HRQT#=K}ROxR%DzA2SkG=5q=PsRR2ZSY*8WJlPb +zTHOy{rBk7o-+u?p8djUw^i?_`{&gioBid_D@Zf?w^S(;QTGfvv%qJ32k@v3#0Vt1~ +zw +zT5QGz?=;viTJqH@fk!fd0~Qc@jOCr2C5#3Nnl&MbWk{eb6DW=$!KBkBjL>hB%T9gy +z&@3O1V%LAQ`UgWZJ^NLv;E`5Gd)dg{7Z5oZ6Q4_2uLY*A_;i_RF)`h-SYaaZiOzc6 +zA|U_|aH4OH+TH|(;5dwrG@CTrMs6974jm(nB|AjTvF2n7To;M9|Fv-0#>2O_o_;k; +zjG@;Y{c-*R+mZti{8S!Rm}+!0XyNO`j61JCW4!QQ&o@7f{vb1(Qf!kMo7)Zsg~wnY +zU&^ok8;yY)%mzgrS>>a4P=@YE^zEpHn=POMQDzNI84s;l$MgWBpP +z=7Hy28(^EuRwk3Sas8JUm~;oqmTZA#-wP?S4D|*Lvvxi&`SXD1Q)0n^zjP&+jGhql +zuoWW`do;Q)s4^o*K(h*j{?ZfiuFmI9+A%u27v`9rKQ(Ud&oQ?mS>6n)HC@m|yRY>} +zce%nFhyN-P9O=|FH=ziOov<5w1LHHadOB++E-x63VNGb{5m7?Q=g;qS$hAdbf9aAx +z{a6Q$MSPXTjn5DLwZmWbdBAw^UKSc?ws~T#h0o*FuI%J!@51jH$rS~lyC}~-4`e>A +zeVg>1wMn_a=S$dMS>(Q7?xC%~TY}*QJRZ-bI2xIpz$ELK#>% +z&LLTuzP|t9m4-&inSc3aOsitm9r^p?vS=QI}L=#t{lim|~=9(Uu +zw-MIV?{d)Rxnp{1upz(x$4C!clvmu^2fP)V)P{QbaQDRZJyAA}Frgf?CYmZ|lw;<8 +zYKTzsA6+T<(B0VCGXCDitcEvobt|>RV*Sh^;A=!wTGpz(rKRzr1;*B6M?Aqo +z*698AIiMZIT=xIY28(Sm?J`?H%yY!dar-sO5-a$qv%E8wkn +z<5)Ge1=N=z?ZH#3OSHRw2fH#7_UY@F;E>MG2ERs`qtWAwubb|TGRM$HYj!OJwZeMa +z%QLE0tL2p!%MiI@etonj$^xydxZLNbDgu(-TE9hEIHD5WHEqzeQ25=74_-|Kk}gYO +zd|s0`lpWOklEHQ)4y^d_wo6>x9Zc~hX6z5%+JW;# +z6v~r&Fu$zt)M1A_=VvYN_8vWXukE4Yh^B2n&W*ToN{Bn8n^(qrH=x%%EX!HhL3q2# +z+Jn^o?2=fK)(q{|CE3UZg6y3>o&Kz8aP!t9FUh?_MV5$;@03HF-`eZ-1C?YY~cvCmu&u%xHYB!bPUtF}=NNl+~)ym)<7uvdu +zZTywI91jQnuX$-&J*l+w2jdrCJ!GCx7_-f8D2}OTdZ2LpUNx@w@^W!RlhKc;cljea +zMH63he-Xd%QT##NcQ)8<%-I4;$)S=Y!ds3HTfuK5r@_VthBo_DH`rZ>LKk}m?Y7I6 +zd`vSS?Rz}3!typw-wV8f)uG8P#^jc37LsP4tHZKTUNAl@pUM&M&1T%ZmF0I=9&wFX +z+{y5?canv!hsCDMk39R=*V+HnkCuA0JfvN7nIddxFE8!@I +z`1n~*=cU|K6#Zt}L#inhFif~QeChjc8`$OH6m{R@*W{F2UUj1Jk>$BQn$gjgM|_#r +z3c?>Q$6#N-u{@gWV8m#ZjP5h4mMSwX$1Yg*G8ZY9XWIzY>=fr+Dx*G>F76VSu^e|n +z65cOms6yR@O5(%uY=@FjTO*soVBzI`{k8aKgL|$`b$!m*LHoHtejE3UkG}a)Qt0q; +z(#&myNK&BnkCEZL{m0fD8iv5c=W#-EJG$3CAN5tOE~rydz2ZwFDzck!q5-B>T49ft +z)l9rq>UW8n`UGjO +z;)cQ3{1I7q!QsX;UauTaE98?SOffc|q|~l}+c}@77(2MP@%SHhq2DNjUVN55{Rj(p +zw4;@>UFW5y-lK;HT4mk!RZt)$VoyxGz3=)A`N@2XuH$ +z#hk6*4?D``%{s$9HJ}D){gbS!BXiI9yyS^36|p|Qd}Lgb?nU3%Rkz_l*1t9`1{JPV +zXUc0Hm{8E%jPJxds4?u9LT6P`T6*^QOK^w5*YERbW8-|aSBF7m<1Y;k24yfWLN%3HGslHn;W1`&MB=n-h- +zP}4s++x*A_Wcd2me7~uQ1L1le1zD2N>?N++6oj%%yl +zli%F+stfRKUnkggXUaS#cI>~ntCjbbN9y}(Slpfee7EPd>zh89<+-*7FA|uf)(#cs +zC3+HB>Altjvj*NoYo$e49nVRek@cF&;2kB#f8Vh3taSKsl=g~{La~eX&5|4Txg-p` +z`0rye4FQ)P+{m>tjUoGfb}GxtkC{L#ZsSEA>x +z=f?^@;pJnOQ}12l<6n5BI+aC#-dYTUtx(0Z1>hp&AK4dDNAX+7-Zho +zCY&0MNi=Mo$nVGOE_q&V?^|Xa%+D$4cX_Lo&vzb5&>eovcajcQ?<8m0=7xWL#}v07 +zeLm{!dlG$eEcBX|KX;;4^azVR^*F?=%dI-7;FANZ)!^=nR-s=W!*|qK%KR+$H}<#? +zMU7w^ixp3UJKZBb^0G8Jewj~%p$z(gfD~t&!^XIxBL#=BFWs@_M_llE8@tOL%Gj2! +zeq>3$f*%r!m7Ph|)Nq*?;yQWw^X}@f>rE^A9P-YTDOT(^u{rx#Y*tyd`CTEE6yxX1 +zb4sNylca@@6^NnV`4_e9eZ_YOV%%oxSY>u(PJuYa&8jTjeZ=+kWpdPR=P5r%acgJM +zgz2+@%Qg&_DunS?j|Emr^V8YL|@X_lx=~c7G_E2-c@xl7Fnz1bBxRoN!#e-hr2TE={+|Ra#SO0y_DpMA@KK4`_+1qBfM6N3 +zN7?`1L;CaySdq+k35;sGHC{ItI%y0(bh96}N;7Mb{07}($|K)rN=n?@UT$KWpURwq +zb*7-aDfl}D%~kN4vB3fr2L|Rb6n)HlzFel><7xdoENcvn{Y1<2CK6UaxdN-m|Og;rhk3o +zVh@M72K&33l#OcXgkR7&leh-QHS;}=$6eoGJjY{4oYAjtKTrnLTyK>AfHR&~{Dbdl +zuG=Dy)65MuWj|3i!Xz`<~*V=9*Bt3l}iIc$e=&?x%$w3z_k8 +zex^9hn`!fkFW03095auSq$c^!cQe;wp~q$>v&LEu{wprkTiHk}owZKKpE4J`m!p-`TvL>gwM!bx2 +zo_V)MtVOw-Qx+S%*u$7v8>hVvN4VLxAn<-o>&6&0iqHJfg-nZ@w*Y2lMa`0*C>1&4 +zSnVx1@jC5lQ9jRvSX1_M!2B+e +z8tYoA87_N%v6-(n_uY3M+RXAA{qH>7nPD}FD=1+(BXQaWxDh+cIp$tmiyL9{0{^TD +z{dr_w*J3r+)$z?-ujQ1ygWj8tWsUR#UF3vF?;E#+fem&|((XRBym} +z+Evaqx8qhMhiNqF;n;RjbIeb2BX3O18wD8JeOgS}tj4-tYK}WTzu4Rt#eF!hSko87 +zeYDU6!}N*GFu^fyOsEH5sS)dqXm%Zr<2w#72u!PaVW%<2+?~7N#?pDCW^vjFr?%jN +z=Z&6Zp5P8F^4K!8jytfhYaR1t&59o=FLM}k%`x08JsmZVhc!#q>n!TxtC`;lS%q6X +zFL2cmj=OSE7mm4$yKlfxwO~4AuP|l86 +zqb;}{2YuAYN4V!wn$!X-YZ^CXF6mktmvLlj4bDzYvSw&4H*8VYTIP$Ik)J3pazwG6 +z#yHVIo;ul){Jaqt9z`D>)czRMR~49P7guh`sW3rhVb0_#a(!&dX4iB6!jd9xWY|1 +z4Li-bu6Ep|$y9ZZvvE=J<6CirMO~+vdNs~JQuK0cGe58jL`+=!#+ +z)W$^}<|f_Dnp0d+lex}%p~sRqOS{NLl=E?x`y(U0!Bxco=@hOF41x1FA|EpxZ`yC+a% +z2)4j7{n-nXcAnb0>iY$kU(S3PL+yi4?_Cx@{-nKBIpRFW(~TVH#ChC#drz$-Z~X{d +zy~_?u&pvT?$C+BH{OCcY+kc&%z2blWa{oKucQQWCzT3X#?1#3d4?{3uVEPb)lu`}tvxxT6Yzbw8($CsW^{`H2f +zPo)+qZoJQMA2p^86zG;{B?ih5{gL~G5zt8%7Y51p(iCpF5tr3kFCHoC;{8T`#jDg| +z$a=~NUe?{)0?@u?YAD6Ux1N?-XELJ{RK13cAr`c3F2B>^p4DbsMVsuVX(Y;P2lrK1 +zF4-D-K2HBwwgO$X!?v1Xo3;sd%5r|YNNE1Q==ZGM3InNF~xwLZ*NJIJlR*_x7Nb<$!`^FmS%3> +zsmE*$8Qi`mW8u(+-63}p8WTdwbSmDzJGZCe$x_di-X$B@WlKF>yi3-zLzjB)^e)l! +z)QLB#e75_>Xk@%e{IlI4XW~uro~5s2CoW~{zZ>|i;!?ax`m-0w#l?HmJKL=ex-uR# +zc>8?0^MXGsr(P +z=Rwwo2S(@p*XQ{4eOR%*d@GYZ{9(n;^6!{tVT0FJxi25OyDMaWqVbiGBRUm-yz@#5 +z>CmZYNUT;Hy1P5Xb(QjpQPG#c*qtpI&IetSQQh%8^l;hX` +z!PD1&b514ufzjD7&Ieha9#q!1GY_)fJunLJU!CK}|B$+^d<(N5H^@|aCWefxttd=1 +zjt?2pskrzq&9-9cQqKr)qjjFP@x^~WTajFRbFXW2`=Nv3@q1nA?ezy)9S;iq{a57h +zdpr27?+S5FEV>fnsZ(*`or`V7y``R^-n}=9Gxlovd@(!7Vn3*S*S_W;>-B@e +z)BZdEU|j!(A2IF)|x0CrZ{x4ct`nCCL8c=n~2Qe +z^FDZDzbrWzesyp7PJo+Jhfj&B}F|OD+x$uZ~*AToN`I +zxV_wl$?pHqYCdr;N4w_(+uvV3M|=2#+181bIrbrgf!oU0GnWJpu36Lh-O$C|A&Cjq +zD~7IEhLG2Et{OV9DVv2CfRy|?>%_KEo7)MsQp&%pT6FmHD~&y>BaPwhJonm0Z0 +z^Y(Yo(H49tGb`6&9>EQMTHUETw9z7DByl7*^#5z`+~b*i|Hn_1kVAwJLQ<5yJ2>RDnxb@AB^0p^O3I-$=h+nHlv652%uqv) +zCEkQlPSu+^M!aVWnI&vCw%NVizk7WizsK+M{p0uN@Ansv2bb%*Uf1h-UC--vUDs>( +z?%h+oYGX**A7AmV+AG~G&0)BGM7k(vzSn5;m>OgL?o5N$m;&Rv6`JyBE)~5`r(wQh +z`C!8ZMK7hRQ3e$M_zGfmQ~EqMz9Or-DI+k|VR&rB{;1_JVfLy&swjuvyJWt6s_5%% +zFU8LvUX-)YyR@$s-oN|y%!;;+1Vh~#E%itz0iC?1;a-O#qM==pvh}Krp_gNPU{!UP +zK1C&d-t21pR?6A +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 +zE`C}#PG?l^2+#$6=_P&B8GX})BL+= +z4Ax?TArhA-io-eFriaHl;z3l1ii+I`pqOwjukAp02B-d>SkHopE +zafAx2DS^w1=$kHN;2QyEIEKhYh2)aM9BczXYkR5`71^2) +zM55^}vOKSf+9`pD7Aso+IKyN3s~F!f3o8N5#fs?fwLEDC8y!=!{T2B~|2&Q(vNn6E +zGz;$p4Y^JLAC0lx4Q27Z9cbK*Y!vRbYdu8~ZAFpWZkDbb?9{kVcL>O7lk03q|lQy;BZj^a*m`0>!- +zx%PPKy%pGK^F9n#1G2)#vy+f7N?f#7`6=5rz#h)n4oQ)bu-@DaysG6Pd4J*=5J5(P +zE#8MA+hhzHQ#(KoZ%Ju~8jHgv=oOJ3K-08xXvIeCwR%rT@zWZdm42mpS&>EUiG=XJm;kuix|mF{yeS +z>4G&{)B#qqw^L(p(T$C5&AH>>uQZMiMJc^4FZbYV4-Xkj=gvffL +z!T6404i61xC4^gx2Crcr8s=fK@)TSF>wq1Wf=d;z>ro!yv%mQ@<~|vD2-@l^B89Rk +zB*t>2&`%N?!G=Ztg9PHFpw*saP5U&RRk*aG!Yp}Vj)dd>Ar;^{CXo$bh&r;fP8&pV +z7Fzl4L}4su?`x4>fL?7g*7mhPYCNwNyt{`2?_It;%Y~h{4WPbLhgQ_Z6I|mOJB6vt +zAP?In`?Fw%KzjwKqD#T!*c|Swy=`dR;jsbPM_)D%2vviS0{ly`OQ;rYFN`jkP)CwU +zZSY{6qCGrSggtj8nJB3I!sTwBUnmyNEI65`?Nr?5u?10M^}=X|uOt*I4$XGn06E+! +zzY}*tGyB-EQQWq+O~xv_dkj5Z_MYHi9@Qd)@Tk~4WFMR4UI{Pcn^T%GC+-CHP52bF +zOL7mhZ>{hxJ2v^^c6*TWxoNL!|S42pHH9*+ZkjBs-94^v@(B_BkU98 +z=;~P<59(!gO5>@i;gO<& +zkh~3A)c)mx7kfMVc+c|iiV~6PERLWradTw>OW)33Cx*Rlf2!{3X(rQWGmjDSC +zXJtUr0&kF)M^en^%cUrZ>lcEQkpg4kT2Vqrd`&b*gSQXbhc +zMvAN@UT>aYEL-=y-J}KYBU|1{NFWL`Q&A-e9Y~I-bdnQzcv3qOH2uw1P)2sT>+9g} +zcj$3MWs@#i`g!x9vkv@zhXxw7#ugcC>GiTQ=i!0^fsGw02ZQ~q0XHx?P&u|Gd3u;5 +zqKwmxp*11Wv2K>?#xeK|UaIR1UzH-##iQbR8?aC(3S@uO@ +z9V$r=_AKdzM@2@P)j|70SwtqRU9hEyGH^w> +zHukMi`<;81@ZnJ_{P-)sP%I#O9xNdhf$aj~oB%-e!zcOsn(W7A>7Vl8m>bY`snquiBDcQBkUpGX`l52-O0RlP<2E&*w=uq9TQF0{2kxeamQ}`%+!_ +z3P0=t`!dVD5RKUYZ4T7B)U=4hj;Z9$iFx>bQOUIv5%ztHoAfd>CT$9S{y6-Vog4Q} +z=>|Ap^xAg#Mucrx0bgeh6#|^Yae(YvTItL&)pF5|R#_4DPR=U3=%n9> +zsF~~)F_ws(GM0t2$&2k*zc_438O>VO3%K%SUy7UW^sW^wv<48mdIY{klL)=$yT%RC +zVd#FJR%}XmLz9^gbN2*e>6MHGoWNIY!lLzKP|8SdrA-1=oT&Ehm7bifqAOXSK@sSg +zkcIMtn$WRn~rR3}%+>&ttB-lT?G+kYch +zRydK}cUIzIZH0V|T+|G&`#N+E4wKM;k9^wzKhv8Olrrs(#ul)tqg(UxaB8`vhtL^i +zjVs@mje~lfteY1H2a_-Xfv=gX#{lZ?L1EqSX*%Ss+7wa`PCF4IkO%)adD^`u8jZQG +z0`2d!qG;&M7TGXZQc3WFPGYChyI$Z?4?INl?-nR9o29ea(1{Y1kF`(whGGCnxSrR; +z@CNX5Bu1R)7IqS$_=t>zlUVqVUw1`BDQFFr&!*or$UGBX=mN@K8L!iRU7Fs-U3%=e +zvmR0KJ>_!>;)TP+N9{W)ncDziM@7fZ1BfdNQaU+t2Zsx<4ZW6a(KwGLTyU;UKac&+ +z?mn`dUd$csQ2$Iz6GYzmI(Qs0(VO%mQjmawnueO^6pWza_huy^*X~)U^F3kn +z7%%bE8qs)jgC~7cl{}Fcda7GfMQ5)i7~O=c~HW_86QGD@(=U_QinUm&Z=Tgm!6|SnZM) +zy^P4y(N&^4EMF;iENY2RIyh+>iR)v@w7X96vV%>6F(*vb4m2Bj0~yjrT7aqLJcImu0?QqkJJ0bDaJ +z89l|Tz7e8aI3#=FAry51Az3QZ*s|f +ze{W{xH5K{k`7hq#H!k7c&@PK{bWFv0CG_BR@u^DQ@!#MxTpNqm)rp +zoQZV>e8VPtG(b_9;U2F{L+ly4td%^S#bGb4gxS?VA0lbLQYz){cqElnmI#HQ&DJ8; +zb+rT7JIW2sGfO3GBsYKg)iC(-`LCJ7Zyd&C%JIDmPIU6T6CR4uD|@323_Fe8T{0$} +za8ENPafL%0wPQOv(b&FI!&wI>uSVjAmyE7Mkuu&|6tG8&)IYbhGA#$~6xAhQ478Cn +zh(2lUZ+|$5= +zbITJ{dz{bu=|eirH!Qy3@r}d5Pb|ratwa>Cy4h`^k%{pYI3Dcjs9a`-w{=D@M> +z#$N~NNs}&@Nw;v=phin7gId~oI7l=cEG$kO2dY!I?CZ<1Tq;FjA6o`#2M=gxKECwf +zp&B)3+a=JUB04Zw1%tI*>Ynlm8aJ1#xxv+}!-uBEU{>R`-ioXpKro}2FrFOIkb +zW>{9*jD)rs1nK6||D8E9j;V8=EKgQxj9_M4YDBOX3NtbqHr(j2XpWi#g>6DEa6*lSH8X7W;MV4?l4UCFQu0rOR?9+ZL6J#wWf{y +z89RhWFyq)Lkd88-q +z&&`>deR0__Xr{R$q +z@SJlGmtiie7Oc!`u)ywiFcDR@8hu-W+OZRLgb(?e;PQ}u2U1lE*>+az`cwwCErA6`OMGE?L +zvAB5Ge-K^qtzd#{8=^~xM)g}8FUw!g3;TW~YU&hop*G2DeZ4#ol@4MjsS2W|Z&O}f +zb~LK*?rhn54M0%dZl%w?2cEg5Vm5_k>Q$+u;xLyDK +zyJBg`>c^iRV736rkwbHP*8=fnK6mu-65wTh= +zm4mQX5c!rLvDe2-f_Fo2H(}HPvge@#2zwdPfZLw!`gj>o-tBQ?I;@>@%jKi!2DwCK7X^1>2 +z@RnO}OnT*gFl3`Q=SFBV8ENr +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 +z@>I`bFOJ(}l?zIoN%R{BOPvlI2Nz%U +z0gI%(f6q2k(**g%m#04EUBMm5z3;lfP5B9fSA}ABc|GiWn5Tn8UY=aQr4nPSqHcs3 +z={%S|ner5^pSQ!#{a7WTid6o%=MyW|*Mwi5#_=vM3S)NK%o;D=g1!9PDns|v^s{ec +zd`j4fZt7=vG@Up$|9bK^J@dy0ekX1`5j3fi!qB6jc6fayEN +zx()jq_vCmVLXms@trb6fi$=q|lIDAMzen$Mi)Oj))`^>=>XrXQQg6?C?9Pq*1$*z& +zAQ9k_vIH=x0#-?6q~aTVPz4cR6@)u(7aj91sBU;5F&r~jc$cB~(mEV#uM=-LOrIV| +zv}ziuy-k9%Mt$Y^AlDXiP2VnIIT5ANzdJmiG1-n*RD2Y&>-DYE{*6t~u?|08d_23d +zj(Ty{!#QYjh!mC84=e7Wcsd7N39j-x0E!GPmv<45_i~0l|3sUgLX9^(#(u1BvT^Ho +z31@#RdCHN49=f&qvr1rd839J%WC9q0hmB1>2RRXI7Rtc;USS7GZV3ois +zfmH&l1Xc;G5?Cd$N??`1DuGo3s{~dF{68c>1D9#(V*Lku!Qt(w|A#%Ts$M0qN??`1 +vDuGo3s{~dFtP)ryuu5Q+z$$@N0;>d839J%WCGh`)K$V0UfRU4kv6B2>J$be< + +literal 0 +HcmV?d00001 + +diff --git a/tests/f_dirdata/name b/tests/f_dirdata/name +new file mode 100644 +index 0000000..5abb939 +--- /dev/null ++++ b/tests/f_dirdata/name +@@ -0,0 +1 @@ ++corrupted dirdata length +diff --git a/tests/f_dirdata_optimize/expect.1 b/tests/f_dirdata_optimize/expect.1 +new file mode 100644 +index 0000000..52368d3 +--- /dev/null ++++ b/tests/f_dirdata_optimize/expect.1 +@@ -0,0 +1,10 @@ ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 3A: Optimizing directories ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++test_filesys: 102/4096 files (2.9% non-contiguous), 686/2048 blocks ++Exit status is 0 +diff --git a/tests/f_dirdata_optimize/expect.2 b/tests/f_dirdata_optimize/expect.2 +new file mode 100644 +index 0000000..3cf9314 +--- /dev/null ++++ b/tests/f_dirdata_optimize/expect.2 +@@ -0,0 +1,7 @@ ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++test_filesys: 102/4096 files (2.9% non-contiguous), 686/2048 blocks ++Exit status is 0 +diff --git a/tests/f_dirdata_optimize/image.gz b/tests/f_dirdata_optimize/image.gz +new file mode 100644 +index 0000000000000000000000000000000000000000..fcb7f4f866cea3160b77da4998ec69c0817afebd +GIT binary patch +literal 32121 +zcmeFZ2~<-_w=Zr>D=I45h)hD-2~KxWcP3jzX82r@-QL}ZAOc}U_2DwBeM$`EY@ +zlqoWXIjBIGgCIl<5FtQ-03n1BGM)1dpx@W`zPr}{-TS}qt@qaYvRIIFs!pA%UAuPe +z{oB6+7PV&0%B~9A6%w94mpt58O!lvJ-r^3cWqTx>p4)P+D(^(b{siHdQ>Qx){wkxb +z74`Vj!A%MEMh3-aD_O0D`{VW(O%@-HJ5W;CVq+~;(rQ^$We~&TO}77fchCO6=DvYE +zOic{Auu`i?tEE!vQ|_7gU1ASTWZapMldHq_>U5C<3i@AW%9pvG5_J|wh8?ixocd)S +zI@!9ntV}EUd62tSW=xFXgYJY;OYX&qk{ylM&ofU)w61D=t#TWvXuT7EnN-&2D? +zmupSrA0A+Vc7a!P-jZb(@*b_K$R5>&f3!a$#SkvEJ7J +zk=L#3S2XwR3-oVO-=~m3H&E$8=)C7yTTLbR!TUp;y_H5hY^`lt#}eZ8wLNcy-gLZP +z!TIWdt}Zr_h!tOhT1i +zM=F@V-I#=WWANc{>=`x3hR+kbTJ+3TIW`nbTxrp34>7t&oIRARR-6#9t*6&uqjX{H +zPMd<*owg;huPYo#pR+EI4rMu!3S9E&Wm@~`GabG?D2Mj}+f*(qo8NOJJ-O6_I#(93 +zP5F{C=}$*e!Ra29bFurj&5CZyk@b$GK~xXw&mg8=VPwFzfJ~?wQkgVY9P1W#frP5o +zpf`5>%GAq^3)nV5F^D};9J@0im;M&hgYw5R^+xwI^^Wu!#424>Fu$Mfqa2yxKpK?D +zqdz#u)H~c}5UY4a*&OGlOj=(W>(&KzZhecMf&YVmZAZQsY=lG2$&ZR$>6cp68&5M7 +z$kjuAR$5V{82eA^(M8IuCc^1L^T3|3xvf?=)wXJ>Tndj46kv(#@0m+w_@TjBTO +z;%KQhmhOf6*j7|8oy${V@KPI0N^90CtljG=?(za;j{VR81I$fvnipRPR%7yc;19)F +zoOxvrK83gP#6R!&e@Xaz1%Htm3*7w=JsL0bb&o4kuzU^^Fp$7mtam_Vc0PjdSCyDO +zyEFfv^(+K(?o}X#HHhvQ-(>HV@0=xBtZ?=&0mo*=HhlS1R#kB5d_!>&s+@Sp=jzEA +zA=mfPNr`ArE4OdW&q|ME`b572%5Iqj2v7X2XS*yq*%V9hhsf&0iETvfwqe1ee!jx< +ztAe+`YX-kQs@zUA%|P)*8E&VaGw*8JZHlXG;>uQXBtKq_srG`$m2~Al!@R|hPvPS2 +z%DUeWz)6o;*LUK+T|qAl6Ty2Gr9>_t>4!1HKi8xZ*S_ev3=hV?n8FhXTLr!O)`j9Y +zA00FxRQ|vrhRx2PBLy!8054k#S59PjyyBL=5wu5f5cm)T&7fB(mPT67X~?~=jYV!3agsbCi8Cjnu{j2>U#5ZtjGr$y;K3Bk0b^XPseLYA +z+NBFNJsPFjL4^0fR%XG!T4Ud)0Ke;sxBF^%>0x^TZVKknd6AfizbOU~NcxKIM%Pp4 +zCdXdbpF6BdDrpnjNrcggzhIigU1?On8V(P;e)F;!?rG~Qi@RM3U1z$OegXe5Te~c> +zcOdMzLaewbZAEv-`9>$KxlPhet8z@c%*$|}=l5Sfs+5fj*b=Rjl82q{GSexLeY(Z4 +zVI;8SKqFb1-smUZ|2F3Obyr_!YC!&nb;;5vTi5KSkYiLA#C~wMq6T-_trW`L9sd*= +z>4GeIRYy*ZoSDIBHzh>vA3b^F=7c7KPj|gj>5`mT*po;amPUluCn}$@w3ppHM0n9BX@rE1*s#fXM_Vqq6M7MnSFoe +zSvb&+TdS+5R5@yN2E9kK#)6H{Yi(^98*kpdGi+@9seWY|MXA_ZT1RL@Q?q6<$c3j;!f!297Gm*oT@XKXhW +zM5GJ=fN~BE$oo2-_c?Pbl^CQ$h40R}kz+wd*!JV1ehRC*dtF}Q&6*x$RNytdGrq;P +z_MzU|+jKyn`}P38@tnW!=Pely}#+fW1Aiwyti}ZlLyDNFK>#{^Ea0khnd#B +zRttTl`&)-3`pJV`bEeqT`&ZW2_MZ6g$D17+?%vqAdZ)62{GC^Na-VLfM9{;dYgd(R +zdS15Xg8W18;os###99<@>?$LKTxl?<UC{dY^} +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 +zEE^PvSx=NfM9<6EGomw8AksV0lhrLx) +zW+3oX@I)+!LdY8gTpV(^>PEBNoHi5?*-K1gUdoRdnY9!W(s2XWeJ}=V6mY2|O>Jti +z)A!?Bc7MRaPIXNoK8Y&_O2H>0^zDJ5Sb$b=r4noU`pk%B23+}X}PfR+se@%$;(b~;4AfuW2vDLMak +zr}r1#!JfH??JBH4 +zmN=Lm=WV?4egbLAR%uZ01?OWeO1t0+Wu5Uj=S>4jn-kHWK3muus=PshKFvg@;hNc5 +zZfpZsn;y7uA(h2CXM6iJrHQE@+cW*OI*W*}P5V?ESWi^COX5ohIXfH~n5%kpIM~oe +z;Cf^%Ah|@2N^YQ0gjJ(L5gbisUTYANh%qr3kzHSYaNoHj1MqvFm9YUw1!cVpf>0dZ +z3=Uk^rq9u7Z_bLse7}&S>ZdAnuaF*%8k+3D1fJW5wc{K5Hq!G8N$?i~_(sk%I;+hS +zt)gke?4(V`&Q9GWfh6+x&(R<<2iv`3`Ex5YV0|=r;4lEDb}Y~%hXnN~c<%zZ$xIjX +zRtMepfiB>fAYx1~W6_RMzpPj>W0hM&D_}cRvGr}oYnVIv;8DmPg;be1i|+Vd-j-9oHWGey$I +z+GZ9P|CFi!Y|o)*U~G +z0a+)lLTtD^(8`Q0#@fY*q=Whe1r8szq-&f*#k&I_QJ9B=B$?rjTmat+N}E3cH|Wf2 +zj-+kn$KlxvK+tQEQcv(OvBC_{!efAu+`4%;R?2oF4$`^@3(Fg+{o9>t>P2)n}Fs!eBxPPgE|sGS`>nbclh{(r8ev= +z=I!NL!K+IZ$<~Fe{m;PAr3*yD6`I{a(094Sst|`b2s&LK#8@ +z@#2709Bi^k>HL5QZ(E4Ca1ab?St_!N7jJ-?FkNawSG5;^;29VObz;PdM~qMWiph;C +z`LlXZuEy_QW7Rreeh|U;EDauQF)x%F +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 +ziL1_@nRNq +zb@o07DQ4eW>yoi?qI`U|+Ay%+-dn>J1`KAw(-m>=%kO$XV1r&Uygl_d10#Xfq8GBB8at0#iPPI~`Vq&Cd9%)N1L*L!*F$_r@)Z!xpI( +zd&!<_J?!`M!epWd?C(EUpTSQdjFjiW(+>_#bk;I-;+a)GzQjZCk8MNsxI}M@)&{}gz>ms +z*3{Z@A^eb9$UxDV8u!VHV7NVmPuU_UNk0Q+e~$+W#i=xf%!u344~r~0LtnuDo=}Vj +zw{>rpr`@9adS`l_sTj~?O?qjxDG7K`WMD)KJkP96-vv#`%hUBVb~h0$!tqDY60%}2 +zBc*WjVnMCuleHrV5$SAJSis`ML7!WKL}?l>j5D#p9(pMZ!a9|rZEMBZ{`^QS4kHndFu9|#;_m~$Dg(?Lh`X- +z*F4C)!KA`((&C6!40zR`D8D83#A4L2qT$T8j+=pNs0kBU8rwztt7oqtNzKxJ#`xoH +zh1rb4CC4(cnnngXqR7TsGw>p8=*`?O124|Wkfkq$oWb$?d#A|05DsK(6tWPB51+#8 +z+Q%8L8+T24gXyyi1?Qnhp!2xOH$)EL23bXCSeb!x}9U8tFScnTQD +z`VI*F;e^XJ!Xn$6@t*+VJ`9xq55p}8u@e~}aQ`gf{Nh6nmROL~b*{e4?me3xoh9d@b{Py&@k!@NdHWc>w1^7t@YFG=UO* +zA=dTT3{ +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 +z9i87ohGAU@@y$7*;$OX?DTYaWoYP!)QR!? +z$VCdIJ4AsbK-@}x;>37{Jw%?YthgSEq4Z6RhonKgO*};B?68Blm97xCk`M7P<)FG3 +z9E_{|PjlxA>!A)*B%QM*J2^sJ&Ax&&hA6PNW3Y%Z1)wmKhrQnVOv?M>}U+Jv;^RMi*J1VdmX)f8__AhZ?pwHU>u_ +zGAI*zAQ0khR%C>RvZ2|s^36$i4Gn`jvB9n@s`3a_H_RStI0&j!_ImDupIOWNfX|@u +zco-hfxSJxJpO#M9mr0oCMes6lFek!fZy~=XT~ZJ~ZV3IG5T~A8M0KFpdN99}Zhfs9 +zI*s{BSV&IMK#Nm&zWp#b(h{ei(C%A~>W;8uRv;^?^QA2y6Z4yG1|7VL`vMvU(!u;3 +z9RTUGcs$_;8Tk;%ayIk_lx15=Y}a49ex}{FdC-8g5&@lqmgTTsX!!$)bWqdsFi~%B +zmsGR_;=)ca!088hnu)x>BQ}eUy^7NYDoe6KM*Qh$5RvF73JMX;jmx?AmzYDl0jX4J{)o +zxq(Wg9C_!?{>zJ?=~(POSm+*Q!xStA10`wGOzG6$0-PIXe&!z1j}jxz4eT|c(wUa= +z|IyyHhBbAiYdTJ~Q>J1^kt#K5wJln(SP@Vl#7e!4h_Q&Ga*2u*FMV`e +z`}@oNf6kk_T5wnEQbve`{cWpX-a3M?K5t&IS(6^hKf~5ZZR@ECt01+Gn-!a}QJ$U$ +zwyOoNv!aW}zk8HgU^#D?ENGd}qz5;zr5ufR&6J}_tRXFu(mZwOzXT-I28yuA +zaz}V1=wAjTHm;YF&Ky;kppTxJ?fO$N81ROuRazbCUyLpXAyo01#B}$=S`GczKT0w9$gptP&fA}8vaWAs{;K-* +zhU?55^$e^z2aj$P%~!r6DI}&USa*Na3<76X0Z^dC1TKV%`{d3KEC#(ptop|S4F4AK +zz6#R)BaJh$4|rBqe(^ +zyLmC##JNF*)m@3?{_h +z4eFrHxFKpN1HAVN`$R_Ca|Fa9c7v1$xzJz%!gGO0!if(9LtqI+zeIwrpLTt|Be7%m +zspq&CO-ki^5-zl49gPcVjgcUCb>ce0zofAwLg=kaVTubix{V7>)biYF%m+++BUCIF +z$W-%H(km +zo)^*8b^?$c7RCfDo0ktrA=azAf|`iK-?yMNcAIZ964gJKw)o0o1>SgHZoNWN5LH4? +zG}d2FzYZU61q9cN(dix_t~xkSJWu{_856ib30(Z+o4R0Q+lqT{Cc?3YayYqh8Vrd~ +z?}69o@9aJ;#1`jGzMZoq_@C@-;D^v~AzTn>ypGBw5p7drtlw0n1c|?CFi3b%QswEawphgc|4Jz9H&>2 +z1dwoito`Z5vA3#Z(kGFBZynbLM*URw`Bx_o<^9s}v%UW{CL_aMfWLfG9{c_~54>)Feds~u&P$i}{`vj2Cw3kRaJBj5#=B3u +zTH>h@bIA!P{I@($l-_)of!B47YT{&FV=X#TPl+|nIvdzq->C4BQG-LbH*UceG2PHD +zRk?FJ`Co2hG#_HP5zl^?@U7vT!v7uJnMu#AS<~>x)1kM((FW%n_bcaBeFUj_9w~4*l?jCjX6>R5JOY}zP3)KnX +z-o66crd5$IMSaO$&}1tj`}1@iKEKaFIgPXIo2sHWn#`By0I};OKX;^cSrTG21(awA +z@JBCtvfkHdsKNIKYisa+aK|Ou)<>_W9v_RAcFvBTR?OzAdxu-(Vb(O9i>BY&1=vbV +zK5gPZ6LX8t`j%c>`KN?cJ~24Y)$t-C<@q)PCAt^H~Z2t5SI~w>$lFP93O?w +zn}{!8^Z75^N4lmTzZ}*SRN&f=%EvCiKRExCzs7?Lku_#0?2P6Ru%N)a^wyS<;1Ul{ +z+gOQR>2`CECeEzx`0fi*X9oeb1F!Atl4!EBTn^K_=k_#q90jBt~CwfB-p(u(G_Tsp1DiAmWv3v +zS-ZI>kbf@(MHSk+%g4?MpKnzNR@@T0f57(ix=@s`s%CP2Uf&SG^%9J-HbS^0P@&~N +ze4Lu2-A>=7@8v)ycPvBiaV2VgPyFa^@7dFbgG%XD5oPxyP^-k=mAb5H72kOm&g)sG +zcH$;3qN>-~O)8gy4~AItDLOMN+5E);zxE(pfN)EoO?Lvb@0eS}rZKH?eylVOn10sZ +zsn|HxxQ#h@IdeuNuP+Z!=G%6@mo%JGunFG+`sZnmhP6}$jDM%9@++HP-anL5ofsYX +z1%0qbox_bCl>38;-%yjohEG&t>E`N0WV>Q%9VNP(hmY7aIAW*sn*$x0q|;*E@8~{%D;xFUW2~}oN;fhd>DQhwGHOOu~X{vltzxyc8bKwZk~zG`ff@;$DHPR +z_G6QU6oy92Jiebc*RJb3ks2dE@7cItz=MAhySzQ(q0-<>urZ&>Fi?jS! +zsnINXL^Ly|h4MLr&IR~ru7pNm_X(S6{91lQr^eciMpJ1k#=+#?`rE|1SWL0UR<}6O +zD}LRbu$6nssr7D!s)_XgZx=3@X7=Co966i`Oz3n%WmdWnX8g@4vpog +zE2?_A#x*h|xqZw`xurZcaPbbB-8*t8UPDVmxGk?qXotDEaUiGL+OeZZ85Pv2XqLnu +ze;~A#w9jOzbw_kKJR8yqsOD=rGGxDu2p)+FEOtKvze5`fNf%>FW4~mvrogqc`atuw +zelm1@Xr553((kGZp;*_%89p9OP5s&{p|Kk{hbGInt16!Yh?sTGLPhGd2MWE(XX +z=g=vQg`o%tiQb@f1xZh$DHhvlX|uS-i;y%FzN690h^9kPJnJ%75Pb#guz63W&u44# +z3}7kTkJh{;;up_>=g(US>;&3fXS}UKYQ0-ea|9$*u`1de#L2?L6iY69peSG@iB0>g34)WAR#i<{>7KcYDF%`qLrYIm-U2mv0f~kBQu@FhFKY8fIwJGI!9io3(d+qF)9gEXL)gMR3>*IiOV3hd +z@&Xav{s!Qn=4`1dEGhMfjtBRrIAPJH77Jk#4r}95)(14LHKUpw5fPN9{zp~K>oh4f +zbssuO1e&;%+aqzF`S#=jOn#?I-;Ap3g1Z>vx$8+x@6bwafEB +zOYj0R!#jq07!7{S0&|_p;XgWp`xU@K2yDr8O!y`<%%bSj5Iwk5%LtLnF}hH%*-uzD +z^o+8Xbv!4L&KM?Z*X$zM)nXq$U9K +zYYRkqkZGB7iN3~_YN2aBtZcIsH~5ICT#(gHu3V6>&tCogTW>xSS)}bhd8;i&ANEn^ +z(eTqcoC&wjZ3{N+f+DeMKAFcQq +z?yxegNNR!IcpnD)F)CXqqFqWn2Yj011Zt@po-o+?-pyepm6mMX>_kIZKV0@`y6)w4 +zU5^Zs*>kWtQEL!IA;I@UibBbimW*>qrcCY2g|hlhQrhLFc~buDZ@v-Z!3CL?6^bd~ +zdx?SEAk`H7W}ywbR;ZB4%3(XUeGdhdA{`E=cn-YODfB91)`KN?K5iX~C?T|14z11> +z6&thml7)POKqxS#sZ2&RC_s+Vb!-v{kmfK#^AJRYT!6W8I)s}S02;b>cr*HgWN3iQ +z1S9N_CNZQpQ;Y-dXo8uUz1zE;{+Cp>Gpy)m(X<+sxeZGcrw9N*ybLf6s!795@)Ee@ +zUrX$?exQX8D$zodhLS2ugUr%$QgX_CM5-udniuajfCc-=c3 +z2S?}?{MrF**2M-QD$v=f_0g82MJ-!VbbgS%Jjon-)~To=FKalln9r)ohU-c_^y_8i +zmP;t!TgN*cq>N83OIzpEm#`!5%VIhD!g~sHS&=vpbA(g9$9S3{k~h2hP6FttZVl7Z +za_pld!UxaI7xAk0C02x2t>AzF>+G$zr5KgbPAe;NuK5*j-;ppq!EfumL#g)baYtsw +zFHy!iVb3|)oY^#1f<>>oC5y9>MEY_aZMrufSS{TBoY0#49Beh!`2^lO*AUMWuxfv~ +z&n~d%u>6Vnp29Dt8XRJA?%Lx@0;$CuFd)nBm^t|%)bnWb@`vu!KsD{%bpl`)G4t^3 +zRYFJ}7HCmb5kaA?vQ2yW*_6F>3f_%0!~QtzKM>5z%!Zv&fnH?KpUP)R-iaS^buYbu +zN+a$$)yAusihSl@NpnUB9GE*-SgSL+KDC#o*0a+ +zNCgvFsp~C3^KF)zJ+ScgAdp@D26Qd5OGDiH#?>HT=0d%!(t4$pUJ$yY)Nl&|ItMKd +zgQa;M1& + +literal 0 +HcmV?d00001 + +diff --git a/tests/f_dirdata_optimize/name b/tests/f_dirdata_optimize/name +new file mode 100644 +index 0000000..1649a37 +--- /dev/null ++++ b/tests/f_dirdata_optimize/name +@@ -0,0 +1 @@ ++optimize directories with dirdata +diff --git a/tests/f_dirdata_optimize/script b/tests/f_dirdata_optimize/script +new file mode 100644 +index 0000000..52cf88e +--- /dev/null ++++ b/tests/f_dirdata_optimize/script +@@ -0,0 +1,3 @@ ++FSCK_OPT="-Dyf" ++SECOND_FSCK_OPT="-yf" ++. $cmd_dir/run_e2fsck +diff --git a/tests/f_encrypted_lpf/expect.1 b/tests/f_encrypted_lpf/expect.1 +index 7e215b7..63ac5f3 100644 +--- a/tests/f_encrypted_lpf/expect.1 ++++ b/tests/f_encrypted_lpf/expect.1 +@@ -1,7 +1,7 @@ + Pass 1: Checking inodes, blocks, and sizes + Pass 2: Checking directory structure + Pass 3: Checking directory connectivity +-Unconnected directory inode 12 (/???) ++Unconnected directory inode 12 (was in /) + Connect to /lost+found? yes + + /lost+found is encrypted +@@ -13,7 +13,7 @@ Restarting e2fsck from the beginning... + Pass 1: Checking inodes, blocks, and sizes + Pass 2: Checking directory structure + Pass 3: Checking directory connectivity +-Unconnected directory inode 11 (/???) ++Unconnected directory inode 11 (was in /) + Connect to /lost+found? yes + + Pass 3A: Optimizing directories +diff --git a/tests/f_expand/expect.1.gz b/tests/f_expand/expect.1.gz +index 1015e155ca93f1aea0edfad09be6e795c0ab1898..81fe7dd67f81dd64100b5fdfe2884fab129ab721 100644 +GIT binary patch +literal 13461 +zcmeHOdsq{9)`q4;Z6K*dFrt9Ub`=o`VoEloMy;ZsRsjRbCQ1V8R)-L=K!_KT2uiw0 +zBVAAwibyFTkRm81Py>WZ0V|5t5DE7|DjG2mE(wdLxv!S&et +zlg{{4N;3cs +zyYG(;A14}*ty**p7nosr8fS_vT`NaC*ZebO%dPM)1f&&dLe;FzivavO`SYlqLe)E) +zX9HK(%8#ckyA_@x*tFug)Ld-oI{Bo`rzwnE;h6%;iZ-Fjdb2xlWu5$a)cZo!%*`m^ +z&{}y+iruZD^Mds&o=Z)`My-`k%FM<_t&>m6^sn-fanAnDK{+R|-v3ejo_gBQ_koYT +zjpZ3m^#B?u3;}Mzl(H9Fb +zy-U#qgu~6~TZI_iQuInh=FRB-Ld?Wc^eTkIchNI1W8lu{HHggbqFpazkk06}2!~q> +z7tC=_bBnk3%rxuT8%Q8y60AMHG;`P&_#qjSWbK({wrgMD4l?G9wWq)=b6+5xjQQN! +zGuy0dpU=alw?{%hQGGsBjPZ0vZ$)G_M7xSHTb$9p2nR*9j~KJf8NCgWsfa!x#soN{ +z{Sgj#qCXR3{^5)!pU6A+M$E~hXY1$eKsYo;-x6b(&gcL{W@B`}7{hi((-02I=$R5s +ztTQ?Yk*SP!m0A$*=EHdR-*a<<{ +zZ(QCpn(+g+TOma$ley}j4CKx>#I?{hP2u%~*5!5#S5#3vk8-`rxvSH9FtmTp~ +zIV7v+-b!=$-Qw(jFoDUB#sv@%}m1PMr?!DDCwd +zu$AG1-d=44a2MpZLM{t(+X-MML1CRj8P9K_FK!q$&LEQZ0a|=IKN# +zu9#9Fu)M>lO5yuUt%C8p)Xc9`31Z460qG8-E`|ShDK;4Yky`ha>b#h8S&(>#Ay46x +zrGCNqU^O#ORUoEF1oAtKmJ~ik8WD`&uh!+M%Egpofn_73D}}#9dMX$nrezXPL1H6gFoho=RRrS?tC{&KjhIpw?54hFdECA5sM!pQ>gSszN1{dV#!&;gQP!NUEjd +z)782{6<0#}PGH&0_#lsfVfCuL@##` +z%76mlJn{o1?v^c(=>cwt6rO@=v}G`_z>pC<@nK>tXg7^=~hp@RZU9{CXx +z*JKM6dVqT)g$k$!lp%#7BYEUrB(BXCka~cuNTC+00cAh|7LTk!;yP`CDi81zsEjq{p%VEf)Jn|bToS7YfAb@C=5Ub&aff+g|5X~dMiNejW11t&PVwTWP +z!!3j|DqzSM9vP0pS=a${2_TLojL>igp$sT+j7Of1!p*b;90=eBmhco*qcek92}2&| +zk>5h$tn2_M0_e{YilG{v89FEs%OjhkaC7VcHv+hqB~(B)po}UQlE)(>Q8-(>oE_9P +zjmg)v?}kVH3IAWrVRhs7Yg()DsH`2-KjEKqc={&jh`q4isj(=dr{$V9$^y@T} +z#4b8mox?T^b!&S%WE_J$-Pk0*@6u7isqJy6mKg_#qh0nZ +z4a71>v7#}-R1(Csm_u`dEB}Nqbq)qs_{jB>!AUlBA)Jy^5epQYdTH<|5SnB&PY7S1 +zQ}IVY;-$!0uz6Qa*1MJ;H4mLia1;$Y(q4*YoQIlMZ8B|nxsQ41 +zeAvr_npJStEEpld)UMhDwVMkqA#4ulWBvnOW(FI-U-am{@$*{3BbNollHO6-_;6pl +zCMj>rKGsGN34U(*!z7s3-yS9*yuR+9rAtn*56Ir~Pa`T_b7bVw!&I^+xvar)hS&c@ +zyj8M&3)hQyiLpy?AmaP`_Qwd2!R-w{-B5tZ-a|kJwmFT9bAObljBoFHMqf_AEkH +zgX7$DmlTc`Ui%`hm6JTvJ_a4vr+wV%m}}swc>s~7&uB&|*+LymV*h-KT42a(ewr~V +zGwW{Zi@TRa_$_7mEq$8(OUaV0JFRBq$N6qwS1DSk@cT@YyCK5wKeX{oLayPMIvXGc +z>T{aClDcNWdAcW^{ +zjhUTWA!-1R|B@~W)W?|yTs6rL;?7=PE<%IH%{5EltOc-=DMAx#OwvaWeEQ4=p3&ET +zX&bCRN&qL8Y)N}ZljNPflyz-u_Fo9^Djdzc93!s9X44}!R*}eQ%QZM!4BUa$a0 +zuQq}9^;ClTUFMpz_Kl0N|Je-+n$t5N&f9{&H3p^t7h|U;tc6WIQS-6J`uUTM?Dl$# +znveC^^8ObQHJ>9?K108JS@aK2caRFV7|S|uL)d6xCxoBe8Z#}o0+N!C0-D#8?mGHY +zrT1k`>S-$S?>qO+S~TcJyx;?9R$*C5HUw`AyDT`$HwOBm0o^VBFSLtq%=VlLgaY&f +zG;6S|Q#K{u76DoCKY*@GuR>-2%h#M^O?#*9;{NcdV+L!Z +zkYr8RlS6vv+`k?sMQ11B_f(N2_^eLHye)HB*MuY_;hvDRjId5@UtsW7Poook^`Q3u +z6}seSn_p=D&k%lpJnA<;1N{7B0jEk=1Wd~OLePDR#`|;XH#J@(^tRGni{<3O2V0^@ +znp|{*pLxj=&z)A&0<6}*pq+5-6cYbBPdVYEhJMXK<8Zcch7*Y#b$Z#s{=2GV`*y9ar|({R +zdkLHKjoxKc>uS8)Ka|Ecwi#6EWh3Jq?W4V@^4TMlzENquv9_&lHfQiVqKsp#ZXq5V +zzN?lR`$fsJ!~MFtVc8{)w$pfyJyvKOO3bE?4^zh*)5i^Rjvggrjp>a8kwm@fCVL=~ +zYUq+3s^fJ`*!LRB%87>cUL6O=!G4$YfKs;Ba5F%5Xn3HJS~7809Vr_Qw;QcOwTP&O +jft91*+EdF8AJX^ABdH|@O^5%H0htNwD=q0!0?g#!cRwIx + +literal 13462 +zcmeHOYgiNKwuYvOx(SIb5(0A3vRg$3o#;)C}6sk +z6ZCk&f{2KO5agyNQUip5sP)!r5oytUlMokfmFk`qw)XJ{L^N^*uf7;3EH%VeM&;{8Z(%kVAD-Se)eVYCRqEq)d|*n+NA#PdvdVm +zXFalz@I;R3X?Edrj|WNS27Z~gy8r&Dht{r?8jk6wn^!z)EQO68HGNM!9weHm;Yoct +z*gi-{bIvI2Fvp*f_vym913GP@^_++K>HJ*Zs-%8hnYPAih?6Inda|ck&B{3*axt~< +z>vd&Xu9!w$mHU`t?4UMY@t{8cCfVe(LfeE^T%b(L`t0`hJmHdAgHq#()eDuwGXI{%yuCeN$e49sq{l6r16*9F9E|!x +zr2k+U7D!m2Ov!S;-F;HHXx5i2>CmY9N!WavdwMP#0^Cx5T1KiW|C`;QEWUO*$`K|ix +z?q|9PIrG;E)14P=^#6M9M&WVi)Q$dGa{=KQ=Sv&?v*$85R;?khaDK;;p3#vv))2Pi +z{Bn>{(UC1{2ppW>31ohB3(*XZ`X0oM@;ZeUu@@hr|#JKh{@jR{&tt|)K#93Ab6)QwewTf +zHJy(jd8aS8yR1B=Iycdv8>{@>6NpTw6Hep&ijYx2Yke)G-H|T`(IK~%9lm}vF&df@jUnw#_Ch`fLP=)g=L$=054$uj;IKOhF +zXKW;zLAZqTt3XD@M!GTxS8;x4k@>N=+jr7>YYX+qw@3*myz!gtJe&6%loEvAc)%{d +zc~6CuQ0k43we!^Mxh*9~z41)De9fLtDWS$2&)UC&#;#u^Th@mDCT#^%ag2d)!=W#x +z9b_s*4E$ppT9$U3sipG{hfzmR=ojDzQA)U{713gtW!{PYG896hDa`4Mj2byA7yk*|y +ziZQbE`!Py6K6{5g`? +z_P>FaH2d?T^uldJI`~(oCbr8ys*T$pL5?17-Iu3Ylw@`2wGUYO8$0({+_C+Ax%yy# +z*djx=+t(fJOO#L-Z03#nf=<@ALx2`%_ovZv>n8~K-D9vD4ZF=0)gjmw!EOxfYA7lt>{i}vt*rJZuP(w()p^dr +z_T0FM@ZH`OK)X)?qhPlMb~&*7fCA>j?i1Kegk3EKY=zwc*yX`4NC7=b*dFvPgl}qB +zC9~w{E%n7}I(c<5E=D&?q7e#PRm_~MTS2lUfE)nf#QFsijY#OJW)@`KS}Dr`$Sa|v +zV*N@EJ28@2Ox)+ +z7>o5h38P%-aF@)fU62@6!&|T*BEWsKXF@_us8PDiXN*L#bhwd_! +zSpvE&IEEYpu}k#j5{6W$yvx*N2^g~Y7;+qBEYa6W7?nbYMrLc4AXIiFhP(}8m+HTl +zFfIy%8kvu?1Z!oI81fFtSgHplj4I)wMrK!*AWWu?A@73NWqN~zQ6p3~GEG^6a9K|b +znF|@q^fppPtT&d(NXk~wZB=R@rC`U6tN9br&2b4j+~Z!+R$av@|quRkee +zsDy`_nL*hCKo-22Tnw=#`f@4bu29*`WMm6sWbvEHWhF)l0u#%pH(^K>Za|a|c$FQ^4L-YW;37Oj3G(ffEXXJi7k>qylt91BOGAz=`9%2H*UZ-AMg=dq=tCs;EW3h +zOdOy707I&F19tgK!5pT;qP8 +z5e~5V^d}h7JvZQ-54dTENDbG3Gh_(N4nF-UhIHQzkoka|9ikq%2Aly0IDEPRL(;hc +z^*-QN@HjenGaux!s}Pu-eEKsC>7g5N-3L4dkE4UP?LnRq4kYmD-58SI4N&@kB6u7f +zymN3yH3GAXPd8#nkQ<=!0W0Bgbnv?13^7scVH$3+{6*7;Tmv8Jp#k$ +z(=k|*n|o1c_`Jrr-=&^3j@3)%CDvE{0DEa*ioH5w +z>hA^-YH%`<6ksn1O!*_Ad_%`%6zPDiU>y(P42~q&<%&qWry=I6z%Pj;e|yZzly?@o +zVqF_-M$M>Qfo4rW{C?2zC5kf+K{;US-e7}W&s#LT7M{Wt=ohpFjp{XJKFQ?fUZFgh +zHj$dta-G}f5niqHV&vR099~t3rfg7ojXJSa<>ho@>rJnpk2y~M*g~zU@6s#9(*Q+y +ze_-KXDIcr74B}1k!LzES(APTJm+e~>var7RlsfqKFK9&Bz7-)zlh1XUN8$3_PzJz_ +zFy%LUG+9K(QBtbd{0a)8f%#z>JB?gy9=e&sjs7~*ob#|SBdG9w%Eu}%yAx+sUSnwg +z7VobJ^3OT@%1)eW#x^C3j0mZR*vy0Y05!stH#mjVgp19uGHvc_li}sNqo{bDqIlh_ +z>_@ubgYDwQoZ!)abrjj=(f{v0u)_D~z_u}{$1m(GrO0)5qH{`6WNnlSEdK#st+<_VM)01!^PpbJn4vEp5YQT4{R +z-K^g@2`_qVfL#8N?mDeZSyH4xs=+{jHJ4a<*d;W;{<8wq?@3=lWUk}c&8RKFgL}{{ +zFI43OMCd--&#u~x5W2Jt4_<#zy2juBGZ88?FvU)+C{TfW0G1cA@}x`XJ4u5aFc8g} +zi>e%l2t8o?S%Zz!dft-hwMgf;K|9Q-U5O@4L@aHv86wP$;!WEn`{anrQV}YsNRbK< +z-dWhXy9ggK4|Qyx?I-JbBMJWW&qujq0rtYclridvDa4TgR|nW14NO6*BfN-1g;x;p +z+TDXLABXt#s?A7(XI^d{UIi$4(+C90Pr7{iu0oI#;e}d#!1m}m9@2S)z{-h;mVLHQ +zUpD!kzdcigx)7K$UaTllfqMbgRAObGOUpY+>p0*lG;2Pp(h<>ez?RuyGiN=IF}>E_ +zd8E+he?EZxALx0+d}5Qo{cKlkY=h1C8MUj>eKioHPjI}2NP +zk5Ex|=*lMP50fZ=qab<(0SjWg(X4R@*Q+)o2_ApBQ#%)+Mu`V +z(r8y~)jr#>t2Slpcuq5Fi}7F@+AsyhnTYu9bPOI$CZKxtttu~D+L-ujdkQ~|_pb{I +z%n39c4lIo2Tw7H*i&CKWLeQM!uk9{$jlY&w_^)pRxUlT>2+E@6u1Z>A5RZ-ze!ptU +zytR(DW%~j`7Shh<)&=?+G5-}w3m-k9yQrF~JvW84Q$ +z$QQ4V8fuHzse-qF!CQuEJsbr6QFXf^54GiIlLm#WEkid`iTD8fy@4sV>WIn1fCJ8e +zp~IJJwfxPhR%RskweJsyzlGUf7+$r@)I;^Hw)W4F_YK^i<3Y2uLo#imMc1R5lWV>b +zE;s)WLZfocx;eSl)+=0o|9^dxVv;8$^edik>>ouvrqo)Wg!?|HX{!@@y1Qs)30A1_ +z8C6?t=3Kf$>w~6S+dI3fExl^9F&h3>rsHX%b(&&QZ%|oZ=LPH5=l$wjN_Tje+zLL- +zP2%)e>aD%)J!Rq5)}LC-o@f*Mzf;n<#@ys*-OsJ&4(nr@#i*B?`EqW*#`>%^*W4XV +z?d$AF?#~E&roUk2@8W)HxL|#x-<2Ux9C%zfCr?!OS{TV-izjFTr@&2kPoV?b93 +mskP>3zNT-fa*LtcQs3rLlWf&nD|(-B5!=rsOnZC)Ve_ARYc;I^ + +diff --git a/tests/f_expisize/expect.1 b/tests/f_expisize/expect.1 +new file mode 100644 +index 0000000..ca3fbae +--- /dev/null ++++ b/tests/f_expisize/expect.1 +@@ -0,0 +1,427 @@ ++Adding dirhash hint to filesystem. ++ ++Pass 1: Checking inodes, blocks, and sizes ++Expanding inode 2. ++Expanding inode 11. ++Expanding inode 12. ++Expanding inode 13. ++Expanding inode 14. ++Expanding inode 15. ++Expanding inode 16. ++Expanding inode 17. ++Expanding inode 18. ++Expanding inode 19. ++Expanding inode 20. ++Expanding inode 21. ++Expanding inode 22. ++Expanding inode 23. ++Expanding inode 24. ++Expanding inode 25. ++Expanding inode 26. ++Expanding inode 27. ++Expanding inode 28. ++Expanding inode 29. ++Expanding inode 30. ++Expanding inode 31. ++Expanding inode 32. ++Expanding inode 33. ++Expanding inode 34. ++Expanding inode 35. ++Expanding inode 36. ++Expanding inode 37. ++Expanding inode 38. ++Expanding inode 39. ++Expanding inode 40. ++Expanding inode 41. ++Expanding inode 42. ++Expanding inode 43. ++Expanding inode 44. ++Expanding inode 45. ++Expanding inode 46. ++Expanding inode 47. ++Expanding inode 48. ++Expanding inode 49. ++Expanding inode 50. ++Expanding inode 51. ++Expanding inode 52. ++Expanding inode 53. ++Expanding inode 54. ++Expanding inode 55. ++Expanding inode 56. ++Expanding inode 57. ++Expanding inode 58. ++Expanding inode 59. ++Expanding inode 60. ++Expanding inode 61. ++Expanding inode 62. ++Expanding inode 63. ++Expanding inode 64. ++Expanding inode 65. ++Expanding inode 66. ++Expanding inode 67. ++Expanding inode 68. ++Expanding inode 69. ++Expanding inode 70. ++Expanding inode 71. ++Expanding inode 72. ++Expanding inode 73. ++Expanding inode 74. ++Expanding inode 75. ++Expanding inode 76. ++Expanding inode 77. ++Expanding inode 78. ++Expanding inode 79. ++Expanding inode 80. ++Expanding inode 81. ++Expanding inode 82. ++Expanding inode 83. ++Expanding inode 84. ++Expanding inode 85. ++Expanding inode 86. ++Expanding inode 87. ++Expanding inode 88. ++Expanding inode 89. ++Expanding inode 90. ++Expanding inode 91. ++Expanding inode 92. ++Expanding inode 93. ++Expanding inode 94. ++Expanding inode 95. ++Expanding inode 96. ++Expanding inode 97. ++Expanding inode 98. ++Expanding inode 99. ++Expanding inode 100. ++Expanding inode 101. ++Expanding inode 102. ++Expanding inode 103. ++Expanding inode 104. ++Expanding inode 105. ++Expanding inode 106. ++Expanding inode 107. ++Expanding inode 108. ++Expanding inode 109. ++Expanding inode 110. ++Expanding inode 111. ++Expanding inode 112. ++Expanding inode 113. ++Expanding inode 114. ++Expanding inode 115. ++Expanding inode 116. ++Expanding inode 117. ++Expanding inode 118. ++Expanding inode 119. ++Expanding inode 120. ++Expanding inode 121. ++Expanding inode 122. ++Expanding inode 123. ++Expanding inode 124. ++Expanding inode 125. ++Expanding inode 126. ++Expanding inode 127. ++Expanding inode 128. ++Expanding inode 129. ++Expanding inode 130. ++Expanding inode 131. ++Expanding inode 132. ++Expanding inode 133. ++Expanding inode 134. ++Expanding inode 135. ++Expanding inode 136. ++Expanding inode 137. ++Expanding inode 138. ++Expanding inode 139. ++Expanding inode 140. ++Expanding inode 141. ++Expanding inode 142. ++Expanding inode 143. ++Expanding inode 144. ++Expanding inode 145. ++Expanding inode 146. ++Expanding inode 147. ++Expanding inode 148. ++Expanding inode 149. ++Expanding inode 150. ++Expanding inode 151. ++Expanding inode 152. ++Expanding inode 153. ++Expanding inode 154. ++Expanding inode 155. ++Expanding inode 156. ++Expanding inode 157. ++Expanding inode 158. ++Expanding inode 159. ++Expanding inode 160. ++Expanding inode 161. ++Expanding inode 162. ++Expanding inode 163. ++Expanding inode 164. ++Expanding inode 165. ++Expanding inode 166. ++Expanding inode 167. ++Expanding inode 168. ++Expanding inode 169. ++Expanding inode 170. ++Expanding inode 171. ++Expanding inode 172. ++Expanding inode 173. ++Expanding inode 174. ++Expanding inode 175. ++Expanding inode 176. ++Expanding inode 177. ++Expanding inode 178. ++Expanding inode 179. ++Expanding inode 180. ++Expanding inode 181. ++Expanding inode 182. ++Expanding inode 183. ++Expanding inode 184. ++Expanding inode 185. ++Expanding inode 186. ++Expanding inode 187. ++Expanding inode 188. ++Expanding inode 189. ++Expanding inode 190. ++Expanding inode 191. ++Expanding inode 192. ++Expanding inode 193. ++Expanding inode 194. ++Expanding inode 195. ++Expanding inode 196. ++Expanding inode 197. ++Expanding inode 198. ++Expanding inode 199. ++Expanding inode 200. ++Expanding inode 201. ++Expanding inode 202. ++Expanding inode 203. ++Expanding inode 204. ++Expanding inode 205. ++Expanding inode 206. ++Expanding inode 207. ++Expanding inode 208. ++Expanding inode 209. ++Expanding inode 210. ++Expanding inode 211. ++Expanding inode 212. ++Expanding inode 213. ++Expanding inode 214. ++Expanding inode 215. ++Expanding inode 216. ++Expanding inode 217. ++Expanding inode 218. ++Expanding inode 219. ++Expanding inode 220. ++Expanding inode 221. ++Expanding inode 222. ++Expanding inode 223. ++Expanding inode 224. ++Expanding inode 225. ++Expanding inode 226. ++Expanding inode 227. ++Expanding inode 228. ++Expanding inode 229. ++Expanding inode 230. ++Expanding inode 231. ++Expanding inode 232. ++Expanding inode 233. ++Expanding inode 234. ++Expanding inode 235. ++Expanding inode 236. ++Expanding inode 237. ++Expanding inode 238. ++Expanding inode 239. ++Expanding inode 240. ++Expanding inode 241. ++Expanding inode 242. ++Expanding inode 243. ++Expanding inode 244. ++Expanding inode 245. ++Expanding inode 246. ++Expanding inode 247. ++Expanding inode 248. ++Expanding inode 249. ++Expanding inode 250. ++Expanding inode 251. ++Expanding inode 252. ++Expanding inode 253. ++Expanding inode 254. ++Expanding inode 255. ++Expanding inode 256. ++Expanding inode 257. ++Expanding inode 258. ++Expanding inode 259. ++Expanding inode 260. ++Expanding inode 261. ++Expanding inode 262. ++Expanding inode 263. ++Expanding inode 264. ++Expanding inode 265. ++Expanding inode 266. ++Expanding inode 267. ++Expanding inode 268. ++Expanding inode 269. ++Expanding inode 270. ++Expanding inode 271. ++Expanding inode 272. ++Expanding inode 273. ++Expanding inode 274. ++Expanding inode 275. ++Expanding inode 276. ++Expanding inode 277. ++Expanding inode 278. ++Expanding inode 279. ++Expanding inode 280. ++Expanding inode 281. ++Expanding inode 282. ++Expanding inode 283. ++Expanding inode 284. ++Expanding inode 285. ++Expanding inode 286. ++Expanding inode 287. ++Expanding inode 288. ++Expanding inode 289. ++Expanding inode 290. ++Expanding inode 291. ++Expanding inode 292. ++Expanding inode 293. ++Expanding inode 294. ++Expanding inode 295. ++Expanding inode 296. ++Expanding inode 297. ++Expanding inode 298. ++Expanding inode 299. ++Expanding inode 300. ++Expanding inode 301. ++Expanding inode 302. ++Expanding inode 303. ++Expanding inode 304. ++Expanding inode 305. ++Expanding inode 306. ++Expanding inode 307. ++Expanding inode 308. ++Expanding inode 309. ++Expanding inode 310. ++Expanding inode 311. ++Expanding inode 312. ++Expanding inode 313. ++Expanding inode 314. ++Expanding inode 315. ++Expanding inode 316. ++Expanding inode 317. ++Expanding inode 318. ++Expanding inode 319. ++Expanding inode 320. ++Expanding inode 321. ++Expanding inode 322. ++Expanding inode 323. ++Expanding inode 324. ++Expanding inode 325. ++Expanding inode 326. ++Expanding inode 327. ++Expanding inode 328. ++Expanding inode 329. ++Expanding inode 330. ++Expanding inode 331. ++Expanding inode 332. ++Expanding inode 333. ++Expanding inode 334. ++Expanding inode 335. ++Expanding inode 336. ++Expanding inode 337. ++Expanding inode 338. ++Expanding inode 339. ++Expanding inode 340. ++Expanding inode 341. ++Expanding inode 342. ++Expanding inode 343. ++Expanding inode 344. ++Expanding inode 345. ++Expanding inode 346. ++Expanding inode 347. ++Expanding inode 348. ++Expanding inode 349. ++Expanding inode 350. ++Expanding inode 351. ++Expanding inode 352. ++Expanding inode 353. ++Expanding inode 354. ++Expanding inode 355. ++Expanding inode 356. ++Expanding inode 357. ++Expanding inode 358. ++Expanding inode 359. ++Expanding inode 360. ++Expanding inode 361. ++Expanding inode 362. ++Expanding inode 363. ++Expanding inode 364. ++Expanding inode 365. ++Expanding inode 366. ++Expanding inode 367. ++Expanding inode 368. ++Expanding inode 369. ++Expanding inode 370. ++Expanding inode 371. ++Expanding inode 372. ++Expanding inode 373. ++Expanding inode 374. ++Expanding inode 375. ++Expanding inode 376. ++Expanding inode 377. ++Expanding inode 378. ++Expanding inode 379. ++Expanding inode 380. ++Expanding inode 381. ++Expanding inode 382. ++Expanding inode 383. ++Expanding inode 384. ++Expanding inode 385. ++Expanding inode 386. ++Expanding inode 387. ++Expanding inode 388. ++Expanding inode 389. ++Expanding inode 390. ++Expanding inode 391. ++Expanding inode 392. ++Expanding inode 393. ++Expanding inode 394. ++Expanding inode 395. ++Expanding inode 396. ++Expanding inode 397. ++Expanding inode 398. ++Expanding inode 399. ++Expanding inode 400. ++Expanding inode 401. ++Expanding inode 402. ++Expanding inode 403. ++Expanding inode 404. ++Expanding inode 405. ++Expanding inode 406. ++Expanding inode 407. ++Expanding inode 408. ++Expanding inode 409. ++Expanding inode 410. ++Expanding inode 411. ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++Block bitmap differences: -1385 -2019 ++Fix? yes ++ ++Free blocks count wrong for group #0 (8, counted=10). ++Fix? yes ++ ++Free blocks count wrong (8, counted=10). ++Fix? yes ++ ++Expanding inode 133. ++Expanding inode 165. ++Expanding inode 181. ++Expanding inode 286. ++Expanding inode 387. ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++test_filesys: 411/2048 files (0.2% non-contiguous), 2043/2048 blocks ++Exit status is 1 +diff --git a/tests/f_expisize/expect.2 b/tests/f_expisize/expect.2 +new file mode 100644 +index 0000000..17e031c +--- /dev/null ++++ b/tests/f_expisize/expect.2 +@@ -0,0 +1,7 @@ ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++test_filesys: 411/2048 files (0.2% non-contiguous), 2043/2048 blocks ++Exit status is 0 +diff --git a/tests/f_expisize/image.gz b/tests/f_expisize/image.gz +new file mode 100644 +index 0000000000000000000000000000000000000000..43e8095d999a67f28990a0176cdc1b76209a215b +GIT binary patch +literal 323883 +zcmXV1cUY3^`>*54PQyG+%f)G&Y&a@YbJEGm%FLE~&{E2sil&Ct>6E3Zl}F75Y34*w +zQ4tp{wQ}GD6_Ij)f=G&hvYy|2zSr+h;JRL(_jy0>eSgONz>VPdt_&D}x&6P_9mkTak%71m~@+A+CJ070d +zQZK(#elbQ>c)Vfh7f0yJOCFaljq7dQx>c;SjT4%Y{3V`oPlk1En&RQ19nwyU0(=5l +z&C&)NzDL@c2PW?Qb+!cg)XmfojQlCV3EO9;{Bc*)Mw$=1VtpfgeDWo1#B}&AyJeP= +z8aF)|2=7tk*s?O4Jfy2G%(S#Q4UEOotZh^)Lor{x;)RV^TdKk+_5Py9GLCDb(xFbY +zz!zR6#4EOH-k)2CRkSf!lTU3s;3SZe!xMK6q+DvGj2I1sl-3~xt^s7%#^jNz0J2LX +z3o8~zJ)mt~v0}xBKmsQIR=->PY_G%5-7BGQR(uE6IQid_ITC#Je;-$zkQ@R3`{8|Z +zlFn+T%8l_Qap~jy!__mGS6?Sr{&zD5s0w9T&iND)2*t>GUu@I9UP-~8$Hp#-<;v7O +zzd{$WC@Hpa0TJ^Lj{^+toFLa{)~h^~lmL_d*Z~M3z3mOM3&x&uXLnWeeC^8>D-zO@ +zU;|?+ISuUIJ0`${|2xNZC>OZo_@+vuI2b#suWGZbP3s?*X+2$IIYZouP +zfxE1y1w1V($bdiW9g(AkMt=UBG==R3+ZScl4MiPw{qqOxVp%aWG1DrhMQiyJZ|xN +z<#IM-+u1w=zgHP&k2s6T*+j3&)~0i$CM8yOZmRhmL>^snfB*pkNN^Q!K=}ACZ#+J@KTw+I^RN&q&u|w6`#*{F7xPBHP#r4HxFVag9yZY&4iXz +zX!X(anCLyKX#I_Vdq9P#`6Ncr&u(f^iA5K9oNQZ?l(O$zq#Y~bw2-|oUfg0^Y)+-J +zfoH=%3!FedWn9~6i))+-B@fj0?P8OQ(QC&7rXnneB2Gk@xKN7pbJ_B6$l%n=?r&Da +zh3c}#B|53PC-`LMTxV-NVezhWSwS`}>4+n${Bf@AmMxZ4W-JlJa0|6)9;HMD +zz@*&Sr#4t2G~K15xhaH=hgDpOkV0w-n7~8<--@K7Ak}QA3OAEt5oo8gI#$XvG!pMP +zMu}#>uFdadSXTk@w_9^;xsvZm8}pFsX8$^d$>NM52f*yDm{$a}f8QQ*AO+tyw}VKd +ze!N9~T0Qf22>JHQw`xjg;o$j9V#Arla2CsAOAKqsk!9#FZo)>RS1AuAHZ7C=d@b0; +zuBrCIV2&6V&be*)42Nw5TKiP38S@B=1=6q2uADXlpWu4rnZuc+*!gqf`wC%sK$%>y!%BPZe*o5 +zAmiRnKhXNt4c#-%-Z@9ccKDdfVf)vlr3(mRh3|oqwDrZsA1f^pNbX +zz#<6T2UZoe*p)o}0olD<&*F%(zvq-Q<>hHsZmZwy^HvaN$1#4lR8rOMad4s)b5DV! +z0hO2t+Wy@*BJQwT_b%k9?D(Wg3`?Y9l<;dO6^Ozmcvyl8_YtvLj^PcvcGY4+gtW3g +zRo9HN>ZC_BEvbxw>qqYm6`Fp1|N8sV!^2;ylyMhdaRkypq4MCw;{w7$?d!?db9~>+ +zGcEa5o>^U56HWM(MXnDO0Zx!JYv>v*tEUZut3K?oj0`9C>9-EztGt->#<;5@A&NaL +zlVQF*U83Gg;zY+Ct6eISOA6|Z2{GF)js0EvaudJY_Fatfdph4Nt5(?<5r*zRkt+gfd +zYh2wZga-cCz2~b9Nd|b^&*D#gq}l`c)r6JzN?}M(9&uVY(|{NMYQ*!z{A)pF$0u7k +z9z<0huw58L9UNp{T^;OO$|nXk^ay7P1|KzEME+4xc3Dq!QZGENB`~aL`=9S@2M3?w +zn496G{e^qnGV?3vS{fEjt# +z7iT=b_I*@eQ`@|TKf6Vy6_XXB1Bg2|f=sA1HQED&5@$sR{Rw2g4pwi;6qVIP$!8L} +z_x~v%?Vh1c?2DC4a(gf^?WC?|6%`;Qx?N2w%(Q;3Ne{qvCC0Rj00i~)R$HGBiFp2} +zsl?{kr!KuM^oZkmw#mO4VM!k8w?Z!LEIptxzxcI3qAT`shp<;gk!ADl(TAUKsTcqn +zHqHY|vJ`W_g$pcv00O>C1t%`S13H%3Kbt!5C@FPE?{F}Gi>M92#TOIuj_9`cEHm_2 +zi_{EiMiLZ%1-s_RhW(@fdz_~kL$Q|SB3^L@@0>B@Qreqs6)n1|H@Bz%)2?14 +zFXd4s^~6Mr&DUW6B0N&th?iB!i1ohxw5Tdq7IcSxAMLfa=XG@nSN5|0F4|>FR!g=l +z+9Nwd7CRGedxFv2RurpS81sX()jr}9vkmAtd38j#9m= +zlt*O;7-Bt-S7_zSgQTKpktnu}|KZIS{tiSYz3TOF|M{CyV)X@YrM#)^73D;rkH)HV +zw3QnCLBDdO40l2gZM!+q)5qrV6<+q3-oT&uv)zBoqtn~5va3ySzQa<4D +zCHTPE=1(3Kw2wi)xA!5XX`U=k@jK1 +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 +zyDP~MGVCE_I4UB@7Xc!c;3S=X_MH#3;=S7H2^ +zO*l>}-PBIsS0Ij8i`ji}o*M9n3IW-Em>@BZkif@?mvNk&h$d&f5}k-Qn9v@Y5nc1P +zbVIH#D`A>0lc9b~(Hmkk!0S29^vv~BKZ(LAoicf!op7C(S9Nx%_H|y|P@5H8<%XK4 +z9@qqkIvW8T@`B=_7vULaX;vV+r$pzjmdif|g_u{X%I6W}(CNvC%b#zq<~71LyTdN@ +z@f(M(ML3^fdehEmEDh;iPfIN!>oC(s_^ClUAXFFH0WT#^j{v5`uTM$l^K?shj8L}) +zzZtZnGGjF~z0q|Hfte!Z3|sgrnZkOg2w`Xqym!(fp7xhzF-=)>$2~l^dJN8f!Fi24 +zrmW4qlCBn50@m>#6&R()rB*fN8kO~g#P0#?ctEQDphYINUBiLHi+QHCLOlz +za>|Ed_4fFXF?dr(*r^(!P!{#W?u&J-XjQ{f0e_X#Xn0NxE!+gtpS*6vjAz(Bnngx= +zU9f^00fAtE2ZCaN=2Rd>rl~^vzRfnQkx+BB>W|d7a5?{^c<5wij=etIq^_(}*}h>0 +z_VKwU((CoI=9$sIy|)eS^!0k4EERcJYI6Pw)&au*ww5G=TeE;qSBgkIKrMH3=erTD +zX;VXae6hx4AWXN!0v!+*zYpsiHGbSlzPZ5cwmMyd!PtIc8S%($MPqKYzYxfj;1eVd +zUP4fhCmG_%FDWVqyFn3%P-m +zi-=a1QLm9!rT@8w=lbGR~LT!;X0h*V?pm*D7xd7QQB{`%FCFDIgT*dfpO +z>6Remx%y??Ph}xOrh)94w()tFs54cGDRQYVM**_N3=v;ibTDJRX|@_Txx11HRwlU7r +zu^M?RnJHf-ngfpojCgm61`+!iyDsFy{>UiS2pTgrTRSL66Jg}bY_mh%5z?L3ww>{J +zkPn8vALeZ=;j@c$kNAkr7HDP!+to&V+Qclp5z{6rx^>1EsuygiUQn+pFoBuNxN7v1 +zIe~1s9q$c9t?sr>PvQpO>wa%kAJ@gHjWDNH;EDE;RT^DnlkU*9pQRVORuYH@neOlH +zG`dV3KQTr&{9SYT@STQOB_A8neqwmtb5KuO(ubB{%`d@LcgH4=PZN1*gOOH-dV5?j +z)paqxjxP=l81ypw$>iVP_5$}_iwj?RxFu^$Jbyq@6ojSn71kHk4QLVCh +z)a@j$>%+3l*qMg*|A@M2jD>pHNXzvSY+(*NdEn~vDffEW!Gx)npOCTfpHyPFf}1xL +zayfh;fBz^Y?nlF$c8%u~%wu-Fz_jscw)~@`LH_;ZFYdv%CZFPKqP+2hf&=7;ZHp@i +zsNUh_xLUL#pb>`5KwmdFIyBQ1;UyzoxzCk6B0tXWt4=y7*O46?a(H8ybE9A8Oe$?S +zVIM2j=o^#;H^dCN9zw^?3Wkb@yC2k^yB>8uj1{!~3a<40x4q(~ec6Mj`4-z`?tbRj +z*G$ZGXLwsbXD=mK0b-$Y+s4Dpz5>_fTcf`K4^Fb~bIJa{W8ScAQu(1zxSGz|C0ClM +zaOZbp7`d`2?ncZvKHp)^Cad7~hCrebFY4xg-ZM#Iu!En#kOwx3kr^M}&fWK;JvdM`waRDY@!W;l;KQ}8!al1t +zb*7^&nSaI?cNw(XIe0{<*P~G=m;Mo1dKL_nuO;gKV{)yADdD=EgCoJt|-ap}2Snw71DI)^0E> +zZa+)sgb4J{jr9<9V#IsmY4rhr(00F&Hx4;3bWhhG&QROriJO@dR*hnPliTu_6;;Up +zR0M!}B$X_Kd36K3STkxtWP~`s;hM2Tsnj+}mMEd1^G6{Y@%o+1{rl48X<-E;qW{lw +zugC9#XRcgjsy^&-oE?=G6+IZ#EyqtEzy21kvBR*ry-maXYoO)c;m+z)k)fU0mM=~^ +z=M>}rG|v}VS!IL8KAsCRY}_$ +zmN14;85YjX17ta+R=1j)|}< +z=bp%j*_tC7u5{~R8VpI~Mp@VB-KgcbwI^zAR&(B1%z@!8AP2I8{Qg(tY0236!vcaE +zCZ%11`G;3;60t1R%+(km%rCZUn+Uts(L|AVRgR*Ft1A+V_TJ0V`xd|ae%bb>^gcdU +z4YFdv^8aL6rVkDD9WsGjG;m;jx<$LrH_?VU%~IaT)G7iEIIG1x6ukaXe>?b<&i5Vq +znp^+6 +zJXZ8bK=~j{B}_b#tT5u<8|%eQ+;J>6;$+*SFTs6%Fpkj=ztNG4zj@Fn#hmyP+~ye% +ztXVlZ-Dq;8MYBV2CYT$aam(DQvKm%8DB7R>O5eOAbI2Z{W{0|d*?OU|CbqzXmAg>7 +z@~@X>4g*I&JuMh`WW0ZG(tpM=ObE$#cO?$0C>9X+ioOEC-`9-Y>Qy3qQv0wPZK{7Y +zJ?s~*+LngICRBb-1xFh-k({R9mTRzKalc%dkl%b$h1_4CU}!@>c;(=)S;m|fu`%BR +z(a+NPm@5kEJ&17li7`<#z$iexUJN#z7OAsz|Js+4FCzxC4<+5-z~0(rmKQ})x3_$o +zu+Jg#W#)8iOXdXG34~tx-z)$K5o65TFt-71SgrPYcj7=YJmT8e&*N0=?dWaK%Yn3M +zFy@U%UB>2~PFffK*9iag%(8*Cj{gdX!C&boiVpeJX{VX{-8{%o^H>P>G;^_@t-}tF +z!NvR2MiOg=o*^1+-RkW6J9la|3~V(!_}dNiIo2A(xc0KolePNu+EW9ud+JHB8(g}f +zWOIGC2?Ww@Qs?#m%l|2Hxq3nu* +z7zEv&W31`b?hjFr!`a`G4!~Ntj3`*;o(#kq8S!ZwDmVM}-mkIAzgv(? +zm`)+lX)&hPgG>^Kzlp&!V-@b{Ab`XdsDb{~8<;X-79RAa--s)n3&fbBhn7Rt7hc^V +zn-39%cbDI1|Cm;?^J`lqQdBAI+X(!j*|cFOc2$Q6W8MmOLNu8&2!^MY;n5T;q(D1bcDr>`#3!H=2>)g8kj{@t&ZMubHt_Wj^cU +zLF<@a^GBW@)PW1gpzei!+Y$Y>u}|Ebun(U2WU0b$6f1_#CTrIXJKfK4*ZW@d3X#)R +z{@2IRwK1h^U%oY6GF)?N62G7AH)XTVOT$&`O(dG)Zgf2}M?1$vw@Ia(2Mov;!U(KX +zh($0`{R;-9mf!Ian>9x1%r;grKJ(zoPXTaO7AMaOg&<61T%|-1Xxn%Q%Dm@2;2<~DOr2*ReO6(w +zk=)NY%94hf-tuFnd^r-)9!jFtDKoAG_mm$~EK$ +z-8HlCrtj`IAEVNz^{*ADaGX9qc$YPNrpj{rC$W*5*{@o1*WjkgU4RNv*Mc#naIN31Qs1|NG#>?gM>#mUOC_w6IYXhHgn@0z2F$LC)%0+G +zLg@A~E=O{6Q8+A%KD%g%uz+`;5mfSuDNulf)c%c|NgbLPmc{d)n2M##9PvEOYXaGsJ#y +zkw*W +zIn4gJ_ulOLeU4f#Cvz+dIg1|-Fs^*EL-K4UT^B|;DWjwtQ$c@2BpTAkK))3fN4*BY +z5fnB&3{iiivW*`A)FsKr3*pANMQ(QW0DOXoOBjVqKUC}>a6?Y-7XQMnT=L +zf^IL?GeD_wvk!lNn=25BaXko%%P^2MGPrhMIn$a@(JE;f7T?k->PRPGdmh +ztKdHo&3_LRMR4li$I&#a!G4>nQ_GkCs$R2l)frqynPo`ZX@5#rUr8uY$J@`~)u4Gx +z$Lx3VjS#m6!A^2wM4dxnxvH2 +zzwXLc-f6$qp#K-TNHOL#3(!&~r}E4X`5*i9kjZ3#y7%Ej7C*bs8iocXEK|k01ba8p +zbwN`>PdzQqX=5Y6KvvX$a#Ki#?okK?S-M2u9TT)8(E{S<-CsrKuA%?gZob2DzO>+g +z+GU&Ou=1+=LF;iNB6R}-|~OYme-PQ3y +z8;Lu#-Ive!bVf~PPEBDRm|rd +zvRVXd2Nn`Z+MIi|=RLBN4$=Aw5ZZv<9XM-IRJ#kT@B6SM=fkO%yHv2zdetLZW-t-3 +zAu_MIUqxhws|;#ftu;F5Yq{mRPv-{1mVF@Jdm)jNwOSf)C|lpYDB9d0W9Oqwf;aTN +z>@^cST>coZF<*;p#8Cx#(%Kg1LO1fBn$t~?`2od+#A=yy<7Z6O-smvr+sTXyfbU$_ +z>CeK>r@iH`$w%u4cm1qG+`HzdQC9Ki;eWMsbxeOSC;AC1&pzy9dM +z4>Rs}t3nuX*8B`op=9QhE4VWuf`_RZ)oK0jN1T~bIP!Z_iK#5`7uh9RQ|+XjxVU4X +ztXW0WnA~)WRsWqg*6{uaT=^|o^!R0reY9&*`mbcccV5Hr)8;Vl=^{yv_NYa(t;TO6 +z@3+fMm4r8WYj(meP>n<&Wrt0aZ!)h=WMIr0}1S{RS~*ciKNp!RK4h$oyh}6uU{YH<%Bk^ZZCz|P4`7I|aqXtP1{=C>N`ZJ}qw8_aS0W43_f*_X(5ZXW8kjnL|t3Y=>9bF>cWj>eM-fT +zJ$0Mj?Bj3D@W}ITZKnqWFu&&)ANOT$DR3Gavi(TE7k)7EUGYg$5W@Y5!{8pN$8xk6 +zvCjMVoZsnNeKcmbYD{VKDy}9iVTzIf@&;6DK7-BBay~Dyr_}$MxaW6GiJ=d!;1O4r +zMfj-m+lt6Z)zr2y<^9aLGBVnd#%{aXS{RGXC$5|j=jMrU7B*S4mzK+ +z>O}H9%B^N=WtOs-lkp>S_}Q&zA#2ZiPANwxdMr)5hD}r=i2uVOS08s-0dJgAf~ayz +zwvRE*L#>u^Avr~3R6DH1dE*H1nx5NX6L{mUB#tT}TI;+Y+{))BOZbT%LL&Ab{u+v{ +zi7(>gH|yef{Zi{I@5^=QHXRmu%Nefb8;mx2-N(}xs77-*=*2Ng8L?I2Tos`)14Vq0 +zdnS+EUx2*-q&pz8R@XT7Kc&z#*eqR`N&z+$7YyB#!(>zrS0ps*Mwd)eY +z79c6c(VXL0>A}?#x?>&l__O;MVYaCzu@YG_U(^GS*mn`!xuWq=iegw*vKk%}ryq;@p@;b1uZ=ig>+Acw-5tk6&c{A># +zx)kFv3b*(jOh7n}NCbN3ZQ!42J5|1C2!W +zn?2%{-U>LQ6-2yTVnYVLls6C4xb-w%h*1--elnzQ7rUysza +z=mAW44}kCO!%&LgxPieO-{<>3)#hp`701~oQOTNg%!cP`22d2bv~ivdok4(%-_&RH +zdl50CKbEOTryDV!_9V +zgHI|#3zpbuD0qUEG-F&BgWlhHqe_xBr{{RZeCOF*@NxcV7MF=)P9WE|%R&<>>vB{n +zK3^KvO<(WJ<@jmdWjSPH3Uoeuv+s{Z{;Y__3x4mju4Jup8SdV=$Ek}kM#0P(uGGRL +zDGOGOW5%B@!Ah6dH#50lTtSTAP_L1CSs0_&y)ye`KtgMvs8L)P7Jm^awD<|@Z5;nb +z-X~6J1ef)q&UF7m?w?e0LD3QpV%iS-RnpO8VDon1hT8Z|)DOunx#jLx^1HEbQix0w +zZ!vwx71nbmG4oVFPu`H+F6KJ_seE;SCTug_w#wq_y0ILz=kV_BB@@;MXFXo}Q!HF- +z-ulm`UElFA!~JrM@^ug81CKWn^r;gLu0skRN?RNbs-$E0lsJovH-)(mNwRU#r~dEy +zhsre~$FW1BFT8X%;OtR%gtBPy9y(Ee(e_Cd(oCcCthgJS+^JP>`ioXXcf3N1Z)GEZ +zZOlo96x-0X4C9_ARGF%GhpqSKCMl__)oOo`j6owpYc#-;(%kmLyT9YDXo=weC3bG% +zhW=mZMR7xNLM81Q>GaoenGm;%60Ui7p55Pyah{Y>*-w|8w}M-l%hcAa(PGW#8XF{x +zrA=r~a~%3uCLc0ur!xX&362}4W3e7t1E+#~^P}}yb@Mn#3fi?|TBc;|3O9~RKP3sh +zG|PzBEB5QEFIT&1={8{-rb0xAEFQfYSV-tcf3SKqY%~0G$FoVX33tZ`G#C=+Lq3!D +zI!h_fN(RAghlcG`Gf$V;SLbO_?!ZIR_=$@-uV%&wHjdXmR$jqMHA}{B-JDCMjf_?_ +zKa8!SBiEr*yq%u*aK9|9``hww`pS|`ZWeo@o+MeA9Gg>UViZ-uiVnz>&l*PvhCp-# +zRf!UJsE03^2;k+7%45dBAQ!o`@WCwiy{8j?j(0Bj&8JDrAK~l%R$`Lm8`b8CP$Asj +z3LMEzs!v?;X9Aemg;bx@oZAtx{9Wa~lh)to)1JS)%FTcPD6`yWT+!5}$}Uu{C&7K3 +zKIIxeH@1B=U{xnxf3&IkM{~te1y)=$Mux>GiTHz*C0K7OczQ-b4T4@G!V<2!LxGSs +zMM)o|FMIl&F;-WazGV;5ghV9EGB|XaP135x7_a55)5LGCk^ahj?KUlX^=}t`w1CdJ +z9@$N**uTf)2I4Pvs(MX)K;_oBe0`&Qm`80XYs9|<9`E^)W>bS{`Zy_B)KTQ{DC^^1I{CIfDoqaqe<;BpJUtR_FQZ;~;rAK&2^K=*g-ATo@s$uc7sQm)&G +z&lvV=-9u)`d}+l@hO0)~hF4z$9bx_QnwN;n>2>x9=h<)DR#x01qW`ot!hg$bL6st1 +z{Z5T#i>HR0=7c-l`Iu>k9=xqr>-Q1*%Z}lnVqrTNfF5o7I3_GX40D@cbag=8N{|>v +z^&hyhR~dKKYjfnZ=S)Dv*zEudA5HX!3L!v1Qh?mDK}6-FZ7jg%5v>P5nm%4^0kQC& +zRN$me07OU~F!!kt&GRx$aA;6nrzoWT+7DZ6$Pf@~ai92%=rFn>ch*LHQ!4Kh>^h;d +zFlX#)%R6rDUVet@rvGSg`_c;b`Y1v-Jp*?j6AC{LDwF3!xtx!dzJhym*ULqgtd^uq +z=Z~T`nn0<#*o?jS+@2dvpyBFJwG~B3S7z8?A1UofM}W2dg=o)a=bZdJuWCQfqZXKQ +zY8sD2G&p~!xM50ij{&xw&1Qe6_(QdS5!!`{aq!cp4X}pG2&ou;t?mN}t$X`1i}A(x +zsb +zLH^RJ=;*@Mve;E^2nDTc*;y +zvbfQx9VR=bEn4c}n%?!Mw#Kt!or+P(am;bez&Ky6<%>p{?$kr%EM;NoP}zkOW3#ja +z0gf6q=Wno9&X(Vz7hilKP-vm_44bJ0qf0|`TJKKhYa5O@l{T%mg +zd6uVBx81}WAnzG1L^gZARJ{%lLVsx$V{U1I-Mi=EaVHhR!X-?Hu?UldqD1VXJVZ(Y +z7dWTL38F6#MSBc-8`c@O@gtJs)VT15CKi9c$<6Sm3lA2JW?41jn+#C`IT?^488x2> +z$j}H8Rn=d;mzfneE;@$%HN3eWk5;Yj27>Uq(FWB`h3-n_q;yrdC2J`p^bcYoo|7-H +z$WyzebMIW}eg7$RpihSDCObFAp|3&53ADiL%ev;nq3=c)tG*tQ>y=Ls^l^5_DJ(> +zi^4ncr%DEKFb)k1MFq9Gb9b2_xJf +z2N^dh5o&RdxGqyu_r!sZbZ0TP)_;XocZxNM2EJRrZsakt1_gF^Cms*Q+|9Q#Zotu+ +zYzp{jWo6d&>F!;>4Jv-N|6{Cjh@OXAZ363{?VL*lnzNNEu55Nrn}=hxz+?BO@-vBa +z4HWmkV`xA@#djz2t%@^{biFTv>w%d?$!Cy)^`SR9>QJHwt}nh72Br8KCl*eS3h~AAZo$1I0h)F+9Loq^+>p65-fYe+|;TB5)RZeaBsw;aVppv$A?SbKN*6 +ze0SUtIzPM)-qDvanf5Jlp;0@?B15!-+^oVtVHEXNxe8c5^u(g{DgdL4@q`nbfx3AC +zHq95L5)SI_WlRrI&H!!uIh8g9B8EmJ%iv$AEEkW10lfuy2G>kNThV#+I~4t@)pFxad$2tecIpaSXWRxRC9udd3W#W!=0H_w=oqzM42s3z>NP%r&iO54Wza>vP>| +z)7^jG5nksVtsgxO!F=^Nn1FWKq!k!Ml>)r+zu>uMUdMO(3T(@Q=>^`jrCpNj4MX64 +zHxu@IR@%D3Yh>?Wao^FP(7l`rlVjux>)7l-ch`Y;wnO5dgrK8tw<}+de0&i5EcT51 +zV9{uJjKJMOV^5&9);GyYKJ4~$3&u5e_yflzadOU5iTL6fd!*}7 +z8k=qqh*5@yYJujLOK?al2`iwft4t+m*mI%^F{iZNp4Xv4kN4=@vG;@g?DYMFDUTBd +zr@M=7u3sBlsDGGScT=r4X+#vl;KntYJrRo@jiN^RZ}BuuBIAe)qm}pAY@!%4y`i25 +z_m~GW(72vo%HoU~^1e%R{M+Pz&Y7&f{ij9Gw%-goa{Iyrb$4!6NO|v%4Giw&F@Cul +z@vmCMa@7d+huyp6(V*WML7U36e<=|t^0#iQy#*+FFl6iQy=usZ6_YPQbpQ^^<>dQR +zw9);bnAgp)GYM~&a3A|9)6owbc8289T6xb7f)IL_j(YcIuTFbk{VcV3x9|VQ(Uk`> +z{r~^UH$ENm`E&_IpHGKMsN_E8ldexCO2|18%dsi<3`>P1RFW7*ha<<_*RU=}j?KBT +znT43lXlBN)_wUv3AOGR~e!pI?=ka(x9*-CL`SF#aMo!qtMMe(e+UN_EXXdCq3b1b9 +zuR0fEeTreKQm2z&dK^Ln;wkDn!Iw8xF!#S|y`}%}P@1CoU``vK3rU +zC$e|_Z)HP>zqz}aQkzIJ%m0MD9`VYlF5HJtd4E1DEnn}JtEA9PQV3QEpty^LtFXX? +zRYqNjUxGwe{7HD@7F}Fv2kg#x+0#Vy8aFzF8%CB#2<$p=)8uWpMViuN>`Hni#F_*4y{p +z)x|}b|Ln)uUY}482T=kjVB!u;!t5kil$V5o;3PRrv8LUG!c}KfU#my7(0~N`HQXAL +z<5jNz0^3-HcsE*?Mt|gHKMS3HQGJzY|3}5NakLw!b96-;v+(o4o7DV$>+)=F79gU^ +zJBT7HhpGCy4Jc73UFS{HTv*(pCLY7I{%DLK<&?O~w;&~7{(*zE(XS5gr1Q-Fe}mQg +z`5cndm{9R6#J=zqTfPc?{#{n-mFjuS +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 +zgL2Z3AFDqe{&l!=@2}eiGaq@es(-~`bx$YE! +zao@1>NNYfeq3`fGa+g!;+c(^0#}%UW6Pxmw*j<6u3K(C(Uct@EuIJSst_HXp)k^OB +zWm+{k2;VafTxS>$1O6!3vHE{PziEjHM`ez#6gKuI3`=(l~MeBRHXrxlRwso$4c2*XJ?{z`|Cb$6bV`x`5*L}w?i&KtY!a01}%WaitZ3W-D_E4 +zr8}KFLZ$PzDYWDhhQWsl=WPjUjIqzQ5-A7j0sR_IJ=VJwOu!MV6 +zNC^utn^HmGs6Qziwk*p{dlUR#dbPO&G65a%F8Z1BTij@)I +zC4oL#AI6&&MJhYM^x#1qb};Af${68QJZ=$V+u&w3&yTYe>FJiAw +zEf<{kLS2A4I2Gq+#S9haFm44xXR`}rW +z)aYF0U_kcSo+UczODu1Vfk*;N$!`Y}c;PBGq!8#hu`pN@^o42oSu9U}GLyWZ*rPb& +zl!9^}$8H;4!+&yaO>(x%5Ypm^(eW~Y`e=u8w_pz@w+Jimt-FYAfv_AMS$)b^Xb#k} +zk!{cp;t$B_%+zfs=w3_A6GqxT3%xhJi!IVQBLZrXt$a0}>h2lMN13;8uMg<-Npuh6 +z4TmX^PUfst7#%ouc@F4pdqL%Pi3j~?U#-WKe?gBa+f1&(3G;3l-J<PA5E%k1QM`(cOyHA33QHtrsduppot>k$X|YnKRx#+Ai7lL&$Oli=JlQY)Osfc0A)Fo~i-uD^F) +z>oztZso#s^!yKO5@zc-ZPLT{kf&_YaJ7j)gQ5_1jm86dBfx3Z^K10zAVhHHA +ztrxa$Wvc*dM=sMljA>Fn5W3e3BF!c@01#c<;6qK +z`^|QS<2MU5HwcsOK)1AE2kHv78W16Q+dka}JpB3cwx~g6U-a +zpOBijL@I{L0FLXj3vyWug5X1bX2Bj~(H3idvju=`S +zI6-;GaAhvV-al&OD4Xb#?x-_Vr1aOF5CSZoVadYn`lq&qf3_0W+xzvyli||FPAC0&yJ!!hL^Xirlmy$=a +zwg-m&^K8MTy6bS*rS2~^R?#1P&bQWVC&x7*snPYj@Bsx2IlaqtS6h^V$@{o6)f-`x +z7Y5#il8-aHU%*0H6)m{par+$Ss~+}1K3Y$>!LB<#l5P5;#KoxMyfIC(V>TaCAtcx$g&@CWPhutQVhG)j2%XLDm>#u6C=Nl! +zwO9?B{Yl)}C9@Lri>seQt>~Ek#8~M}b-L@9UwcC({D!t{JS@RXYbi`uC<<*Jp=JJv +zY@#*U%*JHwY8t*m<*YATR&$jEGTNXzz_tOvjs^itK)&!Y9xXSyua=J@y)D55Jp*xIFM9ZX*Rt50U=n#*o~2B(V++>gk1YnIsKF +z9fj=?g2&Ff-k)ym+abRazfYr7e_{zdu$UOd>x+3~9o^eEs{LGV!x?d-C+32eSjH{= +z7Jy1pAuO`y@Zjka4!T1Kyu9DN +zpPJ9F%8Ad>TmL1l>=^foxfkeK5#!)GJ6~s2kwBD6ZZ705IJ%X^e%|)B_6VoZ-9?v> +zz0v>TMsYkSlK>|Q1Nb25Cs0dxt1LBnK^iR9rE*NK5^G-z1SW>q`hnDLhKb)G%DMr1 +z+Gv!8sggy7uHj?FrRlfuyLvOby=#0f+hr=(U0buMFyK)J_x;F)@(uDKsbH=awWNreIkHILau%5Buxu*v)Vjxp6aY>8k +zGi`a@{BgiH$|WKN(c4+}^9~(ViAMUiHYWdFTIb=ktM^B)?44h$11fz$yUMqEdy#^r +zH@jQ2F4j_tWn6p5zGeX*y=+mvZv((+3BS8#(ghyD&;nv0=1UxNd#jJX{K6&QPRZ%` +zz9gXfZ?Klb#4t?C2=l@%O)U!fXk4x6cnLyK$3DpjHmeld`otYNCXniHpq-;1-#oYe +zmQ!rlANY9B^j-I9dvv~CSNrF5rT3Ul{hm{Hpy&gltV={Q% +zv?!3|fHn2Ow0E&RTZ2*p8{BP(@_S8e!e&J+78C~oM>5h^VjQ2}s5hJFZop{RxeeD@ +zVY04{si}3@WjTBFRBovH@vg{uhViGlT|?e!-$&;qHRF$R|Ei7Nqb1lDY%ronW|%@^QTR9NIGi-_sW=OOG3>dIy| +z$8L1zOS9dEu`#+Uo871s&Dput_!%f*{4-_xaZZOSowy@Qt|B-qOW(}pYj0I)_Na5Y +zg<5asU4!tkFwqRMF4n?1?9a!&(w$*XJaT~tXsI2# +zG5V>6rtDg*4ZQrP+s=rv9>E`sa(~b9O~dQYTHtyCMh*8 +zzw3irzN9!d9}geNA*vLOR=llajz`9DWQ3R^)L2-J*Jvq=(^%d;MwSekyIcJi-O}ZA +zuWZRCZH-`h#&gT2u$c(oge!A0TRQSv(0}vQwsg0PIWW^GSFcBFo>!0ARDo&OckraY +z=}Yxvkg`em(dLeh;rKgZMO|lUxZ6_}6$as+2Ifuf2Ke!VrqU>r# +z?y^BbUj4XW{slc{V_6V`9ytAgtHlvhxR%#(C(E;R-c4`p<@hiz%q*T9#Uy!VaIn`dhk?8>h6I03-Nuvx +zJsNh+X@pmwbfxfW(?;m|-TU@_=>GxD)5>|398`WS>x|(>#xBnb#M7oNTX1%ll0H*I +zPI2U%g%ktSyK{rJB>{4e55@K9&-Hut)* +z>LU_3(^y*`G^fa8sXZnQPi>EJe5tRD9^X6v-lcKh8g8UH={#1o%%ygl%O^q^4)2uAn)wvC&lorF-z06q +z8Y;8`0-!Z-`kdXqb~3Nx%>GEtbVd6o19KgtCLVfLuU#(mccpOTZKV5xtMplq_+r_3UWkc;oQh4_UWbm~UpngjBhX +znaWVj3i`OiUmwbm6YbZ#1nx*gVWikVT%z!wciMXDbPeHM>PseUx$Lqz`WR!LG3MjL +zr!%bn9M`RQap4D`2I350oAR8H{l!;I4hjqjj^PQ +z!yrjc#tMy33|1|`g_RRs>a0Fhk0OJ-^1^f4tY6s^yIRDF`|7z=G?kLa +z=%d_(1@_K0^^^wQNW}|j=$|#8@m)g +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 +zxsBU(>pR}!t7*ABTCQ}Epn~~ykP5$hWps +z{~WS5h_zNdYyiED{nb`34@0u*Dx +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 +ztPsfiNu~U-8A}}@c;C +zYqmk)78!(`v_XcR7xg=E^}aWJ-}|eENERc^TunC-4he!G#@@Fpjq2)Ft^V7)#GA}b +zsY__dy=;>D4inDbrxO@^CxfDw6~MDR1Z6mW7o@QG5=!%~l(M?@ZjckRp`gi+(XvOe +zwe2wwVPMxx`<4>%vl*tz*V7FIjH;0y_0s)teBwHHM=USjWhZJGkZ{0}R%PYb&n +z0F^+z06DfnC1K7G9vG-lQcHO`hIcgrJK{O)2Mv2kGS|ttv=Kd@s@JJFrI{6GCm9-v +zkcv52IM^^yotKnd2ZgR!MicZvVJBz2j)~@?)HPlG^I)lIAMiQW<*?on0_vZPCcW17 +z`3Vi9%j0;?mNLb_Xer(R?6~U^8;x3sQxoedd)QBp97G}Sv=n?iT>&TbP8%Jy)jQUE +zod9phRogqSeAt^yJKU(Fe`|MiP0hsvjqTmlpEiisl*QyPnDuYOBm*}{2~4!HEI){X +z?hkf7gN|`Hb)Z4U7#^o97eTGAC8m2?0>?(m-1zy~AJgg8F%sb2Cet_x-Xnh%76k6Z +zIEUw!%CZ6+t3M6%=VD*Y&CVd=zHX8MwYT01mk>_)xuJq7U +zs!~(*qp^+X9Lsb}8fFY#rj^O+MG#e(E-@;>X&c9~UJQkaD0K +z5{+6bSwc?!E@!a|^|o2Ha@w>?VBxm;^+w)#xwiThh$6UMLD`nO10Tnxc`ZUx>Ar}u +zT)->uEpD3f-a^B8P?lOT6 +z?bO9_g1s7lv1eBAFgw3nq_*izcg6}HfBSwjZ~#wKnh7G{4M%!a&QmZ>FqfcLKe*$b +zj5{xPeH$x*JnxYxmJ$s>OMu?5V!v!#BRSbYnm|F4Q#`YDMkHLdQz&0dQxLrX_UqGE +z|5(;z>yhxvxo;bM?xq->Hr%U1BrI<^ASJd%@BigGo1^cjxz^JLS%7G>BN1`}JDK$a +zGF+^ID9O`g6(hN&(mTkJ3HtX8rJnWjbDNK^{L_NGTSj4~$_c)sI*myJ5vzQ>#1umG +zU)cME#Dadi-#`c&AEJAmG8|e(W3l4}-E7!X@vKfDB+n9No({HdS|*xrV7NmpAOLX$ +zGxsK*2xgdNrQtkP8R_-~pVW;(A8=qZ2&224{ew8)w1k`wIf-*E_cq +zhSZJ|lG_KP%g;!jDD~e*sTV03=~k`G*VfWcI&_s)d>cE~o79FzhS@k~ +z6AICv@5l<{)deiFL?WFgT-d`A)UzYKV=_33)@G(PF`!0 +z_5$7bRAaBj2U{>60yQo +zZ7c%)It{uzR7Imcw?kj@rzMnVpyxB({{KXha4nh5$SoOSRwA4>V~xtKWg%Ah@^e6A +zwM=>3xhsEy|1QB#p@xF%L)#?@-dcqhq+wsZY;6)HdSBNGich<3o>3Dn69W^O4$vVK +zui}CD35gfmYjMoHGvI&C1{-op0%y&qGBElgwvi71o9@<9-b>$B-`>OZcz>rguceQ< +z$v&+G<@(R+)#`Uub{%7GIz{|)dZR1Ozh8Eu+FPw;;l*^A$GhBqhxG+(k#ob0&pF)H +zz*EtBihl?)(z-4^{Q1{4%~zXTUCur1+WxS*py`Son*8M99PG4Ref|e7`}U?HCp-D8 +za?jp$YO7s=n+k;xm=OOi)y$tjYk+V0VeZ!&!EHPl2g9s(@y$6iUUV7#fP<{3cdGf; +zc6_&DHZ;mr+%z3h+B-bsbSoizbgtIE17pZ +zJsowOIb3=hm%BA_Sa#3&>&p9pGo4qf>dv54U7e%<&{FnMXzXQl-H(+2Kla`{s);0u +z8y&}maTJ+xLuJ!(K}P`<0RaIO6$RM^WQ~G=ge3wJmJl+osEDW_s4S6v4UwgZEJ#|LJ}Amq8>Js{0I_1W7_Y4O5 +zfuozYGt?_-GAL)Cq`zz6E%}z}Z|OhLyeJ_p5f_5<=wod6kSvIiV}pOt5)o$jcP$VVNAS)yPR5=?#ykOewAb2R +zNCg9zdorDLy_Lpo^A!(2_(8T=Y>_$!UOLZJq7OWZ>fHE+TkdYG1k`B0&{~zJt77n7 +z*M;4f)$Ny<{@4!lnQ#8Q-^E5aQI!*c789q|w|q3+?Y!Xl>HVSF4RAUO`~v*%8)RO8 +z0!r7DZPM?(C%|vVjh?jrUb=7i#HWN9e1)rLO7xPfOopl2T=>?_AM58+_}1BX@MeYv(Ac;5>S6^z;1#&-!n +znt+y8XOfl1qEHz)wKNM8l4YB|(2J(!P^Wbb$bUGIzgO%UHIB?Hj-|~ts +zEXSp?R#d(kTS#+OeA7*9rWC3vv84v_qU}mwxOfPvfP4Sdc>yOCB8=O1S2y}gs0Ful +zDO$F;+11Ek;>qg*mmiP+Hj}ly7cOTt!(bGX8~8XhrKMqF1pZ=z>bYV>=Q{NV89kV= +zV`=+SpsJ}mHfxaPHQ`i}yVUE0UXh;-^H2T0bAJtLbVt`W>)COSM2T#7;{BzuL&E5@ +z(14)z&n`E^&B{<-0uDywlPBfGZ-MZA@X6;om4bpq<}JpNxaU#)--q42Bnp!k)=VBh +z)R|b!nl~{#ftXmVc_fYLO+%j`MyS#I4_c|T +zw+EfSnpWt$V6ggR@a|jrsFaS-H@$^K!ne_eV)bHLQq1o!Iuu9i#`^c1@&!)PFC3W4 +zh>ZB-pq18x$3Ds}z4`J4 +zUs(*Furtc4lf|gtxB^CxEitW`kS**#7#Ev1^%g26j770d5}u$z!Rmv7)Cg9b-=Ywg +z=KqNjw9#Gp(Ne?U4$B|0PW5BguOANF7xz5+S->Ax(+ajo8P~NAupBaURRo&OtLc+z +z{f?gI6%Hhc$I7D-ZLN9z_3oFPSAJcDYE%zf1?SoMzsd}J-cLW3?*fd4=A$PAgEcXI +zoq6r8OYUALjV{fRNojpaP|!}9Jb@_bfQ-i42FVss3+h&|75`1R#B}Q~`$v;WbE_Kcw=%ZPd*#_$=3SO)L{P_< +z2e$oHag|rr@dKz`Wnwr<_uH;T+SAgezmo9kUfJsnB?(Yj0(1yIFuD^4B3?3j4E54_ +zHe^aYFqjjc0P6EwCk8hu^hOf<0!)XE#;}R$kw2Kx65+^4;QfHCYpC|y@;(T8(xm2Q +zhzIZXs5)-0^>)qigY{JnwCzP>QKI*+!fr+6p2faH4o&@d@A?@%Z=q{ra^$Fu$<;SD +zj2V@{RTBR?jL&fsok!VK@6#ttB|#G2-}Q@6&%R>9NZSQJ&EP{ZiS|o~w{1Uh6%haN +z5c$L4%F{fY^-BMxYT;*=$8D5b+ui`PP0AK?zmwk8cxK__YMcq&UcW!Fe+e(ycJDKB +zA;px^kCHxeQZs`Ou)+sF2fI3(^mfP0rsn&YuQUGJM!7nq$2nwQ*Iyt0{m{gZI@_tb +z&TB4P3a16j(~qD$IQ__8$fZ4MSH$bzSaTlJ*cR@x_`|iUTxA}fPt)pH$JR`h?=nVp +zwEpf&>HK!cV6ZN@*_l21q;YueAJW{8*FrVLpH?QX9u4SY*gnyI{s!$+Q>IqkbmarB +ztgyd{uZhE@NU +z&ZSa#-Y~Yg2Uo#?ced_0H}rExH=LNc0PC=s!F@?(;-YLt+gAqGDCF|ASMkktI^&zy +zG{Or>?HZYf58H-%?BrHYPNt}DpZZir999Ud>2*>!*4=rmQQVpEM=$n=_?cve2B(_9 +zU#j>MqkTzKWc*JZ3C({EbGGo-4y9m__G7zgxfhQqIZ_nN5qDpJstnTab^e8V;*>;N +zas5H+YFapbKP_al{(&ojt7v0cf7?jrAP7+?MFr@!Y?Rr8Xd6o%KLnb){NDw7b2-#`=Lo4zz;s5ZVf +zTw(G~%lcs8lbNc-SI+v{J;6qfytdBx>N8q{#zCx_8g{j*a!nX_y+g2n^FXC((CtFQ +zxxw+8*X!JI4tj`#BvT)3eL0QU>>eYI|$4q8V +z#)rD&p8&Oy`0<(Yq;QQjb5uBa0?vS`b;v4GJmQu^7zg4q|K%8^EdlP6z +zLiAGiDGT3uu{0z~^ig+qAz9`@J(9JK>VWC~VkY>8x5$D}@MmytO^gijS0<6I0&k?r +znu&G3>D4JzWQwm@ujJMD0~+lLZuHd~=rUl>8I(*XRy1;x7SW>X+NS4fCb1tpJ$Nx_ +zlfUB>fZRAZ01OW1dP}}|M+~nSfzM5)!qAs6k~eB#7sTE0{x#YRV+K_XN;VxYY_dc| +z(PVL+MS=Tfg#VQ;2I3NSn8RD;qYJk_3$q0>Q+0xJ)kybf(Q%e@7=J?h*y!Mnp=60ThP_s; +zwuu(VNBcWlXE)EaE^?i3w$$)b?x{-vlaIlU&tF8=3@X=-vD~_SS?%<`2J2qBE4+78 +zn*@iym-?^XTywKp)>N>EwvG>l?N+sEi^nymO!43aU_weh2wP_Wlh8}~9vV$0YWm}c17v+G$G4zHz-d@K7Lu!(U`yY)S +zt`jKWrObRt45ugIbiY8))y8o_gaJ6LN9(Vv?f=p6H86K(Q2AY>R&w3zyEG^a7-i1> +z@W$Wb`(%yVb!<_XTko;7?#mzmqhi46IZgXzDE2le{0=S3pwaymw*p&{JiM6I^S=Lm +zaOY(>xniA(?EvL1*)z_T+WGmI18H$GP8LlPU-MP0prU*#ok>@V)PoKY1Ie;NQyphn +zK3O1<{s%`DMevxY{RXAEi=fld4Ixs0DQBp6wRvq-&-=P7_4vaom#u;XiZqXhxXPnx +z>=Th&sxFZ(ml87cdXClz-Ne3$@5|1m_`1+j+x-_*dJnw)*X+d@$l7g8ig2ypxX!BW +zr9nV;t>WCc^^=M%t4jPkp25d9p2r%yThtWZw;pu&{4L@)Km863wnAN;-{nKpqL$V0 +z(l8DN3?|tv=?q?lY}3O-d*8nss+PUZuJgza&t}DByWYeR+lHebL#X*&7Mq}0&bx`a +zESZ_B*6N$&>g7|zOx8R<6tMBGFcoP$*t9Wp9Bt(SeMr6GH>uhit~eFm_Rm-Ig14Dx +zJ4EDN`;QKvC?%=Pj;DUmvn*Wk}K5C(8`n87urjzD&};2q5)q^P>%;_wi! +zZ5cXf09Rv34W7xM&U6SiWUlMs=fXhLRQLrbeFSj@4iL3;#LQ!)bVpwrcYHB^awU8K +zxeTP_yzlSQpE0^YC~X@PRMmb6G_sgnQ^th;%-S^6L{)_Y!|)84uo;S+j*^kwB?xNc +zActy)FnLL;=(CEQ*^{NbR3O7MBI>@lK{?a8VDaD$(;j%ULS+9J>fp!o7ms;SLDii9Idpp0_!oo)+mI4-27Tgqobm0vUSf{ +zhq6v6=>Ny@0Yne>4UbEGy!EZ5wSSM^I{uZ&|f8Oa9s3J +zMVr`-pjhzo*bFsx*+0qwfzlZMZ7QMfoHC- +zX_Z=y-<@;Ls+~x`Uy)lo`%mo$npCw+m(7TCGgLscVaOgBHnj{s#=1?2x9cDT45<>) +zoO~)29xdy+Wl|xbrbBCa|Ly5A%n!JprDu +zGkdPcgSz{&X8SkP^y2$)jhN@ma+=|N15=(o%1@^7+poW09{A;fUmp1Xs|Thg{{VdU +zVV=B0iQz?u=+A$P$tbaZPs=FF#NwjpJChdIQ5BaXt+$wt9@vC`IS{+R@7GGDW^uz7 +z_&1?hW+N3CC|$fe#;+w)>tl$Zbg%;xED%g{ +z0x>vEIgPClvpC$eC^_qsoV7;)kg1qu(ZB^GKpcsZ7bKIJBH8o^xkem`kkgWAxWZn! +z7F{`63oAiP!rU}1gue&~698DkM@%rHbl!{2ENNhh0HnM~M+lRPN9C7}^1^8WxrQkG +zZ;U^{;jWaout9EzNweIJ4|3&*X?cq!audzr3Nm$h8{#c;mO>hF9V{>*FK}9x1?94@ +z<+4n<8Z1G6`AJ^QM(o9wVBX2;-Kj(?3@!<_OJcm-U%p&`!jU&=FIVF)@45*~P9Kre +z+#$Kz-q{FWfj~uWBc(;oOP61EieNR8t#S{b;I2s|`tr;0WlQ;T!`_YY;WkH>WtRoe +zaska{^Wx>^L@zh7+zC(lrR}m|)M)HY46avYDFgyIL*k!A;TkFvM=*%G1-YSqNS2r} +zceny7%wHkrC(CKG?{a#V05CZj*M}pB#n)gKHwmsPi=)eFA6X!oS}3QpCaJv=NvND} +zyG)OhYZRJo7v-X@a?zV|mM*LnX9mhew=dIDn5NAl_)=*ZX2tzg(ZVY(E1N +ztn?HyCl?)%i}K~7+~ukt<+P=|sZx1U#O0MfVY^yVZ!Bi$Plz!vherv +z<@=u+%l{AmKjxWuTVEg{4oIqRoIa!3Fv*R*a*72f^+j<6poHv|>;$f|~(JsmV$37E*z(o+r8j=(rd= +zfxD1OPLe-?J4i&a$O(xcpkK3?MOXss6WzuI^NzKfu3n73&tev1$*f#@=Os)v%ZE-m +z1s(!Wmn8cDl(Vrr=uW3NfoyuGJ*JE`LRTlE%UPsSlT)BEz0*-*0|*>2IjjXFmmo4h +za!b*-SmI(Vm8Dc?6`{b>-# +zklBKRNS6|_1xQ8;95Gau0^PJovY(`v?x)_M_04FfMS*@kX|x)5!?o(mkyo=Q;`xzNIp6cU>B*C +zqTK;@@t_xY955~#vd`Q_g{b4D|wZ9qSWAJzI1h(4|vsKt4k~A6>x8WvJ(h6p{YL +z*j$!DF}8};kL2cv2uN-L`U%U2pT*-PjD@gn++#pMwVdHSeqD~E|L&HU@!3k +z*3l`ppo9^361;#kD-xL_&B{dA01bPIJ)q%;dBk#L#Cd?4^sE9=GSVzxbQAC|l2)^5 +zMJA4*E7Gh~6a?^!OkBWdB+UhLi?xp7l_&BB(u&BJKps8L3sk0i6^Ig$)I3oeQn^I> +zh(#=szGk&C;yghEx>vTy5^yOdyMcO0qLaiL;5uM3S!a<%7fCR{wa46H2}-0{EI}#R +z9#o>s?7$>CCr{Lb#N~+mfCPr@5=f)VJiv_r)ee)ua%XS~L}-9|NpcXdV#wS;6kX;F +zsv&WOA~6zrBeDT-mn511&bj^~h@i`yKrWq=FA^Z3Y!M!rRw_+n;Yy`RtSv~WRD?qc +zoa-Gx6QsZigJ($?rf)>20HtEje9=`PsR(-sL;^|0SPyU$5+3~ypd%9RTn}eFBJoa= +z4A$trIvL}MUHwDWGo(ea8llD|xTMAwEI=AK8lMBlktDnNd{!LbUOeaq>LZ&<2Ax4P +zlH_7+18zV@UaC)K%^)M4CI0~RMVW8VEpPFF7x +zZ9yt9C=OsLo#F-_1Bmt#Hz2+^vs`oouqZNd0M`RVM@bA|QJh&Ux(+lIVehb9k=!DY +zHIiF~u3?diu%#?gab~XQGSF0P;stsDC>P9aR%B6Tp(qo{%@>^k<`@)r5JRW9fWHF* +zM@bx@VTXCnQYw)?Whs@KxPlh+xJzIYJu63a3D9tntOW{-rFksdViQkrJJO6G(nZoP +zVNzMN5)*gO5J_{wWU=NLUT;LF0p()yWpFQ2$4O!c;9VrE0r+W=!_q01Rk1|VD{ihxTI*#UGy5}h%LtUyMbBS@lq6{4T9_>4GrFp|!BBdSMI3q=wn{BT|g +zm|c?W1`LX&@Pn&}>StR;`MC72AfMoh~Ft +z!*VIXzF@hOW)_I_kcd*zVW5YhUM~6ruqesQ7DXTtMA3dgm!VD&Z39qt##W#TgK_~( +zXLLGCwgM<8i9QfcS1%PE2bxMVOGO~k)=shkn4?o1!FqaD5t_n^EX5|V#3i0@L|7!3 +zC|ZfMb _G#n&X0nJkB16ERr^d-xYo>d|mL7HWYjsdV64*-RwCgxxvBkmmd3Q2R2 +zxB~vACKg~VlIDn^u-4JNibVea%BAEpU_R2UP&9|6z7ZV-5SJu-0fckC9q2-ja{`%k +zuW}I|NzE4h3Bd0lOOSyi+G7YTREac|#iwgKV8|>~sq_g;g&yYuis^9(FcFD+BZ^1j +z@S5WFOULz +z43Qq;Fkw}dEl1^etF=R2Yz|rmj`}%;Fkyf +zKX_nhVnj1;wy@Xk&*jRoLmvO468^oG4(0acmrnW-5lq}bia0i +z(_Fa!biM$3(y(Ev{?n5#F`?pW+;nsgFR3qd*tS|sNSF&}vjyw9L;;kBo#yk8_{L55 +zGDalv(w0I*p#YOSxipYp+9Yha*+fCXd!o~MyeFQ80yB3nCBg9<@f3|%o4If?3Cub~ +zY*XGKVTWYHSYk +zPE?CQ+>rZX+>CP#<}3y>oUH>ZR#N*p#FloNC&_PshCji7P$S!sk@Bg7-zYtCGroU- +zV|$Ln{n|UXa#5D7l-a`})|O@IViF|_@fz%RU-<{~_ds4Ik?me1HMUYPSgG2#(}|fn +z*x=_OT2R6Z0ZO|CH+4{#(Y3IShilMT2k00hSsWVoZ7s_7-v(khmE7nP(*IhnQ%38^ndnUM16{0ZScMj*sjfnC +z3K~|FVm>TVI;{$P@ePZQjTeumEgn(*`b1hgyZB9j|8X9X>W$zfJJvP`U$|4cQ@>nV +ztZZY&WoZ+s)Zs)#aGS#h>CcdmCK9os9d}%+BdMHRqznLX4{DUxH>Hs$_ziwY4HeVb +zaSGWx2;w;P90`i+YSaOI8U0=)i7hDd7u5am#ky{5U6e6=qP@1;P)Ryg(fg|yBb3(50&cA`@&w0ZZYM>qAxqg +zq({-}LNP?@%mA8Ws2q&oed#fbWsUJ-%XJQ-uiwEWwb__lXDhRhqT)eM6M$yDP6_)~ +zYn`dc*B6PWhPI{NqZ}Hibiy0=+ZM}J^iTAqjb(S>kVZrUZe_qv&O04`K{)1Q-Q?B#xJlf*n^s$|(`KIDS0ldchnwp% +z5c+m^F3t>6&ahs*Tv!x~unjJgr6R5zT)3d{t`bgR(3^o(qq!3!HOb;3-SC5vYJPUQ&;38@tlTnjXic+5I +z&Ynx%IKycE`$CJcG)?$rZ`z}+2`T5lnja3ce=(Wj{q)npFl**4b9UV6lr5*`uWnC3CFhSwMduM%8_L`X1jsO+jvK +zB>veyz2T>zsptcNy9tGT#~4;A?neXk9Xt$``#1IL)LJEbiYm7h2HPSF&OdYuaPKb9 +z`<|HcEcWY`fGLNB7_U|Qyw*puzk`Gt!l1PvO6D!K$mNwRc?L@IwJw+)RA8mDGv>cH +z9E%Ew2)h$-zh-|2v$dn4`dIOue@U3`&ctV0*ZL0@YZ{`eHkTSW=vLAk^iE|(ngd;;Y|g&1 +zE2&nAWsJS#1l@`n@g0xFM;>`)%-&u8jJNnOI;9%DX}$#v^?M(C21hkxXxzEK!JdJ2saoxCEi*FNUJVh)suPLg3m8W;!CuO|6Fztk2 +ztA3tC{*muaUOK|=GkG_JZ^w3QvNpzrzmRw(kGAd&E^Xdx!AbsBZaP2PXkCrgWWeW|<^T!i|c0l~AQ+y!#@G +zXtl=A5-Fu;k&&o37oKE0v%yL->_YSGYULe`4wijgiwC7($oILrpviS7P*(xLk&QkG +z;fy1qAAUE+UHP6sBAW%V>5xcQ32|&bF+H0rYz;80(NbM}R*_UM7JC{AN%)^K1C!(P +zp-R&ECY!M(j6zmuBoUFeXhaN%K;LUHU7U4<+!0$H1PB=G-8S<3k^+tE{~c2IUQ^Dp +zhQu`@vf^yrtfyv@lv|4vd@D8!uYn|e#U7l7w^AQ6WZXpQq7@7oP`QsSBeM&S*8ec~!By*F`xWO#D*I*M6+sM(CK*tsRuCO= +zc2i@9YM+t=JEaZ?=Xi=o4@+bW$V}%OB^Z3w_SVJjh!G=yNktoLrq5O~pwX8tI4+!R +z2%Y2&HrzNbNb2N>eO;`N?5V;wCDjNB1CdLgHwV6*ndZg8lL$(hRg(QXXRjvQOtJ>p +zHv5-<#nrmTpr79sD`>T%u!$MH7!DR%!CtIzG58!3l=;oMS0l<>P{`D9XIEkhj^7=b +zuAjK$gNWdAL=!t^A4ZbLv$KgY*XPnMN{+HMus<*PHEF40uOP8`W0lw+ASmj|QcABz6>iJ*>_00Tf7x5?SCui?b@vT9jb7-_f$>x@}D|yy?!Y+ah}R7JPNQe*Me&Z#odqmmIdGg{7t( +zbl^Z6;>>Q`UBG<5GDunLDr;BP3~a7kx$n{-Z$I;|h1;t4(M@e!=2Jie*aKR%7GF=I +z0e%zOQ(d3UoyM~~OR!WO^@$BaOZS2;()=|Ohl#BEy +zJr316mn{d7gRKY*h_$ILD6%NTUg>2OVWSB~qc*1`%?&-+uci$SW9J-4*56LOb0AEp +z#QMjBex6){1Ce~&HUiU$g@5RC;&#ou;ca=Y)w1CnX?%Ct#XwT!-?-2=hkJxwr0a7j|I_x!78L3_uccJ0Iv4R5yXExX) +zIrCXI>>R7SHKko%XTXib7`$f3DcQxA4b8YS0XaMV+@%@+Vm#$e8?ZQ4wK?kP8kK4T +zd+|lq{W4n_Ens)@KhIFc0jXiDW+!?-5TrjSdloK!?RB{Saf{Q$>?8i(Xr=DIu8C_{lIW8Gc4>sm1EO~>xDCT^~g +z9$Uk!92y=@UrFsb#9y0Tcv*eXcWmmsL%H61-#kweSl#RYd+pKVgbj&|^D!&`{bDy? +zvL&onVbj9nYCod&m%zLCvOYN&J1}b_x(dI#MbY3^C*3)_1rX4+ztu8m5|c4k7Az1BnD37h?fuA!jZLC1vZEy~eX6CmrKHq$@?|h)3Ma +z%p$+gxpm!yy>|NZY3TmKq$$8|D7{tKXtdWSbQkE_Jq^ZV@>!QOzPwy60SQ3@7 +zi0`CwY%p6xS=xQ1zRIUhoLOUH%vpL;%#B4i)V^AruQ3&6*sdR;ViCN;f(Xt}3D1O{ +z_JZDIL43U!<}aZWUyH)g15p}+616mcE^ZniU&MmgBrHr8p&uZ{E_{y^`F71O*5`t}R_p+brgmfCKpi93G#PY@iuRMGX|P99mZZw=lf*nVSY +zb=R2bIeuX8hvC;bCl#tK5}$XO2Gu&w5>TwDM56-*kuP;7syuh;pWbBiGsV&MIq7sr +zf^~x1+M2wp4NK)=dS}#rgj}=^<|Y%uEC{=P>uT0k=rOtw*nQ2v1v`~F&Ek&9lK)}`Ao7irC039ii+7(djHgQ&FDh`yr@H(!UBFvdEPdw +zwI2e0Uz_-<^}+@R=j<^p#q*R>pRc)VZe0KEHmYL#j)#BG6UvU9n7zB-DPN`g_+Qpm +z{|Fs`YT-H`%5TAU>t4KlN5zWsJ~z@<<<=U<=bn`Wtgj>#d`a6| +zI +zZ?shjQiw|a(dUw?GZ?o0Q7aW{qw%@#b +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 +z!VGjaH7!<*iLOsp@KUEg&HTlY_{ +z+S1t`QGjQQu6gRYLt{I&yzqaYW>eoJnpmzruUqVcVTN17Z$4?GDK22n0hxV9NAFlx +zpo2l>;?%KC!-usw>}@dvcaIqvwp?WV+oO$+E+{*7XG8TJ>gd0TF0D>If&iWROV^D( +z^U8qdR&Bzxv15-~&ab{Ox8H3n=KCytG`4kd=bHt!*HN@{o}MYzErxcZ +z^Rtz&pU&T89DPt%u!G>Y`s@8oiCv5Hl}V>e54^}_K6HzJcWdm(jw8(>@P~0TSQdP1 +z)Rlx +z@05h%x6p0ED}VJZgB#knvPrn@do?mHgr5=^!i$nEZ2fdXg#=~o4V78VtyVuVHp-5U +z`*5c)YT74hG22!tv@Ik~`(njNn!0q!j4x2oH6w*AE(tg?bKJl;$TLN#VFJ=R=QfAD +z{MJLlF81TPzd;1za@4%rn0Fx7dk5l24>vZznB$!hOW~=|6B|ZV%zh9=l&PYWPt{rG +zkse*%@2$RuD)7Z_vCuq?B(4e(zYKuzLMBa8Ws1sq2rsZ#i~V_y1Gq;4_)ObSNs6YR +zOy{SPlF#A$4R`Rbzcq8;{&CBdd0&-+m!di4PAE#F?Js0f0M}=c6R^-8FNwN${PPsPmibLgsj1O9 +z_{k$d!P?h2ePm`PzzipNue%s`E^Tqflhs>{FqO!{iQveVr5o!dHb*2?KHK%HkNl-F +z8ZlOHqn|iL +z-!@&Jg1HE^4NY1Q_(hW=d>y}7dARz6R(;FW=$T76(o!EyYu=X1#Xn{7y`+nm7j^rQ|S1 +zJlT6=@ru=j{#MO9OP|;;BW%#zjnV%HTjw6nbRYly&RreQb*YqNT@}eGInU{mB7~xx +z4@Gh&<}}Q%QdEvPO-?JvoHNITtrEjx&ciTahM8e(W~X~~UDxma-H*rpuLt{jY@hG< +z^Lf7x&z)i#zJ-^bI(A>LvJP_-ISZFh#g@I3MZ3uZF4zr>hX&S;OI +zHh`UXF<(&Ok$*elfq;DoY3+2P{9ii_(<9A5T(U!XYZ8Rt&f +zhz5q%1R(a(9+&OV^a3tIRoT?cVAjoa{7&qu+PNuK=Z1i^PreE8YA{2=-#dug@`tLD +zb4HvjFW+h?=*0OZt?4}PAgVpJji@)2Bl`MYv=?X-KCIStqCs@1;vw==L9L~z(P-T{ +zj|d2JCrdubE|xx@HWlBRGas;QcZ$6Awx}hj|C4iP3ts)!g;Ae +zm|Wc}1P_i|>g4E`eI~iDkoqGplA%{~o?BvHjJuJoGc}?|Qg`Qzm$B_>W3S9e2;0!orJQbiSVKHa5~il(lf7G8+1y=!c~ +zbVU082<@=LMBAWIZKg!*YP-|rkcBw$jFUER9L9uLBZsIbb$P_-RJ2jGv3=v{)5CBd +zsqjcH?ZSZ4lXY +zoid*sFuz`Mdoez!&$!w_Z-(0gwuy<+ix$CRb%l6FV4fom*_4D0WC5{?U6jDwuD7t} +zkCQ^QW5?ZzeIef+*P=1!ITJu}U+`7~N(2=hF+&@g!^6W@)wt4|zvg6ao?RShpCaB9 +zhkez&_V_z1t2|Ew%OsgZ~ +zW6Dx2HA0!Tzi)HX9w8}3l?*y +z6jMMwJ;1z0gVe)c&YW&$pmIrnLFC{7P3Oa#WtY%{(!w7(%p1)`vO)_k`aK3WKwIjY +z56bnM?}1bY{7!5JTcBIw-%%qfmpAiQZ{6OMzk+?Rd0;hq=)gXcg5B!XQXvrA`CK+2 +z0O#cvO`#6z3hc_+DVl`Adt+;>ObTqA&8$+@lAh^&!>Baje&10W_j3yizL>N47o_ZH +zi3M7PTX2mV$C%FA|9~0jX9c!e+Vp~zoOH`bI^1_4b&Js{-&u$n_R?zo;H|%4PLcUx}bW7hw#9}Q^%kNsmeY_z`QK^iy#S93|c73T#S +zs&HEZRslnCa;&3x&2*A0JYnZqXUkMRjVYzJZ3*KwNyba%FH%rGlWRY;V<@Zim{$RL +zuCunG9KPG!=MUpgvp^B*p8-4x3OLD8Z~ZK{=+lD8J0O{^@dJ5nEXD7?W#j@*oz0Xdt +zK8O}>j_G%9X-A(e7T=|>*{e`6?HbkOZELHPOD&HzHkK0R&pvh+SqnthY@GP%I_P$_ +zPoC#;#$;n6)oXrmZ4ToXLc8d&$s%;c;o{%WoFs$S272;Q?`YM=`7^rSGG$YzPU7I`*2zB`oJWrQF#qj+?`h)xNvM2@ +zf1Y4W>iv=rZ${y3b%Bv3df_sc#MQp)ds2Yg^zz;}H9^$thSS!H9^YGCJ#PBzhqxTh +zZDfGT=wBcMZE9rYg8C6q|cAXd4 +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 +zg_W*D)y-=B#?u4Sjz^NSr#j +zTLrwlqOwLH+a~zR(Mca(@?FDB +zU}k!uX{8h?>t&dnS5sStY!eGr#~B-OlPo4KcNF9~ba<9reza}R+Dt!UWW2vS%y+yqPl%G2UKmI) +zudZ~(+ok!w&iibHbwu=@@vkTy1vVIA@0MfFRa;q(rj@9fIg6D8<;>;0-7~=J!M_

    IVy&k_?&)7g!Gyd2vljD8*V~ +z7f^syWo`P~CJ$E_oz`~@uRoTefqrv3)sp2I +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 +zo*#O>GE +z0Pi!tRx5M~*H=lJ8JuxNq(qxJmdgp_% +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 +zV%xxEu$_7&{BDz#L +zcbxEbBK_h+!91(u_`RNX^yV&if73Jpz0vwGpkA(2tJkHTQ>V+a_~kF2cdt?A +zf8f#0LqWu`OZfgi`Fu1RP@KkxaUHi_#_N((TIt;s-%`7FZSVv|LC3Mwzil +zh=Z1JNkp3XeUmSC`Dd+OpF^u}z!WyY(9i;%iDbdoN`qZ_i542;(#O>Nt#m7gANBIm +zo|yxVc-}Ta{tkp;E#lF+sqOul<-;!*ckcCJefZOVk4!-qEwtC7d%t@s$=3h1)nTj4 +zU6{4v59LRTkDM(79SJc)@oQSuWh;;JtzH18A0)ew&ibYAGb(F5$Fr~^ZW8lC96H}2 +z{wUr<6dwrU!NawB_llaIO093$wj-V)5{9BfMX#%T?~!#JT;3nr9O8Bpbf@XR{_64n +zR?5E%=Wpu4gn6FSZc#O=`6o$j-aik~F9P|Nd<;^U6yL1akEP(ds>xqP3U=mD%kvAq +zIj~kllD+jaSo^O@fWU1dLo?5-&_=%2Z|w&M+xo3(_@C%`>0-I=3bD*X1<8u7z0?tN2?;eU08upQxnFS7H)z7rbp|>*glhJ= +z0&QM}aG`uErkOV;V8(ZfQJtbo685*hg`{GfS&1y~nwbbsN9lyfyv0>{~8Z&wTODzSEzd9;wsJfk<7{LmHTyaNer +zZB;lnvE|O&)tlb{FGAI0{OwNjRddTwU{{g;IzPE<7w2?{!H?L|GF)}2N_hA^KLVCy +zjySKbv$;ZIi2qia-LzWh9mUWIpDzNxO=)-P&ud~#9_FrJsIES%vfwkWM>O7HL`k*| +z&@O!YL-PmUyWrX<(%wL)O3&l!=!2IWLn;_P?Fr{KVGEBHSE8vm(WG1-L)k8ETwJAb +zK5W`JFc0HWaNO-`aED(k(4g!Ml&Ie2qy~Z}uR?3lXF|jjwOs3?6~?Z>M)#6Omz-#N +z00~Nf839#7`^?x_RUS=C7*wX*_bg&WcC5nttpbBX0moYX44P~fF1HPbxc8s3H+!Aa +zT-gi!o2J#HuJ*>DN(*rX3$Up_o*}+aenZ_h@3HVYpmYW!96!1-_fOHfbuuo~5r^*3 +zE>h`hEz~|`CW;2JCO0odcy1e%5hXu#0h}pma1FJ_&|5v^Jq*o-OCOa@&fjnc^1`bO +z;<=uc2WQ(XCp<2o&o+qP7PF89huxIa4*42+fjC#6X}nJ<%5#BorSnH(oyfad+$%)BI)x_5xR*N?1o?>D)B7rpeLWkK%ttc6u|I- +z)4eET@%G2ji;$jV2!lzF`5Ai8_HM;ScF=e&9Lc*$Z77fJIqL7W4W3JXxbfM+_?(Tm +zY$5%oIuanml!D!4+{QenokMz3oq3BN36mRIJD!rrr57BH!|uEF?6LMTg5b}xR0sUW +z#P0Vd-M$|YGZ*@|Jcjn+;YFpS?LZ08*Y*zh0Ia$;yPyY!z-b9>d1!4>{qtkcB +zU8=$teo|IkE%Qgyiw^w(XpdTv0^Xg{(l1Qll^%}w=%6atHo~LJxQEsclX*Tn(--L! +zXBDC^yL~^_izshP97*8}jk-&qe&K|nCGWpW5>+ +ze0Hz~^Rm=W>JGNe&#+csHp`{i@-{k#&*|Wgu%$f3kZA3&zP$*pt0V!U(%VSCh6hM= +z#HF+$qzspFi=#l1+xXU{-C-8p6s1^IpdCSpDEKLxZL^`Hf_UwSzLs_|K?>?eH+%#- +z4WN*6MaFi1FfQU!eyo7QIF7?5tvyN1Usz%|RtqK(?4IQ^hA*QB|A_DRCgnOkjOVmL +zCZQ^)1ySWn#|)#iVm=8vv5%F-lqjX^JG8g2^1~dswpJxMLze-rSe_)SG-AeGSHx3% +zh0{|$<4FtQn*(-2{IKGWFZmG0r$@W(t3T`Y+$j6r4n|W`DT +zh%vqOWrIV`m+n)B{O +zs%4_nAGo37p;$kD2yQQ)F!~Q}q%tt20>?RPl +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 @Kf8RCz68P1({%-6(gPqQz?O;#MeKFJW +zJ{z{WN(JYpmI=CHr;#m+wS7|?zzx=f*w5-*Z`MG`S%|(y(*oTf*Ew#7_e#z!rUy=r +zHN}SeOW7)VK}tK-RIalab6$@jx{USm%6GPPqC4N6cS3}f_6xJ;;q(ncd|kc$YM#k_ +zi_(@VKjJ0|Z?4AVoz!tmJgIAiC-4TbOB;w(G{w2~N^MFrlnLK_>4Wf|VNz4bqdP2$ +zPYA74nEA+PHJ9P2ItSt7=gYnu4S#GNB(%bB3-{-eoQb(>tzp%{g~2|E4wjsVw)n9! +z(K0MKvv#RCZ;%?GOlLErIT(oYcbcYtes;q3c(ZFR4RJNVFvJA?qu%_&iz +zAnB6$_(0+F4JvZmon&y|G^WQ7((>du>xKj0*-vU>XAE4{*t7zqJ|H-FoVt~gUZqva +zQ^D*e2__=e0iy+cZgFl5$j?9CJ?QY7X{KN0*`6_1mBySmKb^t2i75?*K8hR;=tGh~ +zHb5j0a?(n|j5>G<4I$1?2SlZZ5bW9nC|fJIvn~iZEC{Ug=wJ7m&hT#>VtdNjLlQMR +z=mii^LqE=c;$v)>MviXSUxrho5qw0`w*mW&wHZ>>h)fN@2X#N_My0QF%Y<1i*TRl~W*#PDf +zx|XpQfugI2aJY~+m?zY$ek09w|xb +zvOu~8VSoGCp+SnE=6Yh@IvCiR&T{nHrv+RVvyXzU97roCZKEhyW)9ZP(>s@^QAS77 +z9XkNQff(EK)?$a9`6p%fTKzu|`CcO{?O>BA(fE@<0aB6%h$A7rc6Zbio_XU^o7YU$ +zN}=gmg^^uAlbF8#>CsbbQKk5K-UMBqK_-s6@uRTZnD^K>>!s3L?jbT)xAq$5e{mWY +z1IT)BtzFjIN3OS;O#Y`GL==)52># +z7V*mY0hr|{nRm7t8h)=|8%BVfW7nAJ(OmwMUV1U^l~)*r9a} +zzoN*QN}kM3%WOc0lB`maA=p2f4;BNup^z?_D^?7spUv_p!OmpKY+p|UX?Ur!q_6)f +z2K3U+#687eYN~4=QTzKoKd1OC^TxhPa8xGOJ_gP>o!)Z-I%oSlUIBPF6aUgbHAVc*BV%hK2`=Id$Gr&JmRb&r{_0QZT~bU!aqRQ|4< +zZNpLZY_9I>7(w0SkX?;ksHrZOy3an`SH1JG#;N+fbEOU?x3;{=$BIRRQbE(Dikf8t +zzRz%zSE^+ApSj&0H7Fv8Jva^$0|tOj^|-t1w3VeB{fuKSc%>9F +zQ!TYxzMcJ-*O6Fugr?^IlVOm@_3E4{NcO!6N>Qz71IceoVi-_NLr=b#{e-oif2pgL +zAl~iYZdjc|){J3yaYHS&Ckzh7L)?2vnO}Tk-iLoikCE9!=9~Ip4P!(ZZ0D^4vjj;Vb5VnjZPX7Bh5%MD$WG5%P{pMnjl(UHFyx|y`HOQ< +z0P$Iupkp(xfdvJwX{Vw8hg4F0MBQzoyJ!9<7A2>d;uYJ==~oGU +zLO8CK{j*Kqs_ift;fFOCPW?r3QAZT9@hP%?5K&;qLRO@ +zjVpHKHA2z!bZp8Ol(6S8raP}HZ~nj2oP&S2>X%w+cq51qM4DGx`Ja_pAy*kz#cLNA +z82_btRtAVUiBB;huKqjOaV6*>Ad9iukR7g|0C_~@2n>gIl7(`YbudFbV8p+aVzWzw +zoRD5Gv*9BwvKUR4XlK@Fb8&(us3HU=Iw#zXXK_%DvU|I=drkw;2ra{j4fmAO6Z|)K +zpx_$14!lcE<{peQF_E@lU_p1}qd~ZnoU@nX1AOseU7LXegI2f$sI5ARzOuEzE#pu*l=`(aTfMJ|`JGHkneS%BTi +zsv^!ZszrnSVF{&=F+n?0Ghg(FfMQYP*wKxB_u(1&u&4>#vw^XSF*I=mge3;Jonncf +zO$X3*PNY=`#r%A_lScg1Iz`Zh6VCKG6-je9X~$gG;f0@_+4K5zcL5(g51~#y&6Yk# +zL#T?7ROuV(#7F_@Y~;0SEyq19cBRGhA{DZ5+)Nm3Ax%Kf`!X>Ia%TsGw5b^c(!l_o +zb-$xrQEe@b5+y7yfhrH-0jb?5KGUZuM`W#gWF4sihRI-K(uq7YKdEST0+z?#c3)%~ +zYxQbrHZv1j6d$NS`cnOFGQyUmP92_23?TO@WzJIUkVvjb@YLAXnah@Ln;OA +zDy3vLY+9j^-(MtEWA$S--X-rBdi_CK&*EmMi-M<~@Xl7p+mtVYYclZ;qxswS*X$$| +zd}IpF4Y4k1y6VDhH8%2TpVad+-8p)zoJSh&SHYDFgeUu=3i|BXZ_)vK!}`s2sEQ +z>5I;#sjqFBmNh+gNuWP>Z&mLuaJQBkl>T*3;uP^zd6bUgLU1VU9fQcZ^z%_e#_%!D +zmvc5+vE(dVSJPYs`q7$V4JFUEVj4xrvQG>h52S{EPWe3c2zUYV$U@Z$m}MlcV_&Dw +zoM274-(qFHjGnET%i59IAT}^#88>rQJ`=bfPvp~KQ~eP=D@9_DS98@ietd>+8+?xS +zi5jv~iOFO35PJj4c@|QAMSsoQDE+wR^I8GIA%;TF1{aH|zK~9v7kn*TT_UQIM3ZJS +zqLPxJ0Rx7o%4mHu6XQ{n=ueTeVULCMGLwQ$C2z0%r_KB0XMr4iBL`If5tkYpvy{O} +z%p-8eju8+_K{}Oc%O){3)P%o=QvlD +zBDy#ILA?r-8pK)LED*d@bc%~;1%=09#H%k5zi`+R2hiN2*GO44MyYS#XXzd_CQe@5d}jPoQ;U45`aUZwO&U7f68r`mYyE|W^PIxh=L +z1xn=A>fe2(Y~JrgW|sGsxW&jFA^bj_Yy|7{Yyy)=+#wBw_*Ic)l<_P6jZdyH8JLi7 +zRv3-XCB>V@Z_!2~An+Ls_2I(;6l|GK%wpX;v}yKKFQRVRYp`CR%3Yz=#(ov(H}y?m +z2liqM#%v^8J2Z31qOa!RM_TD&=LHEJ$JQFE$ezC?Fi0=(LdLf+8&Pkq0+50{}X!6#Qm@zMFXl!|7 +zwkG+!aZMv&gg6N|p#-Xxo=kAKbO@3qChT=T<>5asEuI~xm7jYZePWe%rC1MJ?0ITO +z?Gg>V1+Tx`En&S^H%_Ip)AH&uQl_)qsI28%>vbFDXd-njQ;x6_F4~E|M0mtLKX-no +z{_)%xzb>enXZ#_StpJixv}+d!{5?BnT;!jlgAB#zCS1eHXun#{j4*M?(TD`IzrXXcT?)@3Dg`l#4&cUaM;tXoTMlK2j=> +zv~$a}GA-+NBw3j4wdKjzcB{dDuOdi0+p#LZJh`yYe|M0rPsnweQRgA +z2X*JvCJWA@9ffrbLq%9k{RVtlM}4Co8or>L# +z0Jj|^!wx+G#aRqivT<$d1Sn+R%Q>}o4mZ*pyMFie9`;ew#Ba_VQb5q0PyE~#=y;a9 +zhocE}>%Yw+L@di}XaXq_Y5(ISL~M=-Exd3ZCOMz+!HYw?D|kT;{Qo8ibf}P&Ru|gP +z4GM(YSzS=7muJBKO3msyHGa$sl6gYxd9#5mbwoKJ&itT%dJ0TvD>0;Yft18EwfER; +z3A~4{@*(etg)Xs62b7)w^Ea&^{n40&ZVJbY{^bKAzIaj~B_wKfw$W3jG=s3AVl4AQ +zsFc)rb&aDW<{*&4>e8xxX>8%*lye}!x+-P?6x +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 +z&Zxx2f2At!{0)^J$IFc7()ADMT +zifq}`O8uunf!S&FwyuqzV_ROWD!TI9pM1|XM+Uc01Qb)hyT>AX(Jq8A9CDv>Pb!NY +zyZz_J4;Bj6C&me$Y9<9tyR1P%URe&2R2Rv$qco(E6!?ild9Qsvb3*d_ +zf-djkPv4bQkn*w4n%?zcNZ5co4$FQfodIJQfX@k?*KJs!|1Eu0_s+p?Ta$@+JG0Ke +zt~9VA{l-L7sT1mdQJ8p$Wklc?1yt8SJ(xw(j8h&i&Lit01HSwC*m74P +zcsu5Uq{xR0yRe6P5k3u$_V-d~sJ3?R4~`Z3-GR0J)^pGU2=u141^l +zCI-@j8u}+}Lf7_uc-%5{KJ-hZY4AS;ft7thDKDtp^z|(HSbejFyLSwX1yHu)sRC}m +zHzD&4@rCYlWN9yXCDU49*Bki8I?dX*@X_k~7HcJp>!_l-?#*JqSv8t0_z62vL{#6U +zGGXvl1KSVrFZi)Opvh~`P0s4ljiukj$d;W?GgXEAV9GofI|>QW@fnFpJuatjIAUb` +zbv0MpTQBr;V$0raaPq}!J+ZpGAy)a1)r*f--6C|FcOT|Hy>j!q&V3Pj&26opUx~ft +ztvqkq3^uGL9ii?+;C&48;@qk4k-Trf+U4_9WCLd2eF)u**}6z`H;K?G8kT1|{`IRf +zlUm41LG*#0z^Hd|{#|PsbnJktIo4d|iEx*wwA2GGgOtE&}nA~aSCa+JXc7`(#b8+ +ziBVyfGbm7@waeCJSAI6tWiw?IMw>;+?m{1DP9ga1W@eGs^fukQ+3v0fIwm8oT!3$6 +z3ALO5Ky-57WOXP=gloQFQ8o?gsudFI@Vgs_=_t{`Mu~kbNwRmDezPvG#XPop54CWe +zoUeQ(cf@*@A>v%LfF&~MbH6Ev_sd(RPTHuaR~E-QwQZ7*PF=4xeU|2;m$qKdj*ck5 +z()jJBU>z-Ys*q-qaw8yGv^n>!M@Qq8_-Ci)aElaVfdh-DVwPcz(9>HMK}KAP++8s}VLO&;)b=GC_EKwBZuaw# +zwRrkz~Dlv`G?t+q| +z=%J@5Ly{*>M6H!a{-2rj5_W=nTC5QJYU}rxoLyMm}|b*&etu0_naZY8*nuS69fbjERE$%Z0n&e{HUS2iDN%?n7ZSP<2)9^~^G+lBKRqYMvC;uM$>lMSXR +zoRoUJzg)RQ^_HeLwDZlXj(`jb#*$?WX6U-8j6v*E%l1 +zN#%E}b0p247DEx2!Q_6Nu7@y~=GdtS)Vvvb{F|h2px}onB%;nLe+=liY^u;mqxBE3mh5NFrWZw*`r +zQCM9HXSKceJ#mlMJ;@bZk)fjVh{^I9`>&Y#;mu6fbf&KF-Nnx)?aSrbFkgr6OGK5w +zf#1}-ZEY}l7fsLMzF7a-|A^_Xu7&nD +z`ZBKZuQ!h2-i7VXd}@>Ats9M`;T>ROZgh5P@-d +z*@9QT-HV##lULEyb`@8B_v|u{gEEUE*{A>X8l*wLV%0xoSv(b4uvw@l +zB>m?6z8=~0k(t-n=|$3cG?zK2?aVV!#^|x8lHAjvrdTEz*;#T=ZTZDv^~jpX#To5A +zyl4jxqZvoP&HwX(ZEKq*5P$D%I4AR_&CF?@#&OxqP6SE9=WL!55w6z2(|3#%0aeFe +zlR1YxaL5k-PYC$-tmHXo5TMTo_S6LtafG3cCGJ-~Ks97w44L-o5_W=oE(0C0MCTbo +zDN8K6doEzXC4Z+5KOrlwa74K-!#FR&69Tb0zGKhWt8~5Di~H-LDCJhGE{jP=&7B&U +z2gILId?|bCeMCDy)EK(H@8_|fXOkp;$04G9#1nDf=UR$vkb{8PqW9GVeirM+kJL3# +zo&6LkBqF31NElB;?pql4aGkxVV3Qo`Mn*zZ)`OnL5As-^J&w?hciET+3)wrPf7Y@< +z7T?mivuGVRvp`Vu@O0>$p8E>d&h)!F(I!0BI$zJQSdsz7Q&}K+J7I7i?=g7QhS!?v +zYFp#|nQ`o;9&dgd%6M=Pma=ri%w%%ctq+k#xB_d$rQ4z3cZ;Sln;RBdg66IA1*C{} +z8-UIJ{6rzYV(182oN$znf1N0(5!@XZWDw5{S>1n(6O5P;i15$t-9$aI30rr}@j>|X +z(8Jj_vusRHs~NxS?9-Y1HL4Ho?HSV2G5(gh?V>v9C7~`RnZNvvuWW-Z(qFrZ_xfp7 +zQ~z1*QvGJPnt;2yyy?aIc|7F3RXI{cSI^x!0=~bi@cuc!@o=S=~l0@Ze(PwU29?cLY +z@A5reFs*7NsMDLg=Yv(g^D~=I&yL*lwR;D4@r_@Y=;p-V|FqQh3WgPNMevg~^K0d$ +znwCn7F9703X7XG;suo{2)QiMhEVP=wQI|A%+dLGDxdk*;Pq+{`ru{6;(HTAGInRvP +ziGzhdYls?r%9TttGnX2&=hkpS+Oe^^_FnFJ-^tc+Y=?WUHrC7~?ucT0IycdDuKeb)wd}rZrj{tu0t{0U9u)iij4s47i#HdoD05)6-^78$Kal +zt;g;i)N%W%jcZc(H7(Q1*W27j%)Pp8HRCZ{otMJGRmtWYW(QRHE&Tg`YzbX8kX}~J +zgZ;GrZLkzc%iOJV+6S|;S)seO_$7D#YjyCg6xwO-SHOMjo7hUewy{E}JWIIEOS)O3 +zprE%NMIoBa-?r>*=)zM}gHL-sSq(<7#1wL!Fifgc`%zA-o-7Y@u6M|jC*CZS&<~3i +z6pcT7m=xR9YkpHh`ixfb;Em}>X*I^u9RK*>^!LXdcOw +z^?rOGDwV)`-$E@R=T_|`Yh +zhf6HDN=h+P=N_=RM0g|4wjoK2e6i2}aemcs)fF@-YS{cF@lb}Q{+o-F{mM;qqk|Rp +z%I|#ciVX~z*8=SmTRwX}@>~-aRDL9$i>@RJ{O1Jw^V0t5(*IxWF$yHau*c*IJIJ1x +z6NnMmG|g5O*AT`pvUn4*cx_~hU19HrYMP~bU6R6lhG +za~?hfj3PpmR#|{`UhRu+i?6EP&5QP0m-6*xHQ{~<=Pf%%i}jL_Q+P&v{Urrga+ED2 +zGT7%DWa6j`?13K5ilmOEdGEDqs1ZgpJvNJYztW^)@|^#WswW<*pOh-_Ue85i)s4D` +z%+bl|V!u}XVUzEn+Ufc?8$j=AZBzri$tVrGocM`>J_B3f;vemPMrYhGFP+yXUtc_k +zde8h~VA*H;)KM3-nO8ke+( +z92dI}uZdNq3+MF(dn?(wQ%39niNW~>@oaNrHCPsSaDB^J+qe%ki_=htq_n{KC78(| +zg+$r07vl*M?w@MSdPM7NA0WyY^j?1zO5He} +zYa9&Y*@kfG6^W7g`d*a-7kjB=*v`2K31ZS?SRSB`CxyR=rg%lj${1{?0dqOuTz0_d +zBq1wMDI7gknWq|kC{oq>ndpMQyrJX3Xfm(Jcy7D(*dae8@(enu)idN&J@y_ROwiz( +z(#iaOuPMP`dZzv(>yl9jtSyqd>-MGvXaB}4R&psac_l)$+Z#5&2NeNN;3B2Tfhs26 +z-JQMq_x)ZiQx*4|8C)AkcN<&#;9!C+a0`wzxIUfUKcY=8*2ZJ9Zs^xP_>fD{aC1ee +zGGE8(;Cfi$!RC%ny~>7PzsX)?liCM&36^!aFlQ4JWxMSAS^8873=fnQ{NTB-8}5Y? +zSfdiQ?7vK9zrzLWR9O}di-oOfIk&b|h(2_-=fW`)a%J*pnC}g99%p~Qaa`aO@e-at +zOg$iYUF-YiTJ}E)*+7}sv_f40Z-s2}*O;XmiiGa_#ALG!IrQ}38DeVX{27zCb(>c8 +zsU&JRq=zwTj?)OR%1E~LLy3$3(&GMBu*iLl7eWfLYIjbvUtd>YrS`tD+!ilGt8XVC +zbtO^xDn{$Tdw~BHUCj)OSH_iFf;?76WOW^@ckZt(&S&{$2^p8ypps$<$!~NN4^_z{ +zd%C!zX0D_vMzCU3)aaayLYvxU4EBQCus1nZAng5J?g=s&U5Sj>mjwUWY3WL +z$byx?(**es-SzdCulfk~#iMEt5yWh2|MOpcDDPs>T;0t+tg!}rF#Ci5ZgRqLn3~CN +z&x3`dPplETXT<+)e@IYmA!kJ-*t+oah`*H(BCo&21xY|^cmD8G( +z5fq=j$1n|;7^2H)iFyH@auF?wT*O73m|T^e3qXBuSU6E6t_^ca)|%x8xG2Kd$`8h1 +z0ibOYo)TOO=iG@3f+JBxgoG*w5tR2TeVX;Yp(m}yiN*@Lg12mHvPZ9I`PvNy8xbZ*U9IK<64H| +z10p*r&d5=VX7C+Gn-kB0ypFAlke0a7FIovarfcgHz=wO}S$Y*(x97D6$m8 +z1ekI9*TFA)UX{F3rAk04_1fPL4R41yB!djP4-^>lc@YD?-3AUY;Mmc#)GBlqbvdHm +zhytvREsaTOKHYs*ht8g}arFLf +z&GjCF4sqm&fHc~Ccw+@uoJ8lns|qSLz&(Rm3`z@)elQf5AigWLE_=4))|a`^9C`cH +zKiGPF(eD~haE`bR|?`DKNEznlG@`*R9@T1vUwn(Q$T2(&e@sE55AE3hZ#Gx=c8evab3 +znm(OX0Qa}1552aWQ}h_P&9QkHx9jqv!}_pSL~RjUq`M9yU?b;)*vvT2|JdMz{q39m +z=Y3*_{d5l~dH=EZ$G+k9@#0JFvexu~q~EV{mI{@ +z$ImWji(bxP+GI)Fd>hto!~lDTr*`h9F~0F;dR3cuX@geqQP@Dw+B1N=MR)y|4q3X> +z1FOF8sOzeN=WiD4FQwR@OJqv+8%V`4nH&VNZCU;XZ-Okvnrm+oD};XAGf#@qCrco2 +zzmqopMxpkboWi$@yr5mjlDBVDh~>@Ab8-i#8hPI2>tlT}9V{ljN$U?mRI{759^x*y +z)Ds-VBhQ}QPAt2mCcJBFsy@+r@XSB5%K)W)6Yy}!mR31!>V~EHbG=g{*?)cFB`!Vs +z|9RX1>+yv*7 +z1BdNZKXLHC41!G0tou(^AdDAg4Qr=l+nT}FxE4PcLf_>3>MRX{(BTI7Cj(M_my_Ict)D%{yW(q?Aoe-`pT8@-F>_!@g#po +z*|a0kJm`dP|E)z!2bNELxdfW3-raysKf}oHk($%x?-H)K)QD +zNb|sIsF2ka7q|%|{P~^q58;dJZz!&i_-YzZiYQO@kX$r{9d*cglRg|?pd~3r+ +zVsfcU;T0YOZLwVVXi3?;LQt2euId2Ec)6DJ{o>XKgB;wCKWVV&TE~S#iwBYKTe?Nn +z#7xQ#f4=L%A`H-PI4zq@{ClUtFlVczig|>q(=Gystn$<`Tp~Oa^(&qA-4`etvAup +zjkn8uFkwNCt&9J9U_r(GL7>3-Y@TAsz$X2a>u=UHC}Y6d^@xP>?n;fYYAi!U)wFJU +z0rjfE#Y(TfMEr{_ddt!7a_0l#(k{Ai%bC|PB~1Ql)-x|B(Qyx_(0}Tp@&Vt7Z-(>u +z-JJF;dX>upYlk&wG0O%a6MH`O$QFp9C70t#@B|-V+p@_l*%0B7p7B7mZcM>K@Xr9S +zMqzpI9gCVOe5r@cfT=v9V<;!2`wqD@cc|#=am|LMIQP!+6DpOQ)a<^SK<;iI3p3C}F$$Vmsr*8}ohv4qmfq +zZ;8{7lh2jtzBmS-mQH(Zez>IKd_|h^Dmt2LUdqz>S-kY(?(Nv%!RCiTH%bnOw4lv@ +z!F;GKSeWTdL%Y_1{m~ +zGJIgZITci!+5gGkKKuPl_R7`kkx6b1uExO;FB3nDi>;>QEWkv+&D6lYxf +zLPB7~R!9MuYMOc}(Qs33grd9uiR`^W)WPdqS8*wUXrY(nmWl$p$&G@Zmfo*Ad>uPu +zgJu}~<+eAUtX_Sh-JKn}`FX6HrWl&__^T+x;#q +zu5Gs6wf%l4d0C|8mx?Ee;SWXav`f2+DbK#QpIOo~IA%+RBz}`qES9(pJV@MQw)`Y| +z`Cc^aOPg-=TgZAzd&0dDBGm#lw;K7p)%%9XV!4;o<<^4N;w8iB$Y3j;OnYxdEsM(NYB}yb%YIds|YR~6xUGSTv-*Ehx~tR +zePvW!QPOP^ECjdUkO0Bm-Q5GhEy3Mg0|a+>w-DUjT^o032-0}tbYuOPnQzvc`QED^ +z_pVjz-gW=nQ+0No+PiABa=UMnc+7xpYD4$lPVEky7TX}u4LIw31eiPgLPmm-)4;fk +zR_U~Q-`;in*cRrnkvAf;a_TWHyime>{Obj#%I-~8~Eq{qa`98$S +zng#sa{S%CGu6Qjene$j%@{pP)+~g~ES20m|5~a4vPf~GbWfrYqoHG2Xak1_?{{Pn$9!&BWUZD7%P1qnB|P`>9!<`*?O6de|tZ>MwjWbJJC0I#HpJM#GygXgiVya_WgbAfgC*{R!gGM%e4 +z{f`pok1HE5*9UnCmuR|akH?vAQ+vUA)4uVupza>;Z%rj#TJC0SagWU=?QK^@WtBeN +z+Z2)02THCFBnJul3CB;Uu~I%{P;sr)^|m5orjJTnPe=M6C)yWAbQMQS{CaJZu;Yd;+OAE@vY`elNGPaXK&?JGGf?PWRWaCEhpX8){QP}Qz6$BjEqS> +zcz5;F(=_&HmK+jjjMK*^|$|H_@JJvW}^HgOD99#sMjZc$;XV!F|gXibdC3yv!S1taroe>6M6TA$^#YBY6~jd#DCyuIuGWVErYJMs7d+(&ed!h4OO> +zeKOO~XSb8*#_)t-22%oq+lJ=Hal;0^5a?ad%Ka^N8B}Q819V`WrNsC6vVy?%D6l`ck!5>Yy8ETZf^ +zyi+>q?>C`Qh)C!d&`T;O3jI^Y;VBuUuDMOrk~t#>Xx0AQ>49RQ5us)=0`kLme(izp +zpCVTbA8IaXQu&l&O8Ff=uZCH# +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 +zGqX9QGyOIBdSBdfD3VL}y|(zfAKmjbu +z=kO1>vcnZMs=jCXz@*w60ms2EAExkGdI(ckJj?kAKUp3#&%z_Xr+d$r2F7b?eOG|= +z@O<}lcXhshdj8lAcpSA*0a#e>K6Ifi0$?*yalRaRc_rufvGOmS1OAW8TCidkPxf36W|}O142#>0pEn)_oqq9Yo#!oiaO-i~u*!1IWY~Dp +znj-Q8UYgqtv>a4>^OxxC|1G|TE_e_{B~IG+gVwqSfpa0_TSIKoB}+vCp8n>&>0zAC_j<_^00UyV$Y_=VLsE$xr* +zGJCae6ohYJWa$0mu-s%y>(o7$8#j;*I5_NxUp7abv+rRmlgb+zT;zHgD%b0F(K_hI +z{Bkfj$$vop^fb2aoJsfG-LrpWkOG>}#v&`p~Y@9?p*{D-Z0 +zOpB=JBFtrsYO|Q!1@RFgMSJEQ)S#Q`R;lQ(sCG98}izVI{bpjE70) +zVO}tKXDEOb%SGt03B*xX5fnuH$bAQ2=QrP=D#zuN65R>?0nM{PwYZFs1v7_)4HfwFk@L{roaA~ra3eSO{? +zlC~-;Ui?cm^5~;cW$Tu5yQ1X+dogKFxu!F3vX$WmHs-ZR0E(BxGDthVN2A_x$dS1Sv0h5HN~YoizpZ^izJ+DN(g2a&lRA}xC?b=SJPFIjb@ +z-=^^_UoCgRIxDkc>sS7YbR*f{OxF4ne}AvhMf+NTJnJ%_Ncv-jK!kh5zt14qrJX9XaOKj`VDzXiYB;HftO_HeA_ +zKaSk2+IXbmUjqm5eZD&$701E|s+UVDf2?(QV +zeE+}}^rJwff@RHM?W9wt?w^1Vk%tW)4vRqAPWY2YgU7+DiJrW9-iJis%MG&Rr~>;&m=`!iedPD&+AZQ^x?PFDNW@Ei7GDZ!k(KXHK*2(!gh-E_dDL +z7p4eaYjK_!=}A6QEgltqhU*UPC^LYV9ypw~e&jG3kh#=(*u@LTu=^&tGv3M6^sE~@ +zyUyai5xRI%I4Ue_t?% +zr;XfR*~@TJuw`6;J@2h<-h{%fexJXm)oc^r)JNq|o|8@;!EQ_YjFHc2JQh@WViFPq +z-NAbj<-S*13rooRLGJXj?aBPi^^h=rg55$7U295-?|b$%s4w5Yo%F_^-|#kxeMSOn +z;6_I?l6DDS23g_bKJ2HnCf+661e3|4+a^I2_u3c<7zPMKNtbNwx^DH7vFT_ +za*u43ijUC=fPXwWA`btwaI|S&@1QkC4Sc&+mrdOGMfx;}v0l}ZCROGs +zm)|xX5?;{L)u;K1J+?{CjD3sWq_V+1IDI=OpkglC7R*@x-PUVAr4BAn3voPDFfqWh +z7hkcK{{c5?BV&Olp>Khda%qA{owP;{QJp6?p+6*X1z#?7vUIn6Hpsty_%F`_iVE0q +zUth9)CdhwOjA&dbLGS~%C=E4s{$Q|Kkt|tv-$dd4-&C>h1mBCqcWRjv0;{XUM|8X; +zv-YM@6F6A;A9Rs}pFjJpf7u22{JDfD+K*?Rp(j?CbVNnAb$qvJZf1Ot$VO1p6}p1( +zD%qLli4ElnF;tJ|+{`)(o!RD1v1 +z$dS73%e>tBHk~B3`i*_8wQSti$>4w%<7Jcd!mV6NSy}nu`H0S`*z?g`|8oKd&Dk^F +zHYS&-64sK7+YSCea#pKj5Fq^WnKHlbri(~y_K~WlAW@Pj54%|b#foaZSZaL +zaa#{r^E<^O2!!6*z#UC9I$s@fbjC$6xTX(Ymh#%nCY-`#ufT&fKZ$7n{N|E-I}>c% +z<4%jRsR(nt3mM*6W^VJ7co-#eLEIISs6W*O2y>v~)*QjdxlRB2CRB|?gi{9D0GIf_ +zqc616m-+GxoZZdzc8x$zG~>xIVL7?^`tgq?&E-YR-)Z7k%Hf)kp|inY4ZL(3wGG^` +zhHQ3VIsl@qTXlh#M@_9ejC@W@Aq?n2$aYJ|*6*p64DZE5azLysBS<{_9QQhLhlwv5 +z)r$$fI|LSoFs@gP6jXYgDDpN)yjDMVb!_sj2sS%Yj5Z2on4)4)SX9mT_0MnR#AEu; +zurgnI3jWi6kc$eycsT#l8m|K+{@ecd6P!JRXoLj`FP}?}pw7Mr +zJ-4^&IOMtY?La*>zO@6D@RXxA9RJD|HopMt+)mOa4a-XBTPR0Wf|#wvzjzy +z_2phyu~nC-fOX%42NHnl=%i6|`;yZcWDR`4iNgV24ZR`r+RS}EDSHGz-_`qE%RgH!u3jKGo-|*{YxBifmBxhztgAB7i^KThSJ?=TvK0{ +zS-O%cM|lFVND)EIgvv+=ZQ{9(2}Dw14vrox`HNn`@~oWmXoAK}!u6bYSqugx6i3F{ +zS{FZBGBHoHb+2+h$&*Dc|F^FzuQP#6sxt20*BIK1G7#U-!P!V(hqrt*?oybpqOeqoXr&Y%*xqGxB!Mh#Ug +zR!&WKkf)V1xzmD83|Y^$C?S9^qlUZ39L?51|;w(a#^u-;BgBMVs +z#qto-!;-yK2wZp2^stAG457R*2#tu(ZL-vE6j9r^f4aOzs(9!MR`+}T*~u$9A3Cls +zLYCP;4a)cA*Q@RWr?VcYaT-uVe&JFSm7Z~nqY;a^ZWBx-*IQUu8jA?y^-YxXG})lI +zw!lkBVyQl}!+LR}mcyyRm_^GV%Eg!@^24w1 +zz5^nxqqlOGwe@TCbdB%-y{x)F;8gs((Q;dTf}@p}0KE%gd9LM48R5mY=&W>L*noYJ +z?rU5%5Yk#vFdEx{H9JCpUnlg~x-VZQcj7b{TKwF#wvzIu*ghm*mc*T>3weV7QnIV` +zr0SRxpXhsA9AxZ<4D?*wkSES9UHPA;Dmdp-VNaRVHiNGo0lsw|fU$kM%6%rXfYUo? +z3-zl`how(v7tVRXv&nO0xi?!SJO`YWV7jv={?r#!nELRw?$5~5M!ux0&R2Maven3> +z`LA%-;qXbOgLZ5K`Z6ywr}WSbxi4#_M#|J~LwVT2$! +zu=1E!n;wx{UJ=R_2RmB7;R#49(_>sW?911>d<@*x9ywPP+vKG7}K@ +zgFKPZEk=85QDU8#2}Hz+%f^@-zKM3oTE-c0UEQH>2D(s6R1g@d5s--2X~nD@*2hLm +ze3I7>$K{ZaW}`&{c>-!xj4=eCd6z8HJa6h&C)gNNIY>>?gpUPt3N=yBQ$IP6lWhhe +za%cv9aCZ)f`}^9}pr}TGwp5rrLCM#gj-4|M=d!?eH?~CpGrl7I829Y0)*-z)Qp~)! +z;*vC?)GPXamh=CIQF=rm`&sTPn>~k%<)1o#Y{@Ve3Qr?(RRINhhCdnk4D~NJbnBh? +zgX4*oeYAW6N7PO|kLy7~?c0?kaE1^5;0HON$l(TwmJkJb(s&nE-bijn(h~~7P(4tf +zdAJO?7`q*t467v-6FI^Oz|Vum0q-JiHnatSHOD1Jx#agXqka(S4@RgOfG-`g0bhb|;(2$!H>MG|PXrsuxuMqgnO +zY>+Zuvh{#(D9GEyAQ|XwuX485>oM&K5TO!4AU5q;ImdVu)Bk!49JoUfP|so+08I{P +z3MV~Ej~03erp?}L(9~>9(S+t$#uC5 +z=X{qiM1bINy>h_Ia`r)#KP)$6(dfub6a)Xq)N(r0TCagr{8%3GhnUANpR@!1sC%DfT +z=c_M6y$T}C4cNl6nL2;fb*>G*TnhkZcF?a!YVSJ}E0?>qT|uq`lIQg=J6cO)$(>HF +zz!m~12B(8^RVAa +z_Q1P8K=Rj0Nz&;%X-IbQ)gh(pQ-X!L4{~`FV9br9y^hoNKHe|fytMJmh@lycJFahv +zqrDw>+lcWK1Tedb2leB#B-D(#~S +z%ueB1)F=L)r2YV!{81w#E30BM_c>*M-6gYmD7JXXY-QS5k8~Ns|7FjPZz}onYRDSn +zYBB6%m;Riuzk_ZS$N~0!p3RFCPs*G}D+6uaLf>fK-|uvxif_th-CvgYPMqpFp=C@n +zZK-QT52DN>PN|YPbZjLRa9G#C#@XYF$f2?lI4$MP2xTV-T|B`4VXzc}c7#=jpRj-~ +zhf}2HRkxv@Z3X`J{RP$9(2ck8h?BEZiWJpfmBOEZ(k*?ga$dK*sO&AvVj?Ya&s%MD +zRkp_A>wB7+@KkHzzI`cry&KUvfwd&|X$Tc*VM#fCjP2?ucAVgYWy<>%h^m6t-tJ}8 +zsBg4mBI1nn=YY(-xu2^9zA5gT-(X*vkdfz5x!GO2`r(d8e}xeQvC-E@q`FUM?ju@g +zM5EJv-Zv}X#L?z)OQa_1%U@hUpA}!1L*$pqva3TXHBaq3K?pXs(6g~23ASn|$(3I# +zo-s|fC#BWiqpOP&C;r0a_8U{e!X{Y>WfQaUI+`W!JeD&x^@}^tS#NpcJT?FO%r%|L +z$W(7JqRyg_SndP@_(M&`$asvi*j2YA+i8trjTUDDdrR6(2SmRDLbz-6K>>Z%6Mo4`v3>7_bx5x&)xj&_ICCoJ;?B5p8o74T|{L{E3i8En@VxcL}Ah57f +zsoSkV!TnCL(41y+>vzg%|+sHZTGn-}Zz +z^YZ7dszqggEdki8uJ~5QhpLY_L2ko_N5qWOJ5KPSV`TWZCqE}g|zPk%s +z26bFP&0aXxG*~vAwo0G$EBqY{_jR*;{)&OAd^|tD@?EAf0j&62aB$T<0%>L)4wO+s +z_RTOMq&!$FsGr=z$Jz+8%B^MCts>NPF0p#IimP{3LT6`9eDE4MG-L8ac&_`((}4m7 +z%_q@JX#uT{LwJvm7BsTtpYY{tiTubB;FPGCSv=4)>{8{S;=C}Shg>Q +zC3AB>dM0$|y--biGZ|wNSp}U2-;l^=Lo`1)qkQ-hjpFLy)Th9}SaqAxRDdS@qKW$E +zr$yjknE5u`#{}89ILYb}5&b*1T6rpm50t_4#%mo%17D76e(?*`D}5A}j?tCk$C*K~ +z<`M4QgWJw2=$Q#<@VI63(Y$Q~OM2-7#mfvFaj@cL=@6#xktj@bd8kG$P#hE#6n=kr +ze&cG&rrcmo8JX}Vs7bWZ|(2Wmlj5Qb^<1#orS^*G$# +zFPtWH_kYq_aQ0Et>Zsb?v>heNLwHfitO?)#MIJwaPlA)3z^@V7{rpms?UHdWEAn&M +zSnfv|0AE4_;XUz8n8PV2g<-105tbnuOADa?w}Z+1810nEv`?H!-$_~LIDT3eVugYN +zuM)Z)a8A@t0gt_+^l-;-E*NG6(T6N*W!Z7fP;~hgzVYG=zo}!4>#_Wa{UIiJ`m4m& +zyDP+6l>D(EgM)d@2DP<4j|G{5-N>yh))#B-aBBA@tZE|ci?T56TxI5~& +zo=)7E+D!PhRIUwYB9AZs{f{SZ3c7m2ZP5O*_H6vzo{B7^gEoL~@kn=W`BIx%ua-l5 +z>QHrHJ%_^qdr|A_^r}a*`L2iVnWe$25p<|7Q^l5--nxL*N`-^egpjWD9-oSaNcVA6 +zYs03)N}R*i&x2vJWhb3#s3H<47%=aC&R6T5);}!&57uzQAFT{zc@QSMZ0+jcDZ3iU +zk%&g5H2#D(TBhr_**O%UU%y@0LpBrxP|aA2j|`LrRMw(QcTH3qC4y-5H4&A=rDZ2mZ_9pf1IGVc8n7s +zbNjZ{JJ94DdOv~&7F?I!zp@4=ve=$uYNTBYPO-%D9kP09)@DQvNwj(Ht*UlzyVm|- +zrQr>3J!^#XYQ09_yhvd%beVld>_p!gMHP{I(79WcvUsoyL84SLRNdlN6bGr4^_hn` +zWfsZRra~72Upy80_=&=&72=u&mGLq7*Y0Phm)86@i+mY~dp3fJRj#f2egoJZ0#7U# +zd&SVUoL0K6A+Wvx_IWb4GMySp-~H13KT8pMN0++iOhU`!QL)FYg*#CsC*taZ9CUD>>&Y +z`cZ~l^rF+aEP6e6~s4FLWX}yt+?EFVyYFU*vD~yy<2~1!Nd9+NIsHB>fgH +z-Zb5?&SEzm3ZkK>CKei5G0J;NlwRS^!AJ~6WjQZK$qQ)MiV&s1afv2kUBxBxqy-7R +zK_x>uhcWWR-(yO?Tn7AG4(uPn$q?so1ZI?de<3%o;A0Y()J(8g3U@+{YJ2>Xi +z%)5W-gP}Lzw36*(@;L4_h`_@vd|E)XtJYPAfaG?|xZ!=$w%>W(Jr9*Zy{*uLU7Se4 +zfS&8b>ubk($0)2lji3+w)sJIYXgHO>dkmnH;~8bkqC+EA>w8)~N2s~?l1t&KUYP|e}XN=D(s8vMTt_y#6#yFGua%(~+?iT7N?Vv-a)j2RvSmwCc +zMFQxD5gqZA3U6o3MC90OZw(2&N$YeG`f*y7P`fk!ajUN}qTxU(Atzsr!-@Bb%I;X( +zbG-?~e^!?akage+cwqI|DJAqo^q4wYS{;moow6Qa|K`udfqNlsaRD|&=pSsYR5koS +z?=R$Ti6gJ~^_9uYh!7X +zz}cUW%AXq(%=_`oKFDoWAmpO;!xq)k9MN$*PvE^S$KY-Lc*yzuVt9I*O9Eo#v=oY+ +z!xNtgmO)5zT9FT;lt-X5K36UxPmxAAfFjn~Zv_MCC%s3CK)!B301_Y0ycZJFi+q`S +zM2%VjvJ`b3w|S^}ZTS5Dn?At{oZ5xo>eD-@?cyfoiI;s}6&T%y=LsZunLdds`4t{1 +zaoLknqT$k_yggOex5@U<_4WD|o%UdCAiIhuj5xgVGy1zI!5cg{C(9T&6U)rNroIcz%(|Nuk89ffS4^`*07$7MP1v%y!pW={zStD;wovWO`_kyC}MReoK{& +zrfsz)Q0WF&C^~4Oy!hj2mLX_KK*)t`qRff^u;k77yQFKj@78rYk4Zr!&-(i)zqVG+Q%{66@VA!^=6N(; +z=P5@)l@<|J*n9CIPe=+c0av9w&89-ay);lcnPeuaE6>V#;qGx*JP$h!-k{+1Rey57}oi_dMg%|(y(uqgvWgoB~AT9__ +z4TL;D*6j28rm6VZ>|*=w%}nGSc(zyjhiXk?+8C*gAI#UC%gDGq2_GC=j5;j>X6sz< +z>+%j-otjDFG?$)t%dkipO}K%I@LWa+?@K45Unh{r#0dqIE_9V>(r)vm0n`zFOHuCt;flhT<9oc +zbju6*;@_QdB#hZ-ONnx=CK&D`Y64wLm}9i4TjRNGC)l5ME%(Gx#|bT|lXHsY`pk1k +zHv!Vt4cAylz#9Zr=Lt9iLQ>BUwbMmgy>5WnPii*$mp&8Bl-$a05=SFen3%s2;e9`! +z{Nnb;3HpcHSSB-^@!w&(MQBCb-}266UmQalGE{6(#a7?-$-5o583p?znTf3tA?rj1GWP}}MAoH|;N#f}DV+C+n_NeEYb +zxdXB!+P;<44q@c`0dGoW-I +zQhf(o{~b+?6DXU=0||dDQ8^)u4gpV*pTza!DX5&c<4i`l}}>YE*cO!4@+%ogw~u< +zLYtOXR2&+W*9w&IowQNx#E1b$x|aVV;t>QC!Zm6lNQ_+@pl9ueSC$w@|L}80PhIXY +zIoat(fQp|Wim9Dr8l=BKm0+B&G1~WNX&Y(wXruNnioaDfg?Nocx3*I#M=SO2QnT$% +zOM5g4-0o4VYw+o0KC_`Cb&$xpt0YlSFsJUk<2B-3C|&zs1Fgp&hX)rfcdK8Y7mCuw +z?}XL0di_nh3qiNE*yL1qra+RHfEwJwy2r!y*I#dK{wRo2vU)Tw@2KdjkfFGw+Y-R&G +zyCEJS#rh7XDEs%}Oyt*pu^6I+jV4|F)uXah7SFOQ+k?RYJHPVq$pYEic-%d$0CcX5 +zkO#e%)NB5ct(C5-oY#tpk>Fiou>X$6^8?Zi%v>v1d|#>gD%dm(MBkLSWEk3>etc +zyvs$I)lg}1Chc7Hcf2o|%z9sLy>GC3^AUCxj<+#wSuwl?7$@mNu^%Iz_HMU+Z+<>d +zWS6`2Z2GuZdB3u_YIFa1NNzBh{b95_xxPYv)v~5TisORZKD`gg!Ecw6as8V4uAxY5 +zm#w3C0|TbrwmaElMlM*@iowGudNMHb;=S6iD57%NS(DqR2QKCg +zz}N3M7tmjVZVRosVrnU#KVbXpx#imH4R^Rbjh3Z0k)XCw80~{Ru=pk*>aZu5o{i;(OC1-f4x%qJ~}fI&MxkVYGKPb +zoIay6k|%%S>&R~{QMCf_MAAHOA+z^S?}VOmw+ +zM}J8sE45pEv`dB&aZy>n@6}Lh)lwtzOD4~YSa^T>)s=_*yCm)J#*E5U8FpTqsCtvy +zaFT%wbm=JMwK!yUU##QU#*9Fox=RPE|Dwc +zGWk%`+e=jwu5Ue}8`zlO()j+zq>RfMb`||vk&fOk&ZFcIU+S2iQ27FMN37xoOixMM +zoNi+0_up{{h$;%nWP|@6jx6ZHImn}G{S++;TDGE9&ZK>t@CL4ugz0U&$*>30)Z2ys +zL)TXZwb^jn;?Pp86t_|e6nBaTiWY5=BE_Y+y9TE?w8h;Wic4_|R)Q6WAcf$;Aq0}k +zd%tsM&U@~?`_Ge^O#VDG*=x(%YjxWqo-NA+SD58@1R8xV+Bz^5vZ->fl?Ic=bh3@y>pbE#~1pBDnL;Xa~j+d4+;# +z9>@@$%%|W7>7T>3M!M<)xypig0X?(7L2BHYt7r0)18;NP!}FZmVFS77q&re0Z&3(R +zUDxh*!sLtKw5HYl&HD%3VT2W|Cw1IyE8t?t`RML0S(XRd=~HE&+d(~rb-Pc~&iO~; +z8D~*mv0d+p2vx3likgx*q9%sgu>C^SvyvWp{bO@bVYV*gWlMH?Ckv +ziGwku$n>%9ga-KObP*ViJ2Ol+LuQ7pcK%j)&js9RcfH!Z9Pb`o$C(zHY|eu$Hw2td +zWQq2ym3OdY?)LpNwW59`{eq7wf7fH!Z|x7|?ed${S>#1bi(ZsX9z&cf!H*M1T+pxP +zOX!`X#-GmH!G)4i_*u&m!{Vsb^tr+Ef*{_c&)x60?vtGj-vs`V4Gm4hM2t@7yx(54 +zq{F=IN{*6D(#_S@&a}(#$lv`9O!b6!klRiqNz~m4(r4UFt{|QHjgXqQLuvkZNlAn? +z`Fgp{<4s!H!Yrf`#j^r`vGTtYqNC%+pGrGk%ewG8*{@bg2T%>(CG}o93vi?8ulBsn +zEBqcmzs1N1w}eO%aS1x%$0XB+zIO=Q4tep0TUa)Ulu?fTN8uPcRiK8r +zOx5pXsn|ctkXE^dqSMeyZ*+=Hm`2G=&0N)V!GdnO{PPe+R!W^xJ0iD7?$ZSJ{+^r^00;a>XXkk1U^OF=c!^ +zD7qV6?#8mQP$-iBE3~A;cyFB2>uPd%g%fj9;XIk;gnVuAG*8$OqlkBbkx>DnZ{oSf +zXwYC%Z1yhyr3@Wpy5W`9n?swBWHLu(zK_4Tr%lUQVz0`~ +z|BeJ`6ctpIRNBI4$BMe%RYeMahioUJ%?sn`o{A0-3dcqBn#IMMHbYA +zSvmZy8d0`XJ_z}vSCDZ{6GWWMcG~#r*GT*8Bp$S1jFFV4|hCvjn +zP$*B);jk|7hNL^s@W6}S_6*OSUUCZ}k|4dZdhC$*8nz*I-EOSBaCGDR@an|67WnxP +zeAE?lfxnwy4sdpnJax`}=*#^R000S=2=u^9!EK&aqlsnOSGYZK5UN}n7ym<8gFl$t +z_g;IV1 +zqSS}6&>Hw;oBH1~|Lfccoipy-_5H +z<4338fW`9|2Kebc(8Si>iT7lq`+6PGT3hLgJD=jaxVA-`3TUeS(QZ81CEn)HR)-pH +z@k)(17Hs^XZ!{*{+!-S425ruc4r{-dbhJ`IUVqC=YbYLHY`uo>Su2oAIWtm41R!6=e}}S+R-1`~J65VxP0%B6y_|EfJCF{!IPv5|(=X +zZiSpE*(Op$am_*1!-J6|`(kpF@VpT2pv_NDf)vJHJc+7KZH969z``jswjP`pWciL>)GOW^;#jFCE@JSjIy*t?EyOE+4|kw@ +zc1-cWJw}MgIC4NdyE{jRInf9>DU{t*6dfJ6v2n$KA({2#U8VfxNBt_z;xKNyvI3jUW1Aht^0#p4oK8=dn4!Tj+@OOQk!nH7C^N`E1kv+$=;q}N0<9^nR +zN92`=7o)mXbY~dz)hqwN@!*Q5Jb$Dqq%<||yDgoS-E&6Puc~+>4$<;`TJJFN5>ojC +z0W;DSUUuv(w=kx$&@r+a_B_#pfsa~yO`8s1n}U*Cd6t#J8gJ!d1zVLi($3P)lyH@B +z@S2YH;=ubjOVI!(hu4dCDw&7KfHZAc1!9aZH?!1rO!xmJ$wT=LC|SK1#PAsXp(8pGT5h}MzXyS2{6hxM%1ojM+qp@&}Ns#_F4t6i(z +zZ^U+!a&%i(sB8nEb3C+XO!N5K?4IH)?LnuIs?>>~?=XLr<63(Os823XcRL7lh*xX( +zAo|ety^Vgv-$OhL?(4FtnCEpHHF3dFQ|eK>3tgCQzQ2yp_!KB(Br@-`ZGzj3o4A7v +zO+!NcIr8Fx7=If$mMKxlbTU9yM|i!<2f&y!R=m^(FY`m&2GN}$ +zKI;L#7qDt!Jx(0V-ThQu*CfI{iy>@Tul?S%Dq(#y{&7g=D^DdGqeJTCH#_k8;h^zQ +zS^wNBpsuN&$PI2pkC5n?|3#*u%MBo>58&>>O}MXMsP!#%fv;2Kg;A}hF?$5cnw%<6 +zV_a4)?yP;YZ1 +znGpz|XA}ipYj+8i`?`UE>*g+j^543b$Zo|2s$VB4P=kgabrK@;(~c}C(7nk8-jXUQ +zTp^tIpG7J9tufhbx>N4h#*9U1F?AD^_Ki|b^*r^Mdv3x9;VH&Jf4p&9;!XWuKYj>B +z?koh@WQK412JFi3Qx>M{dcXW2d$ONPRYwbHHPw~Gubobw$QW_^dbxzQX|snH`q7(@ +zC8saKu8q!zw^cPJl(rOuM!%Nt15`jgoJF>QTmPU%c`ER7OdL;|g-Bl}EarvW?DOJv +zmc45IW4fDZS1xwuoDCB+TS?5!PoJkMjl&e1J-&WwQ?vfuKxhN>Ax%#=BN#zVS4B?N +zX_HDgu}*_I3_PSboFZ6?_6G_+8cog}k;+7dg?y{eZ)FsJn?b*6Nu4_2@u1q2@IYeo +z!g6J=oP_*7(y`jyUxd2sI{Mj8K+kpICq7d-!B|1E3H^cNS9{qK3b}jCcb%`qyyEQP*N*c4<==Y@y +z@?BO~F^*FSbUQRgXz+4{ZY-8WSRpXD;Q28;xXzWiITC(FFJHZ9F;~%a%y9bI8Vt^y +z7s}?aiJBJH&bY=T$UaK0XVVVfFl%XAEco&s@hBT3`d2Owop3C%X^Z#NVT8D;W0N_! +zY{@nB)5o7r)W--VqpG4$|1Ho={3y^|ciYFnnW?vY+}S6wE9ybl*l%6aV7!Vi(6gaT5w<8iMZeKo_OJoPghaBE4)sBM(&hzII`oC(>l +z3usN-zOe9Eo1{@2M+%rAI1f>vYVB5c(1)I2C+IGDl$3EE(C-kuWs#cJ7WkT%(v0rz +zVQ`UQZkZu2rKc`_XAB^T+A;s0WOpQ%W~8_f!2^WiGADFX^cXe0$Ug*vlPM%j0@(b{ +zRvxvUmNw4-Qojbr6m_@v7;J^9=UO21cfNm`{xI(vLAA}->zvP!X^`$aHf{k<#8-YN +znC6eQhPx~3i&|xWfoswWWWcOR8@xaZsJ}I@Y(|IO>r$ +zeiowyJDF7uYDpTXpO`{c(%v;n{)gxv4z==vMB6*&fUbiTXE>5tT7 +z=VF{V3PE05*Dm6hmb=Rc9?N1n9-i@bS*@4 +z7JQABZQhPuPWze&9#EVvZ3;Xk?$%{Q{K%J=xwaR>==){d9cAWA&9Z&z-%cF4&#LD` +z(|av;_#^*8C0?2PML^_kzIZ6C8jF&tMm0+8rHGl2R9K%_K2@2RP!qMP +zriAVi9PbL1y-(5*I`r+s(yX8A+>`lUm+}nq=8vM-biC@7T(503rBzE&JhYS2}?Cb|3O +zwY8dK;8L@X?3u=g4wqwb1LH^)MU9?M{(}Sa&@1+}T@2#5zYdmULl9U0)CGpqh503oS@=^i_V9T@Ih#Lbw9E +zQvci&f`n1ARz(!QIYkMpYo%UCT^lyAROGj02Tap^7fd6@?zAutL%_oCRt+rOJ&xA^dkK$brRj%m#a0 +ztf4PcB_%K_Iph2R>b4PjYf(mMfc8`VGeOR@1_r7$Eqe4GB^ml>pbJeC!;7Ws@!j6IR-y&X)%2bi&fw;| +z_?1sJUJcziD*FM-9~{a61X~G=(I$;PVGTIH%esmt-%U%}#lGH1btrP<{a~c=QqGpx +z)Szf!@Rh2VfxHG4F*MMyLMKBYXNCHgs^=`q!L(M>73q;FC*r-!FZ}m4Se@@`Iqy4i +z;f@4pcPk-52&LUbEEXtsWqBuc4=>?pcD><{Hn*YK78*4iw*w$vjU +z2}hex{X(?4tfxDtLQVOFtG_OUzTo3e@Vl2;Q*l0+)JBX@jALqS;pN$C8CZ_6x!0db +z2J38*-{|q{?q-C609~8+1;1jnrtIUyUM++coxNJmsXiI8p|`uVL1%uvz-!Q$ +zo0a|?(_vLFQ!f~GYxry&5F8kF_03O|SgNq|+39n}*_{_Z4Q-t_xD@A$gp5!icJ +zeZtH2FnG!g%=#Z?#6La{(5|kV=EvT^+i-iJF7KpUd#hzlsnvbywJ-X7>*_8m647K7 +z5vE;H#>6`Ub+!d3LNCZ5CaMbrMeadEH;qM5uoLb5J}hStjzRo##roPOFE_qG5@vG1-jm4|1w~c|4?gxeDzD3RZ-##Cpy&QTu#^B +zf1@u^1bLsQldwvj5a90b4BtD803^<*c1sLfmF4q9art%sfLAv1R&}*{TsHlB3aqUH +z_SOelnRJx69Zu}v|Az+}@a^`;P|IvR74j*GBD03t7uq}aGSN8{lbnj89>rev2@{^7 +z)zWc@SjeMPz^efG3dp{42t +z{~xCAC=gkt@o2>ehs6SiYD@WknqNkOb-C^;n}Iqs13I&x0Q${)_V;%(hENg@ +zqqAdoV{X@LNdg4bJ-zv9Vy3TIbf4msW<7rE4b&rW=Z_WY!`4v>H;it@rWQ2t@)n0x#r>=-#NT9OCIIm}Shs*7`kS4~g-GS5)(5_mE}!%4 +zM%i~BVk36WhHiar>DBTtTXs6n--NFQy~7f25STJ@CMj`Ln`g%*KP|%)_XIOq$a`G= +ze7EZ%=U{F1vaK$qtRBl!LlH|v=bh|3H*ct6DY?LXZsV@@4UXF(H`bfFSu?<0r3%al +zZ8LU)Ci@SX-63HG6=w%Qe2`_s2>sf;Hc$FSoX3lhfkDTwsDbrAxGVZUZdM8B-M^!` +z4x)1iy!wFk-1TP78GEdWH%Kt@luWkMwlH75ozg0ut*C`xtJKu$)@5oYS+kTE^BLZv +z!daC$ok96`uR>ygvK`4b^CI4|4L%tN8T6>Tf3w@odc%OG^7He#-zT=KbI^N%@rV +zgQ)SC(1$d%ysw229{8=XnNPZUT2B<@cW!$d{7IccS26`7ju){N!WP6Sw+U?!*?08e(#u +zf=Tp4Q;~M5s)~GC4t(C;>e%+-5ZzCGQF@9#^6M6SL1o$2DZ!M*>VMn~y$k9_`CAD= +zB3x*Z3@S~%Z`Fqrf +zFTXQ|?EmxOnjmWkm55qitIL7hZD}s#ZX8%CIvQ}@c9tT6wQ#99R8P?s%KreBcyP6Y +z@&VQ|O9%awdW#f%e7n&hC!+p;c#hmxo}af>Wc^4ZHx`4x_sI +z4xeJep}lP38k`+wsAAfAg33_2lL8|)*?K;j%ULB1*zJGsOk4nYuHe5d91nD&zq+7t +zV`?Boy^kGsWvZ=fW}JLH*`A>LAOo$Z)%3iLTKyXP=rp|1?6%#`@E}wrE|$?r&`qE)Z+Z|l|+ +zfv&%a{J0f1XD0S9OcF*6<7!>ZCqK`Cpab4Dfz@*oZ|psMcM7Vr^ivLbPV07OuE}h( +zwv2s`{*Jq4aRiBK&)Y~uZO3%9K%{)uxNTL2cSI$c+7i=RCGOzA&X)=U=%FPlcg;r4 +z53#M6j_qLF1LS8RcT0G-aD5<~p#8OdtAY2jI0nc3?{;BA{6l+RT(-9-C8mM_?5Uae9gILJXw5R8&yp+RcY~hWcapAK%6J}^FQ|RAH_x2I +zu})yoVo!;FU$I9kBeSX^KV*lnZJu*Un5d{dE3Eo{ +z=)Pup&M=BqQleav_Pr1L#{n9Z3O;nUCb_1Tq8Ra#k?7b>HN7})=ET%Dft$l})=Y-+ +zn;br=(Y3S`Q3X%h`Y@fy4=*T9=08SheSPS!qExD2L~3bj>Js2I%GLSXobQigG7wXF6&^>Lw@LXdXKO^;jfC&L$?MLpB7m$i +z3+1bl`6$y0W3ckk-=F3layG7zAG#cVbp#MK#s|6VWjQG&y;mvC!(!Vp@ZaGAqL&*~ +z`eWrw=>@q`5tsTX$v($|K|)5L2#>iz-!XO=bFoSb8uh6|FqaKhDHx^kwq8}-oSG&f +zW$%fV;=BIbqmVa$cAgA9zqMX8m&H10+r~HC)&BuN~X_18;x|$f&$SwMRpSyuMYX@f*#uZ +z@b=Zgn;k7`xEWhubMl<|$SzQik4sy{ +znfEU4(dquYAt5S7Q*;ryvSzOJp9Q`(V`AZdIYKL)y_qE6v@rqF!2Di3g7zK_9njg< +z$P}uOY}6+iBkv{g=UI1@3rR?D324-MUpw`gl7v|Wt*L7~lw=Y=yv<4y1B+kXlMZea +z;jH2iK6sHxQv0)T?p3b=RY0p*=`F5TsM9U*zvtP?YqC0jR6!Q~_^s!pS$cL`{Z^Q)gfF>x0C>V&>vWBKJ7!_* +zu^i$t|JFmqtLr;E1bUD=^|6|;*-{v- +zvXVkg-|ztKCn?I1r~;w9TOF9_ZbjU&{qDuWp<*X+h)21$hF(pgxeaEmVH8aEO$$&h +z?h??|ecPmq3^OEp`XKRYVPV5_XTojtqIL9cdN9o{_uSW6^3yOZyHBL9u6>2W3wWR7 +zCfVU6SpO(Rpt052eHX)}StiZe3Dn)Gy%6|tO)(pFumA#kma?ylJzYxfmyTZ_qC +zC`><12*KnDCpN1d;W>u({{_=00PnSSf$T}EQ=1>&1m5Q{z_k-9 +zq@oZ$`|h2{U?XXZ4Y$!~l%O#U!+isXqdd_|=!ts``2P2wj9>i**)uK82d_Kbq3CH= +zjugJ+q +zW1YiEN|R_#ktl1#NZvn58*7tz4BVtVGG@TMB!)C20&|U9mxG_Zbp%} +z3qq%zD`J?@u7xM-FY)#W$*~!!c!9A>5<(x?}I +zf*bLf7-}(WVR{?U7Tm3K(7*GHD!i} +zgF{Tz;k}#Dr;|57s44Ga)Xg}pEj1;OVN@@ +z8*FI7R)h1OSVp>s-|%HfQ+Y=eF%|UK$l;>@3cU!%CsPG0v0DbZQPS9PGaiSgW}npcsDb%nSVO@O08X=qB<+z^WEu +zGjBVO>_b~Q=COU0?-&lQ0Xm)wCXI;1Zl(pX@3kp;W9mq=nI9 +zT$#)PZr&#diCV~HnzuGIsw#v9ef$#v5p?fUqk^6&6Cf1r2oQ~^FL%?A|Ddz9V@PWt +zbkaR{!m)HCm7_RbWJ{dk?xd^zH$~2M{ERTYIJg6ETL{Hdd5fAws&K`bBwVO^8Lxr5~<;0f}e`0@R+tTbu(G +z(uDI?PRau^Ot_7-4u}T%Z>n$VqoscB-?OU3hcujgKG2I4!f~oG%rc`3v9{xi6`%*A +z-n3q2hvr$15?lS<=0-o9JcKq7Ch=dOA>a)lu6XPBtumALW4Afq)RAPVZd +zp0Oeq)BYbILp1B}mRm}EJ9_bS4m`bLP3J3H7$uNu>NO-0uWTE4f;5~Eu`f9+?oyxL +z`lWw5%k6W{?*N3od|ATfJ8$6Mm~0O{4G?@^gIC#r&l4$s9Cns7r+zxO$J!TV +z`MgdajE8xp`O&DrUS(Yo6oPe*sd<2RaX1o#zfP%G-hI&J&4Sa2CM@0~)iK>i`a@WA +zEF@e@=um^7>T9;aF<){aD=fM_ihE0jAM3k$`i^;A1xTued^G!xXq)%IFwNLjmXK$Z +z?)4V2OiPR>0jDT0y2TY9HaT~1o6*(}rTly^N&E;A5wzBpZ#aoi-omN={g)!yQy37o +zZxu#y4XHjs6ajh1=~Sa!T|tt&iS!PkDo-XqM<})qop<-oR^?4 +z|M@Pr`9Oauw^<<$WbvtjS+o8Uo?Q{Qq6n@eEghsnlHhjI$$c@*M~>7P!Zv(A^@Iz_ +zv{}PRkgo@Yzn)S`QPvyjtzw?+YG@tFXufOW)8qMF-is#s_SsiDO-@D^3dL^B*}rq| +zh)*G=rHrroU3H^OstEq?Mi=|B(M?;sE(K&jmZ2!pFmb1wOf6+(54~D;Cxub4Jx5Dh +z8Fz1qTVOg0=sU!wn|pbV5a`K2R45sK-~|KScd$FXZW>z0uLhAY;%pBA7~*>kim4M* +ze!UODfJ`aAh+fBVuQn-it7>sCZEDMtfG +zx!MjCdAc-e6^(n^wyv_IZkMaYr>G_l4>Dl^}5alGV?C!%F}x5tlk)L+ypTy2RVC>}@bWWLL_5WuLWrEp^3V +zlYq0T8(@vdq!Gw_mm+cV%UO8{%lU<9b$r!-<_XzMoBxBk-HX*;hy24pi!Ml#y=&kfbkS{hiU7%0QKN%E)$4kX>*QI; +zZ$o?|A3+ZC8%J6C;lS??9YnsAvFtsY{a|%x4l(S?Q-T9yLm*5WZde!S;=7aa%$Jge +zVna(+H)tByILG2AekICqZJP+vd|h8?_Q6LGJTWaLa#gxIpWAk;>@V#XGH-liiP$85i3SY7xjmlH +z`GSdf~W1vJ9 +zeDcCRpvTmG8j-!zWqK7&%vgkeXs>_Y395tIR?&144d{MDuH76HD5&nBVa1foZcxq1 +zX_SUoCH1}ci0KDvyCh`Nrq%}&G}y$c<1myRNd#d;?pkSx+C4E{k9>;77S1O$kB!oa +z;b+u)tu+ht=3^9?u;U_4pUxCt<=^=0#L>9DE8F=vnbA_1nmcTaRbC +z&++*XYrHvHioz`z<@kllD_|9* +z&+D_>m_d;y-d}aFBCjuu_utr4!NrGLT +zd!O>&fCG$ibyP!HH+vDH*3$DV(sLib3|JUHr4j#Nfnh9H{q4-*g^=3M<`}=&QAFs=W&~bu`c)+$x<(7f(zf_MAljf*k3Dv +zzf*@q@r3h@QbmVJ+xW1Yi)Vn{W1!>S=!7wHp~RDkTPs~|2LGQbgW;;a$7kq%o$F4kTKMTmQjmjY?iXJG= +zW2_BIGIf;ALH(HlgH8>Qvu~B8T3hLA0h(v`lAc)Vl>y;zC3DVvkyKvWx1HTL4T&l)_z5df`= +z#;CR{Ivp_Z>t~aX2-<^lfRG~Q<|uPJSE`gd_q~-*AVR=8$XVkazC4Bwzwux1VmidV +zgx?cs_ek7!H2ZS)r3(KF4(k1~e?jV#C$)+4-dV9Ri^LFO-z2~m$Ek;mc02c1={Y=)jp0j3wn_8B>ZPS_GZy>+NZ7MK;c>a +zN{uI{?AjgTuRH6;6$p`crR3yp6|}%Gh43r?+@rr-y4MI&@8)c6=Z{Kx&ht2{vqMlg +zF9~QML7p0u;E23zk){)vjsUESy|tttwfNDK_LJoGOxAg>4t5%3+U4&*<5Pchs(LMF +zy75%KW4qd`I!uZQc;6_TThF{N;iX>P62xM4QUI{<{*_06W3qXrKnSlQ+@;cz^h`P2 +zB|6O)eY2uT-OMY*BZtMo@wqSh4~w$Yc2E>%2F|i(Pxk&)uAWhEk>w|M?`lF4J++te +z?04dt0;jZ9%ImE~PkYAxkTqErkgDodW8{}(aW~fEn50!SP6Q_2dTD>#t@8v$4J6?a +zG+;zrG3tH7w=E1h)QB6HRh>FMHtWE6R=Mr9lEcCO=4Az)Gc0 +zQl}e&6~MmfAapY>V!7Zn36ERjVTXp&`Dzad)fNxoZv-)=*1f9V_M^|%D7cGM4+qQt;U?JwrS{Fzd(plNl_%f$7(?hH?rOv- +zD!6FOZR*LJ&pkRnWwg2cX1F;qJ8fs+%ML|fL`Kz%h(1|6lHvH0q3a8&g|dYNJQ0q- +zmlJKJbNMeX8ozgX-x_H3h0rVt)a5*?AQGzMgoh0u2_~+v@KYNXe30Dwd768DQGeCz&jfM~Ljj6zozm!}`V_$D1^w*ie|# +zYk*Bj(t@L_Y7Ti%-@WVMDQ$h4Y1WSEk>W;}?NCic`h$>ZL30 +zN;u1>ci~mS>M;afBSC<%BAkqQM*?*72~%DccC4)B^bd*+#Ex*8&&niizh#v?Ipz#1 +zFbUI#NeI(}iAhoq*h@wFh;eDdN=t=`O<%rLnsq*Q&I^Q1vE +z^*^b;s!6mf@H8#x=N~cAG4bK!h-7;@XUGZ#ZoL$0E+@PBs-`w|WxDn||@VziMxh5tRa +zT%;3Gs6*Vh6AUJPmeARVI@)m*jLUW3V*6fk49-fI9mEDgS6n-;=E_}#ET2V3kvi9L +z(gEMlDc-|afv(s0FK)OuQ7GlJev_cSXj*`?5M7T?sLyQ$a~XWm=k^dE1>EXWd5&V} +zEZwHiIHaRcA) +zn(V*KlxOq291wp>j*l0wS7HeB=~gCJ5gW9a_?lEA$8R+x)4DFtT6eUsKWH$yER1Z6 +zDoBEYVDBGjXrrVwYiINH&nexn-<>^(K>9ihWY!;a%UTSj^LWO`iFosz<>z0&IF`#g +zB$CISx;}vzZZ)mAZu*Zc8w&d^O&oz4;2pj@LC0+_^D)on$sIV{SLVs%R1Z^(L^%#| +zU)Pl^4FU6y8-e~EPA-PGm+u8J(n=fp#L$v=on4T3LRL9kRBMCC`;Wf67uIRFS1oBs +z4l4;TeGWjt-@7;+74x6qYX|w)PxOy%IZq|D=Z#R9cd}yHxDnOr8&vj*@NlgM)Re?- +z2E8=Xc`3>vCczf&@i8o3jGE+5!*5^;a+_9t{_C^$*Wzn +zZ|H~E@#TIZVpDVCcZtO+u`-I5=F0Cj_&oh3>H$4EXsWmkZqVtr`7d7 +zN4m4F?Aqk@7774GB%Z@DB<@4|QHk*v6ho}QY5;0g3UD99fK-X?>D6OEy0grXyr?^> +z7YkjA@MfrD()&J{_vrde#L&vLk8N3e@st7wN%7~;CU^Lw8`cEe+R0zG +z<7Q#cz1DEl_2QePYLs}{55v=AN@T@;M_(tB%_?B!>>*2&1{W~{;|{uZRz+CMli1{q +z?@}21?CeE*zx4~w_LqtWnF0_|2?s`R*TF%7(R3!rEfD>P7)Fl8E&jslJPGF;&syr7 +zy2iY&y_;NyBPw3N6^!Fj6xB<+J7~6^HFizG6FsZ0H__Rx>Q#PfD$MZ24wa32x;i@mzu~A!1hG%%Kq>pf92u&`^LIfh=Jf7{GmhtF^bU252*QuV8=a+?_ +z+c|fAO-$~wynq2u4n@t2BGNx!ivFRY<13G_&U$Gq(LAbHh1K07{fmG= +zZ5TzcHTC*DK%;j@=CB}jCwMug$`dgX +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 +zqp)$-dXQ|m2Z}Av#JreG2VG9+uoo>Am0)j>D +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 +zCl*uQYWLm}qKWQ1&$rynpeo|Ea* +za!@*E+Qsyi@yuagr6aE+R|$zlh)HM;a^!Dk#gp;->N#y3qcEKFB@_t_2;P?fI +zbR)CqU8wWBo}BBH*3NI?&#5Sr|@kNpD0h#5x; +z__)&0x?x&avZ1FbiDgq-jmjiikR +zzHivPlbM~=TwUg}k}25^@UFTUOkRlbJ5+}6i>|vm@6}l-wSP5fE{p()iO-D6MR52^ +znKbjtuqw6VL1U)B>3Kc~95Y~m2ZXacQCe`9%e22xO^SQIUUuEdX92*e%j=_7kG2qWM>$S`Y5gM&K?6y7-@9;HlXCm(F)ckv +ztkw_l-r|iZ83P$e@$0OhpOF?rm|5MQGr}@Wx09H$-+Mnd`|Cl@w6gk;$;pboBWkyVtt%I{&;N--rj<*bH@k{^`*_lwrZ8L>ZfT^|(3ED8cd +zbZUP*tVsrfX8nsRu019j%B)3%nt%`Plo+CIJL2i!>|p^^yhO6Yu(RVGIYioY#MAAY +zFo-QW5$^;wy$em&qmCI2gw7d5Iyb&#ajdqUTQ&8R9k4<4*LaS;gaDiqXRj97Tz3ov=~?mRkQv0oncmt3UE@AT)W(3;3JvT|kNMB1?- +zqEVR6`W_IYxQ8p&5n7N4?mHdc@S?E5BU1RhSUfg{JU&PJC!3ftcgfRa6bq8xYNpLV +z<~$Zhvp#M<*Z0(WEQ?8!tzP9fQGK}apOht2B&&acy8ZJik8Mw~SlF{)IRsEgA;v~+ +zUGzi-UAf<$3wdA%AbBdnv`TMHgJM!*nH7CwHL(^og1|MY-QOdkB$s@ +zokF_zmL#CiG`Db>Jnl?YCb2$kZ!FWgKMYT$h8@HAFX2d5p^R;h8H<>VeoImHu8nJi +zTdYM8eUS2b|H#$XhH>(VFKJzcg!?$5K0`cpfyJxfRX4sOd^?_Feb<_}M-*BS# +z_qf?Q{gUwQ_%sPwrf)gFm=&O>y`7?}*-lgIr|>C6%VU`{S&^`mV&2^dS1svHDjS-P +z;wS85nE~dTQLbKQDlL2|ZS*=gO8t!ZW?FJ$!N&G_|2yiWIPo^cR)N$|z5aZAfH&Bh0RpUN{ +zsb&%p7?&QE?IEv}WDr#XQi>Hyc*X&Z{pRUe?ppLNFgPoyJvc_84PxP#hRT-gRKppU +zW2+$6k6R+ +zA{N?3Y5Fw#T3yv$z_>c>c^wZH&-iC_-v@gv$S)^b0Quk`(l|8!j;UCCoIk8;lUayMWM?M~NqQ4mKxeV*33M^$gkRz@iJ`Vg*X +zDdcc#AeqIU)uG&c3D({iJzc77Lm%=1T~9(9>StiXmLZ}qJ%Gl?{6UtE@p?_Z&CnNh +z5x}83k4 +zQvXU%UT^RXY=`4fRoz45`V2oSvKQ#IeRSdoilXO|)9dDa=(P7Sup5_`q>rtr9DDJh +zhOvYeDqe3lV8)FVbw}pV^=IZKyl=Ju*y=rNR*$oxK${l7t +z?NG^AcoyuqhwF488oh^h=nhsB0&X|X3*b%epZ(d`FIQHH9oyx2Qvz-{EQ+=++v2Ef +zghRrfjT8a0JeK8@(GKW{9Nz4Sb@kn#azS?!GdCc_Bt!Dm;Y`dak)p$)0*S?7{wTd4 +z$=}mu2NZ}Zrjh+v9MnBuiEM(mJt;L7@y-E0;8V_vHXw@JJJ0Skldo(K#}9FD@UkEu +zjPFso?tUJWAdjIm?MW&b*}1K3{l%&+C1IDV`-^m`lG@!)Z>_B=*r}h?luNSvh;kCF +z6M5Eg(IydI`>@tt&jGo7xQjY&<=^nUjwp6Wt|v6Fc!)0qK6LpE-8PP#zWVS@tf{_! +zM_^98Gw--ZTBCh?ht3DyMInER>;hUF!beY6-`?KnGrO!@jqduX{dG&eD|#Jp$L=!i +zv{HN`s#%Fm`jXAQ@2std|G{&7Ixb1rKHyN7+^4UQzcQJ}eK84+kh?u(Z##?}dSq=a +z4zp)%e|DNOky_cr41W2>`c*9`1;aO@Pu!qM?sv-Y*`=5zrOPMsv8|mZ*P?qTF`3N@ +zmrpo<=q|qL69wHa;Zd`90aGgP!TOC8r|%-ZI#S>K-Jh>qW(Nv1apnByJF^{Yevg=? +zsWG~Y%UM5Swv_~kR!&vpnK2{5Nc%oC7%+ZK!9ssB06~}gW~&Cso$(WObmC5y4AatR +zLp^3KP2uGuu4_0$OK=wTz8U*WV!}f4awsCEht!$(P;d4bTm25p`j5#^x$DG|Gc6Wr +zQP*gk1a)Rq)_k?!jTm!NSw9-1(mz()5!F`d3WoV|tla_)H)-VS +z5s4x}Vo)z|3j_#;wL_36w|bhKA091@`%4?Dxq?a-TLoPs#FMVH%3QyzcWn(zyax6@ +z%l4U3k<|@!Nsak#>++s+Z>|(#*mmJ`U0DTsG(LJ^iz@j#f<= +zy|ogLEW#_Z`jaDydPC+%8_;5nz&AKi_$%jzL9K9qd5v9t8V_Dc>{FMaE~937A7iFe +zR->vdPIO6XtXjhN2L9mqfVYDe7*8T3A~6jbRz1rf-lP7_O|9?g^f{`06)`q8MMp7o +z=XnP*1^LZFyObeizd{4iL>cbGq0ykCeq=**U(X7V{q7)e-ar}t;=N-?pylY*GD-Dj +z@sI<{IVxqPwJXt-_=t&MZI;7xQFki^}W^~ +zebroddAcQ_D2j|5veBNo>g*_tM55nn%xQIig=WO;P6f{)S*-^i6jhJ4oGFY5AmLC* +zRi?WX+i2@xcXk?s<9hBY_`Ka8SQuFYv-gm1terX1Te9VmR}^*DAEmH5zkWrh^YqZc +z!JLh{tF6ja#L+14+S{GVpXxqi>Fzj6bG|mi)}g!Z{vobO?5-;N$nAM48y?(;&0_b} +zKl<|g!@k?kJt3vaeR9aCb@}|LgT6&HzEs*|TF}B#{i0x%KPp~)cYRbe(o=O+mP=b` +z#v2-z|Is2-9&2n9Y(>}j7iQmk +z7pSLeQwz3eqx$caK(SadDijZLOJ);xy~s~0&sBTN#y)Y?t<>;+82t3R +z1}k>_MiS4pmUQ8|+Zzi`EFvR$qa0It(RgZ_*-4+Vz^0N> +zV>d2odDRbVZ@DF&XgGsDDMlR|m^%>2WVyU{$}kCZcLqr$RWGhU$yf6ftrxe*;CeH^8fJ*K}{cGlU4MlEx +zMr@0xoSbeqRcWFTT|4}p6BjQxovPdW-G;oL@+BNXx}9fdN_(-_Yq6ix`?reQ?jyM{qi|IVTkdm +z%)+w~VEoQ;O?bF?ImH3o2gmK(tK5zy +z?HKg)a7C@5IbTd$ +zJNv5LBF-w)DMOv(da-$-Q)VEDAUbL-`)(-BGFL}2LU(yV5KQNFnpfG;CAVbjvpO_q +zkjha96FNFRTowYDCd<7ktLmyLse=`cdWfha$>b?Q+mhwiJf>}Rw97lG72RNVTh7I^ +z?a_9Cj?=_@m=h|?15~_gsbx5-TJz~SHlpGi!P&b`Ml{SoV<-k~?Q+#IoR8b)5{)uCcfL!TZ&ei?nFZ+ +zCR|+4ZT{pd4C)(;U{0Ocj#g(vizUe?&$EUtEz&!MBx}Z?WICd3LaR+3bL@lUTL>F7lwfNVkpgRvuRWD`8rLp3 +zHR0XXIM>iRQxb03o_eJJ(8vePn1cj-gs!E$#Mq}`Y?FX0qePR0RjuaHd}&fPN{Z5`V49u#5FP$78^Z%yNeP> +zL?=^X?I3Zk8>>KW;%&2nPS;$YoEj?5t;XJnl)9-FNYHYAi$2i}S!AQejQai^j?=Ie +zxEQOz;rccB^A(1n(AVaM9;*-ey3`n0ZBR5ty5UUvSJWAMfj0A6P&r>phko^_mAY`1 +z8dqoHU*OX(gHOYxY4eT`dSZRiBX!4}oheKE?JyI$s_H5P-<7QF#x0o$G99``$!>gj +z_(xNw|7eQ%tcOF~?Ec?A*!Z!3hcZ3=>$WyF#U7K18~}AX>W+VBV3B6>$y-CKc0B+Q +z&o7_PTuf#kz<`e0P8&epc|jsv;s4>l|MEEprT1!|9(;jR-Xt}nR7U5)G^}TvL>wEJ^Lv+jTtD{tgP~%!?8Y+M2;gT019;BKW0rXje +zj3yuZ)+c?h91acy4h$}|TpBLjO6adOUk36f-rhG1fa{#^tk#0ps>~;6g<`aqqXKXK +zEUcB9FU*J?u>l+gYim&`g2&@2pI?nxj%_cDfc2>#~U);=IC$#M%Yq1;Y)zQK7;U$P_WB +zu@Zn6>9h~o?(Z@Iix6CPWD~4;4$Lv=Xdm{S_+_m*-?bGTxSB0xTx(SU&L2&Dnm%S{ +zw2%FBGGC{1<-N*s{Z=3sGq>FCdSFd=cXn`F6DTf5U*pCZRwAdxr@(UY*w%boCyl>kYLmLs4yWG +zeobVV9CK+CwSSwbk#;0)!of7R3L;{PS5>?Ym`;=wO-(`5aklG6lIDG*@B6|zoO`TQ +zfX$kbmjGX2N?(_4rq^6`sj?EF{MzeT^?5@A#N}M;IwtscQS~Wxl)KQO0mT6wp+cc{ +z{eq>-q#EW^nveyCn94cVtilhCqx(N-?YE+DZRDGrS`TqtsiZ@3kSQrwD74N*?#S+6 +zEiyp=ch0}|9Pi{zL!J{%P*5;h#Wcidqz2$rV~!H*ZT_a0Sn-x89Q)+?lB&1gL)}tY +zJ?KnO87#IL!Pn-X*!k&(gt~*1H1*7NLh#37gnLj?J+WBBtM6~$eRx@FPii>?jl8@` +zX-`pHNioUG*@;{g40lPa>G!sw?ug3CaPhtOytI4o2bq5p`pKAnaZJZ#+w~{^=gsB( +z5KQ`j&_1`xg7v+N4dY6YqPD>Ad?iNook6*Qq_VrY%if_$FC<3p#l3^+vHw{3$hwM}26(mvQ+19bsBQs83@By~1vD*Q9BO2e^oNaZ}nIU5&3fo#}sArEZsKaJv+>%B+|mPewHCFHx->fwyz +z-R!Fdyt_x0pKjwL0LlCPrE!<;xtb|bDS>O%e=Fm@YyJXDZ*-b8={BXWW@nf{snUFP +zrWS+5-Ssq+-{8)$aLnpEu(5O5gFIRxW}%~^e8>7|-(Jwt=E~A0wQiOpJwiOS%xS>T +z4r#y!v$uP6dF|eB(!WU5C@N#~P?VoXCgIK2&bSaM?q$c;RURB2UC_)W-lk}th0hym +zxzb%r&#AiK%48neu2m?_f@eF}PVbVb49f(GRAz;eue@*&_vYjGpS05n(xJlx&2=Dj +zhGO`>3 +ztA&knBZXOYYkyz(OJyJEElwkVhcinDq#x#;;}g!)`<)N+ZBeC3$T=#EX_;JbtaF3FLs1>e`P@l1w~!eEq3I57%_A=k6O=8$}XU?)4VkW^ab%Qh$E1 +z_y^zOnmm0`Skh3q+1BJ~p4{KdZcuLe=dqYvP)l0YO&3tb%RUD?dZiHAz_sFl8?{GX +zJQG>Aac{~)2OvA`B#*(0q*F8Y)(KtI)>WTI+cLm0(UqokKPW9uAVQnr+CqzIaZOVx +zEBNmA1)Wm#V!@1vjCcqzSMmm23LR2)mUY89%#-f9O<M^X!a>#74#;+3?c@=w%T4HY>jG#P +zK;rm+1;FkEjqDUX(zduay8#)5olyL~6CQ!SNwRy*FIKDR>lM@2UxKFzgU6}t)WMq{ +z^*19tN4bxFlfIB{!D{C7u_e9cCI4#u6~5s_15ji)5!ncjGk$$m(W6Yy!JQSW;LD5A +zOiayEW5zQ;qfDh*&DI&=b6$~M4;JfVDuU-vzl9c~`?-CKtbK1g#SuN6qwPH5a||&5 +zzFq>Tnd%M`iPu#d?6_PH16e}Q_Mk)9Zz$Nj4@rT8VM|)v&SU-*biuE{Hd@x$3 +zB;bf-!Rz!$=`F!wN$O`23^sBIYZ;~Mxi+b#7^~@@!M&S5^DFwft`_F{C&8BpC&&XA +z?-l*0eh*Cgm;s>|F{IRAaA+~!8VNazOunNw5{Sg)@(ngpO*jX96RZ-!;uFrv2U+>CPo#|YS6EIE=G&id6hcR?IG8F`_wg-gRB#X +zFY=N`D-jvO<(AA6gAc=Ul4f?zx#l(^cIn+D>ebG>KIoG%fjiaaZM^|YA4??GzYzIc +zj@v0glcHuU$SM!$&S?&E$SI0+yc{b)E4nTDI5@`gBX);LoyqHzOUFNk(I+ICk-4vR +zd{Su-llmsCp?$ +zQ&>%$()IsNX%or=x?64`)%Ax9CZO8tFJ_ATdMySb^z*F+k +z{mO7D+5ZLlF#iGi*cYxYAM-^R9*8>)8m+6dC1yO$ZluqMm&+8;^S6)BPTFH9@xTsI +z)Ew;UnG&5lm_s&Suo2jV86o?L(e0>2EbH!I42EDhbi<<0#~)Fv&3%eXOx6G1ql5;U6)Iq*N;w<`?Ez +zAN2BkN^>w|51sjdn(%xIV7t`v@wiWsOf{)KbzvG(s!Bzw7wGQ;)F_!VhIx`L-RGna*=k0{lK`u1NK1=`Jbc8P*jo@|6gH{Dvq`4jRDeb9@6aFTf{SQ+hG-+fJ8;7yy|R +z;8>sX14qFw+4cn22a)hbNZ;=!JE=9Np;w9gN;^8x?Y#Y306)KezxvQdPiKd7XUCHC +zN&4?pEhM}3=zfg8Sh+bBXu}-12D(1Ce{37(okCQ2w4arJk)FMLXT<_*IBFbN$@qJB +zecDxeaSVWYD~X?M2}MHTrfx%P4;!F)54GYhZGf=g3F6cX;bD_{b=7Hk>oK}i#NN@G +zv{OXuZTZ`k&rkeuwq2V)Lw4r5j%eu;LQOJu>EDYJ0TzW;>f~Pt6Zl4MPuI3?fu?&x +zygb+I;bzrp+jJB==tly7v7l)dhu41nj>-=0ZrHmU?*dyE);)OL?yTyZZ#Qg%Hm!=z +zn>JjZhWwTRvpXJN0``pV +z-nXS}0*74_Oa(aa_|W($iT%{4IhA96sm5Nr4}RY0NO8G;wqgG!>1E@qU?yz+R4&qF +z=IRoIpqRS%M{oRy7%9U}x%DW|%y%9v+2rR8BWF$j+7zAnNLMIkDQH1s4f|vQgWjd9 +zg5;`Y&u{=zu9_gH)}sA~dS?A^4OT_fs>YS!IX>4xrJ#m~g1)BME@5EQV1T*YYK-5g +z#X+1&Uhs|tL7~tj_Z+%Um1n3ce)d)qX*$dK;|82CVa;8zxW}DJUlM<6A~99*uc%iE +zwf(0r-Q%TLRXCl1d6fdo{dvh+0ye+rXs`*c1J&R02W_-jlwy@vDs$jR#FbdG@jP3j +z$pD7&akOMg(6z{|5LciwK_ +zEgSL4riz75Z*{1g6#uXP7Q5e7NmexMMY%38Xxe_5tIdyAk?9#S^ZHsJtjPkPHZ_X; +zAqSQlG*x+y@Q#3$8&d{ab_`F=UoGb++590!m}}g|E0Hc7vw#>s4~s*mva0sp1^H8oBKb<|4v;QfLWWH7RWV67@ojYnWL;3JcVN4S=YbRxcWDRiGTp-E=qH8 +zn2K8$io;$if+}u<7jdm!zWtvv6y+n#Ii}c8m=AUpKZm`tYe(s&lDs+Ra)yz6+6@vD +zHW|)6w_}UwtEpB_+TrH1uPvk2d+-U$u&S*>uZERpa{5g=T$_)WT-M(eVw^eEvwkO; +zRI^}uV~f*@X!x4^e@vYwk(!4;sTFk?2n1lxQSWj!!gl3$)8bW|(6Ryw6^>|ZenJwe +zukU`a&C!l%{a%sfBh%ND)=7Vxhe4dZP=9AnjeAm#fDAz`HL1NEXW#r8#Kpk2UGCYr +zUcTIw4yA1s4P#ptw`!g42@n<bc|rE2J|moCE1eOJHFi7hm=z?TD7AG%Ti8;u&!oC5fA +zQ77>YokyiL@3>_2coNMefV8sxHqufWu%NqCJ@26PuuS3jTg+pS;{M}*%@GuxdK7{Y +z-ICJz!;+#a6$ACWZFhuc4Oh^5Cd*UDD=xwIE?t_4WF4H7nR^DtZxweSD-=p41zIfn*JxWEw=Kj|6&EY3YaUBg}Qh{x$4D8zN +z!_<9Wp>*u%cl&3d*u&9wgHfJoi^yg){)x>WC^Z-N)-tswWy2Ab +z-oE}AFGAD>ywDS7mbPY(DWDwuenn`;cF88Zi#8Ha#u2 +z?rO15BVgh{2};=Ea4$vqN8-1}XWj46xHuK5r%5jV5|M=kEI4bM_UCfN-iMCX@?w_h +zt8SVC+Qa-Piwq|8`dj+Hy%6x%F+7VI`qsz&rS#Cq{%tV_W#Sw3zjy)wp|8XO0>1^8 +ze2q3bbg-Z3;?E87$RYntOO1;gi3GuVVmdkN9-S*NM6*GCcW1eSM4{S!J%OSKkq-85 +zr?a2lnZ8#fO`SWPBTH?2p@EO*88GLnZ`~B_dhH*jX27Bu@==RKclN)7+qwh`aB6Q>0uFG@>R>3wfcnm6U +zy61>7Kv_koILX>99V|jE&$N+Qqn+~tH+Jcn*xtHxb}ie%iyAtjLxO?&z~w%3ylf=2 +zVqBJjDX;G8zyXdFlbm|&sW5USi1ciJlzH5 +zpXamGkFXVJiTNO4yRi)?mNRNg3DpK>9~M9Afg1#^w}35(1*zq;`#EA^!>STsCtmg} +zhoW!iz+2L#3Y9fz{|s2%)?Tdfe58GHSzNQVrS8E(H(yfPbxqiPL#?B#N(_Dk*W)Wf +zx=K);DqP>~aa%S)u{4?**-C*Qqs_-*3{)yh{Rxc>VoOUc?gwyF9SZLXd!?(xv*W(` +z6C3+{!Jy9LEb)hR4{2V`v`jf4LvcUY?3(rCB^zGBzHYH)>u3PSQFsoptDSqq0sql$ +zmbHCu*n=|DziNB#)FoC48N&9Y@E?RJWTy{XPJ4c9tO^jNe=aX*`ujGd-kqKOi($dX +zGtc}1Ir?al9?y%m>r*TH#$mzae1=gx&!5q`Pp*Z{lh2$KleYb$Tb|d5nb$NEpW(1_ +za_J_!_6n$SqT}EWuLG8OR+lmRp17DM2|M^+#u^RKb7hJ6X-=RKl(Uf`tkAYpY$;xf0RC4O=rcau8lkDMTi-dhgsR)K4Gv +zR-}-L*t7wRusYaM{a?yEkNvwlTCe*WRMl@Qx|r{*9}h&f{~Q( +z7}r$V4(7cm+GfbolTTQ+)Y_QveG@RDsHKVous^NLrI9BX^kj1Kkc~`Q$KMjz<#y-+ +zdM3FB(*7KU9O}1!{`T}xv!L|JI&xQ-bOW0;GLwL1@{SSA6dxOr@p#{>og}H%gE9Q*NzW=pESsO+!pkC=X5l$yq-s8tsTM +z`Cn41XNI1uiw!e(AkJM_X||)33qmY@_F#TA(%M#rz{R+;{Lkq10JKBcXG+*@HvKuS +zMa^psq|d?iRyle%WmeOR|4FmkI%pAk7OK>+I%!4r!3k>W_elLSZos{t`+gHQHw#92 +zy|a}QEM>-twq8hrH2{2b;$n(+rG$;2K?xjl98c#j&IIq9?MapGU_|wrGoDSGl)S#b +z`US3!oBwzbe_i+3s~zkpu74-8B1&v=2`%%ja7>)Jvgkb4Z@X-J&hWBfQl#nX(E|#J +zFhMsQ%-oM=)8KFpWTL?2U?={^MexxgY2lB{jrSuB4VmdOjaTW<4!i^Jmdl+B(oR1@ +z=TGR2PmMbDXEfSDs+2MoMru8c#r=4JyU8;x@oXZlc108zR +zomXR=J%H&?M=t-nBknMc1h{1IMj4{e2HaRp`u-A@E@p(VEFLs&00Lax49UQRyP0VZpuTn{)m@r%!kC4*l60f5wNsKs;2EiP +zqz+_uQ8XHRXuioJ_V?Az(}Ovd-Z!i9tun-bh`C*6QEjq&-Z_;(iNwcZ7bA++&wZ!L{OVMeeInuuv9$%1Z=9Nam}RFi +zzfs3Er8m}DqdWHQqlafxbp%rvDK>bJHc+`R!6rf%101o9eb7~clM>y%KKMM-t?fxa +zRt{g=u&6b45sLCw$+bY@X)(00hH2eYSmt8v`PhFbSfX;i^Ek|^al%6e^Aelq@GXT*X6@LBSTvaFx7C}vaZ{$FT$*kkK^ +z^hRZt4`OU)eeG%lHzyoAVJwm}ExMZeHLMX~g7^+fMSL9mle}*6(>+gQ9lmBwVCHZ$ +z&rXQTc^eE~Y`Li$@rt1Onnf&gGePbHMPK@x8c&iXw(%*d-wj~YqpCFGh2hL(& +zksP2L?P2jiiTZsC9aO04;XJ#V+a`-X{?+!8rp2f7YtLdW@R?>0OOrar%qJDU%JIAW6xNvbC?3NEN`l;w +z%Gex67 +z^iYh4Ex<}e<}NPJ+l4(g1M#JR@m@~3}6thN7EWt1EsJG^6 +zh%16R^{onhKs$uHcXv##`sMEq%>0Pz30K=VQQpN!C5yN`z#{hm)G4xD@V=ELODyUhpi$tg=JbrA+KZ@u2z=7!3=r_6;0nERf1 +z{Z79Me2_6a_xH@L@uHp6t(4Tn!qb5W!P90phqHJG>CV&pq99GvyL>bAj$c?#4y{Z@KGFW|o3Oa#s8<1{yaXa3;;?idt@ +z<#Dh86g~o-EO^Xb1y#(u4-+^C#UAZHx$q)6UirI6Op%e!ZN7&J9-acX8X1GtjV&&h +zzMb#}xgiIQj3<{e1)FMS-9(SlCmq|d>}s5$M~99$U*uV`?duss9X7a$=fqVNVBK6~Y(3 +z>@bt4zdJ5!eyVl=zxKX?M5 +z=+&-Nu?6vy4RpkCeb!cnj8*(OG4_d)9l$MS +z5R1$HPLqJmb1gBCPa!It`mRYWUTf$@Rl3w&R&CeOF0V!Ty0YhqDq!(#{CY^jS@beQ +z{DPMJ!m&b17|*$En)>k)mB%}>{JA&bIGowPP+T5eHvP8B8`Z*!B?eCg3AnUILxc45 +zYJ%*aDL`1UVIPE-gEI_09ue$6cu~!j@;u8iP#|Ps&BR@oQ|apN5A_X(a3X5lI* +zK9%F~RF!4;1|Arx!3)>o4U@nn=?YdM`9i^F{M7Fg9>12|BXiN`&U|I}3585;%Z>F{ +zg*zy1-Z$5}8|1@(K_mZa;&J1%7(;{3|E{8s{<*QjBU;A(o*3uO68n9$|Qp|%A8U_27Oh$?HcK?wP +zX#r`X(ELiM{&HY*rCH_e9XWCW-I)h#MNHk8PcFhg>uZ*IKi~W)Dq1+(BeO0u-#SCp +z`s?7(nAC018dC*Nxio`Hf+$#a?nKFVsF3ANvb9rH9HzC?7g8R2Yu0lTEV(Ew{HLu< +zx=~4NdeJ&qJMZbk>*@-)OCz1?D_lne*Pf3y%|=*Q;Xi4T{R=$uf@E9TN}@2I9hH$V +zNP5i72UNCSNh7j1>t`Cx(AN^%ZPP`I^9!pBmJr%i_Pd+m_jF%GIC1a)nCHN4t#N0M +zBy}qoOqDF`FBfxy=3%RBu&k({tY=;}<$8T6c(%bKZz#diV +zgnh?Wg3)n?S2fE6Zp1B7o1zsfDZl-TU1LMsk{7ciY?K=;JjfX)=4`B|Jv;-y{Bi?~ +zUb%>8*+`$685tw`5?9-HQ`AwBw##1~3}Y)8s!LZuvzcw*tyzCMI2cO)T?PAekDBk* +zlug6Ot6IomOVDaUqq7zudrPLWqi9fqwNQ=y%afZ-A7x`6-sa`@6QW>ve;Nw-b|7s!qDI@9?k^N}Y&nS%5}Nl5`I-*GKquCBY| +ze0D}zbGZSk>(=XRJ8#*ge=Ihn&9k!kk?a7ZKHW@f9-m8Z;yoc#LfAI5m?;^nFqJ8cC`45F#Gy;#3Q1{UbR=!*1KEfQqTh(NI +zF4?aemU=V+e?PcAHi@uz;37|dzaA0Ea2l&f3NVnAx4xa4NfoJ+=cm)%$+pSwDPd|Ss#(Y=qVutOfK +z;$iaG@67ZQ!fIaSf`@cr_3X_XH}W};>U!%Z8(PF3{05ROqk-iUxoi=S;REO-pXU)> +zv=lCG+p1LIhy_~?1`NkdYYap}aTU1}b>Nkj7;z38-qV*TiUL468c324w+ +ze6Z_ZW&1|B$t5z&bNjGyUgWp4IqWFiPD(uGR@NCF5M;hE7~Jrwoyz!uP52*1FqDLX +zc|gujzWTwhG`zpEuPVWa2XmwCDf(YP9XW>lJ=%*vV@2%4!jV&{Sgj^kIx=Hpw6WVq +z0@&r^PLZjSohU7TU!)L+A0xIAZanK7{b%Ul~itbYY*uN+?2 +zC>wp%>t3yNKH;GuwEY)!HV@O>G$5JY3a%_adVbk(S<9t(3{P@6P(;eSpP3<}wf{ym +zBgWNgv(CvC!;Dbf& +z^vXSdgu#o;K@L(VCR5D+Ge92sM+!X;w;BVihBJO<7ZI<-K8Plk{(F5x~M2T +z5&&Gk1d!?@Q{1zi>(2D}(T1Qa#dy${7HmDcmPoeCEZqi(7m>V~&-o%w^rPm2%_-4!-#Ub@?z6t&IH(#Psui}Dx +zuo*r_sVa%a+`fAYSe3qx8YCbAxtCVLb>_eqaL9Zi6n5^1;G(Or;0_pnpD9XrXNM3rawBN8@@CS%e +zVQUs9Gw99|P;0h&sTcK1ixkx+QFsIzkZ}&q%S7;aNrX+Wc5c>Ff87flk@J#}aNs^e +zzzNDq{LQXH+v9Jr>+H`bN2#nmNC4)J>E;WI$lkX*&G*+c>9fJQmC)zZs8*G4%SP~Z +z-o^I221Y>@LCUVal3y^#(s_ZC11%1P5XEnuzsex_*uDkgZQPv^DQ +zTB{AQHT=br)=tOc!5JVo(C;ZD6llEdW#ESX(YagMzY)rwwJs3_`)z(vT?^O#QB(1f +zpvsTyXaDsVl2i5%ep2~!Q|(@%G{X%$&>hiJJn%gAW)ng7LYUDdTeh?+5k=96eulD7 +zsR?na^Ca`1e5HJ1-kYBKZp<`%GzhrR+}^V^aK}ib<5%DGjDDiBS3(pK9>+>o4Uw24 +z>^IMlny0G$n{<&=t3jmSstD6~PvhsXcx~X`=fU^cpeG6X$1f{xVoZCcqB_q9kZMdM +zk&>leS7u;W#z9EUr6+7@n4d58X2q5AtS*LGHI?AmPfZM0$l +z)sEoBu)*U5e4waH*P##XI>I +zKK^w-STR)Cf5d>Y%%B!VN7c>a^sUcE<87dIC#UpOvrs>`c%!x=UnBX2DFaz;QC!~~S`)%ct9d9rr{X}bi{J*D +z^8YKWk3U;5S`48(*T5)2C6#!W^P6E(ztJ+8>--*A&RBsa{!UIZZFHpvINS2mY{%WLIOO4i)lalz9Um&I*L +zmeZ*LxE2quu#D5EG6h-s+xrNE3vqFe*F+x``Z)tjS_m&HB-1t@mF?Vcmj{`7?1)!X +zuUYqEoLyHv*wrra7>(9U_c}0VB48$*-AN0C|J@3KCXeJ@-Yb*Wn{l8suJ9~;uqi&H +z*gX66Nw*6#NqdXbGpQ1g@7*otKH@-G4~+_(*P#AQL9bYbP)JZDUff`r-QwzFKVPHN +z_raGo2zROF6`S0Gf+_T=yf~#YcUyN+E|Lr8P*4% +z9}dM4TeHn|ErdMFQ*$e}lzKMu*IJ6Kz8e3C-8y@NY@D*F%wyoi%;al9nw|s->f9k_ +zAm-cJDuqyHRRCTYQHE9RC;$Dy>`_R5v9kT8k!3!+)30~ERvPy{@HI@oi9Cy_82;2Y +zq5;c*I(}@U{)DRPJ+q;2!qr8^7rE7eTTo4dDJ+6@@k1W9)Hh9ZNkh$_J|BhIM*t*? +z!t09`aYV44rRhu}b-FMTdt81p-4zVY0{O)<1ea4&a|R=+UToS@b*%D}m6b*ud$kOI +zA949W4z=c^YVYj2+9eT;eDV-vsU4#fx)vjUp1z|CbY1K1wff0ENqoU9iYHiz_c+kt +zGlOv`>Gd^78_nR<563=_VAS8PLBHSQ1YT@u93)s=g~{^L9yiayEB +zL?>{;B}#HVe`+P}2L7bVc8dG3(v;f%WJUbwXFT&^Hxp&%`v<<&IkD(8I#ocIDw4i( +z>Mgd3sv2og!ZWSh2zDom1*NRS7-2Fg-1pLbYr1)N#iOys_>WcwEHWp}zJ6kVo3r5& +ziF{#j_Ae%qkMzaKznDlhEW&;?`nWRNK<44-4KP2rA#y=)X%dj+G&C>H8$eb=t=Hj` +z=$M!VC_KKY_@qy7Vg5f75+K_|E9WbC7k-JyfYmhXi{kOh3dFTt0wjDd`+EF-d5$Qq%n1BZP7PG +zGIU)0bU$S%Ri)mA@uS$&&^eZP+MUYZhSV@erkWetv55cObY)*{ctEy&Fx)WTpqv +zS@mnMMz&D*WyXV!lBs@3^tRs&$weuxlt91X{ce||TyXUq;B)G2i8ha&?=ZvX0GK`( +z57I&q%o*$kH$PqA_!;x%utf}(mwDw*i +zA!x6=**J!4o+ZaRxLok;L9sPMzSMwilrHPx691gF6^qKX6|YRH;V;0t$oo^aWU>Bc +zdXki8Q0CRFV{uNu!0Og#C(f3;C*Xd~oYlI~xIaa+Qg_n21<#%SPF?zkVbTuH`D#`sk4A^zy(eXu}((;W8NDbAC%{m`ryd(0Mpn>&7J|>Z1sL5UaCO;T#jFv +zAMtGiUNjz@!WS$2zS+#EmXm*8L$OsSgYg+)6p<@b4Cnj?+iEq1U0z+y$_#5PS{K$T +z{C@c+_}4WtH0G%5mv60W@@m#dS3?XlN&;uZwBEr(NW^~exRj)dNC$XKJvmYzdy<1{ +zn(#Uub_{&Y{<~B}KD;qe^<98nscgeY0haXXSv$D0_XD|60E6HUhna9mYEVYr+{7AP +zzmF}OcJScllj+-r>=B(!3BqXEQj2=W5glWOrd|cR82l9p;A6#HqYLX;DD|unhg*5c +zia3j^(SFgfV0>8oJ0QE-YwSBWnm;AAYbCKBYD`z@Bgwr+EO{qRC88~QCWe!~+rG12A1GdFoSH$VaWsF2g&?v2Q+^N}&x2qOz +zh~0~FMgEN%3A8?{q7}Hzb)VTy-$}2nPj)byoaL+2r3i>wF18O2Fb>8c +ze*k|ns#dv7P4PNQ*V@DREpf&;3;3LzH$k;N<=y_e+hXQ+se!l}JPl_Wq;Hr$f2o== +z^O1|yVEe|{_!jTUlWK)0iI^B81~~QJMnyjrM?5`Q%IgHe8RWioy?&1MGAU1SQ7w*a +zEBMcU~2t6v2dT8y;!hwX?s?YhTC!^s>m3+-?5U(h<@OBfTAk+n8K&x_EAV4j`1A*=zEe +zr#Haa`4B7=u5D9eu(w=7wJfx>9 +zhX3);-w2c!)#AAgff{)kk5v<( +zCZ8`q=TJdR$QS#ID=i~@xqxFe4F?23opO^giWa`wG+O32X4;o*zy;;<4bQ +zx~AvFW%Hz8?XsW5po#e<34_Lj=zc8g6(^!HlTMnDlqMYa;t~r?5yE$TuE`@gGC`I7 +zb3}scU3lq$>Z^+4q$7Gt{|mBqJKQ{jR7*))DszV0;%m0P-x&Uue0shbM*BqcSd2{5 +zmxow-{48-kU2F*(B&~1VpWytt3`?tXTd5k#{T;|)!68)7&`u5r;9@j68UN&&5*AZ$ +zb^6-&8iaE~2@nJq{S6%6D|yA%b-;hc%kv)U6P_#Q{Bz~KR4R7Y*|RiQ2uQKjVs{&4 +z-QR6B2+-I=m{S4Kyr^3w+IIsP=wMeiXFK}`d8#;(!(hI<45>Lc?Q}(KGiV6gVbkv= +z>%Cz|S0BGlJ{P^!SL$oRgkaCX5Sk1h8%exc`Um{(8VG{v7vpbKuDWN;BtykGv(+2w +zbcQSDbgwXYBs@`?9%-7wn-w*d@(66ET2>rH{UjGjyPtTPk$_UFgw)`3nQR(k=YPfnf@0eP8S5G@ +zLaiKw9gy1$$~NNh^K-Go&U<2$ERD{C5sNqXVOc3&iRJTVjn2FcJ3C~W8_r+jnP{J# +z#7=b{2^wY1RoR?DK2kcQEQonDWi77K-5O-RYKzsWNwL##Ty$U11i^~xC|Neln+w%WXVBe@HzV( +zq={hQ4}NM-l_EuAwxKO=*dJ=9@+}L?%U+(w*UFYg{oInc2Z=LcgfuRUU7lMr)cbIb +z<3_4Kbi#82dU*YDn0K)mQ8PVFPnIIXq{gIh8vbr({6K6qd}s(Cuan)3UX0*tPb8uQ +zfMSsje@GghAcgKkxL&8aR+(CgH3VSR>C(>qD&e|DdCKH}HiZ6>o`g8}qWB5D>iW5l +z4CnIWLKI6MCpI@Cbwe}W=yhLv@~t~d1jkLjHhTu#Fuj#Bif|tzgF%cqug=W&`r1>1 +zT8g{q-r5Nvyqp|?)+5cPj8u3b8PimFbZ%-R!nGC~8tBU!iCkA~@5vQ%OU&)I>K+$OTp-&pW28`V4>PfL&U=Ot +z!+jv!$izp}oIQfB{7|U!Ka2m*12Nv-IvRxBk}1nHSom{&DdIYIpL3(?4hUZUlWBYJ +zwq@vn=G?q#SQN`!yBj>}I4OvYig1BxvaU~8W-*y}m4|x-jH{m9`eY;IQeAdjR>9WS +zn?PiIB$Sr-y=J#hJoREVPc{jJ#EYKuF7#gVF!Fq_(x2=m+Tr +zbCCIc8RNq1s2pxYtFPxl){{n`G*}1Ql_g*0{jER*XS`9i?~^6-%)h<4QKmA@_J$jf +zfHW~IT1NU{0+L3Vb)?hZ1~avm(?m&EhE +z?W}*n;1w-7p67-{`I8lFJN105mv&@lg|kHyJWS6!E=a$6$_WkNGvj&qS3cpuZy|p@ +zB2LD-C)+#Y>o11)cOovSfG3f6naXNQg|L$st*6+uxK^LL3y85?(yc@oV?xREQQR0wuq2b1rjp*p~Gv7x^lV&h_i37eiJ{`yv!Cy?`4o<=m;6Vm^Ba~8s>2;+SwcE(j8 +z5mr1)N&Q$fW@czW5tL$K-S62GRa-Klc4y%FagP}%E>}M63yrTv3)swVA|vm~h2f<5 +z8u(hSpd_JawQ4;TkLm90@Jxd#1bj6Y-=_ZP|}=vBYor~}sI2L%)@bC>OQ?tgYVlkK4< +z4oo`OxpqYbUrKD;D2nb#ovxIVLQ}fE2K(Pi*di|D```;}cQKog7z53!9wIN|cvyZV +ziW|n7&Dtna%Y3tIoLF^FK?1gM4ECL$poT)-W`vLXd4tW`z=2_#sPp2Q +zlYqnuRsN?q$SRVQ1}@}!^bI>WGl|>}7gfFC5^EE-*|N;XBfZ$yVv@Jdffp`H9{F-!Z+lp#WK)>xe)Rn^9?K(V(>T +zsy*i`Uio}=$WO02+7`_XLY=$Le?ZjNRlQ^l++P1%2sV*BAJHw>>~!^YD; +z;lQ1?{gy>TQ}@iAmfdBNLP>k|$)mPl*ML>**3R4EUGp^}6tR^Q=K0+Z-yj0>))zaq +zb{Ah=V5Scr5#XFFjS@GnM3;Pg$vVU83#9@E=cHcyjOPk=JyoZZzE2L?u$WEOzWQyeUtKd%<#3;!nuLvq37X0$E!ZO4snPT1R`1d(kuK68W1i6tBIB4! +zWe{;c(OHYGXmIsS58BC^qv+ntt}f_$j8qJmr_Fc?G&_6M?7Jwos(icrMdxZ>enG5d +z<4V^a+y*Zt(N;0OwdQAGpfy7by!Uen`)j|Vxva|5S6B#vLJSa_ZAF1CE=1J92}90`9hFF7@A7xiXW?>itGDLJ;VtIWME{ +z>s+V2v~NbMg%=(!Fh|8F+`YJ?W|OP8%eoIleDkapoS{vwOt9~9qc0q;^SeD31gEkt +zHE2lT{;e+x2lDAe1mpDSXA{C>L=FnhmZ(_3mf7lfD_A%&@RD!^v*9i~GN68U(&`6x +zy3_=&9W|v^nl?si1@My@06R3h^HZILs01vv(Ufy(!SBL|nuT67&?8?P(*88Rpfs~K +zz{>2hZ`J#oTDh)-G`^3O!t2)|-%wajI##ThhJ}GtZ1HRD*2?-x!Zg*K0I~ +za2t6&ihuCK8g<6ni>a_7eP0d-HUqv++3(m6`qVHrF9|AU4giMMnAi{0bO-S~;;bJD +z36zFugNK)`og@P_sk?`OL`a9Y(=oQM^YOz|XI@jy-9fvMh9&^o9+TM&Ux0+9#3Cg8QL!8 +zH-=bIwTphN`tU}LJ3jtRZ1mI5?6+LTA+7QRxzt*?T&-_+ywp@WRO=f$2s0 +z4Of&RQWdy;sVss#2n!v*cL*SINt1tPYXHXF*h+y~yf}_|2}}KLtkr`JLN}JRJJYZ?E9Mw#@$##Jp-Dyp_Z_5&G4| +zPGeXR0V{5U<&9CwN~vz#{3%0EJ9n=6aRc@Z#oNp6x?Sk1jh(;jd+QCt`?BMG;dTAr +zC|^YN$_Py%QNA5rVWg7>FoLCrt}w^$PI`(nm4onO+og;wiL2?=dz(J=4<{p&jO*3a +zz_q)H*lHNn=h_W=e2>#Cb|o`48)@qv%^$&K4DF(pvrEcg8wo2~9BX*Sps5IH#>w;8 +ztMLbg@@KA1#mkHq=12w6EI7uF>Bi7$Tjw~4W{lh)pGj7{>oI6Ke?5|hHrDytTLsDCvg^QvY7ci2EN+hcre +zP^JJLFbivvsc4j!Y*6{*4NdP;OEU@f@ai~5Vi;DQL@70ZNOw&z{3)# +zJ5L=Y12o?Lw8~l#N-oJkKm<=y?I`#j$9xH=HsG=NNW1ri$@k>T6RHgh8X*5^?Eb)^ +ztr{L>W}l?MSn6OZzO8I8qN2}H?t(5kRHU-I@o2KC*S)x_674m8y{9{jjBc#T>AlicI%^0GXEajVj +zoLuOJuv2xMBh7M76?j6M*5i%%9fLY}6H9TP!GmqU@9G0=$#g>U9ssnjL#CX?9iezmZ`*J*cwYp?r11;q*b +z%Rr%XzF{331Ay!@hLWlNL2S=gvSHltYwF6tybAyI;(fcyOZrbq|Bs$!GhF +zxQS3nNx96?&9Dsizj8wb-&!`%|Eo>@OD|(EO5K6%5gsXOTv-b@F5Tw?$Q#Y0v6ySB +z?s{H8{eA52D$gDoZPZ;(d7ND@e#417eY7OLG*f$u6ntnD&plm^EhG&?cH6_zA~Tg` +z_VCAKDU#P?2$YB9$(KWK?`MYr*ISKf6dD!hDU5{-^MM_Lbfm&F|Y +zBj$vY@6ApNTDWiKM_JbUzCJj$T3y_9Lho-_EVGNBcivYrH18`#Vdk2&XiyR>g3Nk~ +z@spc^FY;##Yu3o=)7@{~ob;Nehgr?2)A*Oar<}#vA7pFVXcQkbr~?<>cb!M+T~LSQ +z6=`=xogtgmKwi{4j#?H|A4Mma`9{;Jo%x+!&w=skZXq_oG3=3v;VC?rxGS!Zdw=dQ +z>_lMzT1+ARMg}4yyfpJrl;WS21x)XHF^r_Psb3$2VOzJKLm?=`o-K87_^HuEmIo|W +zGV#Royd>Utqrh#FUfXY)=G)Ce@Y>dBTqd({u^V0dNz;dJ{)zN*XU +z{ke4gcKYA1(B*25X?x?WrlQ?GT@U>t@vNchCl#qHzdaZmq&;}4Zoqr(HOBE{&96*p +z4$ST%gJbV5-A!fQ-kY?!xI%^vZOSEsH+7*!0yZDAo>an6!cK;5g2=VjGch6D&ExnV +zu+bB#+dj7^K9qiO%R=STwc2KZHVzz<56b~+US$}LZ%Y{62oCx$!E>&cgdvHuaosX; +z?b6SwjrhLUxI8;ysq47LzAvvpOs|Qgnut1l +z-nD4;xe0~QVyRyk{zc`C;S#)jLlac-}Ojwpom0u(Aweq;0&V%0u)#u@@uF +zCdA$5Is=uz%ECRsZVWZz%gK95%Ot9n#H6m0DF294giqdTt>yF^Q3#qU;?)Na!W+I+ +zO9)M}Y{EAq*<-1y@#KCOUC}ExYRjpE+j}JNKuCv=hY^sB;awUAA;HGxHSb`UfJHEo;gSRlW +zk0iru2nl7TpQc&YA7+j2TPOhGAi0`AIUb{3W!Dx`y}>GdKE8-%KF2F~BS8{(gmwhL +z%_YQc{f(E`I-t+E;JKQBE7>hdtd}iWam;$RN~_8Un_Yugc_%0%coFktnFcx)zf3@=QFq>%x` +zl&(SDwKAPzme8eB718~ee%{WUO;=EN3sQ{O!|DMhnvoRnwgT%X_z_Bsc%g0{3lF+6 +zfvk@>PntyFR5}i$_0@;yxmJ3E*3sI)_~gT-_p(XvY^H_6Cn_3$ucBpW_6sR3AXkPIJXE%kQ}u +z2o8pmzY5>X{q53MHqh@{JCmF$Nd{{=l&*ktv;-TYch*PZO76ZI7GLd@nU7kyWE=!* +z^#4i@=nM{Yd+>|VM^Vz}bgQmiQeWWDxSR77IZmrOc53;O{{jQe9V^X8*C3OuBSj9> +zOAF^W$Y!b-*1cCI=1rt4dg$;caf!k0p+V|sOVoM}YVSibM~dwMApq=GUS?kTB1`?tgyJQ6MvTD!q-CACYTQ +zB~ePK-}&w<%3np2{{{@s*_m*sxms7f<}37``u^&51;la2pS +zAMMan%mk+HwS4jNjsS^4zAHrY{f4?3DOU0nQz}vDyzm(lRtZ82p~NTJ^ZLab$jaM( +zYy69kp09JiybiogiXaT85&hW$_L>lki~p6^az;rMqxQ-zp)dp#%I!!g03d#v-)CU& +ztr{#LrC3ZbJ=wS>>3hfi0WT!NY)p8<7t@&HvE%nbF?r#Z +zLg)Cpo3Q|_wGs^>`BFqZxsZi5uE2$-EoBD<4TNDwte#2FRG<5>Se?7Zi7N< +zI*Q{yPX)74d~9O=IJ7a@jNx#{p{Q_EdWoftS;CXcl1}CyeY^fDXyB(hFu^-MG-}Dm +zU*6w;#abdm^z}vO?Q_CNeZ*@VaEu$`np9{&#}pRr)xg=)?kf=DsHMJ!gbj|JIM1P61=j@srd9 +zS=0A}ovZf3midp~U`)}4pTO*;IkTku+4Fq{gi{?^=2k +zidR->a?Sa4n%Mh&LZWlkWjl!lpW+nd~)-r +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 +zNq>!zvg0&w1>8#U*hM$wc+}9*hXaI?} +zO4}{=L*?9J{+p+(!;=qUMhdj6z3rqfjhvMCjlOx@|54!eTB&O%g$_6oT^=4uONW7w +zxsCqr^Z6_F`T1eo1Lvp6)n`M&GI~q^+y8uCS}`!sDvL)8eFhGnH@Q*R4eI-s7rBeR +zGnUl5y|+tI0WN-b{G&vLU1y^rSW3-My(n2SyKnO`O%S5?YkDt(BYwHjn#{*WD}=8H +z57;Y0Lkv@H)cTz?)l{BNkMGntu6cKKui8kr65rties|hWO^HBSxOj +z(WNizu`VYT_KrAT3QN4sC|)sdz92Sin*iZWQV9_iA>a;CRH%CX)k48vLv2bAv>_n5mBylf#pW*lu8Uj;i +z9~V^H@mAlUb%+3z*oPYbIE47uqV5Ru)WC`~$(n#!P-AjT(*T=r9;QM9&gaF+JC +zepX}gbNz{arCg(VSZU_4y#Nu06{mE$ZCYj2JR7B3!TT>n=n9bH;`aavw&8a(PirMF +zH$@17ubf>fvMG};xYeo;YRFR0bKO6MWosP1lT;Ubngfe(dk?xRmMx&+XNwq(|EsuJ9d-SJZr;jyKX>?OZ#aVQDGnD|_a`&*&(FD2hG`Q$ +zCVoTLFX&Lf^JLUkTQx!V%F>$o0iDPdazO-H=XvBsDA?7jm6tu>iv0fL6oxiG^=Lea +z#SLlef_b$ywhqAolqlfWpWJ)O9KM9o?t(_B`n%=yHV!!*^N|n3PXZ#6P)iA5j(UeW +z6%IrmMF7<1FYW3A@V7luIdMPR(KDv_H0$L;_kJyL2gr{vs^Gg3U(X(K*5_Mah3s+@ +z>h7bDtZ_HE|5tAM99tbbgZU}eZOD!5Su!E_R7P>IrzW;6yG25?F*|fW>Jt}Zc%y8r +z=^LM_-jpeI4D_t7r!T&qFsU&!4qt{PJ!yD$xHHY(naI2Jx20u7uQ*KRr`Qb{FCE#y +zu$__}z;mv#k!{aWhH#d*4((Fj73%(RDMRrg0Z1=@LVco}+dL`HBnuhy=p23TZ}IF8 +znE-xGApZQ&DCb9BMw&k7DbcU!1%1Y4m?WOdRV9+1k@h;+;F%KgEC!pL$;|c_*v$?f +zj9^lfDl@4@MKNdy*_k8Fomue;)O5&RcTsV{(+LX41pJ~WYRN*g@4O;CF-e+hh-r%l +zIN=7%tGa^-0s`aERboDZu5-z+O4TZgsTO_T3lM$(yS~jO`v1!R+tca%9qsK}`GI~e +zRr^^z0O&!HG}NN?0J=Hc&Q8XIqKl +zR@nXFn*|y+QH&8RE~>{hQ4DE!`8sYJ?zWcgm+zj0ja}u-6?Sej&=b5F)CeQsjClMcx>!k*#pOc;k6pMUPFB;Nt;>};5~d_T$S>P5C1Lo +zmKN)!xqkh=Jwe)`aouQqdSG|0{9Eef7ttS04b|7X_&KYB+q=~uUMehJX$aq+y>(V< +z<XY0GrT#frbOv>`@R~sjY9B1&ZIK +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 +zD3MPm +zgWR#``kt*pCk5pT25jl^tuH*f|$8&4VM87(Xs8?v7VD>zH>nfR%Rsg=G_;-Fzg8}Up~Az26pR?Z~64HjrqcA*P44S@z8fD`9DzsPMUwI^MDv%j%N+E?3M; +z*W6s1O?1pr&Uoo*-6FtZoq-LMdY`(@)l@R4N&sXM&Co3X5yx;V +zDAiREWOCBzArMEZFCwSD%CNtF>MI7=GfXn~Q)puoC(LP@T(y9~MsjCUjn +zqwG5tr5OkofLM7DO8uJ0R8!kJe>r^;NmSl?022Fz@z$x>KvV;Cp<3+s%*Qcu2}au#f7dJ2&j2 +zW0%gCsH?{T!W2djhr8gP)oDXF(be4qk+~^W2s$I2ju^H2$E4Re7DUYG{c^voa$+wNr{J)>y4NM=rYiU#s-w0E))Usue*00F9rT4Lt +z*`<87J0x34%Itp`r^(;DmDLy +zwf6o0mS>#be#1eboZM;Yln2&MkN0_&#t4mJSYImvhCQwP!NTM~L{&S<0=FSIH4F!; +zW3ws@$L8>NU5blw1wP#$-V7Cbi#a2I4vYJP!BlVwfcQcS^9X!EztqrrXaUPQdOqVc7F)Xks5&LXn{LOEvC;6JWxR_8QTC+`z{qqcI^5b~(3w8N$94+T!qWl?^^yGCQ?r^(}b8<^~ +z0aMV%IoIx%>?1Ixd@()YytAsq5N7~^<2-VFFHQ}W_WwD^er93FC7yFBO3BUO%Vpbo +zl>uW`(X)fDb14kD7>8AfXSZ$bswKV5iAnKNt_`2Ar@Zz?2zlMlMMx(%2q7W2t61j7 +z>;A)OSjw4cP$OZS4mVJu_J +z(e4M(wIowU`peRz$aW`j>ECx-%qx7;my>r+2J-~!AO!zS&6iQB%u8Rr`R48qTk=!> +z?R7It*MPQj-WUR2_1$UEYR{*3VpE&7Wj7?aIzZn1y9`Lf@L!=kbw{W7I*>8=@7To9 +z#L;nR`w{<4)8$hQrXNizVh!4ZPoZ+>ujSoT*^gu72zhyBoAI`W;>M|HonCf3TBjzd +zaWQ23jOnOr^EmzX?yHb9w)?%$z&nSIB;K$3!BkD2C5sV2yS)4P>RHOxDjVQzCPLu_ +zaaHu08j#c&Fnmj#_qAiMo=swZ#-*jKub15K`17s|;3a>xLVsLlXV-hYRO_GqZ;1gs +zZc;u?-|i25_?+Wu?bQR4d0z{FWH7#1JpT+F@mrxd5=#U{-%HU9j`Bhkwg)?V4-v8X+g>$BXqQ2)U=DKK}>&7cuUN@WZG5XLKL{T$ym%patw0g36QO0 +zgF!C@QleI6+tCAy|V{8b`S_lSs---+-^wV8mHEh#_ArR%LJ +zKS_NY53ki&NX)?AGOnRktktLm>R{DhsV->qA +zX#lqMBlHZvwW9CVsUJRe&9tG+loiK{Aw_*B`{cy?|DOWEWWVRGaldr<%6X!@dH+86L8V_wD6DPa!-)eMe9?f0Em#=U?RoqEmfup%4VUjVw>> +z&~d>Uz4TwOF}dYA+4wk|baNtY;Kh^Qx-Gt%e0PaMedsK8Z8q&*Jap>oFx-3=mrF<7 +zExQwI;=PZb5x%(ZMV@ME)6eK(ArdeC9E5QI*T`Q-diBv%%tuMhAJ`7>L%!zne2F0n +zw1CbacPOB-lX=wi?MF^}t;M`Jlh6j?%|-8(_DRJ|@4uk2#w1^|#I4!`!=aua +zTTG6D1$R1m3*uett}_!l2_6*Xru)SZ-~qT)1Bz^?wV43qU-z$Y-PD_+t8S)A)HXIJ +zaV%cA^bN{U^fb4FEL;OFOoWLB^G}Q8O?s$`&GKRupiK}LB*}_KI-iaR&)w2n1^7GT +zyu;4OD>ry)QhLKz;g~fz5DQC+*$NmVwJ;7?L0p@x&>uH(VauDUm8W}#P2`ishbaHO +z)^pbnB!t^lpX~NO-a3Qax?pl|7hmTw3XW{=?u(}b^ntpWcR~NznrI9AD8fqSb!;fu +z2How~v2%KGt#}kfqqK}e1J-&7<7LRG#2LIV6;X~JN>PG_I)As3}E0QTC0 +z)L@3YHwkG$?ilC`8Ns?2pGP4Mty2++gwO>jqL++q;$p=kT4;UmC`8o~S0yx&C$}+v +zM)u%yYGwx%J +z6E~X2-Bt96Ec5k6djlhie@3ay^Qn`*uQS@YZ{lX)`L4_#9KldJ55C_RY&<)EYzT(l +zLqcgaS>~4Cb$2Kxu{%d!+}d;YKBpq)n0h%L>frX}_U}phSSe8SM>M_NB6G#MeEhG{ +zoo$>|m(j-O4}~^agg(T3qF*(#zQLQARf%RSHT-r<21qstHeC}YV4RJ^ZJo5 +z;F9tFsFK@$<#kZ*EX&U4& +zmO(ns$Mq>9eyEsyh6_wjL0|oX%0ZpvH-D`d$>KkJSQcp~Xtz&}OL==LVn*_*wet4= +zshYq6m3OHBmWuv6rQErsC%HkL2HH&|m8BXXg%$BaGd&Kz@-mu`>AVpk_)x)BY~{PSs>B&x6A89t*h0W^?-G;sKbtXH0GW&e^f5yN)UnO +z<$1rSL1*|KvRxQ>OLpZ*`9o2fLsvS-=zLI>{bU6y_sFGoM-Rd< +zNsHq}V?NzSqh}o5H;`Y!)y;>S0ndgfz5zC_>b;~)+I-+rn-sllKgNV6AJ?W6;ilKs +zDsA<+5(gmvYU?QJvH8C6n&^E$b?Wx4dM$YQl$0Uaz%?C^-<@PKKXaA++q$b&3A9DUHF_isll16@EpYAQLh;+CNxM!soN-O`ha*BzJxU^OK%!!Z8kr4$NP%$X%Yl*gx|1w5TPW +zr1cT!ym?$crobDD2)q$$x&)%__pLszOrLsOEcgMTTbG=}9p*JpFGUa&6RyK8N_8#d +zD?0SMzLq(Xt(be#>$lI`i}?xHHy4QQ&95%VHP2AP>&?S{U$mij4z@Q0;~~JOkGvG? +zXng#shoGjAlA&m^9c|hHk%4yo-E!UNKrX?%xa13P(vAgMb~kmO-CAW-EmBaf_@ +zpB)T2GQQ6lOCwqC`Hht*j|V`FDgOaWnMD`(i)klA4bJ5K<{qO$V&N)z#h(KfwIte4 +znybZ>yRj@c?ARm`f^&a(E;U)lP^&{oTm0QGIx_<$i??3zFhU=C`H@nQXz>N +zyo|WWzl4eH%x5k<-@pAad<8%8Z5i6+-7Lv{D|1DGI5o06DU;0==(sX2=_Xp$X#~l?L%Si;u{EATv6i +z?cSpd)_qUtI5}v%)h_JTkfj|{(0q#fJn`GfV3r_&Si6+R(&l7r&vGQsbP*s3idT2+ +zd(xo+&+1EmNXVY_|NR4zmmM%v5ZJTRJCSrHaV<#{Ff&vRJ~zVh?m`@?!Ix^&ypH;N +z#BMeo=hTLe#qGwzf;(=fPvD2h)!@LV`QT~I7Sa{gBwBE-PLW-ptzpbAykqY`C{kOO +z;=cilu%4Kh$snjNZJEa%4TY#j#9h04O_gZdb9*nQAzj>k=E(DV-kr~CH6@w4hvtO! +zZTe>7@_>x!0hOR<*8JG3KSpqI=5MoN>rgRDVjvL`}KN|T)`W2fLo%aOasuLMhfNx1L=Yc}8%|4*&j7mMfE(aN +z#!+#UL$DiS3H2AU=niiMtd<&YGQRbP!uI4x$uInoEqH)$d_hUc4G!UCXS|O2OQ?IN +zT#YIBD6r5Vn#p+Q8v3(dMvM=|EDzh;E<<9QxV +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 +z{JerwClevII +zOOgsfZt8`1&zULr5>!kqcI)>DX^}$7Nk;J_gb6J%_Pb@4ojIoORIx3KhkJ8Yd{Qfi +zHhKO!k1W1@z1k?<$J7Mg+PR?;l +z4j9J)^BVEZqDAnCDT}rw3ujKWqJJWhVlK(AgeB +z(&hyiNV1~u?qn6IURg6lJ`a5t^6qbn3^w;WyO)C@wug$zq2o=U!FsXr5H0<}cT`NV +z5s468YDflYtX)=`DkU9GY4kfz-RBE{y1;8m-|L-+fj=J`f>N_P1Fx1$98TeG3wjO@ +z^Pzl!M(%xNU{AkgOjknX&B51&AzDLV$r+OONd^6NUu~5vg%lXy_P%^0`8Q9Pr2Gv7 +zt>_N{90BbidACW2tHf^q0XOx@1=D(2cdP| +zb}#GGS|HxF!mvqu_40ttg@2OZ-DS*V4}f6hv-^oochjftkirMVJL6tX8mXSz2Wi2M +z^{>HxD)qdPC5AoTT5xfZDP&I>f|dG@!mkb(?)^S@T~@`t{~Y0jkaoN)tk&JxCQ-6< +z$;-#FQPfzp9!Xfs|HH=Fp;0@?5*2B$qVoe{DhnYbZ|(yC_^9%4db`GZ%B#9A%dC@D +zZ+FAE%Rz +zhV$wJ7=Ny|HD+uOGw{p~b*r&E;dRh##hSn8q5F3Ya|1Yxd?#MS?GGNWIf=hLgHC$1z@wktmFCYfbEx{BL +z!7BL@2ZUFWnsXXkKY__@_w!5|u0|YQr2iqOtfPCo6JfK$SFw}B=HWR<_7oL{#dE1` +z@&u9+k(t^ZIwhQqF3WRtHWbCkLbq?Ac?Pl;kzpjr?u_Kd#9vu|rP53!#E`XOUn6;Q +zzG3);oi*ciO`*{8v?}pF5svH522yt3|2IAnp>8Puszf|U3!!M+R=Q1%1#e{~oL@{( +zp&RriYP;bZhYN%m1{iSMv3cFIHzf@TW5zG&#-0n(Nd!(@z5O6aZt*h*mTJDgq|h&V +zH9W;Tm4){VVhYk4%=30y=;WfD)%9VUx+P#28&W4??`oa>GCWHG(CqfVa$u#E9a*7% +zcqzq*$u(0VePF(*)8s--IKJSr&hzMe6XxcU$GfxArgX*+BK&-D_N_3NK4#i0jFOlO +z=gcUSok-?RX#kBq#GN-{Vo1V5r3-Yqj7^!*x+k)=l|D+jOQYiV*DrJ)hvw271+i8hY^)N;tUL_Y>t{ug>AxsjZz +zjQaA|Tu_)2@16`wu|^Foo8bf`ww=?ro$-$FxFO~>!Tmmevy()!)SCoa!<9hXA3dpW +zEjK~|oHxg+(PE($FFxTBcKQ?yh7EKRM4WJiW|N?2yfyQjSJ3B>_n^mV(%0e!i9ScZ +z{!K5Z>7re6pTb73-ix7aE?&0flEW6+Z=>+|Tqd7CttUw?!OW65w&gOtYFzL4l-8)c?cQTY$9@tn1^YKq*dfiaQi{ +z_foV-DQ=|{EAE~kEfjZm*Wzx0;;zNrf(Hl?B#=MnoO|!@ocq7eliAEOnVsy;>?ix} +ze(&q|GNFVc;T4&g2ZOh~Rv3?1j3UtwuBks|z8T+FdlV~WbrDiKQtG#(!(dBGNG4~-gi4u}{8qivYaS0UbUi+?O-~hj5g1+Bhg>e~m +zBvc#DLL_v~6yP`6n1HH2sDh};<9e|Rg6@9oArxlE=J&*KTbo`IaCbFm7X=l9ubb(T +z`|_VNuCK1L|QNbIFUVo+F!FM@(qJ}%AuyLv}MEzNQ)|e1A-K48$ +z#^?Y&Cor>h%XLoybogsaEOvPH9BR-GjV4EM4z}5j*UqdM`rTPqK5+b=Od_ZUX74N= +z4sUzX{66~=)^A!VekSnbW3jR`t>+1-<`o!x*rwfp%Y2~F8>U2 +z{&(^sp~NK7ngT5uQrVKcQ$gNSY?!-Mnb(1d%FVr{>)Lr>RwZ +zHnkvl$nD{9BcJbr;L05{7@|KSxGlY)E0}$S41IZG@3#Rl_52etCQ^Oc&9y0hKepzv +z;BBV@tKBf1ZaIZ4d8lqdJqKnVxe@^r@1?5QB~TYS1>F!q153a!CIRw$qAjD~?E4$t +zQNKhT^G*`O%s(*@!+vp?lVO_X?FBjLzVsRGVf;yA1Oe1OhA!@KdgZ&o4XX?#Y`Gz9 +z*}UP$ulzY3GWV?knm* +zBsYzZh7WUPQrfVBfsZHOSMRtefs)OmO(S+HhpyixpUC7bt){?tlhx~kk{HYGk9aio +zx+Kx{j=}DYlNRG>-|n)pnVqxL*(V!6&ch~Kt~9Gu0->+Qz8^o-hc0jrf}nAGb@^E< +znuwq6%4>6y8000x0>B;q*8Ld!J93YXV|WRhR2TTd1aO?|z`p>;wC^Y)82l?tX#8L_ +zd&w;h#{?ORoZH(s7hGJ#xPYZr{3O@KJnl`ZB9bRJo9IJ!)~zd +z#Qle5T)YdpCM7K#zv#MOC26qT%a&pJxUuTr3t~2T+4ByqU6Uts0nU|{nCxx*hW<`h +zx?C{`B-lk8$Pi9vV2L$^U_R65+VrC*TjQ%=)etAVKEy5ENK$j6fH9gPb(|>)>yzO4 +z>>37R`f;wGGsFd?iQda9+vit#lYEZTEeyQyZ*aM!NA~-{(NAz +zx#Uv*;_gSADSW9T{{Svk5uTDm`3$aAK$dzzpd{-Z3o>(=c)8`f +zl9{=P6J@F`!&vl>Wfd*R`qu2^$Iy{WA#@G4jhS@pW1JQ7YkQue;{{SUe+ +zyTfi<{sQBuUoAAhN2k8A|4#H6-SSHicPl=%|kDo_++F3dx#mdA>45Kl7{eeg-;7gDE7YRRs{Lo1? +zWl?6`R_ZM>n*Ti2bvWMRf50KgA;}>SRtw@!jtRC_^Bw*LcL-s}b&>-<7zoT|X(DlY +z-#LEz+TZS8gqXBR;%#G4%Bv-htq$tsW7gf;Y+DK&sg6DT{cWwT%V~SZ%pYvj +zdKcp(WT|N}4j&@eTJCSzTC?VpD$Ww;!78DqU7_X_`4xUaaueNLRbFnf!LiVlB7Nkg +zNOks>f&r)Iw +zMPrbM$PkBm=vWNbs43<6(;n8U&e2)PQ{*HhQ6|wV&EZCS5^=?N< +z*S?-#+Yo9i%H(p})A1PDfxrUK2Gv(7oqM+IvW|eX2MR}upTO*SURVw+ZpGfl>O2UD +zupM{jIhQ=i2q8H?(C=*n?)m-N3}bco73&BnSsz^m8eDiSP)Q0CY;<|{Cp1=#oa_$h +zwr;muZ49`JxQgx9Wr|X7hYTFEi2MJ`hcdy%5}t88SIj;8{&emT&6nspwqClMg!(|f +zL68|XG>TK)5}A2Y>vDtIb`p%4E*hm{v8!7ElyM4;bYM&o;Vq-jYI_ENKt5~zC!shh +z*Z0$Ih=N7BR=(hnV9xK1>G8V|!owTvkvF9A9v_=%2}_*P30YPeFq0H;m5vsrR)aX> +z27*>@BS*kiDpWp6Hm3Q(m8G~lY~XBXCYCHEdb*`)H@fk#AK9g)vDjUHj0-r4?(Yl| +zj9$MX8&G0-%i6)GBVUiZ93RWuCBQcGCDt>VL9y=7eVjAbENm`y(>XiHGw^1Gjgs&e +zg)237p>F7VQre`x8N^;V9_idgTjp8aswYL{w +zZn$!3m?GW}QOno4+=%!e1OzYF4xyQ)r5_7oNJqb!_W1unImnor<@Rl+LW!2I(AsL| +zIeD(|p*Z(Y$DX6~R_V7;VYKfjt0WJ7x#3Asw3$pTr|^dE7bZ^!DlVv5rJZ3z*fKl9 +zlzx|O9W7G_-5q&KKZoPFRwdgKZ{VD_@jUZ +zYYP(xzx~!J{F6YHt(a00#x!$jlTUNbRX_E!c4IbcWZHh9NN+ulb=Pr7kUk=?HdDQF +z_suzvt@XKlUI}o#0m6tg0E1l21Ynqzdn#`u{*CGNWl!F7I0CrvCj%tW+O*NWN8|BS +z5pMsWbI-mc0tPNVXB7e*m7v#>7e6CBlaHs$#B0G^izVx~RS16g;-rz@ +z<7wllT|LCJnRL0k9LLrm}DdQ7*cYu;`yWTc|;u6m*wI^a8 +z3a7v710eyzI96qGQJPBu(r8xvvT}(!+=?0R4NPjNiqEmQTp1cl;z~)tMnURgq-QoQ +zxqqfS)Y5U>^If7$Z0i4vaJdGRu&voFJ3@&o=Ne0jQ!#dqV2!H3;#8(r2XV^ +z37`IRmySEy|KpB(a_#)D3e&=kFPGcp&Ev4b76OtW^tfI%@KeYU4A)IXaFx`q-?&g3 +z0dUt^zx$3`n0~^JzBaLQFSt8eNNg*Ec01a;>Iu|Za)JYe(pupj4Q)vTh+7)yb!+-4 +zKb>OX2oG3zeoF!-jO(YCNe?g|MfIA0in$iS_4~AX1~HWEgM#j= +zK<3#}6HDClD^v5Z-z(L=`A&DN#|0F;|IZZ>W^fu#(lsb}2|qX1_{kTWXp++NCiU}3 +za#f(ul)*kWzvywUs|&4YAC?y?opesagk<}#2LC9>nf6^dr-2`(-_>M4in^Cxe8~-ZG +zZ+1pVdfBQDEi-l)DlU_jXsIf`#cOn?p$+&5(7B_SF96J)Y)$T4g-V4Mgh&lG;{w%c +z9;rokI6C8z0|An4S_2P(=Assn*V$@h9yc(Lk(#(kvSbyUpD@pnp#o385-dY_hZ@-p +z?5?-2{}EHvVhl_o_Pps+Ba?hxuJr-&JOUhEbE1(VYSA#6#d{`EruE?=LCm7zakJ)x +z=O$Ft;tEvy+y_|nkBz?`P79(zjSPnPP!jo|4oTzz@jZ{}s9zF!mnFikFb1hqBiqSZ +zV>R#C%i~X+h9u@$Mp~)ml4N-X`N52URugK7lAR3I!I&jf-ULZ +zy~7|lI4eIZmwo?LL(_@~D;|kCV2k$XbvRd0X=RM{c4=-YODvwiuVa?n_XH`MnAFos +ze&+^m(sRSVUg06>_VJtn%kS4kTon?oAL9Mm4ZvE1po-&6trE3`0>>OJ3R}-)E8E7*qTp!_YZloFcd%x%S|r4u*a-^&bHRE% +z1C!p*@u;HxlI-T$<=7{MQ*D#p_@tWeO}rmBJ3z4XUIoCT%?}=ODC9tcA|U{EK2_X4 +zK8l?uuy6=m$|>@`np-urq-%ud%5a$H%=B+i!HXNcQJ&rE9nwqF9nu@GEc2n2Ztjn- +z9i6az?RH5Y?*s=oH~M(4*7}|s4TT3D4MjpEA+A{dlAENbYZKgeFr4VT4YlVIO3_P2 +z?TmFt?TY1{gO0rX?ECWvh?7DPR04HW6+m!at9$*x8g34sR-he+T)pE0g^Dj+~O +z)BId4$oya-!TkI=%raFi)XSfTLJa_qkR5`FJJb +z%p02H%`OqZ9a6a3^H^$Iq>tCg(LD(M=;@~|tOOw9m-(tx_;X1&y9DzIhe(X`Sv`@%joGYOtRv;ExKr0$k%8y +zh|2S0D>|Ksds{cMZ +z7Psqy!~2gzz3+e4oxi?@Y!{X4Mx7oaw?%xtm^1jzxn{@+N5F +zPeVM*wM>o_2ctLR-{x8UOi_yl>-^~&w^%%+hTGF2uDJzY9(>*bxgf3HY!DHu;oF3z +z6lZdoJaSR(}6hE?0XpNv{E%@ +z4&<8~E-QZ)(T`Q?9^1Xm*D)N#&Or&!U?Nh^8?tx!T~>0Ys^9JtIPSSOa%q{rrj8)u +zg^B?=OQB~u{jhG0uJ}%^JcY}z>nSW7nLpcxR+C77O>=}caLk%$H_}G- +zdYy62CXp^47#-Q{E?zt0o`E7Byrnld8>y&0!Q;5WseV3c>%$q2Voi&m>_#&lbiluj +z!&})|DpEIQyj&?E3W*D@pdY7dmTj@Wqs{!~?4<&h;^F5)9gca&&ll>sw|&YxKo&ojjd6tjl|^GmIoTdBW)hKoZ)?(yVqfwdjbTHANQu3YOVlA?2*0K^g#)y +zZ=v%a5j_uN@JX{tZV3X3B|eqMdvJ&Q{OIZp`gj_LzdX!z^g8fmD6ju7#Gxv%ZVk)9 +z_5jE>xcfS7{x~G9g94tj=}*v-+R(r?_EedpI2oMA$uGFp^Y9ALVpV*dzAfp%b}$nN +z<8UGytg%pd)(!+4vvSQ76mo%_6mmWOA|dvmexBXaN!ZmU%sx5~;VB$q-{y?97VC90g +zNH1e{pUXDsW%NGj<*R31w(%^7(OVEw8i?Mrmm)wfCEXi!hAQmG&2 +zb5cp>bJWkem2zN1L>ff>jQ{i584E$)!?T<9EbrRS>W=<-H)^OS&Zbbd`6`fj(ApFm +zXch3l?1FU%el`Lrml9Im_pBbp*;<9Nb5*E$baLE1x&{lmud%xcC>c$EjQAO*Zaf-1-0S6TKg0u +zKbn-l2`a(|Rv#PkR=BC3{IsN&vUPQqk%4?$t=#Y2(&d9>$%Cl*sTy|Y_x}V1Y48-nf(`39Maboa>N&gz;cL)_I +zwP}C-6FkcqcGA|yTe-0gD6Arc-&1*yBfC$*&NnK7xx}aMey?42^EQ+`mD>{kohr75 +zA4VMKd6qn+uybpIMNI)t%)k3_h}^J{JhtZLS8?A>CtFvH;tt +zuW}@gic213KoMLA_gIfz_kW_jClh5I#@n{7jxS(+@*9ArSMXv9m-%|4Qr$({ZcO(Y +zEeK5X$(iq#W6^Ox=UpCfK_%O_^(DM`wdLBvpg!5X{U*sWk<0JB5pKR&8!(vj +zb=Qqy@=;%dA1*mLuWBS1Bjtd7*(<76ht-G2+>P+3tmdSAlgIHv +zyNaIxE%5I(9n4m3L)f|rrvLr5l)G4zNEX`UvPtj*S9TL(!l$AAvY)_1up96w7PY7! +za~Y-%YH)o!k}?6<>BVSJH?4gtc-wFcZuWfg;=GM~vR)hH*Wu61_Yev|ED7DL86)|Z +zM`ySCzJ2OC&raj_nU~z +zbjhgGMz~C<--qeb2bl52QXO3mVlshQJzL!Sa(DP&m3toz6*$5_;%to%)WGff4Bfv7 +z_v!Sc;GW+` +zEWV$*hbyJ}EizMSj-&ZBZg=ok +ziI(0~zD{EgRbznfA$6=xRQ*b-i)|2yadvOt02!f$&hGM@;G|hSM}cEh%pCn&yENq! +zu(*8M$NA!`$L^`lSD>Ad$j2xU3!fk}B$I=@%JnhVJSCyVf3Wf+fcvq5DWiZ^!-o8w +z%XNsOL>-6&b7yEzTfFc2FbZB(OEz}0@#W1zn?;Pvcft&fC;As#ZrsQBMC>>vVc5Es +zg%t~Xj=Sb|LrboIXWpf_YL?GsYd1x9O;i6Rop0?3KdUd!ACp~qbzfyRB!*n=ZsELn +zM46f(lwVfW&cSz6QWRvzseH7uGv75oc>k63n^e)of3MT!6(ehg0=u#*A=%G813WfH +zEPsVB=8E*JbnIIVc!|O6$~6p8@8dP7cv)o=UKhQLn?l;-#Yj+$puu`+M@;woec~@Y +zdA+9(@8UkZukDVPP_x7hDO(oVD(|K^&PruSY$DNI9-+T2?6 +zqzg)v_wY&~mHU-$%^WYjo~D9cLI~abAL#{dnmlEu`1ooYvIyy&F7AO3FLV{{^Lj~1 +zQ0D|`4H)QuDd%gXvLx~nZbsP3;P(=~>tQ4c4eXKS?-rEPtp7%_>CoNHl7Wr$)x5IF +zS@Y$e$|+WK<4o$x{9GivRO!YaIKa^9e3mJ*m#(r>M6zKFI8&uBLgH!d7e9adLjO6U +zS7V^YU;1N&x$*>+BL90PMdW~WR=@lPs6nTebi#mK98DHTr(+ +zeztIX3U?i<+l(v3PkUGE?$7y}PBvbqg{z2Q4kM)Y4@Mg2yl#vg#A|qOFn&hIvrO;a +zpZh57znAJ=JSfKFtju#N9irW$xW%jv&!edfpZ{v5*cpWrOn8aIPus}jP)u2sUkapm +zw`M6F0hCY{2ug4`HMA5-I7uOSCcFitb)Sa>?ZP35f0y%TfuGgQfj@2hFZsWG0RD$Q +z_-DUBgKY#et{3|V7sr@e-bs=T9KlTvRu82AnHE^YvA_(R?4MI`HnVhnV_cGXg|@&& +zarSl5TszgK0Yb*|q4S|kqN&6iCH@bVh5p#(A@8z@&<8@xclKQ`!q?8O$6QNV;4i}h +zB?XByC)P#b!6{O8-Y73oC9hlcAi<_BPwu`F#qgJ4f0^|_3mu>+wDPhM`I!-eAuJa> +zlkA5AJiE^y7yI(EK_&UyHDZZK!gIL;IWJK@Ew5GY_VVGwZ?_xt9}!C%No*B>hVPAR +zS_AzJxOF$VM$>YC(mz;9*+X?nECh+I?0L%$SKE!(k$h3mM=bTS3FV~VRq4$$b^M&5 +zhQgwCbfGrh0?J9UCQ}yh{o>zoL0oB;LN^N)S8;XSf{ka{O-K7uz)_GncT6oYdYJYN +zieqFw%CgW~gr?oz#Fmkq>Ow|nxdJ=y+7T?a2#Z)UwLXr^WA5-gp(=|(i3T6wEY&$@ +zj8wS;;tRcBco18;r*$AmOG;`Lq%|f`*_LTK~s +z>aUqcl-3cy%s3}ySZ4gNA~+@|C$nnCFAMqb)qQo@8!R+a_q|Fdmh487dJ)?r+ueUK9`RU;4Ix3H+?HiNcr|ysl{nJ^s89w +zObser=!0`lE<*LnK!VluZWDVnrG+=?eiYhDL8(n1vc5YK>1==Sd4`Tl3enqb^e{i3 +zb00!3ccQ7mQZc?4CERMW*~2OHKJmV9;7{c^mDJTXlWy|$S~?ELHF0ta@9)AKMRD)@ +zl39|z+z+y5CLg~VMIGda8?hHgg<>UgI$7~)T$RLW<`Tf^<;c&;Pzn9n<%-ILi_w4X +z&;H66#75;h=8kn%ytAaEoC+I>i{p_u9vIjp#&&nh{nOodbG4_z^o3MqoBbOF>IY^s +zS)O)6&oWkxxl-=WN`lb@ya#TU*ndBtY=0FPR;N3lRVDo@5s1j8G6-m;(}{~X(hlJl +zA{-(gM4Ho%3j`>=hY`%&q`s#b4Ijb7pH=>7-bY;f`kQoZaky;dFphyaS^VoaZ!PG^ +z(8Ku!!@Aw*koAT&DC&#Fcobe?yz)FI^KD8{rTZvTCX@MImI0%e8;eG64ol;GSpv%y +zu?~R@;rmaoe|nn+Xkjr%23iM}6H<|PQ=#w6hg*kKGW@FXnyU3+%6;L4`jhp9C}{_; +zlgr%c)2E7GbQNa4<6ljCg{KeJy0iICCp7bSl}Kl&U(p&r6@tsv}uGa|JO72Y~GN%8a(+pz_^# +zb06OBm8zu^k@vD+EQ`K>leopj3J}2pawBB$sHiaHLNS8!XHik<*|_sJEh^7czipm5 +zeU!g=l$mfqjCcW832i*1$@?u7t~BK67x{9*)HAt~*&^HlOkc3a!#uxH%QgrUGHEL0 +ztqk>l^_e($;a;@0=~bhd&rzL9SBzXK^rP_L>B?p>Ibi!>TA3duny_RiHjwXCJQX41 +zC*RrNvL0YYP#MoDD%@9hI`O*=m5wS7Vz^$7VJuiwp@Euo0HI&%{(##_MIx +z`@TJ)CnF%9b*uixduyp%I9#R=hm~i~h^Bd(Fui&zhDV<)7$d~(ibXY?h~fGzV?hBL +zw}%T0SD=Kago`WoGr_D2S*{f~ji}&_5xeIHf+!u*SZ6 +zI>lpa@zP~QPXIp#cj4A_&knkR8;m8=&*_`E`OGQf+R_eba*dn94!22r0n(cO$A&`t +zB?OoC!s%Gk1L99~PP01a$WU^JcXb5X+Pa|X!XTddfj*M}JoyO{{2MJW>QNL0TNIiru)9&$M49 +zS-=vsqc%?WZ-fJ#e8-ns{UKIGy)&J0YRA~)hj+J`3F~gYp)_v*===ZW@BYK_Eva4* +z(<9PM?po~1=k@evC$cE?+Ktf^DNw~xMdGqwGU*9N0rObX?>Im%m8H{YNRSxot` +zcvcaM&;8w}mzL;e>%$h64ORo?e +zmGMO+W1)&%IVQ(JR(P>)vUQ4LWQf^eXUs36$K@)P3K~^Kh?+e9>;Kc6AB7;GCLJ!u +z02@t9tuvv!rj5i6bD$Ig?l=MlcU4pV{k$Y4A*I$1aS;LoMsuLIda(BP$fSoZj}ndt +zI3&Q+e+$;}zdQ#5%`;Vy1_BtdzfnUlqZPU#`)syWOQ1dBp>Do21KSle>|^57JidrRl?OPk +z?*dhYzV;f}*8XlkjOBCrK(zEIH(&I_;{i>PN9kNZ%%AQTeB2?ls#&9QvgBWFR6c1@ +z7fF-zGZmc{#uA?(Ti4jgPm^NlmC49x7A9{yp~{zIy=9NRff@Sd_(N79?XyxS-5uN40U!5ERHAXfhWx_W{bZ1BF&pQakz}xv +zQ9ateSy&d(Vpt`XZM|phcc&1<8y*luvfptSzEJiYP0tc_KbreTMT!?)vhXr85k{2p +zS>dCe3OGMnI4b>%D{q)|$ve_&XH9Z)XUwyD)sq;*Um6FUMk%7HZKj4reiOr1Oy}yt +zC6+4iK2@(9RaI$)7w=QT7D%INRa;^_(A!BOFRW#rUuMfkFL}*_m)0vKrXoK6t_Me +z0xF^Pr@r$NSII6WI4T45%q=T@FF>2|*c)tM58J_l6>=(ANGF;j7x*&rxFQAD>TUxF +zWrM`J);K$hw`tTgsrNdb8ZYE9EM&oUrf)8;Aeg=el7AK;{)b|_KJ%p|Uq%Q9AH$d2 +zH^A;G#-zI9F53;Do26#EcnHqa&x?cPkVZ+@LE4-*MsoI0FSoySc~6bL)$xuv!``dF +zyUW&ND}Z*D!aDG6Jv?DC5|RKeHs@<2>h(;g +zH1%50WK<|D_ok_i0~dp1I=4|-@zT$ +zy$r~LJ@X>$46S-vxZ`yFpc;=<}Jf_?e +zjKCXo9`lY#=B-5f_r`XWP+ +z$|cIszja3UE(=~4j-Kiqk`B_Qa)a6u?=DJfEw|tGAW{^Bc-wTeMScC=^*y^*Gd)XNBHIGmD75XXk +zg&Vth9?}#rJ3K|rq~O_Rsl25+Y>!#hS&k^bab2BXfdH*ndiNd*JmkTc4)3l{a{uz- +zD(efnW38l2`ZvQ@dTsUD{af392Vz3YI4LPRT@FS=rCJZCKka`d+nC>T-4GL^)akN$ +zJKdv}MSRjve5U(aRK0TV3yPM>mwwE`#%mehVkza0cQupiVvfHUql@Ty6+R6Nge`7{ +zDPHw_ZGZpGIxD-~-(-o|tU|%)>(A44cfYrd+m4EydG3|xUM0do`UE{oR%bV^MU(MR{8Sf%cd<${u;Tepbmc1k`$_ZuW@RuQv6A1868g^|x48SI +zt%lSM6K2g6xsD*lnz&yLBlNr`C#FM}u<45{!9cd}1rmZSSR}S4CT^$Rr~9a>2qf9| +z>!@z?SMUN3{rqQoMJDjpYFwUK&)q#D*^^y^KC=5KN!s^pa;HM>#X#vQrn{~6*K`cN +zFG}*y|9n#C5lU9=$H^JBXL@bDxaI019r89NkcjMo1DBF$KJVk7^f#MW<#L}rML2Rd +zHd*H;QN=NEWTG^!i?hjoFmp;XzFbd~oU6?zuHHAxDe(3X$Lsvq-rCwITt$|s0uG?m +z-=2$HvY105W=s-x&g<{fs24w$&YBJ$S_@&&=w;*Q!^}|XbJI$Nec0S72tLmv(V$iX +z@DDPgTr-aTM2_E6MmCYH=IGgQA`d)~d*RAQ!l0N{|8vSQHq0zTl1!k|eoCUsJpI?{ +z0k-LoI2-=ixT~g9zE~{P#ZCu1PHLZC2lu1*CY1Qk$dAgw7Cy5xFHS7p7o2+OZ=;Kbl!G +za8~V#Fw+qdHCmO&6m7OT1u3O-@lfsO;l?5_+zzn^CaVx1{TU%g`5jx2s~U--`1$h- +z_TSmVh$-TU4=pDxMqb%!ygw7?)3Ji2 +zrd?v%%}vtjefzwW;mHSs7=;x6jE!U1x`$CC^PY46Lq-GG(f*p^x;FY% +z>+vW9tDhUfb~DZhe7pD#CUI)FrX4&Mngq5frgw#{6E!pq1DlF%W})@*YF +zQJ?aqJ7)VGh>gde*(aC%yr4L1ms$yv*{{e<7X&J*Nd5#9&sn>F2aN5HCi%%%#!l{S +zBcfIozc#lwEEzktpH;To>h~*(H!RtDN1*?dR>p&WWisrz})45kEbOKLTe6Hg{ttEXCQZZR+YR( +zz6BLuw4LVTE&7-;59s$v@s=e;=F@${^hk%!+U0W_>bN??bpP9|`q6O2OAw0kQhYJ} +z8KWUc^JK9qdTUtlMu{ADeMy0^^F8#TEHJND^VZq_YtMT#k|Ov6`({%BVLGh=h1LNY*!yyrS$dJn};x)p6i#+BrDB +z%}yhMx~xY1-LDK^6%u$jUvOBx95>jnfa{D&z=U*@>nJcyt8BzqE`JMk7B3c{0b|XJ +zIuAWgb_^+Im?h8m6^`yT%>#9s8@D}ih0U543wlz!T0H;hk5MCs;UaYscDPQwO`zzM +zJP^TeydJiE>rgw0#o4y$cH<^o6HZ0aaAsh{Bf3d;>KsRaPMe}ee)DN<9<>L)YGih3XML9$>A|_FhmSnLGffw|6&nbh4vM9xcyPaqeK_y}u +z^PF2}H0y$!I=qszRH2%DP{rz +z@7S!d3#ku)aoo=^F$WBKFPIMf{oLCgLI3WQKPw3z&8f^s#0)NCn~Q^8;)|Ph{oW}# +zqI&rn+gDwrY5;M3VeMJZ10e?k$LTztB*xdfwub8&C&b<_LscS$c0#E|cfbr(k^=_= +z0?eD={GOsMA0Ep>afy5ZBO@^ix++p616y2_Yb$mKD<@P +zt4iyl3W)BMB4UG)ydr8zRQn`FK_zSU^e&}&5jyO3Q<5I#J(G=)u18ZJsFa$uD-#2` +zuc{M@wdz85HcM9a9G7E^pYEAJO5{GZQd&&v8#VOc4TK +zZMzxXo@oceg{0gr2JkV@v}`6DZ=S9a#FTww-M24JHrgS0GD58C;FfKjG?W<7kR+0+Qnk+y(QJ1(Qg#joe}#XnUKMY +zWXCS}GH=X?C-i?*F*vyIX>!pe{X?y36JW#d)mY1g_!3jep5`X;c={OOD~xu{R$^@& +zd=Ql;NO=*?^C;6P^**Phze(j2N|xXFUBH$;$){vE&Qh(e=Ij@Hc30E){cdCph7~k6 +z5_WwWe9B3h_#DxXP5oVC1-jM|aesTJPGv<85o9x**fQGxv=~4gRi#wo +zlOt$J$+FTxQ>XxaDqSy5w$0nkAw4)+fGCd$YW<(7o{XZq+d|HeQPP51be|T<@hRL{d@_Tx)iWvBi>fDb!Xgk +zD3DXpHSt}%t;CB<*4XY* +zz09-_{O8ej_hI;3SGW0~9FWQRMsn4q#P|x6#IGRn@Cf>}>$N%f&FGIiw(d#L613{K +z_bWER<)05>DlDnMh|LovGO?@Pq;};qS#sN@il3g4eh3@2#GTZ4P8rh?j1Oyc7pR}W +zS8#varVb!@&HqS2*)OoHmdLY;!tE$uH`}=8s!lqoWs-WTuCJ@R7%_&P2=DRQ_%p|qcHN+@}t*Z3*974S0$m(;%M +zl{xqg^A4F#C54-9g%sk#KnMEXWM-Sw!NlcEqR6g0!B=^t*nE3!{SwO|%YV08CGEN> +zr@2|gZCYx=uWX;}Gh=p7qh6>Id*^66MU%gaZB)A=(d@Yg*~3*!1pThafGu3V{DRhP +zBEBw51??`&c|*ZHs{OV688a98a>khY?U+|8TSBUrdQ+`q#^VA$_|3 +zHpipi*cFCXge9c5&X{1&|B;byf;jSrfx0RkM^d^nSHEf#4|uyBUC9c&9C>AZh2xBD$2bappU^M{Qw^-Con%>F;6XFg1Gj^x=q)p +z*A^-ri9!1})12cYG;t2JzkWcyE!+?EuLF8!dQ-dqx@~^!d#%dK#+l&8?9OE1lQt7< +zm?w#3-cV}Peep{PyX!M>+Qz$%xOdEuUttk*yo6XAbA~$ao_{vL8TvZgHh)DXRYV5+ +z^&iD6*>OKNRfNS51`7&OE0!~;EJr57QABfz-FduYLWx-=lV9dxB>MX+8=Dh0dPdAU +znb(Z!nHcE~3u?I!uPHdih$6#VtUtSpn(TC{Hx-~Oe39`H#yscq_=AJr=q9o-BeZXj +z+~>oh^eF|5CqlrUH;!JDOepau%;v)oUywurlGa`em&Z0gwY@4Pn9Yvh^+m$y4_Bd3$BwQBVDV#}mmk_7OZ8t}T*&NHu +z)*p-v2AmvYiwZ#ZwjWTzO2V)R45pv-f^@-==m~>SuO#Me*M-7g_ihG#0Q+&vxwN9P +z8#6kl_Y%HXNc}n$%g6Kn=VJvv!W+$7K9Hty%(MhWW|GO8SYn@Km+uEV{^MO1EM3|s +z^Jm{#MDT`GV%-6m4A?lpF1%X2BuQFCw)S!LEfT6amgoxveIP{!#DAav7o)P=csoL* +zTUj0={)VA7T1z!svl2ffDoz!o)q7Q6=jujss3*_#^y*-4pEWGVpF_vIGRAnB9N!WtdYfdcLkU58)fxE5l{>cmyl_lzJ&$H$YgeRk=@n5f-YmO%$+I_eGrE?pGn!(ht +z*44M*OV@L3dW(#PsKA`Dtl4)L$H~!5OB8n;Gf>+P(O!`oc1tYvvV~*S8EJO}@eM)1 +zXeHuX=M@4fWDbk@T$lOy;~=@l`6D~*yy4d=arj4aPP0@IhiA_z`nB#NO#SVz!Uge#Yn7(YOec8@RTF +zNo_6WZ~&f`Q=P}tfEWPXv8sozTas@i0|hBfeot)cZbP8+Hr+^iukyPIh`9SHY`3l1 +zSzNSXP3oUfG%29{w8Qt-P19yrGlL0@SHWOG#B=87nJLUJ40Fh)TLAAF?7d@uHb^Ws +zNmk-dsCf!|BuUG+J10adbJvk8qe+19>y%;l`@!l(zbWuun|e!j;o7iQ;Ky;0KUjAo +z3o|G9-BYij;S(Hcm9lK0Q*gPvoHH9YwI=s3PZGRUSMz-iHuVEHGPYxk&l!pz4j^`- +z?gK>aXKWV1Irm48n;3r0cV+6^7%lsJz#&bsEg=E8O5wBX>d+0bHwB&UeEsSAJN@IU;DomyKsMMK0&B0k-bozDdcQG-~$`ka$ +zkb5V%E?jLrGL>dT_(o}fJEqgBFVG^|BT2(oBRme>fR7>csds>H64XfiwJD3MxX`NX-HoMnAe8JlFk@k=wqF9>8>lI3CC +z)Yem;UkD7w_)n}jXstqIXgHsrD}br(bhXzmR#^pwVqe(HcNf2=eN7wi0E;1x_4uli +zg{K%mDkoc0$SC^br7 +zA3SrUVYRKa{08!ccTN!by+ +z1wcYv{9b08)@MvC0p?cv|3PsLJ989oSfQ3^Slr6Gc+QY&&q7=a*fqm?X73i%z9Mp# +zNX-TvA4kC>7uKJj@moZw1vjI>eqU^Bp@RqaosAr(5BD7PO(bGK95+eV`GFN^`|3?8 +zINOnf(n9jkcZRd@~-u}TIu#L>d{F==Mp+Nf+)9-$DaVZKon{_pq +zDL6ZZzJsmeU4#Ut&6RglSbTTc92T3^t^UcKMrnRYxLzwyYZ4-!S8ceuzQE0!`II_P +z!6cbFS2;V#sMQym!8I5@y>n*n3#vB)lg+k^h(XT;)Sc26-2Lo1P8U7LRZcKtD{zrk +zuGI4Z8s1T7&$ftX+dPca0%=Penoam%nJ+>V|r8+QpcGEy05? +zX#PL4-a4#`aBCk%P!K7VZk3YmE~Og;rMpAebZ%NeT0pu41XQ}aBsSgMuz^i)VAH!k +z&igy(ea|`H`e&}0`D13D=bE+dwVr3)_gA5}#Lh}mylFF-cuxllu&$;9Xsx{S9AmiT +z^|gNcXM2OzFJJd~$bfn>_Bp3trAc^0^vN+d!=lAfaUi>oV?T#czyDgfxW+C_94}5f +z^{sf}aR1N^+8o3d+L3J=zWkd;#_rTxq=g +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 +zh>tb>Z{(Oez8D`0wC_*7uE$`O; +zAfA@kWF9jI`rF3eNPgb^-hHrM;FlE6gB}r%@zN|W^>3QkC)Pvd2a$JfFoA@?g&GXM +zvB!x&F!idIXo;&hLMzAR@E(m{B(PN@)Fx^1n(^kny=-y^F2ftWu@OURM3KGZA3O2| +z-bpk!Qxw-b6}2U%TKV$rIVR*Y2?|x_fWl9=N$vUzv4kYTS+@Q!#fDZSdcYOJc3PuM$Tu*_19zQ>%|I3zjFW) +zn>T8M7@qAx7!n=WP-QPw-z&B7`+KfTKJ{wL=-tHYT5j0r9{tI+!8M-;%48RTZjN_2 +z35-QY1!j6!Zfw&!8~5g*ovnbeuTwlJ?x> +zUjszHZxR!KW~-4Hms4aZ`|>V(Q%Cpf>Cj+g8pf(ma{O5Aj?|T^E%uAIrK3=*&Ts*X@Ev%0{Cz^ +znuDNm%7~|x&a0iGD~bMXuBiHihnb0Q@`4vdkrC$euU|hDQ}VmZjO?5_LC*Ndb=HbJ +z>9uj=cRxLH=HVZ~4Mh>E&cQ61`pr;ouMrztn)N~ +z-K5EJ1WxzXhD-mNNPp=bIcC6~XPc0VYh23awY~k1y3en;w$X(#E}IZ6)Lo=tQ#Ihr +z*s7*&xB9WLn-zF*37js~6DLmP%jywt&}_XHF*>W76YOpXkZs#=qC+oM7~8V(yCUOU +z5?EmU87lcF^u}VtHjNi}dM6umEj!U3d$rt=m7Vl3)!f*9kL$8)+r2%9-qi-s2ry40 +zzoIGUMuoFXtx?A?Ku@wd>&}Onk*;^t8z3zea1}ecGLu!+_PYk1b{E^^npx!$=#gDV +z3$OHx9&vvlyoCFl1YQ-SrZz#WcBfL0nD=%$ahW!hE^mkG@Vv*TR_qx}zA2I_! +zX0S(z8r@&^+~}GSk9Y*$K3by)Iy#%9W&@93EJ8D;8g3>(q$lzT&*(~j4+JY +zkX7nr(6k{YtIsMzB(9d2coT|~lnl-m=JeS4_O#3nVOl_(i=&cGP`Di`U +zvd%sWmq;(l+3jJtFmw#R=IwZ5HTi+14s({AI#p|& +zxtz>ukR?&Ql=G5W4VJLk!- +z4x)RESCh?csN%_@^?UpUk0MpWqd0*n0u1%38Ah$LXTFM5uWnNkgsAJM-|LP2(Ealb +z%bB4YbN2Gx5vVK4#;U%Qt?BtT3V(4?{dGm*cR{0pIj>XP7uLu4*i^4$!>m6%u7CgKSAF3# +z=MM!0k1Cw$q9e?J|>>e1IF7CN07X +zKD)s4;I3cSHpi7ypqTR8GXUMsxS;h?sX)Y4Ci#cKV@O9$S{r;Im1x%&^AoT|xEOAd +zUJ8;}`avzvW_v$$}$J<=c#hN~VS@2#-Y81rFQA_@2- +z`QvUJQ$-5uz9rT-=!1Yrfvq1MrR|K(*8CW=<$|j`W>d=6k +zjlRLgV)ZSB8;g0fq!cU^rbjM$pAmf`9BxR@xz$cHNP@cp97itCACnV!fo}$FT7rjt +zvu%hNDXoOp>7+XQh`+dZu}8IvuF-2&|G7qfkrsnwa^UeD*;tr_lW(|Pc+k?@CXF2* +z8cPL@kh{~!T>2pfY}JQdB!Bh2z6EyCHsmsRq)Y0FaI3}**>n1g-WIlq626a^q#Gc3 +zum=s3VAJ^0<`?fB=wmjZn*GvC&mwTzis>8TnW29BHW# +zcO%oQ2J@HKuL?6i*Zp*Ib0;pT@(mH1;@l+} +zE)4e^Be3VZ-)Uj(7razpaiUlc@U5|mviu>LNOzI;86f8srsgnQ#6AAZvwNy6GiZ=Y +z3!+f-rY95++sAe#43Cvv}q=zQ|e4*h+IaF~LltTV0HlKi_W)Qww+NE@uI85vQ0St+HOpiiFp9 +z?~4|Cn9%MgmmleUjOEu-#?=jv`CZxPLkSX8J5d?2?I}v4i@Dx9fuP_##GlfgNYEZt +zophn|lPfL&D(m6xz5~4bY2)z4 +zW<{0b;gCt6 +zqK$CW6883|vDqgU+_VU@F~8IdgKHT5!keIY+fAkRO3JkP9S;L9l!AVQ=+U?@38-By +zmQMX|xjYL)mes*mA_DzV!L;0GB?I_R8NT$W^yuI*9LpM%W_-vZ34TNnj=dxfpZQAO +z^XolY>#;8Ra3Q1ZbGov9|H%(9(|wA(6n&Vl`F5F(>`^2Ui-NU&rK3bHuf<(Kj2lR{ +z$JN5>Vt){Tw=YVOBMY69lE~u$lChIc@b=Kbh6tW)IwIKK(C=$CkYv0gV<8Cow8JNW +zn9V|)X`&v$Ba^!o0`9NZhA#I1Znp+V6W@XF +zT_7PeI`ThE5;Nr*O&c84Go4$E)xq!GQxY<`vhA!bPfG?~c9bEGbbz74?!s>BZvm-K(=3#RCo+V{!)+;I-Cxko +z>54>({Oo%=#Vdu=s!i9Ff^E1(>8Z2)RVCF6n|5}J*T0WuwOMdR>R0HG_bHSS@9;6v>-iK?CU`kJ}!wtnlU=cLD$KSot4r8wT19Vw7$L +zsqdKvwB&Jzjgs4*S*i8WG6cSU!-_wYO+oUfbHse5&)mE?qxX +zyGL_(?ocyo_LU81b|pJMtYsWS3I<1!z@WI5)!&#W4;j +z7ab!q6oM*>vY2~fb%fh#%m;7&ahD>z3)dvELtP7LY^d6V?VCVk@Sg_w*kwT>K08==Zh_ax3ZY_U-2zgp0?U4k>aa +zJC(>$>Mz{swb7^DZo>>dD{nmRg39c??j_&_#GT0tr7xs^ipbCE{vudxfC#(q3e-Wf2>;+y+MR4cETH+YH2E>DZy +zV}pDiGB|ub0qk`B8nb#s;3atpiyi-6+Y~vDGEF|PcQ>AHHH0kQ_NAwc+GpE9=KYYx +z0lK@33|4`a9#>imQHsKGQt39GqZ3!3xY_tTbHrEY?$Wp7IIOr<%j>o@>{ukv +z1v72dcio!3emOy6&Vwc2g5Lk;^XcOC(DvSM=a^~jQ<}SK0wOZ1AQY?&7tIrk1kl66 +z%(dpk&RcODW`pDTMXb8k&csoZG&o(usFRJd^9V1PXjS{xFt(C>JnuU#Fd$7i7cz2n +zWdd8#l(4OEHw`!$5L +zrVL5SZ9@R2;^+F%zoPl;9tXyKOr~3(oa!f2g4%o&AEN*!Jk!q%MCyKieQ0^GDo-7? +z1gNe9+9h*(;iK5jCLCVuTN&V0ku9%bMJ{V=cdvRSCJnA6U}!Nfo44QU2b@zHPevay +zVGJE$G%019rRUX6&PJZJxW!}sA@B#fvG2eu-wIKaDxVi^)DvH>=4IdaKyr2$sgj=% +z^sAF#iyveJe#a}-zYtWguywbSs(PNOmEFYbR=>YR}BADM-b`4FnjxX5)!ZYb_~>y7RttQF2s(9oy$IFlGEMDQfGS!no| +zVOGhFVG6djL#@|LsV|yZUa8;HhLeWXDL*LRy_D25UHlsxxlF6j|DON2xb@1@UdvX`&$s`sCh;;}@cUaS`m2L;BTm{}#V(wqgD6%>E56h+9X>VW$(1<7 +zn|*B5TMo-0AcVbe>;|4OiyY8IO7MwxfQYnsXZJC$mD)=Q{@g~x_dg4>h>%8vmGF>; +zbAu_BS)wX18tFS>oaArJ!BImPffkkCUKY%*LXj99mI8;yU<9H4pV>>2#Pt=I4vJs> +zPc`3&5>%Yarz4kaw#Vuep6xaH=zpHX@Y&+Kiz|A(hYLxs$q>|HnJ0}ToS}tLjZBLr +zzMn~3u(DAa#rvEb_Q!cSm0qGmM$Rpo7gk%|@f&9^lV=wak|sN$`(D&f(Aa6C_Myf)B;Z +zKIA(FpT6J&mdV#Y0G&Ftu)x3DF>XdZ+6=k7A#G=Ou+Ef_ +z>kU;U2ck1RuXyugs{p;Fxx3%RQwOqecW+bKwfSyUt>vFAsSte6fT4U*dNWtl`V&q> +zNV}K`@^!CvjL)-K(uhGP2|%iXWSL_CVK8z+LlqMKpfSolc6&?&kQVIs;;;Mr4xr%( +zk(ozVU(!ldAdaTw%L0n5c$H3ch? +z2OcG^2kogY5y^cQ*{q=|MGd?j@yPL?Ert>cV&6Y#OXJs1GN+3-%`eeY2dPs*id^Fm +zuE$V!OeGVuY_mLBAG +zUJh=w&Ln6dI*Mv*S)|uP9v&+%RV*bkvYC0BKz&XmV@(HnCkG%kYg!7OC(_tzkd+Bh4hLJga_9Vo=Pc&1-Od!w8b|89ZC +zu+n+kF60l7?)vY9*!TJoRnO>$7k_ADm#WV7N3k1K2;p{OX%8CYy}aOOHqXKY>(Fm+xrpXwzO#K!xng_MX@5WIs>PF^o2GCw2W+ +zz%B8h-JlgWd@~;Vqfp5^IDF|uN2kDrQ%j60wBIJBSo+*;|5Z)5K6i;!I+i-BnSx0) +zs-ej@=bgpNg@RuFX-vH>J8eJx@%Mb}BHHiFHLPqOc(nU~@#XK|ZTueE8J)4-4XJHj +zKaW=!e?DrZtP*N+Q6vBl{~ +zNV9RHYBK{)k0)hvyl(sBMypom8g@cd+Qpv}3&xWMLIa2L=+!9poi`%Zf=;-6Zx#PI +z15qh>C~?>cXmSZcKEAk=*Y)e7_@QI%I+zDW_*8t+$mA&B!^19^JYohJGu*#1k>91a +z%exPm*l46iAsXf?*CxWHKa5<#Htk%l5B$!WK5m2uRl;e*zkgr_jEb?R&#YSqoabbT +zZ$crJqsY2p8?%s;xq+Z97G0aR4zJhgZT7#8WTm?hbIJGiGF;azBq#u#kZD4H??=OYC~^tMv|hiS6VY`+&YBw7%AIZm&C&1lr6(ff +z(w6?_qg%wtHR-wzQ{;6;m=v^IxVQB$7HhRx^kfdr<{aA~hJ?RlCAH +zgpB$&By7}h=Lmm8a*5@kIm1ni?(YQlW>L;T=nLnF^iJ11XhM1r+90Ji*Y6H|=0sr>@y;{vj|Sz^?fBcQO}FKlc4zyr5pVTe#N(2^r&^(`gp2~@ +znCkG`^h@NB`a3`B0)Lw+#b1er1?S^4E(e3GbSLOqpR1anR3GHJ{uS9<8@Ei3Zw8?R +z_B9evZVS)mcYF;z%kRxX(!|V3-ma>M)v3iHYLtj^h1?hzdn4ZRZe}zVwAQl9zT|(I +zC4!^#YLJbaT>nSF!QsBb+yn%k<8gWt2nP*OAcF=SS|E415D5Te0k#T-!0$+OjFjr- +zQYcV%F#g`DXv~dFv|&=+^9zBEkb}Fa?{AvEYgRS%sl2}k^I1Psw*CdAt>~|&Itu)i +z;~_-s5$g67pM@EFp1-uV`$7FLZ;`QQ}VE3iWq~COSojgA>)h-|Q1-@QL +zx?;ZA_+pwM)&qVsSWcD5gkjz@=JsDj&aTAZ +zu%&zqnt3+cXNoPP1^?XbUT +z22=u12>tr`!NFAL`%)}4swN~5Kis`WO0kA}S<-~B;B6)AAB&Uc#4)dNUu7G3O!4y2 +z=qa47=xd92Sw6$0WTR+4HgQ2uR29ZN;t@$2VtOtnYtcrm{6_x!kth#E-#bH`y!Vx; +z(W~f0xmwH|2{Y?LEs}gXQZA8Jma`Q+vv!6LlKB>@26@dOd_`R%`s1@z3A_Bh%wE3Y>}EXaM8K1eXgxW;~2t +z>Op7?>I7d$qw#@kCoM$fxcKHkQ3Hje_ +z;<;Mqp~qi)`&c8o`c3Qx&>IxnW7!K_&Uc6@h$$fd2Dugu>6+Xf2a!=rTI7kqf135| +zl}ekmiL^PmHK~U$bl>*f>KSrK&W;P4RvJZs4*?x5g|JBI_U=kljg8a$khT=N`~KG7Ye?2cmx>Qa5a^C*{a_tDDaV;arIVfWFih{)>ozZH7P7R +zFZ}GI?buNM0Q46Lxl(HFlg0(2?%dx~TVKk|f1N{>yxos~H4Nz6j(Kn^tc4yM9`Tm+ +z6gUcqDD>_%XK6KnA$K}%#W3=Wcxf5RCn`49aXg?n5{UBJw=Ap{(#$-J8WI&D3Paq! +z?^D-?tYhZ9fLQDDNsVDW#L^t?!6C5cTO8hR#sx3zLaUIMP +zz7Uqj&kMz)+5a^V598q`V9tjMUXRWPLNBLlrYgb*;J2k|!Cf2`!`Iv%ZmCx&$Jb!Zg#zGeR{!kPx5WER4|bMx}Zjbklf1GEGD>Q)}B +zII%;X0lxR|tiS0OfnWO6oi;_F7>{D{BYGIeBkd;sR`<29Ms)(lr{=>s}9V_ +zAAyzZS#4USM{QiJ_-rnEjo$-=G*pyKGA}K>>BEUsa%n=GuGf5n*-MAqe24e*7W +z{MsrI*~iTIm@3%?!mHS;6I@j4oRFG>d%O$N8(o>A_wY!+Nt(b2nRD;{@9hg{r_<_0d>HSK3@h{1Z!udh +z_ln{h7}Lq}NR@9W!XIZ-436T%<__&E;(g>&EH9*{>BJXJp>4K9{$t;hpP +zy``eHd2;44%(bg8 +z!O+R!y;s8^4-GVqNu!$m0^928O4Ic%U~1I4*D8tCMhpO +zB%kNVj>r%9M8AIn`IVo1Wb7_f$i>2XpW)V+ynN`J-={58rB+ad0j`>zD~uF(#xC4# +zWy>fNOB@ICTF$;}z{bwXrYD{-@)stVnDrMZ&v22v;RUqg^EM_n`5|((lPSEn<(Ljn +zz@k6=!q4BFgp}2Y;oB6Q{iJeivyzYO)ACYgnjr}LU{%gDqSV;hCTi +z)C4`M^c&UD>3FUf7G}5o75ZmgvB>R(h-5}M7Ygk?Jv)(Cg0ns`pqioT^Mr_#>>10K +zaqP}(WU@`vxTPA!4#+1@R3_cB74)R@Wz5^Wj3J1Z5SMb*5KkF%^Z=UlpI-ML2N5bB +zN_4PQzig8RH!XFCyrnfic)bbVtpRkM@BZuHkYxrE%kOeMncjBGG$W}%AsnD)>6_nM +zGwk9JbUrGORGS-)gFI}jbZWit@oKsAA-X%uevtN~H=+zSdYkpIkkXAFut6_xmzT_V +z09M0HM1&;IU5^D0#3gSg9+-$g=G=7mJUS_;I&Go0Mns8U{VqM_b~)PPG>t6$sv!2L +zl3Ij-|7yI60DRFffgTU`UfwaGaj)B3{9l&|@K90{jv0Znda?Vq3O=MsGOI6j(n>P}ht{_V{w|e`)ufJHMk|~`PuR1T?4wu>=YY+O- +zC44C|#Ngy$%cA`wdo^dYcTWE7D8-_0xDaH@Ju}9@#J0yz<wi%S$+P|m +zak;i`J3Ehaf!$xaIj_UGS-<8!A&{3Teizz9&kV{qD1Bdn)^eW_;u+F5ef50DZ`S_Mxk03M7?8~sCSe$;$a^I5O-&X^^-OLiQvi$c#5py%rm +zYLH&&6J|g3D1nPsPhcodAEC +zlI{wD>zjG4!O7HP+Uq&Q)jKcIh#2)&2%Y4U&tvjJyjkBnl$pK6f@`RFsW}$&eY(te +z2DAqxtGjW48RPl4#BjI_ZP#b4!?Gmi(4_&DsL7XcFoklhgO~fV%J${A$bui6By*UO +zoHBSwZh}7*H6*+L|FGYMLUIEw{0|oQ_j=5r%XpgpIW-8!cG{zM#4RYQ$}s5NI8Hi9 +z%=AHZSKq(;^EcSgPDBv{?CeP+p=p>VdhF9!Y@#ixcH_I#E-H}vhMU4L(0z>mY~2s| +zsAUA6OHy`4+WV+Dx6774$lLzH4D8=u!{SYeH>izaHFB +zj}okU?@!X{G?W&ot(yyw`a*;c1}^nsm3rGODJ>;f7;^zp1zjhSSk6w6$*x#tm-`uA +zUFV|>9qp2!uzz``el)ifuhcp{m!;F@AHjhv%Qlg74ylmwncgvZzpBy+Q_CH4wAZ?O +z-Tj!nthVU0&+&rR=kyRe*%&T=z0czjwt+)dEW3qQPl9>Z)l1vhEUZ8KVoIX^2;cr- +zFCfX+BF@D&5o~DQvw+}n#o1dZcx~(GJHJ2$^sJBT9$OnnGl|rT+Z=pVWwt#I(#EHw +z=lZNU+MnFy;&jHl_?;cRAQ}L26qFVf6;5hY}<>)10UvLIy{V5HNiK!JPdayfMS>pu8jBlHj8OhcLxhvp6dPW?G3 +z4n*XKZt3Xdqp+fj(z6B>nh4!?>WCzO?_(LF#Dx48+>nq7iAxlE`_9~1LDD_X?NpB_ +z=M6A)lmAdu{m||h9cPzD>vA8~5EpOy2140uis~)POM)%6)l9AIBK#1DB9@cgJ4^P% +zu1|+7np@;%Vjp~;6=yZOdcr63!kdC+wvP}dnz24rG?jNlGTkFW6zuKBYq#30e#TDxKnmIYr7_6UY*JWvS>U4n@L$i~-g +z^Xcl@y~oN*ds@cNdNvgjd=A2FBJ +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 +z*LRfi)#rq7y} +z4}JPf-~OucdD)fsTN`tu5>o~ymFLEhQ{zhbUmkG-3wN}EJv+T}@6WL$_y5x>{+~;| +z +zfjxIPy%KL(IEDGU9@bu2cE2D52+u())qx +zRl|X_ue6_|qgiK6!xo$Z(E|J(SSWU-44^cBy`Wk6w@ztVK)QV)-IPj*{G8q|62G)m +zJy64#dQEb1s*sHF-PqGH6}ad3j{~o>9@@9yrIB*>mW^Ni#8Y}?9U;~v^J(xUn=lXe +zZ#`Cmr``p~2c>S}-K+iUFTEbJBlN|E*`?J~v2Hay_wngxVr@91@EMbt|3+o9hAMZu +zedB4*ro__ykMB3`*R@Ux!+*0=SdwI=iR&raPoxl +zG-B*?$o$WfZmkgYzvkQIKYH)@)_7P|c*;yGX0ntI+wF*2<$`;@L?hAzhAwwK=?-6X +zM2z=mb&?(4Xx5?Cr;0d_Vk)&)FLAL~u&PXfM1vR6&ZdpQ?x=U5q-gtwHY=Ir8;^bN +z?Z;lyA`0tqaZto26Te^K38S8Tzy5G=3+z(K2qTJOj2M0;S$qlalS~I=mA2o-wt4Wn +zxPr}mpy60ErzkNsyYr*ZsEu)`o@~E3OD51QI7f}nRqoanlywkuh&0RtO!%KAGA-Eh +zWuRX=jC_=I@v@T}l8t_H63k=kdn>c0Rz}-JpRB+K+BXUwVU8G&J(K;I<5_l{`a0qw)8$Q+VQwSn2^ywK +z*!9)3<@u1q{Fx;}__KtMjJx?c&8w`z-<&@-I0x=uE9&zDIu~W3Z|uA;f_DmL6u8AF +zq^m^&Gscegt^PIPBM!9jk__~&O!gTLB5oK9`G +zOLVe=&rfrYz?S2~cq;Ak)xS_pbPMTJ7nVnFB_{4Hp*&ZVO8k~InRoY$<CL5=uU;y+J4(?LPeK3&Te_cOj8@mIpEfUJsT$yTQ^c8MTN*l(i0-SpXj9 +zBc$qKv>@m>J85d_flL{m(AOkVS@jp+|3W`6`x +zJ_ML(MVE38_sKAQj&_S7VU_2=l|+2+=TpgUZlLV;XTYEX-r%v-v(++Qw_0{e&sR=p^YmsjL0UbVrh5M +zcB`m=h|5n!lh+H-IXxx0H$gRG5nbXU`>rJaJKWTg;18;5*S+3G7GSs(V6TuJ!#QrL +zwCqg#TmUn?jt6wMfn>D{^gCGB<)QJ->6o +zKbJ(^q}_O5I9XDDPi_thFqX2|#%L+!eqV5Iuo#%RtQu~pXD>2JV0)9Rw7T|iDLS7n +zL}gS-RACOCN)zxPj%4cm>Vrk+pds3@%6TJqB4N+460?0iv-1zrx +zo{_#EYkqUIXLq;F>+Z){6`=sfX=RctM}J0FK$O=-2GGR>vtf6u8Y;++ILHq{wJLq# +z9WMuEw7W5D&|nQT``}atyQB(U;bG=EiyjGT*(Ku-^x4&ydXupqyl))*4>m;3IXMRT +zyEtOmWY0Gtl5fi1@qT=K_gMZH{6O%f20hv0vgc+9 +zK;I*ITjyx@-6xCx16R`be3;H-o7b~?=o-M0=59Eq`3rM#T)V!La8 +z{C@i?*imwBASt~l`tLoapHaDXH11^S(~|32M~h$fVxRCShDjHXap{>3U={fz`my-` +zi-aEgAr$`)D0Bfdy5lc8cC}P&F0aN~V +z{Q!%49z#->FW#_fJnOfG*@z+R(!D%vQj~&-zrUmGAXfN;KBXW8GUp^`Fxy`mL;A&; +z76xU*`UlQO6-?@D=5akiqX#uy&X2*hk@DbJDP&O*-HxjI2Nqxb}TB&f4bK3mT5aYuobz*2lbf;j}DY_cR}S#Mu()9bYMI|dmtNy +z^AFVDM}{(;^-7-m?!(Ge +zWXOYE>RT_V_1rr(vz$=8lot=9%!Rd+{di-eQap&ZlW*hHN{3M5{qrhK@eAxQH))xU +z2iM=aDwR@wxr-kZImL2QHkv$0nlC1qvii*D)(7{(~Mgn1gOSt*?|&C(M*M!J}U8qRmU +z_8+r+`{l|^OW1!r{mz#Cz2hU*S#O|ZVkT+8dwI>RX)olvu5sw!L^>t{${N9dW?wyWW3v)up0#k~7l;Se;JoS&8-ceo^%XqM(@xL)tgPFRyX!kBO&*qN)?{4-E^ +z)t=R=AoG#5)=it@d0J8^tNm?<*TLB%P|0wiUtkQ-95XaiT?SX&xITBdFqH+(&zgj1 +z>$~afL+fW(c=)iE2AYT~!@N5FfU||Fh1o5g>YQnG@Zkzv7-)TTLVxb)+~(#)VeEZL +zy4q4WR%Kb!35`+UgnwQ7J8U8Zx^zZt@pavA+L`z9$pK0%HC{dkwf%;zG5T&Rk*mil +zPM_zLTSkIg{5wB6-PJN$oAORs)6F(Rn(~(#7*mT*=KqBGp;#j68u@*#dTHqrBuDz7 +z1Drw2rMLjZm$daVJ0V@?DA$A5HA8%m(xRm&$-wxjvn=JA2$AbWkJbZG+vwTtqWn_T +zqp>!n21~_&WIg%iT}dbTce=pi0~-|)+a0Io6oBTC|X +z3C}R6U{v|qTjuw4Kc%&ro<%A8Jz>=gmrc^cw1xfLkkkSvp+RJGTyJU<7|N)0ZuiuN$+ +zmGds(eHCVTn?IfWmt#y~IR3Ho%TqSbp#q#Nt!KCc^C@IWr*HGb4U^{W<6zVGiToz? +z8tPAHmWVYL9!zb2zi=8o%k|FIqVg0TQ+wxJ@Pq8nt*4KmKznXzRCeaSS6>zx-H$QY +z`D^k^%s+ce?ZAw{?M;z{WA5sCplfsM?Ktv0$7m^}!_1<~*B&}8zn@8QTX2l~A{t(2 +z?>-_{#%3~nu`(DEx21J}oMZubn@IsXb}wqPp1J_0b8Byq?$>uT6(4VQA705@x&Qm8%kQUO*z6^aWmVQwjP?gre?N5;8Xe*P6F&4yj|5 +zIeowV&@CN$a_2Y3AFmDeM20z`vYV+TTA06@GYeh4K#@p78g}obn~yTx?=-^HzV1WC +zfAM%8wy3aGAiZ^^NQ{ir6Igx@mr{?@~t-U+^vuRB=X)K|eYDXqx%H +zUmDff;)kRb^0U?*UlyAUf5`+(IV(JJXIrde)tT%k`{L`FDy2#!f1^UZ)x+FpGP%NIddn@G1nFn&pJN367kJ_J +z)PA{>(mC*@MJP!uM)1M^(UbW3NVJif6>yuBVM7~A)kO(dIKo!DyhmKI+ET6^hZpaikcd1KHMzhX_IWd^#+sND +z;6|_olvI}QZ3ofaqD3zF(2s=P%+&=E=O(z#QhCWM$6&@kANsGx1g71Dr_$W`>qA>G +z|5Wtrs8?r!pMUJnjkgn3B5!~q=Qk3P=6!zgG3I)U0Sxie-Ek~_@q`CBvKF;fF3u_6aU8U*UO#vu$;$+pa$}oQ$vKF2ZaJ5g_u4v{ +z^WC^$vqs~< +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 +zO1vDSMzFGvc#M(s*7;)tMG?xznUD? +z2u*WP#tUh{w)G=w=c2Q`IwWI?TmPpIdN8>WH_)w`exJ6{1-eF +zP;-Sy`_-v@^aRj`L27OnAz3T)eW&nSi6EVj+UxvOe>!5eo4E9y>xiMErli~ +zYft}!Sd;5#+5M(;w4#OtW=3&51mv-(TXnlVI0E?G#lu>&3rf} +zLb25^XRjD!1t*!Fzbm4xIc7t(wvUeEJw2P1&7YGP53Uw4F-- +zIi-8G-yC(S_3`p>?kGN6* +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 +zt+REee?IYt{Du +zvm2_}w&}Hq*W7yb<&U`HM-gq?x5fmS1lnYzyHt?s_tN%FmVV7*!KNw^4i7O_;jh0p&uxZA;F^POl*&g<)s2Z%%iuAY)0zf0RSg`o3dd +ztGLovS?%mXPOaGq??kB`e$u{ll~TM>i4|{FwJR58-&-Std1+>+Vv@i|ca}zA{_Y?w_AHq7Dv6?6wrV?NU((5c3f6H? +zVej_FQ4hO^H$&$#>Q--+JO@GJf=*X~<^pSpA@Znw{J)Z+$N-!)IH1F5HpK=~!Ld8*SmRp4bI*4`JZyZ%iq<8r)##?m3&85n>?`z%B~;BM +zZ2S_F{yfhl<7V7ad8N9VmHb?$ei{l4x-6$Nmcu`71oc0RMN!8}9>Y(l)yYk=uqww= +z8k&ge{WQidY`Y~VY5^c}t5l^pxkogbiq!0b_p11?neRW8)JOaRROX=I3Ju7@VIB)3 +z`D?zCIDd?cy#L~KoM-pkwQZ?%))97-Mso&4%`JgxFTxJML`x%0fv__Ykh-^Ub=Nf> +zR#%Ep2i6MYa_os02>84}*32i$PoRJG$>ny&wcSD=_RRk5e#oS!WGuut2-E_fZpok8 +zkSVIY%bVtoqk@soayWU~X@w{B9fUx-qxn;vD)TiH2jfLg^4t*Y7DWpqe!B6-VWa!RudFl>1P +z%O!@Y0b}OWT5H%4=)hI%Tjv-J@YXG>Z19|J-|#@ +z)B$49b;clvK0@;(=0MC_)CUqVj5#V-}=#4bryLUowRi +zH`N4W?abX8v;8{%)jW13y>fP&4?ZN}Jo@aeD>Q_Mu*3EIOkzCy#6J!#(xk=i)zDM< +z_NnW%WKEzsp>(*{(6$AOL$cwAPXZl-=}xnwTP5$ch8k*N25i*vQXF!hX-K#vray^E +zb+F``mn#gY6PwRc)aLsdY;iLxV-y4F_9*HGY~Mt(Q+e>oYAk>nD?)8e^Qc +znR_+5NQ#C7EubStBy&2}yO&$C@`WV*my5M$zx<|`-EXHEtl(~GXpGNb{nPi=Cu=zHVuN-&!Xhe$z&7?nS~R@p0VmT*%9mSi14_JIx1e7 +z3;HB?_r2KZ@QygWjObg(y`aELHpFN3v1{{gEAjhjab{m`uUaB7k&;NWz?VVnsxQ9I +zlFWRZ9gh3kG$EzO7j5A@brdL0@)G~v%by5+yqdSt%4Ncha`9@8**K)Cn&lfsfb*yG+e<0b*Q +zq@z=sqBQgcWLrf^fBw4!ENZL;%jCcUfit +z72eL!#fkO53sedA4S1?SCjUxN6`LGjI(Sm+&~Qlwc}Z4hWpVi~W=2pNdO97i{}9{t +zUo4paxLo7D!C-xFXVG*5PNsh@Z?akf`k>-<&X}91bqhN-y806!Te&+9_vZRqVZIt5 +zWCe40dsZ8`L8Kfq*PZ2ChF68|>aphc8dK%C=k~ +zF<`PrbF}(cl20wjIcpkJ54sTxhWh0nCv5kN%KF(=Jwp5t|8GLi-B0N_7mN&hY^a$| +zSxoF3)6m{e^n&9=Mc2T0)D9E6Sm@dsPJPB%t*U7tg+OxJ<@S6A@@IxE*}JXmx?Ff^RP{49Pra24r|Rmozq +zW(Wyda!8m3t?dO9UIZ;qH>vBs|_R4Su26iYoL>Jn@1$uLQ9oh<%J3%SGz3z|D +zAhYmz$X9o2#0vWMIUhKTy5xV-YfTr|QR!a#=!H +zvKLbXvk=P~GCiCZMHcFBza~-E5jaze9vHaxyM27BJjAfttP|Gz$9N>0d8hM?5A$zR +zOXozfH`pqE%nm5Lrmx4lQ^0SA#4i8u4K_g1Z2+LIfPDnD8?SAi-vxG+T(n@3zgACQ +zR?&UgZ%Ny~SohrYq`0lW#Oji!gq;!ktYVRJc>wwL?8dIr%WTAe-SnJ1VxRuWUy#O@ +z{1pfbKW_XS=i+R7ma(d}NU!ZS$S*U!N0hk-T`^pwtrJUp$Fv^~MD~k8{+a-QmB3&} +z1d6TB5nM7i<#&4|R-$pU_20L?$C2)IJ)n5UAntux_q|noc{5n>SvVbCjb=pJiuE8i +z$6sn~ai=gPZ$J&vD79lGO6F-Sw@{I1N`?xep9B&S|GZZz@n^4%i`2W{SBz6vrxlAK5&LAZ}w1(E1qx&nwj^xxy +z2?^P{_hB~xp5Y4!3fC-m4~(6?0N&Z +zyH$QPZhp{LM>PeQY-p95!ss)DfDgbPeEjN0|# +z36EGJqOjpd?)rZNk=hu=u_IzQCPj03u)Zp%@_X9XLZYsd;0dAcAdMscic +zvUFR}i91-xZey>-x%MW^sO2UCawQvk!PU)SOjW@c><;~YA|Whj`NoiSd{o^d4ZR^!24!P?Fv74Z_&b$y7V_U)Ru +zjE^%{31#X&o`&F}v4IWXA0OihegB!0u~kRsxas4VTO(&FTg9NtZ@jjO>g5e@?#SEVj0qR4&a!^Ph$9y) +zFJXcL@oRITwr2Q)r`err0IK4y_w771=Wk|s-mP+s-mEh@^;=F6*D(cD?;NlO#jC<) +zXFZ(MVQmLC*zN-z(+g(xLr?#%qd69@1&KwlhHgaIHK+>Fagf6Yc{AfrerGc<(N!TO +zu6B%GgO~D{mk?Df{sDymfPva`c7Jpu)UI=j8}-!@<^D4DEA8aB@(guT{%T2iQgZs( +z>C!Qjs@*uR*_d_i|1h_%fWNt+l~Npoyx_d=#sp{eDHpy +zrL$V)9_n~y8{!zs8uGHGYz|>C*DNLzSUw?O^dG>wO@&3XLZ(1Q+sya!6vih|;SOYl +zCiw0hME~N!mVtBy9Nt4|?$CJk{^Iy)Zc$g6rr*ykkrL?)v0IUKMYY+{S@G3VkB!ap +zi7dR&#?e}HI>$zXxsqmJ(5Jx~0t8upYbny!p{C;xBNN307a~-+!fb+IPD7B$SQtt1 +ziVn<)S@>sQt?;kQu()G_;>bpSpUC~P_8zH{8cp$xm-Mw7|Pjq~&CK`KYk%YWADKGMYd2fn*!il-;khzpCI<4e1T|0xOX4E0;>**sQ4q9oBm>!Gz2&aYd +z(ltt20@{&#$BYwZPr<>PMoG`c)``r$7)>hxw34WM*1ZNvIBUcKU-$}S!pz(wo2zXH +zlWh&c5=o^tEws%1=R?@f82KnJIdO@tgD8#PuQ8Nh}OLkPWf{SNCN2r=ERF +zs>qO9kt0wq7(N_97Yd8}d8JaUDqf7)(x7kzzc4Ob7Ug=W<9>Pcx3P~9I#e=*7pWbw +zj^q=t*s$5y>tmu|7)HL2;b8$hmVRf`<#Dk#|D}iEhC=*{dFqnN-)C2RIV8A3Yb>CI +zB$473stglPHpUJS8{sk;3PVBXj#OLTG7WC6K))GvNl{$q#Rj`vvxuns*{>x}X$5%< +zl=?N(KCIN3M=%pHf}$8!M+5=+_KzaXdyjaKHh@;tpl1Rb +zwejm01CX$*;Rd}&MRE$fkS{Mbccak9cKyr)0x@N36VjD`pPjD!0h(`%98Ijc#w%bc +z-YN7j$uU>+cuXPMPGje81GBm`13cW`?b^A^_cD#lpK69&g7=`)gH_w8gWDrm^L+%@ +zMP9^2c*21^7@c8yM#PV3Bd+sXEZ0+W%XjU(>cL)rSxgT)(+shR2lyA72WWSRXUGTt +z5on^1-L?y=U%H^noj_*j1I4h(ZB3?zi#q})7ix}G39{SUBV7#_yCK_0+s`zmb&)u92 +zfN3wDthP5bMj;ntTh347t~06xGO>$-*P|*qfVPD{i(t%_RAZSQL$afIYatsVS7qgL +zcXl?YJu=E-deF +zSN0Xm{9o!$pUrXpI+KBwifPV)%F~z!@4(eD7B_fynDMIK6PdDb_5av<%dj}QZCyLK +z1_{AE5D4xLjRr_aAh>&QcW>O?-2()7cXxMf+@W!8=)=4Bx7R*vo$p^=^{48ZRddcU +z<`~cYpsV$PwcFhzZDgcM?|%7*0nH*8xiU%kFGP8=3G<0+x_d*T40*P>dKE=xIf~gQ +zoK7A-{q}UGX3g*A?~fRyARYY8!r_?7FQ>v$qqG&J)E3&`NOUpAdc#d4)tR%+IuI0c +z&n#oWOq%)qQ0U7ZCmfPs>ovj1NlZk&L>N7gBXN=w2umInG~|Nfhgq?1u<%}d_#fQ9B_;^%r;m-ADx)tYvvJd&NR#5y%Mo2nF=2$ +zv<*ys6^UxC?HEO49p5)nBbKNo&kkX<^|q2pVanI@n|g%vbjiWi4n8?(d-{CJCR+HT +z(PWGw@MOW|buyI|{FoFHmvSU;{IUF&l_aHQ3y2&9I>;vAWvx~PmAJ4f$_2F#VUa3I +z-(5IQq{QnH)QZw@4J@(p!y)=L|CX!^5W__haC%cWCVX_;ThW=}PP(VgXCp0>xyoOH +zW8Ba&(6}4;jBJ>v;e~SE)i8;AGWHO($#m+=Mu8}q%9gun3kVQnMLLuEsVph|j+E%F +z({=&fH|zEnBYL_r$1h}+m_ss?Q`m~`eL=@O!SERf_@prjn(x_xQfkBhO07*)*rXe4^2(5i|I$U*}YJkq?Lu$G& +z8kY}UutWuJdajl*k{|3!EpXX`de{xcmf2E#W0igpHaPgf9(t)NG1KG_nr*`}5GxRm +z{E|lZiBz$mRG@7_^XOIAU97(pN`ejm21P&0jLAv!`Y1RHhhGZ+|D>|e8C@v3hbpQUs6v>$sK>_Gzf-=Wk9zY +zz1w$nlGmZ~w_R +z+9>fsE}heC=FhiynxAQJ7rW95kU={3!cQ|yXa0$6S7ySU%0IprttOATI9j6l#ZC7~ +zAxFUI5x`8)WKKKM$@B=+c72XX#r~|V&@{>B?DwEX=?;S~@-3l-Bp)XvMvrk??7Oj- +zg5T&C7xq^YvKT{5v8#$rWO&fDVb*H*-1VFrikaPr%LqM;vvgKBlcN&OF&wVOC_{v} +zU9lpz^6DQuM-#^*;(Xi=l +z;^Sg75n#o@Uv_`U_WkmKzS*>;tAkcWbnp_5E>$mtNY4v7X$TLog&=|-F2-?CFC(Fx +zs>TT7JOlVVP?<6$V!)2`G{j+Z4dwa2hUA~I>4eNoK>uri{xwp6hN~%NFQK}fm%75- +zt&Y6BzaGzY9?2(HlkG-^N*g5&HbOm|=TCI69{pYlf)Hq<77wyrt}^X~z6dd9D70Rx +zKivp{@CAi&J)>8p7^`S8nel)E7OpP^Tpdu`wT=Ush*#5%?)k)I^CR(5U`8eFVRP$( +z!&A4#=S~WZD{SUsH>61~$k#mYA0zLPMj7PRo;SRna{Vk!X^~VXyB%CaRwRM-*Ea)W +z?S&lR{@+_LByU!M#{JU7do}5Q`Oxz{ojgjT8iB`GwDv&p8$!*qg_R09<__uu#ioe^ +zesI=4_Vc!8l98q0`t{{ELOWy@*O}8VZI;>-HchfCfUMdxqE?+DsYc())k+s*!IlcW_vgh; +z!TDNmAOPR=#_NQhKs@_pKYok@fb;6$GbFMn+|?5lgw)u%W6?a;BzR639^Fjs(gvAC +z1F27z-kZ+voxaG8GhFxX-D#^@b!>sS{=aYbTG^9g2)h-_KK+b^T9HW!q%C06`{bs-+8RU+X$3kS(syB2e-6w!s*0mlh%dAh1E1eq*zFo89SBEVuIJAqN +zfoXMC!HSHDb<;u{S(R;xLzI|- +zB|ELpxtgCsNN#cTc)u!1;FJ3I;NENLXnfA`SWy>$5K8iowb{H={{ +z76%;t&OacFnk@YTy{rlHVhAnq*DfAIKa4(jC5coSI`f_xr$60FecZn-2!CLbPK6Ih +z;d7u!a3;i(?vW?b|BfG`n6eKR1x`A58wzlTRtseqy3 +zfHAAtL>=fGUB@RDN3=xqUFc_b49pz8X(GG;CaI4_Qsakyx$cK4frtv8KVQ%zTpPc+ +zOT;rPABqHSVDFa-Vlt*4$fI=7n1`&$9cbyDOFR-=olS)zjM|gX<||U(-Mb;+QUwk1 +zbwf|$sQT%1i9bts9)uVHVOAw2`}>>`glMBm1=F2*(!tp7u6YR)o8W-YZtT2>X1Zb4 +zG@zrgYv>DFwgdFk$!J6GKn()j+O#I~paFzUZiATwN-xIVs*q-0x>dUqo&3VtKba=3 +z!Q~GRGQy3gd7jMkyuskK#cU(Y1GEsXd++5=uXD_+=Fy@pJrAMa?Aq-`;p9nWZ5|R5 +z9&gBV$k_W=<1Fa?xof`GASVgN9r|Erbd$_+a}1cEFv&}`g7&!cH9%*Qn0xOYZQ@#} +zr{Zx3q{vu80-1(9eW +zc;MfGktLf^@8(@Tm-?wL54gil=O0#Ekh6tnlS#jjAkjCnI3Qt#Z)0|PzS;$vh$r9kCJt_n9K2kr +zeperBIZa(memVLn1odS;TjgGE-1?)qXjB0U>Dps!DOq^Te@yR48dY%PsZ+Y~#I)Kj +zbV~Kk5*}4(FivX(LK$S4!MJF^!HMCw%>IH#Nwa0Q3oT306$iEGg|o7&6<}w#AJ_#p +z=m7UUN&#&gb1Jw>JDv)&b}07l&ayzOx1`XAXDAoWYQ8s165m;J!o6h61(TLAbO;=| +zp?PovUWZPVUTGAdcJ`hlNCArynw1AGnK=23?;dN});v1Qw{00-oi$)rB)&aTE!Vv( +z6)=|6_-66($;pzW`k?C$MR&F)m@Sh+%TPD`32r&1`m@top8+Ndv92E~8a>YfdiWXO +znjr9OP2jWb9E8Z3Kh|_f4O%7TqM!2y1-u5g6;?;8enqWb)lhYdh0!ZR3?7kHA$u!w#NrOA^yaU`GG#@MovLG8b +z^hOQpYyR*&e}$wyE5q`NPZ|ty$XjB!`PNK9 +zxS5Ij`hM_;UOYH(;OAmA;)AF2Z<$}hCNxj|SnXsM0;lY0)M$jX>OPcqGrb{IQ&Ook +zg1P*%ie)z#_-t$!&+pc&ez>zc5f--f8Z>L=MrH-i`A}ACU8nqvJ`d4y&k;gozVsZ! +zmhaxI#t4cGPx^uXfGH`9Hi&@#u_kQk +z<1f-h(i0ZQfv8W7jhsko=u +z4Z)-l)N~wI?e_9LXp9YMIh&ntN%iI0MyKYobUC{?9O`Hg#d}FQ4}Dp_&wi13TT&nQ +z|A~YD_e~GO`?RQWo_WJ$(W^HdN9a +z1qlxO85HEU?~6aloXNBF>GAJPwT(x|xZ6W!CIN=?u+vkkZo^g``R~p)?%wVKd!c72 +z^p$-$KDvS!qXG;1V7b;Y+)eiQiu<7DIXs+gg`g`$dhELxfoNiAVI@uxqG?Zae*;47}#moG_!)hy2a@ +zBJBsIi5+gQ4!7}d9j?b|Am-*Rz@Yll3QPVY=)?l>V!GCQiwg%Xs$5P1b2RK$fdxCr +zgVD%V?IoEV*zRvZ%GwJ*)}1^ipbZ6QpkltMe7=oviOEa1HC3f&4IwAR>{8P2uZ?Si +zYxjxI)}8t)70&fL%Y2Lf3hq0l`CwgmYyT!bT=Dl)AL=>XNJjSCoIEaN{{)O>T(3Whg4*hBo-Kl0*9tkC{v>%@4wRA|1PWsV;AdV}TQLYD8=zW2yh5=6;-#{wbtST!&b=-1^0Q$1xw-CJ$xKNdi5#*KWs_5vwhd +zYAfWXiKLF$eq~j5i!lH&$G51Bt=w&XDIhKftK!&acsPaZ7bf8xX-vjn-4kk+e7Gi= +z{lNl(Dghft`P1(AfERZ;9FuX@yeK^u36l_5A?YuK1njx&?w-iUfB4WP-c9?}bbTw} +zr4M)~?bl*}a*{Ho?JC>%KxbEJAxMq2`8ib&)&mr*$Hz~jpO+I^#UU7r%ubh2Eg7B9 +z()o6(+ega!3(Fh_=JQi%uK{+J@Y+w +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 +zrf&DhH8xPgMwW!@~d6- +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 +zIS>@$;>;$!VhQS6hBt$FOW!85QF87&SX +zuXzPQ?*=%K7NOB~f>%YaF9%6iL^Jy99S(6$uW(lF?VCP3PG#3&cP!gGjnfUg&GE1C +zi`U(K!11rqPxz2txoe^*nwIp1^y!5WoArw$)iAJ+%V*uLiQclKqKV@LQ(b7bdlANuJS}JC+0v|;`Bsr +ztl=op9I@hv>~0OARs(p{>Fjv)>BcuzTR>IV3nH#1IcaZpkagGEN2?3G$g)1um=L&K +z8eXh#U2(&I*)*})Vb3pn;QE)#1UM9=Y&xIfxoLYo)V3Q7VcLRj*{~YDoZ@C;nW-oG +z5!LGMA>(+8H%eRV*6iQb6&Ak!3RBspke=2ZaD@ycm?3CK4PWfaow;NU=|6SnV3GjI +zq~$d=N?QNaI(3xQn>`{30P6%bAu)RB%%#O_L(4@*L45iWfmdVxL1#@&pDkIYOC>sorw~*+mQARTeW&rEJo^Kl#}Tok60bToabR +zN6OHYz0TAf8N!eH!fPz?8wY6Lgc?v+Qlh4ulRy=W|^wymy7`CGvbPVa}+{0mIgv18~#MViWMdtMeY-qONh48$2lB +z-NO%y+gqpemVIm|XSH4(^?+N^*N5viIttO2IBSk_^A22^FF=~wFdOVI1)41}tcZ05UfL9rteS)Keg*^eN82sJft3A96^$K7C<~E{u1%)kOeUhh +zujQHkE6;C7bIexWtPYRod4c!Jowhcu!F#Jor%XG<^@p(kV*q3b17v&F8#HgnJ@Z*w +z@-X&qXBbpBE%9GGRjW|A+Gst5Lq2+!TIX~#U3Mgn2WqAerShsH)*x9r_bdsm->vI- +zr;4UtKg_*jX&BC&#Px6^Ts}hArIHC~F!Tu#QpW%w*I}j|o5HHCNGx7SQhM=|mXyDT +zd9s0 +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 +zcjLF(i2NQ=u6^Vx$t)vm +z^(VF(`wU-xb>#`RaV@to3XuwUWj(>9)}D!;9I5&Tu1p##L;gN7 +z5{X*wrgb1itmvQ +zd1BYfmvS%5Au^;&7;o}2C2Ar3mmpPD)80$nMhvfTPpmxpzf8FACz=RMM!!Lu_kB}5 +z2LBA&?Gv%kmx5R*n&1C1brB$tsP~>oFXg@FDRsG>|GX;3zmKr@YG3^YH3!?(UaTZ= +zom*Vvwx}m5VLmx~M(&j-{ +zNy*THyr>-2WI*0dp(HWZGu!pb4ycxgX4x5zer}zUz)CwVH6WU|;OMsL?#O2LuoR5i +zDg&bL1Xr1Lt12Y#em}-^C3ZfyBZ;*=+8~Z6aU;nnx;Sv3KHh7bZ7{N4%-?PgNnknK +z1cG~oIF?)2M*jGx-m@^5M>T=hj{X?LPD+vZE-t_0nvyg%(QRURhr|i)V|H-ifPbfn82Ny|Dv|IoR8AzmtUXqJ +zoH|S=7`wDV2JuyI<(unJ_l_L(&M&v-K730CV?U7=aB%Gko8c`KPz=>7JIpnQ6Y=m1#_9<#Ut9db97Q=Io&W;;w38bm7ZE#Y$v6bnk{=cdur+h0;30y7khWJEDfYIqZemlO;#eo$7o7mLnWlGv>jb)^2F +zA`^{C$C?_Cj!gBc7O3oyB9627E8w@Vv=UAmNb9cq0nR0L;Q2VIXB(``HL3YNI<`%GA4$RjQXvSG?u;gc~6Crh&DrR`=<{Ia*={=hCF(qtuN_c +z9lt;OZ`ApgX9u%-64!s{=6jIX8Pkodn0*Fq&k-v(gREOH|O)1{3$O_F~XFER@3J7tu%lAAPxvzfKYd +znSDEX`*i-7e6WhVGhDeZ+TTxHhYuuqpqRbeGmL|1*%^!mz&AIwk2~UJyJ99_5O9s= +zAHF>m$4JDA-DnHxT{R}ztZu)M;;C>N0>YyrZL(X4D|f0j>96peIOT>7c7+eWjM4xP +zcxW$gbSiJZKs?RthFdnlhEtxH6k9{dsvR(PLf_da>sTZte{@~7JDOo{;p3?Es`^d` +z?PWpjELh8BuDBYDedp{MDx>Zc|E2P$~QM(BbM#-?m^AFC%zaKeG}C*W)wfCfnrT{MHq +z-~j{X{q};U{@qiqS42lg(r;rF4346XxFIs4KpI6wfWnf!Kx!nqSEA20T0JV8)I; +ztbVlYRQ&276f~!`=v?ZzvWU{FzwI-uav~WGTR9hTxjaj;rnzIYt6ikE&ul)PuH;nL +zKITLi{It0ZsuT=xE4}pcj$GCf%WS;>&bKb)w3hCp4I)R0KR?p2Eh(hHRt^5_1O&bm +z{`>Lv&8t^(LHMh3#$^h*Mr8XgCL*dGXV{kml}#F9ACHp +z4jEJl(p>hJyyADYaWxl#fA68l>h{N;V5MI*W4eA?v^;eERL9AFpq{YR?|M{M(;w2e +z?`y#Cyh0<{$(!E<${4;7oU}PIXs_ri1qNFmc=WC9;QGcEyrIYYSJD%&#j>*x8`=n% +zG#vLFWM*Luu?n_i~1K52UFJR&CN-`0K} +zi<6FPE7#KTs8K0Wax2ZM*>cb_Jl`}M(7MK()S&izN>4^^$<)@Bu|?*M62bXE`Z(K* +zR{nQ2ZVn;ee@z5Tdgy8}1yD3PnmR_vWJP9!r7I-f!myv6*QSoky4+LFX_bLuERsPy{5U&@6jN6(T>bsm7>STbKmPVg8V-z;NH!fEpp+K> +z-f3}~8%arfC12q0ps;xjXb!&yGWZ@|+1u*vIUHkxZ{!W$zbjqUowuG+_C$BxTsH~a +z4o&3)#AZ3zXQSD+{Nahc`ZrZACqE{khl-i2x)av>DYp8<;;kylHk%GM*AGCgrq5y6 +z9XfSATv~s#8c{JxhA^#>q*YGSW}Hoc`>2pG=DqspgW1X}%KmJqKM``cjBIhz#Kv~? +z`8cnOVMC*M%xPN)Kr~M`qY*uQ?jdZ>=du_pc!vV(a-pC0+ip)f*m@BjcmSG$O*=LH +zLJJFcvZtzlS4?}ZblDY*sur?rb1FjP8Xeuzpo5anWgD6`gep*P;p&GbJ>aICMSM7V +zJ$TlUULgfu-LfraOG`U;P2y<4S;L<(*4w1f1D=Gs>|NNm-^G>U=L$ENe3;#7()eV3 +z{lEsFUAU-Ic-R!uTyYfGE##L`|H^qZLAWGSNJM#KpwOenyni37UuC*$PH!w@Yl0VY +z_5J|1-}$uPd4%fN0x}9~is@mtTZXn?@wfCn>?f&%h6)648V-p(yO&AT)?GZ+`?*}Z +zFE;|OV7I#?Xdm-jg9GM!k!`iIXRl+*U{=F7wiX%Cn+Cm8yBKXl_#$pMf(ymd|7WL0 +zx&GFRa=zk&etyMJ$XvUxl^YIlIFL +zabwI`*}>@J8P2YzFNWfOjlX&!cZ37`x>lzDSF(uqTd9Iwa=go%5Z$m1Lro+wWXKNt +z1%P7zU7%s1L*g&Lw*sx{Bpq=}q&Ga_MM9Q;_vLQ$9FXr+@Q*qQrJm|BO}r25617o# +zoquyu;~|NknkW^x^yAkzF-5~9$sQc#xLmAC@Wmou)J=&zJba!?j(pQcb09C?T-z*yq`+0gVu_(;Us1A2q{OGKzn? +zsqOg<;18HqIeP_C(S}jpt4E(|uHO4WSrp%nMk6G&JdAWjNVqU!uv_mv<*12o0Noqz +zMM$$_?jR$4tuUl}6PD5z{ERc&LwPuZYMN>Hj8J3!7O;pyIWKuG!V8!}kBSAhJ-<5n +z!*@dTfqnIO_8fLu(p8c4f~6>y)NfgsL0Z(GzJnFFsReyn{v-u`tv-=7!_}EO%1Y1e +z76wO-zb)6@I^aIxD=_@T{%D#3gyD=a>!v+S7F@l`Y>Mxv)ZgAtYs?;*2RM0ptUw#= +zjleWyS3vFql0w1f!nkzqz5lzeYZC}{DV!K_aFYA-1%-7 +z%-wM7cYU*Rh8^Q3@-VhRq}6Z#=!$1{)r*%_DD0}+wNb0WMK)Gzf+|wf|T?0&DRjHNgh&rdzu?U-X&pU}dfxZ#uQ(%(SMKhgW;O +z1{%>A#x{^4&N4B)B0wXbVTBgs{t{BB5o!9>`)l&s8@x$10 +zwiCNg+Mt!2U#uQYyd0eIvWfHi)%xOgt5rORKyN!$205jlAfZbyRUrcU(%Laj`v#Uo +zYGkLXm_^?~bQEk{acBDiZ*z$kG2a2FLu!{_)S +z@3anK$)3D$)8bwoU*v^gV`K`v`;>l9Z09nfe7Nw6!u`~dB*5__4uF&#JHt;UZAy@g +zlYq0fUoeIQ_vjtT!ryU}P$*0L-p8-3--ZpmF!Sd$L$8!4WmBbF4e__+*TOyq4PqV7 +zm0qt|@iB2y{YE%>Xp8?0j_lVD1W&Zf0Uj~(2FMuSm{-#-%rOaibq|f%(^cPZLp7AB#URysh)t6=EFaUl!cuTs9wwdQbA{!q@R#);mR1c{l+% +z?(}1hxPs?GRQzwRT|P79kv?g;*yRcvk$xkHB{;qHLMl#es&3g3=+D%m{!&&j&E5L*y8LVo-=@h@!-If+FSklUNVEYV)N2Kjv?)2^ +zR>c9wXGQ+OzFE +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 +z*mnd+jN<7M4l&K?Jkhg%C^1nX{XnF3I +zT({ZPZ}1@y*h8b70eVVWmg(p0H@YJU>mT200O8&7kQ(=hwJW!CfyC-;(%0 +z+I~p%Bxo=~NyL=6=wtfV!&GK0t;Y{qdM$Be +z8kJ<{>6cpL`0_i$YZ69dcU3O;5l+%B=Epoedaf9t?0-i8FxJ!^W(shUP+zOtpU<8F +zxt&{1Y5$BK>x-4`f5xyVfVB1ZoLBB$rCeHTEP~th5>$}^!Gh-EqD8cZA<%ESf?3~U +z#A5xq9GtLxQ0tWMFo;n~2K^0O-xDWsZ|{kh&;xf!BN7uV;4$0kV@jHa>iU#_+Z}D{ZFZHUX +z&G2c?M%M)0CdzCC%)e9Tj)by*b^P=pr@H5^^FcbzZ_BQ?mt!lI{Et=rp +zov#UysskWoBBa)C%rVMkjq({t5{j4@HWy_8a@(U#YJ){ZvAHg50o?4l5mnI;$Q_p}3DK>g^E-YNcA4lb-2-MZG +zDxs_EyqKNstp(e?_Y-F2bYrF)S2ldct}lmjIU_3@IbXO+%(B9V<^ZA4L0y1HEpkge +zdcEoU`Z!D%e7fuO$D-JJR#!K34F6J_m)TA-oYT(ETg1zH%EU^+cl#e>^wYd<17yY3 +zj%g2ODvMU2q1%W9p~loMrL=h^gX>M!9zFM$Unl8XpEk`zY`u(El6+}#L%DMWpVIHe +zECX&)YrC(=rvwDE9LMIv=PIHm`jf)*2UPs_F4JeVo6<%vxc`iEvSmDJ8(pxdV_?$ +zhzkc;djxB6BB3Z&WW9*ZnBqi&<*ii3NMEmpFJs1DOiIp!LX-~Lo0UaoidE0I?!)@ZtD?0u +zt&uWIRG0v3z&bg-RAgF9v?5^xkwgyn-}TBNi~L*@d}Ahp+2?eB-#YyzdHg-<4atH*x&Uz!#V^=78E13UBkn(9azG+<_T+(c@*(VfWFSWqU9aIU6=S;`Li2Z< +z8!>`uRwlVW42dVLFlLu8vzj06I0aOG9+S+m#yEp#$L +z^9YW|vCJM8vjs +zx(~aTK9hO)+(p_(U|{GyMXIT`O_b7U(-W?Tw0h=hgEn_U?2QO06e+*?NoX0$n5bp-f@Y?QYx|a3JAvw`(;?;KLp>V75At(F +z+09cO|28IMu4K;=@P2 +z8MmNd(2lf%p^ivx?yi|YfF|VNb&!{y%j{nM(jWJ0=x@xg{`{+yO;*Ljy+($!hF(Lz +z8szWj67a0k@ZQ~y9UK)`H@`n@FzLJuLya-8!A3!~;2eFpgz6$d-*4E!xgaFNhz#Vm +zxZ0M3icLa(WL@w&D2$2AwAd_#>p8c;t{7Ium|{^Cjo}Phnn0MJo$oC0v?psrinFRv +z^grTGb53EY>u@gBP~*7$GY4BvG=eRccMZ~~W$|p7L5>-FliDe;%m>zX$ub!``tgyV +zPpCs;b=a2r_y?c+UB9WzV6$&{!$>UCKc;q1L#eHj=Tg&P(0#(tr;HqFPZ%{bcbI>U +zO*BIzNZE!?4L_lKxnHsTh!f{f`zRlhIDr3Tr=lqSS^bM*0U6(tGmeE@4BdYPx8FGo +z6Z2njhyEwk{bztMV*l}r?%(=9=h4T&?@0A(p@%bmGOP_PUYc;Y5}N=lDuXJPW$|>I +zl-94ov29P7UP1-gsRf14!D9TBtT$@LRvY@J-Ik8I(H|=GQ~L8=bO5rLDeOsz$t_^k +zdfD%KD<9KJ+t?W^D@0Mr<2+A?UK(UgMg=XbwOqx7!3{kxzjZO~a>h6~WPTrJNb>%{ +zxb=?S&c4mc=M2|CWeZ?zB51gFA+2PvHA@fNh9qukf5^^=$gK6kqKq-nt{fg)5xJOK +zeS`s>s?hKV=#Ok;TJ6^zv!+(RdSPqh=hd}?Glc*`YhUcpWq0mpH9C~M8I$gFdB)|y +zI>gx!aj|t)S8)0r^k%3)cBbLA+hY({3zA1N7TrArf81|);@sYvLbSPf(oU>kb|=-o +z;uZope(TGH>;$d8r3GToF3v`9AP|`42_znO_QI=r3aN5EzfC^F`_JsyO(EnU7Y0;N +zmEDK$UZuN;2fke1=$}IO%Y=DQ3mVPsg>Fq?QJqsy_*(*@d%bh1W-?Dj?^Z4dXi{%ogsVb=IKw%JUl%gvZ$BY`aX;qokx7Ow-^W +zb8CoH!6=moJTA}1{uwaqep6A3>@Kmv=Y<7q8zgpc8rbc~QdRJ`9<8~@pMI}O4epyj +zRxCoj^3I-l$8FneuD4CA7WsZ$P~2wI8*gG)&R#$d4zcb2)+n@blY<~NfyiZvYrOvG +z)-wdqX)>mTGGqxzBr0m)`ld~Rx4I>6bjxH?$z_TI?GW+qb7%Ue__qhn)&dzHCzXUJ +z6~A&|C)GIp;$>@9eEbcq8aH2QdyxL!<(o9$w~!~zrU_I-YcSTZLn0Ju(;NSifw@v! +zj*GNEuL3Dha^KB|sc)Hek?CzrwRHaEK`ISuHj@(tIZ^@0G#t-~8ZNcJ!pSGPy*8-t +zZ!yV(U`Jm9Smx(AUtj?$p_@{I{k0Ei$gdiCRbM`sbbMP#l#O|YtKz)zCrNpA&N{EN +z-`kTw=U;{&Ok$XR%%z2wJoB+uNvQ~IXITFXh&aF2 +zImQ;i6ZHvRKb7_X0Q^7H6M@z!5q +zs@GiMgU(vSTA@vLpSZt=AbxZG5Xi|G(Q$h%^?lnxszu>IB67)iV*PPokCz#7wM-WC +zENvl+vFchnJ4d)ygyl@RSy7I(94%3wRSzB$r%GBL&C-u=?v+M_7javoR!PoV$ygz4 +z9Mb8Z9>srNDsC31Z4j9IYVt+w&}PDvIS!8$C}&tK?5Qjd(4wQ>b%cZ5Y8VuO4Ns_j +z9&tVtBtl37n|wE3u{8wKJyj)8M>)r;ZAJB-4D%CSJsutMe4I??ENDj>>?HQ*i;S+_ +z-`61ZW}as5vSk&wagM*GO-=ml#L4MCJTqN;1h^lS{+v0T;wkdH>l%I3D&5B&kV<`+ +zztm}BP!p5uM0VKu*Vu3__F+Sk3Wzi^z=xZX#Nw~B2b9M!wK({L@j22j;9EDEFRh~4 +z>!U&cSwM2*L5M2fx7KjiEM!PW<@W>spj)a%3U5ZIk_6_*ai1xEjy^}d>8VQnM&Bn_ +zql{13{b*^KPctd3#p&(*rwQ^HWi+1%v4tdt!R;V)(*koDb5KhHB8|O;73dzgJj@0) +zCf(S~j2OBu*xc1DNtvca$&xnQ95aEuj)2b$9*kZ+oK5!U>V%~;-0j?M3;W0P<(oyX +z`mh*wbWPme9Nk`D4;6ItL!odjR`FALVV6^)=GBvOpY?<)q_3ZO1=LPu7zF*c3O=ZV +z!>`4CE+*RnKK8cgGbru7wedEu$0RJg;t1CG7siOYtfYvTR2_q@@~}aJW~LE(o3zNi +zEcjiEID0SZ(AnPS>J-d0BM`tBO~C0%Y#M)GeszyCid*I%{M +zx^}h_&;9PXq5Y3$_*(_?>;ZNl7JaJQP9%1=`bxNTh=q@2MA>gCKklb|tL7)m_@Kpn +zsJG-XHrOcMqu}#qAPwn($l0xqnn%=+Le@vH@bzvM}g-ikkqRG5|*JYUU+ +za=ZPq`(`E4?;Y=Y?g|^&h6(af<*_m{F~vbvJwli!wsJ_MjEI^V`HD3?b13pb6(M%8 +zy02My1CrDj%qlvG)gg0PlwM!g*+p~R +zWgz)W*=yhe|0;M3u@VhE1BoL+%-M#$JoL-o&LYw<5SJ^))?ugN%~pAU%O(cSF4E?L +zxb#TeWazc%&Bwn@**fCCCk{_y2*_&@h*cevRSVd9tn5vr=XJjOy_d4*S0uP+hhO8a +z*uq0k?S5oR5hF+;LJh^FDbH#FLlqTy!2a5iFi=JY(9bKjOFWzqat-FN%iZ~*{Em7? +znX|5bR8Ac8hi~lK1!XvYmLa5Qhb-SZZ{-jfVbJCq_;Xm@sBqjetx?(N1=&MXmR{en +z{LH+nZx}4ew@;ycq>lh|v$fnx_>Q%>EsrfEGs89l1TVRl>W)8H@e6=ZKMK03j=g)Y +z7kgxE?H1eMIVlMG+a)q91$9t{j={~4A>blBJ;U&Vt@#D**0tCr`}I|Nnrnfb!Z5GM +zW(2>@nDpOxgyh8GURv;2vYxY@4SoM|WSHc?aOZ1`0ekaG(Ga?(vL{XKsBppjHN)nD +z2CLDual&e{ILU~wRcqe-aGQWoAVF +zso%cNyv@D9aM^v1^t0D{SAOv?6nnpp5zeu=*j9Ci3IrtyT9_S{jIJ`_S0y<(CGaaUM={-&MhidzP;{yS`W{P7p&?0r;kf{LB*b4Q(yvA +zWYj4;$se{=u}E#CyFRd0|IU|3peXo-jm6>F@RPN&h2+FbDsASUdw;+2`b>Y?t{r3a +zNeEI!URabi8E1PBA)|Y*L(?W+%sPo8x7^r%=FDdpr*a*ynDqeF{FYI-ZeNYV(VMQ5}Y*2=%|rqXJ~KF~CE{$ob+4lm2` +z)RJ~;C+!$&>#aMvtl#00SwodJ*z_%c>!h7g)&Rk(;#1hmq8Vy#aDG9|kkcWues=Gh6S1g_j8tM9v$gjoJEBnp9tUHNf-m#9 +zL{8db5qNk($!e%G#R7|aIiL~iFn!)|@iMYlBE;GkZmyRox70$uqQ2jva4rR3K^*fI +zh;ljo)~Q6Xinbz0X!LLg*pYjn-0dfU6*Zgw<6zH`2vY;$sFc+nj^bS>ZqYY{Z2QIx3M{K0l-lr<1iPJ6*9Lys6dBMCPr +zAT}F09q}gF7Mt17*{vB9+M#F3s=>*zzY{ZQPI~5RYpL$Q$6B6E)<$D;QbW=eCCXvY +z``XPihg(&?v_sgM7VxaZ373NO5pvV@X-DyU-QG{N^R?o*9y+$vb6_oAyr7QMc+K&u +zt^lpjj@rjTuIRxf;*9Z7zJrV^gl_trVU8?mjqo9`fue#K +zaKq-rfr9Vxl6Vkd3ehUye9|;K!PBs!KR=oi4<*IgjtcbFKO=0=+LrLbue3+|Hrjhl +zr^x$%2*(&|qd>z5kL7ouRWV?ZFTlK@FaPgGzYxG{fWHet`S%z6{arJ&#a$mH$rlTB +z-Z3f&Q0^?G$Oohpt(7E`I?d$TFeEnt)lG*e>$HxBNmfrJtfmA6(E)wRO{YkK$s#xT +zjm4CD#0ot$3F&uW18OZq;M$A9av6^yJ2;7mo!A>dz0<(x_JcO?=(2=I#VVs6+fR=!{-X&|_|CX2YqdCMdmIaKpNGq5C`?|KBvU#E +z`}F5eQsfPYOqk3;PUi<5K7#|UUcv4P?EZ~X-=E>?ZOiz2pT3OLt={peuW%+YSlzhN +zl<-2+u;b^%A?)AyWd}izb;p*!xe!>3xA#=nLZcb(Aj6LX6>K +z_Ld^A4+@o9Bp9oHv$I0Xae&M7yM5PQplgT$x +zu&7Q*hTNQr@sP`PmhgWeI%@htR91X#yq${z&hdgmqOX3 +zh-072<$KFoiJL=&I0SY!m(0Cci=L=jO&rpT(Vpk~5)(}`oXIf8j?@|qzwXR}!V^rM +zyj!MYfBW|Bo#E449|?EOxuzd|6ZqL)^NQoHp+zZe9-Z^4f|1!L#LII>2XJn;$^h?zWkuL6_uHc +zNuB>vT)+4@JVSC(-juR{qdkk*<%W%#fB3^?GW~F1nh4Ea>P5U?Ku*t`-jDdbSv@pe +zwD@tV-EN`oDKL_z|Iah~An7M8$Y9< +z17%*?=H;j83(`|lOCnjE$R}k1=O`s!h*@{}FT2&7<{N5u +zG8l`7e3W(^k;>%ms|1{n1|%xRRD?4^oAKgBr2Fa=gu#I&ij@((UB7$D%nc;LzC3(y +zx1T-xnpF3+k1wEG3vD!-pxkY|2pHWPpK#K3O_M!RbD<5@({hbipF`PA^$a+0 +zZ=S^xj>#=y{c@k|CX?-aj$AswQ-x#=o!o_+c|7++#$`aipdZY@mUdI1G*zHMqIRsHM +zWgzFxvg64iR=%rR1V)Of}f>xio_fxo8t902Fos&LItFq!)zwSxdRpmqLYZGDVo+i?I~i9#WxSB&nv0uNTOTU!wFsSsl%Cyt)$2`A2z;k +zE)X4?qU7_)Y5v``=JlZdBOlF48-a2d-diaeLXys0X>qqMau*t9gv-mVW6(jw^ +zd*g#m#}1CQv`_&*G)_ArFreh;;1EBb+~_VCfu)jdL{aKqadz^=;}cyO3ZwadAJe~I +z4vBZ?F_?Sb3reEo;{>}BG-6LmkR$feTvcbiT_&Jr!S~P?v|cN7oGE=(sZS +zM#uo|B`Jm24QnGaz$*NM;@xz(GH8=o5`v1`B7Ks6-i8lru+zIacY-9E#oJvC?m&?t +zS2t7iN@jvLe;^v@ea#ghDsPMZLC>ErHJn9j2-dShi&~J+arY3ieL@mXli~(VogllC +zjeb-o4^yd@8TYaGt?)B?aNkaN=5Wwy~-^JOChQaXPNpBD-wPs@-;mo?iYxvozRH+*~#{2S`mM3oGARm +z)L@p(`?l1j)Ok-MMU{@PC2x2*Y|P!m<2a%>yTZqAk#7^30@EGaQ?NhupozZrrthKI +zOroUg|F;A0;CJrfL6qz+Rwb>=Y1d7NxmIN@N_Dqu%_{3V!Prr6QdYlSkZ3%;OF6!= +z+JcdfHMBiIyBy(0zQTZN+Av@;3*g^lz>WXLk=O)vSki{CwQNJYq@Lw3@4%l;~aj8S#Yg +z7Jk;S@KY~PH!Raa5|OlJINn#rK;0igDsfXo2+kZ*lY=fA^j!xH9)(ACh-MwGvu|8! +zY$B%YVB)jM%o!eMAgUv%<2Lw6tIBKlQpAeOE2H_5Nml+f?&?$6vs*$9^w}A!i}vN< +z?x}ocyUj`wxkb>Z|HJ+s(LJB)y}s#$H092snruU~Kxi{QIef#CQyh{~yf_po +z?(XhE3KTEyQXGoA2X}WX4#5Ki3zoxw=AAR|%$X18`jD*WOIFsCoqJ#V+4sJFJrvmK +z!!6p)u;Lq25Ot!7%h0i&Hmc`KeHK69J$1+4N{QSqbS!)Bxx^GYt7>!Tt5EB)=tLLk +zv^>Rr+cQmTl`Y!zT~vPvdH$lwy>3rLfb8eQkpY#|^ODTaw}45*wa}5_R>$2uX07$u +z(R8>`Y){RQcg08>ZZmFJ{15B9`~my+-@8AgFIuai-k8p$>Zg%Z_H@}d-nhapE*H3X +zbiU9Fz1&kLs1J{hx878GxOQoOIb)#!wC-$Z)ERx2*Td`6p#BRUEt$O&q3+OT}ykDNzS~;)EDF+vft(OBEPQ`$ncu`NR~&iPHtH_ +zu`!?yV*|HKqm(xhyY}gv@+^)Ifjo;C)iP`3#%J3W*eC1x1~d?D3W?K?7N1=gR}Brs +zqB&z4v_lJD@4YPg&JnXoZV8r(7u%Z6E1#M2veQn#_(^e)cl%J-OM`ocBnL_UwN*#S +zdJxE~{CdGr`}0$`Xh#QUhTpaa?TANoRY~JRK%UL+vpJ2~V(6s|K?VJdmY*DU4mTb* +z4iS=&E$_#U{fxJTw;sSiAhyPM@nuS +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 +zUi}UDeXXi9>8~E4XaX~ +zPzk$;+;T4o^i1ksIudSFRF7axj1Ec +z89HC1hnM{%k)w|k>tl#63j^RAI?GK#`%!H2r6)tnDfdzcsDvmVW@2kIRZ)DuVXMdd +zRFt&mER(l@qYa#+42R(N2yH+dNa+A#Qt~5?({WAgzf7y_6&S-PjfTZ?e5h}7w)A)^ +z*n9ZWcunm#c6-K+zL0kK8&U3?6NDmReo?yzN&LI|)&jB~5wb8yyRhc+81K7f72H)m;SOE(hQK;92L!+{@^vkEr>LLbbyLYz7NV>pZ%2p)ejrzxPI1tF!!kxu +z;=l&8STWnEt}HcnJ=-jZJdjXX>ZwQI+Gw6@ZYE+Pu7{9Y8h|(M<_~pe!@Mxx7_|zU +z6pap+t4&l2cWU=j+=~p-4z1C5Ok$q9`cDcLUPVwgN&+W^i@eH+pE&&3_`u9GELiO*deZSkY +zm=@sH9{Tq9oD>SqLo=!bVLi))?Y(pNuD&FD)_k+~AvV%%p%8Vk+7XMezmJQel%-T>#j8~I(uOTa|Z{7zt@Ky +zABl6+PLQj9|0Bc3_qz%s&8Km<2JfDwG(xMsH8}tkKeC%Y4Xhx67AlBfgM$R4~&+Ze%?74pEuFY6MZ<48?vv +z=`T*BWEqK9wPaSiun8PuDHm}L?03#v1$90FtCe|oGz?Z~{3x`&)te^w!X1gBlk9}QDQG6k*>W}GbnOUkzMt;P9!9iBGr>iy&bjm=ZAW%k>U{vi%E>J%h>%C +zY`Hs&%p%mFB~niGSQ$>9kCJlx7QQ(TsEP#!p9LdRcGF`_#Wv&mY6&GMzrm}LHMy`Z +z7f6`fz63B4^-Q4SRq0^4J;aex(>$MEIwD7`PyV~A_;Mx?*|its5k*PY{Td5Rr#)a; +zA2;`ejgEciIwA!+CgW38vvbmClSL2oJRU~_q`+keytnDq*F1;9z*$!>RZ7-wX?Q|> +zYxFkYk1Y_zYm`C9lSp0gQ=+~ned!yfp-Pi8gk6sC!=| +z@U+f!hhp;;0o-BcCu;L^+RDsS_870}Ew3=X2YC!4@?p^vob_NS=)<;o4b&gM{anxY +z$pjQ2W$wPsu|&LaC5S_x36i^zGT<0H&ebQOM1bb8ync+L#5^}B>4^}AY@avI-JYAD +z@+0aggeq%SKktq;;8@slh&e^FSBJ-ca1$ +zbA4}3HdQujGzA%FM^vb{)k3b0*;nDG#=Ep|q4A;WW649G_4!ic+m&W!r}c8D)OaxC +z0kWhuja`K=B3^>o`MAxs09R-_<$SN6y&_X}I2^FC@!0CR>h%S=bKmRye~38`LF893fP5|o$tR?U>Na&h~V^QuWx1kkubC?IT2Uu0tiOva0aW7)k{`y +zbX}GbyE1dS2pfVZ)+`0deqDcyY!8j1Nl+Vkv(Z8wKU( +z4FETHap$WIO7F?ekc6yK-UWm(MOS@9BUjOEyD6h+uNhZ?67k$aNr&X{7bWrY7T0CC +z>bhnOwIxQMcdpQb&Z=elA}zz_wPL_|nzR;#o}wj2mNflr<=H>k;&%HMxBMXdsU&j2 +z^s=Fb{eP)2hxwVYs1l`+RS#tPH@QNr^1^5tQJ9O~eEU@m%TKMYjt}4t1-tY1rC1wt +zyH`p&R^O_o^Pef7-%ZC7)4t{B&70sK>Tg*Si_YTZeWiuD0S@m+s$*1Iqq~^n5~MOV +zt(NWS_2_RGveKn#z{Jy*3#o~hbDfUsxWo!}%MTGj2s%AQuFvpKPlJp}d#ET#oyxeN +zt<~GDVQ>2u?H4lB>7KIWxFttbNjJpZ$A57R&=J~WB_-{&$Z%e0a)nT{(v`nvbLjba +zQ0$Ted%>Ht&)+h7B(h{T!m7Q0|32sU+V9GpOW%@-3j$ldzG-(Vl1zZVeITu&Jw8gM +zC8y|H^fmf6x-24sy4}uvN4Vh~b}&U8lub}p?4=L-R$tfXxocs?3xWxMuY@0$EV5T< +zErFH=%dculs$P{u<@B}hgp$n%p2Wy(cx=w$%T)R=eE;d^(-CW^c(L(wmfc~iAnd_L +zUY}wS&Bx!7Jp9U_b9^*-RYo*?5POJXyW7+jkbo+M+BdS9egnpEi1XHTpFNHJ8sP#?TI*F +z1kwBHO(GC`2M;f;SYRekAla)Q;Qiw~E_-{P3f#mSVK0ce%5h8W*X!34{Kp6o;?vUu +zp9b`N2=MUdh#$-QWc^d8Z)J1A?d-@XHI+*HCgN;Yk=Re$MaOm*6zX{{W&IQ+3n~?7 +zJL11X#@%1IS@vsYA=KkJLYIWCWS851zZ!PdAJ%bU5WbT4MFhT&xoNfX?V*AmF(dBh +z%ZW{?G%VubQ^zt2;EN)J;Z<$(=<+kUc#87@Ds!dVbFsqi190xibvO|^6vlEMMjP*B +zOh=lyl8qj1t3JKc5LpNn*d;eRQ(Ldr2iy4h6)v=#ja@yG?4>uVLGR6>!Vvm`veBMr +z%hcloBer4-FzkTemg;IEo^fyyr_YJa!aDVzdOBWcANqo56}_r&U(&84LjF@CxX4~H +z%8m=uQ}G#l3IR@7EoV2Ln>KZ1v2uLzDEy_z +zT}m-$Ss;?xTKCQ#${FophYryED7W#A1LFlNVG0XUo~U7{0b%Qf1%}t~w^z~KM9a{4 +z>71tDZJ^6NnJ`7Xg4^;LO#&gB~Yfi9a*#(_zstEWEfXO3`%Up +zt0L+$90B%IKE$`5Wtv}-)6xj7*KMM#}TVV +zBDu1Sx?2LkA8p-8ZADJE@%aN|bJ+cwilQnP?oUcqU`Z-0d7yPBKTulcX0X`tl|X(e +z%*-lCd_aoa=Ls*?{!$eX%;-*V|fbRT6y>Fc=sEL +z?67C5@~Hiv<9^-ipE~l{>nEuj4o9=_1%Z`Br`DA9FtvEHt*A +z+DP2O_vEk(ryp2}Kw9(T@B<8J#{+#`;BABx6Z;8l<34o@53)Raz9~I^HT}b2Pw}wC +znCG8XcAEQuvdZFVK##R~Frx7hc9q)WcOk%jCu1|hJn~d{HXD4i&V#&eW42+%hkM&< +zzse4)?n-Y^B7dG-{!5ac^&3*k^=uy-C5jj^KA`N*WCpIi`{EA3n%Rx3Vk0SJff*YE +zV{R4#%}^4^HX;nBjeGNxl)JeO{2N9MMOT746Y%u5nqBVE^+-+I74(qh*8MAe0`X%_ +zCSzTYd-96v$$tK?OYimpL5KG>*bz@Z*S?(2fHqW(}#!pZXPR^O?Vshgbz5iejAEii@^gr +zKlZUF)ufCl$e8ABZ#T{X!mwqjC-l%-dhqfQ%Z-RM-~KvKYov-JF>0R6 +z=Y3*k)b>|T(P(N2V)3h~d%@j4w!`V40am8xWsKqF2WfhGH~mDbyAuI@9~4(<9aMsW@rx^QPnOSrFlSp%rygSzpgjV!&|+N +zyXl?26Axtj-bz{Xm=)Aa`5|jtQHO}2?5UNHR4G2X&TT(dik(YT%|o7c`Jd|fE1FEz +zt~nf3Ol${x4gg+s567nw*~6x5SpB!=_WrnQ-+hq7lY7sv+J&r7Q`w2^U!*Qf&&??! +z>cV6zC%ocQoTNYfOLAxzg&_j?Hjz{aL5O(x1m6xD={cJ!8OCch^E0Y<@WBiey-Y}SizM@2RT52nj&x+<=sAA0X#e@xhY{5m^%da&1dD4Fp +zO{QHPKJELJyemYXlg0o_6UCygZp9qSy8R#t+iH`jTBnyr}c| +zvZL8d^n$o*{BB&zKvSx!x&hV}M%>{vRUJ~Zye +zrZF3&z(6*rP`;S?5m5j!|G; +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 +zAPB}n4JL^$K58bZ*7Zxfw)wV(J%25A +zXJQ@wWjMA?avS{0I|T%7n)rR;o^vj6txcvVP;AJtrCohI*tZI{`2_3G9`W3EKCT_{ +z6kANPzyGqksJr_k6-o_6>$0@$h*nv%$h`eQm8Fap`Q{9eeb}k1Nx| +zfQQvd=h2ncLoo;K8N=JXJmyp>cff^bsiiT?vfBgnn||`4c6G;CUO`W73Ud)q?}9&) +zsr8b9t#-~VJq2DxH^SnnXVBJ0fMDFDbTr3}vRX!4{PLP=SEz{HU +zN&ZLhEcGVMs5`yvd1J-ds&^02aCLPh-f|fvZuFCJcqLCG)6Z|DHY*I>O*~Lah>1@C +zmdK$2=Tj0Eg5!2FP3`qoUn~n^QRrD3Tq=3aiWAjwzDYcykPIe-@+j0>V4#i=z|xh& +zrufJCLw~FDzXry$2y@ovzlcF(C>Bo6XKhVKMJL4Sm1MZesC{1lkVNv_O3OLD&n-DD +zpaU>;S-chwEN1L#LPF3FdDg^~)D97jlS}rHc$^r%ZDX7<>8+Dv;=W1~P9xw@@0I9L +zN*QS)j6K}pj@3O!I54EXV;6yNOoqX@l_&(6dR>PxUA95z!>c|>i{?R^zH^D@my!Dq +zpBYh=-Y^zYnX!JkL%RR)5rtcnH1hM8^e89BU-l?$KMZq8MR7P&7^+arfS$burYN~{ +z$YCVE2wyb&B#6#%0Frd*8nGq9UjVuQBpNAn3Gckaa};HWsWX4{tI}YZnRb$L%+Wet +zsrL6)#$3ndSW16?^MR)_;&ELTAX*o#oX6FNh6LPj3%O2KRUM;0ubz_szvgfZ`YVLl +zKXW+rmEZ#(QHSHN?Dcu0RLDu&S#b9ssjW@WoRO2F9w*3rb1pNCa$RQi=>CQc)Y8AF +zaq6nwdTkK-IIUcLVXtVeC!z-MyQi%_GFQx`S2h+bnNE#hwlwXJK6*RN4|;lAJv{TVXOq^muKR39 +zuOyF5@&1$G`A_0+%saa9<{Q2HLz-X4*ODJA2U8goN;+NyEx+|11LjzHf5P^=(4XQg +zoDzJu6Jg|X=tS%SAouRMu}HXsHqk +zC_qKgdUPYJD?*?$6Hn5f7oFFzi_@MoB-P2T#tlPi$<4>*eb4GgVt^bDyyjj +zDjyzNh=>8jmQS5ODBAuz*%uu^#h}Ai^5s{M`*1$RhEu74v@qZWO~ILxptn!6*2$2f +zpr*>fJ73hy%p%SE{Q8EF{K-feB8cao%n9{)b|i^YRTa!^V-C{w^0dp>D*19abP$u5 +z0-CCJsDI9tW$x&jTwK&Y63er3F)Z)MIE$w2)H2~9Gai;ED?d=+U$F*@V_;-_M5!*V +z#A{=|+NG$IFS#Sp%yhJI#Ou5gKnwam?jYhiv~_H8x}=?wb^f7$>9lMZrg*Tx@4Ph& +z0dXLL(rEr(d8_u%p`^@fYhPFPG#s}=ga;nlrbZ`#t4+Oq@Yzey)&2(+zw*-IhkRY6UA+skk# +z9VIFZN{YT+Yy72!1XQD8D$X;7BZIbF@pl3me!lj-tJcHP%HQB(-x6yF907+J#&gsR +z0{nwK{`j&vW8=L}qy$0XwAco5j#QKpGUme|6$(7zX2Jw<27!$hfw-PPHqsY9lCI%3 +zXgMY7D3u03{dLzQoJ`&!UYZwwxa8jzXJq|fQQ`5p@F(K`cMQJ_FwpP(`P`1bKn1q5 +zIhbAJ-gym-Mj$Ho5MZ;D2lvJ7_2p;k${r91k(GKxyFY?VLdP=KuJt`v(T+7LUBQrH +zzl%PgA%vz#9dy469kUPw4fxzHnbrX%!`Tfof#GQUPnpQ;>@EK4>3;T>mJ>!cur=^~ +zgaq-VhfsO){v^g04i2NKYW3sD4Kc3scl6&0w(O4`FITz+Ms9`6KMfGsSXZM2d1Az5 +zEzQA`aapznWtM&?Wb(HQLAT8H{1Qe2A(|m5_wJ96c?*?UJ#ehVtqi}IL^l<=zFm8g +zKGQA-pI%XJp?mB-QQ?9_Z0v~@rD2M37E_8CM~;SMC=i0phM9FFY+}ZzP7Ve82qhPE +zp5ryj#c7|{Ij!+k>0azDKsQ&znH;oL$RTq*ihj>~_1l6IS!;8aF_i+Od0h45mfx=3 +z7f%u85&GrT@9W1kid>xy=g5nm$dWz#9?6-m+i+JT6oFgKEU&0S@mPl?$k}}3A;r_x +z2_=uMf@s_Fr?!G|8k8+tS1L*MTaG{%l?^&K2T?u#p?MaI%djwwwTofTDZYA +zXQ9}u*=ZWTir+U;u!QJ36HZtYs6|aJ2{L8v&0Z0Y+hUIZF+}X3HyaMdb;hM?eaN)uQ>8m)&_xZ9wO)+ +zo@CV)^wZ|Y;ML8XMOVBH-hVy$GS5-hk@M7_k8Pq~%S6U6$ZWSud#5|j4AgR=6h)mQ +zv7>gyMp(#wJ3a_7l`h)|U4Kv6P~F=Ts`2;}3PSQdD9JbhcSoP9}IT~T?N5Ht +z2^Vku@cmot<=aEq`5bKv%g!LYiIp5eFMBQ=XOp@OhqOKti3bCl*+n#Cl9ocn!sVFy +z=1*B#@B8^paY07NvRmOy0_Cb{Dks}tpV$>u^f)Ljy$-Cbg*z#*I|j&u`EVY&amMOM +zEX3GGJih&&>{|4owN@dX+4&Ip0omDr)VS*!-{It=cWgf|H78_I#`1&+r +zV&2xUHHWqx#N6fc{+B6-QPQY(>41fq;@;doP+@>Y42%r7rjM`;RyV9SWBHgT)t?d9 +zYN)q&C}!uvOR$@q#~Q2ABmvGF +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 +z5&w3rM1hqOhCs~J`t2+}q|S<J{`291x(xKt; +zg(Kq3D=bl=@5lN6w*!b51vAKH#4?v=KR269SH$9MYyr>5@MpQ-B{MN_!3g1NV>*J$ +z+72fR3Y|#sHT}y+$N9jzuz_j`eMy0Ey|))xF*!Un-=KMF9@2F2{3-Gpj%d+030E<$lwDNhV7Co}+w>LQIzOWH7KN?f +z@z)K|rkr{WEuG2PeOED@fmDsmzeeNo4YpW(vYD6zXO;XmHFV=^+s~i?*nIusZ6SPs +zxkERg1qc7E%NGNS=AS2`ye9+@9sg4U&r#S{jyB}J-8z)lYtp}@X1-I +zSSaI&I)49~s2yaJOMwm7sm=9hq$z$4mfBB5?dmXjgN@NT^zDpA`s55d*40p{ZpexjUHW9yY^md&b9ZRliM#y{Wfelx~CDhR!k)y!T1bL1pW7_=$| +zC$WvA_@O2b#&9q7y>QKeCQ;6VO~#MhCbj`M*rUp<%MB +z1{~K2ygCPCD_Ch_BkXhHEE-jsZd0sfO-5Fbc<_M*gnBcSn~ +z+)X24YSbaTgq8)axJC6_V^9RMX>2_zIQH+>AJTv^FX~g7^3NH%e7f>a|2bBm$j#9E +z5v?g6y5t*8C`5L&;SsA!^L)+UTq?kPOKa6<plu&X>hS&Bk?1;o06mnb +zw3T@-X>8x`n<8O-(4g3o1eHa#Czz0_WY4jZxTzv_@^o6j!6;ER8H0H6on&9z8F96`{jO!=aItx{5|a$2?0sd}w`}+6@25o98fu|OxoiGVUg{l!kgJkWh=Twc +zM{6Ve{U&wxR-NhUZwGr?J2-bCY}Yr-Ik0n-B;!DPlPg$1ayK6CCEG(#em75{76_{} +zy{EI402MoWXX&3w``U4FNr#v(qQEEy|7718MHpiC#BgaX!PciKmPRig`_0?D?|UWL +z8t~3~9WnFod}~ANN0=xVcW`RcLejJ#yDHaE>rL^~!L(e7#e4cbGYQ+Gj9~mxEUl%^ +zip+g_A-9wM;I_Nv(K;6>ZrP|>b^dl+;Kk!-9_4|Rc$`e+RlbuAJxg`%t#YTx +z>#b-b5K!oI)Ot*wHeA`Ysx_7H$K +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 +z%F_@4;bI+Pv@H1_Q_iOw(4X}VIivngd0oU( +z_67p&d3|60XlbFx)1zOw^(9hZ+FZ6mx91JG3Z`-o>W}`+*KPVZ$RSqHXK?(?<#Xzu +zE`xWFZU1P&uvtyEDor2R#ZB?X?UP*PqH@d(b@LtGC0Az12G;@VIeP^>utpHvHH{#D-sn%%N +zoq`4?w8{E|U*kmfePkO6OBU4)XQvmFD;GH7Sh{V6R}b%fF5gFo3^7dS8FciLcAH)p?yZfy}ewUU2OC0_Xwi +zvN5_>b-2<8RDCn{^=CApbcHPMhwFU=`d;g@eKLvhVV-&rc-?0+wbv*qv=|B62H7GUj5)>tj0_i7Vg|96@Wax%_cgsbOsrJ@h-z#C=U%l4LP5O&=h% +z3YLaO;}%Uh`@hP!X@yH!UJigNjEGW4Wn8CqR?U*eXQ4O#p{$!7Li?$2^}uQDLItve +zAp5h^1csiQ)(lH#ohgCJ%cd04x~oLo1tF;=e&)Sul3pBCq}L~`(Wwsiz0BxJ6=BbP +zvUkaCmcr!H +zc)9jZr@(3BKnhu@<8bt7`AQBgE^SiN2JnoMU@p;Z*riPzI1idx2TJw%r?FrXC<6Lq3Fz`bxN@>wgx2FjlOHA}f{FT>^%d{kn;ka!>h&LL1NXQ)8@~rS;wP)k@CE)NKj)s`iH;z3!e$7Xt +z+j73>IK*XcVr+0fMVYG=z{O0%uX-j={mf+d#jGAD1k)QR(DVV-dFilaR#z$4N%fu7E0IL~6x +zRxc^)Q8-?Okhv2D_u_vGj +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 +zni7j{ngMCo0S-2uG4NBcyePoz~MY$G0RSu63M +zksjNFq*YnsK2oLgSg*Fj`C9Oe>2EQh{agJ+_9w|`Z>O_=l1V$`_zDq9V&->k^*e-QLUMN`w;npaFO#0NVrqM}a??=T3>- +z+ySpD#V+g%*Zwlu1TE$z)|*6LzsDFRn}PmD+?VNFq(vwgft+i=@zE`_ybsJLHpQuI +z`^sjNMP*`|NB!XZFoF9VwXpqSv$#YS)V^|FCGJK3+um%H8h)jG*tL{+CAJ6y=Br`EibQ1DGFHlBr!6YR& +z@o7XXBiFrt&vpJb^nV)Zzxjs8n=ze7WR~c9hjo36s7UF2KH#E8R+@ceDh}Z575B}w +z38t|*1=X9O32Ys%!*aXbx#rt$+8T*LvM-$B#yoIy-iD3_gVQ&)t{+!+1A@*Upm+10 +zbx%Is=l;^>W!})otdWz1N>B*=q?hCbiQ$g!9hb{@UtyX|X}^HGPGk6qe|)1645Yk* +z=lP*LSe)j0FA&Itu5m#F>M0kaiNr!3)h6!?v$>P}@wj@;=!fpVQ^h=KFsT^#KWVaF5f=stp#@O!w%qt6Sulm16j&{dR09Hec9j@5+nT>?Ho=hmv +z+ze-yt0QoRoL9*7^1AME7E*R~j{^vS}Q +z(jYn6h;rA&aJj5rZtit+PX1-e#_d$?J^CEfTkCFo#E`8d0|&Oa>)0yY{Hqr3iT(Na +z{+?b0zUSKiMZM`3ee&kR+7oNF~XL5*b +zHhR(7ppX!1N}-!k0M(z|JdByu9c;LaNTczBumY?_p( +zs(M63T<(Op4M60-7{Py+68?RnDEA9#`hQ<|{=~E|1v8Pz@Vewa-})BW(2xN%T#%ao +z#@=?IS3C$(aEHwGM>x5j#`zVc+#(NZH2mk}uYo?J1%?N=ydmDuD)ByjxF9bBr0*60 +zc9{_Km_+g!*}1NJBD*~3T@DlJwCk_3{zVoiUvI!Xc-^v9F3LXj)rSTTbQ5`_8>-9` +zNf`lK>_8ePyWXxBYjKxw5`yk?2Fu`ZokMWxK16HdDtzp-tp-b=Wm^{Q4u;n2A_YgZ +z^FA|l2J>HiX0?|)*}VRo#=3szwl5bS$NA_xL>D;ZhFZMjq0O$6xL@Cl)goDta%bma+(UpI&%6Ef_2 +z9FT^n`K7hi5G;Lc=lDCG>-r}yq4L&kyasvEK(#r;k$T=yYNoUCbbl@BVMsqjL*RPm +zzOD_Q(sbT9FoG{-``;QNhVCj3sACF1y+04jzESxHSB4%g2%K`Bz~FV_qKlmElN24^ +zU%D_grR}YE_%n!BqOR!seCcIExff;gp{z=Is~kz7Z)~o9DlQY=)Y^J^|1KB*Wf?Qt +zt*>i-f@Q?%>=t{SgL~XhhwezTGa+aB{v&;5t$!9+GQ3*@E?41Y)L1ohw=O&_s_XYL +z6!*QNdPx3{Hwm~5$VPSN>GF;q(UnK#jjPs)(6nPpE8wt^u2;`dZ>Fr1Bkk<0sxkj7Nt+fTru4{tT_okhGxjp(d)1B7@UEika#Lf!}snoQ~Tbs%UmZhqf +zzz}J~yx|;zQ+jh4r?V{kN~%R%iVHz2E30Id{5F9VqK$;0PkNW{Ngfk~mp1%u +z5+%DyQwVvlG}AHGL^K^2{t<2!c#XBDBqA{wk=y&|UYA?wq+rI|+wx`D0Gq{Yn8(p* +z(iZ6I%J?!beeSaBIy8FQFY&h}!)NxH%P0o!AjkKF1RCkD2nx+=T~ih?j`bxe~lTjPrx6Zf$m)HprqOn$k=g4(|ywHDU^`h4bXCVi}&8p +zRxVa{FmTAB8%O;JJ}hlT|A1_OpUwD?Sr@^%-Ni&Zm{cRTgi8rO5EIvL5cqp}4aVXF +z(V6z%eMgT=BlHrG){j+NICLNs7^Yf{QVWRwYlA1BGAbyYSgatKoBGiy5*>$-1#dge +z%ny?^Piz|g@XM#r6Cw^r%*2yuJdvw-`kong9asGd_9=wGpJZ5-eteWizOreFiQ}@% +zNoORnoBwF=%1lXw!2%pFIv4B~?Ny~d0rvZ2X)`r8{J+&>^p>?X+8xN>C%ce4#h3Aj +zUvb-{HCWeR#i)B3h@QN$`}*_ktKzcPimr#k!ET=WKYd}!Zxw%~I;3uR6zj*0riRbh +zFPO6#zTt7G4v@+(?mwhcY40Z%R-ISQizJ--QRXZ^TM-y1=gJYSn>;d@M98)W-Ks~& +z>loiUlx5L2M3>gP_<+-W@f!23yA(Fhv$aC1{HrOv03W$4T2EnSxvyDVes=;^pWg+{ +zLP>~AQ2B8k%GpyD%)-24GY1_d6jbUX>?!keaHX&gKjWWN*jb7+@aymhqv;R1dv!16 +zK)Ec3Pv6*z!C6iIO3?%SC>`vU@>3s>-|)p7HTV +z4qX-aLMHuuX&MT$N6JE)n?YZTkO^^9lHeHzz|H#=+jr~J?w4bH{QJFlxU)rA?zdR# +zP8;hg$GAcM3dmr@!Fb_QM~Cd$6~-|bK5If3j#nmKC3`(h;U`;HUnkQ%jI0v_-+HY% +z{6c05+}!2A=Y^%-qgG@GBUI_ag>E0CmH>S|yI4yu%}~3xXg1L^s!A4qosCgYpw4F6 +z={rz%xMuAO*xmPS0Btt>jO|Rcmd{7xDx-U|0%y1D=FAA(>c3ba-7^+A7|xp*4zJO$ +z)+o5i8lQ3{>bWB;;`7l9L9&uSXTz54-Pu(TQWlYllKtUiwx~S1wH<@b^jn2lAoQ2QsD+z +z8Jk)G-smFgl!2}x*14{L?xVpN4-?GP-y#gcH!=Ybc}qy9DTn9ItTt~DKg99MmHbRF +zJ7D)-i`TJ1v^G>f7o1Js#(Eu2Z_(r=!3?MSyd;ri<72G?>Vjis1@hAO~3dPTGcRuOcmp?TdKhZM6s>*r>I80MZBuP}>` +z0aj9r*kra;=qnY<-#)mnpi>|AsWgwdt2X;s1^oO|^@dP({lW09Y>)3rsR{z)(Tb#@ +zqHN|Zw{*|VM=g7ZYM1X1lZuZp;WnoFV)fxLCRpGyksevN5La*q|m@ui6Oj7O29^yHDaPcaXvV7vdfq22>U{| +zo|W}7N7=5BxxTf*BqB0pBMZ?S=j~HPN!lJ*f?sbX&H%lU%1V +z7uvYe9$d)(@YO=fjUq$A(MmKb+4M^*U;GYOo*wCn4#&D*7%u59oq#ATFYZM7lc}fs +z?dy7LrNNqZny&fX*YKIuGvh${B7%lc#pFjoxu5E{bpuxo?M>Ya?<`Y1|;cbJ&tzK-*v!l7?^JPLZmhS +z4!LbxZkiqRAo1|DsNqn1GKF>#wCxGIzfp>lKH6WeSi-*eIfe3##5Mm_`tO5RBCRrk +z*&8Y1D4dCkJO98yL~d`l(YXy)-Ebl%1<1-yZ^CiuRfEE}K1pg+UOD>mX?ath2myL7 +zA_DHN3|BSu`Leg}aS9vfT*n{pQtlbsrx8KnHP*a5v@&N4lc}J!^uU#=#~|3koz{M% +zRET5y^hnOC)>J2R<}xjs+o;$bT5Z96$L7@No*>}9-oM}xrHlO^=Z>3m{jN*TY4$*q +z^~`j$g$&xRjKzbik%i2z4<7|Yavmo9+ZD}1N9U5XKXfKz_n5!X&y<~db4Twj4VYHiT=$D$`V~E(KR?F#a +zaaNTnUt|IKTnWXeLyMN$ES#PZB5KYm`&)){0aa3X8jyc&Ih4 +zyG0}HgIBI$3-8PG2s7TZ9HN-G29W=m{4QUP^Ul~)IEZjb6xJUb%OB<@1;ma!x6fj^ +zj@*8I%*sZm74$*DZV%P(oFBa=_D`WLBY6LCbdE6{ODXzgPQ=U8myqt_ai*mTbx)kB +z@7C|tQu5>z1r_G5PnB$*d>irfaioayQ05mOgATLNhW!pKg*#Nnl1j#77zgzDpf6Gt +z*$!V%hlg(rOD7zppK?Kk@F1!?Uts-;5g1bWmBh!)Nq+$z~){C1hE+pEa~x +z{5Fo_`$1GDT1m=8YJ}BTZ;iL2jAxn>dWD5eb_o9==Kjtg=A<0a8o5Ossfv-uK|Mjd +z`B9h^Hf8fsyIECNPWz>)v_keR3GUn+nxNTCI@8+_7bN92iAMqGHuJLYYRT{Ty;%&(Fx8NizS_{}x(?dDO`5-ZFq+Xe +z?Kv2xxO884IeP<6-a|snLU>UL%6seY7AKJu8{Q|_N%L2$V$m*}a^fLFzep*}=yvc; +zIN@|uDi<#q80h%;msb9`9Q)rLC$pJ!*5}ssrBB>D9`f-)(R--x;p9ARCOo}~N?ake +zM!7Js_3RHir{Icjb$!Pt@4jh`>wvFcBX%BnRw0_!yeGx$U%Wa4@9wcYB_FP?b;)UN +zjxQmHc2ApvvLgbNxgE2j*$oEbQoAR)6Lnp88|{AABvtITg}v1$Au3(DTs61Q~sQeQ0qXG)v~s>T?mQk=IU@mugg!WD_p>Gh&89$tKf8%x+V?!!^y7!p|mi?jB0+VsyV_ +znw+rCk53A!yFo~=`3@Tv_|IX)vADi1oiMe~pueq(0$B$?(QYUgdV@bI>D8L&D# +zlXE&F(%sILv^~lp(_d9>=zlh>x!gSOTj$;B;yJTnbi1|fTkiMuN3c2wr*%0ImfQ3c +z*j6D3@a7WD?u7$sjXqf@|GEho>3!t}$B?e)9&3#LXXD;}kVR@dQh=sRq22rd5J5|) +zP+B4#4GfY+1h%#M-*pk#UJ}%BX#SljX7s_^=t|!ro4}S3`ddNA7W%v~IQSb&N*IlNogE`zjGYmT@fXegch90;|0tB~+(|mZ`~Ja|Elx?n +zP*SrnwF@(O3*GrI4ya<&IyO9qU0J-?AD$xZa>DL&k_S4536z&m@7E8b!*zL>NU`<# +z(=F&d^D9Zn3v?VfJ>4r`n_;HEBikWL!*@!jd0}vg9qtI6QngD;efsCr;mCXD!_WX~ +zg$zfWDk?@qUpct_>j$23^#6UfZDvrGSf|NCxGDR{L +z)T=M(n@Lh`aOrsJW(>kC_Z94f@dX}G2Tf^%32=^O=l2o^X)nfVe-Kf~51lfKFhmew +zbK|7Q4eP{o*oTBw6F_B9t^>Hg7*OHEd~L^A|45;?6m(JwR1$3tl6u@Qgk^RVq?}T{}80 +zc$4PfV4@T;y{BM7rOjE=z$LUP7o`NvMyGg|+GAA)Ncq}1%(ijbe2v|Z;G{^JPNcn- +zYh@uZ>ty2m+WFE&I+uz`8Jpzhk7p?hQN_%$%2zZzRB4ez{qV0QMKrWTBHLaE_d{aM +z8=Y79Dc(}xwUT$?wxus$gE4rh(Hi9PCSg*-In~i$I&1{qCrQec4E&`eid|ruRIr@C +z^{1i}{n|+=*83GRrJ4v`2SXr2*arWHm%NtfNGcgeP$ZjZM4?>)9*?KsFS9$zuL@h+ +zs6+~CYO5dDH4u>v99g@)wkbXaiz?~D3lOOJT@F-d_n$4cm>EDBmM)A= +z8o5Yjd|3jgzfnB6!X;X%DQ%~}SWHGto$3b}aY}^pdDIP +z3^%%;wC%GhpbYCFk+6ms=KrQX7bIAw3_!F&pAe|Qw+FMvxf1}-x;iSSmCK%MHBnpM +z&;v$O>G_1ubvDTTpmmBv&jCJJ!*Pc5d#O-M +zkD^Gt*U_cf>3!da-Jb7;)z0(e4_AC0Z8?)vr8&KJU%+Ap9|rRBZ6F$SDz0*UWi6lo +zFUum^ABF9IPg3sxs>UM +zfIDM_%9|&a1V&}N5nne~Xyfi%Y#oMm`gcRQy12|j#@oQ(;{2EurUv{$@;BCLo?8@^ +z!D1l)QWP0_-=f}Iy6+!~cQqB6OLnzxywiFIinHl|_Q`+1Lf`9enXT{nh)Knia!o(G +zF3dTT>fApRvlsXwR`iDm6=7HACK43Gc!ejb8LQ +z8vVge^ljxEJI4G-FC36WPa|F)f6pjSRT098y>7`gs~tNnXtgItLiWQw05aT|JVqoB +zEO~gZX%Vf8nwLcl^Bb3VYW_hdUBkRQf?hkpY=APuL%prTT(|ayyOH8g#7O@vo{sIg +zL#hXv*NCi{W-+|Tv(rusBw~O)Pxcdv%L->)ovjwh8GgCVG1fJh%SCv^`f4YB4BZ~@ +z51QzHbc1{KZBwnDz$AKdJL+_~8KII=VS@0BG#BcIds40U$@^!Az4%&QD?^N)*fsQV +z1-Jz~VQgxr@n_3eJFUO|ldOgQi>w_Q_8}OQvs*oDFHNNTbmNmBn;^(VS=BskV4LA+ +zR`)r}(_IBcPbU@fA@MZZOFqZvWN*h)dOJ$d#1h$^^{db`c?jhDSmeoYuxm0puuxKl +zFbVFpRvJ2MSrT6{gq +z%Fs0?K2DK+@`XTFR3J0zG{zVxas~+nm_FwB7z9*g7hLur;By_Cx7ux?j^}fglgpMEdi}*>z1|p0X&EJiq__rtD4%{6SV54Hw1Z4>OQtLsg=6iWmGFtbOn!7 +z_Vti_d1B5S30hZ+8f~!NePma@Zvm6`bl*v8`Waqo;TFQyYxzPROpvhZ+Jeg_$ZrED +z=BaF<&da_{FAdIbGS|UB?b@d{L%wKdjY577rY;5C4z4fz7CzmSEIHj=^oUyHwXJ0h +zkKYpiZe90QEQNdtUi@zhYvd==TC^U%M$nvtQr+C27B7@|^LK`P3K&{pz9?9Catpj) +z!;C*@n7|vFska}RXYJhHf9Ic#Ot}bzE+*}9pH>y5Sy)1%1QmV)0fkq!+K>{aH>HQO +z?#=izJ`=1c4xdPiQRGWEh!Dnfqgsw+s+oZ=D%O&h9|2O`37f|M@oeORE@E=6U +z9V=1fPXBz0wbRe81)cxQQHZc4WGIyE1PMNz^*Q;yLj$;vJOclCbiM$Gb_`1a1g?0- +zk$jmBZ6e77xJx?I$b(?lJDDrgjK60Kk7->Fi$xrPx9!RZ*@5fHQqaow5#JTmE`{QG +zHZ!azh_<0GnJ-|qC<6q_kM?~LdKx(W|FHFyacu|Nw#A`XTUvrsO7Y_EE$&h%?o!-c +zgHzny9g4fVySr=f;6aneIrpA-&VBdIhri^Pe3|T-wf35swRvNr$gBJHEG&)|-J*^) +z?RA6`JfTX`r0&1n&BY{CyAS|5VO}I8>{6K9sPPz28KO&qYX`W0#l93>G6xo{z0`N@X4PWZDol{K-`m +z2G`FI&uL3nVPX6phFgnCJe|&vE9IhUfm=p1S&U1kR+z;EB+-F9lf9%G#GTcC2rBtD +zWK^3rs^$4WC!Hzd?Nvja&5 +z4Cnlg@59j@Z75Zf@tV(K^A@%fa4$koRz|1LX%7kIM9|sc7`NQ9LLKOO=prnA5M%|! +z&{ry>d^3*5FMEh>eXoO%4bz1Ne(g0oOrUin-f?Mbypgz1KE@dEtN*Uai{9-kMg{K< +ze>%%y-4ph>9pvVb?V}7%nFG3=H +z6ulI+j0#`jIfi)%bYfeofc{MVf0z#?RoSy5i%hX_Ln*#`_;hr +zY;!$4;z=l^p$tJ+-r-t}r;EW}pW=U%F=r<_UVb#y9IGQWm%f;X=_>wbyDW-ofmIg& +zXImnj+J?byG9|75k=yEHkU(2{w4u)?k-!kQ+nMC^jkZ|bxXzQtfR+4(BlkWzUUr#a)tW8C$0awRbqD; +zFTOLF021P+tDq!SU-;J*#SvwFf=Odi->0yvJH#@W-axWXi*3b+ +znB9rrzZ*Y`3>^u#GI)bA4{`4&{{PMduyWY$b!9jMe-(Q$kkm&Pdh9=rQkzLiELdt< +zR-W;A9#y@eqkwRB8Wn849O5DHaGvj5WSIwZ!Sp(RS&m_>kzePXwJzWGG$TA>y$u}i +z{O#@Q1KpJN)U`!YNq67_5!b0aIiF(;khIwUTw=pl|(IH8_%mhq;}rj)WsRABVJ%H=aJH*CLI6reF~6frOuXpM9(fV7}Tx>UC;9`{QGZeX@Vs+%w$N#isqzsgqgb%EfP%odiN +z;7q=QZJiF`-) +zJi{UOyp`FLDV*9DYBQfdGS4@cj1Bhprp-7FB&UOHf3gm`JK*c^$}tEl4QyALjRI3g +z92wHOji-d4)2hB4k!hUZEbeC-)QV!iWXKqA6kKZRp4J%M4-V!#mDF_Xl^IOx@b_^W +z^MCWaxZrg-?<;e26{}Xa$?PrHHvY9(mHS%YUUxvPMML6yK>_CtfsqjPU%k-l`y>GForJcO!K9*|*NU31|h_4WOYA2Jt@40$T;2e%i~wKn5!e*8ms +z(X;##5k~U4PQ4PCT(o-nE=GWaD4_U-iA-m&_`R#7qhp}4AhXlT*G>AmJtK?(H`Yvs +zjM*E%gYvGj-2+62MbdGqT|elEFtR`d_>_0U%zgme>EC +z{D(v0HwhH8=4tmFfvM=0H#lF2b9{5j$_*%p`ryn`rpt0Ke-sMC1@az;au_iZ=a>P! +z`aZZ!NzC2sWzz_=ra=`3hR@T(;IF59Ph=0ap8wdE8U}o8M@BdQiE1QUhJK7uPS=v8 +zI1r1p#VY>x2SLE$VL}Se)}=&FVCaUDi-|86_j=m*KJ0Ao}h9xJ{-JGt8_#mE0IlrT996!+uEyz8a0EWU?z_;z@v5|>9cVA +zvjtp%$n0$#9j-n0$kN51>>5vh+Mzas=})sCc`Lm_1v9%BeRMD8UFc<>;fqP^m#?*g +zmad{sTlSKPco~1TUAOP+lxC^%r;L`3rU!oV?5vzJIWH-7E^u|qa)L$CdmTqCdzbBf +zaJ{^XveQA>=Nn}E&t7>h$)=kSa3@o0<3B6%3+`#xlZBIzEG}-Fjm`?LXb&HtrPq$G +z%Tii0p!vk6ZNe^eUXLN=VNw>UFdMZ|BJm_*mj0oe(55&P?<1lZThF6erD^sy+2O*5 +z>HE*G{z{*J_UEs|k)aNG{jd>w`zX&l>V5t>L1@nNCULa_q4X0feR!05*yh_qF4NM$ +zpE|sK%fh4q$4Uy0Oe;KS{Pce@R`8<3suJBLU_w=$fOmip$BIN25jg%2=GY%8jN&}H +zV(E)}*AA&M^MwQM=EO^n-riv1!{z2mMNExw%ff!sBNP=YD%Tc7Qnw_JZKuyo-BO{y +z`p)#cL^KK{Q`hJHo?#YVoRUD5z;PX_Ucx&h>G^Wz8~x2z6 +zpDs8ni^#lr24y5Vg6l0C59CjY1Rd39Y@%A$&1RLG~M1Qbac+S27rV{gOuTxhLZRe;EX;4|@9QeOuO-HUkZ{A<%`bZ#Zm(cy5};lUfohMs|AMif2jOHB#E) +za{w@3`hkM5Zsh~R9l39GZg1S(J`qZ7G7^x?rKsk_k~~`#td|C>dhws|8+pC#$MG1K +zf@O>;DbM?ewHMoMtZ2i?=9~RiS>gmNfTEV10Q~5oMfgYj|eUFbf%1A6;0mR +zjC=9yv)FRXr(B7ZYd0PUARfhPGw>Ft#FcVnT}LPv8nkSdg^afyjr&$v +z**mO@H+o)an_*VRvm_8R&n=z)LzgcZdr&q>UK*QTv>wxdMUU*))Q)&QPwkt$mZek5 +zAiQr$xKVG}-6V;=CO4WG8w8e4ieP!aLW +z(P#<;j@E@9wLG;{@RHYyuBHPFQIgt&1x)yB?>j;1=x*K>+X6R}gH_%{)|21WuXS5J +z+-mU4=f}`!cN-lcWHu7bI6|2?bW#;TqP!J6+)2&Kp!6D&M2yO3u^se~>>#Zn!+86OZ~x?x1#Nh~B%xXj6&E=I7x#@e&3pzGX|J^aHg^qkd3)JyBchN8HmG%emo%6uDk +zcaQnlPwfcn$^;Ts>hmA1P=|hghlTx(_witIdyE$qL!`;x +zvZkoPb1m7Xo}2!X(d@?=)4@!%J|twmPWX5I=w1Bcl$NT()#TY7T9RH!F{NJc7Qm7J+6IYM8+-PidV+D{ORD@s1xYg%h^PhvZgCCl*X~>To +z*hVO#x7>e6dkSdFT$s6PFolxzy-tn@f5sxcT9rtE$UVzUNqB^C0{{eO7}5Ov<_p4& +zA22NEoe+As8P&13K04#O2M>75eQh^vhb +z;&gWTq%?t*mJAsc^ioIHZU?zb|F%n)-qYHs;GWVoLjtklvFEHJ +zU7R5E-_xg)`zZj{rl$io{cI9$p9=w>P#9Tp`5hKUI`#>`HhS1oSQfjX) +z>CYJCa}?JKSxd2hJ|X^5;BAPcuyLX_zQF+}Dn1f>a%yRE7W_J#J|DX(SHP`DS`%^% +z?FHP(8!kCq1r}5|0-5Lu^l~Kj38mU^x7dF0dU64H{6mxi=x@~=N!J@x2=)>2XkN<- +z4@u3T4F%jN3_z9J$L{AEEvBa +z5W`?JtY9ACKUh!c{Y2D5U-)MJk|ND&dAle!>`L9{MKKhUJ$D!|H3~>pe14z<+AhI% +zTs=w*TR#n4Tu**uE`M5lh%jH_nq}H4>sI +z&CL*AXyD;Tkp<6CR6`;Y9Gx94X5Bg}Vm)ROhIDX>V? +zV;4nJQz5oXm=_!UXNE1Yhn)m0p|I~9J_3S97jZxhMI}#{)6V&rmZ1$GqyFa_SpxJ{v}_;D@|%XDKo|g6rk@ +z;=g0*h|zs17w1*hhuSPQ+l5A6Y%^y{IPTivTx530UmsT{1@tfM;#U|TSojwGwgV{f +z1|z(ec&ZGCEauAR?;o}bnJfvIGuvwcsqzzrB?|qW%NsHTmbYL0 +zn7&`XRic_2^TkD}!NGfknRZ)8!#@%$FuXDBo?#2*H_OiLUQ+%4shF@;X@N8Gq=s7H +zJ>gBtRq0U?RfL<_;XNMoIW8>o2F(My+v~YTH+}dFIo_}_BE1%RB!aC(kZ!qpFQ6xD +zxT28XUYOt#Ltp9l*Qa~Yg+Z+S4Z2{HuV?OgH5;z2rsa&ly^5T@L2QPH!Kgi!Lm*6c +z$o+WecE}h7@bV&ko(eIVIgTWIXs&!c1SwD?O{(WSLn!Wuok)h5u_R#1TYiaQK_;~Fle@}ib>WoJOH{T^j;aBq~ +z62ik1LUbje{${bJuI_0o;QMJ&(cc6N*|it74oh2tCGO3`JCpGT>&!0FxQ;hpz{7Xb +z$S1-Rms@^phWiZEgMrA{Kg4|VrI@dg0&rMFOuiyQQ~a_M-WegZ_~zQ>>$sk%)4qv+ +zCycz{n7Y?e{0r`Z?+bh6NMN1=xjItc8`1RwhiD@B-5@>;9ghpz??)F~0aG!5W=(Mj +z^^Ee%vwy@}N+ti{sL~5O{9oWA_zEtYFl>MzQ%l|Yhv%m^&%IRVDJ~jUFpFjDabLQu +zYr#q#haL2XChJC(I$jX)YMn+vciGtjW$gq3{gCw^`%`0K>yOT_UJ{d!@FpY>gV3C) +ziuIOYFnZQ)2+ZWFVJ{Alv)H@mqMV?MgXQ!R=;TJ)_prK!E)`XQW +zWuHaSnAg_??zj~<$?f_w*Sqn}@drA`md#s#YGIwHa-hqCV8ob}9pb7bv6r==S+{)i +z7(o&nLB)Zyfl!&Z!R?;%tCQs_pZr9@WF@E01x6CLO)NjD1*gN|Kcu;ZHiZ&w2TBg7 +z%+BjOy`zo;KUzUu#4gaomDOaR@xT45F7Co^y4DeIEcf2`iw5wX(lF>bJ +zw9e|FFW`3uIHT$qQ1b2I=}e#)KbX~~<+Ghb_|WTG^o;;kTElbEky`?r3W_F`yyd{Z +zcI6!0Skg`AQ1lAQxrwxmI2b^=h;mm)TD1SM)#jjP49VThK#2qRq`sJ6gBPd0K)e*L +zTZubV$busH5B6`x#{W}u0h43WueI|I3^U8$7<4M2&wCL4)UWDOwlS1mM(#;JBk^uF +z+9WMI=l(?aBF{h?xJa}n%DMb_Sl-WR_r_z~Tp!T@!AnH@t*TVM@WRcy-=Q?7lc9An +zJG^A$ksR%oOcOI-eg9zkYAOj$w*;M0q}QBd`Hv-vpER>855QAx^s!81xAP>)`?uvy +z0W?iwvPans;rt*3gdPb=j3ZilwYPOdV)#g-KYC&Zwm#2d;2YH-$tJ~wTZ*8UDu{7L +z5H)V;t@QE0akI_X-qYK^GfR25wC1!v`6K|_etKfW&$afle);Q_1@^*%INWbEE_&&z +zRwnUJY+II~S3L5~W)9wG9OtpJ$8E(Atc)^T?$L04vK~?vaXFOhnfj2>aA~Y;U5n{E +z$=WSSlsYCP>aRlK8TF8Fi$Z|fgo4mFXLd?{OwSt!FVCOmhHLiwc89=A1Qj_cSDb3< +zeP9;#aa72!MzZ=c7j^EBOXJp +z8YEBHVnjyAS4C}a7#ESovI6gfY^ikmgHOf%RFZ2hjE5^n-6qA>lJX+P@Wd=I?1C6A +z{VO=7Z1=~N-*f;iRMAmvSY`rODSuBDgDyag{$PSxan->8z2Dx3uwe5J`*mhWB*AYJ +z)@F@^gz8dziR`bE+L@!m-S1UCcC*gbr+xCHnEcWN_jW)}^b|voq@8m_hD1{xb?wPl%QJf&{RC>B%+`1+Y_TXT +z0}X!FdgF86fgs~TBXed*S)_R3;#g?|-yN46kvo=VAiJ?Vp1S?ar52;b#AW)|@KER$ +zkx+0o$sgm|-%-8kah7iRwX7tD1(i;e+5lYj0o-c7mS&ippZ*yaMm&h!%a8qC^Ke3c +zT~6!9pL5;`5}A~^^*2OaAx>4P03-PKa`a7vX`rAS5NZjW~(E*C=)q8Aj +zA4PJN&kNXcF(RVAKJ$hTyTUU_&wuT%4rLrOFn{aoP4OY&pLb;$J_m5cyG@d>vW8^w +z{@SI2)1)?}-&NfR#kLJ)B_i8yoWEAswQ1iDnTR7AlysSp1>pDvhI4_@mb=-Xvf#fq!U}xQb&eKeS$LRxl34(E2ER?C&{vJuf0a +za|EwJf>u*qK$|4@-7eM}T(kZ)lj2z!Lq7x04&@p~Ko;xmWF +zR8*>gQmdoZbzE^BX`QUoRyQFl82|x|k=(RmVWxJDB>zSnYB5X%9I-5OVRKo;QvO7JF|%b +zcNm$IT=1E@wqepP-Sfka~-t;`q+^`nvelTZ_OUtmz6Y~m%uHd}*YnyMASZj?BAFn`=&QSf8mI;bwoha%HRl4cMt9hx_ne!22 +zH*~`5OnpF>+CgfI*&Az0VVDu`W;UITTX|!%7Rj!8qhdTFl$`uE|BoF*_~8sQ8x;2M +zIQ(ZoT4q(-J;SEXfDM-BN48ZWOh<~(u=&sk;LZ5vBX;*gePk_4)R<3L(yN{Fbxe}f +ztN+RnU1s8O4xLHTW`{hL +z@T$C2?F}7c$!{tfqRC}+?kvkebO39v9_==}FVZ@Pu6KqW9g5m7xTc{(c^v=v=Zy0-mcb^Z~TDr7*`vK0Dm +zh%El7jN1GyCd}r4j@9uyOu|7}ekolEzHYvLHh`T*yXp!!3ld5b$`!_ugclX_g +zdbJ9boSw*OD!bmci?%k-t(^|HJrW+= +zZ0g<{HIoR5@pBHnj``;va)pYl+W@U7+?Ta4Ys=v-OW+6L4*JDfAwkkIPZaD<7TCBw +zf3g0cyg-5t@J>(1$|XJys&8h9B#`txR2+%Yu{*e_F$g(WlgI6FC)B2CExB^9^tw9d +zHfH!q&5UjVx-kaW2%a_cj9T-YKSSo5!W?vUJe6o_wMm`{YoBTq1t9tnFKQ0=_<@AJ +zl3#yvm>^d`=zrDf#ZSH@kCeg|%1?L%;7_DyC@}ZM3_*m|21| +zpw79=_r)`lJ%IxJ;?G>0J(H2zFtre3J8i+Fv7=EjHw>)A4w=bYXy%Ajax`T&`u}`{S?rdF;ylPrr +zta&(Q%6VzrT-j$>dde-wAKv;0=@tmzFVZ;FVy=(dL&kZg2V|u +ztmtM#+SA+m6HNU@cI;AaSTL&Q^`hP$$~`XF--`hGBFT-DGNlnMkMI$$6k#wtPU;b# +zA~q-^61A}4v?W5(Y)+UTJqn&H{Akpcqqdhg0sjlT*p&E~0ZU6on%U(%4beF}%!?7P +zd^o=UPl1c}gsZL50Je-*;WvN7)Eh>T%0A|P9@@F+KbT=_{FJ;FrF?~PXh(Quh9n&Q +z1XXp+>ryKG3)JH0)jhVQ-L*7vYvp^HwQ>1_*kX_0!FlrWh+RLYGVQNJR8x{8N{VPv +zSg)-j=kh1<0;%4=@rbl@tIPPC*{|G=d2otT($FsUM|O!*lI;gxrfgHI{R!waSwSuc +zC{GjOlMy@!Ba%3hH~WOkBbVX8Qw3-WEt%PS46d|)x9!T7WK^WLQFR+@aKQa2Iv>)7 +z8AR3B7qOq*IU!Y*{#rxP0@H%W__!?kCKElW=LXB;ot*DeE_i~_T8!c(@boR0m_a^D +zd1e>cg&ez`M1LW-;M_=;7ekRXc=sXmiB{2vyy&ae({m85Ihlqt;V||`MNjLZvXb&0 +z>VmFcf86@tzbk3&Ch`zIi%hPKNQ^*qvh{N59@V3!o~5H1|(_qf0-7TXcCV +zHY5o3+y-k?x4jIH5nx$YG(i+wRWsGtcFRey4wO55dR2%nHM&zA@SOQh`v{^Q8~vT* +zAAb>GEi9bG?V_HSB%hhcKk99hGcjPH^oFL%?~&tSRcxX|VYU&vO?Q7qJrElgC&o#> +zmA??pw{_Muyl@6*+=4R>yuLLZa+!1$PdtN;z48bUEKH_s1Vxxuj+_t^C$dp4%=^7m +z*X^dm`WOH9dT}mvta*tS$xi}XlUP(ikGa*L4waEy#x>-q$)i=m{-@bB?+WNe%xDyY +zF+;+WT>08dUb6SLv|7ld9jUguNV}F)#IYNm*wAUcr*&yL#2G0xuiI2}LX>mcR_gt^a56So`uH|4 +z8QO+c{e~3Q`tx@Sm#?PLhU#wZbFg#;jd2Ivlf*h8Z{E*xCYnhjIxc_cMb}Inj$(jG*>7C;Rj@xe0ELS7W +zj;aC23L>bLD?}jC{~ho2_7VvAM6Gqgy*0YPyWhGLMdP+z3q>JXiQeW%_A4iIZ1S9h +z2(okZat$yYrc17YaS)6={{+JLsrmeWBk!nDTCxiD4Cdo=y{TkMiJLvs`NTPJbC +zM`PXobNNwDz`d}QF0JP0u!rA?sWgS?hKD?L<_|u6uX*+RNA>q&#<^GCo-!-JeZ_>t +zgO&Tq`~%1MGy3LjC^;YzT=zgKuMV_(7IAJAzF&80PNV=9ZA---S)*Bf2ky#NU8gsh%8+e{zh0p;w_FHuekqx`2Md!ph{aVVKGMpB3+ +z2D=BcGqry`88cz{RQ97!sFtoPYY<=?d-39bQ3lQ(BU=DAOYKp3_|j_F9#*ObbCx5>;Rn#7pKMO2hH_6 +zad~csoRir~ouyYWoBOy~-EVmIS**}4k0&T_>ks+>k1U+#xrbh*+sgl?&;NWlU1tvY +z)n$>w{KG<;C0eri(JNeti83J>cVk4Y#6X7a?FsGv{rR@8YyfgctJ&O<={NLJ#SO&0#|5=Kn|v##7JGIU-@5-s9{b +z8G2%@1~hCQ<{N2FqT4uztW7MG*1gAKhOSJs2Niz?0Td#Ic2nd%IOqvGK7>>iT +z=1Qi(dnu0Wl1=dUw1>i&*(agAqqwjnt;TL_l&D2K-&^dL0nR{}ZrmiShT99)SgwBW +z9-^zqe^Ri%d#QfU*xCH*dhhs3_p&O_G9mHp?cu5}p7$r_=g*p&6AaDQv~oMKCY=m| +z&oe!Q*-o^Oc4dc#MgGeptq~zW@P$@{aFh8-YOJb!f;i2p`gJpGE07M0t_|+*ZrJ9x +z7v0Fo74c1hiuh(ZDm{}3T{Xc5i5);PgVGL#imJDN<)+hc#m_{cVFz9MGdqLHO}ESP +zK%1@u2A$l4-KZnJgI4JY$j$ +z`_X9oY?0fE?;7Q9m)GNTs8w1kxK_Kud)@|b9Hz_Yq|^75Ih)p+{$y?4IPWI7JB{s` +z7vIbv=q;^1YZ7k7@Bmxxo6(t8p?qdHG28r_ +zK>b+30%tN)P-=R~geSCzQyje%j5=vl7ndARj<^s3*WuW`r8%N-*>!02Nohw>x26Y- +zwHeJyils1OK+Dn*G-z|*D>_rBwCTrl9dn9;HaTS(ceMMWR{ZHbyPdfVrJYfY7}CwC +zQpD#Rm?XaVcql4Z;~>LOG8-EY&3(+$sZ9(CoL5crRyIj8WaUjalCt%Mmc_J{GNPb@ +z^c$Vt3zi=ak;wG9a2VQ6a35ILaBTd=12j8EcL#aH^(F$g;zo#V;5!b#j`A~aXY8Tu +zT{V&^z`DC@jkw=!qlQV&#q%j>*mWn19C(FUpGa_cCKa$pXrzC`H)9d0E8?+6^#`)mZDcxM57Pp^mz +zwqgHsnkifE(A&L-?QC}HchAkdpp;rbVeG-W?)HOmf)-p&Ee8wok?2c`c5}m?P}R40 +zEuXRi1(%^p+aOhD3|<}kodfhNt#9{0RPNj4s~fK8SpP>4vFba!7hmat4hNCJY4F>q +zt^xN=oW?B3u3x>T?nrukOcAu)FbOd3Zq6pPoIVmJ7+RF2b$O=9=Oul+-pt6@QPL-* +zrs+BlE_or^Ul9}^i5vt`x~LpUV^!-tq31KsTCA6bibn11RH{6C$Ah;>n!$*ka$at? +zNxbDxkxARW1pZ7THo8rRMWB*S17z(-adV=6>dogC9&tjj?v)UYL-qZ>S3)Q7FN4>= +zMGM_XS^tL)rFQ4;h>RFd%c8uIzR=yKj+Z*EOX8?!N1|)5ihIXP8?He_hqqH6QD5$T2~fEa|H3gT +zY2B}HlLj;P;sjkHp~=1FF%cl9!uk3|NY6BaW(ZDx?odEuZ0`4{#?P$?`FKp!%;W3g +zRR|Fjj0SB+zXgiLn0Nu8}BN@wL;bk8{xrFO2GgR>_r$fA$I(wzux~9&cb3- +z#lm(F?1zkRBQ0}@?HV%dNK@fXb`i{~;1%CraHyU&rH*WEy70TH>BFub;&rep3oqPa +zaMwPbRiz?aEsy?(sS^AhU5rl@7aP55sI=Tw^1v9Pd!I-1#{Wjy%~zBK +zPFH4mfahkmx4J`VNb5cJLx?9TgZ&99CR5c;{eaNfPe>4FeXga?OXt*#U9VZ3ySE9% +zi^{plTI>bo=2m9nnlYJ;d8c5I^iiSPJpvyKE73V*R=0gmc#~l<K!E|a1Q6%w|W#9Dd1YyTO +z^UL^F62R9{7L^)xMPX^*`72dA{Bb6DrH(;@8?tldSuPfn^w}+HzDV|ypiA{@$Y@xh +zA4|(#PvzfTotOGwQO@az+7r-Bd;_w9>pfMX)%C$=92yS~XRv=K&*N!zWaa0?JC4N% +z9-G0DG--^$x;< +zoVW1Nj;+JsXw4e~#soWMLADVJF83tRNAx5Y1JfOZYzP4s|@G#Oo+<3&{m +zE`Ht?y_~UjXf9M9-+Wyd#w!GIyXFs6m$mHX0;KuGrxi2sM(r=}X07RrDU)0y-F}Jh +zmTN9LJ)+_##o~;_m6@I;nxnzKYuWt +z4Ek3<%N|)T8*7k_Rb9t$^+{WXxZ25OQVU?4M^^npErZrCu6HfwN!2E~Nz0~dVR@@d +z8%#@=kEtprZr+Kbns(*OCf1dAJZ1uJQRrsAaA +zBo{e>U$e(*EBwsgz%_B9FEJ(6LL{af0*t!NN7C%&E0=9Njr!=Lt+!W}g!%YwPTkQK +z{@@qTI+)g}+m*)3wWHqVMbDUq5l`vyu6saWcGrDT*2cT0%;V*ruV$Y+ +zPARt$bH@X$+vKjWAPA7wPOM`$ACH`uPhw|sl=9v~^y~f59_fgSb@pLZ(@9j9pzL?L +z1*>OK-`WACh(7TR84L=6)(J$Htb7rULeiu-w)7wVQE|j9GbLVI$v-jpbNUDjYKlx}Facgz)Wc?`j>ei$N@EZEYF{es4W|Tzy8z1EW&<7WVc)@^srD^7(SNT?<3jCj)Rqb1{05I6QRuHC%v{> +zMh;S6;nxB!JM|!I1Y*^_Ju6hJvFr)1G(7Wy(r}#C@XUFVG$-1s((x{>bR#|1MmB`9UBnUKR*I}zkhy* +ziU|MD8y3pYgYLgyU!x38_z8w7=<*EtT^Omlx^Dmj&J%{xH#zSbYJ&d20JY_()UeIM +z=V#OO&iRK2MV;^Sr&_AeE%wbxNGsL@*o?>)W%as~i7sl(wLU7#Y*LWf`H|20x|MKq +zGqF3-Bb2yRcAkTC)dz-D0d(!}ZvV!L1dw-B;b< +z6EEq-_$$9sJ1B|T3gqZvu(N*2jY`StIBfC_q1!^H2|z{g9hDvAzxwT2H+$TrsC{}# +z^LLhyWlX8TsliWtP~3&FH7P+k)uRiyvu-ln-seDo(SWB +zxR9pOA+s!y`JmLLGo|8QyoyOYQ2E9sxCtdnni3Occ1l$AqGm<3I#}`sapyg-{!f!=0le?&-@NXm*N+Pc9kz!t4JME(<5<`8lk;E1U(y#HRJ<;U2^ +z(R54>@K<;v#}CJ1)ghiQ@{V(V$*xVC2KsX{h%qoKiXu$plMq^n6SgZ@F^i +zh;d|I%5IJSGEB}p>lBIM$C0cTPg!6D7()8P8xmy(!t>ogtfY6N@%lbME#g3B0-vM!if^8Bbz4=@8ia&9YHI0jcCJFx}UhtiZMY9C?Qz` +z`*>eyK=30C`4*>Nj@K!IS{f7g+(vlC8lqf@=qbYrgql+_Cmu#N0lyS7AXxK*VHzo! +zolNF95>zC0pjxhGM~22>vv^X2{hYD3z!5(4`$7gBLM~D`Q?#17#wQ$Enwh3ZP!}Uxs>`;Qcm4|hHOJV; +zkvOy#H|4Xx>Cg+nO5~RTn*es^QVbD`Z9r~wP}zwuu)SxP@mdHui-#}sNSKV{E#I|$ +z;bCDGEKBD;Pn#9g-&3tb0D59C?XZ*EwuUspJP(pUS;TZ37ZvuIi|7M`=eiq$u$7m} +zmH5eN=I!*(^2-O(F<7UG8*pLWd!Q6rf7MiaS4bnE1b#oTRG|ySJLmL +ztNpxR38vlDY@^#Wi_}^hh4t7fh6L+rsdhw^S-V-2q(6tG2kC1Xprx;_K$=%M1e9kS +zBRZLuA0NR{n`#C;dI_{vOB*8|V6(Ii?HSK+w{^|(_g($1l}+SDZc2tf)|#70vySCC +zJwCfXiB%$KESFNz^y! +za;O;{yHIOyXig14_W+DqzdG3A3K*mhpbL(pSJ2f}({$9;kyS3PlScxo+=c57Gc(p* +z5v{u7Nr#t;k{=IZ^MgrE#a;-{C$46a4h$cgwOY!u0D0A)1-Pam(@{xf<>3C6AkgZ4 +zIssqYAeA@pSgoa|A9vXuyke7B_fcB=E)sIud!?Tt>b_Z*u_^{` +zRhc%c5Z+yi@}yB5s|j5u*U@rr`r}8h^OWZe;|C8t7Zcgp`b?Z&$V78vzWT3&>4t^7 +zX*ED~|0LHFVHQ+Go%gadezs!b<-+8dfC<7?_bl9s73+btzT2= +z@;0r!ZL_($p@F2`{4nSwA1axj}vgbEK%!PH<^{9i(uW$=(ONkLQQ@PHaQYL +zEj?-LW>=EX=b61gaZPd-aU`~fW#N6&*NQWPwOCO++P@`D{`5y7EGfKz#eWx5Rs6LM&@% +z$RvuDoJr1y^64E8yoea?EkijVVq2JAK24B` +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 +z;Z+*mEE`Eo)|l1zRBd7*Z(FmHI9CF^ +zNz`6bY}O*%eaY(L6|3>XgdCCTk9F}{_7v`ypQ{s0|^F*AbJh{W2O +zn&Wz3+kmLk0y98}ov6biZe7s%oi}(t-k`1!Ih~@CDbtssu~jfTx*HGh!El&WWxH>U +z=rc^`94DEzZ!`>T>fM#PmTXELrV8ga6v_Bs#vAEf-&TxPx&GLcs&&igyv2mkeaJWr +zKxU?`FGTR>{5JJ1JsAz7#z!^Y+*Yj^4QX8{8uws~KX#HFP4>VL9$)iUEw~6Ube>HPL#au1X42zXzpQ<#a&oYIgLrcyfQWjK31J{RfGCoZL##p%;wFk{U~iNF3`vCVf=< +zT#KLcJJE!`<1#d`bpM6N4DbQVz_&}HYU4T~C~wJ-@Z@KMdik0rlXq)ca^1b3N&4Qx +zBS{_-x7P`oh$xfFR-aTAM*TeEqNF5YRgsS1S;Qp!{>kZJuHj~EVk&| +z0`<9ecnlI;pOiRA4te@L8TkCj39m@oB>Fd0yX&m19ijV;|x3EHmj1y>;A +zFe^93Hd6G|6UP;fpU}9*plePz5kGiub?mx(kO({Zx5o$Quk5cUObUWk@|ktFKKPRb +zI#zc^VY;HDlqa`bo56=K{hmwzq2e(Mo6g5;lFFin)Hv>F+-=Kb2*4Q-(AJfJ9 +zTJc)vZ?CvGpLvY_bu=FS_{Yv{seTrVZsN`QZC$eyS>?2Uj6_rc8f`g#=~#-V3OfbU +zssEBd!ArF+H@zWIe;$+R#bL`jK=xBdj5D7MmbPuCSZ5EotvP>4q={lq=`5mu-E=6<5~TiAf3PB|6^A1mib`{5RqKalPC_fG0#XUZxjyvjO1cDOZl +zU#4ucGe76}6o0>&&7@(%C3DdPp?{El3oYWFZV;L{Z?<=juP`Dho^AnRD}(r?L{2}z +z>`x%E!w!cFbAf-u0A+d#7o5Job_HSwHlCA(*6lRyucQDR+SO*LG@T?>8fevX7c0^< +zf&vS6l+zQ341yXiFa^M8Ra6ytCbJh&f>(IIa|K@mFn`st`Sl+A#5ZK)4f|+}xIWf{ +zbGU)bVKF^!fVjfNVK+=At>ex@BN(-qX&?=p5ttE`O#}KC*g3`SDRaAE+I*3a#ppYQ +z_#(&Qm!^9&MJ9$9?ae^Eif|IAPs$CnNA`>yg*R79_;}CITy^7frbCt&&&52Qn_em6 +zn!UXGgYWLXYd2swHqc66aNn93^+!&Abqc^JWtq3_{FYlBr*AXv?Maie#1T14WP)4t +z+&K|fiv5`*xuy3DD%x|75#p{qLqFPyIKDS!TrK2lTIL2HWfbidiW}Jos>{vm*6VHm +z5>1)DYYBtN*Pgr|(lM*e&N^UbC3OkSON=GE<71HnJW`1W?u#LX5GS=h-EoU%Lmg$F1gd(FXJsF?YvtW~5iu0g_A<*r`+V7;Vbw`fh* +zyxp^4ss~>E@(wS1ikKA)WfbVaREf%9-{`@K5(>5Iy00XU?cc_~`axR|@RQ;_FD=_} +zVcy=uuB9H$xMlQQ*QR44IjJ>Py{*TN?WiqQ-#k{Fgp)^FD48lHxJIGCfrXuJP7^ot +zAzY=|dqOY{_{mn&z$gb~z_;?c=rrAn|8v*R$5z>eL3Wg~E}`LFk0p{tpOBIYolQjf +z@b9dFWW$*3&f~X;aB63ELnAPcx#8M4&{)XCn~#FNZ$HieU*DkXCGu4$zHbSy=LzIm +zC|3b6k8X@YByfnt{_mhqMW=;|P)JhChWBSqxd9)ig@p|ZG_OcM>hX0@l92ccYs@H)D*QGb)ogfBLW}BJ4((&RsrXLFd2Q2_Y6^bI5oIi1C%=u +zidms^NT_VDeiHzvZgFg1y&0lH@DBy?X39Y!eJWoOL7sA_51>I$%NO>XxRo*EM5tSv +za{#s?tRJ5aYvB)N +z&9{F)o=EoL_Ro2>;YoZ7T8c%HTr_losIRPx26u(^m9Y(p +zbe4x29S0jDXmq(8iu;%(O29NfA-%Xb$bI%nkOM9Pk|0dnj +zZ5%gM#ycu13iXUv%wcQhf{8nPa}F=~eU=U;?E6ZRJm9p9VlK51{ahl3`KSDtR{*aVd0^v_MLkZNW(M*bc3BQw+jA=7 +zZhhKRoe!+&ycrb7YPk=F@>!o<2W)x_1}!1OR6GWA#j3e(r>kZg70ZX*G~9DGt!Uv5 +zG|}a+ny_A+F_6AjODh3SD`gIzxlE^rXZnMHQ^GWHK67&e)}d|ZTbUe;s>bS0cZbKz +zZDj-U2KqPE&7&8#*?k`P-uv5st@wP~wi9P1PwzBWE(@TlkfypK$IXW(OwP?)1)>gM +z-x>Pmx{4@O$n>>1o5_ZXv$KPxkOn%kSmi_&`bpgItj{TmC&S0Q>2B;_z=ZcpVfJxf +ze*0k#>PIv2zG}`e!uw1*^BA*3EWRw`2ze&sca_W@A=#H{2Fc(0r}H+2a+OPbxqh+o70VBkaeTh*cgJc<-O96a34HIG}HdwO{p>c;AT +z)QJ%O)XggLr-}2~+|pJVgC=ryS9bxprBL%(!vuoi?`)0mB(;rxiA~&j>AE0n2H4(7 +zB0SO_T&pMze$PbJ%-v^TlE^ +zh_J~`i)*(X3c%a`bK{eh4jcZ}F$r{)0ND*WhExoTxQlPP{b_?b`g_CobM<(iYvqlk +zGZYF++LuTJAv!HY^*UU%n@0*}rNJH@9d2{O9J##cDvwInZ^uGo7aM;BRbME+wIOMq +z>fsslueN_a=f311c#`5k$H$A#|IagCb>bjSdxtr{r0iz(u@sro<;sO{q_g}?w_5Y` +zbRhXYN +z++0$daxR+eq0}8s9iNReB8eOENn|>wvKZG3I_J{@x8=2_!5mr8C3FetYR_Gegtq?| +zl53omF_7(_?h;qivn9aZk5CzNDfyzAgO#avjNVN}^KmwH3|}5hiRmQJdB5SjZEc6L +z=wtcb!=@TwstGpB!IaOs^`@Q2fe}QF+3IWDdy%f1vxx9KG!|^xuF=|dKYeE`Q +ziixo?FJpAoaPI`sIRV#dH~JBt7oW4zr!JhPHC&&d$gqxne=~E6xWhJPy%E`!IfbU7 +z8t%pr*-oxi^b&5rL-m<^)|x~b%%vB>w-Z2MwY%E7-6XpA;_7uSnW@+Rz=>1T8Klt~ +zTglUw(C(^of%2Hque@$(2~4GSkvuFzF)eng6>_wcR?KIS8euFstzy!)<03-!9Rd6C +zWx}P=B`cG-ZD(G^HJf~~w)%JE<|&g0jQ*a-eklo}=kvyX5%NDUnZ_e|#AvUNj~m_kLOGRL7?} +z-#K|k2%mp=TI==%?$ocXW>-#$9&8VnGvXf*zY%4_4=SbE?eA_OX6B=A7=OZRr2gW{ +zirvo~DEUL%bx5fkm%inxQ;0qlLr&?V6-ynbOU}_X8|9``bM9=!PS=Z$?WbwlM8tqy +zm<`Vk#eRI}hQ(z&aYlNzshJ8i%GO@a2D$nuG)tIOTM&I9t%u=5s+``$1@^hAu +zB`bmD$HZ%_T}W6+7zIU~+%v#GN!6U(2bLDkh+*>GA0A~rm*>V|AxNd7D%O5Z^6T9r +z3UsMr9}4s3=+D4GF%cm!*V^zh8{qK;at&Dre*v2kjfeI&JcqU(ZAmU3qTh~4qd^q%jX}PAGI#n_tzz%BBd(=rCHbg +zibQLQrc_9bIKi45|*VBEwa;@=@MR|{C#771RJKRXL%vIv?r}C+?n?7y4 +z4>gecVYMuVo*+Wue0I+t9Uu4l37j-RaJSd+X_`kOYsLY;AL_AKp8c8Ql+S{6M9x_h +z{P@J8TEn%*JXc&@3kG*bCi?iD`NlIUeGT4K_F&Wv%<$@Y_8_L@j;uT^Y}4u=Z6Q~Q +z2->CsS?BY2S*+0Ew4ROT1dA?PZOoUEITKDj&v&Ka=$~8Ur7FQ35_zt5Q{|D-krXM= +zLb4u+dDxP5DUGt?zYys>Ed#xVidQYKT4Q +z>%kt{Uiyi2b@^|P8e#?9I0~94O{v4k|GuU9Me_!>4ZR4##|HXz +z_<5e%J9P%ER`o_uZ~9%-i1+TSw;`r*HAwZdtM+HkV$KfMZ(W#7Wtn>XF81KtH#3l~ +zVecH?>TxFVlO~e{_9}fFDw&1u)m6XLS&!iZ=#9+qU1#f=#u+x{D`?3n>-5v%W6xn< +zFdzVG(|bmZ@tZl2pv#f=I%e`-F7X`RTk=8&RUMq1=J>k!q0uK@CPJbwa-2$diAyp{ +zO8bsFYP^b;9ehX<%wG5MpemQGHV==Rnub#B9_K)%3} +z5nt1CC*Mg%qwN6nQ3)>z!t|tYIZb4Y^-8K9JIFUxF1ie)PHSj}w}`d}C#<8QayMFb +zp+vp7sK({Rxj$2g%yVtvqpfchj48B?39BJ1k +z`z`(+QHUC*AdtR0+M#xG0O(~EL_~5t +z9?kzm?$pdGzC#)vItKftZ!6(BJs5VRddS}V(amCH9%`CZV$L@yw0o9#5%$d`87ApB +zeWRpdX53{w;z@b5(agm;pm+N1>7pyoKwtQkf)to&r~Y#1DVR=5EoihYGx|MY;jolv +z>{sWe#Dn20UiA@d+$PzXNSck(t)|uyD<0(4thlq#hZ=7UC>vxP1!St@vWw^yyve45 +zTJ_A@5$=BHe8t(`yQuU5#`-xp<_CZ6Q;&k18g09%U}gx|qAy17L*&Z^>sCBgkUf|9 +zxv6W3p;;s`b-{)0mw&il7X>c=L!J?XkgT}_`ieaJUKpm=ti>Q#K9#m-qLS^f5jgbX +z>|DZ|P0=;d;4?oWfa0^nD+;qR(vJ7PN6icw{JqB72GVL7)W_Kw-$65zG|%ZQHNk!! +z!%`zt8@kD&x%Nk6f4_Ogj|m*DlOD#U_9|1_l@7lBc`pe3` +E2QQ%6y8r+H + +literal 0 +HcmV?d00001 + +diff --git a/tests/f_expisize/name b/tests/f_expisize/name +new file mode 100644 +index 0000000..869edb1 +--- /dev/null ++++ b/tests/f_expisize/name +@@ -0,0 +1 @@ ++test expand_extra_isize feature +diff --git a/tests/f_expisize/script b/tests/f_expisize/script +new file mode 100644 +index 0000000..fb26ca9 +--- /dev/null ++++ b/tests/f_expisize/script +@@ -0,0 +1,4 @@ ++FSCK_OPT="-fy -E expand_extra_isize" ++SECOND_FSCK_OPT=-yf ++ ++. $cmd_dir/run_e2fsck +diff --git a/tests/f_expisize_ea_del/expect.1 b/tests/f_expisize_ea_del/expect.1 +new file mode 100644 +index 0000000..59d616d +--- /dev/null ++++ b/tests/f_expisize_ea_del/expect.1 +@@ -0,0 +1,16 @@ ++Adding dirhash hint to filesystem. ++ ++Pass 1: Checking inodes, blocks, and sizes ++Expanding inode 2. ++Expanding inode 11. ++Expanding inode 12. ++An EA needs to be deleted for inode 12 but e2fsck is being run ++with -p or -y mode. ++Abort? yes ++ ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++e2fsck: aborted ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++Exit status is 9 +diff --git a/tests/f_expisize_ea_del/expect.2 b/tests/f_expisize_ea_del/expect.2 +new file mode 100644 +index 0000000..1fcfca8 +--- /dev/null ++++ b/tests/f_expisize_ea_del/expect.2 +@@ -0,0 +1,11 @@ ++Adding dirhash hint to filesystem. ++ ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++test_filesys: 12/2048 files (0.0% non-contiguous), 2106/8192 blocks ++Exit status is 0 +diff --git a/tests/f_expisize_ea_del/image.gz b/tests/f_expisize_ea_del/image.gz +new file mode 100644 +index 0000000000000000000000000000000000000000..1739f3dd2f09350348ec4aaa8fd8d178f3be2cae +GIT binary patch +literal 12311 +zcmeI0dsI{RmdCMn#I~cZPPJTdAr-HJP@qZx2}11kqP&tQPYs4ZEnMX21BZ;(nAaZasm>P{KmFx?wU2zxoh1&IZwzoX$F`qHyKKP+5^TGx-Yxue2 +z0yb~rFH;LohueD|N|o>5x@er1fB57533rV`JLfX#bEBo@flG(fH7V}RJKu}boX>Yh +z?tw33cF`KUBQ`^S71Nx@t}J#iW(=P%)J%woQ%R#0AS`}e-YX7&|42KwonhINa@wQg +zKDX&=Z{H-&W5KsrUnyD-SEoOjn?--T(Ux_>qNKJzI{#)^*j2qbK^EAff%iB#%mC)H +zl!yAkAdXzpj1@2Wio*HXh(o~!V;p&2nl +zwY4IAGu%y$i&}C@Nn_-yb+}Wt3ua2#y^aTY8-7?UzAZj5#Wo8o;H}i%D$J^AZoC5T +zZd)2(FprcmkcVbAD3d6y!<5G+dCWaa>f3#%9H-1q6mDR>}_>a{7kaTYfy;+O828 +zxY>TvWATM8$7FasP5<>Pewt!ejJ#4sg)`HmTdB|E$$lb4PorJEp|iP$uK4?W?RV`2 +z>;(R)2+V+lbEazP61c+t=)oK+NRL +zi}p;_Vfn*h>V;R=-QiF>M*SI4nZjw&zNvaegic_J=@iSzYrIB>#{U(!RIz?{8qBJ7 +zE=6|CU(Y&z$A6?^8kcT4Rpb(!6UWeY-(1SKC@UUGa)8dbl^c&y$Y&R1tK^9Rwq!KB +z!PCL8xqO_xXf55Lkj|EusGa75B|fdKGu11f_yO0({8MEu>h1nVI2oL|{LF6kikh&l +zRF#J*$_n45R$<I)my@2nj6_Om6uz1_AX+qZn|Ii<^D!OfTx3xZX+mlHl)S3FZp(9X&Q +z+M?a-sd*OpoupkZV=fE%#jXkd40rRqXIbu!Im0v3THiQt(;vV4j~dLVDGR;xJUz-Z +zJ|<7@U4o;&O;ZKPF2B=qY-dyNw01BkXC~zG#BoD%)xVSuOTpcXM~a$?lgfLuj>#JCUP`*}y;8|ZZmjv4C0 +zt|Yqi-hd;JALx--f99sfT3MZ}nm|nF`N4;fXLJHKu#qim7$#C8oOrLnVaQ{8gapI% +zXL>V3$hAJiM4lHMk4&Kzbi5>h%>I(7iPl7F2!T8UZv&hUe~k9gW6dSzcg?AiAghOU +zr}}(0zK1^!yCB2#M013hDhXCsmDEn-7x+!WCD<2Qj@&{A(Kd9ynNhein7`V>o#jpNR92hjdOu8!b^v9ksQQ;EQ&q)&L&6u^4YK#GKQW( +zN6=1`M0)tVB8MM$j>H=n{acPj&|;=)Q3sQB_F8M_^;<&ANqC&NeOyfGXp^2+Ka`LzbIcpMheEYY-<6ICp47_wb$P()U@b$wr#lbUelA|&3 +zc+pOflZM&-U>LMHPl7>MdO}OGl+y?A;ec>)1jy7Q;L{zkvvH!?f*+^SpEmWPe09{q7>n}#&AWr_3$OVTqHGl5 +zpB-|FR?U9;X{z*V9f+UbSj|4#33{@N$*h7G$$fBa67+lL*jTw%3+sLDlc(Tv%*Xe5;&e!c`m0tffbZni+xuoQld#*32t(g{o^x5HNN>!0-4Ce9DHeNKNkSg(An01Dt`Fw0dxuYgvu!eiXT3jSr5v;78_-quba +ztZAjlZ6Rk!-c3dwF=%3`pHtKmC$G4G%=;Vm +zcWdQ+eaq5t{kUySHTT6EFGzjNVAje|RuD+HLV2c1#i&c5i+@UI +z*I;&Vn?&$PZ!)Hu*@ZG&(DFP|v5IAB5a8Ag2NrgY1QsUsUjkBE1JGKU3Wvd=E>083 +zJ#SeE+Gct25d +zL4JU9^V^evp_P~ayk@01usN$AkmgrZ>z^Aka&{l81QKPiGzd5i3~iVM$?ve#8>1+s +z_>4rBEknJ=vHr>oCv{bSP(Xh2jOU5unSbjqeRUFG!NRIa(8=Mr0-RH8lv$61tPwf2fzem5>nj@_Z+b)SekVQ$O?7qIfaaPV$ZDPKq +zue-}@gocq*)GXB&Jtr?pDhz>o#px=q3ZiSIE1^ipg!V!E;C`qdmQm&C=jb=62(t+v +zy(FBX?{1B#fY2!xKI*H9DvkYpG6+?Uab{5Cic@<&v3vLux0$Mj+btIx`+vZFQl +z*PsOmk1QdMNGb9Zy@YD%Q4)W3Z8kBV7YvgTcSMLx(~0Iol0Y@P2>ZgF +z&>lpIJVL_@F(I`jRU3&!o<`sf8=$YyCA1XnM}_Dl8fT6&XBJ{ZsxIJ1_;S8nI0?6) +ze=6MGSDj4gfn`lNMtRwK)){g|!#>O6vL^by#H +zsuU-wLiFeE@qgb!T#^H!bfe~WEi-;HUF+Ek{L2mGg +zU<*10o%~MWAoK(&qo+wc$&IpeUq&beI>>}@ktAds`4nxWA2DZ>&dS)?ks2Z{92XrZ +zbmhAWlb{Zyn_eW@tgfGq#6{rn`NAS-1nNU%sFBVxhZVjRQdd%6QnN8qPFN${2VFwC +zP%e6+(9IeUQeVP;Q=k#zcsK!$j}rIOxTTL{ +zJ7=r6)g(ui#~z4Z`@h>32@X)D7>QltF0Eyc?E?Sp1%6NB5h-%J7G5Jt%cyCM(TPbJ +zRVqOq)g<1V(S+qyiejf4Bs_nZB+8tsRS?v%XGZ-xsuXw~KbdMB4K_tE;T6>X_EVDo +zF4ZUwb8hI4-UB62k7bTf|ItnE_dovTKss7`ACAG1hJ4Ykc%1kk2IpryI{DPps;R +zIISk-Fmka>pxfCpUPZ3GUO6QRu3M+1pl?^9+wttbLM<6E;8H6<`Gz+ +z9IpH6Bk4hfY=|}?JE}~Mz4~<@OY0*U3Y4~N!9A$@|6PxN|5CL_U?*TFU?*TFU?*TF +zU?*TFU?*TFU?*TFU?*TFU?*TF@H;1vmW|E_i@ThD=VAP|%RkBLaV&lLCm$c%G1CmYlr>- + +literal 0 +HcmV?d00001 + +diff --git a/tests/f_expisize_ea_del/name b/tests/f_expisize_ea_del/name +new file mode 100644 +index 0000000..47de502 +--- /dev/null ++++ b/tests/f_expisize_ea_del/name +@@ -0,0 +1 @@ ++EA needs deletion but running in -p or -y mode +diff --git a/tests/f_expisize_ea_del/script b/tests/f_expisize_ea_del/script +new file mode 100644 +index 0000000..fb26ca9 +--- /dev/null ++++ b/tests/f_expisize_ea_del/script +@@ -0,0 +1,4 @@ ++FSCK_OPT="-fy -E expand_extra_isize" ++SECOND_FSCK_OPT=-yf ++ ++. $cmd_dir/run_e2fsck +diff --git a/tests/f_ibadness/expect.1 b/tests/f_ibadness/expect.1 +new file mode 100644 +index 0000000..b0233fd +--- /dev/null ++++ b/tests/f_ibadness/expect.1 +@@ -0,0 +1,60 @@ ++Pass 1: Checking inodes, blocks, and sizes ++e2fsck_pass1_run: increase inode 13 badness 0 to 1 for 10005 ++Inode 13 is in use, but has dtime set. Fix? yes ++ ++e2fsck_pass1_run: increase inode 13 badness 1 to 2 for 2000f ++e2fsck_pass1_run: increase inode 13 badness 2 to 3 for 20044 ++add_encrypted_file: increase inode 13 badness 3 to 4 for 1008a ++Inode 13 has encrypt flag but no encryption extended attribute. ++Clear flag? yes ++ ++e2fsck_pass1_run: increase inode 13 badness 4 to 6 for 10084 ++check_ext_attr: increase inode 13 badness 6 to 7 for 2000e ++process_block: increase inode 13 badness 7 to 8 for 1000e ++Inode 13 has illegal block(s). Clear? yes ++ ++Illegal block #0 (4294967295) in inode 13. CLEARED. ++process_block: increase inode 13 badness 8 to 9 for 1000e ++Illegal block #1 (4294967295) in inode 13. CLEARED. ++process_block: increase inode 13 badness 9 to 10 for 1000e ++Illegal block #7 (12345678) in inode 13. CLEARED. ++process_block: increase inode 13 badness 10 to 11 for 1000e ++Illegal triple indirect block (1234567) in inode 13. CLEARED. ++check_blocks: increase inode 13 badness 11 to 12 for 1000d ++Inode 13, i_blocks is 3453453, should be 138. Fix? yes ++ ++Pass 2: Checking directory structure ++e2fsck_process_bad_inode: increase inode 13 badness 12 to 13 for 2000e ++i_file_acl for inode 13 (/testfile) is 345, should be zero. ++Clear? yes ++ ++e2fsck_process_bad_inode: increase inode 13 badness 13 to 14 for 2000d ++i_faddr for inode 13 (/testfile) is 34534, should be zero. ++Clear? yes ++ ++Inode 13 is badly corrupt (badness value = 14). Clear? yes ++ ++Entry 'testfile' in / (2) has deleted/unused inode 13. Clear? yes ++ ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++Block bitmap differences: -(1368--1369) -1375 ++Fix? yes ++ ++Free blocks count wrong for group #0 (6822, counted=6825). ++Fix? yes ++ ++Free blocks count wrong (14690, counted=14693). ++Fix? yes ++ ++Free inodes count wrong for group #0 (2039, counted=2037). ++Fix? yes ++ ++Free inodes count wrong (4087, counted=4085). ++Fix? yes ++ ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++test_filesys: 11/4096 files (9.1% non-contiguous), 1691/16384 blocks ++Exit status is 1 +diff --git a/tests/f_ibadness/expect.2 b/tests/f_ibadness/expect.2 +new file mode 100644 +index 0000000..44d9c79 +--- /dev/null ++++ b/tests/f_ibadness/expect.2 +@@ -0,0 +1,7 @@ ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++test_filesys: 11/4096 files (0.0% non-contiguous), 1691/16384 blocks ++Exit status is 0 +diff --git a/tests/f_ibadness/image.gz b/tests/f_ibadness/image.gz +new file mode 100644 +index 0000000000000000000000000000000000000000..4c9c22fe43637fd28afa934daa33b9925313bb1c +GIT binary patch +literal 41023 +zcmd?Qc~n!!AOGFfR%@-&6a|&7O%#+ZBKwxK6^MX>vMQ^BfXEW|5D27}S^{AyWfQ|v +zS!Iog7(z&*5D!T$H0^PK1WocNO%EOWVsA9n1~Ym8fE;c8<$cEl$^8R#?$3vg +zO%I7_&fQva$`2*wZ(E3xI{6?u<#^V8EqVf?bn_AoEKTAT@+w&z*iQftqMF{;A{NiO +zOP6~jg2y9eB7eBV8NQ82j3ooq7Cq!i(L#PET?WWu_lTISL-4ruo;l7E?W0m)@|xmi +zXy`IC`PITiAD5#Aa)*>=#rrb|;8|sE0ghzTp#yAym{yoT#(GJLdCSJJpp%?VRlJEx +zq`KecJa%5fvG}yLvm3clmSrN(l`kvSttp%e{v=B)j9ou4PW0Inr6#SNXu^(@W|@4s +zz0p02^!8jr)tcH)^WaOv|OOqF|wA;cX4DMECuEm~8bukOuBN-g-v?x^~BwtI=mUTNV4>K;E0x(9Ik;1M6} +zvC__H@h4`uYW#?Mu}NZ2zZO8abO^SLP&NBRR(n6FK{cc$crvCSrD=kG96lNz`Jn}1 +zl5s-Z16-H;ak@S4>a0^Z6Pjde*7D^S|GSr91{lQ2Sw!@d^sLh7&`ZsNogP9ax4IL>+ug +z^~o&g-0ZIK15VEL@7V)p5g$6iFbe +z5HT~}o3RE_%`!Q~z09b^At19qaDzc3$1L}z9ZNA15%QHhg~t2KU>)X%0^g#B6WcgNNI+NTIA1wAEOFavvUoyCE+AHmWqu1$*z^y&th%z +zV2^3g*6}3IWV@j;+TE?t6Ra&x=oM7Yp*iW62JNG#Ybz~V2_}=x3D_$pviYyYIH|38-aG+H>tm+j_IR%M(3 +zl-C-+pwO+%vQ7rSCgaa?(Z@!=eP-S9WDCg^LuW*DbF;rEB}(YSv%gEKgksJiOWA=P +zXK7FwT(-BtNo1-7o5MdH(O|mi-4pH-8^UMl%@dxS*|NV9Z%$c6%9`pEvHk=$&pgEF +z7%#}W-?|^6ZKZ7!18K7M%5DQSALnM_f*=JDH?SKd0Tco%Q)yOh1~s2*KEd^34B(a^ +z;np4cKs0#v1ot<_k`2a(v4rR_2abSg7XUn%W&+rQX$C+am}UWJfoT_kdN9ol2m#ZK +zfHg1;1}K4PdH?}TGX*@sG(%ttOtS>c!8Cn<0;ZV*iC~&Buxo|!WpFYDNuW73?jA(? +z3qvhKa38myTmoTDfNU%A5Kb*!;19xD0I87VGk~L&_$>~8f?EN?ngL8J@eM{cLOg*h +z!wI56SQr4c65nC?W(aC=Wm$qE9Q`=A5F)i>_+|=1Kv+v42qLv%%w-5XL0EHuVYxvMJyWPBsMSR^l<7Oo1DMs(cO^F2>E_1RN0k6c-Mb1~Fvmf;o^( +z10aEu_p-{j(FjHf2#SwKGqk|7Q1HddLq4bUK#>=K17O$%AO#FF0WN`I20-Wk2bH@r +zYHX%eA{`l2P%g+BlnU9zoBSAQ0Nh|mKs^u#D~lhvw-}c|#H{$Mj1Y*AB3FbL2<$OIwNfhbDwpKt07l&)hcGhIRfykG%4ym)lS=aTl +zQ~Ea(IAeR%PqNzG2RpJ}**Tevt|Q~@iL;lmLg5@DUP_wllbzoAU-dyGcFU$k#I4PM +zL&y5*)3o0ufx1ny|J*b#oY9I~0~v!0z_TE3C?kqt$GB$&_0s`bAfpf?uo2`1xD?-Z +zii=@1;!rji2L=V~gA+{Sn0SF0heBX}WhmNUt}_%77+Xf64dy1J5P`8~xZ7Y{8SV(o +zRmPYN#+xyQz+7S&+hCj-#t4i(gJgs8WRMUT1OsJ*ac7_q7)QpgjkpxY!3(G$IuzK0 +zBx4zBI6(>s{sT7!ggpnyA;dX2_-XFGuC;-E%|@;@{oU8*_g6OJTC6LS#FosAG3|WT27bG(W +zWL9D~1`?r++Z$8?p=>&|0XB$;i>Kpuv*QC8R*Y9TIh^1nPA*-r@3hkd?{IQ>!6#fc +zPVfeooi13$Wv2%2^G4QTbr)(zH}I7R})h7rhcV?=|DA*I=EC%A(+W?H;E +z;|QosiHio6sc|=PP@Ld34w^0iaL_ctFb;|rY~hGFK`)M&E?C78(*%<^B3>ZEA#s9k +z95P+7h(o3cMsY~IU&AnXO;5IFe) +zAZIQ9h=c#gML?3z0om4KE>0~=u&+H3R|6t-VPxBgS8)4k@(00Hxj~R*Fu=4H3vu)x +zxVa##9>CqFFfEk6d4f)RRH9?$7|nAjuGbjt~bjWH>p5-(*8_Gy6sJ8*Gg0Ek +zGvq-_V3;NF7RLiAf^}`Y(&IG&eXuUV>;G*B2!Uz&ZL){q|I>QAHU7F!PWeX0vW*wM +zO*InYcOFmyF>SOF4OR^{+u%_!%-qk?58|iqrv;F41P~K3ogN>=ShDKS0v_O)nSu@+ +zGdmu|P_)9_W++-?A{m8Nm|#YsH3rRax55N4+^sROj4>-r7-P&Dlf*E#!uT_ctufII +zk`*R|L9)gqGEi2SAO^}BgJSGjVUUb{$e^mSPybIKf*S{Up~J +z1XtnegRtj;eW#O;qo3xEfu#uyrj0lgx4&*Afu(VbxikR<1Xtwlf~Cm}I8GqMVNY_i +z!O}X);BqQ$`C1lb_jc>sTKkS$Xanhz{b;L6Y?Wtd*FFlbztwAyP-izS83u_uZ9EBK~g+RX_sy +z|K~b2;eo-?|2C;zvmm}LraUn@7qRfH8g_YXDv@yE$6=X#w +z$ClB}WHLjcjJV-N9oo>@8KsoeEA8%Nb!CrmILQr(Nx}SO`5AK8rf6m*x8AtG$ZV{j +zfKrlA_AC*G2T>_)&zs3K1A6O(_j+h!_n+u6Bg&eV606QKnY%LR?8)o1KN76ERH)Ei +zuQcP2KCEAl9}w2WYlcPn6d(&G{*hFI>TTFcJphPkXQ-Lk5JExoz0fqZ(nc +z%1Az`BJ!k?hToa*xcp&0%OqgFcXGUVs%@x~{U)k=z$*zmqzXP8pZ{^9yMKM$0f +zP@K&aDdF=rNG)AT%;APOd{HA}^_n-k%k}-kn~z=rqY1R8`90RQFsl8FG5|)N`=&4hQX(mnR7#Y_rXsE7Dd!>IJ3JdFsrUv=D*`s}lifNtGtBvEOmtQD= +zUuk9AJh}?oI{&s!_TiPgP8?CEG0watr(w{CyuHmH(U1Ig6FyCzoyqW~)7q!KON#As +zX__xW&|0HwIeAt@A9&pSPx5|tf$`^4S$^}Y--#E)L;A) +z=+)@e@ScocVtN-BS?+Cjjkt^U{uLXHhNCOYw8d4?WUBQ%0+?@(}3dd$A$|L +zX6Rl6*|sfbvNbdO3eO7}+#DSrmb5~ih{?ZNqD%(oScJ7)Eb$8ntZ%iAYq8-oC_c4f +zYnod+f8wF`v6%jt+dLs;<@l7xo3)ax;ZQGALUXrX{dSno^y|#a9ewue>hP$NS0Di3j7uLNX}GR*KT& +z73*A)^`%0N$pAjT_2DZ%e|FR(cENo9m}GkY#7XI&rhyo4ci67S;JfcbQ9fRL??@V( +zu2A?3jD0X}AP4hZLA0YW{ziDE2fG}f<}cH=3cR?P*JoPTx^W_hPB1Hy?~>Y1(CdQw +z+}#-xDHR5 +z%gNtd^ooY0%ik#%T*U^v{svEkENz>oQj7yfdb_MvG6)Zs%g$)X(ITRj?-r1W#n#~} +z{SJ{AQc3mG4c#3cijKVgyTll?qp4#x=L$+T8jbB$BU_;EPg|64rUIK@r2|u;zclw5 +z2O1}~u*V?CLjf0abZc|@nIUm;YldYo71$u<@ds)6L}; +z5?HD9pOW0J3HMS&fbdzr9&@P`6NI9o8gh5BW`(`c=A7LLAj>E8dSu+uv-R`CsTdQd +zgqGtqeOBvZX*Wj6b+;(vNwnxN^k%~3a&ZeT+Z{gxl35p(qmn`(vdS9*$yh-Xe{=4Q +zQW=Z}UrcIr&igwHwm*)=)**6@ei3sjT9Mh`f!ZIPSPYX-S(me( +zOC#q!Nh(w|`I81`tY#__$I(l3h|(%WOLoSW}j8ZxJZMyslE}w(=-? +zTjeZQvaTJgdS3l}?x+@bC~5a9TlreZ&%%E@!d8lEi;Y*yTI8Y14boV@8iSDeQM!C)>xx8j^KUY)6E;Fz$^BaH&QSzaZLMOQq1&-|f*H`IYa +z9Ugo%C8)Xw7AHGISd7xPkLv=fj12Z +z8j=2JO4jC8B^vAc1K(ji3u*LrDxGU~bjYymL?!)ExOcbKn9#&%a|m*7we4MVsCM;O +zRayDIk(1-l>(CQy&~YzPwJX6jR+)TdXm&!Q@0-QLhq4*3?uQU_SHEAKH;FkpQbr9q +zFx571cU7VAmCIfbqI)3h)&o>)f8IS8dRlaCE3hGtaRHoWNNZ=}E@q(|h7_}_r#fBq +zCD}?g@V>;#5lUPmr8GK$s#&Ewl3TaPZeG!EaW8#jniMX=ctwn4`%bvNHY;C!>_fMF +z4?8Z*8`no&t;Tl4PF?x=FE?TixH6?^O?`D0c-z59a6=3;p@UxJi;3J}_K}gL`r{v) +z+SvUCS}x*++P)TzKw`hw1~N{MaK9?k=dE)IQ^jK-d1ZA`G#r?ZRq~>Ci?d>mv126f +zT=w26qK4W+!EyzgBx|Gf%SEOGHOb1tyw=N(W$ETNk>m3ZmptvzI{ +zHWz<%clF2nDQ2|0<{3Xo++4|Mf3N^0m?r^M@NPw@Hzq{WG1G)0A0VuxKNHp|x0Va> +ziqRPwHp-csUj0?Q>vPgy-=ebW1nqiiS_JoUT5X2rA52|lqpw=it-G$@Gi@HLr$0*N +zsRevASNPj54>4SW*EqBVQX)|K)%sVL|XJ7ND#kRP^<3LdrCPdH|nB6 +zOuqg>v-Fpmau=!5mc;smW5Q+Sn|WS_h3ZpRPEEA^svS0cu6kV=E5evnQU|Ah<8~OZ +z`|*%Roa)TZh?rYPAlQ;)=-$?@0@V$oW1j1q`_ +zN+z?bx{QzWuGHF5%WFjyCYosVef11htMzy5B-iooqN^1{d}a;ZNN!ulPCgXfDJ`dc +z7X{7_N{$r0?q3%c;n9DrQ2|?5QO^w}mx${H^ubyG_x@3lyWi=^sDAteH +zN0}+5#_WVnpG2%rZM}XH$hy0IVeaZT?^*4qtIUn#f)wfPT5~%nv!iv7I2)rzilH`* +zp&nCtzis1F`BkMb-KJf?jr2o0!DWiUdr1{L9!bB(@HqAA253rRAKq0dJJPcZn`>kq +z5ce1CDmI)1Pp=H`&x-dG^~zU3A4t!_7r*LTa?S^@M+`4*5W_ESoLTS_hdp!n#n%^sYy}m})Hh-(pYd5#P-YI}ToKV`; +zzrE1ylI*p=lk|KmtPE*JI9cut2~jj&NoL*SghTmM*k+*#bFyYN?Z%0ze7L@T*VK5{NwN$Qp3PPlPC%J)F) +z4+9VQJOY0#*l49L(_atVR~)xG)V#NS$7czXR;sgFJHjStwU5X@Ash%%Ni?i_NT$Ku +zf7hMUbi%a(TRLX&N0WEQ+>!bf*9~6}yxk-RJ#A_hZa`L)LtUMX=t%}8#m<~llM4j*dcGsr@g!Gj#e);QTt_vIhH3i +z^@93+T8y|Y;zrl3)e~t-$K4(31lboaC%^7E$!3_Td8!L|)Gp61YZEW^CX`d;$lDWV +zOWclPv}^0!p-T4`cb<3E7OGv~d%jh%&HOM5m@vpMhLH{E*5n^w6t6j@FF|LP3XPEL +zLrN>RujK?*VoxwV2WKe%g!uG2Td*kGZe{k_R~7ntpx0k}Ku>=KovVA)(-qJX-;i5} +z9xitBd?t|C5aUl42K}S@GIRmiE3ao+U>DF*Tv-*TzHn!St&E4N~c4Ey5$`_13O;R(lh#nza6WBwt;SW+c<93-trLRT8J%-~W +z<{440`_(U;vhpmDOn1f#KKh2rl9?nUgh6HOvMcrf@lC6GOcgNrxv +zGxa;`XIQS-tiYWBt$~z41du0)X+5104+Gp7<`9?$;0=OWVZs?p)|g}l1w#7?I0B)a +z1Mm>q8NePw(+2t=G%%nAp=kp35Sls=0-@;wYY^JcfD(ju9w0zyX8}(LO$V5Q&>(<0 +zgr)^hAT$ji(f6ab+{rx7wc2r?=hwZnv9b6?x7?Q8)ZvzqJjZ2HAM^0!WAVx6wp{+2 +z=2psRjI;KmYX!EOZwRaCKZOLA9-9CQrkpdEo2Back(Sk>R1Lf9nf_sv#t7 +zfYC)4{TiZAySSk4f=gc6Bh=*c#3?m~ZbBF?pELKE*FT}{yA#LjPB8wiw-1jnn_+D~u~Zp({<~(qQtEjsOh1uIG4<^D +z)oC5K#XF}Hu5I;ObA-PUJs|oV>`895pohEdds9Bik^Jd-^rMzc!xbM+6X(KQo!Q>C +z(BR2;6A7&PF2+}N*#{N%=GJsjOKvC%&d*(uX9?oz#9eKoC|~g#nXXTobG*f=g`IXV +zuSYt~Kbn`b$m3OKBdcucg}>e$%uwv>JCV(X*<;H*FNb+*^f_k5%o-%FyzOrFKw^4* +zM(xoHE;V%b$->PK)!K~1#ZB2;7M{f%q$9O|tN%*Shj#^hM}i5L5QLdnCJE!LD-2hx +z!iOxb8wctV9vM#_8avN<3u+XQg5SYDnK7(Hb8mKL*h)5qLFw+b;Ioflk~@}bYevwt70K`K!LJ3hRCId@GBxr)ur% +z?FlU#-ezdWX2%+lxuLOMk;-^j?rt96!1YL3#{{*toW>~~>^~3`1htHf-Kp)<*H`4d +zg^6rot1382Bcm-|wOTPK3 +zYY!4ozLzOz_07KE?6{!lqr8R3fXcuniHeu;Xs_q?xU=I`oBIinD0Pie7?#F+18LSs +zm&=NCk}lq&TYq?Hd^l?35`W_z{@cuSoXCv07^}DOvYb|4XMSa^C2viQ;JhoFeWYzU +zfzE+XCM)Dhu*!qx=Qhf!YM&z=7N)KDyfdom>JsBMEJwT^W5#{*eG2JrP|K1BEPhe+ +z-#iNJD3g797~B~ZP_XKQr!INOe-fpwT$9o37sTU+J33GfWh{`$Wv+|#3DGqFV<5oJM +zBzb-RB^p>_i^ogM?TgkY6^U(ZvnrL*-6hg-}e6X6tU32>fLT`9+=dSyUizRXk +zN%0-mL!ZP=y}&EahM1R}u7O%6aaY4OOINS++IH?YF2>BO*`ba(^6jhnhh00+#y1PT +zuCLn0Yj&lkR<9nKJwT*h4c{I8cgXBSMI87KQ6!FsRuz6mz=w6O@hPs?wIh#OPPNS5ziijUkIbC7y7*4 +z*d86*-`E#;_qjlCxE`&`-k$qXdzRD>hwfgj<7=s=yAQZ;@p|5L=`6Y*-Xm6?=o>e2 +z)9zST4$_*b;~lwGJ1{gr9)A`2z0-sDqc$v*O>%ylAXXaIK3sk)H!ezJx29R_g{p}E +zG>fTd@Q}EXR9ALupT4{K_K?0Bl|bEocb0!0WGV_-$(qHeg@iT;mH2dq6-sUfuG%R?dE2)%8&dT^Sx8^ +zvnM*LNw=$Nl^!f&A`O3>^PB0Nxz4(uk9uJsd1$xbcVagovy>8*AOdDN0hbDcT0;Js +z@uA8$j=hSyZ2^tCh^o6*DRLhi^g(Y;JLinhquA43JweQT4tjxcju^0cP~&0~E9u|l +zdo$2!HT+>bSp0HnAh+TA&FhWhHce)IZv$9rR?YVsC;xQlO&kk{y~~@sJcN!7@siYRdSUhf1+yWT!F$wKITQi +z`NdnKjjKzVVZYQLC|CuDo_*YyA$#YwRlt!VTy2TmmcaTy6>UQA=C5 +z-h@w{^m_ev^-cD8;lMvVPt=y?vZm%u5r&EE)v7-IMsFGqhFst781r4`JQjsI)I=4( +zVyB0XZS+lIN{0lJws)SC)-cb1q}CYbq_{Z_t3jE?%7u|y;&dr9-QfgWzRuvYMOE{g +z$s-)Rx?#;D_$Vj5dhn-w=hnUa;ABreJ{NAUe?ICyi=GaPeFQ%z8m-k>MpZgvU3SVw +zL_;59^I%?Dn-6#MT9<__i&tZ&U+HFrP2?{eV1>*G4~{|W4Mdu!R|~XM@`P@`73hN+ +zJ$|<=JzK#{yZD%97H#T~p_r(-U_F*dx;#t@&Ny9jn`T}az4-b{JEAfcy}DI(#F6!& +z^4`Yoen2bn!1xaO~kj +z#to;WiSex2#T-%QxYYAq$sl>44oQ#dHJNwktrYAX)=r2@`gDWKmhh8Mlox-pnp9=e +z7Ra$K`;}iAAGj-U17B?(qAT%dDna8A4Qc44MWl=FZeU0&8o6xAqQJ!vug7UIQf)I% +zo(@g)D%FD!PG$sqU6WSAp09*0b$oQSO?>~WC)%jdUx;67U#nFs807lP^`p{zYr6uO +z&mu9#$m8EkTO{f2m7A3L6wuw`e#m#MaMAYN3=5qtasaGv#$*7yz?|5XC(PgtzYP2#nri-q*d +z8`b7YAu|u&=YD$awVFdpx_7J?zB@fKpXhFPRWj!SgNA`Hv>p^Op5$9jY&=AqoWZPv!IMA}#&G +zIg{vW+QIarYPsGIZCS#UBPw@eM(N8hsAfq2*lwMzrmb&&_hvQ?ex=}yB)E+s4LAQj +z*Kx--MmiTRpYqD%cMO3z_udvYyY=z)fD(1vf2iE7G{G +zeg0sAVeD&n+Ajq`kyH}7NMx?n{*>T3tG)FlkCblrsgcEYIo=z)92{=EsK7I~G)^$) +z4dc}cI1P&)oNW#u3u01*ulqYw_}lz~O85Iw*hs=kxKGTow>aWr08}Ku(8TuBU{HUG +zUC3SA9wWIa_NtP2-N)g@oC3+5uG_A(IHaw3_l8h3W4>jd!h$?VNkNxDOpznYNXmK* +zoN27nj%pNKrK;4QrZG +zXw;Q{*fI}rE!!vosP$lM>)&c+hI^YC9WLBX!g;0VH^s@Vo1f?yzrVABxNjizK#RFd +z`P)>FTNq#3`psg462B)8$gE7lN?2c}DDrY^WY_I;zLvI}TLVaM;-L$7wVP*i^yX5t +z9aI`F22}9wppLqvEZ(V&WqN9dIH%6F2ak1)#@?^sBrid!!7;kw=j4sI4odz4>zT}= +z6!i^}>xm4Druk$p#LR6g9VGiW^=6TOV +zNmJNG+6E`JrB^HSE7_BhDQx;byIYY9aiM=!_d@<)x*?>rSq?R4iV71{0-W8QSC&+=8~QM{_# +zh;>|LM;yf(S}(jjR_LkQS9ydyXS?_*$KmZYep1nk#+dnGoyDk@*si$JjkvMZ>o!~F +z_u1;~O{VCra2X%db3`i^+)6pJCTJo){CFh5@tg9kx^^mN+Gbi6LJm`mi`xHY0yd>Z +zv3P4~Q+*(x=ULd)594mL_2t~Dp}X=qv)#afp77Ad8W~e}pc?9^;E2X6ob*?(-^12w +zt)(i&-xl?fjk7%gyJ^qTYK!G0UA$k +zxJ;-haZn{Cec4(hsw}t@eWcG?J!UNEmnG?5qG{&^@f9Lgd96Qcy{`l2EJ<_+KJHq4J~FV(yK4lbHGiH8hP8`P-4+C+%6>J`a9zI%)on$< +zGgp-KrJKW?zn)SzC~bWP;n0eI9#1tDnckpN;nRk;^!{tlewHj~g&}u!5Jz3w6Jsyu7 +zoUuzv+Z`UiS6@3=nV{*k^OSzEuy@Ql%><=5m#p5rYo5R&%n|0qi-X&MU(ngih=+lc +z>jC?J??dY@HLEoqacwjM^6x`yb{;(r*A4z?-M>zg4}jh?o;-?Ao$Wil{JUu38j_v) +zy#pnCJ6RzpsweqMuf_BZ>Robc0$qtJts8`mdHc4&3!>>?OY_`WN1q1mL5a^yd;pqgUt41-a)MzSDuCz>gi$ +zSBpmQCuL6zNIwm4%{Q767V)Q$O5B7_{SCL2M4@Z)*U@c}r!pTt_1bVNiXfTRD^8Mj +z?rZIS)PulX4j_+@T{Zol(Kc_mxf|3ya4V7&-DVbkj6f;5gguy98IYPkbGx^G%CTtg +z{AE`I8NB3|L&$m%@0I8_``z9zu5#L)$g?cVbEJd8%C4hxou^v~GFn7L&xE_N^a0yP +z7Mr>Kowd-%ikI~7_Hs}g<@MGp7B%=x*Jgq-3%7K2?ukvYPEU;{;@Xw@bFqb6AD(-L +zumf40dW)i*T1fEksa>-JKvL<>8E5td?|>tZ^A{;58;5zDD#q$}^u7*^7C{DV@(_;4 +zGiR1W5bJ82+ynMc2$$W<-a}u=5go|EiC(pUJ3F(vIeB*@P||CCtTBL##(HamygZ8oA%&k8!OI)jm6h>@w@zBPK_r;at=l!Ruk2(4x +zuZR2^Tl3YFm#$!rpv7@rOSnr8DwWuU=oRr+v29@Q29I;;$MvnAREBgPhUl +z^MxBKgRkmG3W;truNAUC>Q-?#hFe=Ml5*;Pbdr~?7A5Ouoj5u(GC~)V0C!dl +zW|8pr?D%%CufGjDw|w-%Besx$cdza0S^Qu|@PT!!wK&mh-5yy#LHcQsW4GA5lVaYXVzR@2*({mJn0vf} +z-aHU6d85IT>PciW8^@T*Q5rfaNkIQjVpy8x4b9^U{-)$HxD%K$WZX;s0oqvv*i&^|!~%lXd*`FiPsvwEG;y?m=%FW`c7TsvvnW +zrh*Mz|9f1XjYp)+2$(415;uq7DTt^US{oiOAGk#vly5XtlB}+BS6Q4_sEkx!3)RvH +z#vQ$(Af(kFrlxt_s;3OW{2Y-2HQM)wOZqq7nle@PLr__bh@>vsm+xx3h)(NJ2eFePvy2C$5R5J&?<_k*8#BO0f +z*N0y;Lm~62JqC+LTU{UPmZ^O|iZ<l)i@^ER=AqqyFL8TK8n+26y$Uf6>#;idV6`F_Sm~Mm=mF +zI&??>u)X4ykn64zx6{XnhGVOE>4hqE{+jvV12R9)8A|-iq9eN9r+mA3(*phN2BG#8 +zvb}F1#o!vra=i84^zk~6t%34;RXM3A$F9yt&~4Z)ec%=Jb@ou*Tt$1$K#3W=PJz1g +z$C^=z+D5a>X;}&7#*TrpCrtmLvQO96USbofadShV7ZeIfrBC>cdgrhK}@ +za|40&$~S8mm{Wb9dDE#{;U1e%wxGh738JF6<&i`#z6S>zf%|BYsEXMq+PQocIu)wOl_( +z%DQWpG7?fA(E8R!c&srw*@zJMi=Y-LUL4oEHibGDPUBLMLDF;=z>Kplm3k#Ox +zq3G70$m>zeP|3$9-K-xsYUer^zj5+a)$;5k*av^x@qkUP%HNE5W<0Ir*Lsk$;X40n +zYQ?nzn`vb3I{tWcXQy2!SoLxDsf(CDdyf*c9231n-pqhy6B2ZOMO;~#V0&*NrKT-B +zRn>y8g&)3Be(RsT3ntg$@#!IG{}334pSrw??j+r)BUU +z^QeW@Dx1vISp+*JRv+R;WDN)x-8a)~^fGNn@ZMeHuUA;P;y-Sw9taVf8jQHw)rPR& +zz?+X5y>IDN@@-0{>sEW$U%vzEBiA%_rgl?S<@7uZ79N>+i32bXtXv^OPk!%%YCUgv +zApS+t>>>5)+=wF7U>2E!sI}`~s`siU$K@P1EF*Mfj|D}aeRGHR%7*!D?DI!>RFI3odQU(zS&^fuwg=S~9fBfCe +ztz9Cnw)lPiuaPFD)m9Oz-ndEgxMHqK(zXqivZZCjx~*hty+m6)U*HSV!H!-2m4HYl +z9K0jB3Y*e2&)W-Tygn3Yx%lBYlkiuTLkl$LRlzrjYc@3=Tw`yT@%zldYx5u7?g_1$ +zT<*qE$=0eGYIsV;C@VevGW~as=&C890;RV>*c8to&hNkQG*N&QwHC@n2W^IPW1`2Le +zDaD%xhHQSXPD*|l(g8V1A53zosY~y!|2@;M&t~oHrb9EsevKvgd*0#i>HKST-FLHo +zMLop?qg$!Jli8WGFP&D8IqkyCel`3(u!7L#_l6dRSW|i^8gedahVZYt&WJdzx8r2* +z@{`!rkg*c2y+TL-1O=jPjlavHxng!q-O>O-LcLgh!YVSHL*s0^=`-KFst&oR(hd4% +z2UIj>lbEiVS*Hl|yRv!6L3KKMG?vLXQj?_RF|pS +zG311rO=UAj(K#_=yLWrxT1rFE$bnDE4t3KfGmJZiDzrSO_RmYaP!ZKrM;K4OXjTgH<%c;j0)7kvgJ)f;R>`vTTwAZGn`&| +zqxV4#)7O%e8o)xgUfdmZ{Nzb39y{>c@!YU6CaS@T_RIYD3F7H0d}c^A>O{dnbvfJ4 +zl_cDn6V}@8{mOsB3tNIX6IWO4mzZUgVc)5Z-J3awRZ-8}4_qopeR}twN2(YjGilaW +z-XXg?M@C%_ZFhO8zCD@%q)YEtagV0MmIn4*C+ITJT6*YVhT>3eYCl-GgY)ZB0u6@ +zIzI4aDDh>jgQ2Wr#`W|h>}$n&WLLW521b7T=d1P=Q#9jYSzRfFe&gEgvFMG}@$YC+ +zq2y_Yn!DBS2E&aK(v{yVj0H6QU+vsiR8v{F0N``kAcPPh6d?o%As`~4flw1#5>OyOs6uEV1TJ^2`+nD5_rBe{oTt6_ +zS?4?Job~VZ@Bi<7ZB9nN_mCMElaN+Qyu#5H@&5PK7+8}^UDLt$zu_$wA~a+X^CNbQ +zy>Z5CrmkTrDh2!H%gv$%-6%dC&l&W2=4m-l1SHZ{qh6+J1}xg#x_;Wb;ykuYD^56$ +zMr)hBiYQrE3bJJ>dAG{q)CXF0;6i|EmEQTcdq_%2F5u?tw+w5306)ES8J^2uCV^aN@3 +zVhgg~b}{PIftS56WK$*Nu$=O8Suho&{o2r7*g3Re^E0_mu@W~y)r+u+auk$Zhnm4t +zQfi)x(!@RYZ_HS~+N_fol!3V~Kos*tZ+%)H!oz}~^cZ&D$yrUb_bucAE?+_`h;jH> +zQhPGeLOJw?1cM5y(9yA}tG!Sgu_!KcF9Ou1YT1?^$Hqk>IielPlyR4z#ka +zfJ|NwHj7Ec3?c{3>)K8g3Yk3x@OaB__yHi6e_sUSy)%Jx{I1IL30sG&fYiH~bSP!D +z>0ofs@)A~X>zRuwv&`t1qpu!$i_cykxH2m$M>zg)+>w1mkn$cyPs +z^5W6Tfz|x9a#PT2ANQz)SMwU+Nu9&5W43oYDib+UluPcVy-1S|M2DvO(YLn@=1DTQ +zFv^Qh3#+Dx$MG72I)dgGz#H<}ebVd7Yw|-|Wm~`4?ZnjMUV%XyP!+4S(z(c!egCxA +z2ICn3ZW`ngfeP|is6?40P4AYDi>X!Kh@q~H{2sOD|0HCiS`;fFkN-3h3zIUQ!|u@S +zlA~vx73azV-p=0Gr!_0c6PBgc30KD01>MlHwJZCSH_{^OYpv +z=`U(Y>8_PWllGob{v40Ka?oJeqWPEoYHpR)KT +zdc19AI$r;+NUQ+z>vGC-rftoPv=g0@YX|dRhYkmL#sqDSkn>(AR*hMp@@JkH5aSkX +z0T;n@H2$vJvIu+I0N~at%RM*i*{W&Y=|`_|`UFC|PLpWm(hpmQ9@)W{;n8XPhE)#? +zJoUmH%kM(%P<82^Ddqj<3hTz`DJA07)CEv%j^`M*qv{VCn3AP2HuSng+Ln!P>y}6d +zki0I2=#LJy5*YJ00;^ZnFVi7{0q>N-)k2(B*!S!0sv}NalBZX~+`j!xh0gj0^{n&Ol!h+h4Ql)l1jg#`8ZPY%Mj +zp;SF>O|5+jer(kwCzBCBX3bZ_lk3U`Nn6GK(9h;vD^h1JY*`Bo<_DLk`K-_uN6rl& +zTftF9xDj?>a@>rd>Qk{rht)SOi3FPpo<|%6B5%x&R2bWli2N=lp}x;5dsKDh2HZNZ +z-&uO?a1mwW6mxLMied2nZAVW($rhVONFp67&7NdEr=zh#SHGQnCCMx8{rY!=@~o$2#6Q5>hYwYeqb84?Vl?m%)Xcz? +z4(pqIwaS-HenKouWo}q2>rY~U5{>pyT +zF|HNfCN|ZDkW0R_q91K#)Tk1I$BjhS766|4@4Sz4VJr=2czbUiv-xuL6#0N^d4D?= +zCOoYCV)}U1UxH7`9o1?fQw3gDWV5QiYIi)@d}HC}y~+A=|MNMTR!NAMc9a^xl1ZUV +zwr!UUE+9e!vu8gN9VpDN)O8~~5Z>~HU*a;NC});5U;>Rd{(-Q_vsuMM9d^S#RK^bH +zf8^nnVjkpZP4t~}sL0l{1^$&X)zJ*zJpA#AU +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 +z@#UpaG$KP&v +z7;>!eeS%*C_?xc!FYQF)dp&Hzl_@eK_yyrHJ8`la&-YL(bAL<^h7v!yKp!utluA(n)imt~Awue$96BsXMmZ~Xjglf0>kUQ^u`8)!C}nsMU`hx59H=3`p~N)lhJV@8 +z>HY&-xG+%IQ9Q%<6=l}uJG5jUFgJ<7Ojh9^qG2udV#!-Hb96%F{42+tY(lt_iGyau +zlY=cg^I`9WVAOpwj2!X#7p?B9unNu-Ci4G2ASv5_TazN#Q2+%z*X|)o3*rTwExFAffz@{bNnuNh#D{;I(`O|f^+r*d +z_L=?KlKuh)doFc_w}G6;spsl)k{h-j4fy%(g3Y6(f#UbTz!Z`CW?Mm4?NsRY2IV9a +z(HviUD1ysd&%@6eRnXTHTu_wU!MKDv~3J +zFcv@>an(0{r;Sk|7}jOT_DA#@b$`F45Su(>?{`>Hn|tMp;<{>IWC4~9#J^EhE4gPX +z?=_Q}T6`-Ztw@DfvnXA<(^Fp^e4&zR#XD!^Camih330v`!rEG8Fh>{V`x{5!mY$*) +z)OFW|2PmVmbW@5a?x7Rc1GmmzR^8O-u?1E~F9t3L;c~sgd=UAa-y1VwxIVw>LO|b= +z_wNj8E7Eb$F&oA)-yyKgfzJ=W&pIsn>7~wi`(lFs9a+9_IqvKF4GrZ*rMgCK22CAq +zGr_-D=V7ErJ{_s3Mq8E#yXxuSr)mA1eQ*|xakHjtIFbc#iCUy-s!33^e!~f$!}!{2 +z`ZvBM@rFb-F +zCOQY;kc)>_G6RD)@3v#1-c|Kah&K=<&xfgg$>EsfOVNz^>GS#-$>$H-5v}Q%>6gQE +z`TnDM5VEjU+)ZjuYlm7I4lSZ6L{mOJbXonq&^3Cn&*y1f)%K+j*$zpdi&FBgF~mR6 +z7W0SeRpqAI$a|BkGEMoGKBU>6v1Dq?T9X`KgUW{>&Zsi-DkDJ}P#S(y)>6H$Wp!E8 +z`am*u_qA9J6uz#7&_`RZ`iBcDCn`Lo@ENCEXpWFCcx#b2NSbk?B^yrub?+`IciNZ! +zRAkVA;J)}85Ea^xMe2DkBp&9&)Q1NQ-3hVcixcCi-rqT?njU`X>lanK8UbjknkncH +z99N)I+Qvo5OQKy}E&(A{KHxj4Rj;N))c3>j|EwI1>{rQljK|(vwH}eG8|~EiM{{y2 +z@2RBszfB8IP_I1`(fh?keLmVO)Y?hquYHXNd#lI_W%(QB2_^y2k&7XK#$@icQ$dy? +z(`Z+$53X}uBmgaFlBk>YQ=;hSrRz@+La>-9Z0nDNoBWka3Ad`g<6a`Y +zHzmj!(os457y_`epB!q9Ta(KY?v6-`8$h$KecX%0G;O6DvVyDaQs>tj`((TAA>V>x +z>sx&FJZCEi@(&XiKM7VL2Z*o_ReDCrmuhzkBNx+S6n+Yr>WK&q9{tK17~ucu=1O+_ +z#;v_CONuxJhvgFg_Vr?amkkr)sTbs38BG4^%T{9LYo_eTb;!E%_iaR?=U|CC@E&1( +z$u=7tY--uyYezIEzq>1X=`K5;<{t0kj9YQA4I2f^S9r~gY1$>AYQxGJ9nVg&EQCQD +z;i7uAATr0dBWY}j*=@-J5Woe?pJnS0Gnt$kO +z7(aa|CbU>V#S{Mqi0Y)2(M&>$=(&X6(#gkVP`j3Dbve7Gg%`r8<{)^%;5%y0uEUEG +z0XnwfQLT{a%JM3M!CaImFkbsZ-XYfIU^b7b=y~wV3y`}moa`Bq)^*Q%cO8=!eQM(Z +z0Oi!#y4|1qq~PqH+vNMZ_^a(WplWR&0l!AtTW>FXA3dz0p^@RRp1Xiz;wBWa(MdVb +z@j?-dkNL)PZBa{&bSWrE2&32Me@%Bar7`2|ZeJ5S{7_s}UnhLRXTxx@uhXmulGNU| +zEUtWZ;iN5y@37MmqAx&Lqbv9tlG>;b?o$FHhfk`uUO12zjF+PEbTIQaU)kp#0^N_{kg}d`a})A@wfK{!dUceh?19Q)soXtH +zSXOGPJ$?>8j*Ps{{M32+|6jL4?h|tbxB^@Ot^iknEAW3U@R9un%X;-<_vioXg}Li- +z1-JrS0j|LRSm4kpeA!X(`K=2de@tHU{p%mY`aiBKDJe-e;4*(ZK9-gnTxmFaWZL3UDo~1^zsNI9P>COZ4G)pxMRdRJiLIMs;l{Chi>+lZ +zgp7I=qH&t(S{tYf+3|o{c@rO3HhIRTe>+EpRl%H^+>9;7-E(BLsH)}1wi5FNY@K=^ +zBniS1UaGcl!ElThaO#aRyv9p?>TNiBuz+PYAlf4VPI_dfs>X<0?Kfxlvi5fk%~Y!d +zmP)Es{6t9r?=sapy5z@K^3j=L&EIxB^@Ot^iknE5H@t3UCFu0$c&E +z09Sx3z!l&Ma0UKbfscmKfmi=?)YUID(C56;|Lp|s0ImR6fGfZi;0kaBxB^@Ot^ily +R|FyuqQx5nKo+kvS{sSItLW}?a + +literal 0 +HcmV?d00001 + +diff --git a/tests/f_ibadness/name b/tests/f_ibadness/name +new file mode 100644 +index 0000000..bdaceb3 +--- /dev/null ++++ b/tests/f_ibadness/name +@@ -0,0 +1 @@ ++Inode with badness over threshold +diff --git a/tests/f_ibadness/script b/tests/f_ibadness/script +new file mode 100644 +index 0000000..324a3e4 +--- /dev/null ++++ b/tests/f_ibadness/script +@@ -0,0 +1,4 @@ ++FSCK_OPT="-fyd" ++SECOND_FSCK_OPT=-yf ++ ++. $cmd_dir/run_e2fsck +diff --git a/tests/f_ibadness_bad_extents/expect.1 b/tests/f_ibadness_bad_extents/expect.1 +new file mode 100644 +index 0000000..d627834 +--- /dev/null ++++ b/tests/f_ibadness_bad_extents/expect.1 +@@ -0,0 +1,68 @@ ++Pass 1: Checking inodes, blocks, and sizes ++e2fsck_pass1_run: increase inode 12 badness 0 to 1 for 1005c ++Inode 12 missing EXTENT_FL, but is in extents format ++Fix? yes ++ ++e2fsck_pass1_run: increase inode 12 badness 1 to 2 for 10005 ++Inode 12 is in use, but has dtime set. Fix? yes ++ ++e2fsck_pass1_run: increase inode 12 badness 2 to 3 for 20044 ++e2fsck_pass1_run: increase inode 12 badness 3 to 4 for 10084 ++e2fsck_pass1_run: increase inode 12 badness 4 to 5 for 10084 ++e2fsck_pass1_run: increase inode 12 badness 5 to 7 for 10084 ++check_ext_attr: increase inode 12 badness 7 to 8 for 2000e ++scan_extent_node: increase inode 12 badness 8 to 9 for 10058 ++Inode 12 has an invalid extent ++ (logical block 0, invalid physical block 1231231222, len 492) ++Clear? yes ++ ++scan_extent_node: increase inode 12 badness 9 to 10 for 10058 ++Inode 12 has an invalid extent ++ (logical block 556, invalid physical block 4294967295, len 45) ++Clear? yes ++ ++scan_extent_node: increase inode 12 badness 10 to 11 for 10058 ++Inode 12 has an invalid extent ++ (logical block 666, invalid physical block 4294967295, len 5) ++Clear? yes ++ ++scan_extent_node: increase inode 12 badness 11 to 12 for 10058 ++Inode 12 has an invalid extent ++ (logical block 700, invalid physical block 4294967295, len 45) ++Clear? yes ++ ++check_blocks: increase inode 12 badness 12 to 13 for 1000d ++Inode 12, i_blocks is 984, should be 0. Fix? yes ++ ++Inode 12 is badly corrupt (badness value = 13). Clear? yes ++ ++Restarting e2fsck from the beginning... ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Entry 'testfile' in / (2) has deleted/unused inode 12. Clear? yes ++ ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++Block bitmap differences: -(6145--6636) ++Fix? yes ++ ++Free blocks count wrong for group #0 (6525, counted=7017). ++Fix? yes ++ ++Free blocks count wrong (14584, counted=15076). ++Fix? yes ++ ++Inode bitmap differences: -12 ++Fix? yes ++ ++Free inodes count wrong for group #0 (1012, counted=1013). ++Fix? yes ++ ++Free inodes count wrong (2036, counted=2037). ++Fix? yes ++ ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++test_filesys: 11/2048 files (0.0% non-contiguous), 1308/16384 blocks ++Exit status is 1 +diff --git a/tests/f_ibadness_bad_extents/expect.2 b/tests/f_ibadness_bad_extents/expect.2 +new file mode 100644 +index 0000000..7560785 +--- /dev/null ++++ b/tests/f_ibadness_bad_extents/expect.2 +@@ -0,0 +1,7 @@ ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++test_filesys: 11/2048 files (0.0% non-contiguous), 1308/16384 blocks ++Exit status is 0 +diff --git a/tests/f_ibadness_bad_extents/image.gz b/tests/f_ibadness_bad_extents/image.gz +new file mode 100644 +index 0000000000000000000000000000000000000000..65d1b46b592359f9849a89168a39647e29bafce2 +GIT binary patch +literal 91025 +zcmeFZS5#ANxA$$i1r-Dp5a}WcNJn~&fb`x=DAJ|ZP(o8_N>%Ay2rUE%E%bnZfOG_s +z(2))a9TIwYy`R1JGrlptefAza2k*TO))*OMt<1T8^FROBb*+^wme||3nPrF +zX6eV~5u`Qhu^Zwn#RK}9i7ITc^%6^sS# +zzTxMzk<*n^yhX;vrC3d71G)WGhx+re)mLdM>!zdA)W;`n2;$&iPSRkeQ0+)Y?fS5t +zz%}OD9uzpdql_)QL&k-IMBjmhJj$Upbl)kSj-0Q>>Eef%SYn>Iw25;S%1wci&;Js& +z%t0aAj_*(`xk5H!zd^(7tB7@Z9`!w~E^dKWQR_JkJ2X`6@cR9^tG*Voxo)7VXYa*v +z1>iIycEr*@3pBjo8W1HV2?l6w9Q}}lYE|lECnPJh;6m6zN!W0u4|X=g2z^1>bjdm* +zK#YyoU?{P5xl$~SBL@UHMd29EZJk}W8zwhWY|DiMk^_FX55H%oc8FiU3QqiR4#?Z4 +zlr|a)xR63#t(>%jIwx*^o^huKc=gv6vt*EuRLyqy8A{(}65jMUR1!*T&+nKO(y+Wd +z_tBTmR#$ESa06xu9syN*0F$mVS{LNYq~DA70$sG%T;lc@{65_z@#k&( +zF00Si>NmErxv|>uyG#%hPfnt)mDxO-ozy!heCVy7xNSk^(eUf8+cV>Af+RL>5qc;N +zS?AAKTtBv~8@;K2rRnqa+JADp@QHHS=@{Kpy9x>o2q@wkM4j4``cUlF%rFP>wJ*B| +zZ8u+TfWkXIgiA!#&$wZj{O6tEbN-JtE~kpvmZJ!>)`>Fyvw>+$<+|yhLA?KRSpUz7 +zeM)Jixazy#Pe|j!{k=j1`?Nq`hQi8Z!8%4Sn6yd=V@FPxRW;1c; +z=dqPt|IfVzReD$wXdXwMo22Aj#8^5L2!ruW`JJB%9c$u!P} +zFWVmiNyF*bZz#9xuY7ZYbF*umpLPv05PNs#eQ7vjC@ZWi-A;EdRQi)HQns**0_^!)0b +zDJE*@9*UV7{>tYOZMnAn@E3?}Z* +zg8h*t^T1u$F@_Wyj?X{y3@IFjC8B$=7iR$$I(enq=o0KW$U3B07D$U)#~$J%n;ZF{ +z{OC0700b_F<;J7V%q)!3Fc=&Ie(21|LU*BZcfudne`Xod9;#!ELV+|bfPiuq6bQe3 +zrg~WyY6O5=P4MH4A-Fd8QY%b6KI_cwvNF^vtTYR|)@<+FVi;CFgC(5l&*>()sLh%B +zqc#|FjwkYP{2-4x<714Kaw4Eab|O5VJ_O)h*fTMiS>XWp5>Xy9^+C;wXb%AoQ5X0| +zvv15+WN3MO1lWexJa(c0UkLV=DatjAMJ?g$%nDM=i<~#jigPUo(BAksvo@nr8kZul +zLxuTBnV~bvtRmL}hM`9|R2VM1Y=gBb^hYW{F33zB9EJqn3J%pQr=5sG=(?F_O%x+c +z-7J9wsoY?TKKc+rgqVy*2Tc*KosXw{}`&;sV6TD=; +zR(TS3MY2e%VjTN#VL84nUcPz&v<(n~0!hey3%bKyk4spvMxsU=`)4VcmOe8+z%+p3K#V$1$wwYL!@neecDQC_h6@0J(91b6U<`4p_EcL+nV_QJ>A@DXUKq(B1Z7!~? +zU_mEho6o#13q#ESusjSuHVqGJ{@+@p$h`u9b^`@nLU&60M2dFGTd+ILB}DTuXb`Tg +zxt(Z6Iq_|KN9P_!B_3KW0vxhjc23BwT`OyH$<1t7gPr2M5U*s~9+gL8@8Ex!H9mqW +z;#Bb~U^N-UBUm@i3GtfOR2?;j(2zlm;x95y_)G7(K&Bf-p_(qW)2;QTwCGspf$6gPN;hmb +z{wvrCS#D_wFEvKPuqb>c*bP}(U$O0cKArDZo`c0Be31F`CM^?L&Y0$GPT|%h1#BL+Pm~=?daw5=q-Q9A3R0l|f$t)VR2zt$As*L&t(qIDiqV_@Z +zIVK#aK9E|DSqW+rq?BXoh?)Xvo0Hq2gUWD56z54c7=DGV=wXV&)$TT%9^u4 +z53vw@wPd@jCG7+UHVF?s^R+O^gN~pT@l9vJA^Cij>eyI((V4e}nH3a{#$aojTiYxb +zNeC=7_WkINEdl?QFbq1O< +zX@@SLcd^I#=w_&UB@l}~vz;?)z~o^QGR^g|!_Bar${_3rKCQW72X>Bw<6qrVBKhO? +zm0#%fZC&a!kv%9z5yv4zAB?n!$B^+MX4&~YIGERj3`K?ggz)6mi$y14`|!zNXI`UN +z%((L>vzpYhB9{y>m=`#J5^_E@%Qq@d!Db-5Wne~7Ll*?tufo!0A`@X04@cl65Lz+~ +z=nA~Ee1#Rm#3A-nq}o!40j-4aa?{H~J0Jqxbot9^QK<++H;b8xSln~`7}ylqYN-n^ +zH%7s5BKT>rg&S}NML;NQn@FK>F6&?gWVIhu3{{B$BAe#*S}@EA$8AH8iU!m?LVFu{ +zj+$|~lKe(d9`3A%gv^`nmWAU!OV&}qx^N#QYZA&JxOB<-1lTezLb6(`ED4t^iO_f)=NaUu~{y)3d68qwGO}A;>n}g>nxR4SxGfE2N>ad>3_$ +zBLx{+SYRd)_^vZu3u8cK-h?*J5r255cv%x_h{4>$sI`SyzMkQyB_=+iK0===%M7D_Wkj3FdtBBQ* +zRU+&bb|3ME*Fd|J1Ko*G;Wg7P51c%*dICDN?g +zsLT=Fk1sbXGO9pfrx4%@T^F>ONE^CxeL@mHYu12<-9d!9>5RbEF+ad^ZYB(<9)zl! +zSr%#yp@^)qGytNF5Fj^w{>roob(}r^0IZ0tu{4BNVkTU0AcUKn@eGCnVY_Vrhv(q# +z;d`cw<_%iV?)WvZ`nF}zL@vS@iI_JE!pI^#wv9dDm$-M5RTO2a_yn*c5=K#}fE|@A +zr+~9ze@d1mRN7)EB`Xu)RM`JnJPOu3{pT(5pA7yX@DG812>e6f9|Hdn_=mth1paRc +z>;bmsT!4(d?>T>utQq?X^xb~?N-uj$>7{J!wZ8J}PS;OsI^=GW+t{Rc2!-=`T`XuD +z;zJ%&JMxcA$&8#&+mw~H!2Y%I|G&Lh|G%xnKj;5L;2#425cr3{KLq|E@DG812>kyD +ze7_3HBXR*{HYtsIX?^k>Mm)gFUWED}I@#L8MNWpW$J$`y0Y@Zm{&%@pdV~`s^myf^ +z#ty}B&A2XHYSX@Djs?7a`ML4o;l@2M)edVATx14F>$9iuU#DgPzQwNg%VjWFV>F^6OU_^DVe2J04(#AO%Wr? +zF9D8MFl^Iw=HcGS +zxIC_V1^yaYci6bnXmX$`+O#p3Vfu4T^UAF>E~~@-s*FYKtXZrXo7ih@BT5%_0SC;E +z44*Ccm4zeA7$~|K&oOoIB+Ke#bAhr=nh18edUM`A@6n6w8#$cv +z2u+&9SsfEg)f=kNW9O!RS_}7Vr*PWXxtl?W&k*Nq==M`cqzx +zfQajqz!nNg+dJZKDJ>%#fIs@}S?Mpa6X{ek=fxis!aw+xmy)(i)M(~h5=U86gj;O9 +z3Uv}3aQvxv)R$B)wv#)YbG)AGzRScC+(aOr4LP#zU*bK5`wr@=SobF-80Rh)Ynz6Q +zaZ(I8QlJYZtf{}yrfm*RVPnyAN$|eh8*m-P<;2&@1+RPIk)E4WHy;e(TO;aHTH`-W!xcL5g& +z{lVs1P{3otrJ3X9X3rYBcHPST3TG_U62xywoFR5B!r<+vgqAS41FyHm+X}n<6m3DA +z>6K>KL-f_}MaV)3;T&)=4!EiwEDVxpY~re&bh7`#FPuj4({gggy0(*I$FdC<`q&Yg +zXaY5Je_LN2l|Wf{;xNhsfhg +zRl*zDff|0ZByIlA{ftXO2wH>uc_XbcQnX$2F-2!VK9Er(w|o!)b!<8R*jM9Mjgi#0 +zS>~Butbp#D+`Y#$pkzFC5C~yp6`UCF7y>yfiG@$TT!=LMQ7@6u8&FmjG=-eQZ|5KY +z(gAvdRFK%I1!8KqTU$%Ib#&n=W^Cj@0IE0ABFLJ`N^NsKC3kYF$&WyL+WBh-9oMQJ +zKVv!zpKsZ!0o;DEDBjGB*E(OGw-+zqZ%*Rz{R^opo_n?Jkly@(D852<_x>5m^G9^X +zLeIFyZaIK1!Ny9uRV`%Fz5(#D)?YhHEGal-z#3G|*4_}3%LHd(EHS%q2w8`1SqyI1 +z1qIT@5GnypAB%=yPm?(fruNnjc>MaI3ZE?We-`azcRFzoW_<8!(kYuq;a3zw&CE^X +zG{K%t=nULoWS`67)Wrn{*$X#WqruwH(s%y(kw~(fOHP8hRM#S9_0y$K&yKojs|As` +zq69uy1JTD(1rd^WXBdownJ9Mdn`fxcjdzAu*-hS250jKMy9|8+jB8oODwGZ%A_TVk +zlEitRC$xA3^;W+kTkK8ZiJabc=JOM^9P*kV0YEWdLWg`UMwr>0x|Pu_OfCzg#Xxe@{74 +z0ZM{;w3d`>2eF(@p0I1NPSWb>8W4Z`(H7=9io{0dZiywz7Xu=NKwE9he6oE9-;=i1 +z3xZA@#Lrk=ou`|Vvc#5`9-9;A`op(SVlzQgl*?66Md0nOCh-uLUEG9fA&X+m&mG?6 +z=+OGlBVZWrV-Nvterg#SxaV0>`xzwv`0V_fVO% +z2rFBY`J<0>OIYCOJP&&*hF)A&);W-r^hIMW6+qN-Ypa~4_!C3)0#f7s_D}_~Yuj;# +z0T*rkCTYFStF;9Yy5}6`BBn6_AthzSBx81BkriF|%UzoQj}S5Ynqy~wm#`o<606Gg +z*=hb-iP`BX@TtAY6UBP}h64zPUz68i7(IK$$Xe!z|KqvE@8Wb3jwmJF&=w-jN2@roh|X8JMNS9trj$R7tuC)IP9N +zM+}(L^nP_3=<`T~0WEd4jScoeuDZI|f2$@so8g2TXoZ+^OJoa<+x)>oo5ka<(%C^S +za9Vn@9?(dy<(@}a7LZevlkC<nFOYUCw~cEX!5;Qm`E+My7j&Idc4UG_Nf;UB*#Z14d%<&)amc}b^Evs$FD{!>Xw;tlCHWg{Whmnvhmso +zL^Qcg)_I}X;Ve=Bb2{`}c#wuqnPdvty;bsAbzY2xSK2)LJg_p`KG+9L&tDlESezO> +znts?i(;jDBSi2rPnJ)B9b6tw9T^wVO8{fKSW33(Sh(wT9V@qOyhU?2UJ7rTWsT>WP +zym2^ePDOI`{)7XHqen`Ji!AHqR?g5*SoPwS%AG7cNcjar3Z6`Dx_o-32${ymqyWi5 +z5Gf6>@UnFkkke7~gtgjks~U-YHR1WYx8ns89>Kx;-drqqx*sSq8q-9ooU-sHn?}&c +zs9>(w_EP#BAFMr!-U(ma??ON#bGDHcNZN`O<)M|}TZg-ekLU-Oinwc_6Uxemr!OF8 +z&j5~fse_?eGSc7>;k+TU3%2LlA+P*er~+oim%0MD{eRA +zLd-?#1HS5Soae=@C86nIT&DoBYa{%WW%7|)ejq17P>Z7Va^QeEQPj-9qAWYGZPNI?@9>sazizR%&kGBs<`ZeKl=ey54qMl(@Ac^>o;Q_Y*Enq}rVqOXy?b93 +zWT(@c)xLM)y$VC5CQ|Ij?ZxedZr=6?U0e(s+1mj~H)qK-X3@{AHgxvekA1I9IVzPX +z%L>a&+$@gvJ?#z%s!mKfGNR2{kcrF6wko#o-hhxV1P-0R))Z~e`NqfbqjNnBR*O~= +zQGGa&~w4kWIZ8 +zdPrGs3MC+13LAA-+JE%6b?))Qt}(@ZJ(3|ojGtGpa5ksxkJ?wnx8m6(mX?Hr{I!6G +zwHu;BoCn&cvm^4CRv=O_>q^SaT(?%39yR~UEJHWjRzZ%OppkSUE-r|}-J4Tha^$uD +z!kvmt^|z;|w_0GJkkhLg7``Bj=Wv>v^5cb$M(?V47^65}Nkl;}D&Dw1GG^K5VToU? +zzaVjS=(mHtI9FbY2*t+vs?BA`=Bg$bJIfUOlf^7~gszKbYG_50$A3&J5vjs>Ej896 +z5_`9+Ytm?)sGQ?@5Tju`9e;sHnHVP+9Y`$QEOZB3vCZ#RNG+aEsZNd_sTA{VmgKi% +zd#!!9eu6P+bK@7Fw8{MLt(uM@lqz_Tj>S3eSUJBu$7{EoDyYwL)^sjeJ=y#v7hBNd%Zj6&|kL)S#@*dU`vnPv1?vj^9~S17mWu{<9OG2f+oGvD{3*S +ziKZ==!MwHVU+U|pQUi9#ajH>RZL3+~ +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 +zL80HY +zZ689b`CA41n!>coEB7kt&EPa)$mL_03E`c7C=^EC4LL5CCf3zpLQq@M8? +zfwTbFjugI>U?g$yBFCmK$i-V_r;t150~rnWuuv^dy>O;o~Qx)9*)UMgBRcEXL4L7~;Cg*qptS($l>Y +zQ*X055EdVy)JS2J|57J-jb+=dLVKmV7~Rb&y1o+u4fv>)QYoS!GW*3Rp1;8HE;J%^WP8%v89WnJUA#r@7V#VP(?#wUVF8!zO9%_)J +z@<&-r9?HOKXBO%^@t#brNW)bymX})_sy=Stl=3oX^zChXv!GO?aylopZc{xSKDm7p +zY0hKPQx?xhBsSRwOA0L|Hn#}M^zX$#ApM?i^E9N@IC)T3Pi1X(p4cKRuC0`W0 +z7}|s^Ei7d$L-Z#UB}E7%n|Cy9*AN|5(|4Rce%^f#eM843TS5<%_4ze?us^KFmgP`L +zVVqwUxgs?3meHv&X+(ym{J&_wX*1CM9z0w3@2ZsbXY%{Eln36T-ENG#xH;5l@~rJu +zEdd#IktnAl?FZf98ik5h`!Wxj0l^)1S+XaC-9Z9dO#4M^-fo%c-Un|7|)~lbHxiq +zYNYC}D)<7~%IIP8Bjb>S(YBWr%~)N0jJ07NdbLjn;44$B+$}YyAoYmh(%S!}m!iOC +zP8vJf{nkmzp}Qin0qKyitdsz1q#-pmj +zNzj%uiR{lY;+M3|qrqgKK5gg(RozW_zvNSvtVp5wAQm@OrS(Ov-SxtT5u1OsFE#zv +zHc-vSn{BrAi?@i7b5UzUGQX(M-$C@VfV^g|ZlG~zXb#?>mC3EU>|W_3B;;b1w-Y=i +zrC&^iEh`_J{`>2lA{-}P8@^L=Gw^?z=1%LYG`(H8mJ8P_am4yfUZL +zAwq$Y1cB@S<`bjoh)Fjgh3U|7CMNprd$6#_yHsrcUB+%l;;+gf^r{|?Ys2r~7vQ=6 +zTw}ky#$qdxV@?g~T>nL!#zVQJq50GVF@5I1TDE-_^eKLBR-;`8SCPCK(Y$6x8M0g1 +zadF3!JE`TXd(kYHuS)hGYPBv^CRQyZu^i*-LTaMiUP||Rj%I4-)iSiwD?4m*{4sCv +zt-%suObuVACJHwn*0V22tlGxTeF;5&Dx|-g8KN}3W$IB>=NPN1Ut0&Mol!hjjDQk; +zRZc^50$i4qU5IRCVZpzoXfGyh{CRx;oJ8B`LZB1U9-*i57!u792%*+MQome&tD@a< +zs8RgkU#6@dBx6-JIdEEgSfms>r1GbcU^<3`;3hhICgVSUfcjHc3BxuoNWikv`{KX5 +z!|)dU2;WGeR~w7R88Z0E6vdx*5xU|$eoHjcQp@_=k3Xm72PBpVrZR{zzg(dBmjTC& +z_=&^=Df4Uy48fs`K`<%x)}-XYExMJ|4{p)|6k@CF_U3HRhBb5pG$Y%Y_*f7^rnok +zlw2@;hWA5!K%LoO;}CIWEsB5I%77$h1o|?L-akA>Y(16!^nWC!s_Z|DhAuSqr!}(u +zZBTfk%Km@JS^`moKZ~iTShx<%1Y5c>UC}p{KVpY#w6ZXbxqJbuDA?(Ntciyx8^LQxy +zAmsGt3qbPjpW$>!1(nza&r2%$mzPymgm$!SOkzc7krQ)w^!NShej(aDWZ8o90MB86 +z(%ibou$#T$zO3q$=O<&ZfeKm*J&ksdO-PJ=ogDu!X6C0+U +z;SkXic@C}ejBBS78cmn7N`lsCP981ix?g7vwj&`I&rh8<5v!{`8P5mx^NbR@K0OCi +z%>Mc~X7w$$y|*+#6A)Tq-$R(6`f#w2yDuEd&wkaSvFW0LT7W>?%k&xVb^G5wSSUYL +zJxqZvK^jSQ=E>elKlEt38zg+($FWM*9?u;OC7UPMqIztz8UxPdwDz&Kr_Bndsp|Wk +z)?VQ++7qd0`R2t-^WM-}F>6`Hs3;pu{~YiX=3U8}32p*t?XEA_eGIE`T0EaDBIfm? +ztlZ1m#&j-*k4|_?1(g3Zq{vIU)%HzsctdxO{Hg~B7yWpS6o66QdN(3M}}~xS8H{)Dn1Ls?T3igg=T@+}2>5z9I#Mh4PgOU8w3WyB3n6W`aTY53u07Ndh*H8`(E +z7^|n-A{ui8^T^DK@*TK8=IzL?_Mno(*kZ9Oty* +zD2V()yYqSVUt}n*+$_738)Ln$TaDELTMBXazXsqYLtRTW+r4PX?wj0uV)S9sJ#)b& +zY}npGnC;GI52vq&XD>*c)&?(U*UZ_a3A7CP>$qL+BE$szb+*-d;e6%!WZYb_n=#3eDb(J{lW7^+_mLo +z)CdVHeQWG=MlkvF378h9>{&qpb(&Mp`yX-U)LgIgd>em$+;|Nflfm10fHNB@@!Z)9k!KbccqI*l$?saoF}xn-k!;MwfiC>P^` +zITVZJG&xZt +zQ{L3Md@_+qUq0M9{ft=99&mAiNy5fjUu&8CcCVFwo+M2-*IBNq+gtNI=qoh0s;A(Y +zmePLQJ9rvxzn(4E0^xRVX!j{e)8KRsQ(o^6*@tQsJ>tr@n$)I@vX3`2@2LzX-57bL +zP(!I`%lVktY{dQOQFnWx=a=AY`8Xwa5JV$Tf8|SGXRjRIdJ;}c^D6o;-di6aGr3P~ +zlC;$xM7>JZd427>;_G$$qN>+#b?|a*6YrMwrfYk2=k=po1}%WnG0(pPSA{g(K00Q8 +zyl+pzU?qQx_-W{UuRMo +z72KyE7NeI5#>E%7#vcuMBn9+&-JT=VEv&a42bacmeC_t-`Sbb`#rBzEgE)l}s~{U}5Y7Ut(|$o*!Sy_5Nchwh7#8>VI#%?||%e&0bnMh=Mr1l#resrP9>(7KS++% +zEX3+F=B6^!Xa~+tZ!8C4443;ce?Ps7>Q?-nTjZ{9%wLJu^xtWsK4ptGG8g^}=bN)1 +zAtl!Q@YSNAyR~+AK8)rryh;d|{+2M*!OA{#!L;nrc51&~N*oxThp`iRsI`JuH|~-B +zzD0cdmLuHC%jMEcQJ8)Y(2aR#wi@&7^mR@2V|87HiaTCg%>o$w3ALgcU@EA +zUs2||__P==mL$eVux%-3aNpnxsLM{0^3(a9p7oOlkGm3{-Syh>`z#j`$qSWX#8yA% +z8+bgd7(@!C*Kwa@P{`EV_|2U!WfQeirdXl2P^zX2b+u413Dtg3{%88GA3iU1D(d}LOq7~k +zBn_2DC60BtZZ;ae&3NsY9fD=A=M8_t%X=Muob!?x264{1AD4X@BXreeGWxi*(6v^*Qy116C=yo&mEqBJV#+ +z?cS(NdhvH%GboYkevwO#b +zwr}3!P81}b4yel!`mc$>wO=V5)jh)~95^Qjvo%8mIik23L?<4+iz2_yMft&5H+40p +z{t{8n0Q<-QT1hOs)KYF03`Ysv9@n)JW9Gd*Y|kt4iMr$!=o6alLuxuH!*q5^$A-Hy +zDJh2zP?NkR%=Guqdlfi;mFnK!u5wjD-?)@`P1r<_(Rv*(WI=#@^M(yS&lzNJ^LlIQ +z_@e*UlL)~0KO$Ph2j +z;HNFGxqg)C={ybBh|&Jk^l_m_{O7fJE+lJubNkDZ#G=jE$>6>@4pNXnY6dvBdc2u2 +z+Zbku0ULh6+{X?ft2A}*@z>7K<%p`A$Y%@qZN^lkUwgq-1&?*b=*J4UIq=90=ffbw4jV}f*pG0FSE<}_FupALJCKPa +z+>37i0Rc&sg7wA5ho?n9Nl^oH3dXdFXX&K(mELf;?G=7Dze5}`S2X&){%I+PLWRN_ +z`RlttmD8TR9yvz5Iwmwlc&8Y^(Q-l(_;tZ6 +z;-{}(w85Ph5!|xr$+SNRfo?9#Kc1A?Wf%4Fe2Xf&rfr+$!DvT`!a1`Pbq;(=CGj%A +zW=N8m35AO-6F8NVIxgho-{ay0KZpf=d}w!eo2<8dcf^}Bd_6{+$w1?ZXH-$n +zj{`aH(bC`dQ&T$q^Kvhdwo`}gcdw;>gx#CHcn8w$*zE<^o_9RQf}fMTZ2xnF9|Nkl(LG0nEyNsMU@j1qf0 +z3z;Y^zh42BM&>+P2)^CM`85Sd;c(|h<~JWjKLhug0p8Y_mz_~cFT!J*C#}M!p8uA3 +zVBB_d37A$|C&o3=U&GzMomBC#r7?^*e5vqEO +z&ln_VVpm@dgOa8^PxM}v;KO7GoD}jbl#Ua?Q~YDOH>-|iT4jCF%T57gK*M&|M}6+ +z^2?cFazgye^Q8!7zw;U#VbHY%6mvC3)+OGk|LB*^cW(Icy +zc*YCl=wqC?G4}l=LM84?;7=7pB(d~uP7omm^10KfCN`^)c%e@VdV%@x*Pn7*kW25S +zA#S53zjzt-OX@xhw0ze59Q`6K>F!g}XNQxrnQ~9Ife8|Vn|(DX6|m9W5dRgD73sTw +zF*GUVZ1~g?<|OA;65uyp7MMFFclS^NT#fb)SwlkA^Aa}>rOqxmLWnvKvi>}_KWfr_ +z@qL{=Bupi5VQii4>_SUgfoZUMA|fGxC8g|Pz+Ey)ZF38Aey8kU +zKw%74xqQzmc(er4z;(_V%hpvqrl&jA38jk~jQ(-(clQ)`K05z%#B +znwxoG5lDF7J&52n_BwJoF1Kx2sY?E?-uiDI)plObj3U*_3mUejUPaz}EIEbE)2K?x +z$kU+Kyi@oolkFpKeoWQ2;SH0;oA-B=Z}s4=0;m@cKSX8W`3AiT(KqezCd{U&YOf5Rp7)0=QD@C +zld}zJPVttK{rG4;BE?xhCYk&w`e177OAg3pb7h2rSC>_-KcI@6lKBd}u1&eYb-4$w;koxp +z77Ou@id#gy`8l`-_|&nJFJ|=_Y?AzwgNKJ5EUb!2KOZ~;KTrc?ByR++M62+XK;?Ff +z*b*PJUcPmw=Ut83*Lz)X6IN1$@=h*^q5AR`$`H!s)$+J91+7+cU2M8|N; +zu3&vjN8(oKoo2g7!C~#1QA$Dfq`)|dxKe$3Vq~&(hSeF2WF~vh7gU13r +z4#&W=0YN%v#EOz4}9oT;*%4 +z=(;n;f@j-`oX>KHO*q7g2P;e^;S`0f(cpuom2sz6SrCe%rGGNQ!1CViesll8&>q<{ +ztzkv_0W~q?&-kb?LkV>~Fq_*S6go4=_MG9gV6uS|hEJM+GSoK4S{4x!QnfAcX}D7e +zb1BVf#}>|3P;E5^p14kD6hF3wu5gyND!Rt0&ECRKGa-Idqs<9 +zX}jA56ws$BvXs6WOYwzRy0bN4{%a}2%qQpG+;3iN5m@Ehb$em$JoD_!xs7Vhkj`h# +zGQy53r}R-@*zykX`Xihy;IGzaMfU(+1!*@I6-KQT*Lv3G8>|8rV$FmQ!4NM*I;eP9 +zto(sGpe_vyq(#+!^Q +zqt`xVx3&lbrxtG=@18UbM_uUTW$b0aicZ1z!W^IjW2+>pN`E7=6qZ+)H5_v>dgo3$ +z)*IzKu0SNcmr|f1zm!rk0UMBBc<%Kk5fYfN*EB29^qd3=B~FsQ?z33rf$xwJ0<_HijBgNCnBBs3fU9^?n3~KgH@*PvdYv;cn>fvOH_`Xy|_1{JBz2A4~bcM +z&NQbMR@2LDg^?^)^LS}CAGKJIwtZuOt*%=+;{Xtjy +zs?YFZH_C$K7?qt@5P>plIn&cU23D6&FB&Dx=I&OOqwc8PgpbSV0qOKo%Ww_sX^9Ef +z=^mUS68Z9}?0ZSAgw7itOh;+^;SNA<%5%aR$=IT9DXFi5Lhp^nN7^Zxs9TI^0g#Mi +zD64yha!egBGiGQN=!L7U}gLt62{9(os2#^<1t9iXoA12d;>~+(@l0__^u(U9eB%r1Go_s{%Bg4+<^U54$qlhl0`;wGSI$0=hMRKs(V*)>{_1*1srRK69S^NEth3^*{EtcD@0%R-v% +zsZpVJM-A69Hyoa0Xu;bx$}n^wjCjKa`Y_CCboHWvKo+48BQTgT#VVo&k2_lUQ?>G^ +zYU$@8l)HeP<#^Jy7U3l{B#j6hT9Zyk%Ke)g0CnAn@JS(r +zVAf1{=x;Fx8obU73p2FO21OR$^C1-qFIhEHudT^%g~F5F{hg!VS|`69HtTI5@y*R= +z$A?D;&ySUstbW!H+_6YJ7t8N?n|)Z5!hh{tpkn1O;at2GrS}|`X!+rX60j)~AR +z`_O_qt!3SzVqu9r64UCdN?eF%l#LPy4e==^M4?BnniRSP$znWbHwe?=f-P=HkxAZ+ +zo4pVnQbQe`E;;O?gm&ags)M%>KyJ)=qi%huh{RMESq6}nvlPbu!X*v>Ws!(L)(WOu +zQyKvcr=xF8tjH!8e_exb!xk4%=|${WCJ>9bu)<7bu8i#`15JccXdk0z%gx4%gVw$% +z&Mu9SBe__E^}5h#q^o$(k_^?7)^oPX!fs}TB*Jdlf@lQuwemEWvEL2VSUe^>-^Io% +zpUv3;%#fWehM9FQ5I_+Hao;ANax}oy!7}}kyLdxnhqGu`7^^aODrl3%Cg3dNL72OB +z<3QfmaOJe^JR7MJ#EvI5AgzY3bZaxyiOG5e+EU%*Ah_(vj37eE+ +zjtO$G2)AULK46Yj>9GX1|Y#oIRIG2)KWJS60 +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 +zF)Wk`W2RS4!d8HW79@2`uKVdvrPHD|lZ +zj+D)6nXG@X!sV?4y?n+uEU{Jfjj!!LQmB~R)}PN6+sB|~v+%t=o7cto+aC|*m+j#6 +z`e3ADctGqm%0`IjUFzxPp!AQa%$bRyO~epK(f36a?xM}>Q-j*FxqwN0ojsfqLzqV* +zq7sB%51#znAO-vqNrBu;%l!V@vdA=4DO{iLzcO?(*AYr)!N^1;?D#2PJh6D-^+xbo +zv|2D%jaEy$`kaG+DKIq<0P%X+iORCx178e5iCFqzBS~5)Zg%yZDE&vQeq$grC@jpX +zfsseif~S^Rm6M&hJ;}nrn@fiF&yMWTx*(j^>J6NJQK$0$N@c%Py~!1YQc;*bn_=3{ +z&*v;W-_r$IkL@>ZH{bnWSjG_ +zw?e$T!aA*Il=6{A=qapk;`*bNkb+LPVAR7PtVR1y2IhC)a +zuIv2shdWT%*#If@pITE6ZS(0dDi6F-XE5!$;>U2(b%K8F{IUJa^J9;$!ZplR6eb@d +z^1`Rk)Jvb8DJd3&KN$EIbk7Mr<0Qf1#2>gL_N6>(9E(S_?=e+x(4pKswNUmhoCMR( +zM6{>K3!&S{C8EW`v)#R>SQRU)K_~Rb?x-wQjFPM9tVzGHL--SFmbVM|%j-~P7_sV# +zl`*`K9zFbQbV&z?BT*fCMY{WkG5#GVN;2Q*6mc?-`SKgHkt}?{_;oKh_KNH{9 +z)aX21N3>S?(84$q7SL`l0su%a{`Qk-MoV%As#vNEfv~HY)6pD}i4>-**0DFg*wdmN4m{?3PG{j^& +zawhKJszPRw=sibU1W4IvGPuIb&FJk)xIGl5OSGXpvG$cWVk2b*wgPY`-T?TENf!t2 +zbY-6DzDp#6ttkbKf9QA78Lu&=EYi>%3~7D6^i>@if{D6tuE=N@pi|(AVCq)bu7+@- +z69mo`boEac{hKhx2u~wy=8+3s3LSRn=C~sax?W$GeW6vsASR^7N9${-hfS~xFxiIU +z82B*YuJps+w}@W2-8T$S)aznh{3JHSmZ)yPKE++I`{bo)i0{~=WA`;pL+Y~gVtVLj +zJRUeWjYFps_+kvp3B7Xz+7GZY6whN4KyP^~q%An(6oBlFT=DGSVCAxmD@J|49CW_Z +zeSd>5oicVEC)(^hmL)8`Lg%moduNI+nU{2i`CxB|_xN&UwO8h1PI>!7^m@~LEvs`0 +zd^~o%0A0yLs;UoaMKE4jSuHO{C-kW>3w0pqceV=>6#RI%9g_j&F$JUnI|vI@#CjQB +zVDS5!_1^_b5!UOC=rvBvOc_#|c_EhI09e)k4xCYc@NQ5C5&)FQc;LV~^0_!IELC@a +z!>;Z)qWZM;;_%h$*73osqeim`4_|liVXOK2q`8j?T#s9=BD;gC09KN&abmTAIEY-B +z&4t-qn9YURYY4N*Crb?S35c}H_EpA(v${#{ip5KeIA_O`n_+-1BZWycNnLp$b{eh5 +zPUA(h^~=tl#C)ku(e}73%Ve30LgS5G^0s!nGh*af?@93~iOXWDH!|bmmz+UwX4*v+x@C6iMJ|yc{UR4!oPu%h +z>HHLovG*jN8_!ZxFz!9oDHyS6qmd~Ghm(p{z%@d+C3nM`8FH=I$thfBP^`3*BlHyVH219!iuPeo+ +zD;4SHfp|qZ56)eui{UZRw}pJ7Sph)uc)!!3C?_i5D6V`T6YEla4lONua6r#xjMG@C +z1}b*Q{+mAzyrDNiO&ZR~k4_l60cy~2d0MUGlc$YV3r{V}(_LuS8+BZQU{s|bT%m9= +zii(dqHP=OHoZ`9}k-@Om0dLKH_w`AI(*HJbyN1$dn<6>~{zc3B;fHlfzUn&aX78ppS5iKc&+QcTN_OWgJg;fTLO*+ +z_8yO0@K74%Ca_CtG5(%r#;XyiQN_BIF`gsFN=t#tuZ#C;rGYr$3B`0^K$rkVaNc-t +zG{z{D+BH1I3oIdc;h|;R^mBz#B*F`wkxS?TRf_vSSUVQSg(3}NJ&Xy+$T}n#GTuMO +zn1->Sni9zJr;2kl9_h4<5g|Uwkw%U*{w|~u9q(}3LGD#h_NnwEen0r-5GiZOVL0g0 +zkb-;~oZVJ|6)>4G3~6d$WRexd2#y4yR1t92T8Br?!=r;nYxh}m@3;vZ55>q~4hl{v +z%5>pdZ#;IpwM^}KJ(*BM^;pkt)Nf{7M{XiB4RG(st&_@#nfYb=b;^~qu9U^Bfy9T@ +z^f3HF1=Y=2>713$S?QcA=2S6frE^v~M;bZO$XV%6h?U;T9G%V9#lyKnPWQAZkuG3J +zZ*s+W@zx=g@4BHZk#@f9JIzdH#Dv~Rz&Hm=g;7ceKD>giOT)$L;_M?CU}Q5Yb|&Yo +z=Wq;edzmsf*(LS1kDo=94Jh~XNDRZiOk84PC+v>GOHtCx2*$R~rj2(`nEUenhJ`ID +zSShiDHMH9qr3IJF#Xbt_7XjZBhNDE7;M +zFd53r%i%j=KNaz20Pc7u*wMg9BU-{imVkv$DUg^`my0i#=xcRFhJqWSmZ4lNi63ns +zX6G?o6)c5j+;E4eY`=nX#*0|t7^tWwE~s5yFA7KbTUNitH)7+=3UD61s`la6duyqO +z&SiDo44O{-7*<1rsL%(Z98?4zXWXG^1pU^91B!_!6h&}A1e&0Qvr^M7+-=4^wAqom +z?r9Vf9J{lzzPhscpN;i086k&g;7)8I93XcXGB*GeX#`RaqQof8vOV&R^+dYm1Q%}x +zfP`HpjP(%aQbndx*w}LN^ysFddtx~an8|eII%?se~#&#S%{b$F>B#6@?|bFC<{0*DwUnL +zYTgAG0-&k10|GtGD5`KvE6!i-aw(3V*gXSt-o!dlFRH3^@*^XdxvZO;m1}FJvu*Bm +zIJV|pvTV)&HJ;7ALw2os8-A^sg<)%6n`3LTEl9c|idTl0T{Z);{^ +z+~m}7>E+LvLu-B<7A<{m#hA3_m&2tsZ^@=LljOdc!l*TKPHhpV#xuz?#k`uxngu91 +z`-@n%rp>d>Ud4=D8@Y%!%**@5*$z_bWa8+!LMxnfJ6~Q1Ys-~>;I$L(^(ij*Xa`|G +z>kWMNtk1&=<(`kHjd4OIv2gl;u+NDtV +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 +zPe)SkA1B*cZ@P)*e4}N_2Fix+{(nIGG +zZ721kvZ!uI^^By!0P)9+{d0_HJ=pdQk8Rtwtv$B)*tTukwr$(Cwa2#YdFQ(Ce9!mf +z{p(GdBTds}CGA=(?XO4A6CZFv_x0+|@D28&8Zx4wpT8%hw|z(Ux-~KJe$)0OhO%9B +z6W>2g%zCS_b%s@<`+8N-!ZtZ-XSOuCvCN0ilJCAd@ayDJ|ByIUJ-bHevh%x%*RC<% +zldjWm_l4XmUSRM5%N6yopzX73o?;}82`ld(rv4nnj$9^o|;O=G4j5%u;`uE1GK<)AfgiuhZ<5< +zfz3GUbP>pFe@h9=bGjr1sv!$BIMQPHGnk2}0Q+x};x*c}#8U9uoJ&^QsXVQ`e{La> +zAnJ6)hD1`n?vi2P_eg&}F=RV#3tYa{5Y0GEB)(M-XC2O*x|^~Wce1{ZAK6QLU8Q_U +zBie1(D>L5ICVtd9AIz&2%+Rv`hP{chJg<&KW*4rEPoGiiebXE!M;I5^D8EXP)ifEA +zSr;Ro6tR+5bDB>}T#OP_2iaX`H#kt^XV;CGD`IIc8=EBj9T{gYtmyn8ZzZUhW2$(` +z_lMcGt2hPPe;=(IMhDOG&M&5Fndvp7e5TS$e0W%M!=?_fhuCY4qkjCTA8WO_ +zxgpxF0RAW5s_ucfr($d?+!8C7Q_$BPW~M9lO_mWa@?H|~%f>5S(J>lmulCnG*lyQ9 +ztJqDa70)^!-&R>o8O)i7JW(CUj;~A7K$@~ncvtyRm~Sl9S2c-$zL +zkiDD1_N>0Ae&c;~k41&jVFt}4kpmYiAtE^^8ij0Yl-lVAehHmIayMotk;>*9*&G~x +z>t=+}i&FYn>}uT%v6aS^$*r%GUcSvJRBKir&+m(CpUS^|0Ak1)XKs01PG0O`CvI6B +zB1rRLy#Nyq4{r(&@+hcH20VXUU~EayI&?1O7%71-tK)T*!;I|p)%Yfw41RM-aiHWv +z9-O|}_aMeX^CiZ>ehQ%UZfjjf)Uu~^4nvg!T)qbanmBN{GWdsJ2PM5uUFo4AOJ@0p +z!wopPGEl@zh0@&U#NbN4QL5-M3Dxqp6(nI%QR;iH(>sb8QwT>0PKBmBvW6|J7DrH6 +z?~gM1INb^Df_Jag>1NfWG9daxR`XtU|5F=Hf=hamc_Y6bCjZikKM7_J!7vb?x +zW_w*mO-q@vqnSj-=M7-0Bm9j#>kxxkb%}md>CR7rC)6T>qhL+@@-{gEMOwck9V1>Z +z2!Reqooxb^ZT1DHUXF^09ZG?2;+&mM6F90-EulhfXNmP$aSH#XFr6za+$rOW){Zcv +zKL!>(x?)K0N6D7e^5viT&-=?Ov +zH+l7o9{P4D=|a#BlaY?$O#Ksrqv5Ivz(k^lQY42=Qm+qRzvgjh4%&8{1hrO;gujUo +z@@@h`?gU1><#GPtf{h?TRFX)&VS!5WK_J9SSFsxIUSx`Gk>G-=3f4E5J#=B<2YqMo +zxcPwCM?o+GwAi7P7~nOE2!NGu`v?y*K8_5x>$ns`=|5@e3RO^bWFX=?f75rC(BIgf +zxGdn1oBFk86DBCqnE5yl68{rN`Y5@8xGnmVM62sWeQzY~%+Ze`v|}0=#%pqgd$!Bi +z{?9Q|1Ja2*dNFv=xr#wu%6&Mp-jUozSdno``c`-b}Y|h-8XH +zM`5=a6xmUdT|b!sCfrC@8^85?c_(iujKdyBF{~UCbsqqNM`q>xms({Jzs8LNtyScy +zATNK5jBxt0a>rFAD^*Z|UFN*tTeOsz1p_In8_Vc#gb@T;t|v{ +zlbxF@K2Ep$o6=4({6ovZB;v^-_Jl^AF|S28kCJy~B;wVpkOF`Im>KUM>z2-8cL1il +zGM}|`foS>!=H*oP=)&wBiu{Hrqei>E7HypFLrHqAwa)i(+|5VI*GAj-DiMbIimw3` +z){BqMOE)Q?jL_;RB6FY&FI?z&GUOb>l)fa>>K<-$-ZXe0K&b|d3%vAjdqv==!x&^pc;kVVTksqHYh +zX-e(}5oF_^RdTRAJ`-*-)2Kum;Nb&fH_~6`6neLKc_&ac?DmrXYvZisDh`7$OdkpM +zJwAx8V8(&pgo2P+R;?W#2}#v}cbOW(?(nI-&>DB#jD8Y(5xz+Wa`||LV)&M?+oEvM +zSg`~&WwwsY4|IVQex3QM-v~@}BlWlj-2(qGLQ~6^@vy&k_Cw< +z2298{>jeG@0Hc5dZUwK#A`XE2JPpdn&Z{PpG^1s)20_FW+LWMCMkJimfFm$d22G*K +z3X&H3LPTI)9rlc*yEZV-Ll26d2Ayt`m;=sZ#>}znp_|SIF+tLdPp7|Tm)k1!A81Ga^ZUu~DEglbYr0bA +zAYl+J!m;@$KW)L$pyE*i7S5@%i7ujlJIy731~B8n*BD@hQ<$Szd7ZXWutivOg%2x- +zfXu$=hJ!hX_#;7pg(^C5+$ +z0^2%w7aXlE3bjh=pD!+Q)lDc5(e*-|4uI!FB17B{Di*K6Fc`4nF|btb53Zd!y4H`! +zHTQ^|XV^i1?*MYCKj3#%#V;6$K4?Kjr#p?=7?X_a4H*JyqVb2r){FG;(RFKH2<)kvSu7U%lTmak2W6?946K@7Q7TU40JQ$EncEjYLE +zBzuE3JIvQ^C5v{S_TbLux82tr0z_-2t=Kf1RKC{cRQD{5%oD5kjpd1m8i`ira%NRh +zk#|x+?LpLBPEEDvV)sZKnt%Iz*J3p|k`hu|C|)Rr-w4o4uM+(uSwu)Ezwz}stNwP` +zPQFx0kb&6St?L(DItm9Q?Mzn<9hl>RI&3k~Taz0_>NO;dc3|ptI5n2TnV+4GsX;CH +z^UO?v`^3#L&rFb8A)hBP(0Zn9iN9t&91ja8Mp*bm%KBy77KRdM?*%(x6tVnR;942I +zCS!>j$OD;51(BT6*yT>OICFZw2yWQcC9TSXB8TjZtOuW@BitJsVb-*6GiCW>3EV2O@m)&U&274$K+PcIammSxjPZh&RvYOUw3QCV +z5CvIhvWQqax6d_00PuDosdhBz81ZWY*5K=roouWe!b%ZLJ*VUwHtRvP_pcWTw+}IY +z@=#p}#7Y4eauTA9oKq23+7!h$!A)yA$%kPV%%%XK4W_KEH;e)JMkFD^5c!ia+CkV* +zN=?4BWmXzQ(n81|J^MEluz1l6@YkZ)(2puOpT!2_j +z-vxSci*uODBb{rgVeSwl9Do*e +zmC!cbEO(%;rEaC-^nDI8?}KD@`rk8_}u1l?Q2;Xd+sX7PBQkyEb{2i~(&PJ`aa3p;$7 +zLM;X*7((ICPH0`M`Hs_Py=lm$$oTx6Yr5>t=E$!@VsGZ*`0o0L6>(h_BS3g^G9t31 +zr4q&*fWv8m3Zj<(FF9B!vy0!!{9G^?Jd(+U-O2Acq8Ls?LyT~(A5A3yzrtAIfvD6A +zO@##v7;&&}@LD=*qn)}a?*NA|@lL>C_F{dUK{oOV&^RJ58xbL^F8dYV^y%M*ta<#4 +z;>$P-y`S+t$M0-7jGe(}%S#bl`TEo<(+W2JqJPWt$wusl)XP2de{76o0#k7fS9wS!!6Pv?lj(aWj;kaN|Em4VMH-?%nX&^=E}Ui5OPKffOkj8d#lEJY*`QW +zpEK5lj{rd4^=Y0CG1EhkqY88jIN+2>S`o%(kO+4Y&$|Y&C9p&#G7;iIlfh=N8#+-2 +zm1s~<`=->^8U1_Y%ST}zv#EAFgeK;>GhFh%n`XyD*VWD!?LpMRoB$15S0`k_<=WG% +zZ;<8p(02O==ma;`S=KJQe?@KZ)%oPSg-r2Q=upYn8E}&(DG(pA>%MZ(H@EjLR$yZa +zzyg19_O=Ob(n=&yAyOgOG-0Ai0%+tTLiL8i$>XXvY)Wxz_R}D=8l=vo1r&wj=+83( +z!4d!G^x-~u(Qlp?_>Ts?t&NcK!ML$e7ajQwK5%GKR%_tO{Gx6w+6>OsaFe#*p2ec; +zz%dQQ&QjqtafN}g@owxKkda~v=(m3N4n^u@xL5^g4FI&*LoZQm6qN?zZ;&YRYGQ(U +z0)>Sa-B=g7jAWqD6l8i=I7Z0_dTw$V3cuc*s~#J^YKTp|3(q6$E0fFA_QHJE%7((% +zPODBQYvEDHpt4dVP5oaRRZ9p4rGcdp4^araOJEGYz=%}6?Ys?)y=T;%V6eNrNlv^c +z6sJo3t=PQFk`|&v0T}h~H~N+IBy3wjZ2k2~whjZ|NSqRSHi`+3l6@SS9{XUua<>=d +z+!QYi_SfZ_HPv%^%T}$k$mEn+T%u0A@rlxNuK2}6AE$c>%iO0Lm?zR;>eLdXgju4 +zBpFWh%Mt9r5u6kHX0J82=L1jesCVeL)3+y>e{T?fMRiieJei!r8p!~1x}~)`gB_UV +z-kKxJ@tAo$qD1NB+*Ai2gk+&-LLA$SCds655P2S`y*$#SJWW)jud#teC!%*mRWM~< +za{YxSi8Y>6Ka&=pt3Kut^HvwS6h5b%JlK)6r$n~Xb +z{?Xy;)$XLM9~UYb@9O%B)H=S7-;n&YNy7zPgCbU%ey@HD6o9D{T>eom?Nh3rjA9pR +zikk@bDG}W+5S=#lz=8Anz$95pEd$a1^B&29O7xI@K8(7)qY#YS9$MiHq;WtGFR +z!Otw?ROyGzO{3Q39kf-V__{e+DOvdb2C%olwa?EjZw=r+-Y<6CE;30v_NN5&^$A|; +zC3d$toPx<8($QYw9}k9_<=7@CO6#bDxK0H%%Qo$ii!!gOs;X0KK!9v+$)?JTjFj-6qnP8ZEdRUP1(J@6f!vX~i>os25WiZr6hJ$VAJ +zP{P-xI7+$uHD_r@I0-<~cVnFoeTRE%p?l#W3?TN9eF~@XQ+$jQ$tp +zF1A{_D`KPFBy+Vx)07-k#C&LP{`%;<$3-ku#2oxv(>3W#k)F7!s?~$1#eTQBZ97}* +z+}|k|dtes(*niS?^(BwEYmX>*&ZItSugC3U7U)fBC@h?2hrl +z6XiW4ag?R}EB{v$-UuJOVQy&s?BLq}-SdB%f5Ly;oq8i9V;TK5=v{T_H%Tk>*6|P> +z&d+l@0&@}NwML(~+&emb1O9YNvkNQ)U##ulXZ)4_BZ`ot&0v +z@O~h&Xgtg5Mi?FOC*?AvohtSeA +zX%x;lf>G!j;tN_&fEGY*f`%P&WUO2WabXyY-(q?ueYJ3xSGm@J-6P~Y;11=#z0FSQ +z`MpFm>`VWxj>1;3TLGRsQ4B&3r|djOy7lWrpuk=7TJbct2i_@CXdjWNtsjXdaYS06eZyOdDVYlXZ$~b7X +z>0CW;peV>bL+sZ&rea0)f0&;|GSPhhC_>DagcsnGS3-MsbJQsZYf?}MME}gWiKsLR +zG3kGqivqOlh2cZvR|`p!d)?+KF +z;Cl#TtTAFOxu6Vs4GYZ>16F9MF=Y<=cH0BQF&HC1-dy~7aRR}8BB_EeVQjbH<*Z+e +zKHGXW%s36Lnj^LV9Ht0!k~5yjZ{oVxNPi3DS#rR$c*8r56do`|qX+%s_*g2Wp_aUx +z2c{ZTQ%I{6w3&AyM_OKO7ty4XI%-h<6*TLYC_~5UzyD2nrs4W#0d1?<2T++h9mAm! +z4Y?sF<|OU<^L{42*@TH^oe=)E(`5GX +z-hyVW>+A3h`%K7f*W>4 +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 +zttSSaRbnuMND~+F!UWRZ=^X&7#ndf2bXHe +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 +zH?w+#pF5VjbBkOq_v-5i>s$L&*#V2I8O&GN>c +zmL`Bn+K|pcGSTLt%+d`cWg8_s-Cifh$<=NRGJwp_h|^8LB69R)4;eRXpm1jD-fd4h +zcG)U6IV#rFBzrw1`Q@LYK`@Rw1@Cm$9F77hrrFsU!>mN;a6xd-T3g7()eMHM+X(^0 +zk#YjlSyECK1$}sPra}VDy2TY!nKCo65G?d@nmFEyk!(CIZ)cTcCRQq9@7(Q}X-qmHQW(OtU!^!87x-&>tOr&*6Gi2e4fHh~KqJRWN>;Q~@U_H2qz2L7c-?6qqs;mDc1=WhKLI +z)VE=z5hncT4k61GC^#DolGEK%!bqLoHCb{w&)jw4b5rp%W$ +zRltbLu@*$C%UsOGbjbmOJeid<&aOd~U-3zdj}O)v`?;16igfJ5N&0FAaPej~fBxg+ +z3o(*K;pX5uD+j>GA%=G$$(kb&VX*=3hPz}3d3|bWtav622FGn`ZdSWuxVXb3Bm1{| +zzuXOIS(l(_##HI=h0l2umz>4WxrTaP7-j%ZlG`tLySGum*`6rtyqevdX)zR?OLv{gEzjTr +zL?$=XLnxiTzte$@?R+O)v|@=6=K_2H!r6N!^P7ew59{cOsDrw8F<^UiDft|3bT=qHe(S4&rENpk{dws|me +zA{n$<{oT*Yr{Fs^T$4$DQU{KI8b{LcPKwWC9L0lk%=phHk|_Rg_lAgN@>l#rKf&wp +z!N+Ylh_4Rxb_HK{KDPm|rpJ~I6;^ob0O#}Nzwk8CU*-n#%iJ{fm!m{x5Kwt!8(FDU +zLMR|3%TYX9+#?kYjHD%G`&#v5VLaV}B^qV^Dkz0%Os9l!&OBA2Lg(L;T7Yg{xn3kz +zX9*8dci7eh+NJ<<(PsvIQ}0S^2?Ns=fuk>lFgx#O?d5zJ=x5sMT%^+Z71;Q(IHDo+ +zfNB9fYyvqx3f6e;W?UxJ+C{FuhoGtYLp}(~Fdr;CgALnr(oE>vTMibS;_Oz#$A}!8 +z{xUb8U*?v@f{yvi+zPuW$By37O(%ngk9n9(d7a +z!`wiw{$p-r_Ww6?bDli|UHE@9H`4z3^78`;04%)zLc?4ZpYOII~sh +zQeIg7el)p54QsigymM(Hl`%a2fvRc*y$Db60ox!apQC?(sq`HYxM_{@BCXVQNZbHR +z2GIDbHxniv`w;$4sGO$m3Hph*#|-20IHCBo{omkzB7RKSH4Ie~0-hP|diw-2NhYLU%Nk +z2=Qgyn~of3s{K3o8V|wrl^F8Cq2l1N#rPa=&{Ear4kO4-2YzM35#j$7nbuEQ4Pl42&>Wb<-qDdTr@>cz1+RJpeT +zJ{$DVS%-HfZV5o+FLRxd%(EI5tMww>Ec5z`6ziuDF+5TnuwYr<1oHtyIgxBAPcG=3 +zc#;@#sLXUeg0*c_5&CqHQ)KIKuFbR0hKD98c`M!3(<5%a^>lCy)iyhrRubEg&A%=X6L5kOQyrDKb6NB +z?g-Ubgh?{w&8|Jn%V7TI(V`_EJ;6Ln31;%M33d@inYmm-oAYjHi*!*!$FHA=mTFEF +za?rskX^IBbx9Q7C@KfE)+my|sUibAiiq9gnM=LF<-QE=m{T6$5n~EWbD6t0fwQ4=TC|E9 +z=z6LDtdmou*&9Pp3_@bW8?L5LRsMKEJ=lKHjj1z!)7l`KI`UT-k=uoabZPviXOK>C +z21!TCb<*}~kO{94hM7$vi|=D6;|6%6lAItC_gnmb2z#d}(SkPHGHu(oaniPJ+qP}n +zcIHXrq;1=_ZD;3SRk!-S^yrru@woR>?7d>m`Aw+2&t076KNCqif_oa!#pQCLv$xM8 +z9jXdd +zzL6NEM7NWX@gC{uyF>x)?u?zh%n?sXju#3Ssp!riQjHd>!SP(-;Rgk(D68%jcjP$l +zlX#wh-^t}j0&xzDnTPu=)N#x&VkUrys%qN7MJBEAkmQ%P;v`)5Npj*0pJwdDDqdaV +z++1GcUfpotGUH`#p>8ck}1_ +zCI2qyxxM7yG{9xz2jbrsRkw}tYF=^aqNoxI;F#lrHml%vC|s)FIvB2uYF_x-`KpNM +z3hx~rv&yjck4DQ1@H?$M%5PZ(=-jT-@rF;h`#bOF^Q5x2+cFBw>LJgC14qr=GxyX3 +zz|)@JgW$t|hDUX1S1qfyMSTS<9*_rUN@uGVm@n+)vLBM>dR6oh!(HY&ktfC_^}ME7 +z8t;1%3)4=^RbQj5zlap-^`V_2OTA_Y-a2RPaPK+^G;#Kch-3z +z+TWqbB}Aeb+ebX{UG4rN5S07VQl~t}T03DU~u8qGby#%DpU-OxB30L@~!J2AqXsnGDM7yv +z=O>d)sI?WCh42+z3+Qw%)$24s{xmwke;wg)DdkRd8_^RZ8EbMArP^~InzrlNR3;m8 +z2Rs$YMwls^+L=xfkdbXgVQ&K>x0D}?#n)`=wR**$kdI2MNSuLnIs$SKOI1dow-q3( +z6E>(1du@R3Mk<`W{bTPnyjd?%|I15UFBDzxA%&6+EdvrP#uHdMYxt=AnANG8&5=;o +z%#7#|B?C*L0j)}tkg`Uh1x_U=7b*<43t&hh-$Zi+@WFmcTHiq(5w?*erY8GpL0QMt +z5Q2DkM8$+?gbe<{V!f)5z2P_Hm_`wAm$i4ri>zrEV~;pv=q{IEoQel#?cJN}Q_^0W +zJH2{}tEHbrQaDW>nK)Y`&K~Ni$WO|Y|HGotkqaaJM;8a&fYkyAB`L#lUz-v$DmcsJ +z`wg7@*k=KbU1*%k?Z^YD9%WG~*8sD(Cch;h?zVPh$fz+<7I#LzN=rQD-yFbGh>U@l%lK$8JGn{%A_k5+_vsUnrY&38OJ!4eCvL)DCL*r;*{ +z#6eL7J&Hg~IO^a`}qJLD}L47v^@ME=q(e36$bP0pb>IdssQjhi#1AMGF8!Y7CaFu7M+?j +zO(COA={<_ldvL`T=@mlvU{xxkdVl9C8xvbii<3SyrB6whp^SP?L7KeokpbZPet0-A +zmY2D-gkgw&9t!#*RGL6QPOp@XaO=o!)T)H57YEN~sZ0OOAYI4QKbv9vS28Zk7IB$j +zj<}ZOL8WM+fi`{mrT2_cdTKPi%H*9WCvC}G2imYivrSqz#hwllGb9A6W68kq+3njF +zXX33)?1+{-@?Bvf*6@z_@=NyieL4~t+2UyI2=TwI3F4S$5m0ygLSE%%p;kI#x%%x~ +zr1EebVqHh#D8kLv%@$Mns_JsOhxa +zpEdeLy5DB!hp-3Ihl#sc&bfj)0!P$mgkJ+;ak96QSgSiDvy~&ydj&5 +zaXgrbwXl@f4*QtaM-Fa6~!9dNrbJ@>u+y+GS+=462K8enBzm(%Mu>j`9Gq#=(Q&m0=3 +z6qZcP$B^&naLrFBP7#AMP-LE4+tF{z@9D0G_n_lsiRp_RI-ah>0od8+#I;+iwnwJ9 +zd+uBueYPi#3ywCOB{T^O23cQ-{(?<9%S-vgi~b9AyNN86@5@415roiOc6`Fgpa{=12g?xkgZIr5wXjE{`6w2iB8iYIG%-mY +z&dM`3QPCN-OJ|=w4+aZVH8PI~s1^*2mna5WewohBEr8j=o&}Fvx>R{}@737wd(N6Q +zbs0m*2z+Ea#~}yV;jUk8+6PP@^qReEjo>J3z-phw7%-27JeI~(LB|AZ!3?62+d=C- +z)^_S?Ox%XiDpbLWc0h7-tEz$+H1+bHKCnq@yVtuly(E$v-RP?mnH%Pwi5DW949+B@ +z^6{|RXb0J~tk=h?~ +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 +zl9c6A0y-nDfj +zr7>ZGo}t%pGi$xK^e_X{>1g|rIWs&uj!BK<*DXVFPK{K`zEwsf=m0sPO-c#anzJT) +zQT_{(5lE70roT(Fd|@!x!F;EUo+%O@&B&a%W>&lMDc0#!p2rW#%K1IStklyx7K7k+ +zKPHynulrH0-d-@$g6N;>88#Rf$IyJbnal)7<-+*_#V6Rvz5jblSNe2#!iIp +z_e)QK+fWh)7NL-@;)OD_g?53_z(2lMe_(S|FV*q^L(ShwQIM8)s|YvexCPlnwmD +zXwulIR9jr??YluJ^x~*;Bp3_fq2^ZQl_NqEfD*wy1YZ6|B6n+ME|ITSr?m2qk(qYQ +z;|t|cbh$BhAxt@@7d{oYjNlkfO-7++iBuy` +zjxnaIvKN;yErc8aGho2)nQo>pFz|x?`+%(R+VOo%@C+h%C6kux8c`WZcjh5?pH?on +zFzG?$nm=oOa}KJhdt?oU8bMw|Es +zO^Fu1DYPP_y}m_>7P_Zd3q7EeB3ee#3Q5bSCSiq@HyuCZ+k7bY)FT5@9UtT&%_aGj +zfHEB)X45EhCp?}N#nS}aQRa`93mh+I)2bn)m`fJ@OTcJY^xGUxYu*zig-TEsO48|u +zoZD>5H(8Z!v8fmZ&n9UY1tSn8qvdU}H1A6Zwc8q#X@w{n?94FliIRK5uLRdJn>T5c +zZPBRMpi{C!#-{{B*nT?_ACApXK15jWHMYotrfu6~1soH}2lZ$h1Whe|+0)j2Qv#oY +z6&xKw42pMG0vI3A8~DPW|27GfJ=r90M9;QfgIOWwcwAa~gu)x%Ahd#!#%aCc;-i~( +z$qL#cm10^)Sqn_cXC{3F@2^K4i{#rBD2^2)i_#p+5iP+G|K<`MFa%TW@rQi +zA(15G<*(5+pKS>>hZ>Ww1jWx%Rf*|^-=kI;l8bC6aD|Ry3miw}+l_T +z4oc5}U6%m-X531~B_3(EtdpEabM*7|<)FsZzG;KU5ZULH)6IdfG4LoK4T7o@WH5^A +zMTr#fK{fyWB}Eg+yYRh`I +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 +zRO}&nsmD67&)l$IiWxxMF-=azvS;OF!CB! +z)No6nevmr)d&=(|kw!T2s_z@0{|z-~0sj+fuD=grAVR_$3dGKC%wE;t|4vNVMzra- +z9s#|RvWU;izZ1Z?&|L-Ea~RM57)S_=XTOt-3PpsdVFMF?j;G!yOFOMoZ=|&q@X0+v +zN;y`xz?x($8-FM^l`gB`5<&d<0Nfbot68c3HDWstfXApORJ$g>Da5HqJ9an2pIX0ht|{4j>4nn~<65<>KZA +z9=7!r;y*cBDCG*75?$3sK!(@F;E$<+CHE%KJ26TXFd+s?7bxWz5Ov=TLPu&(86X9z +zoeHTfXyf#ePda|S07zqyaT1WCKFFPqBr55T0veSsT7#lm#<0ovjURZ<^l^yn4Yq!QH-=g_)rtlK4l42Wv%@UxV6;Xg? +zrS4L0+I2iYU9+)F4Q=lmy-71ICo;MJsb2i%J1#BD$Ii`r{@gL*pi4h^HmhQUOoB>K +z!|3SrxmsskIwPJm@Pkr>Sho)R`BUasAAMo58ui6v<90KKTqWAG1z~(bss{u8q(GzK +zdQ)6@3!KmjR+Yn*Tg!n*$q%5?cl4gAuB(|(-cBEfZ|Mb|bCBCUu%EjaAis`I|8M%? +zz}2Nh^X&8cv8C(lmK-IjCrcwS93%l(H%BL(HJEyk>P1jdoNcm;sVFvoYvvN5XS)i% +zbIudk7jQ{DR7R)#m=vn&E9i^P>J;IaGq#pgcT|S*B{}WN(gj=4oeyVK`Z&(Y-rH#3 +zhJlm`*$mmkymj$H-uLvm4o<3)UtLyXP<6NMAu>ZjP!g=7Fq*72v2Q5)S9Zuf^nnJl +zT*NJc$6z@dxDTnQtc9n}4^}Gt{^DNc`U%_FyBy%x5K!nid7kq&g>=E2tWxNnXn2GN +zyI?$cON$nz3oA|K7ULJiFBj@rukR0tGTvjN-7Oy_2A|iK9Bu+QRgH4Yqsy)!cbFEv +zPw60hJVt?_Etf`u`CB!4vKP?ayIL}D!mMF8T?F=)wd#hpshO75ga{MHp6tC|aqrLS +zPvDj8*`~XqwOSb*U`--a!9-cUv)ysOijyYq`uX+s0^N9{ZgU3cwc|*p37t7o=)g%i +za~MM&Z#;1uAG>eBK~#_`=Lm3^`g6_HJFh(Au_As<(>-(=nIfBNqh)9;YwLQ?*LR{d +z^?24U$gaC!@)IPXa3^FP!zjb*b86U_P9ofM+7WQ1!u|9 +zjh3a}I>^R=V5Sf?xduHe9A>^l(#4~Xi?-cWxL|Z(7T8YfPZVpu$!26#a;#Xb8br@#6`^$B2prU +zgOn0n>=I+40-A^i2Qhn2{@d2I=JXX4kk&6oF7v0Wf)T{Rk^WYu61BTbPnQ9JQc#QK +z^d-Z9&3g;?G&O{hT}i}(9edah8@^1zU)t$R=sLok8>Z**%8AJnA-%}m7^;tNtQ`14 +zhKUZouxD&lUUkMwHq0TD3BVG}I#^9bKb(eB8T@;U9qNujLph^rRER +z8mi4C21c~>CnEP7dZ@vO_$|zvY8(TOgeSIhvLA-(OR!fg3l?{s0I2o;k}&TwVBEw> +zn4^IMj;}TPi>tp(6Wj39Py9SM@+h>G^AX4_pX(Ml6MFkq(ZGI;fi&CclyFaAI`Rqa +z7K3%PJ$L{-hoG@;XlZNpVtq9=>rf0x`wcd0%7WYL+Wq2vXTgZ@(U&{Htfo- +z8+G`*0Ov}tDD1_w6E`ZUMQ)xUlk +zv9cJ-?#mC@IoXS3XPsk#M^enKhe_tmAOOaI;njMY6QBx!W*Gg&uviB}DxnB_z$tJV +zr@c(x8I@)*m<^{>2bvBWZS^LbfhN#C*nA;$8*JwpR>eA8ksGILVN>QevXY8}_f-V! +zL6Kp1YdD$HAhNCZ1_9?fDg`e{x?ZNSOU8TX3AZV!T~%is`3hJ^{eYNg^#pZgaMeCh +zKwnlJUn?lTx|+I83~;2V%7)2CCsqa@j|2aH$N<=*+dA`37t%(4%mRu^_gL5+M+m_5 +zPv;a*v=ivwcz*fKI!N@qs_yy!;t9&S(BOZeWAoY-x#jh#r~d%QntY^?!QrV@fJBx7 +zX9@?0Z`CXJKseEWZ`DHQ+AUL!4s +z7j>04a2wf0S|Zq%!bCf!&o^kIJu{aG4K|U{o?*iw#FfJ~Vd!9gpm6f&#L!?O9X0S{ +z+}Xop5|H^fSWeBvgYqNJz_rmp>6(rpz2(OO&O90j-Mvw|k?oc<1A}*E)43TW;=LrwQgqcR(7iw(KNI +ztB1J`;&8%DtSK}zeV&fe=bV?=xiuULF999DT-}MtvMSz?T~v-J(cMZ_BN8NI%Ig)K +z5)`bI2Sk^goS2y5kNS-3{Gn=aDY8hE$|QeV=@~SZ=i*@l;;c5?Wol=Gs4Xkjr;jOc +z-+-~83SjJ)bmz(x{EMt=@3H~R!luBpOCt5Fu6r+!hu6VK6vD_gqnP&zP^iGblPrsJ +zihYkU;IBp&v}dbpm6TJ2Fq(xs2uBf9_eVT4C0H1m)UO&gCM1B%MeS5S;*z8t@fdi? +zjKrOQkU>~6a2jI?-d+d8hXO8Vpc6g(n+t8`@P-Vq2n=F~UTS8IAn)|5qt#A9X@G}v +z8P2zVm}QP+kF!;yR{V)j2rT+h>2>+^4)t}!i|AdPM*)6azqIms!}+P{)z$6VK&D%0 +zZqDK=LDMu%C76doD1oBTJ6Zatwb+W;0W@tZJEbt&{Demn@ +zH(S90cUJk=yRv)_jL9rNOIzj)2Exp}YtY*BOH +z;Fg?w*~3@~Z;JqGAfZTePl;+~fb2RVZ=V~fcI@|9Mz)gzDTQT#yfR+~-VxxqRq|?V +zdn1UHAhDX^la9{8 +zAXDDHUsoO3 +z?k`?!@Vd51P{v~6ouP@69!@;@O5wj`=%M^TZWy2-{!WTyT%L%jpx_YSNboJWCgYyB +z^gh$xg(qHC7HZSl-pZJWEN0+^vYKErHl;qE(D=px@W=F{Kt<~1&Y&T-(|Zc?(}G{B +zMyxL$8D3@=)?$6Z)6023TR=pRE88&LSU9q#E}I!gOyB1Y8LL;i#Q2xqILE@?SO`AC +zg?`AVX{HY>AJ(T1!Hw;~?j-ETRAdy(vTU1OX#f)S9S*Cm+U+=r>)qdM>=Rw4eX!Fh +z2mYpG!(IHW@5AHr?|XZ4iHDOHa3-gLYIgg%;9Ky$!h3pwdj@3!QE0N127>k);?kSY +ziAEa=!2h84?3#YqdPakN`VnyGvCvJd^90#Z8W5qqE{K4maT<@5wt^D_+ +zykmDuj6u;g25ZmR2$&A?xAznQxBRi@46%7n8>C8T8h&_2>bFv?9YRF0yy5a$gZ%e7 +zr()(AzNxJ1cUtJr(80GuQxgIVO+&86fPfcO6@7-vg|j@|suMR59~(Fgbi)RK5YP5T +z7_Xh4>geZ#Zj`#zj*+!VzJN(Q)9u&0*8oE}H+9;;IYz +zUu%fC{qOqa3xiyhc?kq=|Ve)sl*FaFtnEz9C)s8S?3HAD^*Be(lu= +zjh0GUY!u)~*m#f)nL7D?^EcwqdiVN`r>k~L9FlEYhwK_U;KYB*&91Pr?9lOJH?Fd7@r&9$>cP5)6l1>}6b +zB?p82j_F|Ibkc0c&rs9xTEMk}M0HT>nyW_^%b^`t&z?HyVpbCC!8^!yt8yf4il;Z% +zoCE|4ip<#!94PWx+T1>TM%?7_bm=eZ>p<%omC*?x`*z)cl`E=B)f)#k8C2}!2uN6a +zK%7uGZgf&Lc)*U^hdoN|QEBv0XR!ic=6=Ck#*n_NgJaU`9}fam=uS=!i!NO=t5w`2 +zYV&Ca?Cp>!VD|XgI)0Yd#;H@vX*HY-PprIJ!^dX9Yre>;*>Z-bXM0J3^8mi)tUWI_ +z@14Iq@e0Ow{pc9H05(6NL4TEPQA>66B(+(9>cf_=Ftm^t0pz`{+_A0q-GhO^W?j@) +zBNvxW5y46Aq1MZsZa?3qzio45C7@>f?_uU}g;6}6{kzSbF{r-^M>8fg)#3Zk&JiHB +z^tv=3dEplSCQ=bb7qV%2JFTa7u4Gt_>e)b_@P;kQmjs-s>nl0V20sWM)*e<$ihJAC +z*f4+lH$G@{e;&8mrQ3%Am){LySbHyc_v(H&x6Ew2%d7N3_qVKV{iFngd?9-Gsj7&P +ziO592U9Kt9{8r7sWa`c}aPjb(FZkvLid?^}M8Up&Yk&W1Me})tLDA@8YZ^|kF8NCM +z=v{MNHEN5lF0b)iK72fXjp3C}vlmx53lr0KH(`%;EgM^W+g=STYaC$u1C%aJCtEq+ +zQAO8I?jwHBAN(oiJbbG+csDp-u`?fBGZCZTQ72nPU2wd3*Ep_mBpC;`wO+3(-;0uWR#p?L~m(KYOM`k-FBv^K_f3T;MjQk+I! +zS-m`_IgNb@3SswG9@U8$k=PN**Tk8u<=fvj+{_cGt$F(n*s>FC8u0F<=k|i<+v4jE +zX`z>oMr^LtO1>jQp$l!$yt#Qz?@7seWtvVh!<2Mi9xqVzj|+G|_{JRTMt^!t2(Pjr +zY5?s5#7G^|qx@^Ai1Bo_CDJnsGEI^=SpJz#h;l=CGbxtOpyQTWWxh4)eNsM;V(;}-!Mx9UzUGV6j&u9Pcf +zf5-M&8dDq48{!3<)cMq6#U_h9xTKD +z(7WY&+&d?N?iRy>4}4o11SX^qWZVz>mW)(-h9^~iJXAcHhCumY-*%`N +z<-pvodOq*FfDJu?inj=iGL|<8qTmm=#6+GxsqEjefHnynBcVrr6;>eF%tsGp&+)e} +zI1~YgF+l#kWP?-zd>M&IW@&?X;)jk9Fp!itZAS@LwkmCx^#aTy<*?zZtUp3|x4yQZBV#lUch9mJS9+$nL&V +zjXYjW{nigJ54SO2L)a8}+$ohQg3k65$V-^}MxdsSIME;|I-MmK8yHT)V(!#~*z%(} +zBGPp%su=D82sLjmTv-)kwNYf}a35NXfdI$nH8pO)7Y&K|s%`e4M{K({(5$TnRM{xR +z=qVbr2F*YhL!49D--*3wfue{frNe(>{f(MAhG$E!Xf*`K=BLm|f{yn*c5B@O&8r~b +z;XE@A@tPKtWRDwk$%})nz}hVND<#bQuxl1Dv>}CX?Lpg{2JZzm$;0PvDfG<_BSc&X +z%xu8kr+Y>8@oqfh8Ik)L0(Ahe-_)keb4sn5v)#_3Jka;{s_e~7MLNaX84iHC(YU3U +z#Jr(tl~E%q85xU&S0!EfX3%g`hr>zo_dE;{iF3)~UeY_fnE>Lh1zs{a3~@0GHo;)y +z@~zdz7|61no|Zf}5xA9!EwtJPM~iJDzTTch@-TkYC2RMj4# +zMi8T=XwBBHz15~h2$7Pa#3&IlBC%pi5QLEA<9&U<|HS9>_WbGOI@fisoZGq1K9BnY +z-9$lGsLi>0wvV(cR+w^#YBYyvi^hX;gaKs4~;+dbau#tR!56%CYdyNKtIL*m=USi)FmDlHK5?d4Zyiv5|d(Qgqak||;LQv-_ +zH}%!B&(~iMB^4oD`<(^}!x>tC;!G|*UYSH|HeB3)O4&Esd6kX1c1>=->3xar;cQOq +zmgYy;tTsEi^xP?Hn!uBY +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 +zz_{e>ly4Z}38gpt=QUStO;ZRb^L +zS84NnwtQSk+2qAs>y~Y2EEomE(7KgE)1gcFK-Rh6V3bbMI`sE7#`ZnBjgA1QZG@D8 +z_?jjkxb?csqSXi^)*edp+i!jU@a0{boSmswAJTNYFF{jxMApQ6a~6%Qk@gA3O|4r4!GHU$(IZM6>qTgDE~u)4#k_829$rP$ +zYw;(q`sHL-x2Uc~Aib0FTviO)LPf29BTxGtZ&ypxCOo4@C#<|U)W?SUMu?ram&wn0 +z#XuSq1Ne|AEBUzpFHW#c>U)S{up%D|vCcX<{TD?&x4YatbO&r~o?ylIfPF=nZFayN +zkg}K}Zb&Q*bKCM$J3H&|d!K~iCEgH!y;>l=5xm+A;6=KloJ!Z4mANoodT*0Q5mD|x +zB2rfL=ArcUs$D!I$X7C3$8Kt;Y6X?jVF8p(|?-1vJn{5&cZ +zKV6M_y+3{!P3=3KoL3|cF3X_ClYU3lU2pKBS!Kb!g6266)9OTZj!S?%H;N+K9s$}R +zMsxO7!ufZ^i<->V@AT`eH0|6{j%{2K3-J`-ou1_x*0b6*Q+}@MCBi36u~fEF_{_m( +z7AVH|Gs}^k&HQ*mvcJD71`_h~xT|8l+(Ore>&p1FSj)%2XRP3o+sK#wElZB5p)n#> +z!LT6mchD)05)SJuoVhhlfp#b2%E5|HlizK^WwRV>Ggq*vJD&(|0_)ST6b}Y}jdqD^ +z!qd6=zrk0#Z*t{|0TRyi+)-c>DD6O&_=ot2$NJiL;4o@jfj5bh@#1*kT6Vnxg4V|; +zhccJNJrUKL>?VH7R0Op8!*(v|?5-$=bTs?6T$*+Te0>mCd>mXX#&6T=Pj+bL!$P+c +z<_N_ufaFyN=(s!PzE& +zp&LHR0Ri979D7o}u?92JS-XW6f<4c@g!+AcWHxBq3#z8AV+@}%#!r!Hc3)ROIDGt} +z^_1B(w&d#|;x&5qCCHXSAIs%;(Z{UH?$2#3mgT!w#?RKWMXHFvi^?sihaOU4$2*U1 +zP1II5LW;hJc^u1`Z2H)3l@j9}c-S51SsUcD>oPexYd~?$^HC0}Y;)94`v;S0e&G8ILeAq450fz$2Ra{omz(8JgF5?%Q*365JU +zm5K$O8jE9%)M3J89C9mP;K-;4BgFqHd@YG>wSJu7f4XAi6WPhEZ9kOenO+mUbwxt% +zIID|oe-|0GFS+HQEEknKOXuP@&Ma~HyqWAZzdE=FUeU3emQ53^+?0Lcl(WW|joY`b +zcQH?Yt2*(>-E!CK6XFXjol?xC5@f;9!kIJ6 +zQWHMq9n1*iFK5guu%Y2&Y-nKUTGZ~Yn* +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 +z7Jce$E;aqcoh7eD)U3w|nS9y37pb1(ZZvJg7z +zGuM(C@-6pTPi}>K*o5px!!7pkDP +zn|C2afp0oRsw4JXu#OmLr6sC2Q=)4kt~AP#L$?^z&k!g@Yul#u$k&cIT(sLtR#e@ctvN{4$7STCtiF +z@IrSIwDA(B-v|1wjm|is4PzJiC|lRDGmXb*&+H$+KR!&WGH>%JhH_^xTlW4)7jt-6 +zzgRiK-Gl2O(+Uwhr4<2!l|yV>RZr^^A*s5}wQX~OSLH1FF#euL7E>PA9sL>p$M-KS +z1OJ+z#uA_ng5t2`t{>&~X5Xy9Z?UV9oJHA6Jvop3VQt|%;mo5yMh~&^cSMgolbOdJ +zV`ceMZn^G4ndLyO#nH<+Ge_n~Hobe?g|OTnvm>3s5#`jz;o0HN9g3_0%Nbiad10Be +zzJ?+7y|H6$*0GLhjS+*`JZHXFPi^BU8Ns{`XmP-}E}}S`ReK$v +z-92I{+q`n%2iHC0_*BVdx*N&4IV57Mo3qeZ7j0zm?scI?;3k}-{+*gGuxEa*B$75y +z_KI)4>|aJ~Jg)NUps&-3!{Iz4GQpp<^wSJqTu7U*b#JdTW3?yEBARQ5>}2LC{QQIO +z^%FgG23ZYZ!3Pfxc7*#W`mYWahjA0l=eG*JN9QlxNFkpU|Fe0hG07gKXCOMeH8)v3 +z*f3+$Z5E<4gV;F@?{}vxr$3DuyD`bnLtM}{TzOg1?vnCrc8G{)GbI__%47D;T>A0p +zCh%@ms^`qXs%d$$l5L*isX#RB%N;e3PB%s^M`7ESQ#giZK)HpVyWr +z2CBwmI9ylQ7y7>&JscsD5j3Wizgo8Jh7nRWMI&l0E@=L!7b>RZw>9VgD72x7cY4W8P@}{@8m`xY^hG9H#C3BGS0)0-`q5t +z5X6uVGdy)NP6SQ_P6SQ_{+k7U0UO}Fbg?YO-EdNl;x1lRFPj`61Zg- +zPEQ-CDAm=`b!Q}Gi8b0VNM$xsSp0?1(Cd?PxA6C;YiP?PI=zZP#^usi5*XwzHO92s +zkqx}B%k^j?PK!YX(J4xy^y6=?h1BRyYifW)-NrmG1-kqZy?&E2guuhkhcYCOXce23 +zn&TfALK(70wAM`u34zc31ZP~P)9rxvv_b4nD3Y%m{{}A_wFiuX)8GsaJWba-PmYGD +zW56~kQ?sPC(97VEAHnQ`E$v6=>5jYVz5jYVz5jYVz5%}LHAb;9&G8B6JzyJ9kuOYFq + +literal 0 +HcmV?d00001 + +diff --git a/tests/f_ibadness_bad_extents/name b/tests/f_ibadness_bad_extents/name +new file mode 100644 +index 0000000..58bd208 +--- /dev/null ++++ b/tests/f_ibadness_bad_extents/name +@@ -0,0 +1 @@ ++All in inode extents corrupt +diff --git a/tests/f_ibadness_bad_extents/script b/tests/f_ibadness_bad_extents/script +new file mode 100644 +index 0000000..324a3e4 +--- /dev/null ++++ b/tests/f_ibadness_bad_extents/script +@@ -0,0 +1,4 @@ ++FSCK_OPT="-fyd" ++SECOND_FSCK_OPT=-yf ++ ++. $cmd_dir/run_e2fsck +diff --git a/tests/f_itable_collision/expect.1 b/tests/f_itable_collision/expect.1 +index 7e98baa..f303a48 100644 +--- a/tests/f_itable_collision/expect.1 ++++ b/tests/f_itable_collision/expect.1 +@@ -26,12 +26,12 @@ Clear inode? yes + Restarting e2fsck from the beginning... + Pass 1: Checking inodes, blocks, and sizes + Inode 12 block 37 conflicts with critical metadata, skipping block checks. +-Illegal block number passed to ext2fs_mark_block_bitmap #4294967294 for in-use block map ++Illegal block number passed to ext2fs_mark_block_bitmap #4294880894 for in-use block map + Illegal block number passed to ext2fs_mark_block_bitmap #268435455 for in-use block map + + Running additional passes to resolve blocks claimed by more than one inode... + Pass 1B: Rescanning for multiply-claimed blocks +-Illegal block number passed to ext2fs_test_block_bitmap #4294967294 for multiply claimed block map ++Illegal block number passed to ext2fs_test_block_bitmap #4294880894 for multiply claimed block map + Illegal block number passed to ext2fs_test_block_bitmap #268435455 for multiply claimed block map + Multiply-claimed block(s) in inode 12: 37 + Pass 1C: Scanning directories for inodes with multiply-claimed blocks +@@ -43,7 +43,7 @@ File /a (inode #12, mod time Fri Jun 27 18:34:44 2014) + + Clone multiply-claimed blocks? yes + +-Illegal block number passed to ext2fs_test_block_bitmap #4294967294 for multiply claimed block map ++Illegal block number passed to ext2fs_test_block_bitmap #4294880894 for multiply claimed block map + Illegal block number passed to ext2fs_test_block_bitmap #268435455 for multiply claimed block map + Pass 2: Checking directory structure + Setting filetype for entry 'bad1' in / (2) to 1. +@@ -51,7 +51,7 @@ Setting filetype for entry 'bad2' in / (2) to 1. + Restarting e2fsck from the beginning... + Pass 1: Checking inodes, blocks, and sizes + Inode 12 has an invalid extent +- (logical block 0, invalid physical block 4294967294, len 1) ++ (logical block 0, invalid physical block 4294880894, len 1) + Clear? yes + + Inode 12 has an invalid extent +diff --git a/tests/f_itable_collision/script b/tests/f_itable_collision/script +index 66abd90..2dd19bd 100755 +--- a/tests/f_itable_collision/script ++++ b/tests/f_itable_collision/script +@@ -6,7 +6,7 @@ + + FSCK_OPT=-fy + IMAGE=$test_dir/image.gz +-E2FSCK_TIME=4294967294 ++E2FSCK_TIME=4294880894 + export E2FSCK_TIME + + gzip -d < $IMAGE > $TMPFILE +diff --git a/tests/f_large_ea/expect.1 b/tests/f_large_ea/expect.1 +new file mode 100644 +index 0000000..47b6c2b +--- /dev/null ++++ b/tests/f_large_ea/expect.1 +@@ -0,0 +1,48 @@ ++Pass 1: Checking inodes, blocks, and sizes ++Inode 12 has illegal extended attribute value inode 79. ++Clear? yes ++ ++Inode 12, i_blocks is 2, should be 0. Fix? yes ++ ++Extended attribute in inode 13 has a hash (2037685388) which is invalid ++Clear? yes ++ ++Inode 13, i_blocks is 2, should be 0. Fix? yes ++ ++Inode 14 has illegal extended attribute value inode 20. ++Clear? yes ++ ++Inode 14, i_blocks is 2, should be 0. Fix? yes ++ ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Unattached inode 16 ++Connect to /lost+found? yes ++ ++Inode 16 ref count is 2, should be 1. Fix? yes ++ ++Unattached inode 17 ++Connect to /lost+found? yes ++ ++Inode 17 ref count is 2, should be 1. Fix? yes ++ ++Unattached inode 18 ++Connect to /lost+found? yes ++ ++Inode 18 ref count is 2, should be 1. Fix? yes ++ ++Pass 5: Checking group summary information ++Block bitmap differences: -1160 -1210 -1260 ++Fix? yes ++ ++Free blocks count wrong for group #0 (6821, counted=6824). ++Fix? yes ++ ++Free blocks count wrong (6821, counted=6824). ++Fix? yes ++ ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++test_filesys: 20/256 files (20.0% non-contiguous), 1368/8192 blocks ++Exit status is 1 +diff --git a/tests/f_large_ea/expect.2 b/tests/f_large_ea/expect.2 +new file mode 100644 +index 0000000..766411b +--- /dev/null ++++ b/tests/f_large_ea/expect.2 +@@ -0,0 +1,7 @@ ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++test_filesys: 20/256 files (20.0% non-contiguous), 1368/8192 blocks ++Exit status is 0 +diff --git a/tests/f_large_ea/image.gz b/tests/f_large_ea/image.gz +new file mode 100644 +index 0000000000000000000000000000000000000000..0162113b4b05c5dd20945443955ad4cf0f850970 +GIT binary patch +literal 13401 +zcmeI2dr(u?zQ?s*wU#2M$6Ki=rqwDc0yVr!c%(hl@(d9%@=W5Rfkp(X1fw8?)?00F +zE2um|f+14#knjjdAQDWXr3IS=&}<+ILbPhqO?ar;fhMrCk9yiO*E4h5I_LgzJ3}Ua +z?6uc#t-bSEzqNkf?@Ul%z5Md1az(^T3#b{p(Bl@B4mSMQ^2IlY +zW7&K7l${rj+|Aej_x*47TuR=+{%A?W##G9!YO1untgOs+&kE{pDt(YhJN))%hS(a{ +zS$*>i(KCBK^4B+ejrSh?*gTeXN3H3Z^lvurJtr#k-RY5$M2P>0cWaiuqZRt^SfHRTflP6xhDOhXPTe*< +z`bwO?=lc}aZoD;`yEUXrj&vpuPm2~bwErj}4J}oG5UXWt!^d#$D)x~COpxp8qUbRG +zd0-28la_)B;hc(z-n+cLDamf?cBmEIrJ5yM33|l1(~(fJa^bw+{1p23%o6k$_;%|F +zE9N45f?*W*JrHWR*pG9tA@h2-O&1hAzA$iO81`~{&wNPjgd>{tm($~k$u70W53)#9 +zC#TozzF2&v#=85XI3R8kY1yYkjFb7-E;f)`Hn%z*66>YC->O~NOQTK**J@9L7icuh +zde_RLs4n3$?U&T(ZXKPPI#7&Viwr#yR}X%2T0PF1ip&${Z-@UjBY?Gbu#mP3v%&T9 +zDib-lB|SzXYu0|ZRbeM~DMJXb`sVbFo{sz8=-nTx7kIOCNsR4@4DBlk$k%mP`bHDp +z(}X9@H%ZgrugWjlC3S&;xa9dJ`bRJ>*CIi5qQnO_r<6wiP8@i4t;**3RXv$8KuVur +z2lf>U)s$#5zZc@3*B;9<`4hgCz8ETom@IjkB)VYBX7uP$jmPZaD +zNk@m?slKOaZVlk?-JX}6pA2Wi=_P}1oPdT5&CgRstp^rhusZRfp6`mL;@U$9j+?pZ +zlW%xu?zg7E$PdGfE(w8oWB>Ii!vV`t6Z%U#I|nzqx+>myh#koK5=NRj8(>sIs88FH +zD|V-w$ov`XE@bf-QV63Okp)wXXE#6X-?}&8KcL9&8v1C-KxBUH#PrKM2(UcFGCkF& +zR|97TVobcN1l`Qxfhd#EQDn=@7m0iwBUbXOsrMuiF6Dl>$~JH}pWUYJVR{{1biEJW +zT|f31e`DsNn@z6(3X+KjuT>2N6+CLem#SZ?owSqPoh+5u?(bb9lgrw+vhqsFi|dXX +zdQpG5po5|n12H*_u9FuqLnv@s0XwxTQP^^+5fwu#HbGSb01ar@7(vdO&gxQz7R +z^F;}76*JaWva50tF`?a#WlV;aTOUa&P5F&^up)msY2rHVf7!U@cgv0-c2r%P%7j>m +z3>LWyH7qmL50P_v!-jJop1p~r6LjPSNrP6Uhr1EE6R_8Qfxmz8z!zo)ckrjzj7Xuc +zafWNNo;Zz+&xVB>^WKpCvV}&)pYrm70xCj#5A%*|=~7aWrM(xyX=KAW`G#A8i2v>t +zJ=hqPY&dwx#BF-jgztHFDV=V#vooVH8&BfIF>b>@ZFFpW;%rKMtO3mB1U!fdSxXtRh9kd>Bi`pOjA%wABZe-_)5<{w#H2CUC8L4b+df{w6{{l|I45D)_CvsE6C{PEpLk@HOxVXr)$4GIHM^^vvLXC~(y} +z0AFdp0*a_Y=nSNlWalOhJ}EBpHFEUH$acZ7b^;_&izR7;?&F-Pi1UDgs+2G=Z@N}2 +zja)1Y)mDRzw8NM+uB@WSFyUTp6L^Vs6!RA6(lzTIx+QKoi;%Y% +z5pjCT>@2qNl>(&w;Vk3cMLYXO{rMjKM7g^-+jKR14lQJPU4(ZL>CfZJhqL6k2eT;m<7NiZK8=t@e(sw_ +zUUGkAo&46!P|rfCG}8reXdJ$8$qYUmGlp2wUa>Gz(-M0T$4RzDS$!)&J!R-bSE|Mc +zso5;KdMwV6M49qvCbMAms%?fV=*2nRg7c~%nP#sls8w@M6{OHCQw23?wos~e7;d7; +zM8gl1*0O*GO`IyIMFXf-kqsb4Ad`*iwMX0$- +zX-GEYQX0sHMU>2h)O1#;>h=XqHDv&CUt;8N7n+T_@{6ts%X*Lu`Hj#XWPWES?SRl&(6 +z-bt%JiRut_dB6GG;}a~J+Z3Z(J%r>D28CscS(5WsrX;xUI +zd-8OfMi7VR-t`YOu8h`+Tnv38k%(@LV3M|ZR5SeQhOM#n*)zPUh_s^gmEH>Z`HYl> +zbpxpr7tIe=IM(R?vC&fNgJ-@OzWuBkn4FMqs#(~U5K65@pP+YFx1iNi)h8)_Ww&ZI +z26P_tmQd588cR-9qGy-^=QN*EmX5M<{$*ARS{ZBTrW7=5Sd@ZVO|t58izbU{<)G8b +zjwG}69_BpC2+80|DNt%qrPdBKV~3$wJsZKodYIEFBZ&qg#eP{sF14!B41z(dp2e}0 +z9%eeluF%|~*sC?za;p%Hq!@-NBXI^fWhCA}R$W$V0w^KdCKe}`b9=kT(zB9a4Of5Z +z*J7^RDx+UJ7Es|Iu;E*mJ*vJ2-BjwyeXc|?@|j1=zDVP$8`kdk^*Gdy|fF=NBrm16c|C;rA_3&xpi6RjNY$ +z;5)*d4dd(LIhN9U?<@Bw2xpIs4)wBb-Y6LTbxZm(W`~|^r$E%0NOUBT(f!jvEPX!% +zIU@gOV#xsme){cd34ztoo@#DH`+Hd##4Sv~tl#dN=7o +z>nOp!`F5t&;PB2nK#dYv!hnjhv$Pr{5Im%zK +z0u(?N=p-%Mmda)+$}%IQf-K=AFA;2oh9NmEPqsE63%?1!18;!eh2MsK;LXFViAXG7 +z8Lo_0Mk-^J5lWmgN{Md*Sc75XN&9ItFkE_fr6;8wiPb(p9t +zKfbSHtEcoArDky$ubhgS5iZbv3ZA1qJXpuD^fd%*G4(_)bFL$+x#t@2AtI5Ycqaky +zzFhS5Bz)(5jnU#(W^t=8wDexHWiv0@??3sz-dK<~p#1oW30BLR0m+kQ*npm=W9XmO +z<)mhn1$AjxR6Sc85LRkgxjdP%4gPC4G5Z8N+lIayoSKl><)$?=*z+E^rvBeMq1EBpz-4Gx?grR5`0VP4VnLTyuhj!s?LF{I=p$R2E#5}A +z;n`eKr%3c?vOyJ{yb|rr54*5`;ynHLU;R!^OlFKE|Fc)6P?D7 +z0LN%Cx%n7>TufHDk?$|?=bM32A76O@@sxls|MDB@ytlo$mtQ5CvGxw +zGKR^Y=1mKx`O`u*@H)5vRM7~wUAAquPi*0~k8KII!!iu9B;<4ms{zN2C#bo^dH +zFTYo40-UwZ08{G-szG#~101-5T&L9(v2X&x7Cerujf(5?D`781%^~KQ8PB +zmQ&Rd!XV~kcyClMeu$R=IA{-1XME7(r$`l~QqtK&(Sdv>k15~)YON>u0DK)RqwW~= +z9WOtG7f0stf&mhBQi6BkOyOquFfbpyLfeLU*Y(U&+zEaM@EUk+eV6yYpBI0!8Fuy4 +zU)b^1eL(1cqNfQ2dArT2;G3ksJrUGW^Z6v>)Kt-yd!0oq^dmR?8eZC&RaE$*H0q*% +zojMRNgFf501a7{2uBUh(XUMGukI7CM`c{zM|SeaLnFEAoRE27d1aN +ze{WGAzsf=NW29W~rt@&$mU}~igPnvcqusCliI@ +z+WzM>!SBrS=kMN`W_;-de#MndbuSYB0yEEr&Jma+Fh^jHz#M@&0&@iB2+R?fBQQr` +zj=&s&IRbM8<_OFYm?JPpV2;2aBT#58%zpk~9fgGB^!FD0vC+?>5Z&rkr=DKDY(r$O +epT6<}L+3*02+R@q|3lyt=fh|Cug{xTIPdQ+F&2ja + +literal 0 +HcmV?d00001 + +diff --git a/tests/f_large_ea/name b/tests/f_large_ea/name +new file mode 100644 +index 0000000..9d45f60 +--- /dev/null ++++ b/tests/f_large_ea/name +@@ -0,0 +1 @@ ++large EAs +diff --git a/tests/f_lpf2/expect.1 b/tests/f_lpf2/expect.1 +index 633586c..ab5d9ba 100644 +--- a/tests/f_lpf2/expect.1 ++++ b/tests/f_lpf2/expect.1 +@@ -1,12 +1,12 @@ + Pass 1: Checking inodes, blocks, and sizes + Pass 2: Checking directory structure + Pass 3: Checking directory connectivity +-Unconnected directory inode 12 (/???) ++Unconnected directory inode 12 (was in /) + Connect to /lost+found? yes + + /lost+found not found. Create? yes + +-Unconnected directory inode 13 (/???) ++Unconnected directory inode 13 (was in /) + Connect to /lost+found? yes + + Pass 4: Checking reference counts +diff --git a/tests/f_messy_inode/expect.1 b/tests/f_messy_inode/expect.1 +index 708f1da..67cca25 100644 +--- a/tests/f_messy_inode/expect.1 ++++ b/tests/f_messy_inode/expect.1 +@@ -20,19 +20,23 @@ Pass 2: Checking directory structure + i_file_acl for inode 14 (/MAKEDEV) is 4294901760, should be zero. + Clear? yes + ++Inode 14 is badly corrupt (badness value = 13). Clear? yes ++ ++Entry 'MAKEDEV' in / (2) has deleted/unused inode 14. Clear? yes ++ + Pass 3: Checking directory connectivity + Pass 4: Checking reference counts + Pass 5: Checking group summary information + Block bitmap differences: -(43--49) + Fix? yes + +-Free blocks count wrong for group #0 (68, counted=75). ++Free blocks count wrong for group #0 (70, counted=77). + Fix? yes + +-Free blocks count wrong (68, counted=75). ++Free blocks count wrong (70, counted=77). + Fix? yes + + + test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** +-test_filesys: 29/32 files (3.4% non-contiguous), 25/100 blocks ++test_filesys: 28/32 files (3.6% non-contiguous), 23/100 blocks + Exit status is 1 +diff --git a/tests/f_messy_inode/expect.2 b/tests/f_messy_inode/expect.2 +index 1fffb02..fb4e83a 100644 +--- a/tests/f_messy_inode/expect.2 ++++ b/tests/f_messy_inode/expect.2 +@@ -3,5 +3,5 @@ Pass 2: Checking directory structure + Pass 3: Checking directory connectivity + Pass 4: Checking reference counts + Pass 5: Checking group summary information +-test_filesys: 29/32 files (0.0% non-contiguous), 25/100 blocks ++test_filesys: 28/32 files (0.0% non-contiguous), 23/100 blocks + Exit status is 0 +diff --git a/tests/f_messy_inode/script b/tests/f_messy_inode/script +new file mode 100644 +index 0000000..3277356 +--- /dev/null ++++ b/tests/f_messy_inode/script +@@ -0,0 +1,5 @@ ++FSCK_OPT="-fy" ++OUT1=$test_name.1.log ++AFTER_CMD="sed -i -e 's/:[0-9]\{4\}:/::/' $OUT1" ++ ++. $cmd_dir/run_e2fsck +diff --git a/tests/f_noroot/expect.1 b/tests/f_noroot/expect.1 +index 7bdd7cb..f8f652e 100644 +--- a/tests/f_noroot/expect.1 ++++ b/tests/f_noroot/expect.1 +@@ -11,12 +11,12 @@ Entry '..' in /foo (12) has deleted/unused inode 2. Clear? yes + Pass 3: Checking directory connectivity + Root inode not allocated. Allocate? yes + +-Unconnected directory inode 11 (...) ++Unconnected directory inode 11 (was in /) + Connect to /lost+found? yes + + /lost+found not found. Create? yes + +-Unconnected directory inode 12 (...) ++Unconnected directory inode 12 (was in /lost+found) + Connect to /lost+found? yes + + Pass 4: Checking reference counts +diff --git a/tests/f_orphan_dotdot_ft/expect.1 b/tests/f_orphan_dotdot_ft/expect.1 +index 6a1373f..6092495 100644 +--- a/tests/f_orphan_dotdot_ft/expect.1 ++++ b/tests/f_orphan_dotdot_ft/expect.1 +@@ -17,13 +17,13 @@ Entry '..' in <12>/<15> (15) has an incorrect filetype (was 2, should be 6). + Fix? yes + + Pass 3: Checking directory connectivity +-Unconnected directory inode 13 (<12>/<13>) ++Unconnected directory inode 13 (was in <12>) + Connect to /lost+found? yes + +-Unconnected directory inode 14 (<12>/<14>) ++Unconnected directory inode 14 (was in <12>) + Connect to /lost+found? yes + +-Unconnected directory inode 15 (<12>/<15>) ++Unconnected directory inode 15 (was in <12>) + Connect to /lost+found? yes + + Pass 4: Checking reference counts +diff --git a/tests/f_rebuild_csum_rootdir/expect.1 b/tests/f_rebuild_csum_rootdir/expect.1 +index 91e6027..063fb8c 100644 +--- a/tests/f_rebuild_csum_rootdir/expect.1 ++++ b/tests/f_rebuild_csum_rootdir/expect.1 +@@ -13,7 +13,7 @@ Pass 3: Checking directory connectivity + '..' in / (2) is (0), should be / (2). + Fix? yes + +-Unconnected directory inode 11 (/???) ++Unconnected directory inode 11 (was in /) + Connect to /lost+found? yes + + /lost+found not found. Create? yes +diff --git a/tests/f_recnect_bad/expect.1 b/tests/f_recnect_bad/expect.1 +index 97ffcc5..685eedf 100644 +--- a/tests/f_recnect_bad/expect.1 ++++ b/tests/f_recnect_bad/expect.1 +@@ -12,7 +12,7 @@ i_faddr for inode 13 (/test/???) is 12, should be zero. + Clear? yes + + Pass 3: Checking directory connectivity +-Unconnected directory inode 13 (/test/???) ++Unconnected directory inode 13 (was in /test) + Connect to /lost+found? yes + + Pass 4: Checking reference counts +diff --git a/tests/f_resize_inode_meta_bg/expect.1 b/tests/f_resize_inode_meta_bg/expect.1 +index 769f71a..e248083 100644 +--- a/tests/f_resize_inode_meta_bg/expect.1 ++++ b/tests/f_resize_inode_meta_bg/expect.1 +@@ -45,7 +45,7 @@ Pass 3: Checking directory connectivity + '..' in / (2) is (0), should be / (2). + Fix? yes + +-Unconnected directory inode 11 (/???) ++Unconnected directory inode 11 (was in /) + Connect to /lost+found? yes + + /lost+found not found. Create? yes +diff --git a/tests/f_trusted_link/expect.1 b/tests/f_trusted_link/expect.1 +new file mode 100644 +index 0000000..1063d22 +--- /dev/null ++++ b/tests/f_trusted_link/expect.1 +@@ -0,0 +1,16 @@ ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Inode 15 ref count is 7, should be 6. Fix? yes ++ ++Inode 16 ref count is 3, should be 6. Fix? yes ++ ++Unattached inode 18 ++Connect to /lost+found? yes ++ ++Pass 5: Checking group summary information ++ ++test_filesys: ***** FILE SYSTEM WAS MODIFIED ***** ++test_filesys: 18/4096 files (0.0% non-contiguous), 6424/16384 blocks ++Exit status is 1 +diff --git a/tests/f_trusted_link/expect.2 b/tests/f_trusted_link/expect.2 +new file mode 100644 +index 0000000..a8ff12a +--- /dev/null ++++ b/tests/f_trusted_link/expect.2 +@@ -0,0 +1,7 @@ ++Pass 1: Checking inodes, blocks, and sizes ++Pass 2: Checking directory structure ++Pass 3: Checking directory connectivity ++Pass 4: Checking reference counts ++Pass 5: Checking group summary information ++test_filesys: 18/4096 files (0.0% non-contiguous), 6424/16384 blocks ++Exit status is 0 +diff --git a/tests/f_trusted_link/image.gz b/tests/f_trusted_link/image.gz +new file mode 100644 +index 0000000000000000000000000000000000000000..8e2587355ca36dd17d16613f9d9705b0a8309914 +GIT binary patch +literal 18213 +zcmeI0`BzhC8pl~?iXKPM7J;G=x4LnHRV1P@;0B@`#8_D*1vH3=EaJju2%()LDzV0D +zB`QL!hzz?IkR>R=QDB4uvL#_n2Sv63vLz)U_s(`}vFT(R?Pyg@{}O+v +zSGT_SnKD>-Dw=QL8p;kk&n%Id*U0Sn{gn%ynd14_>1vl*5o10mz=Qd1`7``nX1y%x +zZmH^+q(s9FtfyEevroorbjgn$J{Ju(?!2Taypw_t@ZY8iZsKQWla@~lcQ_8+W(w2N +zFDAVAXyR5(1!NKJUcU^_jSObC_Oq4M*pwn;SbKC%z^&OXI*SJsNak`bHhTA^7}m?q +zy~VJ7S_zBuaB3>BaiDVXn4O!ror1VyMYOT*G>10=63x>303JsW=Y-N +z+~RJ%qO<9fS}>C7HB9)f1}QpxOpTZwAjbGzn4;DYAI3qY02S!Z~ZWd-f3| +zS7%H@7x!bC{eD +zkN2D$#D~-$9(=Y4k`543m^uQ+b1z73NP|3E2=G{7d5?io$!G2BNLM*x2KjYxJ16$gVMwmReqmSER#lf`)+J8%zlMzj(tyrCn`*60a1Mu#INhrlx4;pJmzrB +zkb)3ycI=4P$qIRTdgXBm-U&L7h9iYUw#`$s=LF$IiO-~nG41Apc^x76FoHM#V?;8Z +znv@jaWu2U0A9--%CZlq`;XGY4t&rT`HdUk@alT{Yk?q{#@aeVSrLF(A +zvUpiKOY6#NTr*}bxYWL@HSRbOoKZQV*&OoXE1jsrX`_bnc%bxwuB<~T$v;hm+iTA) +z?;!?T{GxQicExSnN%sGWTm==GQu6XNF$NV$5m7N2=dT`5AJGuig9UTbL~}%SGa)SC +zMG_LJ)9XA!y4X-XxJPHw5_F&ur=L|Rn8n1+2Rf4#!(rl?dEQVNm(ejBu(dyB7ZD&% +zXeQQj@QJ)mUNDqHRf^-qM3Y-HLH--)hX^17hyWsh2p|H803v`0AOeU0B7g`W0)Hj~ +zJ^mx?K>pF*7yPWzk&iX^x185BJaCleI0suG7;QYK&$~hA8ix9`SY)iMT## +zB=I%hT}@ny{fO1d|0N&t`G(0A>}LL?n6`7It)gwAZHzt;c7d5tc!b%rtddUqie^uv +z(iqVmVJ^x(ITzCgHeyC>lUnO!#tP0_nw{#55|ii2-(#KF4y*#3Vtw(k&X=8!mHKe< +z)=0nPtX7>;X3N{KzhlAdMS;z=>3nK3^(OT?gTk_8nX#-{OF64bx0Y^Fv6Y$f2CM_K +z#|q?KavN+)n}RJD%RxE9^!-4yx~x&_@-yFqGBU!iq~UaLB&Jfrkc#wzzKpHwDX +z)=dmApT{MWI-$_l=<;S!#PXr4cro`8;nXfXWEJ6Jky5J@;=!hO+^F1eYLFGxYLTzT +zH;{U_?w_yfx;E9-3rr;05{(aMz#@`!A3pI^&AsH5MU1COg6h(r)_2xl=MSp94|_U_ +zEB;LHBia=aKm-s0L;w*$1P}p401-e05CKHsuR#ER?Pyh8vdmdu&#}<`AbZg|2h+0c +z3->N4Ih<+y{Yu-`pBvv%UsdF~9bEKu*2whAd?LPNxRv4NZDjQ7)t;?U&(xEvxt{xX +z9(xu~c^ESuH{oxqo-+P}qpR)>&Gg~>#95pdn{G)H{3k~-eSBN}lxJzLpu9Ym>(yj4 +z+ByKAUoui^&K^?GR`+G~`1O5hRVEXt%s+em@l>w*obmKzSE@@;&zwfp@Jih%%Aho7 +zw25vMhf&ktOk8YC3uaap#cn53b<;MU_@G~tDQCreu!PBF+Vmc%+~}Aocbkkz@Z}vD +zP7KjC7I#YpN8@d!S^jgMN`~$oxQp)ysW|!jLM(SO4ydxoI%bo*+CF&?jUOs*pl7^S +zX@&(7NdW + +literal 0 +HcmV?d00001 + +diff --git a/tests/f_trusted_link/name b/tests/f_trusted_link/name +new file mode 100644 +index 0000000..a6e424b +--- /dev/null ++++ b/tests/f_trusted_link/name +@@ -0,0 +1 @@ ++inode nlink according to trusted.link xattr +diff --git a/tests/filter.sed b/tests/filter.sed +index 5fd68f3..0115213 100644 +--- a/tests/filter.sed ++++ b/tests/filter.sed +@@ -39,3 +39,4 @@ s/mmp_update_date: .*/mmp_update_date: test date/ + s/mmp_update_time: .*/mmp_update_time: test_time/ + s/MMP last updated by '.*' on .*/MMP last updated by 'test_node' on test date/ + s/MMP update by '.*' at .*/MMP last updated by 'test_node' on test date/ ++s/:[0-9]*: \(increase inode [0-9]* badness\)/: \1/ +diff --git a/tests/m_rootdir/expect b/tests/m_rootdir/expect +index dbc7977..0a23d4c 100644 +--- a/tests/m_rootdir/expect ++++ b/tests/m_rootdir/expect +@@ -10,8 +10,8 @@ Filesystem OS type: Linux + Inode count: 1024 + Block count: 16384 + Reserved block count: 819 +-Overhead clusters: 1543 +-Free blocks: 14786 ++Overhead clusters: 2567 ++Free blocks: 13762 + Free inodes: 1005 + First block: 1 + Block size: 1024 +@@ -36,9 +36,9 @@ Default directory hash: half_md4 + Journal backup: inode blocks + Checksum type: crc32c + Journal features: (none) +-Total journal size: 1024k +-Total journal blocks: 1024 +-Max transaction length: 1024 ++Total journal size: 2048k ++Total journal blocks: 2048 ++Max transaction length: 2048 + Fast commit length: 0 + Journal sequence: 0x00000001 + Journal start: 0 +@@ -59,8 +59,8 @@ Group 1: (Blocks 8193-16383) [INODE_UNINIT] + Block bitmap at 131 (bg #0 + 130) + Inode bitmap at 133 (bg #0 + 132) + Inode table at 262-389 (bg #0 + 261) +- 7038 free blocks, 512 free inodes, 0 directories, 512 unused inodes +- Free blocks: 9346-16383 ++ 6014 free blocks, 512 free inodes, 0 directories, 512 unused inodes ++ Free blocks: 10370-16383 + Free inodes: 513-1024 + debugfs: stat /emptyfile + Inode: III Type: regular +@@ -117,4 +117,4 @@ Pass 2: Checking directory structure + Pass 3: Checking directory connectivity + Pass 4: Checking reference counts + Pass 5: Checking group summary information +-test.img: 19/1024 files (0.0% non-contiguous), 1598/16384 blocks ++test.img: 19/1024 files (0.0% non-contiguous), 2622/16384 blocks +diff --git a/tests/m_rootdir_acl/expect b/tests/m_rootdir_acl/expect +index 57f03e5..26f9db0 100644 +--- a/tests/m_rootdir_acl/expect ++++ b/tests/m_rootdir_acl/expect +@@ -10,8 +10,8 @@ Filesystem OS type: Linux + Inode count: 1024 + Block count: 16384 + Reserved block count: 819 +-Overhead clusters: 1799 +-Free blocks: 14533 ++Overhead clusters: 2823 ++Free blocks: 13509 + Free inodes: 1003 + First block: 1 + Block size: 1024 +@@ -36,9 +36,9 @@ Default directory hash: half_md4 + Journal backup: inode blocks + Checksum type: crc32c + Journal features: (none) +-Total journal size: 1024k +-Total journal blocks: 1024 +-Max transaction length: 1024 ++Total journal size: 2048k ++Total journal blocks: 2048 ++Max transaction length: 2048 + Fast commit length: 0 + Journal sequence: 0x00000001 + Journal start: 0 +@@ -59,8 +59,8 @@ Group 1: (Blocks 8193-16383) [INODE_UNINIT] + Block bitmap at 131 (bg #0 + 130) + Inode bitmap at 133 (bg #0 + 132) + Inode table at 390-645 (bg #0 + 389) +- 7038 free blocks, 512 free inodes, 0 directories, 512 unused inodes +- Free blocks: 9346-16383 ++ 6014 free blocks, 512 free inodes, 0 directories, 512 unused inodes ++ Free blocks: 10370-16383 + Free inodes: 513-1024 + debugfs: stat /emptyfile + Inode: III Type: regular +@@ -105,15 +105,30 @@ Extended attributes: + debugfs: ea_list acl_dir + Extended attributes: + system.data (0) +- system.posix_acl_access (28) = 01 00 00 00 01 00 07 00 04 00 05 00 08 00 05 00 2a 00 00 00 10 00 05 00 20 00 05 00 +- system.posix_acl_default (28) = 01 00 00 00 01 00 07 00 04 00 05 00 08 00 05 00 04 00 00 00 10 00 05 00 20 00 05 00 ++ system.posix_acl_access: ++ user::rwx ++ group::r-x ++ group:42:r-x ++ mask::r-x ++ other::r-x ++ system.posix_acl_default: ++ user::rwx ++ group::r-x ++ group:4:r-x ++ mask::r-x ++ other::r-x + debugfs: ea_list acl_dir/file + Extended attributes: + system.data (0) +- system.posix_acl_access (28) = 01 00 00 00 01 00 07 00 04 00 05 00 08 00 05 00 2a 00 00 00 10 00 05 00 20 00 05 00 ++ system.posix_acl_access: ++ user::rwx ++ group::r-x ++ group:42:r-x ++ mask::r-x ++ other::r-x + Pass 1: Checking inodes, blocks, and sizes + Pass 2: Checking directory structure + Pass 3: Checking directory connectivity + Pass 4: Checking reference counts + Pass 5: Checking group summary information +-test.img: 21/1024 files (0.0% non-contiguous), 1851/16384 blocks ++test.img: 21/1024 files (0.0% non-contiguous), 2875/16384 blocks +diff --git a/tests/r_fixup_lastbg/expect b/tests/r_fixup_lastbg/expect +index 96b154a..24b7cc4 100644 +--- a/tests/r_fixup_lastbg/expect ++++ b/tests/r_fixup_lastbg/expect +@@ -4,7 +4,7 @@ Superblock backups stored on blocks: + + Allocating group tables: done + Writing inode tables: done +-Creating journal (1024 blocks): done ++Creating journal (2048 blocks): done + Writing superblocks and filesystem accounting information: done + + Group 2: (Blocks 16385-19999) [INODE_UNINIT, ITABLE_ZEROED] +@@ -36,4 +36,4 @@ Pass 2: Checking directory structure + Pass 3: Checking directory connectivity + Pass 4: Checking reference counts + Pass 5: Checking group summary information +-test.img: 11/1248 files (0.0% non-contiguous), 1517/20004 blocks ++test.img: 11/1248 files (0.0% non-contiguous), 2541/20004 blocks +diff --git a/tests/r_fixup_lastbg_big/expect b/tests/r_fixup_lastbg_big/expect +index edaabaf..53da4f0 100644 +--- a/tests/r_fixup_lastbg_big/expect ++++ b/tests/r_fixup_lastbg_big/expect +@@ -4,7 +4,7 @@ Superblock backups stored on blocks: + + Allocating group tables: done + Writing inode tables: done +-Creating journal (1024 blocks): done ++Creating journal (2048 blocks): done + Writing superblocks and filesystem accounting information: done + + Group 2: (Blocks 16385-19999) [INODE_UNINIT, ITABLE_ZEROED] +@@ -42,4 +42,4 @@ Pass 2: Checking directory structure + Pass 3: Checking directory connectivity + Pass 4: Checking reference counts + Pass 5: Checking group summary information +-test.img: 11/2080 files (0.0% non-contiguous), 1809/40000 blocks ++test.img: 11/2080 files (0.0% non-contiguous), 2833/40000 blocks +diff --git a/tests/run_e2fsck b/tests/run_e2fsck +index e2c6596..1a39a89 100644 +--- a/tests/run_e2fsck ++++ b/tests/run_e2fsck +@@ -27,6 +27,8 @@ if [ "$EXP1"x = x ]; then + gunzip < $test_dir/expect.1.gz > $EXP1 + else + EXP1=$test_dir/expect.1 ++ [ "$CHECK_RHEL7" = "true" -a -f $test_dir/expect_rhel7.1 ] && ++ EXP1=$test_dir/expect_rhel7.1 || true + fi + fi + +@@ -36,6 +38,8 @@ if [ "$EXP2"x = x ]; then + gunzip < $test_dir/expect.2.gz > $EXP2 + else + EXP2=$test_dir/expect.2 ++ [ "$CHECK_RHEL7" = "true" -a -f $test_dir/expect_rhel7.2 ] && ++ EXP2=$test_dir/expect_rhel7.2 || true + fi + fi + +diff --git a/tests/test_config b/tests/test_config +index 9dc762c..79eba9d 100644 +--- a/tests/test_config ++++ b/tests/test_config +@@ -46,3 +46,13 @@ RESIZE2FS_FORCE_LAZY_ITABLE_INIT=yes + export RESIZE2FS_FORCE_LAZY_ITABLE_INIT + E2FSPROGS_LIBMAGIC_SUPPRESS=yes + export E2FSPROGS_LIBMAGIC_SUPPRESS ++ ++if [ "$(uname -s)" = "Linux" ]; then ++ LINUX_VERSION1=`uname -r | awk -F . '{ printf $1 }'` ++ LINUX_VERSION2=`uname -r | awk -F . '{ printf $2 }'` ++ [ $LINUX_VERSION1 -ge 3 -a $LINUX_VERSION2 -ge 10 ] && ++ CHECK_RHEL7=true || CHECK_RHEL7=false ++else ++ CHECK_RHEL7=false ++fi ++export CHECK_RHEL7 +diff --git a/tests/test_post b/tests/test_post +index 1251266..c9acffb 100755 +--- a/tests/test_post ++++ b/tests/test_post +@@ -10,7 +10,8 @@ test "$num_failed" -eq 0 && exit 0 + + echo -n "Tests failed: " + for fname in $(ls *.failed); do +- echo -n "${fname%%.failed} " ++ echo "${fname%%.failed} " ++ cat $fname + done + echo "" + +-- +2.33.0 + diff --git a/e2fsprogs.spec b/e2fsprogs.spec index d2fed8dd50814d3d38d609f98a3f94db3113136e..cb2132fb633d30979549652117438d768a4d3145 100644 --- a/e2fsprogs.spec +++ b/e2fsprogs.spec @@ -1,6 +1,6 @@ Name: e2fsprogs Version: 1.46.5 -Release: 4 +Release: 5 Summary: Second extended file system management tools License: GPLv2+ and LGPLv2 and MIT URL: http://e2fsprogs.sourceforge.net/ @@ -28,13 +28,16 @@ Patch18: 0018-misc-fsck.c-Processes-may-kill-other-processes.patch Patch19: 0019-debugfs-fix-repeated-output-problem-with-logdump-O-n.patch Patch20: 0020-tune2fs-check-return-value-of-ext2fs_mmp_update2-in-.patch Patch21: 0021-mmp-fix-wrong-comparison-in-ext2fs_mmp_stop.patch +Patch22: 0022-e2fsck-add-m-option-for-multithread-mode-fsck.patch +Patch23: 0023-Misc-small-enhancements-and-bugfixes-for-Lustre.patch BuildRequires: gcc pkgconfig texinfo BuildRequires: fuse-devel libblkid-devel libuuid-devel -BuildRequires: audit +BuildRequires: audit git Recommends: %{name}-help = %{version}-%{release} +Provides: ldiskfsprogs = %{version} Provides: e2fsprogs-libs%{?_isa} e2fsprogs-libs Obsoletes: e2fsprogs-libs Provides: libcom_err%{?_isa} libcom_err @@ -75,7 +78,7 @@ BuildArch: noarch This packages includes man files for e2fsprogs. %prep -%autosetup -n %{name}-%{version} -p1 +%autosetup -n %{name}-%{version} -S git_am %build @@ -169,6 +172,9 @@ exit 0 %{_mandir}/man8/* %changelog +* Mon Mar 13 2023 Xinliang Liu - 1.46.5-5 +- Add support for Lustre Ldiskfs. + * Thu Feb 9 2023 lihaoxiang - 1.46.5-4 - Upstream patches regress for debugfs, tune2fs and mmp.