# Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: colin@gibibit.com-20090615143625-5mw3hbalmw1vbbxl # target_branch: http://grub.gibibit.com/bzr/trunk-clean # testament_sha1: 54ff4c41df941b80a7d0190feb00b93953d814c9 # timestamp: 2009-06-15 07:41:27 -0700 # source_branch: http://grub.gibibit.com/bzr/gfxmenu # base_revision_id: colin@gibibit.com-20090615143527-aecd7xrtc3v0vcfs # # Begin patch === modified file 'commands/videotest.c' --- commands/videotest.c 2009-06-04 17:22:45 +0000 +++ commands/videotest.c 2009-06-08 06:46:58 +0000 @@ -1,6 +1,6 @@ /* * GRUB -- GRand Unified Bootloader - * Copyright (C) 2006,2007,2009 Free Software Foundation, Inc. + * Copyright (C) 2006,2007,2008,2009 Free Software Foundation, Inc. * * GRUB is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -16,38 +16,67 @@ * along with GRUB. If not, see . */ +#include #include #include #include +#include #include #include #include #include -#include - -static grub_err_t -grub_cmd_videotest (grub_command_t cmd __attribute__ ((unused)), - int argc __attribute__ ((unused)), - char **args __attribute__ ((unused))) -{ - if (grub_video_set_mode ("1024x768;800x600;640x480", 0) != GRUB_ERR_NONE) - return grub_errno; - +#include +#include +#include /* to test grub_vbe_bios_set_display_start */ + +/* Option array indices. */ +#define ARGINDEX_TEST_TIME 0 +#define ARGINDEX_DOUBLE_BUF 1 + +static const struct grub_arg_option arg_options[] = { + {"time", 't', 0, "Time to run each test, in seconds.", 0, ARG_TYPE_INT}, + {"dbuf", 'd', 0, "Use double buffered graphics.", 0, ARG_TYPE_NONE}, + {0, 0, 0, 0, 0, 0} +}; + +#define DEFAULT_TEST_TIME 5 + +/* Command options -- populated base on command line arguments. */ +struct videotest_options +{ + int test_time; + int double_buffering; +}; + +/* List of video modes to try when an exact resolution is not required. */ +static const char preferred_mode_list[] = "1024x768;800x600;640x480"; + +static void +basic_video_test (struct videotest_options *vt_opts) +{ grub_video_color_t color; + grub_video_color_t bg; unsigned int x; unsigned int y; unsigned int width; unsigned int height; int i; - grub_font_t sansbig; - grub_font_t sans; - grub_font_t sanssmall; - grub_font_t fixed; struct grub_font_glyph *glyph; struct grub_video_render_target *text_layer; + grub_font_t fixed; grub_video_color_t palette[16]; - const char *str; - int texty; + int info_width; + int info_height; + + if (grub_video_set_mode (preferred_mode_list, 0) != GRUB_ERR_NONE) + return; + grub_video_enable_double_buffering (vt_opts->double_buffering); + + if (! (fixed = grub_font_get ("Fixed Regular 20"))) + { + grub_error (GRUB_ERR_BAD_FONT, "No font loaded."); + return; + } grub_video_get_viewport (&x, &y, &width, &height); @@ -57,7 +86,11 @@ grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + info_width = 500; + info_height = 100; + color = grub_video_map_rgb (0, 0, 0); + bg = color; grub_video_fill_rect (color, 0, 0, width, height); color = grub_video_map_rgb (255, 0, 0); @@ -66,13 +99,6 @@ color = grub_video_map_rgb (0, 255, 255); grub_video_fill_rect (color, 100, 100, 100, 100); - sansbig = grub_font_get ("Helvetica Bold 24"); - sans = grub_font_get ("Helvetica Bold 14"); - sanssmall = grub_font_get ("Helvetica 8"); - fixed = grub_font_get ("Fixed 20"); - if (! sansbig || ! sans || ! sanssmall || ! fixed) - return grub_error (GRUB_ERR_BAD_FONT, "No font loaded."); - glyph = grub_font_get_glyph (fixed, '*'); grub_font_draw_glyph (glyph, color, 200 ,0); @@ -83,17 +109,1028 @@ grub_video_set_active_render_target (text_layer); - color = grub_video_map_rgb (255, 255, 255); - - texty = 32; - grub_font_draw_string ("The quick brown fox jumped over the lazy dog.", - sans, color, 16, texty); - texty += grub_font_get_descent (sans) + grub_font_get_leading (sans); - - texty += grub_font_get_ascent (fixed); - grub_font_draw_string ("The quick brown fox jumped over the lazy dog.", - fixed, color, 16, texty); - texty += grub_font_get_descent (fixed) + grub_font_get_leading (fixed); + color = grub_video_map_rgb (255, 255, 0); + grub_font_draw_string ("ABCDEFG", fixed, color, 16, 100); + color = grub_video_map_rgb (128, 128, 255); + grub_font_draw_string ("The quick brown fox jumped over the lazy dog.", + fixed, color, 16, 150); + + color = grub_video_map_rgb (255, 255, 255); + glyph = grub_font_get_glyph (fixed, '*'); + + for (i = 0; i < 16; i++) + { + color = grub_video_map_color (i); + palette[i] = color; + grub_font_draw_glyph (glyph, color, 16 + i * 16, 220); + } + + grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + + for (i = 0; i < 255; i++) + { + color = grub_video_map_rgb (i, 33, 77); + grub_video_fill_rect (color, 0, 0, width, height); + grub_video_blit_render_target (text_layer, GRUB_VIDEO_BLIT_BLEND, 0, 0, + 0, 0, width, height); + } + + color = grub_video_map_rgb (255, 255, 0); + grub_font_draw_string ("Press a key to continue.", fixed, color, 10, 60); + grub_video_swap_buffers (); + grub_getkey (); + grub_video_fill_rect (bg, 0, 0, info_width, info_height); /* Clear info. */ + + /* Test VBE set display start address. */ + /* This should scroll the screen, first vertically, + * then horizontally. The horizontal scrolling seems to + * only have a resolution of about 16 pixels on my VIA Mini-ITX. */ + grub_font_draw_string ("Testing VBE 'Set display start' operation " + "for horizontal scrolling...", + fixed, color, 10, 20); + grub_video_swap_buffers (); + int vbestatus; + int vbeok = 0; + int vbeerr = 0; + for (i = 0; i < 50; i++) + { + vbestatus = grub_vbe_bios_set_display_start (0, i); + if (vbestatus == GRUB_VBE_STATUS_OK) + vbeok++; + else + vbeerr++; + } + + grub_font_draw_string ("Press a key to continue.", fixed, color, 10, 60); + grub_video_swap_buffers (); + grub_getkey (); + grub_video_fill_rect (bg, 0, 0, info_width, info_height); /* Clear info. */ + grub_video_swap_buffers (); + + grub_font_draw_string ("Testing VBE 'Set display start' operation " + "for vertical scrolling...", + fixed, color, 10, 40); + grub_video_swap_buffers (); + for (i = 0; i < 50; i++) + { + vbestatus = grub_vbe_bios_set_display_start (i, 50); + if (vbestatus == GRUB_VBE_STATUS_OK) + vbeok++; + else + vbeerr++; + } + + grub_font_draw_string ("Press a key to continue.", fixed, color, 10, 60); + grub_video_swap_buffers (); + grub_getkey (); + grub_video_fill_rect (bg, 0, 0, info_width, info_height); /* Clear info. */ + grub_video_swap_buffers (); + + grub_video_delete_render_target (text_layer); + grub_video_restore (); + + grub_printf ("VBE set_display_start status: %d\n", vbestatus); + grub_printf ("ok: %d\n", vbeok); + grub_printf ("errors: %d\n", vbeerr); + + grub_errno = GRUB_ERR_NONE; +} + + + +/* Simple opaque image blit test. + Returns the error status in grub_errno. */ +static void +bitmap_demo (struct videotest_options *vt_opts) +{ + if (grub_video_set_mode (preferred_mode_list, 0) != GRUB_ERR_NONE) + return; + grub_video_enable_double_buffering (vt_opts->double_buffering); + + grub_video_rect_t view; + grub_video_get_viewport ((unsigned *) &view.x, (unsigned *) &view.y, + (unsigned *) &view.width, + (unsigned *) &view.height); + + grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + const int bm1width = 500, bm1height = 400; + struct grub_video_bitmap *bitmap1; + + if (grub_video_bitmap_create (&bitmap1, bm1width, bm1height, + GRUB_VIDEO_BLIT_FORMAT_RGB_888) + != GRUB_ERR_NONE) + return; + + int offset = 0; + int x; + int y; + grub_uint8_t *data = grub_video_bitmap_get_data (bitmap1); + for (y = 0; y < bm1height; y++) + { + for (x = 0; x < bm1width; x++) + { + data[offset++] = x ^ y; /* red */ + data[offset++] = (x * 3) ^ (y * 3); /* green */ + data[offset++] = (x * 2) ^ (y * 2); /* blue */ + } + } + + /* Blit the entire bitmap in the center of the screen. */ + grub_video_blit_bitmap (bitmap1, + GRUB_VIDEO_BLIT_REPLACE, + view.x + (view.width - bm1width) / 2, + view.y + (view.height - bm1height) / 2, + 0, 0, bm1width, bm1height); + grub_video_swap_buffers (); + grub_getkey (); + + /* Blit more copies of the bitmap. */ + /* Upper left. */ + grub_video_blit_bitmap (bitmap1, GRUB_VIDEO_BLIT_REPLACE, + view.x, view.y, 0, 0, bm1width, bm1height); + /* Upper right. */ + grub_video_blit_bitmap (bitmap1, + GRUB_VIDEO_BLIT_REPLACE, + view.x + view.width - bm1width, + view.y, 0, 0, bm1width, bm1height); + /* Lower left. */ + grub_video_blit_bitmap (bitmap1, + GRUB_VIDEO_BLIT_REPLACE, + view.x, + view.y + view.height - bm1height, + 0, 0, bm1width, bm1height); + /* Lower right. */ + grub_video_blit_bitmap (bitmap1, + GRUB_VIDEO_BLIT_REPLACE, + view.x + view.width - bm1width, + view.y + view.height - bm1height, + 0, 0, bm1width, bm1height); + grub_video_swap_buffers (); + grub_getkey (); + + int clearbg = 0; /* Boolean flag: whether to fill background. */ + grub_video_color_t bgcolor = grub_video_map_rgb (16, 16, 96); + + /* Animate the image sliding in. End when a key is pressed. */ + int vscale = 1000; + int velocityx = -5000; + int velocityy = -8000; + int positionx = 100; + int positiony = 300; + + grub_uint32_t frame_count = 0; + grub_uint32_t start_time = grub_get_time_ms (); + + while (grub_checkkey () == -1) + { + /* If the time limit option is set, then check if it's exceeded. */ + if (vt_opts->test_time != 0 + && grub_get_time_ms () >= start_time + vt_opts->test_time * 1000) + break; + + int newx = positionx + velocityx / vscale; + int newy = positiony + velocityy / vscale; + + /* Check collision w/ left */ + if (newx < view.x && velocityx < 0) + { + velocityx = -velocityx; + newx = positionx + velocityx / vscale; + } + /* Check collision w/ right */ + if (newx + bm1width > view.x + view.width && velocityx > 0) + { + velocityx = -velocityx; + newx = positionx + velocityx / vscale; + } + /* Check collision w/ top */ + if (newy < 0 && velocityy < 0) + { + velocityy = -velocityy; + newy = positiony + velocityy / vscale; + } + /* Check collision w/ bottom */ + if (newy + bm1height > view.y + view.height && velocityy > 0) + { + velocityy = -velocityy; + newy = positiony + velocityy / vscale; + } + + positionx = newx; + positiony = newy; + + if (clearbg) + grub_video_fill_rect (bgcolor, view.x, view.y, view.width, + view.height); + + grub_video_blit_bitmap (bitmap1, + GRUB_VIDEO_BLIT_REPLACE, + view.x + positionx, + view.y + positiony, 0, 0, bm1width, bm1height); + grub_video_swap_buffers (); + frame_count++; + + /* Acceleration due to gravity... + * note that the y coordinate is increasing downward. */ + velocityy += vscale / 7; + } + + /* Calculate average frame rate. */ + grub_uint32_t duration = grub_get_time_ms () - start_time; + grub_uint32_t fps_x10 = 10 * 1000 * frame_count / duration; + + /* Eat the keystroke. */ + if (grub_checkkey () != -1) + grub_getkey (); + + grub_video_bitmap_destroy (bitmap1); + grub_video_restore (); + + grub_printf ("Average frame rate: %d.%d fps\n", fps_x10 / 10, fps_x10 % 10); + + grub_errno = GRUB_ERR_NONE; +} + + + +/* Configuration settings for a benchmark run. */ +struct benchmark_config +{ + const char *modespec; + int use_rgba_bitmaps; +}; + +/* The video configurations to use for the benchmark. */ +static struct benchmark_config benchmark_configs[] = { + {"320x200", 0}, + {"640x480", 0}, + {"1024x768", 0}, + {"1024x768", 1}, +}; + +#define NUM_BENCHMARK_CONFIGS (sizeof(benchmark_configs) \ + / sizeof(benchmark_configs[0])) + +struct benchmark_result +{ + /* If set to 1, the test was able to run successfully; + 0 means there was an error. */ + int test_passed; + + /* Dimensions of the video mode used. */ + int width; + int height; + + /* Bits per pixel for the video mode used. */ + int bpp; + + /* All fps are in fps * 10 to achieve one decimal place. */ + /* Set to 0 to indicate the test could not be run. */ + grub_int32_t fill_fps; + grub_int32_t blit_fps; + grub_int32_t blend_fps; + grub_int32_t text_ascii_cps; + grub_int32_t text_unicode_cps; +}; + +#define BENCHMARK_RESULT_FPS_SCALE 10 +#define BENCHMARK_RESULT_CPS_SCALE 1 + +static void +move_rectangle_one_step (int *x, int *y, + int width, int height, + int *vx, int *vy, const grub_video_rect_t * bounds) +{ + int newx = *x + *vx; + int newy = *y + *vy; + + /* Check collision w/ left */ + if (newx < bounds->x && *vx < 0) + { + *vx = -*vx; + newx = *x + *vx; + } + /* Check collision w/ right */ + if (newx + width > bounds->x + bounds->width && *vx > 0) + { + *vx = -*vx; + newx = *x + *vx; + } + /* Check collision w/ top */ + if (newy < 0 && *vy < 0) + { + *vy = -*vy; + newy = *y + *vy; + } + /* Check collision w/ bottom */ + if (newy + height > bounds->y + bounds->height && *vy > 0) + { + *vy = -*vy; + newy = *y + *vy; + } + + *x = newx; + *y = newy; +} + +/* Get the length of a UTF-8 encoded character string. */ +static int +strlen_utf8 (const char *utf8str) +{ + int len; + const grub_uint8_t *ptr; + grub_uint32_t code; + + for (len = 0, ptr = (const grub_uint8_t *) utf8str; + grub_utf8_to_ucs4 (&code, 1, ptr, -1, &ptr) > 0; ) + len++; + + return len; +} + +/* Test text rendering performance. */ +static void +benchmark_text (const char *test_str, + grub_int32_t *cps_result, + struct videotest_options *vt_opts, + grub_video_rect_t *view) +{ + grub_uint32_t char_count; + grub_uint64_t start_time; + grub_uint64_t desired_stop_time; + grub_uint32_t duration; + grub_video_color_t black; + grub_video_color_t text_colors[4]; + grub_font_t font; + int phase; + int test_str_len; + + test_str_len = strlen_utf8 (test_str); + black = grub_video_map_rgb (0, 0, 0); + text_colors[0] = grub_video_map_rgb (44, 44, 54); + text_colors[1] = grub_video_map_rgb (64, 64, 96); + text_colors[2] = grub_video_map_rgb (80, 80, 140); + text_colors[3] = grub_video_map_rgb (255, 255, 255); + font = grub_font_get ("unifont Regular 10"); + + char_count = 0; + start_time = grub_get_time_ms (); + desired_stop_time = start_time + vt_opts->test_time * 1000; + + phase = 0; + while (grub_get_time_ms () < desired_stop_time && grub_checkkey () == -1) + { + int color_index; + + grub_video_fill_rect (black, 0, 0, view->width, view->height); + + /* Draw a series of lines in different colors. */ + for (color_index = 0; color_index < 4; color_index++) + { + int line_number; + + for (line_number = 0; line_number < 20; line_number++) + { + int x; + int y; + + x = 10 - color_index; + y = (10 - color_index + + (line_number + 1) * phase + + grub_font_get_height (font) * line_number + + grub_font_get_ascent (font)); + grub_font_draw_string (test_str, font, + text_colors[color_index], x, y); + /* Note: Using grub_strlen is not UTF-8-safe. */ + char_count += test_str_len; + } + } + + phase += 2; + if (phase > 15) + phase = 0; + + grub_video_swap_buffers (); + } + if (grub_checkkey () != -1) + grub_getkey (); /* Eat the keypress, if there was one. */ + + /* Calculate average frame rate. */ + duration = grub_get_time_ms () - start_time; + if (duration == 0) + { + *cps_result = 0; + } + else + { + *cps_result = (BENCHMARK_RESULT_CPS_SCALE * 1000 + * char_count / duration); + } +} + +/* Run the benchmark test for a particular video mode, which is specified + by `*config'. The results of the test are stored in `*result'. */ +static void +do_benchmark (const struct benchmark_config *config, + struct benchmark_result *result, + struct videotest_options *vt_opts) +{ + struct grub_video_mode_info modeinfo; + + result->test_passed = 0; + result->width = 0; + result->height = 0; + result->bpp = 0; + result->fill_fps = 0; + result->blit_fps = 0; + result->blend_fps = 0; + + if (grub_video_set_mode (config->modespec, 0) != GRUB_ERR_NONE) + return; + grub_video_enable_double_buffering (vt_opts->double_buffering); + + if (grub_video_get_info (&modeinfo) == GRUB_ERR_NONE) + { + result->width = modeinfo.width; + result->height = modeinfo.height; + result->bpp = modeinfo.bpp; + } + + /* Full screen bitmap blit test. */ + + grub_video_rect_t view; + grub_video_get_viewport ((unsigned *) &view.x, (unsigned *) &view.y, + (unsigned *) &view.width, + (unsigned *) &view.height); + + grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + + + /* For measuring timing. */ + grub_uint32_t frame_count; + grub_uint64_t start_time; + grub_uint64_t desired_stop_time; + grub_uint32_t duration; + + + /*** FILL TEST ***/ + + /* Alternates between 0 and 1 to change the color. */ + int color_flag = 0; + grub_video_color_t fillcolors[2]; + fillcolors[0] = grub_video_map_rgb (0, 0, 255); + fillcolors[1] = grub_video_map_rgb (255, 255, 0); + + frame_count = 0; + start_time = grub_get_time_ms (); + desired_stop_time = start_time + vt_opts->test_time * 1000; + + while (grub_get_time_ms () < desired_stop_time && grub_checkkey () == -1) + { + grub_video_fill_rect (fillcolors[color_flag], + view.x, view.y, view.width, view.height); + grub_video_swap_buffers (); + color_flag ^= 1; + frame_count++; + } + if (grub_checkkey () != -1) + grub_getkey (); /* Eat the keypress, if there was one. */ + + /* Calculate average frame rate. */ + duration = grub_get_time_ms () - start_time; + if (duration == 0) + { + result->fill_fps = 0; + } + else + { + result->fill_fps = + (BENCHMARK_RESULT_FPS_SCALE * 1000 + * frame_count / duration); + } + + + /*** BLIT TEST ***/ + + /* Generate two bitmaps, the same size as the screen. */ + const int bitmapwidth = view.width, bitmapheight = view.height; + struct grub_video_bitmap *bitmap1; + struct grub_video_bitmap *bitmap2; + enum grub_video_blit_format bitmap_format = config->use_rgba_bitmaps + ? GRUB_VIDEO_BLIT_FORMAT_RGBA_8888 : GRUB_VIDEO_BLIT_FORMAT_RGB_888; + + if (grub_video_bitmap_create (&bitmap1, bitmapwidth, bitmapheight, + bitmap_format) != GRUB_ERR_NONE) + return; + + if (grub_video_bitmap_create (&bitmap2, bitmapwidth, bitmapheight, + bitmap_format) != GRUB_ERR_NONE) + { + grub_video_bitmap_destroy (bitmap1); + return; + } + + int offset; + int x; + int y; + grub_uint8_t *data; + + offset = 0; + data = grub_video_bitmap_get_data (bitmap1); + for (y = 0; y < bitmapheight; y++) + { + for (x = 0; x < bitmapwidth; x++) + { + data[offset++] = x ^ y; /* red */ + data[offset++] = (x * 3) ^ (y * 3); /* green */ + data[offset++] = (x * 2) ^ (y * 2); /* blue */ + if (config->use_rgba_bitmaps) + data[offset++] = 255; + } + } + + offset = 0; + data = grub_video_bitmap_get_data (bitmap2); + for (y = 0; y < bitmapheight; y++) + { + for (x = 0; x < bitmapwidth; x++) + { + data[offset++] = x + y; /* red */ + data[offset++] = x * x + y * y; /* green */ + data[offset++] = x * x / 4 + y * y / 4; /* blue */ + if (config->use_rgba_bitmaps) + data[offset++] = 255; + } + } + + + /* Now do the blit test, alternating between the two bitmaps. */ + frame_count = 0; + start_time = grub_get_time_ms (); + desired_stop_time = start_time + vt_opts->test_time * 1000; + + int cur = 0; /* Which bitmap to draw this frame. */ + while (grub_get_time_ms () < desired_stop_time && grub_checkkey () == -1) + { + struct grub_video_bitmap *current_bitmap = cur == 0 ? bitmap1 : bitmap2; + grub_video_blit_bitmap (current_bitmap, + GRUB_VIDEO_BLIT_REPLACE, + view.x, view.y, 0, 0, bitmapwidth, + bitmapheight); + grub_video_swap_buffers (); + frame_count++; + cur ^= 1; + } + if (grub_checkkey () != -1) + grub_getkey (); /* Eat the keypress, if there was once. */ + + /* Calculate average frame rate. */ + duration = grub_get_time_ms () - start_time; + if (duration == 0) + { + result->blit_fps = 0; + } + else + { + result->blit_fps = + (BENCHMARK_RESULT_FPS_SCALE * 1000 + * frame_count / duration); + } + + grub_video_bitmap_destroy (bitmap2); + grub_video_bitmap_destroy (bitmap1); + + + + /*** BLEND TEST ***/ + + /* Generate two bitmaps, with alpha translucency. */ + const int bbw = view.width * 2 / 3; + const int bbh = view.height * 2 / 3; + + if (grub_video_bitmap_create (&bitmap1, bbw, bbh, + GRUB_VIDEO_BLIT_FORMAT_RGBA_8888) != + GRUB_ERR_NONE) + return; + + if (grub_video_bitmap_create (&bitmap2, bbw, bbh, + GRUB_VIDEO_BLIT_FORMAT_RGBA_8888) != + GRUB_ERR_NONE) + { + grub_video_bitmap_destroy (bitmap1); + return; + } + + offset = 0; + data = grub_video_bitmap_get_data (bitmap1); + for (y = 0; y < bbh; y++) + { + for (x = 0; x < bbw; x++) + { + /* Calculate a to be increasing away from the center. */ + int dx = 256 * (x - bbw / 2) / (bbw / 2); + int dy = 256 * (y - bbh / 2) / (bbh / 2); + int a = dx * dx + dy * dy; + /* range for a = 0 .. 2*(256^2) = 2*2^16 = 2^17 */ + a >>= 17 - 8; /* Make range 0..256. */ + if (a > 255) + a = 255; + + data[offset++] = x ^ y; /* red */ + data[offset++] = (x * 3) ^ (y * 3); /* green */ + data[offset++] = (x * 2) ^ (y * 2); /* blue */ + data[offset++] = 255 - a; + } + } + + offset = 0; + data = grub_video_bitmap_get_data (bitmap2); + for (y = 0; y < bbh; y++) + { + for (x = 0; x < bbw; x++) + { + data[offset++] = x + y; /* red */ + data[offset++] = x * x + y * y; /* green */ + data[offset++] = x * x / 4 + y * y / 4; /* blue */ + data[offset++] = 255; + } + } + + frame_count = 0; + start_time = grub_get_time_ms (); + desired_stop_time = start_time + vt_opts->test_time * 1000; + + + grub_video_color_t bgcolor = grub_video_map_rgb (80, 80, 80); + + /* Bitmap locations. */ + int b1x = 0; + int b1y = 0; + int b2x = view.width - bbw; + int b2y = 0; + /* Bitmap velocities. */ + int b1vx = 8; + int b1vy = 12; + int b2vx = -10; + int b2vy = 9; + + while (grub_get_time_ms () < desired_stop_time && grub_checkkey () == -1) + { + move_rectangle_one_step (&b1x, &b1y, bbw, bbh, &b1vx, &b1vy, &view); + move_rectangle_one_step (&b2x, &b2y, bbw, bbh, &b2vx, &b2vy, &view); + grub_video_fill_rect (bgcolor, view.x, view.y, view.width, view.height); + grub_video_blit_bitmap (bitmap2, + GRUB_VIDEO_BLIT_BLEND, + b2x, b2y, 0, 0, bbw, bbh); + grub_video_blit_bitmap (bitmap1, + GRUB_VIDEO_BLIT_BLEND, + b1x, b1y, 0, 0, bbw, bbh); + grub_video_swap_buffers (); + frame_count++; + cur ^= 1; + } + if (grub_checkkey () != -1) + grub_getkey (); /* Eat the keypress, if there was once. */ + + /* Calculate average frame rate. */ + duration = grub_get_time_ms () - start_time; + if (duration == 0) + { + result->blend_fps = 0; + } + else + { + result->blend_fps = + (BENCHMARK_RESULT_FPS_SCALE * 1000 + * frame_count / duration); + } + + grub_video_bitmap_destroy (bitmap2); + grub_video_bitmap_destroy (bitmap1); + + /* Text benchmark with 104 characters of English ASCII text. */ + benchmark_text ("The quick brown fox jumped over the lazy dog. " + "(1234567890). " + "THE RAIN IN SPAIN FALLS MAINLY ON THE PLAIN.", + &result->text_ascii_cps, vt_opts, &view); + /* Text benchmark with 104 Unicode characters pseudorandomly uniformly + distributed over the characters provided by GNU unifont. The string is + UTF-8 encoded. */ + benchmark_text ("\xE4\x94\x93\xEB\x83\xA6\xE2\x94\x85\xEB\xA8\xB1\xEE\x81" + "\xA3\xDD\x9D\xEA\xBC\xA4\xE1\xA3\x86\xEE\x8C\xA5\xE5\x8A" + "\x81\xEC\x99\x8A\xE0\xAE\xA1\xE8\xB4\xAC\xE4\x9A\xBD\xE6" + "\xB5\xAD\xED\xA4\x98\xEA\x88\x92\xE7\xA2\x9C\xEE\xAC\x8C" + "\xE9\x95\x9C\xE5\xB0\x89\xEB\x82\xA2\xE3\x9E\x89\xE8\xA4" + "\x87\xE4\xAC\xA0\xE8\x89\xA4\xE7\x8E\xAC\xE6\xA2\x95\xEE" + "\xAC\xB9\xE5\x9C\x8D\xEC\x8A\xA5\xE6\xB5\xA2\xE1\xA5\xBA" + "\xE2\x93\x80\xE6\x92\xA9\xE3\x9B\xB3\xE2\xB0\x9D\xE2\x95" + "\x94\xE7\xAD\x89\xE2\x83\x88\xEA\x8D\xA5\xE5\x8C\x99\xE5" + "\x9F\xB9\xE4\x88\x97\xEC\x95\xA6\xC9\xBD\xE5\xA1\x86\xE7" + "\xA3\xBE\xEA\x9A\xA9\xE5\x93\x98\xE4\xAD\xB1\xE1\x90\xB8" + "\xE4\x8A\x91\xE8\x8B\xBA\xE9\xB5\x80\xE8\xB6\xB1\xE4\x89" + "\xB4\xE4\xB8\x82\xDF\x8C\xE6\xAB\x83\xEA\x94\x8F\xEC\xA9" + "\xB1\xED\xA0\xA6\xEB\xBA\x89\xE2\xB1\x88\xE7\xA7\xA5\xE3" + "\x8A\x92\xE5\xA1\xA5\xEC\xAB\x89\xEA\xB7\x9B\xEA\x92\xBE" + "\xEA\xAD\x85\xE3\xB8\x8A\xE0\xB8\xBD\xEE\xB5\x9C\xE1\x93" + "\xB7\xE3\xB1\x8A\xE8\x8A\xB8\xEB\xA6\x85\xEE\x8B\xB4\xE1" + "\x92\xA7\xE4\x88\x8C\xE0\xA2\xB2\xE5\x9C\xB8\xEC\x94\x86" + "\xED\x86\x82\xE2\x87\xBF\xE1\xA4\x81\xE3\x84\x8A\xE2\xA7" + "\x8B\xE8\x8F\x84\xED\x98\x9A\xE3\x85\x92\xE9\xA4\x80\xED" + "\x86\xB9\xE5\xB6\x9A\xE4\xBF\xBC\xE1\x97\x92\xEE\x86\x90" + "\xE2\xB1\x8B\xC3\x83\xEC\x8D\xA4\xED\x9E\x90\xE3\xBB\x8E", + &result->text_unicode_cps, vt_opts, &view); + + grub_video_restore (); + result->test_passed = 1; +} + +/* Run a benchmark test in a series of video modes. + The results are reported in tabular form. This will be helpful to + determine how effective various optimizations are. */ +static void +benchmark_test (struct videotest_options *vt_opts) +{ + unsigned int i; + struct benchmark_result results[NUM_BENCHMARK_CONFIGS]; + + /* Set option default values. */ + if (vt_opts->test_time == 0) + vt_opts->test_time = DEFAULT_TEST_TIME; + + /* Run benchmarks. */ + for (i = 0; i < NUM_BENCHMARK_CONFIGS; i++) + { + grub_error_push (); + do_benchmark (&benchmark_configs[i], &results[i], vt_opts); + } + + grub_print_error (); + + /* Display results. */ + grub_printf ("Benchmark results (in frames/s):\n"); + grub_printf ("(W=Width, H=Height, B=Bits per pixel, A=Bitmap Alpha)\n"); + grub_printf (" TEXT chars/s\n"); + grub_printf (" W H B A FILL BLIT BLEND ASCII UNICODE\n"); + for (i = 0; i < NUM_BENCHMARK_CONFIGS; i++) + { + struct benchmark_config *c = &benchmark_configs[i]; + struct benchmark_result *r = &results[i]; + + if (r->test_passed) + { + grub_printf ("%4dx%4d %2d %d: %4d.%d %4d.%d %4d.%d %5d %5d\n", + r->width, r->height, r->bpp, + c->use_rgba_bitmaps, + r->fill_fps / BENCHMARK_RESULT_FPS_SCALE, + r->fill_fps % BENCHMARK_RESULT_FPS_SCALE, + r->blit_fps / BENCHMARK_RESULT_FPS_SCALE, + r->blit_fps % BENCHMARK_RESULT_FPS_SCALE, + r->blend_fps / BENCHMARK_RESULT_FPS_SCALE, + r->blend_fps % BENCHMARK_RESULT_FPS_SCALE, + r->text_ascii_cps / BENCHMARK_RESULT_CPS_SCALE, + r->text_unicode_cps / BENCHMARK_RESULT_CPS_SCALE); + } + else + { + grub_printf ("%s Not supported.\n", c->modespec); + } + } + + grub_errno = GRUB_ERR_NONE; +} + + +/* Test time functions. */ +static void +clock_test (struct videotest_options *vt_opts) +{ + if (grub_video_set_mode ("640x480", 0) != GRUB_ERR_NONE) + return; + grub_video_enable_double_buffering (vt_opts->double_buffering); + + grub_video_rect_t view; + grub_video_get_viewport ((unsigned *) &view.x, (unsigned *) &view.y, + (unsigned *) &view.width, + (unsigned *) &view.height); + + grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + + /* Draw a progress bar that animates in sync with time. */ + + grub_video_rect_t bar_frame; + bar_frame.width = view.width - 2 * view.width / 10; + bar_frame.height = view.height / 20; + bar_frame.x = view.x + view.width / 10; + bar_frame.y = view.y + view.height - bar_frame.height - view.height / 10; + + grub_video_color_t bgcolor = grub_video_map_rgb (50, 50, 50); + grub_video_color_t framecolor = grub_video_map_rgb (255, 255, 255); + grub_video_color_t barbgcolor = grub_video_map_rgb (0, 0, 128); + grub_video_color_t barcolor = grub_video_map_rgb (100, 100, 255); + + grub_uint32_t frame_count; + grub_uint64_t start_time; + grub_uint64_t barstart; + grub_uint32_t barlength = 1000; + + grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + + frame_count = 0; + start_time = grub_get_time_ms (); + barstart = grub_get_time_ms (); + + while (grub_checkkey () == -1) + { + grub_uint64_t now; + grub_uint32_t bartime; + now = grub_get_time_ms (); + /* If the time limit option is set, then check if it's exceeded. */ + if (vt_opts->test_time != 0 + && now >= start_time + vt_opts->test_time * 1000) + break; + bartime = now - barstart; + if (bartime > barlength) + { + barstart = grub_get_time_ms (); /* Start over. */ + bartime = barlength; + } + + /* Clear screen. */ + grub_video_fill_rect (bgcolor, view.x, view.y, view.width, view.height); + + /* Border. */ + grub_video_fill_rect (framecolor, + bar_frame.x - 1, bar_frame.y - 1, + bar_frame.width + 2, bar_frame.height + 2); + + /* Bar background. */ + int barwidth = bar_frame.width * bartime / barlength; + grub_video_fill_rect (barbgcolor, bar_frame.x + barwidth, + bar_frame.y, bar_frame.width - barwidth, + bar_frame.height); + /* Bar foreground. */ + grub_video_fill_rect (barcolor, bar_frame.x, bar_frame.y, + barwidth, bar_frame.height); + grub_video_swap_buffers (); + frame_count++; + } + + grub_uint32_t duration = grub_get_time_ms () - start_time; + grub_uint32_t fps_x10 = 10 * 1000 * frame_count / duration; + + if (grub_checkkey () != -1) + grub_getkey (); /* Eat the keypress, if there was one. */ + grub_video_restore (); + grub_printf ("Average frame rate: %d.%d fps\n", fps_x10 / 10, fps_x10 % 10); +} + + +/* Test double buffering. */ +static void +doublebuf_test (struct videotest_options *vt_opts) +{ + if (grub_video_set_mode ("640x480", 0) != GRUB_ERR_NONE) + return; + grub_video_enable_double_buffering (vt_opts->double_buffering); + + grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + + grub_video_color_t red = grub_video_map_rgb (255, 50, 50); + grub_video_color_t yellow = grub_video_map_rgb (255, 255, 0); + grub_video_color_t green = grub_video_map_rgb (20, 255, 20); + grub_video_color_t blue = grub_video_map_rgb (50, 50, 255); + grub_video_color_t black = grub_video_map_rgb (0, 0, 0); + grub_video_color_t bgcolor = grub_video_map_rgb (255, 255, 255); + + grub_video_fill_rect (bgcolor, 0, 0, 640, 480); + grub_video_fill_rect (red, 100, 100, 200, 200); + grub_video_swap_buffers (); + grub_getkey (); + + grub_video_fill_rect (bgcolor, 0, 0, 640, 480); + grub_video_fill_rect (yellow, 120, 120, 200, 200); + grub_video_swap_buffers (); + grub_getkey (); + + grub_video_fill_rect (bgcolor, 0, 0, 640, 480); + grub_video_fill_rect (green, 140, 140, 200, 200); + grub_video_swap_buffers (); + grub_getkey (); + + grub_video_fill_rect (bgcolor, 0, 0, 640, 480); + grub_video_fill_rect (blue, 160, 160, 200, 200); + grub_video_swap_buffers (); + grub_getkey (); + + grub_video_fill_rect (bgcolor, 0, 0, 640, 480); + grub_video_fill_rect (black, 180, 180, 200, 200); + grub_video_swap_buffers (); + grub_getkey (); + + grub_video_restore (); +} + + +/* Test text rendering. */ +static void +text_test (struct videotest_options *vt_opts) +{ + grub_video_color_t color; + const char *s; + int view_x; + int view_y; + int view_width; + int view_height; + int xpos; + int ypos; + int i; + grub_font_t font1; + grub_font_t font2; + grub_font_t font3; + grub_font_t sansbig; + grub_font_t sans; + grub_font_t sanssmall; + grub_font_t fixed; + + if (grub_video_set_mode (preferred_mode_list, 0) != GRUB_ERR_NONE) + return; + grub_video_enable_double_buffering (vt_opts->double_buffering); + + grub_video_get_viewport ((unsigned int *) &view_x, + (unsigned int *) &view_y, + (unsigned int *) &view_width, + (unsigned int *) &view_height); + grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + + if (!(font1 = grub_font_get ("New Century Schoolbook Regular 24")) + || !(font2 = grub_font_get ("Helvetica Bold 14")) + || !(font3 = grub_font_get ("Helvetica Regular 10")) + || !(sansbig = grub_font_get ("Helvetica Bold 24")) + || !(sans = grub_font_get ("Helvetica Bold 14")) + || !(sanssmall = grub_font_get ("Helvetica Regular 8")) + || !(fixed = grub_font_get ("Fixed Regular 20"))) + { + grub_video_restore (); + grub_error (GRUB_ERR_BAD_FONT, "No font loaded."); + return; + } + + color = grub_video_map_rgb (0, 0, 0); + grub_video_fill_rect (color, 0, 0, view_width, view_height); + + color = grub_video_map_rgb (255, 0, 0); + grub_video_fill_rect (color, 0, 0, 100, 100); + + color = grub_video_map_rgb (0, 255, 255); + grub_video_fill_rect (color, 100, 100, 100, 100); + + color = grub_video_map_rgb (255, 255, 255); + + xpos = 10; + ypos = 30; + s = "Hello, World!"; + for (i = 0; i < 24; i++) + { + if (xpos + grub_font_get_string_width (font1, s) >= view_width) + { + /* The string will wrap; go to the beginning of the next line. */ + xpos = 10; + ypos += (grub_font_get_descent (font1) + + grub_font_get_ascent (font1)); + } + grub_font_draw_string ("Hello, World!", + font1, grub_video_map_rgb (255, 255, 0), + xpos, ypos); + + xpos += grub_font_get_string_width (font1, s); + } + + xpos = 240; + ypos = 280; + grub_font_draw_string (grub_font_get_name (font1), + font1, grub_video_map_rgb (255, 255, 255), + xpos, ypos); + ypos += grub_font_get_descent (font1) + grub_font_get_ascent (font2) + 2; + grub_font_draw_string (grub_font_get_name (font2), + font2, grub_video_map_rgb (255, 255, 255), + xpos, ypos); + ypos += grub_font_get_descent (font2) + grub_font_get_ascent (font3) + 2; + grub_font_draw_string (grub_font_get_name (font3), + font3, grub_video_map_rgb (255, 255, 255), + xpos, ypos); + + ypos += 40; /* Spacing. */ + + grub_font_draw_string ("The quick brown fox jumped over the lazy dog.", + sans, color, view_x + 16, ypos); + ypos += grub_font_get_descent (sans) + grub_font_get_leading (sans); + + ypos += grub_font_get_ascent (fixed); + grub_font_draw_string ("The quick brown fox jumped over the lazy dog.", + fixed, color, 16, ypos); + ypos += grub_font_get_descent (fixed) + grub_font_get_leading (fixed); + + ypos += 40; /* Spacing. */ /* To convert Unicode characters into UTF-8 for this test, the following command is useful: @@ -112,76 +1149,252 @@ U+2287 subset symbol E2 8A 87 U+211D set 'R' symbol (real numbers) E2 84 9D */ - str = + s = "Unicode test: happy\xE2\x98\xBA \xC2\xA3 5.00" " \xC2\xA1\xCF\x84\xC3\xA4u! " " \xE2\x84\xA4\xE2\x8A\x87\xE2\x84\x9D"; color = grub_video_map_rgb (128, 128, 255); /* All characters in the string exist in the 'Fixed 20' (10x20) font. */ - texty += grub_font_get_ascent(fixed); - grub_font_draw_string (str, fixed, color, 16, texty); - texty += grub_font_get_descent (fixed) + grub_font_get_leading (fixed); - - /* Some character don't exist in the Helvetica font, so the font engine - will fall back to using glyphs from another font that does contain them. - TODO The font engine should be smart about selecting a replacement font - and prioritize fonts with similar sizes. */ - - texty += grub_font_get_ascent(sansbig); - grub_font_draw_string (str, sansbig, color, 16, texty); - texty += grub_font_get_descent (sansbig) + grub_font_get_leading (sansbig); - - texty += grub_font_get_ascent(sans); - grub_font_draw_string (str, sans, color, 16, texty); - texty += grub_font_get_descent (sans) + grub_font_get_leading (sans); - - texty += grub_font_get_ascent(sanssmall); - grub_font_draw_string (str, sanssmall, color, 16, texty); - texty += (grub_font_get_descent (sanssmall) + ypos += grub_font_get_ascent (fixed); + grub_font_draw_string (s, fixed, color, 16, ypos); + ypos += grub_font_get_descent (fixed) + grub_font_get_leading (fixed); + + /* Some characters don't exist in the Helvetica font, so the font engine + may fall back to using glyphs from another font that has them. */ + + ypos += grub_font_get_ascent (sansbig); + grub_font_draw_string (s, sansbig, color, 16, ypos); + ypos += grub_font_get_descent (sansbig) + grub_font_get_leading (sansbig); + + ypos += grub_font_get_ascent (sans); + grub_font_draw_string (s, sans, color, 16, ypos); + ypos += grub_font_get_descent (sans) + grub_font_get_leading (sans); + + ypos += grub_font_get_ascent (sanssmall); + grub_font_draw_string (s, sanssmall, color, 16, ypos); + ypos += (grub_font_get_descent (sanssmall) + grub_font_get_leading (sanssmall)); - glyph = grub_font_get_glyph (fixed, '*'); - - for (i = 0; i < 16; i++) - { - color = grub_video_map_color (i); - palette[i] = color; - grub_font_draw_glyph (glyph, color, 16 + i * 16, 220); - } + + grub_video_swap_buffers (); + grub_getkey (); + grub_video_restore (); + grub_errno = GRUB_ERR_NONE; +} + + +/* Test bitmap scaling. */ +static void +scale_test (struct videotest_options *vt_opts) +{ + if (grub_video_set_mode (preferred_mode_list, 0) != GRUB_ERR_NONE) + return; + grub_video_enable_double_buffering (vt_opts->double_buffering); + + grub_errno = GRUB_ERR_NONE; + grub_video_rect_t view; + grub_video_get_viewport ((unsigned *) &view.x, (unsigned *) &view.y, + (unsigned *) &view.width, + (unsigned *) &view.height); grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); - for (i = 0; i < 255; i++) - { - color = grub_video_map_rgb (i, 33, 77); - grub_video_fill_rect (color, 0, 0, width, height); - grub_video_blit_render_target (text_layer, GRUB_VIDEO_BLIT_BLEND, 0, 0, - 0, 0, width, height); - } - + grub_font_t font; + if (!(font = grub_font_get ("Helvetica Regular 10"))) + { + grub_video_restore (); + grub_error (GRUB_ERR_BAD_FONT, "No font loaded."); + return; + } + + grub_video_color_t color; + + int text_y = 0; + int text_height = 25; + + color = grub_video_map_rgb (44, 44, 200); + grub_video_fill_rect (color, view.x, view.y, view.width, view.height); + color = grub_video_map_rgb (255, 255, 255); + + grub_font_draw_string ("Loading image", + font, color, 10, text_y += text_height); + + enum grub_video_bitmap_scale_method scale_method = + GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST; + const char *bitmap_name = "/boot/grub/themes/winter/without-leaves.png"; + struct grub_video_bitmap *bitmap; + grub_video_bitmap_load (&bitmap, bitmap_name); + if (grub_errno != GRUB_ERR_NONE) + { + grub_font_draw_string ("Error loading bitmap", + font, color, 10, text_y += text_height); + } + else + { + grub_font_draw_string ("Original image", + font, color, 10, text_y += text_height); + grub_video_blit_bitmap (bitmap, GRUB_VIDEO_BLIT_BLEND, + 400, text_y - 10, + 0, 0, grub_video_bitmap_get_width (bitmap), + grub_video_bitmap_get_height (bitmap)); + + struct grub_video_bitmap *bitmap2; + if (grub_video_bitmap_create_scaled (&bitmap2, 40, 40, + bitmap, + scale_method) + != GRUB_ERR_NONE) + { + grub_font_draw_string ("Error scaling down bitmap", + font, color, 10, text_y += text_height); + } + else + { + grub_font_draw_string ("Scaled down version", + font, color, 10, text_y += text_height); + grub_video_blit_bitmap (bitmap2, GRUB_VIDEO_BLIT_BLEND, + 400, text_y + 100, + 0, 0, grub_video_bitmap_get_width (bitmap2), + grub_video_bitmap_get_height (bitmap2)); + grub_video_bitmap_destroy (bitmap2); + } + + struct grub_video_bitmap *bitmap3; + if (grub_video_bitmap_create_scaled (&bitmap3, 500, 300, bitmap, + scale_method) + != GRUB_ERR_NONE) + { + grub_font_draw_string ("Error scaling up bitmap", + font, color, 10, text_y += text_height); + } + else + { + grub_font_draw_string ("Scaled up version", + font, color, 10, text_y += text_height); + grub_video_blit_bitmap (bitmap3, GRUB_VIDEO_BLIT_BLEND, + 400, text_y + 50, + 0, 0, grub_video_bitmap_get_width (bitmap3), + grub_video_bitmap_get_height (bitmap3)); + grub_video_bitmap_destroy (bitmap3); + } + } + + grub_video_swap_buffers (); grub_getkey (); - - grub_video_delete_render_target (text_layer); - + grub_video_bitmap_destroy (bitmap); grub_video_restore (); - - for (i = 0; i < 16; i++) - grub_printf("color %d: %08x\n", i, palette[i]); - - grub_errno = GRUB_ERR_NONE; +} + + +/* Print a list of the available tests. */ +static void list_tests (void); + +/* + Video test command. Takes an argument specifying the test to run. + */ +static grub_err_t +grub_cmd_videotest (grub_extcmd_t cmd, int argc, char **args) +{ + struct grub_arg_list *state = cmd->state; + int i; + struct videotest_options vt_opts; + /* Pointer to the test function. */ + void (*test_func) (struct videotest_options *) = NULL; + + vt_opts.test_time = + state[ARGINDEX_TEST_TIME].set + ? grub_strtoul (state[ARGINDEX_TEST_TIME].arg, 0, 0) : 0; + vt_opts.double_buffering = state[ARGINDEX_DOUBLE_BUF].set; + + /* Parse command line arguments to determine the test to run. */ + for (i = 0; i < argc; i++) + { + char *arg = args[i]; + if (grub_strcmp (arg, "list") == 0) + { + list_tests (); + return GRUB_ERR_NONE; + } + else if (grub_strcmp (arg, "basic") == 0) + { + test_func = basic_video_test; + } + else if (grub_strcmp (arg, "bench") == 0) + { + test_func = benchmark_test; + } + else if (grub_strcmp (arg, "bitmaps") == 0) + { + test_func = bitmap_demo; + } + else if (grub_strcmp (arg, "clock") == 0) + { + test_func = clock_test; + } + else if (grub_strcmp (arg, "doublebuf") == 0) + { + test_func = doublebuf_test; + } + else if (grub_strcmp (arg, "text") == 0) + { + test_func = text_test; + } + else if (grub_strcmp (arg, "scale") == 0) + { + test_func = scale_test; + } + else + { + grub_printf ("Error: Unknown test `%s'\n", arg); + grub_errno = GRUB_ERR_BAD_ARGUMENT; + return grub_errno; + } + } + + if (test_func == NULL) + { + grub_printf ("Usage: videotest TESTNAME Run a test.\n"); + grub_printf (" videotest list List available tests.\n"); + grub_printf ("\n"); + list_tests (); + } + else + { + test_func (&vt_opts); + } + return grub_errno; } -static grub_command_t cmd; - -GRUB_MOD_INIT(videotest) -{ - cmd = grub_register_command ("videotest", grub_cmd_videotest, - 0, "Test video subsystem"); -} - -GRUB_MOD_FINI(videotest) -{ - grub_unregister_command (cmd); +static void +list_tests (void) +{ + grub_printf ("Available tests\n"); + grub_printf ("===============\n"); + grub_printf ("basic Basic video test with filled rectangles,\n"); + grub_printf (" offscreen rendering targets, some text.\n"); + grub_printf ("bench Run a performance benchmark.\n"); + grub_printf ("bitmaps Test generating and blitting bitmaps.\n"); + grub_printf ("clock Test time functions w/ animated progress bar.\n"); + grub_printf ("doublebuf Test double buffering.\n"); + grub_printf ("text Test text rendering.\n"); + grub_printf ("scale Test image scaling.\n"); + grub_printf ("\n"); +} + +static grub_extcmd_t cmd; + +GRUB_MOD_INIT (videotest) +{ + cmd = grub_register_extcmd ("videotest", + grub_cmd_videotest, + GRUB_COMMAND_FLAG_BOTH, + "videotest TEST", + "Run the specified video subsystem test.", + arg_options); +} + +GRUB_MOD_FINI (videotest) +{ + grub_unregister_extcmd (cmd); } === modified file 'conf/common.rmk' --- conf/common.rmk 2009-06-12 01:10:21 +0000 +++ conf/common.rmk 2009-06-13 13:42:27 +0000 @@ -354,7 +354,7 @@ terminfo.mod test.mod blocklist.mod hexdump.mod \ read.mod sleep.mod loadenv.mod crc.mod parttool.mod \ pcpart.mod memrw.mod normal.mod sh.mod lua.mod \ - gptsync.mod true.mod + gptsync.mod true.mod gfxmenu.mod # For gptsync.mod. gptsync_mod_SOURCES = commands/gptsync.c @@ -376,6 +376,27 @@ hello_mod_CFLAGS = $(COMMON_CFLAGS) hello_mod_LDFLAGS = $(COMMON_LDFLAGS) +# For gfxmenu.mod. +gfxmenu_mod_SOURCES = \ + gfxmenu/gfxmenu.c \ + gfxmenu/model.c \ + gfxmenu/view.c \ + gfxmenu/icon_manager.c \ + gfxmenu/theme_loader.c \ + gfxmenu/widget-box.c \ + gfxmenu/gui_canvas.c \ + gfxmenu/gui_circular_progress.c \ + gfxmenu/gui_box.c \ + gfxmenu/gui_label.c \ + gfxmenu/gui_list.c \ + gfxmenu/gui_image.c \ + gfxmenu/gui_progress_bar.c \ + gfxmenu/gui_util.c \ + gfxmenu/gui_string_util.c \ + gfxmenu/named_colors.c +gfxmenu_mod_CFLAGS = $(COMMON_CFLAGS) +gfxmenu_mod_LDFLAGS = $(COMMON_LDFLAGS) + # For parttool.mod. parttool_mod_SOURCES = commands/parttool.c parttool_mod_CFLAGS = $(COMMON_CFLAGS) @@ -534,7 +555,7 @@ videotest_mod_LDFLAGS = $(COMMON_LDFLAGS) # For bitmap.mod -bitmap_mod_SOURCES = video/bitmap.c +bitmap_mod_SOURCES = video/bitmap.c video/bitmap_scale.c bitmap_mod_CFLAGS = $(COMMON_CFLAGS) bitmap_mod_LDFLAGS = $(COMMON_LDFLAGS) @@ -564,7 +585,7 @@ gfxterm_mod_LDFLAGS = $(COMMON_LDFLAGS) # Misc. -pkglib_MODULES += gzio.mod bufio.mod elf.mod +pkglib_MODULES += gzio.mod bufio.mod elf.mod trig.mod # For elf.mod. elf_mod_SOURCES = kern/elf.c @@ -580,3 +601,8 @@ bufio_mod_SOURCES = io/bufio.c bufio_mod_CFLAGS = $(COMMON_CFLAGS) bufio_mod_LDFLAGS = $(COMMON_LDFLAGS) + +# For trig.mod. +trig_mod_SOURCES = lib/trig.c +trig_mod_CFLAGS = $(COMMON_CFLAGS) +trig_mod_LDFLAGS = $(COMMON_LDFLAGS) === added file 'docs/gfxmenu-theme-example.txt' --- docs/gfxmenu-theme-example.txt 1970-01-01 00:00:00 +0000 +++ docs/gfxmenu-theme-example.txt 2009-01-19 17:29:32 +0000 @@ -0,0 +1,128 @@ +# GRUB gfxmenu theme "winter". +# Uses background image from: +# http://www.cyberpunkcafe.com/e107_plugins/autogallery/autogallery.php?show=1.Open%20Source%20Wallpaper +# "without-leaves.png" was called "Without Leafs in Winter.png" + +lua-script: "winter.lua" +title-text: "" +title-font: "Helvetica Bold 18" +status-font: "Helvetica 8" +terminal-font: "Fixed 9" +title-color: "40, 40, 40" +status-color: "#FFF" +status-bg-color: "0, 166, 183, 128" +desktop-image: "without-leaves.png" +desktop-color: "0, 154, 183" +terminal-box: "terminal_*.png" + ++ boot_menu { + position = (120, 60) + preferred_size = (400, -1) + item_font = "Helvetica Bold 14" + selected_item_font = "Helvetica Bold 14" + item_color = "0, 0, 0" + selected_item_color = "203, 251, 255" + menu_pixmap_style = "menu_*.png" + selected_item_pixmap_style = "select_*.png" + icon_width = 44 + icon_height = 44 + item_height = 32 + item_padding = 0 + item_icon_space = 3 + item_spacing = 11 +} + +# You can add text at arbitrary locations on the screen. +# The specification within the "+label {...}" block is free-form, +# so you can use as much or as little white space as you like. + ++ label { + position = (170, 50) + font = "smoothansi 13" + color = "0,0,128" + text = "This is the Winter theme ... brought to you by GRUB!" +} + +# Show the text alignment supported by labels. ++ vbox { + position = (220, 347) + preferred_size = (200, -1) # A preferred size of -1 means automatic. + + label { text="Text alignment demo" align="center" font="aqui 11" } + + label { text="Left" align="left" font="cure 11" } + + label { text="Center" align="center" font="cure 11" } + + label { text="Right" align="right" font="cure 11" } +} + ++ vbox { + position = (580, 10) + + label { text="GNU" font="gelly 11" color="0, 0, 0" } + + label { text="GRUB" font="aqui 11" color="0, 0, 0" } + + label { text="boot loader" font="cure 11" color="0, 0, 0" } +} + ++ hbox { + position = (80, 10) + + label { text="GNU" font="gelly 11" color="0, 0, 0" } + + label { text="GRUB" font="aqui 11" color="0, 0, 0" } + + label { text="boot loader" font="cure 11" color="0, 0, 0" } +} + +# Demonstration of a compound layout: boxes within boxes. ++ hbox +{ + position = (480, 3) + + + vbox + { + # Note: We can't just use 'size' to set the image's size, + # since the vbox will resize the component according to its + # preferred size, which for images is the native image size. + + + image { file="/boot/grub/themes/icons/ubuntu.png" + preferred_size = (20, 20) } + + image { file="/boot/grub/themes/icons/gentoo.png" + preferred_size = (20, 20) } + } + + + vbox + { + + label { text="GRand" font="cure 11" color=#99F } + + label { text="Unified" font="cure 11" color=#BBF } + + label { text="Bootloader" font="cure 11" color=#DDF } + } +} + +# By defining a 'progress_bar' type component with an ID of '__timeout__', +# the progress bar will be used to display the time remaining before an +# the default entry is automatically booted. ++ progress_bar +{ + id = "__timeout__" + position = (80, 393) + preferred_size = (500, 24) + font = "cure 11" + text_color = #000 + fg_color = #CCF + bg_color = #66B + border_color = #006 + show_text = false +} + +# Although the progress_bar component is normally used to indicate the +# time remaining, it's also possible to create other components with an ID +# of '__timeout__'. All components with and ID of 'timeout_bar' will have +# the following properties set based on the timeout value: +# text, value, start, end, visible. +# In this case, we have set 'show_text=false' on the progress bar, and use +# the following label's 'text' property to display the message. ++ label +{ + id = "__timeout__" + position = (80, 420) + preferred_size = (500, 24) + font = "lime 11" + color = #117 + align = "center" +} + + === added file 'gentrigtables.py' --- gentrigtables.py 1970-01-01 00:00:00 +0000 +++ gentrigtables.py 2009-01-31 17:06:21 +0000 @@ -0,0 +1,58 @@ +#!/usr/bin/python +# Script to generate trigonometric function tables. +# +# GRUB -- GRand Unified Bootloader +# Copyright (C) 2008 Free Software Foundation, Inc. +# +# GRUB is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# GRUB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GRUB. If not, see . + +from math import * +from sys import stdout + +def write(x): + stdout.write(x) + +def writeTable(arr, name): + indent = ' ' * 4 + write("short ") + write(name) + write("[] =\n{\n") + write(indent) + for i in range(len(arr)): + if i != 0: + write(",") + if i % 10 == 0: + write("\n") + write(indent) + write("%d" % arr[i]) + write("\n};\n") + +def main(): + sintab = [] + costab = [] + for i in range(256): + # Convert to an angle in 1/256 of a circle. + x = i * 2 * pi / 256 + sintab.append(int(round(sin(x) * 16384))) + costab.append(int(round(cos(x) * 16384))) + + write("#define TRIG_ANGLE_MAX 256\n") + write("#define TRIG_FRACTION_SCALE 16384\n") + writeTable(sintab, "sintab") + writeTable(costab, "costab") + +if __name__ == "__main__": + main() + +# vim:ai et sw=4 ts=4 === added directory 'gfxmenu' === added file 'gfxmenu/gfxmenu.c' --- gfxmenu/gfxmenu.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/gfxmenu.c 2009-06-09 21:49:06 +0000 @@ -0,0 +1,235 @@ +/* gfxmenu.c - Graphical menu interface controller. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void switch_to_text_menu (void) +{ + grub_env_set ("menuviewer", "text"); +} + +static void +process_key_press (int c, + grub_gfxmenu_model_t model, + grub_gfxmenu_view_t view, + int nested, + int *should_exit) +{ + /* When a key is pressed, stop the timeout. */ + grub_gfxmenu_model_clear_timeout (model); + + if (c == 'j' || c == GRUB_TERM_DOWN) + { + int i = grub_gfxmenu_model_get_selected_index (model); + int num_items = grub_gfxmenu_model_get_num_entries (model); + if (i < num_items - 1) + { + i++; + grub_gfxmenu_model_set_selected_index (model, i); + } + } + else if (c == 'k' || c == GRUB_TERM_UP) + { + int i = grub_gfxmenu_model_get_selected_index (model); + if (i > 0) + { + i--; + grub_gfxmenu_model_set_selected_index (model, i); + } + } + else if (c == '\r' || c == '\n' || c == GRUB_TERM_RIGHT) + { + int selected = grub_gfxmenu_model_get_selected_index (model); + int num_entries = grub_gfxmenu_model_get_num_entries (model); + if (selected >= 0 && selected < num_entries) + { + grub_menu_entry_t entry = + grub_gfxmenu_model_get_entry (model, selected); + grub_gfxmenu_view_execute_entry (view, entry); + } + } + else if (c == 'c') + { + grub_gfxmenu_view_run_terminal (view); + } + else if (c == 't') + { + /* The write hook for 'menuviewer' will cause + * grub_menu_viewer_should_return to return nonzero. */ + switch_to_text_menu (); + *should_exit = 1; + } + else if (c == '1') + { + grub_gfxmenu_view_load_theme (view, + "/boot/grub/themes/proto/theme.txt"); + } + else if (c == '2') + { + grub_gfxmenu_view_load_theme (view, + "/boot/grub/themes/winter/theme.txt"); + } + else if (c == '3') + { + grub_gfxmenu_view_load_theme (view, + "/boot/grub/themes/ubuntu1/theme.txt"); + } + else if (c == '4') + { + grub_gfxmenu_view_load_theme (view, + "/boot/grub/themes/ubuntu2/theme.txt"); + } + else if (nested && c == GRUB_TERM_ESC) + { + *should_exit = 1; + } + + if (grub_errno != GRUB_ERR_NONE) + *should_exit = 1; +} + +static void +handle_key_events (grub_gfxmenu_model_t model, + grub_gfxmenu_view_t view, + int nested, + int *should_exit) +{ + while ((! *should_exit) && (grub_checkkey () != -1)) + { + int key = grub_getkey (); + int c = GRUB_TERM_ASCII_CHAR (key); + process_key_press (c, model, view, nested, should_exit); + } +} + +static grub_err_t +show_menu (grub_menu_t menu, int nested) +{ + grub_gfxmenu_model_t model; + + model = grub_gfxmenu_model_new (menu); + if (! model) + { + grub_print_error (); + grub_printf ("Initializing menu data for graphical menu failed;\n" + "falling back to text based menu.\n"); + grub_wait_after_message (); + switch_to_text_menu (); + return grub_errno; + } + + grub_gfxmenu_view_t view; + + /* Create the view. */ + const char *theme_path = grub_env_get ("theme"); + if (! theme_path) + theme_path = "/boot/grub/themes/proto/theme.txt"; + + view = grub_gfxmenu_view_new (theme_path, model); + if (! view) + { + grub_print_error (); + grub_printf ("Starting graphical menu failed;\n" + "falling back to text based menu.\n"); + grub_wait_after_message (); + grub_gfxmenu_model_destroy (model); + switch_to_text_menu (); + return grub_errno; + } + + /* Initially select the default menu entry. */ + int default_index = grub_menu_get_default_entry_index (menu); + grub_gfxmenu_model_set_selected_index (model, default_index); + + /* Start the timer to execute the default entry. */ + grub_gfxmenu_model_set_timeout (model); + + /* Main event loop. */ + int exit_requested = 0; + while ((! exit_requested) && (! grub_menu_viewer_should_return ())) + { + if (grub_gfxmenu_model_timeout_expired (model)) + { + grub_gfxmenu_model_clear_timeout (model); + int i = grub_gfxmenu_model_get_selected_index (model); + grub_menu_entry_t e = grub_gfxmenu_model_get_entry (model, i); + grub_gfxmenu_view_execute_with_fallback (view, e); + continue; + } + + grub_gfxmenu_view_draw (view); + grub_video_swap_buffers (); + handle_key_events (model, view, nested, &exit_requested); + } + + grub_gfxmenu_view_destroy (view); + grub_gfxmenu_model_destroy (model); + + return grub_errno; +} + +static grub_err_t +grub_cmd_gfxmenu (grub_command_t cmd UNUSED, + int argc UNUSED, char **args UNUSED) +{ + grub_menu_t menu = grub_env_get_data_slot ("menu"); + if (! menu) + return grub_error (GRUB_ERR_MENU, "no menu context"); + + return show_menu (menu, 1); +} + +static struct grub_menu_viewer menu_viewer = +{ + .name = "gfxmenu", + .show_menu = show_menu +}; + +static grub_command_t cmd; + +GRUB_MOD_INIT (gfxmenu) +{ + (void) mod; /* To stop warning. */ + grub_menu_viewer_register (&menu_viewer); + cmd = grub_register_command ("gfxmenu", grub_cmd_gfxmenu, + "gfxmenu", + "Show graphical menu interface"); +} + +GRUB_MOD_FINI (gfxmenu) +{ + grub_unregister_command (cmd); +} === added file 'gfxmenu/gui_box.c' --- gfxmenu/gui_box.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/gui_box.c 2009-06-09 21:49:06 +0000 @@ -0,0 +1,372 @@ +/* gui_box.c - GUI container that stack components. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include + +struct component_node +{ + grub_gui_component_t component; + struct component_node *next; + struct component_node *prev; +}; + +typedef struct grub_gui_box *grub_gui_box_t; + +typedef void (*layout_func_t) (grub_gui_box_t self, int modify_layout, + int *width, int *height); + +struct grub_gui_box +{ + struct grub_gui_container_ops *container; + + grub_gui_container_t parent; + grub_video_rect_t bounds; + char *id; + int preferred_width; + int preferred_height; + + /* Doubly linked list of components with dummy head & tail nodes. */ + struct component_node chead; + struct component_node ctail; + + /* The layout function: differs for vertical and horizontal boxes. */ + layout_func_t layout_func; +}; + +static void +box_destroy (void *vself) +{ + grub_gui_box_t self = vself; + struct component_node *cur; + struct component_node *next; + for (cur = self->chead.next; cur != &self->ctail; cur = next) + { + /* Copy the 'next' pointer, since we need it for the next iteration, + and we're going to free the memory it is stored in. */ + next = cur->next; + /* Destroy the child component. */ + cur->component->ops->destroy (cur->component); + /* Free the linked list node. */ + grub_free (cur); + } + grub_free (self); +} + +static const char * +box_get_id (void *vself) +{ + grub_gui_box_t self = vself; + return self->id; +} + +static int +box_is_instance (void *vself __attribute__((unused)), const char *type) +{ + return (grub_strcmp (type, "component") == 0 + || grub_strcmp (type, "container") == 0); +} + +static void +layout_horizontally (grub_gui_box_t self, int modify_layout, + int *width, int *height) +{ + /* Start at the left (chead) and set the x coordinates as we go right. */ + /* All components have their width set to the box's width. */ + + struct component_node *cur; + int x = 0; + if (height) + *height = 0; + for (cur = self->chead.next; cur != &self->ctail; cur = cur->next) + { + grub_gui_component_t c = cur->component; + grub_video_rect_t r; + + c->ops->get_preferred_size (c, &r.width, &r.height); + + /* Check and possibly update the maximum width, if non-null. */ + if (height && r.height > *height) + *height = r.height; + + /* Set the component's bounds, if the flag is set. */ + if (modify_layout) + { + r.x = x; + r.y = 0; + /* Width comes from the component's preferred size. */ + r.height = self->bounds.height; + c->ops->set_bounds (c, &r); + } + + x += r.width; + } + + /* Return the sum of the children's preferred widths. */ + if (width) + *width = x; +} + +static void +layout_vertically (grub_gui_box_t self, int modify_layout, + int *width, int *height) +{ + /* Start at the top (chead) and set the y coordinates as we go down. */ + /* All components have their width set to the vbox's width. */ + + struct component_node *cur; + int y = 0; + if (width) + *width = 0; + for (cur = self->chead.next; cur != &self->ctail; cur = cur->next) + { + grub_gui_component_t c = cur->component; + grub_video_rect_t r; + + c->ops->get_preferred_size (c, &r.width, &r.height); + + /* Check and possibly update the maximum width, if non-null. */ + if (width && r.width > *width) + *width = r.width; + + /* Set the component's bounds, if the flag is set. */ + if (modify_layout) + { + r.x = 0; + r.y = y; + r.width = self->bounds.width; + /* Height comes from the component's preferred size. */ + c->ops->set_bounds (c, &r); + } + + y += r.height; + } + + /* Return the sum of the children's preferred heights. */ + if (height) + *height = y; +} + +static void +box_paint (void *vself) +{ + grub_gui_box_t self = vself; + struct component_node *cur; + grub_video_rect_t vpsave; + + grub_gui_set_viewport (&self->bounds, &vpsave); + for (cur = self->chead.next; cur != &self->ctail; cur = cur->next) + { + grub_gui_component_t comp = cur->component; + comp->ops->paint (comp); + } + grub_gui_restore_viewport (&vpsave); +} + +static void +box_set_parent (void *vself, grub_gui_container_t parent) +{ + grub_gui_box_t self = vself; + self->parent = parent; +} + +static grub_gui_container_t +box_get_parent (void *vself) +{ + grub_gui_box_t self = vself; + return self->parent; +} + +static void +box_set_bounds (void *vself, const grub_video_rect_t *bounds) +{ + grub_gui_box_t self = vself; + self->bounds = *bounds; + self->layout_func (self, 1, 0, 0); /* Relayout the children. */ +} + +static void +box_get_bounds (void *vself, grub_video_rect_t *bounds) +{ + grub_gui_box_t self = vself; + *bounds = self->bounds; +} + +/* The box's preferred size is based on the preferred sizes + of its children. */ +static void +box_get_preferred_size (void *vself, int *width, int *height) +{ + grub_gui_box_t self = vself; + self->layout_func (self, 0, width, height); /* Just calculate the size. */ + + /* Allow preferred dimensions to override the computed dimensions. */ + if (self->preferred_width >= 0) + *width = self->preferred_width; + if (self->preferred_height >= 0) + *height = self->preferred_height; +} + +static grub_err_t +box_set_property (void *vself, const char *name, const char *value) +{ + grub_gui_box_t self = vself; + if (grub_strcmp (name, "id") == 0) + { + grub_free (self->id); + if (value) + { + self->id = grub_strdup (value); + if (! self->id) + return grub_errno; + } + else + self->id = 0; + } + else if (grub_strcmp (name, "preferred_size") == 0) + { + int w; + int h; + if (grub_gui_parse_2_tuple (value, &w, &h) != GRUB_ERR_NONE) + return grub_errno; + self->preferred_width = w; + self->preferred_height = h; + } + + return grub_errno; +} + +static void +box_add (void *vself, grub_gui_component_t comp) +{ + grub_gui_box_t self = vself; + struct component_node *node; + node = grub_malloc (sizeof (*node)); + if (! node) + return; /* Note: probably should handle the error. */ + node->component = comp; + /* Insert the node before the tail. */ + node->prev = self->ctail.prev; + node->prev->next = node; + node->next = &self->ctail; + node->next->prev = node; + + comp->ops->set_parent (comp, (grub_gui_container_t) self); + self->layout_func (self, 1, 0, 0); /* Relayout the children. */ +} + +static void +box_remove (void *vself, grub_gui_component_t comp) +{ + grub_gui_box_t self = vself; + struct component_node *cur; + for (cur = self->chead.next; cur != &self->ctail; cur = cur->next) + { + if (cur->component == comp) + { + /* Unlink 'cur' from the list. */ + cur->prev->next = cur->next; + cur->next->prev = cur->prev; + /* Free the node's memory (but don't destroy the component). */ + grub_free (cur); + /* Must not loop again, since 'cur' would be dereferenced! */ + return; + } + } +} + +static void +box_iterate_children (void *vself, + grub_gui_component_callback cb, void *userdata) +{ + grub_gui_box_t self = vself; + struct component_node *cur; + for (cur = self->chead.next; cur != &self->ctail; cur = cur->next) + cb (cur->component, userdata); +} + +static struct grub_gui_container_ops box_ops = +{ + .component = + { + .destroy = box_destroy, + .get_id = box_get_id, + .is_instance = box_is_instance, + .paint = box_paint, + .set_parent = box_set_parent, + .get_parent = box_get_parent, + .set_bounds = box_set_bounds, + .get_bounds = box_get_bounds, + .get_preferred_size = box_get_preferred_size, + .set_property = box_set_property + }, + .add = box_add, + .remove = box_remove, + .iterate_children = box_iterate_children +}; + +/* Box constructor. Specify the appropriate layout function to create + a horizontal or vertical stacking box. */ +static grub_gui_box_t +box_new (layout_func_t layout_func) +{ + grub_gui_box_t box; + box = grub_malloc (sizeof (*box)); + if (! box) + return 0; + box->container = &box_ops; + box->parent = 0; + box->bounds.x = 0; + box->bounds.y = 0; + box->bounds.width = 0; + box->bounds.height = 0; + box->id = 0; + box->preferred_width = -1; + box->preferred_height = -1; + box->chead.component = 0; + box->chead.prev = 0; + box->chead.next = &box->ctail; + box->ctail.component = 0; + box->ctail.prev = &box->chead; + box->ctail.next = 0; + box->layout_func = layout_func; + return box; +} + +/* Create a new container that stacks its child components horizontally, + from left to right. Each child get a width corresponding to its + preferred width. The height of each child is set the maximum of the + preferred heights of all children. */ +grub_gui_container_t +grub_gui_hbox_new (void) +{ + return (grub_gui_container_t) box_new (layout_horizontally); +} + +/* Create a new container that stacks its child components verticallyj, + from top to bottom. Each child get a height corresponding to its + preferred height. The width of each child is set the maximum of the + preferred widths of all children. */ +grub_gui_container_t +grub_gui_vbox_new (void) +{ + return (grub_gui_container_t) box_new (layout_vertically); +} === added file 'gfxmenu/gui_canvas.c' --- gfxmenu/gui_canvas.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/gui_canvas.c 2009-06-09 21:49:06 +0000 @@ -0,0 +1,268 @@ +/* gui_canvas.c - GUI container allowing manually placed components. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include + +/* TODO Add layering so that components can be properly overlaid. */ + +struct component_node +{ + grub_gui_component_t component; + struct component_node *next; +}; + +struct grub_gui_canvas +{ + struct grub_gui_container_ops *container; + + grub_gui_container_t parent; + grub_video_rect_t bounds; + char *id; + int preferred_width; + int preferred_height; + /* Component list (dummy head node). */ + struct component_node components; +}; + +typedef struct grub_gui_canvas *grub_gui_canvas_t; + +static void +canvas_destroy (void *vself) +{ + grub_gui_canvas_t self = vself; + struct component_node *cur; + struct component_node *next; + for (cur = self->components.next; cur; cur = next) + { + /* Copy the 'next' pointer, since we need it for the next iteration, + and we're going to free the memory it is stored in. */ + next = cur->next; + /* Destroy the child component. */ + cur->component->ops->destroy (cur->component); + /* Free the linked list node. */ + grub_free (cur); + } + grub_free (self); +} + +static const char * +canvas_get_id (void *vself) +{ + grub_gui_canvas_t self = vself; + return self->id; +} + +static int +canvas_is_instance (void *vself __attribute__((unused)), const char *type) +{ + return (grub_strcmp (type, "component") == 0 + || grub_strcmp (type, "container") == 0); +} + +static void +canvas_paint (void *vself) +{ + grub_gui_canvas_t self = vself; + struct component_node *cur; + grub_video_rect_t vpsave; + + grub_gui_set_viewport (&self->bounds, &vpsave); + for (cur = self->components.next; cur; cur = cur->next) + { + int pw; + int ph; + grub_video_rect_t r; + grub_gui_component_t comp; + + comp = cur->component; + + /* Give the child its preferred size. */ + comp->ops->get_preferred_size (comp, &pw, &ph); + comp->ops->get_bounds (comp, &r); + if (r.width != pw || r.height != ph) + { + r.width = pw; + r.height = ph; + comp->ops->set_bounds (comp, &r); + } + + /* Paint the child. */ + comp->ops->paint (comp); + } + grub_gui_restore_viewport (&vpsave); +} + +static void +canvas_set_parent (void *vself, grub_gui_container_t parent) +{ + grub_gui_canvas_t self = vself; + self->parent = parent; +} + +static grub_gui_container_t +canvas_get_parent (void *vself) +{ + grub_gui_canvas_t self = vself; + return self->parent; +} + +static void +canvas_set_bounds (void *vself, const grub_video_rect_t *bounds) +{ + grub_gui_canvas_t self = vself; + self->bounds = *bounds; +} + +static void +canvas_get_bounds (void *vself, grub_video_rect_t *bounds) +{ + grub_gui_canvas_t self = vself; + *bounds = self->bounds; +} + +static void +canvas_get_preferred_size (void *vself, int *width, int *height) +{ + grub_gui_canvas_t self = vself; + *width = 0; + *height = 0; + + /* Allow preferred dimensions to override the empty dimensions. */ + if (self->preferred_width >= 0) + *width = self->preferred_width; + if (self->preferred_height >= 0) + *height = self->preferred_height; +} + +static grub_err_t +canvas_set_property (void *vself, const char *name, const char *value) +{ + grub_gui_canvas_t self = vself; + if (grub_strcmp (name, "id") == 0) + { + grub_free (self->id); + if (value) + { + self->id = grub_strdup (value); + if (! self->id) + return grub_errno; + } + else + self->id = 0; + } + else if (grub_strcmp (name, "preferred_size") == 0) + { + int w; + int h; + if (grub_gui_parse_2_tuple (value, &w, &h) != GRUB_ERR_NONE) + return grub_errno; + self->preferred_width = w; + self->preferred_height = h; + } + return grub_errno; +} + +static void +canvas_add (void *vself, grub_gui_component_t comp) +{ + grub_gui_canvas_t self = vself; + struct component_node *node; + node = grub_malloc (sizeof (*node)); + if (! node) + return; /* Note: probably should handle the error. */ + node->component = comp; + node->next = self->components.next; + self->components.next = node; + comp->ops->set_parent (comp, (grub_gui_container_t) self); +} + +static void +canvas_remove (void *vself, grub_gui_component_t comp) +{ + grub_gui_canvas_t self = vself; + struct component_node *cur; + struct component_node *prev; + prev = &self->components; + for (cur = self->components.next; cur; prev = cur, cur = cur->next) + { + if (cur->component == comp) + { + /* Unlink 'cur' from the list. */ + prev->next = cur->next; + /* Free the node's memory (but don't destroy the component). */ + grub_free (cur); + /* Must not loop again, since 'cur' would be dereferenced! */ + return; + } + } +} + +static void +canvas_iterate_children (void *vself, + grub_gui_component_callback cb, void *userdata) +{ + grub_gui_canvas_t self = vself; + struct component_node *cur; + for (cur = self->components.next; cur; cur = cur->next) + cb (cur->component, userdata); +} + +static struct grub_gui_container_ops canvas_ops = +{ + .component = + { + .destroy = canvas_destroy, + .get_id = canvas_get_id, + .is_instance = canvas_is_instance, + .paint = canvas_paint, + .set_parent = canvas_set_parent, + .get_parent = canvas_get_parent, + .set_bounds = canvas_set_bounds, + .get_bounds = canvas_get_bounds, + .get_preferred_size = canvas_get_preferred_size, + .set_property = canvas_set_property + }, + .add = canvas_add, + .remove = canvas_remove, + .iterate_children = canvas_iterate_children +}; + +grub_gui_container_t +grub_gui_canvas_new (void) +{ + grub_gui_canvas_t canvas; + canvas = grub_malloc (sizeof (*canvas)); + if (! canvas) + return 0; + canvas->container = &canvas_ops; + canvas->parent = 0; + canvas->bounds.x = 0; + canvas->bounds.y = 0; + canvas->bounds.width = 0; + canvas->bounds.height = 0; + canvas->id = 0; + canvas->preferred_width = -1; + canvas->preferred_height = -1; + canvas->components.component = 0; + canvas->components.next = 0; + return (grub_gui_container_t) canvas; +} === added file 'gfxmenu/gui_circular_progress.c' --- gfxmenu/gui_circular_progress.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/gui_circular_progress.c 2009-06-09 21:49:06 +0000 @@ -0,0 +1,339 @@ +/* gui_circular_process.c - GUI circular progress indicator component. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +struct grub_gui_circular_progress +{ + struct grub_gui_component_ops *circprog_ops; + + grub_gui_container_t parent; + grub_video_rect_t bounds; + char *id; + int preferred_width; + int preferred_height; + int visible; + int start; + int end; + int value; + int num_ticks; + int start_angle; + int ticks_disappear; + char *theme_dir; + int need_to_load_pixmaps; + char *center_file; + char *tick_file; + struct grub_video_bitmap *center_bitmap; + struct grub_video_bitmap *tick_bitmap; +}; + +typedef struct grub_gui_circular_progress *circular_progress_t; + +static void +circprog_destroy (void *vself) +{ + circular_progress_t self = vself; + grub_free (self); +} + +static const char * +circprog_get_id (void *vself) +{ + circular_progress_t self = vself; + return self->id; +} + +static int +circprog_is_instance (void *vself __attribute__((unused)), const char *type) +{ + return grub_strcmp (type, "component") == 0; +} + +static struct grub_video_bitmap * +load_bitmap (const char *dir, const char *file) +{ + struct grub_video_bitmap *bitmap; + char *abspath; + + /* Check arguments. */ + if (! dir || ! file) + return 0; + + /* Resolve to an absolute path. */ + abspath = grub_resolve_relative_path (dir, file); + if (! abspath) + return 0; + + /* Load the image. */ + grub_errno = GRUB_ERR_NONE; + grub_video_bitmap_load (&bitmap, abspath); + grub_errno = GRUB_ERR_NONE; + + grub_free (abspath); + return bitmap; +} + +static int +check_pixmaps (circular_progress_t self) +{ + if (self->need_to_load_pixmaps) + { + if (self->center_bitmap) + grub_video_bitmap_destroy (self->center_bitmap); + self->center_bitmap = load_bitmap (self->theme_dir, self->center_file); + self->tick_bitmap = load_bitmap (self->theme_dir, self->tick_file); + self->need_to_load_pixmaps = 0; + } + + return (self->center_bitmap != 0 && self->tick_bitmap != 0); +} + +static void +circprog_paint (void *vself) +{ + circular_progress_t self = vself; + + if (! self->visible) + return; + if (! check_pixmaps (self)) + return; + + grub_video_rect_t vpsave; + grub_gui_set_viewport (&self->bounds, &vpsave); + + int width = self->bounds.width; + int height = self->bounds.height; + int center_width = grub_video_bitmap_get_width (self->center_bitmap); + int center_height = grub_video_bitmap_get_height (self->center_bitmap); + int tick_width = grub_video_bitmap_get_width (self->tick_bitmap); + int tick_height = grub_video_bitmap_get_height (self->tick_bitmap); + grub_video_blit_bitmap (self->center_bitmap, GRUB_VIDEO_BLIT_BLEND, + (width - center_width) / 2, + (height - center_height) / 2, 0, 0, + center_width, center_height); + + int radius = width / 2 - tick_width / 2 - 1; + int nticks = (self->num_ticks + * (self->value - self->start) + / (self->end - self->start)); + int tick_begin; + int tick_end; + /* Do ticks appear or disappear as the value approached the end? */ + if (self->ticks_disappear) + { + tick_begin = nticks; + tick_end = self->num_ticks - 1; + } + else + { + tick_begin = 0; + tick_end = nticks - 1; + } + + int i; + for (i = tick_begin; i < tick_end; i++) + { + int x; + int y; + int angle; + + /* Calculate the location of the tick. */ + angle = self->start_angle + i * GRUB_TRIG_ANGLE_MAX / self->num_ticks; + x = width / 2 + (grub_cos (angle) * radius / GRUB_TRIG_FRACTION_SCALE); + y = height / 2 + (grub_sin (angle) * radius / GRUB_TRIG_FRACTION_SCALE); + + /* Adjust (x,y) so the tick is centered. */ + x -= tick_width / 2; + y -= tick_height / 2; + + /* Draw the tick. */ + grub_video_blit_bitmap (self->tick_bitmap, GRUB_VIDEO_BLIT_BLEND, + x, y, 0, 0, tick_width, tick_height); + } + + grub_gui_restore_viewport (&vpsave); +} + +static void +circprog_set_parent (void *vself, grub_gui_container_t parent) +{ + circular_progress_t self = vself; + self->parent = parent; +} + +static grub_gui_container_t +circprog_get_parent (void *vself) +{ + circular_progress_t self = vself; + return self->parent; +} + +static void +circprog_set_bounds (void *vself, const grub_video_rect_t *bounds) +{ + circular_progress_t self = vself; + self->bounds = *bounds; +} + +static void +circprog_get_bounds (void *vself, grub_video_rect_t *bounds) +{ + circular_progress_t self = vself; + *bounds = self->bounds; +} + +static void +circprog_get_preferred_size (void *vself, int *width, int *height) +{ + circular_progress_t self = vself; + + *width = 0; + *height = 0; + + /* Allow preferred dimensions to override the circprog dimensions. */ + if (self->preferred_width >= 0) + *width = self->preferred_width; + if (self->preferred_height >= 0) + *height = self->preferred_height; +} + +static grub_err_t +circprog_set_property (void *vself, const char *name, const char *value) +{ + circular_progress_t self = vself; + if (grub_strcmp (name, "value") == 0) + { + self->value = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "start") == 0) + { + self->start = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "end") == 0) + { + self->end = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "num_ticks") == 0) + { + self->num_ticks = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "start_angle") == 0) + { + self->start_angle = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "ticks_disappear") == 0) + { + self->ticks_disappear = grub_strcmp (value, "false") != 0; + } + else if (grub_strcmp (name, "center_bitmap") == 0) + { + self->need_to_load_pixmaps = 1; + grub_free (self->center_file); + self->center_file = value ? grub_strdup (value) : 0; + } + else if (grub_strcmp (name, "tick_bitmap") == 0) + { + self->need_to_load_pixmaps = 1; + grub_free (self->tick_file); + self->tick_file = value ? grub_strdup (value) : 0; + } + else if (grub_strcmp (name, "theme_dir") == 0) + { + self->need_to_load_pixmaps = 1; + grub_free (self->theme_dir); + self->theme_dir = value ? grub_strdup (value) : 0; + } + else if (grub_strcmp (name, "preferred_size") == 0) + { + int w; + int h; + if (grub_gui_parse_2_tuple (value, &w, &h) != GRUB_ERR_NONE) + return grub_errno; + self->preferred_width = w; + self->preferred_height = h; + } + else if (grub_strcmp (name, "visible") == 0) + { + self->visible = grub_strcmp (value, "false") != 0; + } + else if (grub_strcmp (name, "id") == 0) + { + grub_free (self->id); + if (value) + self->id = grub_strdup (value); + else + self->id = 0; + } + return grub_errno; +} + +static struct grub_gui_component_ops circprog_ops = +{ + .destroy = circprog_destroy, + .get_id = circprog_get_id, + .is_instance = circprog_is_instance, + .paint = circprog_paint, + .set_parent = circprog_set_parent, + .get_parent = circprog_get_parent, + .set_bounds = circprog_set_bounds, + .get_bounds = circprog_get_bounds, + .get_preferred_size = circprog_get_preferred_size, + .set_property = circprog_set_property +}; + +grub_gui_component_t +grub_gui_circular_progress_new (void) +{ + circular_progress_t self; + self = grub_malloc (sizeof (*self)); + if (! self) + return 0; + self->circprog_ops = &circprog_ops; + self->parent = 0; + self->bounds.x = 0; + self->bounds.y = 0; + self->bounds.width = 0; + self->bounds.height = 0; + self->id = 0; + self->preferred_width = -1; + self->preferred_height = -1; + self->visible = 1; + self->start = 0; + self->end = 0; + self->value = 0; + self->num_ticks = 64; + self->start_angle = -64; + self->ticks_disappear = 0; + + self->theme_dir = 0; + self->need_to_load_pixmaps = 0; + self->center_file = 0; + self->tick_file = 0; + self->center_bitmap = 0; + self->tick_bitmap = 0; + + return (grub_gui_component_t) self; +} === added file 'gfxmenu/gui_image.c' --- gfxmenu/gui_image.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/gui_image.c 2009-06-09 21:49:06 +0000 @@ -0,0 +1,270 @@ +/* gui_image.c - GUI component to display an image. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include +#include + +struct grub_gui_image +{ + struct grub_gui_component_ops *image; + + grub_gui_container_t parent; + grub_video_rect_t bounds; + char *id; + int preferred_width; + int preferred_height; + struct grub_video_bitmap *raw_bitmap; + struct grub_video_bitmap *bitmap; +}; + +typedef struct grub_gui_image *grub_gui_image_t; + +static void +image_destroy (void *vself) +{ + grub_gui_image_t self = vself; + + /* Free the scaled bitmap, unless it's a reference to the raw bitmap. */ + if (self->bitmap && (self->bitmap != self->raw_bitmap)) + grub_video_bitmap_destroy (self->bitmap); + if (self->raw_bitmap) + grub_video_bitmap_destroy (self->raw_bitmap); + + grub_free (self); +} + +static const char * +image_get_id (void *vself) +{ + grub_gui_image_t self = vself; + return self->id; +} + +static int +image_is_instance (void *vself __attribute__((unused)), const char *type) +{ + return grub_strcmp (type, "component") == 0; +} + +static void +image_paint (void *vself) +{ + grub_gui_image_t self = vself; + if (! self->bitmap) + return; + grub_video_rect_t vpsave; + grub_gui_set_viewport (&self->bounds, &vpsave); + grub_video_blit_bitmap (self->bitmap, GRUB_VIDEO_BLIT_BLEND, + 0, 0, 0, 0, + grub_video_bitmap_get_width (self->bitmap), + grub_video_bitmap_get_height (self->bitmap)); + grub_gui_restore_viewport (&vpsave); +} + +static void +image_set_parent (void *vself, grub_gui_container_t parent) +{ + grub_gui_image_t self = vself; + self->parent = parent; +} + +static grub_gui_container_t +image_get_parent (void *vself) +{ + grub_gui_image_t self = vself; + return self->parent; +} + +static grub_err_t +rescale_image (grub_gui_image_t self) +{ + if (! self->raw_bitmap) + { + if (self->bitmap) + { + grub_video_bitmap_destroy (self->bitmap); + self->bitmap = 0; + } + return grub_errno; + } + + unsigned width = self->bounds.width; + unsigned height = self->bounds.height; + + if (self->bitmap + && (grub_video_bitmap_get_width (self->bitmap) == width) + && (grub_video_bitmap_get_height (self->bitmap) == height)) + { + /* Nothing to do; already the right size. */ + return grub_errno; + } + + /* Free any old scaled bitmap, + *unless* it's a reference to the raw bitmap. */ + if (self->bitmap && (self->bitmap != self->raw_bitmap)) + grub_video_bitmap_destroy (self->bitmap); + + self->bitmap = 0; + + /* Create a scaled bitmap, unless the requested size is the same + as the raw size -- in that case a reference is made. */ + if (grub_video_bitmap_get_width (self->raw_bitmap) == width + && grub_video_bitmap_get_height (self->raw_bitmap) == height) + { + self->bitmap = self->raw_bitmap; + return grub_errno; + } + + /* Don't scale to an invalid size. */ + if (width == 0 || height == 0) + return grub_errno; + + /* Create the scaled bitmap. */ + grub_video_bitmap_create_scaled (&self->bitmap, + width, + height, + self->raw_bitmap, + GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST); + if (grub_errno != GRUB_ERR_NONE) + { + grub_error_push (); + grub_error (grub_errno, "failed to scale bitmap for image component"); + } + return grub_errno; +} + +static void +image_set_bounds (void *vself, const grub_video_rect_t *bounds) +{ + grub_gui_image_t self = vself; + self->bounds = *bounds; + rescale_image (self); +} + +static void +image_get_bounds (void *vself, grub_video_rect_t *bounds) +{ + grub_gui_image_t self = vself; + *bounds = self->bounds; +} + +static void +image_get_preferred_size (void *vself, int *width, int *height) +{ + grub_gui_image_t self = vself; + + if (self->raw_bitmap) + { + *width = grub_video_bitmap_get_width (self->raw_bitmap); + *height = grub_video_bitmap_get_height (self->raw_bitmap); + } + else + { + *width = 0; + *height = 0; + } + + /* Allow preferred dimensions to override the image dimensions. */ + if (self->preferred_width >= 0) + *width = self->preferred_width; + if (self->preferred_height >= 0) + *height = self->preferred_height; +} + +static grub_err_t +load_image (grub_gui_image_t self, const char *path) +{ + struct grub_video_bitmap *bitmap; + if (grub_video_bitmap_load (&bitmap, path) != GRUB_ERR_NONE) + return grub_errno; + + if (self->bitmap && (self->bitmap != self->raw_bitmap)) + grub_video_bitmap_destroy (self->bitmap); + if (self->raw_bitmap) + grub_video_bitmap_destroy (self->raw_bitmap); + + self->raw_bitmap = bitmap; + return rescale_image (self); +} + +static grub_err_t +image_set_property (void *vself, const char *name, const char *value) +{ + grub_gui_image_t self = vself; + if (grub_strcmp (name, "file") == 0) + return load_image (self, value); + else if (grub_strcmp (name, "preferred_size") == 0) + { + int w; + int h; + if (grub_gui_parse_2_tuple (value, &w, &h) != GRUB_ERR_NONE) + return grub_errno; + self->preferred_width = w; + self->preferred_height = h; + } + else if (grub_strcmp (name, "id") == 0) + { + grub_free (self->id); + if (value) + self->id = grub_strdup (value); + else + self->id = 0; + } + return grub_errno; +} + +static struct grub_gui_component_ops image_ops = +{ + .destroy = image_destroy, + .get_id = image_get_id, + .is_instance = image_is_instance, + .paint = image_paint, + .set_parent = image_set_parent, + .get_parent = image_get_parent, + .set_bounds = image_set_bounds, + .get_bounds = image_get_bounds, + .get_preferred_size = image_get_preferred_size, + .set_property = image_set_property +}; + +grub_gui_component_t +grub_gui_image_new (void) +{ + grub_gui_image_t image; + image = grub_malloc (sizeof (*image)); + if (! image) + return 0; + image->image = &image_ops; + image->parent = 0; + image->bounds.x = 0; + image->bounds.y = 0; + image->bounds.width = 0; + image->bounds.height = 0; + image->id = 0; + image->preferred_width = -1; + image->preferred_height = -1; + image->raw_bitmap = 0; + image->bitmap = 0; + return (grub_gui_component_t) image; +} + === added file 'gfxmenu/gui_label.c' --- gfxmenu/gui_label.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/gui_label.c 2009-06-09 21:49:06 +0000 @@ -0,0 +1,248 @@ +/* gui_label.c - GUI component to display a line of text. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include + +static const char *align_options[] = +{ + "left", + "center", + "right", + 0 +}; + +enum align_mode { + align_left, + align_center, + align_right +}; + +struct grub_gui_label +{ + struct grub_gui_component_ops *label; + + grub_gui_container_t parent; + grub_video_rect_t bounds; + char *id; + int preferred_width; + int preferred_height; + int visible; + char *text; + grub_font_t font; + grub_gui_color_t color; + enum align_mode align; +}; + +typedef struct grub_gui_label *grub_gui_label_t; + +static void +label_destroy (void *vself) +{ + grub_gui_label_t self = vself; + grub_free (self->text); + grub_free (self); +} + +static const char * +label_get_id (void *vself) +{ + grub_gui_label_t self = vself; + return self->id; +} + +static int +label_is_instance (void *vself __attribute__((unused)), const char *type) +{ + return grub_strcmp (type, "component") == 0; +} + +static void +label_paint (void *vself) +{ + grub_gui_label_t self = vself; + + if (! self->visible) + return; + + /* Calculate the starting x coordinate. */ + int left_x; + if (self->align == align_left) + left_x = 0; + else if (self->align == align_center) + left_x = ((self->bounds.width + - grub_font_get_string_width (self->font, self->text)) + ) / 2; + else if (self->align == align_right) + left_x = (self->bounds.width + - grub_font_get_string_width (self->font, self->text)); + else + return; /* Invalid alignment. */ + + grub_video_rect_t vpsave; + grub_gui_set_viewport (&self->bounds, &vpsave); + grub_font_draw_string (self->text, + self->font, + grub_gui_map_color (self->color), + left_x, + grub_font_get_ascent (self->font)); + grub_gui_restore_viewport (&vpsave); +} + +static void +label_set_parent (void *vself, grub_gui_container_t parent) +{ + grub_gui_label_t self = vself; + self->parent = parent; +} + +static grub_gui_container_t +label_get_parent (void *vself) +{ + grub_gui_label_t self = vself; + return self->parent; +} + +static void +label_set_bounds (void *vself, const grub_video_rect_t *bounds) +{ + grub_gui_label_t self = vself; + self->bounds = *bounds; +} + +static void +label_get_bounds (void *vself, grub_video_rect_t *bounds) +{ + grub_gui_label_t self = vself; + *bounds = self->bounds; +} + +static void +label_get_preferred_size (void *vself, int *width, int *height) +{ + grub_gui_label_t self = vself; + *width = grub_font_get_string_width (self->font, self->text); + *height = (grub_font_get_ascent (self->font) + + grub_font_get_descent (self->font)); + + /* Allow preferred dimensions to override the computed dimensions. */ + if (self->preferred_width >= 0) + *width = self->preferred_width; + if (self->preferred_height >= 0) + *height = self->preferred_height; +} + +static void +label_set_property (void *vself, const char *name, const char *value) +{ + grub_gui_label_t self = vself; + if (grub_strcmp (name, "text") == 0) + { + grub_free (self->text); + if (! value) + value = ""; + self->text = grub_strdup (value); + } + else if (grub_strcmp (name, "font") == 0) + { + self->font = grub_font_get (value); + } + else if (grub_strcmp (name, "color") == 0) + { + grub_gui_parse_color (value, &self->color); + } + else if (grub_strcmp (name, "align") == 0) + { + int i; + for (i = 0; align_options[i]; i++) + { + if (grub_strcmp (align_options[i], value) == 0) + { + self->align = i; /* Set the alignment mode. */ + break; + } + } + } + else if (grub_strcmp (name, "visible") == 0) + { + self->visible = grub_strcmp (value, "false") != 0; + } + else if (grub_strcmp (name, "preferred_size") == 0) + { + int w; + int h; + if (grub_gui_parse_2_tuple (value, &w, &h) == GRUB_ERR_NONE) + { + self->preferred_width = w; + self->preferred_height = h; + } + } + else if (grub_strcmp (name, "id") == 0) + { + grub_free (self->id); + if (value) + self->id = grub_strdup (value); + else + self->id = 0; + } +} + +static struct grub_gui_component_ops label_ops = +{ + .destroy = label_destroy, + .get_id = label_get_id, + .is_instance = label_is_instance, + .paint = label_paint, + .set_parent = label_set_parent, + .get_parent = label_get_parent, + .set_bounds = label_set_bounds, + .get_bounds = label_get_bounds, + .get_preferred_size = label_get_preferred_size, + .set_property = label_set_property +}; + +grub_gui_component_t +grub_gui_label_new (void) +{ + grub_gui_label_t label; + label = grub_malloc (sizeof (*label)); + if (! label) + return 0; + label->label = &label_ops; + label->parent = 0; + label->bounds.x = 0; + label->bounds.y = 0; + label->bounds.width = 0; + label->bounds.height = 0; + label->id = 0; + label->preferred_width = -1; + label->preferred_height = -1; + label->visible = 1; + label->text = grub_strdup (""); + label->font = grub_font_get ("Helvetica 10"); + label->color.red = 0; + label->color.green = 0; + label->color.blue = 0; + label->color.alpha = 255; + label->align = align_left; + return (grub_gui_component_t) label; +} === added file 'gfxmenu/gui_list.c' --- gfxmenu/gui_list.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/gui_list.c 2009-06-09 21:49:06 +0000 @@ -0,0 +1,625 @@ +/* gui_list.c - GUI component to display a selectable list of items. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include +#include + +struct grub_gui_list_impl +{ + struct grub_gui_list_ops *list_ops; + + grub_gui_container_t parent; + grub_video_rect_t bounds; + char *id; + int preferred_width; + int preferred_height; + int visible; + + int icon_width; + int icon_height; + int item_height; + int item_padding; + int item_icon_space; + int item_spacing; + grub_font_t item_font; + grub_font_t selected_item_font; + grub_gui_color_t item_color; + int selected_item_color_set; + grub_gui_color_t selected_item_color; + + int draw_scrollbar; + int need_to_recreate_scrollbar; + char *scrollbar_frame_pattern; + char *scrollbar_thumb_pattern; + grub_gfxmenu_box_t scrollbar_frame; + grub_gfxmenu_box_t scrollbar_thumb; + int scrollbar_width; + + int min_items_shown; + int max_items_shown; + int first_shown_index; + + int need_to_recreate_boxes; + char *theme_dir; + char *menu_box_pattern; + char *selected_item_box_pattern; + grub_gfxmenu_box_t menu_box; + grub_gfxmenu_box_t selected_item_box; + + grub_gfxmenu_icon_manager_t icon_manager; + grub_gfxmenu_model_t menu; +}; + +typedef struct grub_gui_list_impl *list_impl_t; + +static void +list_destroy (void *vself) +{ + list_impl_t self = vself; + + grub_free (self->theme_dir); + grub_free (self->menu_box_pattern); + grub_free (self->selected_item_box_pattern); + if (self->menu_box) + self->menu_box->destroy (self->menu_box); + if (self->selected_item_box) + self->selected_item_box->destroy (self->selected_item_box); + if (self->icon_manager) + grub_gfxmenu_icon_manager_destroy (self->icon_manager); + + grub_free (self); +} + +static int +get_num_shown_items (list_impl_t self) +{ + int n = grub_gfxmenu_model_get_num_entries (self->menu); + if (self->min_items_shown != -1 && n < self->min_items_shown) + n = self->min_items_shown; + if (self->max_items_shown != -1 && n > self->max_items_shown) + n = self->max_items_shown; + return n; +} + +static int +check_boxes (list_impl_t self) +{ + if (self->need_to_recreate_boxes) + { + grub_gui_recreate_box (&self->menu_box, + self->menu_box_pattern, + self->theme_dir); + + grub_gui_recreate_box (&self->selected_item_box, + self->selected_item_box_pattern, + self->theme_dir); + + self->need_to_recreate_boxes = 0; + } + + return (self->menu_box != 0 && self->selected_item_box != 0); +} + +static int +check_scrollbar (list_impl_t self) +{ + if (self->need_to_recreate_scrollbar) + { + grub_gui_recreate_box (&self->scrollbar_frame, + self->scrollbar_frame_pattern, + self->theme_dir); + + grub_gui_recreate_box (&self->scrollbar_thumb, + self->scrollbar_thumb_pattern, + self->theme_dir); + + self->need_to_recreate_scrollbar = 0; + } + + return (self->scrollbar_frame != 0 && self->scrollbar_thumb != 0); +} + +static const char * +list_get_id (void *vself) +{ + list_impl_t self = vself; + return self->id; +} + +static int +list_is_instance (void *vself __attribute__((unused)), const char *type) +{ + return (grub_strcmp (type, "component") == 0 + || grub_strcmp (type, "list") == 0); +} + +static struct grub_video_bitmap * +get_item_icon (list_impl_t self, int item_index) +{ + grub_menu_entry_t entry; + entry = grub_gfxmenu_model_get_entry (self->menu, item_index); + if (! entry) + return 0; + + return grub_gfxmenu_icon_manager_get_icon (self->icon_manager, entry); +} + +static void +make_selected_item_visible (list_impl_t self) +{ + int selected_index = grub_gfxmenu_model_get_selected_index (self->menu); + if (selected_index < 0) + return; /* No item is selected. */ + int num_shown_items = get_num_shown_items (self); + int last_shown_index = self->first_shown_index + (num_shown_items - 1); + if (selected_index < self->first_shown_index) + self->first_shown_index = selected_index; + else if (selected_index > last_shown_index) + self->first_shown_index = selected_index - (num_shown_items - 1); +} + +/* Draw a scrollbar on the menu. */ +static void +draw_scrollbar (list_impl_t self, + int value, int extent, int min, int max, + int rightx, int topy, int height) +{ + grub_gfxmenu_box_t frame = self->scrollbar_frame; + grub_gfxmenu_box_t thumb = self->scrollbar_thumb; + int frame_vertical_pad = (frame->get_top_pad (frame) + + frame->get_bottom_pad (frame)); + int frame_horizontal_pad = (frame->get_left_pad (frame) + + frame->get_right_pad (frame)); + int tracktop = topy + frame->get_top_pad (frame); + int tracklen = height - frame_vertical_pad; + frame->set_content_size (frame, self->scrollbar_width, tracklen); + int thumby = tracktop + tracklen * (value - min) / (max - min); + int thumbheight = tracklen * extent / (max - min) + 1; + thumb->set_content_size (thumb, + self->scrollbar_width - frame_horizontal_pad, + thumbheight - (thumb->get_top_pad (thumb) + + thumb->get_bottom_pad (thumb))); + frame->draw (frame, + rightx - (self->scrollbar_width + frame_horizontal_pad), + topy); + thumb->draw (thumb, + rightx - (self->scrollbar_width - frame->get_right_pad (frame)), + thumby); +} + +/* Draw the list of items. */ +static void +draw_menu (list_impl_t self) +{ + if (! self->menu_box || ! self->selected_item_box) + return; + + int boxpad = self->item_padding; + int icon_text_space = self->item_icon_space; + int item_vspace = self->item_spacing; + + int ascent = grub_font_get_ascent (self->item_font); + int descent = grub_font_get_descent (self->item_font); + int item_height = self->item_height; + + int total_num_items = grub_gfxmenu_model_get_num_entries (self->menu); + int num_shown_items = get_num_shown_items (self); + grub_gfxmenu_box_t box = self->menu_box; + int width = self->bounds.width; + int height = self->bounds.height; + + int box_left_pad = box->get_left_pad (box); + int box_top_pad = box->get_top_pad (box); + int box_right_pad = box->get_right_pad (box); + int box_bottom_pad = box->get_bottom_pad (box); + + box->set_content_size (box, + width - box_left_pad - box_right_pad, + height - box_top_pad - box_bottom_pad); + + box->draw (box, 0, 0); + + make_selected_item_visible (self); + + int drawing_scrollbar = (self->draw_scrollbar + && (num_shown_items < total_num_items) + && check_scrollbar (self)); + + int scrollbar_h_space = drawing_scrollbar ? self->scrollbar_width : 0; + + int item_top = box_top_pad + boxpad; + int item_left = box_left_pad + boxpad; + int menu_index; + int visible_index; + + for (visible_index = 0, menu_index = self->first_shown_index; + visible_index < num_shown_items && menu_index < total_num_items; + visible_index++, menu_index++) + { + int is_selected = + (menu_index == grub_gfxmenu_model_get_selected_index (self->menu)); + + if (is_selected) + { + grub_gfxmenu_box_t selbox = self->selected_item_box; + int sel_leftpad = selbox->get_left_pad (selbox); + int sel_toppad = selbox->get_top_pad (selbox); + selbox->set_content_size (selbox, + (width - 2 * boxpad + - box_left_pad - box_right_pad + - scrollbar_h_space), + item_height); + selbox->draw (selbox, + item_left - sel_leftpad, + item_top - sel_toppad); + } + + struct grub_video_bitmap *icon; + if ((icon = get_item_icon (self, menu_index)) != 0) + grub_video_blit_bitmap (icon, GRUB_VIDEO_BLIT_BLEND, + item_left, + item_top + (item_height - self->icon_height) / 2, + 0, 0, self->icon_width, self->icon_height); + + const char *item_title = + grub_gfxmenu_model_get_entry_title (self->menu, menu_index); + grub_font_t font = + (is_selected && self->selected_item_font + ? self->selected_item_font + : self->item_font); + grub_gui_color_t text_color = + ((is_selected && self->selected_item_color_set) + ? self->selected_item_color + : self->item_color); + grub_font_draw_string (item_title, + font, + grub_gui_map_color (text_color), + item_left + self->icon_width + icon_text_space, + (item_top + (item_height - (ascent + descent)) + / 2 + ascent)); + + item_top += item_height + item_vspace; + } + + if (drawing_scrollbar) + draw_scrollbar (self, + self->first_shown_index, num_shown_items, + 0, total_num_items, + width - box_right_pad + self->scrollbar_width, + box_top_pad + boxpad, + height - box_top_pad - box_bottom_pad); +} + +static void +list_paint (void *vself) +{ + list_impl_t self = vself; + + if (! self->visible) + return; + + check_boxes (self); + + grub_video_rect_t vpsave; + grub_gui_set_viewport (&self->bounds, &vpsave); + draw_menu (self); + grub_gui_restore_viewport (&vpsave); +} + +static void +list_set_parent (void *vself, grub_gui_container_t parent) +{ + list_impl_t self = vself; + self->parent = parent; +} + +static grub_gui_container_t +list_get_parent (void *vself) +{ + list_impl_t self = vself; + return self->parent; +} + +static void +list_set_bounds (void *vself, const grub_video_rect_t *bounds) +{ + list_impl_t self = vself; + self->bounds = *bounds; +} + +static void +list_get_bounds (void *vself, grub_video_rect_t *bounds) +{ + list_impl_t self = vself; + *bounds = self->bounds; +} + +static void +list_get_preferred_size (void *vself, int *width, int *height) +{ + list_impl_t self = vself; + + if (check_boxes (self)) + { + int boxpad = self->item_padding; + int item_vspace = self->item_spacing; + int item_height = self->item_height; + int num_items = get_num_shown_items (self); + + grub_gfxmenu_box_t box = self->menu_box; + int box_left_pad = box->get_left_pad (box); + int box_top_pad = box->get_top_pad (box); + int box_right_pad = box->get_right_pad (box); + int box_bottom_pad = box->get_bottom_pad (box); + + *width = 400 + 2 * boxpad + box_left_pad + box_right_pad; + + /* Set the menu box height to fit the items. */ + *height = (item_height * num_items + + item_vspace * (num_items - 1) + + 2 * boxpad + + box_top_pad + box_bottom_pad); + } + else + { + *width = 0; + *height = 0; + } + + /* Allow preferred dimensions to override the computed dimensions. */ + if (self->preferred_width >= 0) + *width = self->preferred_width; + if (self->preferred_height >= 0) + *height = self->preferred_height; +} + +static grub_err_t +list_set_property (void *vself, const char *name, const char *value) +{ + list_impl_t self = vself; + if (grub_strcmp (name, "item_font") == 0) + { + self->item_font = grub_font_get (value); + } + else if (grub_strcmp (name, "selected_item_font") == 0) + { + if (! value || grub_strcmp (value, "inherit") == 0) + self->selected_item_font = 0; + else + self->selected_item_font = grub_font_get (value); + } + else if (grub_strcmp (name, "item_color") == 0) + { + grub_gui_parse_color (value, &self->item_color); + } + else if (grub_strcmp (name, "selected_item_color") == 0) + { + if (! value || grub_strcmp (value, "inherit") == 0) + { + self->selected_item_color_set = 0; + } + else + { + if (grub_gui_parse_color (value, &self->selected_item_color) + == GRUB_ERR_NONE) + self->selected_item_color_set = 1; + } + } + else if (grub_strcmp (name, "icon_width") == 0) + { + self->icon_width = grub_strtol (value, 0, 10); + grub_gfxmenu_icon_manager_set_icon_size (self->icon_manager, + self->icon_width, + self->icon_height); + } + else if (grub_strcmp (name, "icon_height") == 0) + { + self->icon_height = grub_strtol (value, 0, 10); + grub_gfxmenu_icon_manager_set_icon_size (self->icon_manager, + self->icon_width, + self->icon_height); + } + else if (grub_strcmp (name, "item_height") == 0) + { + self->item_height = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "item_padding") == 0) + { + self->item_padding = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "item_icon_space") == 0) + { + self->item_icon_space = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "item_spacing") == 0) + { + self->item_spacing = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "visible") == 0) + { + self->visible = grub_strcmp (value, "false") != 0; + } + else if (grub_strcmp (name, "menu_pixmap_style") == 0) + { + self->need_to_recreate_boxes = 1; + grub_free (self->menu_box_pattern); + self->menu_box_pattern = value ? grub_strdup (value) : 0; + } + else if (grub_strcmp (name, "selected_item_pixmap_style") == 0) + { + self->need_to_recreate_boxes = 1; + grub_free (self->selected_item_box_pattern); + self->selected_item_box_pattern = value ? grub_strdup (value) : 0; + } + else if (grub_strcmp (name, "scrollbar_frame") == 0) + { + self->need_to_recreate_scrollbar = 1; + grub_free (self->scrollbar_frame_pattern); + self->scrollbar_frame_pattern = value ? grub_strdup (value) : 0; + } + else if (grub_strcmp (name, "scrollbar_thumb") == 0) + { + self->need_to_recreate_scrollbar = 1; + grub_free (self->scrollbar_thumb_pattern); + self->scrollbar_thumb_pattern = value ? grub_strdup (value) : 0; + } + else if (grub_strcmp (name, "scrollbar_width") == 0) + { + self->scrollbar_width = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "scrollbar") == 0) + { + self->draw_scrollbar = grub_strcmp (value, "false") != 0; + } + else if (grub_strcmp (name, "min_items_shown") == 0) + { + self->min_items_shown = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "max_items_shown") == 0) + { + self->max_items_shown = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "theme_dir") == 0) + { + self->need_to_recreate_boxes = 1; + grub_free (self->theme_dir); + self->theme_dir = value ? grub_strdup (value) : 0; + } + else if (grub_strcmp (name, "preferred_size") == 0) + { + int w; + int h; + if (grub_gui_parse_2_tuple (value, &w, &h) != GRUB_ERR_NONE) + return grub_errno; + self->preferred_width = w; + self->preferred_height = h; + } + else if (grub_strcmp (name, "id") == 0) + { + grub_free (self->id); + if (value) + self->id = grub_strdup (value); + else + self->id = 0; + } + return grub_errno; +} + +/* Set necessary information that the gfxmenu view provides. */ +static void +list_set_view_info (void *vself, + const char *theme_path, + grub_gfxmenu_model_t menu) +{ + list_impl_t self = vself; + grub_gfxmenu_icon_manager_set_theme_path (self->icon_manager, theme_path); + self->menu = menu; +} + +static struct grub_gui_list_ops list_ops = +{ + .component_ops = + { + .destroy = list_destroy, + .get_id = list_get_id, + .is_instance = list_is_instance, + .paint = list_paint, + .set_parent = list_set_parent, + .get_parent = list_get_parent, + .set_bounds = list_set_bounds, + .get_bounds = list_get_bounds, + .get_preferred_size = list_get_preferred_size, + .set_property = list_set_property + }, + .set_view_info = list_set_view_info +}; + +grub_gui_component_t +grub_gui_list_new (void) +{ + list_impl_t self; + grub_font_t default_font; + grub_gui_color_t default_fg_color; + grub_gui_color_t default_bg_color; + + self = grub_malloc (sizeof (*self)); + if (! self) + return 0; + + self->list_ops = &list_ops; + self->parent = 0; + self->bounds.x = 0; + self->bounds.y = 0; + self->bounds.width = 0; + self->bounds.height = 0; + self->id = 0; + self->preferred_width = -1; + self->preferred_height = -1; + self->visible = 1; + + default_font = grub_font_get ("Helvetica 12"); + default_fg_color = grub_gui_color_rgb (0, 0, 0); + default_bg_color = grub_gui_color_rgb (255, 255, 255); + + self->icon_width = 32; + self->icon_height = 32; + self->item_height = 42; + self->item_padding = 14; + self->item_icon_space = 4; + self->item_spacing = 16; + self->item_font = default_font; + self->selected_item_font = 0; /* Default to using the item_font. */ + self->item_color = default_fg_color; + self->selected_item_color_set = 0; /* Default to using the item_color. */ + self->selected_item_color = default_fg_color; + + self->draw_scrollbar = 1; + self->need_to_recreate_scrollbar = 1; + self->scrollbar_frame = 0; + self->scrollbar_thumb = 0; + self->scrollbar_frame_pattern = 0; + self->scrollbar_thumb_pattern = 0; + self->scrollbar_width = 16; + + self->min_items_shown = -1; + self->max_items_shown = -1; + self->first_shown_index = 0; + + self->need_to_recreate_boxes = 0; + self->theme_dir = 0; + self->menu_box_pattern = 0; + self->selected_item_box_pattern = 0; + self->menu_box = grub_gfxmenu_create_box (0, 0); + self->selected_item_box = grub_gfxmenu_create_box (0, 0); + + self->icon_manager = grub_gfxmenu_icon_manager_new (); + if (! self->icon_manager) + { + self->list_ops->component_ops.destroy (self); + return 0; + } + grub_gfxmenu_icon_manager_set_icon_size (self->icon_manager, + self->icon_width, + self->icon_height); + return (grub_gui_component_t) self; +} === added file 'gfxmenu/gui_progress_bar.c' --- gfxmenu/gui_progress_bar.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/gui_progress_bar.c 2009-06-09 21:49:06 +0000 @@ -0,0 +1,378 @@ +/* gui_progress_bar.c - GUI progress bar component. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include + +struct grub_gui_progress_bar +{ + struct grub_gui_component_ops *progress_bar; + + grub_gui_container_t parent; + grub_video_rect_t bounds; + char *id; + int preferred_width; + int preferred_height; + int visible; + int start; + int end; + int value; + int show_text; + char *text; + grub_font_t font; + grub_gui_color_t text_color; + grub_gui_color_t border_color; + grub_gui_color_t bg_color; + grub_gui_color_t fg_color; + + char *theme_dir; + int need_to_recreate_pixmaps; + char *bar_pattern; + char *highlight_pattern; + grub_gfxmenu_box_t bar_box; + grub_gfxmenu_box_t highlight_box; +}; + +typedef struct grub_gui_progress_bar *grub_gui_progress_bar_t; + +static void +progress_bar_destroy (void *vself) +{ + grub_gui_progress_bar_t self = vself; + grub_free (self); +} + +static const char * +progress_bar_get_id (void *vself) +{ + grub_gui_progress_bar_t self = vself; + return self->id; +} + +static int +progress_bar_is_instance (void *vself __attribute__((unused)), const char *type) +{ + return grub_strcmp (type, "component") == 0; +} + +static int +check_pixmaps (grub_gui_progress_bar_t self) +{ + if (self->need_to_recreate_pixmaps) + { + grub_gui_recreate_box (&self->bar_box, + self->bar_pattern, + self->theme_dir); + + grub_gui_recreate_box (&self->highlight_box, + self->highlight_pattern, + self->theme_dir); + + self->need_to_recreate_pixmaps = 0; + } + + return (self->bar_box != 0 && self->highlight_box != 0); +} + +static void +draw_filled_rect_bar (grub_gui_progress_bar_t self) +{ + /* Set the progress bar's frame. */ + grub_video_rect_t f; + f.x = 1; + f.y = 1; + f.width = self->bounds.width - 2; + f.height = self->bounds.height - 2; + + /* Border. */ + grub_video_fill_rect (grub_gui_map_color (self->border_color), + f.x - 1, f.y - 1, + f.width + 2, f.height + 2); + + /* Bar background. */ + int barwidth = (f.width + * (self->value - self->start) + / (self->end - self->start)); + grub_video_fill_rect (grub_gui_map_color (self->bg_color), + f.x + barwidth, f.y, + f.width - barwidth, f.height); + + /* Bar foreground. */ + grub_video_fill_rect (grub_gui_map_color (self->fg_color), + f.x, f.y, + barwidth, f.height); +} + +static void +draw_pixmap_bar (grub_gui_progress_bar_t self) +{ + grub_gfxmenu_box_t bar = self->bar_box; + grub_gfxmenu_box_t hl = self->highlight_box; + int w = self->bounds.width; + int h = self->bounds.height; + int bar_l_pad = bar->get_left_pad (bar); + int bar_r_pad = bar->get_right_pad (bar); + int bar_t_pad = bar->get_top_pad (bar); + int bar_b_pad = bar->get_bottom_pad (bar); + int bar_h_pad = bar_l_pad + bar_r_pad; + int bar_v_pad = bar_t_pad + bar_b_pad; + int tracklen = w - bar_h_pad; + int trackheight = h - bar_v_pad; + bar->set_content_size (bar, tracklen, trackheight); + + int barwidth = (tracklen + * (self->value - self->start) + / (self->end - self->start)); + hl->set_content_size (hl, barwidth, h - bar_v_pad); + + bar->draw (bar, 0, 0); + hl->draw (hl, bar_l_pad, bar_t_pad); +} + +static void +draw_text (grub_gui_progress_bar_t self) +{ + const char *text = self->text; + if (text && self->show_text) + { + grub_font_t font = self->font; + grub_video_color_t text_color = grub_gui_map_color (self->text_color); + int width = self->bounds.width; + int height = self->bounds.height; + + /* Center the text. */ + int text_width = grub_font_get_string_width (font, text); + int x = (width - text_width) / 2; + int y = ((height - grub_font_get_descent (font)) / 2 + + grub_font_get_ascent (font) / 2); + grub_font_draw_string (text, font, text_color, x, y); + } +} + +static void +progress_bar_paint (void *vself) +{ + grub_gui_progress_bar_t self = vself; + if (! self->visible) + return; + + grub_video_rect_t vpsave; + grub_gui_set_viewport (&self->bounds, &vpsave); + + if (check_pixmaps (self)) + draw_pixmap_bar (self); + else + draw_filled_rect_bar (self); + + draw_text (self); + + grub_gui_restore_viewport (&vpsave); +} + +static void +progress_bar_set_parent (void *vself, grub_gui_container_t parent) +{ + grub_gui_progress_bar_t self = vself; + self->parent = parent; +} + +static grub_gui_container_t +progress_bar_get_parent (void *vself) +{ + grub_gui_progress_bar_t self = vself; + return self->parent; +} + +static void +progress_bar_set_bounds (void *vself, const grub_video_rect_t *bounds) +{ + grub_gui_progress_bar_t self = vself; + self->bounds = *bounds; +} + +static void +progress_bar_get_bounds (void *vself, grub_video_rect_t *bounds) +{ + grub_gui_progress_bar_t self = vself; + *bounds = self->bounds; +} + +static void +progress_bar_get_preferred_size (void *vself, int *width, int *height) +{ + grub_gui_progress_bar_t self = vself; + + *width = 200; + *height = 28; + + /* Allow preferred dimensions to override the progress_bar dimensions. */ + if (self->preferred_width >= 0) + *width = self->preferred_width; + if (self->preferred_height >= 0) + *height = self->preferred_height; +} + +static grub_err_t +progress_bar_set_property (void *vself, const char *name, const char *value) +{ + grub_gui_progress_bar_t self = vself; + if (grub_strcmp (name, "value") == 0) + { + self->value = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "start") == 0) + { + self->start = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "end") == 0) + { + self->end = grub_strtol (value, 0, 10); + } + else if (grub_strcmp (name, "text") == 0) + { + grub_free (self->text); + if (! value) + value = ""; + self->text = grub_strdup (value); + } + else if (grub_strcmp (name, "font") == 0) + { + self->font = grub_font_get (value); + } + else if (grub_strcmp (name, "text_color") == 0) + { + grub_gui_parse_color (value, &self->text_color); + } + else if (grub_strcmp (name, "border_color") == 0) + { + grub_gui_parse_color (value, &self->border_color); + } + else if (grub_strcmp (name, "bg_color") == 0) + { + grub_gui_parse_color (value, &self->bg_color); + } + else if (grub_strcmp (name, "fg_color") == 0) + { + grub_gui_parse_color (value, &self->fg_color); + } + else if (grub_strcmp (name, "bar_style") == 0) + { + self->need_to_recreate_pixmaps = 1; + grub_free (self->bar_pattern); + self->bar_pattern = value ? grub_strdup (value) : 0; + } + else if (grub_strcmp (name, "highlight_style") == 0) + { + self->need_to_recreate_pixmaps = 1; + grub_free (self->highlight_pattern); + self->highlight_pattern = value ? grub_strdup (value) : 0; + } + else if (grub_strcmp (name, "theme_dir") == 0) + { + self->need_to_recreate_pixmaps = 1; + grub_free (self->theme_dir); + self->theme_dir = value ? grub_strdup (value) : 0; + } + else if (grub_strcmp (name, "preferred_size") == 0) + { + int w; + int h; + if (grub_gui_parse_2_tuple (value, &w, &h) != GRUB_ERR_NONE) + return grub_errno; + self->preferred_width = w; + self->preferred_height = h; + } + else if (grub_strcmp (name, "visible") == 0) + { + self->visible = grub_strcmp (value, "false") != 0; + } + else if (grub_strcmp (name, "show_text") == 0) + { + self->show_text = grub_strcmp (value, "false") != 0; + } + else if (grub_strcmp (name, "id") == 0) + { + grub_free (self->id); + if (value) + self->id = grub_strdup (value); + else + self->id = 0; + } + return grub_errno; +} + +static struct grub_gui_component_ops progress_bar_ops = +{ + .destroy = progress_bar_destroy, + .get_id = progress_bar_get_id, + .is_instance = progress_bar_is_instance, + .paint = progress_bar_paint, + .set_parent = progress_bar_set_parent, + .get_parent = progress_bar_get_parent, + .set_bounds = progress_bar_set_bounds, + .get_bounds = progress_bar_get_bounds, + .get_preferred_size = progress_bar_get_preferred_size, + .set_property = progress_bar_set_property +}; + +grub_gui_component_t +grub_gui_progress_bar_new (void) +{ + grub_gui_progress_bar_t self; + self = grub_malloc (sizeof (*self)); + if (! self) + return 0; + self->progress_bar = &progress_bar_ops; + self->parent = 0; + self->bounds.x = 0; + self->bounds.y = 0; + self->bounds.width = 0; + self->bounds.height = 0; + self->id = 0; + self->preferred_width = -1; + self->preferred_height = -1; + self->visible = 1; + self->start = 0; + self->end = 0; + self->value = 0; + self->show_text = 1; + self->text = grub_strdup (""); + self->font = grub_font_get ("Helvetica 10"); + grub_gui_color_t black = { .red = 0, .green = 0, .blue = 0, .alpha = 255 }; + grub_gui_color_t gray = { .red = 128, .green = 128, .blue = 128, .alpha = 255 }; + grub_gui_color_t lightgray = { .red = 200, .green = 200, .blue = 200, .alpha = 255 }; + self->text_color = black; + self->border_color = black; + self->bg_color = gray; + self->fg_color = lightgray; + + self->theme_dir = 0; + self->need_to_recreate_pixmaps = 0; + self->bar_pattern = 0; + self->highlight_pattern = 0; + self->bar_box = 0; + self->highlight_box = 0; + + return (grub_gui_component_t) self; +} === added file 'gfxmenu/gui_string_util.c' --- gfxmenu/gui_string_util.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/gui_string_util.c 2009-06-09 21:49:06 +0000 @@ -0,0 +1,358 @@ +/* gui_string_util.c - String utilities used by the GUI system. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include + +/* Create a new NUL-terminated string on the heap as a substring of BUF. + The range of buf included is the half-open interval [START,END). + The index START is inclusive, END is exclusive. */ +char * +grub_new_substring (const char *buf, + grub_size_t start, grub_size_t end) +{ + if (end < start) + return 0; + grub_size_t len = end - start; + char *s = grub_malloc (len + 1); + if (! s) + return 0; + grub_memcpy (s, buf + start, len); + s[len] = '\0'; + return s; +} + +/* Eliminate "." and ".." path elements from PATH. A new heap-allocated + string is returned. */ +static char * +canonicalize_path (const char *path) +{ + int i; + const char *p; + char *newpath = 0; + + /* Count the path components in path. */ + int components = 1; + for (p = path; *p; p++) + if (*p == '/') + components++; + + char **path_array = grub_malloc (components * sizeof (*path_array)); + if (! path_array) + return 0; + + /* Initialize array elements to NULL pointers; in case once of the + allocations fails, the cleanup code can just call grub_free() for all + pointers in the array. */ + for (i = 0; i < components; i++) + path_array[i] = 0; + + /* Parse the path into path_array. */ + p = path; + for (i = 0; i < components && p; i++) + { + /* Find the end of the path element. */ + const char *end = grub_strchr (p, '/'); + if (!end) + end = p + grub_strlen (p); + + /* Copy the element. */ + path_array[i] = grub_new_substring (p, 0, end - p); + if (! path_array[i]) + goto cleanup; + + /* Advance p to point to the start of the next element, or NULL. */ + if (*end) + p = end + 1; + else + p = 0; + } + + /* Eliminate '.' and '..' elements from the path array. */ + int newpath_length = 0; + for (i = components - 1; i >= 0; --i) + { + if (! grub_strcmp (path_array[i], ".")) + { + grub_free (path_array[i]); + path_array[i] = 0; + } + else if (! grub_strcmp (path_array[i], "..") + && i > 0) + { + /* Delete the '..' and the prior path element. */ + grub_free (path_array[i]); + path_array[i] = 0; + --i; + grub_free (path_array[i]); + path_array[i] = 0; + } + else + { + newpath_length += grub_strlen (path_array[i]) + 1; + } + } + + /* Construct a new path string. */ + newpath = grub_malloc (newpath_length + 1); + if (! newpath) + goto cleanup; + + newpath[0] = '\0'; + char *newpath_end = newpath; + int first = 1; + for (i = 0; i < components; i++) + { + char *element = path_array[i]; + if (element) + { + /* For all components but the first, prefix with a slash. */ + if (! first) + newpath_end = grub_stpcpy (newpath_end, "/"); + newpath_end = grub_stpcpy (newpath_end, element); + first = 0; + } + } + +cleanup: + for (i = 0; i < components; i++) + grub_free (path_array[i]); + grub_free (path_array); + + return newpath; +} + +/* Return a new heap-allocated string representing to absolute path + to the file referred to by PATH. If PATH is an absolute path, then + the returned path is a copy of PATH. If PATH is a relative path, then + BASE is with PATH used to construct the absolute path. */ +char * +grub_resolve_relative_path (const char *base, const char *path) +{ + char *abspath; + char *canonpath; + char *p; + + /* If PATH is an absolute path, then just use it as is. */ + if (path[0] == '/' || path[0] == '(') + return canonicalize_path (path); + + abspath = grub_malloc (grub_strlen (base) + grub_strlen (path) + 1); + if (! abspath) + return 0; + + /* Concatenate BASE and PATH. + Note that BASE is expected to have a trailing slash. */ + p = grub_stpcpy (abspath, base); + grub_stpcpy (p, path); + + canonpath = canonicalize_path (abspath); + if (! canonpath) + return abspath; + + grub_free (abspath); + return canonpath; +} + +/* Get the path of the directory where the file at FILE_PATH is located. + FILE_PATH should refer to a file, not a directory. The returned path + includes a trailing slash. + This does not handle GRUB "(hd0,0)" paths properly yet since it only + looks at slashes. */ +char * +grub_get_dirname (const char *file_path) +{ + int i; + int last_slash; + + last_slash = -1; + for (i = grub_strlen (file_path) - 1; i >= 0; --i) + { + if (file_path[i] == '/') + { + last_slash = i; + break; + } + } + if (last_slash == -1) + return grub_strdup ("/"); + + return grub_new_substring (file_path, 0, last_slash + 1); +} + +static __inline int +isxdigit (char c) +{ + return ((c >= '0' && c <= '9') + || (c >= 'a' && c <= 'f') + || (c >= 'A' && c <= 'F')); +} + +static int +parse_hex_color_component (const char *s, unsigned start, unsigned end) +{ + unsigned len; + char buf[3]; + + len = end - start; + /* Check the limits so we don't overrun the buffer. */ + if (len < 1 || len > 2) + return 0; + + if (len == 1) + { + buf[0] = s[start]; /* Get the first and only hex digit. */ + buf[1] = buf[0]; /* Duplicate the hex digit. */ + } + else if (len == 2) + { + buf[0] = s[start]; + buf[1] = s[start + 1]; + } + + buf[2] = '\0'; + + return grub_strtoul (buf, 0, 16); +} + +/* Parse a color string of the form "r, g, b", "#RGB", "#RGBA", + "#RRGGBB", or "#RRGGBBAA". */ +grub_err_t +grub_gui_parse_color (const char *s, grub_gui_color_t *color) +{ + grub_gui_color_t c; + + /* Skip whitespace. */ + while (*s && grub_isspace (*s)) + s++; + + if (*s == '#') + { + /* HTML-style. Number if hex digits: + [6] #RRGGBB [3] #RGB + [8] #RRGGBBAA [4] #RGBA */ + + s++; /* Skip the '#'. */ + /* Count the hexits to determine the format. */ + int hexits = 0; + const char *end = s; + while (isxdigit (*end)) + { + end++; + hexits++; + } + + /* Parse the color components based on the format. */ + if (hexits == 3 || hexits == 4) + { + c.red = parse_hex_color_component (s, 0, 1); + c.green = parse_hex_color_component (s, 1, 2); + c.blue = parse_hex_color_component (s, 2, 3); + if (hexits == 4) + c.alpha = parse_hex_color_component (s, 3, 4); + else + c.alpha = 255; + } + else if (hexits == 6 || hexits == 8) + { + c.red = parse_hex_color_component (s, 0, 2); + c.green = parse_hex_color_component (s, 2, 4); + c.blue = parse_hex_color_component (s, 4, 6); + if (hexits == 8) + c.alpha = parse_hex_color_component (s, 6, 8); + else + c.alpha = 255; + } + else + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "invalid HTML-type color string `%s'", s); + } + else if (grub_isdigit (*s)) + { + /* Comma separated decimal values. */ + c.red = grub_strtoul (s, 0, 0); + if ((s = grub_strchr (s, ',')) == 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "missing 1st comma separator in color `%s'", s); + s++; + c.green = grub_strtoul (s, 0, 0); + if ((s = grub_strchr (s, ',')) == 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "missing 2nd comma separator in color `%s'", s); + s++; + c.blue = grub_strtoul (s, 0, 0); + if ((s = grub_strchr (s, ',')) == 0) + c.alpha = 255; + else + { + s++; + c.alpha = grub_strtoul (s, 0, 0); + } + } + else + { + if (! grub_gui_get_named_color (s, &c)) + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "invalid named color `%s'", s); + } + + if (grub_errno == GRUB_ERR_NONE) + *color = c; + return grub_errno; +} + +/* Parse a value in the form "(x, y)", storing the first element (x) into + *PX and the second element (y) into *PY. + Returns GRUB_ERR_NONE if successfully parsed. */ +grub_err_t +grub_gui_parse_2_tuple (const char *s, int *px, int *py) +{ + int x; + int y; + + while (*s && grub_isspace (*s)) + s++; + if (*s != '(') + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "missing `(' in 2-tuple `%s'", s); + + /* Skip the opening parentheses. */ + s++; + if (*s == 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "unexpected end of 2-tuple after `(' in `%s'", s); + + /* Parse the first element. */ + x = grub_strtol (s, 0, 10); + if ((s = grub_strchr (s, ',')) == 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "missing comma in 2-tuple `%s'", s); + + /* Skip the element separator (the comma). */ + s++; + /* Parse the second element. */ + y = grub_strtol (s, 0, 10); + + *px = x; + *py = y; + + return grub_errno; +} === added file 'gfxmenu/gui_util.c' --- gfxmenu/gui_util.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/gui_util.c 2008-08-16 17:35:05 +0000 @@ -0,0 +1,101 @@ +/* gui_util.c - GUI utility functions. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include + + +struct find_by_id_state +{ + const char *match_id; + grub_gui_component_callback match_callback; + void *match_userdata; +}; + +static void +find_by_id_recursively (grub_gui_component_t component, void *userdata) +{ + struct find_by_id_state *state; + const char *id; + + state = (struct find_by_id_state *) userdata; + id = component->ops->get_id (component); + if (id && grub_strcmp (id, state->match_id) == 0) + state->match_callback (component, state->match_userdata); + + if (component->ops->is_instance (component, "container")) + { + grub_gui_container_t container; + container = (grub_gui_container_t) component; + container->ops->iterate_children (container, + find_by_id_recursively, + state); + } +} + +void +grub_gui_find_by_id (grub_gui_component_t root, + const char *id, + grub_gui_component_callback cb, + void *userdata) +{ + struct find_by_id_state state; + state.match_id = id; + state.match_callback = cb; + state.match_userdata = userdata; + find_by_id_recursively (root, &state); +} + + +struct iterate_recursively_state +{ + grub_gui_component_callback callback; + void *userdata; +}; + +static +void iterate_recursively_cb (grub_gui_component_t component, void *userdata) +{ + struct iterate_recursively_state *state; + + state = (struct iterate_recursively_state *) userdata; + state->callback (component, state->userdata); + + if (component->ops->is_instance (component, "container")) + { + grub_gui_container_t container; + container = (grub_gui_container_t) component; + container->ops->iterate_children (container, + iterate_recursively_cb, + state); + } +} + +void +grub_gui_iterate_recursively (grub_gui_component_t root, + grub_gui_component_callback cb, + void *userdata) +{ + struct iterate_recursively_state state; + state.callback = cb; + state.userdata = userdata; + iterate_recursively_cb (root, &state); +} === added file 'gfxmenu/icon_manager.c' --- gfxmenu/icon_manager.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/icon_manager.c 2009-06-09 21:49:06 +0000 @@ -0,0 +1,258 @@ +/* icon_manager.c - gfxmenu icon manager. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Currently hard coded to '.png' extension. */ +static const char icon_extension[] = ".png"; + +typedef struct icon_entry +{ + char *class_name; + struct grub_video_bitmap *bitmap; + struct icon_entry *next; +} *icon_entry_t; + +struct grub_gfxmenu_icon_manager +{ + char *theme_path; + int icon_width; + int icon_height; + + /* Icon cache: linked list w/ dummy head node. */ + struct icon_entry cache; +}; + + +/* Create a new icon manager and return a point to it. */ +grub_gfxmenu_icon_manager_t +grub_gfxmenu_icon_manager_new (void) +{ + grub_gfxmenu_icon_manager_t mgr; + mgr = grub_malloc (sizeof (*mgr)); + if (! mgr) + return 0; + + mgr->theme_path = 0; + mgr->icon_width = 0; + mgr->icon_height = 0; + + /* Initialize the dummy head node. */ + mgr->cache.class_name = 0; + mgr->cache.bitmap = 0; + mgr->cache.next = 0; + + return mgr; +} + +/* Destroy the icon manager MGR, freeing all resources used by it. + +Note: Any bitmaps returned by grub_gfxmenu_icon_manager_get_icon() +are destroyed and must not be used by the caller after this function +is called. */ +void +grub_gfxmenu_icon_manager_destroy (grub_gfxmenu_icon_manager_t mgr) +{ + grub_gfxmenu_icon_manager_clear_cache (mgr); + grub_free (mgr->theme_path); + grub_free (mgr); +} + +/* Clear the icon cache. */ +void +grub_gfxmenu_icon_manager_clear_cache (grub_gfxmenu_icon_manager_t mgr) +{ + icon_entry_t cur; + icon_entry_t next; + for (cur = mgr->cache.next; cur; cur = next) + { + next = cur->next; + grub_free (cur->class_name); + grub_video_bitmap_destroy (cur->bitmap); + grub_free (cur); + } + mgr->cache.next = 0; +} + +/* Set the theme path. If the theme path is changed, the icon cache + is cleared. */ +void +grub_gfxmenu_icon_manager_set_theme_path (grub_gfxmenu_icon_manager_t mgr, + const char *path) +{ + /* Clear the cache if the theme path has changed. */ + if (((mgr->theme_path == 0) != (path == 0)) + || (grub_strcmp (mgr->theme_path, path) != 0)) + grub_gfxmenu_icon_manager_clear_cache (mgr); + + grub_free (mgr->theme_path); + mgr->theme_path = path ? grub_strdup (path) : 0; +} + +/* Set the icon size. When icons are requested from the icon manager, + they are scaled to this size before being returned. If the size is + changed, the icon cache is cleared. */ +void +grub_gfxmenu_icon_manager_set_icon_size (grub_gfxmenu_icon_manager_t mgr, + int width, int height) +{ + /* If the width or height is changed, we must clear the cache, since the + scaled bitmaps are stored in the cache. */ + if (width != mgr->icon_width || height != mgr->icon_height) + grub_gfxmenu_icon_manager_clear_cache (mgr); + + mgr->icon_width = width; + mgr->icon_height = height; +} + +/* Try to load an icon for the specified CLASS_NAME in the directory DIR. + Returns 0 if the icon could not be loaded, or returns a pointer to a new + bitmap if it was successful. */ +static struct grub_video_bitmap * +try_loading_icon (grub_gfxmenu_icon_manager_t mgr, + const char *dir, const char *class_name) +{ + char *path = grub_malloc (grub_strlen (dir) + + grub_strlen (class_name) + + grub_strlen (icon_extension) + + 1); + if (! path) + return 0; + + grub_strcpy (path, dir); + grub_strcat (path, class_name); + grub_strcat (path, icon_extension); + + struct grub_video_bitmap *raw_bitmap; + grub_video_bitmap_load (&raw_bitmap, path); + grub_free (path); + grub_errno = GRUB_ERR_NONE; /* Critical to clear the error!! */ + if (! raw_bitmap) + return 0; + + struct grub_video_bitmap *scaled_bitmap; + grub_video_bitmap_create_scaled (&scaled_bitmap, + mgr->icon_width, mgr->icon_height, + raw_bitmap, + GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST); + grub_video_bitmap_destroy (raw_bitmap); + if (! scaled_bitmap) + { + grub_error_push (); + grub_error (grub_errno, "failed to scale icon"); + return 0; + } + + return scaled_bitmap; +} + +/* Get the icon for the specified class CLASS_NAME. If an icon for + CLASS_NAME already exists in the cache, then a reference to the cached + bitmap is returned. If it is not cached, then it is loaded and cached. + If no icon could be could for CLASS_NAME, then 0 is returned. */ +static struct grub_video_bitmap * +get_icon_by_class (grub_gfxmenu_icon_manager_t mgr, const char *class_name) +{ + /* First check the icon cache. */ + icon_entry_t entry; + for (entry = mgr->cache.next; entry; entry = entry->next) + { + if (grub_strcmp (entry->class_name, class_name) == 0) + return entry->bitmap; + } + + if (! mgr->theme_path) + return 0; + + /* Otherwise, we search for an icon to load. */ + char *theme_dir = grub_get_dirname (mgr->theme_path); + char *icons_dir; + struct grub_video_bitmap *icon; + icon = 0; + /* First try the theme's own icons, from "grub/themes/NAME/icons/" */ + icons_dir = grub_resolve_relative_path (theme_dir, "icons/"); + if (icons_dir) + { + icon = try_loading_icon (mgr, icons_dir, class_name); + grub_free (icons_dir); + } + if (! icon) + { + /* If the theme doesn't have an appropriate icon, check in + "grub/themes/icons". */ + /* TODO use GRUB prefix "/icons" */ + icons_dir = grub_resolve_relative_path (theme_dir, "../icons/"); + if (icons_dir) + { + icon = try_loading_icon (mgr, icons_dir, class_name); + grub_free (icons_dir); + } + } + grub_free (theme_dir); + + /* No icon was found. */ + /* This should probably be noted in the cache, so that a search is not + performed each time an icon for CLASS_NAME is requested. */ + if (! icon) + return 0; + + /* Insert a new cache entry for this icon. */ + entry = grub_malloc (sizeof (*entry)); + if (! entry) + { + grub_video_bitmap_destroy (icon); + return 0; + } + entry->class_name = grub_strdup (class_name); + entry->bitmap = icon; + entry->next = mgr->cache.next; + mgr->cache.next = entry; /* Link it into the cache. */ + return entry->bitmap; +} + +/* Get the best available icon for ENTRY. Beginning with the first class + listed in the menu entry and proceeding forward, an icon for each class + is searched for. The first icon found is returned. The returned icon + is scaled to the size specified by + grub_gfxmenu_icon_manager_set_icon_size(). + + Note: Bitmaps returned by this function are destroyed when the + icon manager is destroyed. + */ +struct grub_video_bitmap * +grub_gfxmenu_icon_manager_get_icon (grub_gfxmenu_icon_manager_t mgr, + grub_menu_entry_t entry) +{ + struct grub_menu_entry_class *c; + struct grub_video_bitmap *icon; + + /* Try each class in succession. */ + icon = 0; + for (c = entry->classes->next; c && ! icon; c = c->next) + icon = get_icon_by_class (mgr, c->name); + return icon; +} === added file 'gfxmenu/model.c' --- gfxmenu/model.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/model.c 2008-08-12 02:55:06 +0000 @@ -0,0 +1,191 @@ +/* model.c - Graphical menu interface MVC model. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +/* Model type definition. */ +struct grub_gfxmenu_model +{ + grub_menu_t menu; + int num_entries; + grub_menu_entry_t *entries; + int selected_entry_index; + int timeout_set; + grub_uint64_t timeout_start; + grub_uint64_t timeout_at; +}; + + +grub_gfxmenu_model_t +grub_gfxmenu_model_new (grub_menu_t menu) +{ + grub_gfxmenu_model_t model; + + model = grub_malloc (sizeof (*model)); + if (! model) + return 0; + + model->menu = menu; + model->num_entries = menu->size; + model->entries = 0; + model->selected_entry_index = 0; + model->timeout_set = 0; + model->timeout_at = 0; + if (model->num_entries > 0) + { + model->entries = grub_malloc (model->num_entries + * sizeof (*model->entries)); + if (! model->entries) + goto fail_and_free; + + int i; + grub_menu_entry_t cur; + for (i = 0, cur = menu->entry_list; + i < model->num_entries; + i++, cur = cur->next) + { + model->entries[i] = cur; + } + } + + return model; + +fail_and_free: + grub_free (model->entries); + grub_free (model); + return 0; +} + +void +grub_gfxmenu_model_destroy (grub_gfxmenu_model_t model) +{ + if (! model) + return; + + grub_free (model->entries); + model->entries = 0; + + grub_free (model); +} + +grub_menu_t +grub_gfxmenu_model_get_menu (grub_gfxmenu_model_t model) +{ + return model->menu; +} + +void +grub_gfxmenu_model_set_timeout (grub_gfxmenu_model_t model) +{ + int timeout_sec = grub_menu_get_timeout (); + if (timeout_sec >= 0) + { + model->timeout_start = grub_get_time_ms (); + model->timeout_at = model->timeout_start + timeout_sec * 1000; + model->timeout_set = 1; + } + else + { + model->timeout_set = 0; + } +} + +void +grub_gfxmenu_model_clear_timeout (grub_gfxmenu_model_t model) +{ + model->timeout_set = 0; + grub_menu_set_timeout (-1); +} + +int +grub_gfxmenu_model_get_timeout_ms (grub_gfxmenu_model_t model) +{ + if (!model->timeout_set) + return -1; + + return model->timeout_at - model->timeout_start; +} + +int +grub_gfxmenu_model_get_timeout_remaining_ms (grub_gfxmenu_model_t model) +{ + if (!model->timeout_set) + return -1; + + return model->timeout_at - grub_get_time_ms (); +} + +int +grub_gfxmenu_model_timeout_expired (grub_gfxmenu_model_t model) +{ + if (model->timeout_set + && grub_get_time_ms () >= model->timeout_at) + return 1; + + return 0; +} + +int +grub_gfxmenu_model_get_num_entries (grub_gfxmenu_model_t model) +{ + return model->num_entries; +} + +int +grub_gfxmenu_model_get_selected_index (grub_gfxmenu_model_t model) +{ + return model->selected_entry_index; +} + +void +grub_gfxmenu_model_set_selected_index (grub_gfxmenu_model_t model, int index) +{ + model->selected_entry_index = index; +} + +const char * +grub_gfxmenu_model_get_entry_title (grub_gfxmenu_model_t model, int index) +{ + if (index < 0 || index >= model->num_entries) + { + grub_error (GRUB_ERR_OUT_OF_RANGE, "invalid menu index"); + return 0; + } + + return model->entries[index]->title; +} + +grub_menu_entry_t +grub_gfxmenu_model_get_entry (grub_gfxmenu_model_t model, int index) +{ + if (index < 0 || index >= model->num_entries) + { + grub_error (GRUB_ERR_OUT_OF_RANGE, "invalid menu index"); + return 0; + } + + return model->entries[index]; +} === added file 'gfxmenu/named_colors.c' --- gfxmenu/named_colors.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/named_colors.c 2008-08-16 17:35:05 +0000 @@ -0,0 +1,209 @@ +/* named_colors.c - Named color values. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include + +struct named_color +{ + const char *name; + grub_gui_color_t color; +}; + +/* + Named color list generated from the list of SVG color keywords from + , + processed through the following Perl command: + perl -ne 'chomp;split;print "{ \"$_[0]\", RGB_COLOR($_[2]) },\n"' + */ + +#define RGB_COLOR(r,g,b) {.red = r, .green = g, .blue = b, .alpha = 255} + +static struct named_color named_colors[] = +{ + { "aliceblue", RGB_COLOR(240,248,255) }, + { "antiquewhite", RGB_COLOR(250,235,215) }, + { "aqua", RGB_COLOR(0,255,255) }, + { "aquamarine", RGB_COLOR(127,255,212) }, + { "azure", RGB_COLOR(240,255,255) }, + { "beige", RGB_COLOR(245,245,220) }, + { "bisque", RGB_COLOR(255,228,196) }, + { "black", RGB_COLOR(0,0,0) }, + { "blanchedalmond", RGB_COLOR(255,235,205) }, + { "blue", RGB_COLOR(0,0,255) }, + { "blueviolet", RGB_COLOR(138,43,226) }, + { "brown", RGB_COLOR(165,42,42) }, + { "burlywood", RGB_COLOR(222,184,135) }, + { "cadetblue", RGB_COLOR(95,158,160) }, + { "chartreuse", RGB_COLOR(127,255,0) }, + { "chocolate", RGB_COLOR(210,105,30) }, + { "coral", RGB_COLOR(255,127,80) }, + { "cornflowerblue", RGB_COLOR(100,149,237) }, + { "cornsilk", RGB_COLOR(255,248,220) }, + { "crimson", RGB_COLOR(220,20,60) }, + { "cyan", RGB_COLOR(0,255,255) }, + { "darkblue", RGB_COLOR(0,0,139) }, + { "darkcyan", RGB_COLOR(0,139,139) }, + { "darkgoldenrod", RGB_COLOR(184,134,11) }, + { "darkgray", RGB_COLOR(169,169,169) }, + { "darkgreen", RGB_COLOR(0,100,0) }, + { "darkgrey", RGB_COLOR(169,169,169) }, + { "darkkhaki", RGB_COLOR(189,183,107) }, + { "darkmagenta", RGB_COLOR(139,0,139) }, + { "darkolivegreen", RGB_COLOR(85,107,47) }, + { "darkorange", RGB_COLOR(255,140,0) }, + { "darkorchid", RGB_COLOR(153,50,204) }, + { "darkred", RGB_COLOR(139,0,0) }, + { "darksalmon", RGB_COLOR(233,150,122) }, + { "darkseagreen", RGB_COLOR(143,188,143) }, + { "darkslateblue", RGB_COLOR(72,61,139) }, + { "darkslategray", RGB_COLOR(47,79,79) }, + { "darkslategrey", RGB_COLOR(47,79,79) }, + { "darkturquoise", RGB_COLOR(0,206,209) }, + { "darkviolet", RGB_COLOR(148,0,211) }, + { "deeppink", RGB_COLOR(255,20,147) }, + { "deepskyblue", RGB_COLOR(0,191,255) }, + { "dimgray", RGB_COLOR(105,105,105) }, + { "dimgrey", RGB_COLOR(105,105,105) }, + { "dodgerblue", RGB_COLOR(30,144,255) }, + { "firebrick", RGB_COLOR(178,34,34) }, + { "floralwhite", RGB_COLOR(255,250,240) }, + { "forestgreen", RGB_COLOR(34,139,34) }, + { "fuchsia", RGB_COLOR(255,0,255) }, + { "gainsboro", RGB_COLOR(220,220,220) }, + { "ghostwhite", RGB_COLOR(248,248,255) }, + { "gold", RGB_COLOR(255,215,0) }, + { "goldenrod", RGB_COLOR(218,165,32) }, + { "gray", RGB_COLOR(128,128,128) }, + { "green", RGB_COLOR(0,128,0) }, + { "greenyellow", RGB_COLOR(173,255,47) }, + { "grey", RGB_COLOR(128,128,128) }, + { "honeydew", RGB_COLOR(240,255,240) }, + { "hotpink", RGB_COLOR(255,105,180) }, + { "indianred", RGB_COLOR(205,92,92) }, + { "indigo", RGB_COLOR(75,0,130) }, + { "ivory", RGB_COLOR(255,255,240) }, + { "khaki", RGB_COLOR(240,230,140) }, + { "lavender", RGB_COLOR(230,230,250) }, + { "lavenderblush", RGB_COLOR(255,240,245) }, + { "lawngreen", RGB_COLOR(124,252,0) }, + { "lemonchiffon", RGB_COLOR(255,250,205) }, + { "lightblue", RGB_COLOR(173,216,230) }, + { "lightcoral", RGB_COLOR(240,128,128) }, + { "lightcyan", RGB_COLOR(224,255,255) }, + { "lightgoldenrodyellow", RGB_COLOR(250,250,210) }, + { "lightgray", RGB_COLOR(211,211,211) }, + { "lightgreen", RGB_COLOR(144,238,144) }, + { "lightgrey", RGB_COLOR(211,211,211) }, + { "lightpink", RGB_COLOR(255,182,193) }, + { "lightsalmon", RGB_COLOR(255,160,122) }, + { "lightseagreen", RGB_COLOR(32,178,170) }, + { "lightskyblue", RGB_COLOR(135,206,250) }, + { "lightslategray", RGB_COLOR(119,136,153) }, + { "lightslategrey", RGB_COLOR(119,136,153) }, + { "lightsteelblue", RGB_COLOR(176,196,222) }, + { "lightyellow", RGB_COLOR(255,255,224) }, + { "lime", RGB_COLOR(0,255,0) }, + { "limegreen", RGB_COLOR(50,205,50) }, + { "linen", RGB_COLOR(250,240,230) }, + { "magenta", RGB_COLOR(255,0,255) }, + { "maroon", RGB_COLOR(128,0,0) }, + { "mediumaquamarine", RGB_COLOR(102,205,170) }, + { "mediumblue", RGB_COLOR(0,0,205) }, + { "mediumorchid", RGB_COLOR(186,85,211) }, + { "mediumpurple", RGB_COLOR(147,112,219) }, + { "mediumseagreen", RGB_COLOR(60,179,113) }, + { "mediumslateblue", RGB_COLOR(123,104,238) }, + { "mediumspringgreen", RGB_COLOR(0,250,154) }, + { "mediumturquoise", RGB_COLOR(72,209,204) }, + { "mediumvioletred", RGB_COLOR(199,21,133) }, + { "midnightblue", RGB_COLOR(25,25,112) }, + { "mintcream", RGB_COLOR(245,255,250) }, + { "mistyrose", RGB_COLOR(255,228,225) }, + { "moccasin", RGB_COLOR(255,228,181) }, + { "navajowhite", RGB_COLOR(255,222,173) }, + { "navy", RGB_COLOR(0,0,128) }, + { "oldlace", RGB_COLOR(253,245,230) }, + { "olive", RGB_COLOR(128,128,0) }, + { "olivedrab", RGB_COLOR(107,142,35) }, + { "orange", RGB_COLOR(255,165,0) }, + { "orangered", RGB_COLOR(255,69,0) }, + { "orchid", RGB_COLOR(218,112,214) }, + { "palegoldenrod", RGB_COLOR(238,232,170) }, + { "palegreen", RGB_COLOR(152,251,152) }, + { "paleturquoise", RGB_COLOR(175,238,238) }, + { "palevioletred", RGB_COLOR(219,112,147) }, + { "papayawhip", RGB_COLOR(255,239,213) }, + { "peachpuff", RGB_COLOR(255,218,185) }, + { "peru", RGB_COLOR(205,133,63) }, + { "pink", RGB_COLOR(255,192,203) }, + { "plum", RGB_COLOR(221,160,221) }, + { "powderblue", RGB_COLOR(176,224,230) }, + { "purple", RGB_COLOR(128,0,128) }, + { "red", RGB_COLOR(255,0,0) }, + { "rosybrown", RGB_COLOR(188,143,143) }, + { "royalblue", RGB_COLOR(65,105,225) }, + { "saddlebrown", RGB_COLOR(139,69,19) }, + { "salmon", RGB_COLOR(250,128,114) }, + { "sandybrown", RGB_COLOR(244,164,96) }, + { "seagreen", RGB_COLOR(46,139,87) }, + { "seashell", RGB_COLOR(255,245,238) }, + { "sienna", RGB_COLOR(160,82,45) }, + { "silver", RGB_COLOR(192,192,192) }, + { "skyblue", RGB_COLOR(135,206,235) }, + { "slateblue", RGB_COLOR(106,90,205) }, + { "slategray", RGB_COLOR(112,128,144) }, + { "slategrey", RGB_COLOR(112,128,144) }, + { "snow", RGB_COLOR(255,250,250) }, + { "springgreen", RGB_COLOR(0,255,127) }, + { "steelblue", RGB_COLOR(70,130,180) }, + { "tan", RGB_COLOR(210,180,140) }, + { "teal", RGB_COLOR(0,128,128) }, + { "thistle", RGB_COLOR(216,191,216) }, + { "tomato", RGB_COLOR(255,99,71) }, + { "turquoise", RGB_COLOR(64,224,208) }, + { "violet", RGB_COLOR(238,130,238) }, + { "wheat", RGB_COLOR(245,222,179) }, + { "white", RGB_COLOR(255,255,255) }, + { "whitesmoke", RGB_COLOR(245,245,245) }, + { "yellow", RGB_COLOR(255,255,0) }, + { "yellowgreen", RGB_COLOR(154,205,50) }, + { 0, { 0, 0, 0, 0 } } /* Terminator. */ +}; + +/* Get the color named NAME. If the color was found, returns 1 and + stores the color into *COLOR. If the color was not found, returns 0 and + does not modify *COLOR. */ +int +grub_gui_get_named_color (const char *name, + grub_gui_color_t *color) +{ + int i; + for (i = 0; named_colors[i].name; i++) + { + if (grub_strcmp (named_colors[i].name, name) == 0) + { + *color = named_colors[i].color; + return 1; + } + } + return 0; +} === added file 'gfxmenu/theme_loader.c' --- gfxmenu/theme_loader.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/theme_loader.c 2009-06-09 21:49:06 +0000 @@ -0,0 +1,720 @@ +/* theme_loader.c - Theme file loader for gfxmenu. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Construct a new box widget using ABSPATTERN to find the pixmap files for + it, storing the new box instance at *BOXPTR. + PATTERN should be of the form: "(hd0,0)/somewhere/style*.png". + The '*' then gets substituted with the various pixmap names that the + box uses. */ +static grub_err_t +recreate_box_absolute (grub_gfxmenu_box_t *boxptr, const char *abspattern) +{ + char *prefix; + char *suffix; + char *star; + grub_gfxmenu_box_t box; + + star = grub_strchr (abspattern, '*'); + if (! star) + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "missing `*' in box pixmap pattern `%s'", abspattern); + + /* Prefix: Get the part before the '*'. */ + prefix = grub_malloc (star - abspattern + 1); + if (! prefix) + return grub_errno; + + grub_memcpy (prefix, abspattern, star - abspattern); + prefix[star - abspattern] = '\0'; + + /* Suffix: Everything after the '*' is the suffix. */ + suffix = star + 1; + + box = grub_gfxmenu_create_box (prefix, suffix); + grub_free (prefix); + if (! box) + return grub_errno; + + if (*boxptr) + (*boxptr)->destroy (*boxptr); + *boxptr = box; + return grub_errno; +} + + +/* Construct a new box widget using PATTERN to find the pixmap files for it, + storing the new widget at *BOXPTR. PATTERN should be of the form: + "somewhere/style*.png". The '*' then gets substituted with the various + pixmap names that the widget uses. + + Important! The value of *BOXPTR must be initialized! It must either + (1) Be 0 (a NULL pointer), or + (2) Be a pointer to a valid 'grub_gfxmenu_box_t' instance. + In this case, the previous instance is destroyed. */ +grub_err_t +grub_gui_recreate_box (grub_gfxmenu_box_t *boxptr, + const char *pattern, const char *theme_dir) +{ + char *abspattern; + + /* Check arguments. */ + if (! pattern) + { + /* If no pixmap pattern is given, then just create an empty box. */ + if (*boxptr) + (*boxptr)->destroy (*boxptr); + *boxptr = grub_gfxmenu_create_box (0, 0); + return grub_errno; + } + + if (! theme_dir) + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "styled box missing theme directory"); + + /* Resolve to an absolute path. */ + abspattern = grub_resolve_relative_path (theme_dir, pattern); + if (! abspattern) + return grub_errno; + + /* Create the box. */ + recreate_box_absolute (boxptr, abspattern); + grub_free (abspattern); + return grub_errno; +} + +/* Set the specified property NAME on the view to the given string VALUE. + The caller is responsible for the lifetimes of NAME and VALUE. */ +static grub_err_t +theme_set_string (grub_gfxmenu_view_t view, + const char *name, + const char *value, + const char *theme_dir, + const char *filename, + int line_num, + int col_num) +{ + if (! grub_strcmp ("title-font", name)) + view->title_font = grub_font_get (value); + else if (! grub_strcmp ("message-font", name)) + view->message_font = grub_font_get (value); + else if (! grub_strcmp ("terminal-font", name)) + { + grub_free (view->terminal_font_name); + view->terminal_font_name = grub_strdup (value); + if (! view->terminal_font_name) + return grub_errno; + } + else if (! grub_strcmp ("title-color", name)) + grub_gui_parse_color (value, &view->title_color); + else if (! grub_strcmp ("message-color", name)) + grub_gui_parse_color (value, &view->message_color); + else if (! grub_strcmp ("message-bg-color", name)) + grub_gui_parse_color (value, &view->message_bg_color); + else if (! grub_strcmp ("desktop-image", name)) + { + struct grub_video_bitmap *raw_bitmap; + struct grub_video_bitmap *scaled_bitmap; + char *path; + path = grub_resolve_relative_path (theme_dir, value); + if (! path) + return grub_errno; + if (grub_video_bitmap_load (&raw_bitmap, path) != GRUB_ERR_NONE) + { + grub_free (path); + return grub_errno; + } + grub_free(path); + grub_video_bitmap_create_scaled (&scaled_bitmap, + view->screen.width, + view->screen.height, + raw_bitmap, + GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST); + grub_video_bitmap_destroy (raw_bitmap); + if (! scaled_bitmap) + { + grub_error_push (); + return grub_error (grub_errno, "error scaling desktop image"); + } + + grub_video_bitmap_destroy (view->desktop_image); + view->desktop_image = scaled_bitmap; + } + else if (! grub_strcmp ("desktop-color", name)) + grub_gui_parse_color (value, &view->desktop_color); + else if (! grub_strcmp ("terminal-box", name)) + { + grub_err_t err; + err = grub_gui_recreate_box (&view->terminal_box, value, theme_dir); + if (err != GRUB_ERR_NONE) + return err; + } + else if (! grub_strcmp ("title-text", name)) + { + grub_free (view->title_text); + view->title_text = grub_strdup (value); + if (! view->title_text) + return grub_errno; + } + else + { + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "%s:%d:%d unknown property `%s'", + filename, line_num, col_num, name); + } + return grub_errno; +} + +struct parsebuf +{ + char *buf; + int pos; + int len; + int line_num; + int col_num; + const char *filename; + char *theme_dir; + grub_gfxmenu_view_t view; +}; + +static int +has_more (struct parsebuf *p) +{ + return p->pos < p->len; +} + +static int +read_char (struct parsebuf *p) +{ + if (has_more (p)) + { + char c; + c = p->buf[p->pos++]; + if (c == '\n') + { + p->line_num++; + p->col_num = 1; + } + else + { + p->col_num++; + } + return c; + } + else + return -1; +} + +static int +peek_char (struct parsebuf *p) +{ + if (has_more (p)) + return p->buf[p->pos]; + else + return -1; +} + +static int +is_whitespace (char c) +{ + return (c == ' ' + || c == '\t' + || c == '\r' + || c == '\n' + || c == '\f'); +} + +static void +skip_whitespace (struct parsebuf *p) +{ + while (has_more (p) && is_whitespace(peek_char (p))) + read_char (p); +} + +static void +advance_to_next_line (struct parsebuf *p) +{ + int c; + + /* Eat characters up to the newline. */ + do + { + c = read_char (p); + } + while (c != -1 && c != '\n'); +} + +static int +is_identifier_char (int c) +{ + return (c != -1 + && (grub_isalpha(c) + || grub_isdigit(c) + || c == '_' + || c == '-')); +} + +static char * +read_identifier (struct parsebuf *p) +{ + /* Index of the first character of the identifier in p->buf. */ + int start; + /* Next index after the last character of the identifer in p->buf. */ + int end; + + skip_whitespace (p); + + /* Capture the start of the identifier. */ + start = p->pos; + + /* Scan for the end. */ + while (is_identifier_char (peek_char (p))) + read_char (p); + end = p->pos; + + if (end - start < 1) + return 0; + + return grub_new_substring (p->buf, start, end); +} + +static char * +read_expression (struct parsebuf *p) +{ + int start; + int end; + + skip_whitespace (p); + if (peek_char (p) == '"') + { + /* Read as a quoted string. + The quotation marks are not included in the expression value. */ + /* Skip opening quotation mark. */ + read_char (p); + start = p->pos; + while (has_more (p) && peek_char (p) != '"') + read_char (p); + end = p->pos; + /* Skip the terminating quotation mark. */ + read_char (p); + } + else if (peek_char (p) == '(') + { + /* Read as a parenthesized string -- for tuples/coordinates. */ + /* The parentheses are included in the expression value. */ + int c; + + start = p->pos; + do + { + c = read_char (p); + } + while (c != -1 && c != ')'); + end = p->pos; + } + else if (has_more (p)) + { + /* Read as a single word -- for numeric values or words without + whitespace. */ + start = p->pos; + while (has_more (p) && ! is_whitespace (peek_char (p))) + read_char (p); + end = p->pos; + } + else + { + /* The end of the theme file has been reached. */ + grub_error (GRUB_ERR_IO, "%s:%d:%d expression expected in theme file", + p->filename, p->line_num, p->col_num); + return 0; + } + + return grub_new_substring (p->buf, start, end); +} + +/* Read a GUI object specification from the theme file. + Any components created will be added to the GUI container PARENT. */ +static grub_err_t +read_object (struct parsebuf *p, grub_gui_container_t parent) +{ + grub_video_rect_t bounds; + + char *name; + name = read_identifier (p); + if (! name) + goto cleanup; + + grub_gui_component_t component = 0; + if (grub_strcmp (name, "label") == 0) + { + component = grub_gui_label_new (); + } + else if (grub_strcmp (name, "image") == 0) + { + component = grub_gui_image_new (); + } + else if (grub_strcmp (name, "vbox") == 0) + { + component = (grub_gui_component_t) grub_gui_vbox_new (); + } + else if (grub_strcmp (name, "hbox") == 0) + { + component = (grub_gui_component_t) grub_gui_hbox_new (); + } + else if (grub_strcmp (name, "canvas") == 0) + { + component = (grub_gui_component_t) grub_gui_canvas_new (); + } + else if (grub_strcmp (name, "progress_bar") == 0) + { + component = grub_gui_progress_bar_new (); + } + else if (grub_strcmp (name, "circular_progress") == 0) + { + component = grub_gui_circular_progress_new (); + } + else if (grub_strcmp (name, "boot_menu") == 0) + { + component = grub_gui_list_new (); + } + else + { + /* Unknown type. */ + grub_error (GRUB_ERR_IO, "%s:%d:%d unknown object type `%s'", + p->filename, p->line_num, p->col_num, name); + goto cleanup; + } + + if (! component) + goto cleanup; + + /* Inform the component about the theme so it can find its resources. */ + component->ops->set_property (component, "theme_dir", p->theme_dir); + component->ops->set_property (component, "theme_path", p->filename); + + /* Add the component as a child of PARENT. */ + bounds.x = 0; + bounds.y = 0; + bounds.width = -1; + bounds.height = -1; + component->ops->set_bounds (component, &bounds); + parent->ops->add (parent, component); + + skip_whitespace (p); + if (read_char (p) != '{') + { + grub_error (GRUB_ERR_IO, + "%s:%d:%d expected `{' after object type name `%s'", + p->filename, p->line_num, p->col_num, name); + goto cleanup; + } + + while (has_more (p)) + { + skip_whitespace (p); + + /* Check whether the end has been encountered. */ + if (peek_char (p) == '}') + { + /* Skip the closing brace. */ + read_char (p); + break; + } + + if (peek_char (p) == '#') + { + /* Skip comments. */ + advance_to_next_line (p); + continue; + } + + if (peek_char (p) == '+') + { + /* Skip the '+'. */ + read_char (p); + + /* Check whether this component is a container. */ + if (component->ops->is_instance (component, "container")) + { + /* Read the sub-object recursively and add it as a child. */ + if (read_object (p, (grub_gui_container_t) component) != 0) + goto cleanup; + /* After reading the sub-object, resume parsing, expecting + another property assignment or sub-object definition. */ + continue; + } + else + { + grub_error (GRUB_ERR_IO, + "%s:%d:%d attempted to add object to non-container", + p->filename, p->line_num, p->col_num); + goto cleanup; + } + } + + char *property; + property = read_identifier (p); + if (! property) + { + grub_error (GRUB_ERR_IO, "%s:%d:%d identifier expected in theme file", + p->filename, p->line_num, p->col_num); + goto cleanup; + } + + skip_whitespace (p); + if (read_char (p) != '=') + { + grub_error (GRUB_ERR_IO, + "%s:%d:%d expected `=' after property name `%s'", + p->filename, p->line_num, p->col_num, property); + grub_free (property); + goto cleanup; + } + skip_whitespace (p); + + char *value; + value = read_expression (p); + if (! value) + { + grub_free (property); + goto cleanup; + } + + /* Handle the property value. */ + if (grub_strcmp (property, "position") == 0) + { + /* Special case for position value. */ + int x; + int y; + + if (grub_gui_parse_2_tuple (value, &x, &y) == GRUB_ERR_NONE) + { + grub_video_rect_t r; + component->ops->get_bounds (component, &r); + r.x = x; + r.y = y; + component->ops->set_bounds (component, &r); + } + } + else if (grub_strcmp (property, "size") == 0) + { + /* Special case for size value. */ + int w; + int h; + + if (grub_gui_parse_2_tuple (value, &w, &h) == GRUB_ERR_NONE) + { + grub_video_rect_t r; + component->ops->get_bounds (component, &r); + r.width = w; + r.height = h; + component->ops->set_bounds (component, &r); + } + } + else + { + /* General property handling. */ + component->ops->set_property (component, property, value); + } + + grub_free (value); + grub_free (property); + if (grub_errno != GRUB_ERR_NONE) + goto cleanup; + } + + /* Set the object's size to its preferred size unless the user has + explicitly specified the size. */ + component->ops->get_bounds (component, &bounds); + if (bounds.width == -1 || bounds.height == -1) + { + component->ops->get_preferred_size (component, + &bounds.width, &bounds.height); + component->ops->set_bounds (component, &bounds); + } + +cleanup: + grub_free (name); + return grub_errno; +} + +static grub_err_t +read_property (struct parsebuf *p) +{ + char *name; + + /* Read the property name. */ + name = read_identifier (p); + if (! name) + { + advance_to_next_line (p); + return grub_errno; + } + + /* Skip whitespace before separator. */ + skip_whitespace (p); + + /* Read separator. */ + if (read_char (p) != ':') + { + grub_error (GRUB_ERR_IO, + "%s:%d:%d missing separator after property name `%s'", + p->filename, p->line_num, p->col_num, name); + goto done; + } + + /* Skip whitespace after separator. */ + skip_whitespace (p); + + /* Get the value based on its type. */ + if (peek_char (p) == '"') + { + /* String value (e.g., '"My string"'). */ + char *value = read_expression (p); + if (! value) + { + grub_error (GRUB_ERR_IO, "%s:%d:%d missing property value", + p->filename, p->line_num, p->col_num); + goto done; + } + /* If theme_set_string results in an error, grub_errno will be returned + below. */ + theme_set_string (p->view, name, value, p->theme_dir, + p->filename, p->line_num, p->col_num); + grub_free (value); + } + else + { + grub_error (GRUB_ERR_IO, + "%s:%d:%d property value invalid; " + "enclose literal values in quotes (\")", + p->filename, p->line_num, p->col_num); + goto done; + } + +done: + grub_free (name); + return grub_errno; +} + +/* Set properties on the view based on settings from the specified + theme file. */ +grub_err_t +grub_gfxmenu_view_load_theme (grub_gfxmenu_view_t view, const char *theme_path) +{ + grub_file_t file; + struct parsebuf p; + + p.view = view; + p.theme_dir = grub_get_dirname (theme_path); + + file = grub_file_open (theme_path); + if (! file) + { + grub_free (p.theme_dir); + return grub_errno; + } + + p.len = grub_file_size (file); + p.buf = grub_malloc (p.len); + p.pos = 0; + p.line_num = 1; + p.col_num = 1; + p.filename = theme_path; + if (! p.buf) + { + grub_file_close (file); + grub_free (p.theme_dir); + return grub_errno; + } + if (grub_file_read (file, p.buf, p.len) != p.len) + { + grub_free (p.buf); + grub_file_close (file); + grub_free (p.theme_dir); + return grub_errno; + } + + if (view->canvas) + view->canvas->ops->component.destroy (view->canvas); + + view->canvas = grub_gui_canvas_new (); + ((grub_gui_component_t) view->canvas) + ->ops->set_bounds ((grub_gui_component_t) view->canvas, + &view->screen); + + while (has_more (&p)) + { + /* Skip comments (lines beginning with #). */ + if (peek_char (&p) == '#') + { + advance_to_next_line (&p); + continue; + } + + /* Find the first non-whitespace character. */ + skip_whitespace (&p); + + /* Handle the content. */ + if (peek_char (&p) == '+') + { + /* Skip the '+'. */ + read_char (&p); + read_object (&p, view->canvas); + } + else + { + read_property (&p); + } + + if (grub_errno != GRUB_ERR_NONE) + goto fail; + } + + /* Set the new theme path. */ + grub_free (view->theme_path); + view->theme_path = grub_strdup (theme_path); + goto cleanup; + +fail: + if (view->canvas) + { + view->canvas->ops->component.destroy (view->canvas); + view->canvas = 0; + } + +cleanup: + grub_free (p.buf); + grub_file_close (file); + grub_free (p.theme_dir); + return grub_errno; +} === added file 'gfxmenu/view.c' --- gfxmenu/view.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/view.c 2009-06-08 16:39:59 +0000 @@ -0,0 +1,503 @@ +/* view.c - Graphical menu interface MVC view. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* The component ID identifying GUI components to be updated as the timeout + status changes. */ +#define TIMEOUT_COMPONENT_ID "__timeout__" + +static void init_terminal (grub_gfxmenu_view_t view); +static void destroy_terminal (void); +static grub_err_t set_graphics_mode (void); +static grub_err_t set_text_mode (void); + +/* Create a new view object, loading the theme specified by THEME_PATH and + associating MODEL with the view. */ +grub_gfxmenu_view_t +grub_gfxmenu_view_new (const char *theme_path, grub_gfxmenu_model_t model) +{ + grub_gfxmenu_view_t view; + + view = grub_malloc (sizeof (*view)); + if (! view) + return 0; + + set_graphics_mode (); + grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + grub_video_get_viewport ((unsigned *) &view->screen.x, + (unsigned *) &view->screen.y, + (unsigned *) &view->screen.width, + (unsigned *) &view->screen.height); + + /* Clear the screen; there may be garbage left over in video memory, and + loading the menu style (particularly the background) can take a while. */ + grub_video_fill_rect (grub_video_map_rgb (0, 0, 0), + view->screen.x, view->screen.y, + view->screen.width, view->screen.height); + grub_video_swap_buffers (); + + grub_font_t default_font; + grub_gui_color_t default_fg_color; + grub_gui_color_t default_bg_color; + + default_font = grub_font_get ("Helvetica 12"); + default_fg_color = grub_gui_color_rgb (0, 0, 0); + default_bg_color = grub_gui_color_rgb (255, 255, 255); + + view->model = model; + view->canvas = 0; + + view->title_font = default_font; + view->message_font = default_font; + view->terminal_font_name = grub_strdup ("Fixed 10"); + view->title_color = default_fg_color; + view->message_color = default_bg_color; + view->message_bg_color = default_fg_color; + view->desktop_image = 0; + view->desktop_color = default_bg_color; + view->terminal_box = grub_gfxmenu_create_box (0, 0); + view->title_text = grub_strdup ("GRUB Boot Menu"); + view->progress_message_text = 0; + view->theme_path = 0; + + if (grub_gfxmenu_view_load_theme (view, theme_path) != 0) + { + grub_gfxmenu_view_destroy (view); + return 0; + } + + init_terminal (view); + + return view; +} + +/* Destroy the view object. All used memory is freed. */ +void +grub_gfxmenu_view_destroy (grub_gfxmenu_view_t view) +{ + grub_video_bitmap_destroy (view->desktop_image); + if (view->terminal_box) + view->terminal_box->destroy (view->terminal_box); + grub_free (view->terminal_font_name); + grub_free (view->title_text); + grub_free (view->progress_message_text); + grub_free (view->theme_path); + if (view->canvas) + view->canvas->ops->component.destroy (view->canvas); + grub_free (view); + + set_text_mode (); + destroy_terminal (); +} + +/* Sets MESSAGE as the progress message for the view. + MESSAGE can be 0, in which case no message is displayed. */ +static void +set_progress_message (grub_gfxmenu_view_t view, const char *message) +{ + grub_free (view->progress_message_text); + if (message) + view->progress_message_text = grub_strdup (message); + else + view->progress_message_text = 0; +} + +static void +draw_background (grub_gfxmenu_view_t view) +{ + if (view->desktop_image) + { + struct grub_video_bitmap *img = view->desktop_image; + grub_video_blit_bitmap (img, GRUB_VIDEO_BLIT_REPLACE, + view->screen.x, view->screen.y, 0, 0, + grub_video_bitmap_get_width (img), + grub_video_bitmap_get_height (img)); + } + else + { + grub_video_fill_rect (grub_gui_map_color (view->desktop_color), + view->screen.x, view->screen.y, + view->screen.width, view->screen.height); + } +} + +static void +draw_title (grub_gfxmenu_view_t view) +{ + if (! view->title_text) + return; + + /* Center the title. */ + int title_width = grub_font_get_string_width (view->title_font, + view->title_text); + int x = (view->screen.width - title_width) / 2; + int y = 40 + grub_font_get_ascent (view->title_font); + grub_font_draw_string (view->title_text, + view->title_font, + grub_gui_map_color (view->title_color), + x, y); +} + +struct progress_value_data +{ + const char *visible; + const char *start; + const char *end; + const char *value; + const char *text; +}; + +static void +update_timeout_visit (grub_gui_component_t component, + void *userdata) +{ + struct progress_value_data *pv; + pv = (struct progress_value_data *) userdata; + component->ops->set_property (component, "visible", pv->visible); + component->ops->set_property (component, "start", pv->start); + component->ops->set_property (component, "end", pv->end); + component->ops->set_property (component, "value", pv->value); + component->ops->set_property (component, "text", pv->text); +} + +static void +update_timeout (grub_gfxmenu_view_t view) +{ + char startbuf[20]; + char valuebuf[20]; + char msgbuf[120]; + + int timeout = grub_gfxmenu_model_get_timeout_ms (view->model); + int remaining = grub_gfxmenu_model_get_timeout_remaining_ms (view->model); + struct progress_value_data pv; + + pv.visible = timeout > 0 ? "true" : "false"; + grub_sprintf (startbuf, "%d", -timeout); + pv.start = startbuf; + pv.end = "0"; + grub_sprintf (valuebuf, "%d", remaining > 0 ? -remaining : 0); + pv.value = valuebuf; + + int seconds_remaining_rounded_up = (remaining + 999) / 1000; + grub_sprintf (msgbuf, + "The highlighted entry will be booted automatically in %d s.", + seconds_remaining_rounded_up); + pv.text = msgbuf; + + grub_gui_find_by_id ((grub_gui_component_t) view->canvas, + TIMEOUT_COMPONENT_ID, update_timeout_visit, &pv); +} + +static void +update_menu_visit (grub_gui_component_t component, + void *userdata) +{ + grub_gfxmenu_view_t view; + view = userdata; + if (component->ops->is_instance (component, "list")) + { + grub_gui_list_t list = (grub_gui_list_t) component; + list->ops->set_view_info (list, view->theme_path, view->model); + } +} + +/* Update any boot menu components with the current menu model and + theme path. */ +static void +update_menu_components (grub_gfxmenu_view_t view) +{ + grub_gui_iterate_recursively ((grub_gui_component_t) view->canvas, + update_menu_visit, view); +} + +static void +draw_message (grub_gfxmenu_view_t view) +{ + char *text = view->progress_message_text; + if (! text) + return; + + grub_font_t font = view->message_font; + grub_video_color_t color = grub_gui_map_color (view->message_color); + + /* Set the timeout bar's frame. */ + grub_video_rect_t f; + f.width = view->screen.width * 4 / 5; + f.height = 50; + f.x = view->screen.x + (view->screen.width - f.width) / 2; + f.y = view->screen.y + view->screen.height - 90 - 20 - f.height; + + /* Border. */ + grub_video_fill_rect (color, + f.x-1, f.y-1, f.width+2, f.height+2); + /* Fill. */ + grub_video_fill_rect (grub_gui_map_color (view->message_bg_color), + f.x, f.y, f.width, f.height); + + /* Center the text. */ + int text_width = grub_font_get_string_width (font, text); + int x = f.x + (f.width - text_width) / 2; + int y = (f.y + (f.height - grub_font_get_descent (font)) / 2 + + grub_font_get_ascent (font) / 2); + grub_font_draw_string (text, font, color, x, y); +} + + +void +grub_gfxmenu_view_draw (grub_gfxmenu_view_t view) +{ + grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + update_timeout (view); + update_menu_components (view); + + draw_background (view); + if (view->canvas) + view->canvas->ops->component.paint (view->canvas); + draw_title (view); + draw_message (view); +} + +static grub_err_t +set_graphics_mode (void) +{ + const char *doublebuf_str = grub_env_get ("doublebuffering"); + int double_buffering = (doublebuf_str && doublebuf_str[0] == 'n') ? 0 : 1; + + const char *modestr = grub_env_get ("gfxmode"); + if (grub_video_set_mode (modestr, 0) != GRUB_ERR_NONE) + return grub_errno; + + grub_video_enable_double_buffering(double_buffering); + + return GRUB_ERR_NONE; +} + +static grub_err_t +set_text_mode (void) +{ + return grub_video_restore (); +} + +static int term_target_width; +static int term_target_height; +static struct grub_video_render_target *term_target; +static int term_initialized; +static grub_term_output_t term_original; +static grub_gfxmenu_view_t term_view; + +static void +repaint_terminal (int x __attribute ((unused)), + int y __attribute ((unused)), + int width __attribute ((unused)), + int height __attribute ((unused))) +{ + if (! term_view) + return; + + grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + grub_gfxmenu_view_draw (term_view); + grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + + int termx = term_view->screen.x + + term_view->screen.width * (10 - 7) / 10 / 2; + int termy = term_view->screen.y + + term_view->screen.height * (10 - 7) / 10 / 2; + + grub_gfxmenu_box_t term_box = term_view->terminal_box; + if (term_box) + { + term_box->set_content_size (term_box, + term_target_width, term_target_height); + + term_box->draw (term_box, + termx - term_box->get_left_pad (term_box), + termy - term_box->get_top_pad (term_box)); + } + + grub_video_blit_render_target (term_target, GRUB_VIDEO_BLIT_REPLACE, + termx, termy, + 0, 0, term_target_width, term_target_height); + grub_video_swap_buffers (); +} + +static void +init_terminal (grub_gfxmenu_view_t view) +{ + term_original = grub_term_get_current_output (); + + term_target_width = view->screen.width * 7 / 10; + term_target_height = view->screen.height * 7 / 10; + + grub_video_create_render_target (&term_target, + term_target_width, + term_target_height, + GRUB_VIDEO_MODE_TYPE_RGB + | GRUB_VIDEO_MODE_TYPE_ALPHA); + if (grub_errno != GRUB_ERR_NONE) + return; + + /* Note: currently there is no API for changing the gfxterm font + on the fly, so whatever font the initially loaded theme specifies + will be permanent. */ + grub_gfxterm_init_window (term_target, 0, 0, + term_target_width, term_target_height, + view->terminal_font_name, 3); + if (grub_errno != GRUB_ERR_NONE) + return; + term_initialized = 1; + + /* XXX: store static pointer to the 'view' object so the repaint callback can access it. */ + term_view = view; + grub_gfxterm_set_repaint_callback (repaint_terminal); + grub_term_set_current_output (grub_gfxterm_get_term ()); +} + +static void destroy_terminal (void) +{ + term_view = 0; + if (term_initialized) + grub_gfxterm_destroy_window (); + grub_gfxterm_set_repaint_callback (0); + if (term_target) + grub_video_delete_render_target (term_target); + if (term_original) + grub_term_set_current_output (term_original); +} + + +static void +notify_booting (grub_menu_entry_t entry, void *userdata) +{ + grub_gfxmenu_view_t view = (grub_gfxmenu_view_t) userdata; + + char *s = grub_malloc (100 + grub_strlen (entry->title)); + if (!s) + return; + + grub_sprintf (s, "Booting '%s'", entry->title); + set_progress_message (view, s); + grub_free (s); + grub_gfxmenu_view_draw (view); + grub_video_swap_buffers (); +} + +static void +notify_fallback (grub_menu_entry_t entry, void *userdata) +{ + grub_gfxmenu_view_t view = (grub_gfxmenu_view_t) userdata; + + char *s = grub_malloc (100 + grub_strlen (entry->title)); + if (!s) + return; + + grub_sprintf (s, "Falling back to '%s'", entry->title); + set_progress_message (view, s); + grub_free (s); + grub_gfxmenu_view_draw (view); + grub_video_swap_buffers (); +} + +static void +notify_execution_failure (void *userdata __attribute__ ((unused))) +{ +} + + +static struct grub_menu_execute_callback execute_callback = +{ + .notify_booting = notify_booting, + .notify_fallback = notify_fallback, + .notify_failure = notify_execution_failure +}; + +int +grub_gfxmenu_view_execute_with_fallback (grub_gfxmenu_view_t view, + grub_menu_entry_t entry) +{ + grub_menu_execute_with_fallback (grub_gfxmenu_model_get_menu (view->model), + entry, &execute_callback, (void *) view); + + if (set_graphics_mode () != GRUB_ERR_NONE) + return 0; /* Failure. */ + + /* If we returned, there was a failure. */ + set_progress_message (view, + "Unable to automatically boot. " + "Press SPACE to continue."); + grub_gfxmenu_view_draw (view); + grub_video_swap_buffers (); + while (GRUB_TERM_ASCII_CHAR(grub_getkey ()) != ' ') + { + /* Wait for SPACE to be pressed. */ + } + + set_progress_message (view, 0); /* Clear the message. */ + + return 1; /* Ok. */ +} + +int +grub_gfxmenu_view_execute_entry (grub_gfxmenu_view_t view, + grub_menu_entry_t entry) +{ + /* Currently we switch back to text mode by restoring + the original terminal before executing the menu entry. + It is hard to make it work when executing a menu entry + that switches video modes -- it using gfxterm in a + window, the repaint callback seems to crash GRUB. */ + /* TODO: Determine if this works when 'gfxterm' was set as + the current terminal before invoking the gfxmenu. */ + destroy_terminal (); + + grub_menu_execute_entry (entry); + if (grub_errno != GRUB_ERR_NONE) + grub_wait_after_message (); + + if (set_graphics_mode () != GRUB_ERR_NONE) + return 0; /* Failure. */ + + init_terminal (view); + return 1; /* Ok. */ +} + +void +grub_gfxmenu_view_run_terminal (grub_gfxmenu_view_t view __attribute__((unused))) +{ + grub_cmdline_run (1); +} === added file 'gfxmenu/widget-box.c' --- gfxmenu/widget-box.c 1970-01-01 00:00:00 +0000 +++ gfxmenu/widget-box.c 2009-06-09 21:49:06 +0000 @@ -0,0 +1,313 @@ +/* widget_box.c - Pixmap-stylized box widget. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +enum box_pixmaps +{ + BOX_PIXMAP_NW, BOX_PIXMAP_NE, BOX_PIXMAP_SE, BOX_PIXMAP_SW, + BOX_PIXMAP_N, BOX_PIXMAP_E, BOX_PIXMAP_S, BOX_PIXMAP_W, + BOX_PIXMAP_CENTER +}; + +static const char *box_pixmap_names[] = { + /* Corners: */ + "nw", "ne", "se", "sw", + /* Sides: */ + "n", "e", "s", "w", + /* Center: */ + "c" +}; + +#define BOX_NUM_PIXMAPS (sizeof(box_pixmap_names)/sizeof(*box_pixmap_names)) + +static int +get_height (struct grub_video_bitmap *bitmap) +{ + if (bitmap) + return grub_video_bitmap_get_height (bitmap); + else + return 0; +} + +static int +get_width (struct grub_video_bitmap *bitmap) +{ + if (bitmap) + return grub_video_bitmap_get_width (bitmap); + else + return 0; +} + +static void +blit (grub_gfxmenu_box_t self, int pixmap_index, int x, int y) +{ + struct grub_video_bitmap *bitmap; + bitmap = self->scaled_pixmaps[pixmap_index]; + if (! bitmap) + return; + grub_video_blit_bitmap (bitmap, GRUB_VIDEO_BLIT_BLEND, + x, y, 0, 0, + grub_video_bitmap_get_width (bitmap), + grub_video_bitmap_get_height (bitmap)); +} + +static void +draw (grub_gfxmenu_box_t self, int x, int y) +{ + int height_n; + int height_s; + int height_e; + int height_w; + int width_n; + int width_s; + int width_e; + int width_w; + + height_n = get_height (self->scaled_pixmaps[BOX_PIXMAP_N]); + height_s = get_height (self->scaled_pixmaps[BOX_PIXMAP_S]); + height_e = get_height (self->scaled_pixmaps[BOX_PIXMAP_E]); + height_w = get_height (self->scaled_pixmaps[BOX_PIXMAP_W]); + width_n = get_width (self->scaled_pixmaps[BOX_PIXMAP_N]); + width_s = get_width (self->scaled_pixmaps[BOX_PIXMAP_S]); + width_e = get_width (self->scaled_pixmaps[BOX_PIXMAP_E]); + width_w = get_width (self->scaled_pixmaps[BOX_PIXMAP_W]); + + /* Draw sides. */ + blit (self, BOX_PIXMAP_N, x + width_w, y); + blit (self, BOX_PIXMAP_S, x + width_w, y + height_n + self->content_height); + blit (self, BOX_PIXMAP_E, x + width_w + self->content_width, y + height_n); + blit (self, BOX_PIXMAP_W, x, y + height_n); + + /* Draw corners. */ + blit (self, BOX_PIXMAP_NW, x, y); + blit (self, BOX_PIXMAP_NE, x + width_w + self->content_width, y); + blit (self, BOX_PIXMAP_SE, + x + width_w + self->content_width, + y + height_n + self->content_height); + blit (self, BOX_PIXMAP_SW, x, y + height_n + self->content_height); + + /* Draw center. */ + blit (self, BOX_PIXMAP_CENTER, x + width_w, y + height_n); +} + +static grub_err_t +scale_pixmap (grub_gfxmenu_box_t self, int i, int w, int h) +{ + struct grub_video_bitmap **scaled = &self->scaled_pixmaps[i]; + struct grub_video_bitmap *raw = self->raw_pixmaps[i]; + + if (raw == 0) + return grub_errno; + + if (w == -1) + w = grub_video_bitmap_get_width (raw); + if (h == -1) + h = grub_video_bitmap_get_height (raw); + + if (*scaled == 0 + || ((int) grub_video_bitmap_get_width (*scaled) != w) + || ((int) grub_video_bitmap_get_height (*scaled) != h)) + { + if (*scaled) + { + grub_video_bitmap_destroy (*scaled); + *scaled = 0; + } + + /* Don't try to create a bitmap with a zero dimension. */ + if (w != 0 && h != 0) + grub_video_bitmap_create_scaled (scaled, w, h, raw, + GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST); + if (grub_errno != GRUB_ERR_NONE) + { + grub_error_push (); + grub_error (grub_errno, + "failed to scale bitmap for styled box pixmap #%d", i); + } + } + + return grub_errno; +} + +static void +set_content_size (grub_gfxmenu_box_t self, + int width, int height) +{ + self->content_width = width; + self->content_height = height; + + /* Resize sides to match the width and height. */ + /* It is assumed that the corners width/height match the adjacent sides. */ + + /* Resize N and S sides to match width. */ + if (scale_pixmap(self, BOX_PIXMAP_N, width, -1) != GRUB_ERR_NONE) + return; + if (scale_pixmap(self, BOX_PIXMAP_S, width, -1) != GRUB_ERR_NONE) + return; + + /* Resize E and W sides to match height. */ + if (scale_pixmap(self, BOX_PIXMAP_E, -1, height) != GRUB_ERR_NONE) + return; + if (scale_pixmap(self, BOX_PIXMAP_W, -1, height) != GRUB_ERR_NONE) + return; + + /* Don't scale the corners--they are assumed to match the sides. */ + if (scale_pixmap(self, BOX_PIXMAP_NW, -1, -1) != GRUB_ERR_NONE) + return; + if (scale_pixmap(self, BOX_PIXMAP_SW, -1, -1) != GRUB_ERR_NONE) + return; + if (scale_pixmap(self, BOX_PIXMAP_NE, -1, -1) != GRUB_ERR_NONE) + return; + if (scale_pixmap(self, BOX_PIXMAP_SE, -1, -1) != GRUB_ERR_NONE) + return; + + /* Scale the center area. */ + if (scale_pixmap(self, BOX_PIXMAP_CENTER, width, height) != GRUB_ERR_NONE) + return; +} + +static int +get_left_pad (grub_gfxmenu_box_t self) +{ + return get_width (self->raw_pixmaps[BOX_PIXMAP_W]); +} + +static int +get_top_pad (grub_gfxmenu_box_t self) +{ + return get_height (self->raw_pixmaps[BOX_PIXMAP_N]); +} + +static int +get_right_pad (grub_gfxmenu_box_t self) +{ + return get_width (self->raw_pixmaps[BOX_PIXMAP_E]); +} + +static int +get_bottom_pad (grub_gfxmenu_box_t self) +{ + return get_height (self->raw_pixmaps[BOX_PIXMAP_S]); +} + +static void +destroy (grub_gfxmenu_box_t self) +{ + int i; + for (i = 0; i < BOX_NUM_PIXMAPS; i++) + { + if (self->raw_pixmaps[i]) + grub_video_bitmap_destroy(self->raw_pixmaps[i]); + self->raw_pixmaps[i] = 0; + + if (self->scaled_pixmaps[i]) + grub_video_bitmap_destroy(self->scaled_pixmaps[i]); + self->scaled_pixmaps[i] = 0; + } + grub_free (self->raw_pixmaps); + self->raw_pixmaps = 0; + grub_free (self->scaled_pixmaps); + self->scaled_pixmaps = 0; + + /* Free self: must be the last step! */ + grub_free (self); +} + + +/* Create a new box. If PIXMAPS_PREFIX and PIXMAPS_SUFFIX are both non-null, + then an attempt is made to load the north, south, east, west, northwest, + northeast, southeast, southwest, and center pixmaps. + If either PIXMAPS_PREFIX or PIXMAPS_SUFFIX is 0, then no pixmaps are + loaded, and the box has zero-width borders and is drawn transparent. */ +grub_gfxmenu_box_t +grub_gfxmenu_create_box (const char *pixmaps_prefix, + const char *pixmaps_suffix) +{ + int i; + grub_gfxmenu_box_t box; + + box = (grub_gfxmenu_box_t) grub_malloc (sizeof (*box)); + if (! box) + return 0; + + box->content_width = 0; + box->content_height = 0; + box->raw_pixmaps = + (struct grub_video_bitmap **) + grub_malloc (BOX_NUM_PIXMAPS * sizeof (struct grub_video_bitmap *)); + box->scaled_pixmaps = + (struct grub_video_bitmap **) + grub_malloc (BOX_NUM_PIXMAPS * sizeof (struct grub_video_bitmap *)); + + /* Initialize all pixmap pointers to NULL so that proper destruction can + be performed if an error is encountered partway through construction. */ + for (i = 0; i < BOX_NUM_PIXMAPS; i++) + box->raw_pixmaps[i] = 0; + for (i = 0; i < BOX_NUM_PIXMAPS; i++) + box->scaled_pixmaps[i] = 0; + + /* Load the pixmaps. */ + for (i = 0; i < BOX_NUM_PIXMAPS; i++) + { + if (pixmaps_prefix && pixmaps_suffix) + { + char *path; + char *path_end; + + path = grub_malloc (grub_strlen (pixmaps_prefix) + + grub_strlen (box_pixmap_names[i]) + + grub_strlen (pixmaps_suffix) + + 1); + if (! path) + goto fail_and_destroy; + + /* Construct the specific path for this pixmap. */ + path_end = grub_stpcpy (path, pixmaps_prefix); + path_end = grub_stpcpy (path_end, box_pixmap_names[i]); + path_end = grub_stpcpy (path_end, pixmaps_suffix); + + grub_video_bitmap_load (&box->raw_pixmaps[i], path); + grub_free (path); + + /* Ignore missing pixmaps. */ + grub_errno = GRUB_ERR_NONE; + } + } + + box->draw = draw; + box->set_content_size = set_content_size; + box->get_left_pad = get_left_pad; + box->get_top_pad = get_top_pad; + box->get_right_pad = get_right_pad; + box->get_bottom_pad = get_bottom_pad; + box->destroy = destroy; + return box; + +fail_and_destroy: + destroy (box); + return 0; +} === added file 'include/grub/bitmap_scale.h' --- include/grub/bitmap_scale.h 1970-01-01 00:00:00 +0000 +++ include/grub/bitmap_scale.h 2009-01-31 20:28:17 +0000 @@ -0,0 +1,48 @@ +/* bitmap_scale.h - Bitmap scaling functions. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#ifndef GRUB_BITMAP_SCALE_HEADER +#define GRUB_BITMAP_SCALE_HEADER 1 + +#include +#include +#include + +enum grub_video_bitmap_scale_method +{ + /* Choose the fastest interpolation algorithm. */ + GRUB_VIDEO_BITMAP_SCALE_METHOD_FASTEST, + /* Choose the highest quality interpolation algorithm. */ + GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST, + + /* Specific algorithms: */ + /* Nearest neighbor interpolation. */ + GRUB_VIDEO_BITMAP_SCALE_METHOD_NEAREST, + /* Bilinear interpolation. */ + GRUB_VIDEO_BITMAP_SCALE_METHOD_BILINEAR +}; + +grub_err_t +grub_video_bitmap_create_scaled (struct grub_video_bitmap **dst, + int dst_width, int dst_height, + struct grub_video_bitmap *src, + enum + grub_video_bitmap_scale_method scale_method); + +#endif /* ! GRUB_BITMAP_SCALE_HEADER */ === added file 'include/grub/gfxmenu_model.h' --- include/grub/gfxmenu_model.h 1970-01-01 00:00:00 +0000 +++ include/grub/gfxmenu_model.h 2008-07-26 23:37:04 +0000 @@ -0,0 +1,59 @@ +/* gfxmenu_model.h - gfxmenu model interface. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#ifndef GRUB_GFXMENU_MODEL_HEADER +#define GRUB_GFXMENU_MODEL_HEADER 1 + +#include + +struct grub_gfxmenu_model; /* Forward declaration of opaque type. */ +typedef struct grub_gfxmenu_model *grub_gfxmenu_model_t; + + +grub_gfxmenu_model_t grub_gfxmenu_model_new (grub_menu_t menu); + +void grub_gfxmenu_model_destroy (grub_gfxmenu_model_t model); + +grub_menu_t grub_gfxmenu_model_get_menu (grub_gfxmenu_model_t model); + +void grub_gfxmenu_model_set_timeout (grub_gfxmenu_model_t model); + +void grub_gfxmenu_model_clear_timeout (grub_gfxmenu_model_t model); + +int grub_gfxmenu_model_get_timeout_ms (grub_gfxmenu_model_t model); + +int grub_gfxmenu_model_get_timeout_remaining_ms (grub_gfxmenu_model_t model); + +int grub_gfxmenu_model_timeout_expired (grub_gfxmenu_model_t model); + +int grub_gfxmenu_model_get_num_entries (grub_gfxmenu_model_t model); + +int grub_gfxmenu_model_get_selected_index (grub_gfxmenu_model_t model); + +void grub_gfxmenu_model_set_selected_index (grub_gfxmenu_model_t model, + int index); + +const char *grub_gfxmenu_model_get_entry_title (grub_gfxmenu_model_t model, + int index); + +grub_menu_entry_t grub_gfxmenu_model_get_entry (grub_gfxmenu_model_t model, + int index); + +#endif /* GRUB_GFXMENU_MODEL_HEADER */ + === added file 'include/grub/gfxmenu_view.h' --- include/grub/gfxmenu_view.h 1970-01-01 00:00:00 +0000 +++ include/grub/gfxmenu_view.h 2009-06-09 21:49:06 +0000 @@ -0,0 +1,91 @@ +/* gfxmenu_view.h - gfxmenu view interface. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#ifndef GRUB_GFXMENU_VIEW_HEADER +#define GRUB_GFXMENU_VIEW_HEADER 1 + +#include +#include +#include +#include +#include +#include + +struct grub_gfxmenu_view; /* Forward declaration of opaque type. */ +typedef struct grub_gfxmenu_view *grub_gfxmenu_view_t; + + +grub_gfxmenu_view_t grub_gfxmenu_view_new (const char *theme_path, + grub_gfxmenu_model_t model); + +void grub_gfxmenu_view_destroy (grub_gfxmenu_view_t view); + +/* Set properties on the view based on settings from the specified + theme file. */ +grub_err_t grub_gfxmenu_view_load_theme (grub_gfxmenu_view_t view, + const char *theme_path); + +grub_err_t grub_gui_recreate_box (grub_gfxmenu_box_t *boxptr, + const char *pattern, const char *theme_dir); + +void grub_gfxmenu_view_draw (grub_gfxmenu_view_t view); + +int grub_gfxmenu_view_execute_with_fallback (grub_gfxmenu_view_t view, + grub_menu_entry_t entry); + +int grub_gfxmenu_view_execute_entry (grub_gfxmenu_view_t view, + grub_menu_entry_t entry); + +void grub_gfxmenu_view_run_terminal (grub_gfxmenu_view_t view); + + + +/* Implementation details -- this should not be used outside of the + view itself. */ + +#include +#include +#include +#include +#include + +/* Definition of the private representation of the view. */ +struct grub_gfxmenu_view +{ + grub_video_rect_t screen; + + grub_font_t title_font; + grub_font_t message_font; + char *terminal_font_name; + grub_gui_color_t title_color; + grub_gui_color_t message_color; + grub_gui_color_t message_bg_color; + struct grub_video_bitmap *desktop_image; + grub_gui_color_t desktop_color; + grub_gfxmenu_box_t terminal_box; + char *title_text; + char *progress_message_text; + char *theme_path; + + grub_gui_container_t canvas; + + grub_gfxmenu_model_t model; +}; + +#endif /* ! GRUB_GFXMENU_VIEW_HEADER */ === added file 'include/grub/gfxterm.h' --- include/grub/gfxterm.h 1970-01-01 00:00:00 +0000 +++ include/grub/gfxterm.h 2009-01-19 17:29:32 +0000 @@ -0,0 +1,41 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2006,2007,2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#ifndef GRUB_GFXTERM_HEADER +#define GRUB_GFXTERM_HEADER 1 + +#include +#include +#include +#include + +grub_err_t +grub_gfxterm_init_window (struct grub_video_render_target *target, + int x, int y, int width, int height, + const char *font_name, int border_width); + +void grub_gfxterm_destroy_window (void); + +grub_term_output_t grub_gfxterm_get_term (void); + +typedef void (*grub_gfxterm_repaint_callback_t)(int x, int y, + int width, int height); + +void grub_gfxterm_set_repaint_callback (grub_gfxterm_repaint_callback_t func); + +#endif /* ! GRUB_GFXTERM_HEADER */ === added file 'include/grub/gfxwidgets.h' --- include/grub/gfxwidgets.h 1970-01-01 00:00:00 +0000 +++ include/grub/gfxwidgets.h 2008-08-15 04:57:08 +0000 @@ -0,0 +1,49 @@ +/* gfxwidgets.h - Widgets for the graphical menu (gfxmenu). */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#ifndef GRUB_GFXWIDGETS_HEADER +#define GRUB_GFXWIDGETS_HEADER 1 + +#include + +typedef struct grub_gfxmenu_box *grub_gfxmenu_box_t; + +struct grub_gfxmenu_box +{ + /* The size of the content. */ + int content_width; + int content_height; + + struct grub_video_bitmap **raw_pixmaps; + struct grub_video_bitmap **scaled_pixmaps; + + void (*draw) (grub_gfxmenu_box_t self, int x, int y); + void (*set_content_size) (grub_gfxmenu_box_t self, + int width, int height); + int (*get_left_pad) (grub_gfxmenu_box_t self); + int (*get_top_pad) (grub_gfxmenu_box_t self); + int (*get_right_pad) (grub_gfxmenu_box_t self); + int (*get_bottom_pad) (grub_gfxmenu_box_t self); + void (*destroy) (grub_gfxmenu_box_t self); +}; + +grub_gfxmenu_box_t grub_gfxmenu_create_box (const char *pixmaps_prefix, + const char *pixmaps_suffix); + +#endif /* ! GRUB_GFXWIDGETS_HEADER */ === added file 'include/grub/gui.h' --- include/grub/gui.h 1970-01-01 00:00:00 +0000 +++ include/grub/gui.h 2009-06-09 21:49:06 +0000 @@ -0,0 +1,165 @@ +/* gui.h - GUI components header file. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include + +#ifndef GRUB_GUI_H +#define GRUB_GUI_H 1 + +/* A representation of a color. Unlike grub_video_color_t, this + representation is independent of any video mode specifics. */ +typedef struct grub_gui_color +{ + grub_uint8_t red; + grub_uint8_t green; + grub_uint8_t blue; + grub_uint8_t alpha; +} grub_gui_color_t; + +typedef struct grub_gui_component *grub_gui_component_t; +typedef struct grub_gui_container *grub_gui_container_t; +typedef struct grub_gui_list *grub_gui_list_t; + +typedef void (*grub_gui_component_callback) (grub_gui_component_t component, + void *userdata); + +/* Component interface. */ + +struct grub_gui_component_ops +{ + void (*destroy) (void *self); + const char * (*get_id) (void *self); + int (*is_instance) (void *self, const char *type); + void (*paint) (void *self); + void (*set_parent) (void *self, grub_gui_container_t parent); + grub_gui_container_t (*get_parent) (void *self); + void (*set_bounds) (void *self, const grub_video_rect_t *bounds); + void (*get_bounds) (void *self, grub_video_rect_t *bounds); + void (*get_preferred_size) (void *self, int *width, int *height); + grub_err_t (*set_property) (void *self, const char *name, const char *value); +}; + +struct grub_gui_container_ops +{ + struct grub_gui_component_ops component; + void (*add) (void *self, grub_gui_component_t comp); + void (*remove) (void *self, grub_gui_component_t comp); + void (*iterate_children) (void *self, + grub_gui_component_callback cb, void *userdata); +}; + +struct grub_gui_list_ops +{ + struct grub_gui_component_ops component_ops; + void (*set_view_info) (void *self, + const char *theme_path, + grub_gfxmenu_model_t menu); +}; + +struct grub_gui_component +{ + struct grub_gui_component_ops *ops; +}; + +struct grub_gui_container +{ + struct grub_gui_container_ops *ops; +}; + +struct grub_gui_list +{ + struct grub_gui_list_ops *ops; +}; + + +/* Interfaces to concrete component classes. */ + +grub_gui_container_t grub_gui_canvas_new (void); +grub_gui_container_t grub_gui_vbox_new (void); +grub_gui_container_t grub_gui_hbox_new (void); +grub_gui_component_t grub_gui_label_new (void); +grub_gui_component_t grub_gui_image_new (void); +grub_gui_component_t grub_gui_progress_bar_new (void); +grub_gui_component_t grub_gui_list_new (void); +grub_gui_component_t grub_gui_circular_progress_new (void); + +/* Manipulation functions. */ + +/* Visit all components with the specified ID. */ +void grub_gui_find_by_id (grub_gui_component_t root, + const char *id, + grub_gui_component_callback cb, + void *userdata); + +/* Visit all components. */ +void grub_gui_iterate_recursively (grub_gui_component_t root, + grub_gui_component_callback cb, + void *userdata); + +/* Helper functions. */ + +static __inline void +grub_gui_save_viewport (grub_video_rect_t *r) +{ + grub_video_get_viewport ((unsigned *) &r->x, + (unsigned *) &r->y, + (unsigned *) &r->width, + (unsigned *) &r->height); +} + +static __inline void +grub_gui_restore_viewport (const grub_video_rect_t *r) +{ + grub_video_set_viewport (r->x, r->y, r->width, r->height); +} + +/* Set a new viewport relative the the current one, saving the current + viewport in OLD so it can be later restored. */ +static __inline void +grub_gui_set_viewport (const grub_video_rect_t *r, grub_video_rect_t *old) +{ + grub_gui_save_viewport (old); + grub_video_set_viewport (old->x + r->x, + old->y + r->y, + r->width, + r->height); +} + +static __inline grub_gui_color_t +grub_gui_color_rgb (int r, int g, int b) +{ + grub_gui_color_t c; + c.red = r; + c.green = g; + c.blue = b; + c.alpha = 255; + return c; +} + +static __inline grub_video_color_t +grub_gui_map_color (grub_gui_color_t c) +{ + return grub_video_map_rgba (c.red, c.green, c.blue, c.alpha); +} + +#endif /* ! GRUB_GUI_H */ === added file 'include/grub/gui_string_util.h' --- include/grub/gui_string_util.h 1970-01-01 00:00:00 +0000 +++ include/grub/gui_string_util.h 2009-06-09 21:49:06 +0000 @@ -0,0 +1,39 @@ +/* gui_string_util.h - String utilities for the graphical menu interface. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#ifndef GRUB_GUI_STRING_UTIL_HEADER +#define GRUB_GUI_STRING_UTIL_HEADER 1 + +#include +#include + +char *grub_new_substring (const char *buf, + grub_size_t start, grub_size_t end); + +char *grub_resolve_relative_path (const char *base, const char *path); + +char *grub_get_dirname (const char *file_path); + +int grub_gui_get_named_color (const char *name, grub_gui_color_t *color); + +grub_err_t grub_gui_parse_color (const char *s, grub_gui_color_t *color); + +grub_err_t grub_gui_parse_2_tuple (const char *s, int *px, int *py); + +#endif /* GRUB_GUI_STRING_UTIL_HEADER */ === added file 'include/grub/icon_manager.h' --- include/grub/icon_manager.h 1970-01-01 00:00:00 +0000 +++ include/grub/icon_manager.h 2008-08-14 16:32:41 +0000 @@ -0,0 +1,41 @@ +/* icon_manager.h - gfxmenu icon manager. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#ifndef GRUB_ICON_MANAGER_HEADER +#define GRUB_ICON_MANAGER_HEADER 1 + +#include +#include + +/* Forward declaration of opaque structure handle type. */ +typedef struct grub_gfxmenu_icon_manager *grub_gfxmenu_icon_manager_t; + +grub_gfxmenu_icon_manager_t grub_gfxmenu_icon_manager_new (void); +void grub_gfxmenu_icon_manager_destroy (grub_gfxmenu_icon_manager_t mgr); +void grub_gfxmenu_icon_manager_clear_cache (grub_gfxmenu_icon_manager_t mgr); +void grub_gfxmenu_icon_manager_set_theme_path (grub_gfxmenu_icon_manager_t mgr, + const char *path); +void grub_gfxmenu_icon_manager_set_icon_size (grub_gfxmenu_icon_manager_t mgr, + int width, int height); +struct grub_video_bitmap * +grub_gfxmenu_icon_manager_get_icon (grub_gfxmenu_icon_manager_t mgr, + grub_menu_entry_t entry); + +#endif /* GRUB_ICON_MANAGER_HEADER */ + === modified file 'include/grub/menu.h' --- include/grub/menu.h 2009-05-23 17:07:17 +0000 +++ include/grub/menu.h 2009-05-24 08:59:48 +0000 @@ -81,6 +81,7 @@ grub_menu_entry_t grub_menu_get_entry (grub_menu_t menu, int no); int grub_menu_get_timeout (void); void grub_menu_set_timeout (int timeout); +int grub_menu_get_default_entry_index (grub_menu_t menu); void grub_menu_execute_entry (grub_menu_entry_t entry); void grub_menu_execute_with_fallback (grub_menu_t menu, grub_menu_entry_t entry, === modified file 'include/grub/menu_viewer.h' --- include/grub/menu_viewer.h 2009-01-31 09:15:43 +0000 +++ include/grub/menu_viewer.h 2009-01-31 17:03:28 +0000 @@ -36,8 +36,13 @@ }; typedef struct grub_menu_viewer *grub_menu_viewer_t; +void grub_menu_viewer_init (void); + void grub_menu_viewer_register (grub_menu_viewer_t viewer); grub_err_t grub_menu_viewer_show_menu (grub_menu_t menu, int nested); +/* Return nonzero iff the menu viewer should clean up and return ASAP. */ +int grub_menu_viewer_should_return (void); + #endif /* GRUB_MENU_VIEWER_HEADER */ === modified file 'include/grub/misc.h' --- include/grub/misc.h 2009-06-04 20:17:05 +0000 +++ include/grub/misc.h 2009-06-08 06:46:58 +0000 @@ -1,7 +1,7 @@ /* misc.h - prototypes for misc functions */ /* * GRUB -- GRand Unified Bootloader - * Copyright (C) 2002,2003,2005,2006,2007,2008,2009,2008 Free Software Foundation, Inc. + * Copyright (C) 2002,2003,2005,2006,2007,2008,2009 Free Software Foundation, Inc. * * GRUB is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -56,11 +56,14 @@ char *EXPORT_FUNC(grub_strstr) (const char *haystack, const char *needle); int EXPORT_FUNC(grub_iswordseparator) (int c); int EXPORT_FUNC(grub_isspace) (int c); +int EXPORT_FUNC(grub_iscntrl) (int c); int EXPORT_FUNC(grub_isprint) (int c); int EXPORT_FUNC(grub_isalpha) (int c); +int EXPORT_FUNC(grub_isalnum) (int c); int EXPORT_FUNC(grub_isgraph) (int c); int EXPORT_FUNC(grub_isdigit) (int c); int EXPORT_FUNC(grub_tolower) (int c); +long EXPORT_FUNC(grub_strtol) (const char *str, char **end, int base); unsigned long EXPORT_FUNC(grub_strtoul) (const char *str, char **end, int base); unsigned long long EXPORT_FUNC(grub_strtoull) (const char *str, char **end, int base); char *EXPORT_FUNC(grub_strdup) (const char *s); === added file 'include/grub/trig.h' --- include/grub/trig.h 1970-01-01 00:00:00 +0000 +++ include/grub/trig.h 2008-08-15 23:59:38 +0000 @@ -0,0 +1,44 @@ +/* trig.h - Trigonometric function support. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#ifndef GRUB_TRIG_HEADER +#define GRUB_TRIG_HEADER 1 + +#define GRUB_TRIG_ANGLE_MAX 256 +#define GRUB_TRIG_ANGLE_MASK 255 +#define GRUB_TRIG_FRACTION_SCALE 16384 + +extern short grub_trig_sintab[]; +extern short grub_trig_costab[]; + +static __inline int +grub_sin (int x) +{ + x &= GRUB_TRIG_ANGLE_MASK; + return grub_trig_sintab[x]; +} + +static __inline int +grub_cos (int x) +{ + x &= GRUB_TRIG_ANGLE_MASK; + return grub_trig_costab[x]; +} + +#endif /* ! GRUB_TRIG_HEADER */ === modified file 'include/grub/video.h' --- include/grub/video.h 2009-06-10 20:04:23 +0000 +++ include/grub/video.h 2009-06-13 13:42:27 +0000 @@ -48,10 +48,10 @@ #define GRUB_VIDEO_MODE_TYPE_DEPTH_MASK 0x0000ff00 #define GRUB_VIDEO_MODE_TYPE_DEPTH_POS 8 -/* Defined predefined render targets. */ -#define GRUB_VIDEO_RENDER_TARGET_DISPLAY ((struct grub_video_render_target *) 0) -#define GRUB_VIDEO_RENDER_TARGET_FRONT_BUFFER ((struct grub_video_render_target *) 0) -#define GRUB_VIDEO_RENDER_TARGET_BACK_BUFFER ((struct grub_video_render_target *) 1) +/* The basic render target representing the whole display. This always + renders to the back buffer when double-buffering is in use. */ +#define GRUB_VIDEO_RENDER_TARGET_DISPLAY \ + ((struct grub_video_render_target *) 0) /* Defined blitting formats. */ enum grub_video_blit_format @@ -161,6 +161,16 @@ grub_uint8_t a; /* Reserved bits value (0-255). */ }; +/* A 2D rectangle type. */ +struct grub_video_rect +{ + int x; + int y; + int width; + int height; +}; +typedef struct grub_video_rect grub_video_rect_t; + struct grub_video_adapter { /* The video adapter name. */ @@ -218,6 +228,8 @@ grub_err_t (*swap_buffers) (void); + grub_err_t (*enable_double_buffering) (int enable); + grub_err_t (*create_render_target) (struct grub_video_render_target **result, unsigned int width, unsigned int height, unsigned int mode_type); @@ -286,6 +298,8 @@ grub_err_t grub_video_swap_buffers (void); +grub_err_t grub_video_enable_double_buffering (int enable); + grub_err_t grub_video_create_render_target (struct grub_video_render_target **result, unsigned int width, unsigned int height, @@ -297,7 +311,7 @@ grub_err_t grub_video_get_active_render_target (struct grub_video_render_target **target); -grub_err_t grub_video_set_mode (char *modestring, +grub_err_t grub_video_set_mode (const char *modestring, int NESTED_FUNC_ATTR (*hook) (grub_video_adapter_t p, struct grub_video_mode_info *mode_info)); === modified file 'kern/misc.c' --- kern/misc.c 2009-06-11 20:39:03 +0000 +++ kern/misc.c 2009-06-13 13:42:27 +0000 @@ -407,6 +407,12 @@ } int +grub_iscntrl (int c) +{ + return (c >= 0x00 && c <= 0x1F) || c == 0x7F; +} + +int grub_isprint (int c) { return (c >= ' ' && c <= '~'); @@ -419,6 +425,12 @@ } int +grub_isalnum (int c) +{ + return grub_isalpha (c) || grub_isdigit (c); +} + +int grub_isdigit (int c) { return (c >= '0' && c <= '9'); @@ -439,6 +451,41 @@ return c; } +long +grub_strtol (const char *str, char **end, int base) +{ + int negative = 0; + + while (*str && grub_isspace (*str)) + str++; + + if (*str == '-') + { + negative = 1; + str++; + } + + unsigned long long magnitude; + magnitude = grub_strtoull (str, end, base); + if (negative) + { + if (magnitude > -((long long) GRUB_LONG_MIN)) + { + grub_error (GRUB_ERR_OUT_OF_RANGE, "negative overflow"); + return GRUB_LONG_MIN; + } + return -((long long) magnitude); + } + else + { + if (magnitude > GRUB_LONG_MAX) + { + grub_error (GRUB_ERR_OUT_OF_RANGE, "positive overflow"); + return GRUB_LONG_MAX; + } + return (long) magnitude; + } +} unsigned long grub_strtoul (const char *str, char **end, int base) === added file 'lib/trig.c' --- lib/trig.c 1970-01-01 00:00:00 +0000 +++ lib/trig.c 2008-08-15 23:59:38 +0000 @@ -0,0 +1,83 @@ +/* trig.c - Trigonometric table definitions. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include + +/* These tables were generated with `gentrigtables.py'. */ + +short grub_trig_sintab[] = +{ + 0,402,804,1205,1606,2006,2404,2801,3196,3590, + 3981,4370,4756,5139,5520,5897,6270,6639,7005,7366, + 7723,8076,8423,8765,9102,9434,9760,10080,10394,10702, + 11003,11297,11585,11866,12140,12406,12665,12916,13160,13395, + 13623,13842,14053,14256,14449,14635,14811,14978,15137,15286, + 15426,15557,15679,15791,15893,15986,16069,16143,16207,16261, + 16305,16340,16364,16379,16384,16379,16364,16340,16305,16261, + 16207,16143,16069,15986,15893,15791,15679,15557,15426,15286, + 15137,14978,14811,14635,14449,14256,14053,13842,13623,13395, + 13160,12916,12665,12406,12140,11866,11585,11297,11003,10702, + 10394,10080,9760,9434,9102,8765,8423,8076,7723,7366, + 7005,6639,6270,5897,5520,5139,4756,4370,3981,3590, + 3196,2801,2404,2006,1606,1205,804,402,0,-402, + -804,-1205,-1606,-2006,-2404,-2801,-3196,-3590,-3981,-4370, + -4756,-5139,-5520,-5897,-6270,-6639,-7005,-7366,-7723,-8076, + -8423,-8765,-9102,-9434,-9760,-10080,-10394,-10702,-11003,-11297, + -11585,-11866,-12140,-12406,-12665,-12916,-13160,-13395,-13623,-13842, + -14053,-14256,-14449,-14635,-14811,-14978,-15137,-15286,-15426,-15557, + -15679,-15791,-15893,-15986,-16069,-16143,-16207,-16261,-16305,-16340, + -16364,-16379,-16384,-16379,-16364,-16340,-16305,-16261,-16207,-16143, + -16069,-15986,-15893,-15791,-15679,-15557,-15426,-15286,-15137,-14978, + -14811,-14635,-14449,-14256,-14053,-13842,-13623,-13395,-13160,-12916, + -12665,-12406,-12140,-11866,-11585,-11297,-11003,-10702,-10394,-10080, + -9760,-9434,-9102,-8765,-8423,-8076,-7723,-7366,-7005,-6639, + -6270,-5897,-5520,-5139,-4756,-4370,-3981,-3590,-3196,-2801, + -2404,-2006,-1606,-1205,-804,-402 +}; + +short grub_trig_costab[] = +{ + 16384,16379,16364,16340,16305,16261,16207,16143,16069,15986, + 15893,15791,15679,15557,15426,15286,15137,14978,14811,14635, + 14449,14256,14053,13842,13623,13395,13160,12916,12665,12406, + 12140,11866,11585,11297,11003,10702,10394,10080,9760,9434, + 9102,8765,8423,8076,7723,7366,7005,6639,6270,5897, + 5520,5139,4756,4370,3981,3590,3196,2801,2404,2006, + 1606,1205,804,402,0,-402,-804,-1205,-1606,-2006, + -2404,-2801,-3196,-3590,-3981,-4370,-4756,-5139,-5520,-5897, + -6270,-6639,-7005,-7366,-7723,-8076,-8423,-8765,-9102,-9434, + -9760,-10080,-10394,-10702,-11003,-11297,-11585,-11866,-12140,-12406, + -12665,-12916,-13160,-13395,-13623,-13842,-14053,-14256,-14449,-14635, + -14811,-14978,-15137,-15286,-15426,-15557,-15679,-15791,-15893,-15986, + -16069,-16143,-16207,-16261,-16305,-16340,-16364,-16379,-16384,-16379, + -16364,-16340,-16305,-16261,-16207,-16143,-16069,-15986,-15893,-15791, + -15679,-15557,-15426,-15286,-15137,-14978,-14811,-14635,-14449,-14256, + -14053,-13842,-13623,-13395,-13160,-12916,-12665,-12406,-12140,-11866, + -11585,-11297,-11003,-10702,-10394,-10080,-9760,-9434,-9102,-8765, + -8423,-8076,-7723,-7366,-7005,-6639,-6270,-5897,-5520,-5139, + -4756,-4370,-3981,-3590,-3196,-2801,-2404,-2006,-1606,-1205, + -804,-402,0,402,804,1205,1606,2006,2404,2801, + 3196,3590,3981,4370,4756,5139,5520,5897,6270,6639, + 7005,7366,7723,8076,8423,8765,9102,9434,9760,10080, + 10394,10702,11003,11297,11585,11866,12140,12406,12665,12916, + 13160,13395,13623,13842,14053,14256,14449,14635,14811,14978, + 15137,15286,15426,15557,15679,15791,15893,15986,16069,16143, + 16207,16261,16305,16340,16364,16379 +}; + === modified file 'normal/main.c' --- normal/main.c 2009-06-10 20:04:23 +0000 +++ normal/main.c 2009-06-13 13:42:27 +0000 @@ -561,6 +561,8 @@ /* Preserve hooks after context changes. */ grub_env_export ("color_normal"); grub_env_export ("color_highlight"); + + grub_menu_viewer_init (); } GRUB_MOD_FINI(normal) === modified file 'normal/menu.c' --- normal/menu.c 2009-05-04 19:06:05 +0000 +++ normal/menu.c 2009-05-16 16:43:20 +0000 @@ -82,6 +82,48 @@ } } +/* Get the entry number from the environment variable NAME. */ +static int +get_entry_number (const char *name) +{ + char *val; + int entry; + + val = grub_env_get (name); + if (! val) + return -1; + + grub_error_push (); + + entry = (int) grub_strtoul (val, 0, 0); + + if (grub_errno != GRUB_ERR_NONE) + { + grub_errno = GRUB_ERR_NONE; + entry = -1; + } + + grub_error_pop (); + + return entry; +} + +/* Get the default menu entry index. */ +int +grub_menu_get_default_entry_index (grub_menu_t menu) +{ + int i; + + i = get_entry_number ("default"); + + /* If DEFAULT_ENTRY is not within the menu entries, fall back to + the first entry. */ + if (i < 0 || i >= menu->size) + i = 0; + + return i; +} + /* Get the first entry number from the value of the environment variable NAME, which is a space-separated list of non-negative integers. The entry number which is returned is stripped from the value of NAME. If no entry number === modified file 'normal/menu_text.c' --- normal/menu_text.c 2009-05-02 18:49:34 +0000 +++ normal/menu_text.c 2009-05-16 16:43:20 +0000 @@ -124,7 +124,7 @@ return; len = grub_utf8_to_ucs4 (unicode_title, title_len, - (grub_uint8_t *) title, -1, 0); + (grub_uint8_t *) title, -1, 0); if (len < 0) { /* It is an invalid sequence. */ @@ -235,32 +235,6 @@ print_message (nested, edit); } -/* Get the entry number from the variable NAME. */ -static int -get_entry_number (const char *name) -{ - char *val; - int entry; - - val = grub_env_get (name); - if (! val) - return -1; - - grub_error_push (); - - entry = (int) grub_strtoul (val, 0, 0); - - if (grub_errno != GRUB_ERR_NONE) - { - grub_errno = GRUB_ERR_NONE; - entry = -1; - } - - grub_error_pop (); - - return entry; -} - static void print_timeout (int timeout, int offset, int second_stage) { @@ -291,12 +265,7 @@ first = 0; - default_entry = get_entry_number ("default"); - - /* If DEFAULT_ENTRY is not within the menu entries, fall back to - the first entry. */ - if (default_entry < 0 || default_entry >= menu->size) - default_entry = 0; + default_entry = grub_menu_get_default_entry_index (menu); /* If timeout is 0, drawing is pointless (and ugly). */ if (grub_menu_get_timeout () == 0) @@ -326,7 +295,7 @@ if (timeout > 0) print_timeout (timeout, offset, 0); - while (1) + while (! grub_menu_viewer_should_return ()) { int c; timeout = grub_menu_get_timeout (); @@ -348,7 +317,7 @@ if (timeout == 0) { grub_env_unset ("timeout"); - *auto_boot = 1; + *auto_boot = 1; return default_entry; } @@ -476,7 +445,7 @@ case '\r': case 6: grub_setcursor (1); - *auto_boot = 0; + *auto_boot = 0; return first + offset; case '\e': @@ -499,6 +468,10 @@ } goto refresh; + case 't': + grub_env_set ("menuviewer", "gfxmenu"); + goto refresh; + default: break; } @@ -507,7 +480,8 @@ } } - /* Never reach here. */ + /* Exit menu without activating an item. This occurs if the user presses + * 't', switching to the graphical menu viewer. */ return -1; } @@ -574,20 +548,20 @@ grub_setcursor (1); if (auto_boot) - { - grub_menu_execute_with_fallback (menu, e, &execution_callback, 0); - } + { + grub_menu_execute_with_fallback (menu, e, &execution_callback, 0); + } else - { - grub_errno = GRUB_ERR_NONE; - grub_menu_execute_entry (e); - if (grub_errno != GRUB_ERR_NONE) - { - grub_print_error (); - grub_errno = GRUB_ERR_NONE; - grub_wait_after_message (); - } - } + { + grub_errno = GRUB_ERR_NONE; + grub_menu_execute_entry (e); + if (grub_errno != GRUB_ERR_NONE) + { + grub_print_error (); + grub_errno = GRUB_ERR_NONE; + grub_wait_after_message (); + } + } } return GRUB_ERR_NONE; === modified file 'normal/menu_viewer.c' --- normal/menu_viewer.c 2009-06-10 20:04:23 +0000 +++ normal/menu_viewer.c 2009-06-13 13:42:27 +0000 @@ -25,6 +25,9 @@ /* The list of menu viewers. */ static grub_menu_viewer_t menu_viewer_list; +static int should_return; +static int menu_viewer_changed; + void grub_menu_viewer_register (grub_menu_viewer_t viewer) { @@ -36,7 +39,7 @@ { const char *selected_name = grub_env_get ("menuviewer"); - /* If none selected, pick the last registered one. */ + /* If none selected, pick the last registered one. */ if (selected_name == 0) return menu_viewer_list; @@ -54,10 +57,47 @@ grub_err_t grub_menu_viewer_show_menu (grub_menu_t menu, int nested) { - grub_menu_viewer_t cur = get_current_menu_viewer (); - if (!cur) - return grub_error (GRUB_ERR_BAD_ARGUMENT, "No menu viewer available."); - - return cur->show_menu (menu, nested); + int repeat = 0; + do + { + repeat = 0; + menu_viewer_changed = 0; + grub_menu_viewer_t cur = get_current_menu_viewer (); + if (! cur) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "no menu viewer available."); + + should_return = 0; + cur->show_menu (menu, nested); + if (grub_errno != GRUB_ERR_NONE) + { + grub_print_error (); + grub_wait_after_message (); + } + if (menu_viewer_changed) + repeat = 1; + } + while (repeat); + return grub_errno; +} + +int +grub_menu_viewer_should_return (void) +{ + return should_return; +} + +static char * +menuviewer_write_hook (struct grub_env_var *var __attribute__ ((unused)), + const char *val) +{ + menu_viewer_changed = 1; + should_return = 1; + return grub_strdup (val); +} + +void +grub_menu_viewer_init (void) +{ + grub_register_variable_hook ("menuviewer", 0, menuviewer_write_hook); } === modified file 'term/gfxterm.c' --- term/gfxterm.c 2009-06-10 20:04:23 +0000 +++ term/gfxterm.c 2009-06-13 13:42:27 +0000 @@ -24,8 +24,10 @@ #include #include #include +#include #include -#include +#include +#include #define DEFAULT_VIDEO_MODE "1024x768,800x600,640x480" #define DEFAULT_BORDER_WIDTH 10 @@ -80,10 +82,10 @@ unsigned int cursor_x; unsigned int cursor_y; - /* Current cursor state. */ + /* Current cursor state. */ int cursor_state; - /* Font settings. */ + /* Font settings. */ grub_font_t font; /* Terminal color settings. */ @@ -101,9 +103,18 @@ struct grub_colored_char *text_buffer; }; +static int refcount; +static struct grub_video_render_target *render_target; +static grub_video_rect_t window; static struct grub_virtual_screen virtual_screen; - -static struct grub_video_mode_info mode_info; +static grub_gfxterm_repaint_callback_t repaint_callback; + +static grub_err_t init_window (struct grub_video_render_target *target, + int x, int y, int width, int height, + const char *font_name, int border_width); + +static void destroy_window (void); + static struct grub_video_render_target *text_layer; @@ -235,20 +246,67 @@ } static grub_err_t +init_window (struct grub_video_render_target *target, + int x, int y, int width, int height, + const char *font_name, int border_width) +{ + /* Clean up any prior instance. */ + destroy_window (); + + /* Create virtual screen. */ + if (grub_virtual_screen_setup (border_width, border_width, + width - 2 * border_width, + height - 2 * border_width, + font_name) + != GRUB_ERR_NONE) + { + return grub_errno; + } + + /* Set the render target. */ + render_target = target; + + /* Set window bounds. */ + window.x = x; + window.y = y; + window.width = width; + window.height = height; + + /* Mark whole window as dirty. */ + dirty_region_reset (); + dirty_region_add (0, 0, width, height); + + return grub_errno; +} + +grub_err_t +grub_gfxterm_init_window (struct grub_video_render_target *target, + int x, int y, int width, int height, + const char *font_name, int border_width) +{ + if (refcount++ == 0) + init_window (target, x, y, width, height, font_name, border_width); + return grub_errno; +} + +static grub_err_t grub_gfxterm_init (void) { - char *font_name; - char *modevar; + const char *font_name; + const char *modevar; + struct grub_video_mode_info mode_info; char *tmp; - grub_video_color_t color; - int width; - int height; grub_err_t err; - /* Select the font to use. */ + /* If gfxterm has already been initialized by calling the init_window + function, then leave it alone when it is set as the current terminal. */ + if (refcount++ != 0) + return GRUB_ERR_NONE; + + /* Select the font to use. */ font_name = grub_env_get ("gfxterm_font"); if (! font_name) - font_name = ""; /* Allow fallback to any font. */ + font_name = ""; /* Allow fallback to any font. */ /* Parse gfxmode environment variable if set. */ modevar = grub_env_get ("gfxmode"); @@ -258,6 +316,8 @@ { tmp = grub_malloc (grub_strlen (modevar) + sizeof (DEFAULT_VIDEO_MODE) + 1); + if (! tmp) + return grub_errno; grub_sprintf (tmp, "%s;" DEFAULT_VIDEO_MODE, modevar); err = grub_video_set_mode (tmp, video_hook); grub_free (tmp); @@ -272,53 +332,77 @@ return err; /* Make sure screen is black. */ - color = grub_video_map_rgb (0, 0, 0); - grub_video_fill_rect (color, 0, 0, mode_info.width, mode_info.height); + grub_video_fill_rect (grub_video_map_rgb (0, 0, 0), + 0, 0, mode_info.width, mode_info.height); bitmap = 0; + /* Select the font to use. */ + font_name = grub_env_get ("gfxterm_font"); + if (! font_name) + font_name = ""; /* Allow fallback to any font. */ + /* Leave borders for virtual screen. */ - width = mode_info.width - (2 * DEFAULT_BORDER_WIDTH); - height = mode_info.height - (2 * DEFAULT_BORDER_WIDTH); - - /* Create virtual screen. */ - if (grub_virtual_screen_setup (DEFAULT_BORDER_WIDTH, DEFAULT_BORDER_WIDTH, - width, height, font_name) != GRUB_ERR_NONE) + if (init_window (GRUB_VIDEO_RENDER_TARGET_DISPLAY, + 0, 0, mode_info.width, mode_info.height, + font_name, + DEFAULT_BORDER_WIDTH) != GRUB_ERR_NONE) { grub_video_restore (); return grub_errno; } - /* Mark whole screen as dirty. */ - dirty_region_reset (); - dirty_region_add (0, 0, mode_info.width, mode_info.height); - + return grub_errno; +} + +static void +destroy_window (void) +{ + if (bitmap) + { + grub_video_bitmap_destroy (bitmap); + bitmap = 0; + } + + repaint_callback = 0; + grub_virtual_screen_free (); +} + +void +grub_gfxterm_destroy_window (void) +{ + if (--refcount == 0) + destroy_window (); +} + +static grub_err_t +grub_gfxterm_fini (void) +{ + /* Don't destroy an explicitly initialized terminal instance when it is + unset as the current terminal. */ + if (--refcount == 0) + { + destroy_window (); + grub_video_restore (); + } + + /* Clear error state. */ return (grub_errno = GRUB_ERR_NONE); } -static grub_err_t -grub_gfxterm_fini (void) -{ - if (bitmap) - { - grub_video_bitmap_destroy (bitmap); - bitmap = 0; - } - - grub_virtual_screen_free (); - - grub_video_restore (); - - return GRUB_ERR_NONE; -} - static void redraw_screen_rect (unsigned int x, unsigned int y, unsigned int width, unsigned int height) { grub_video_color_t color; - - grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); - + grub_video_rect_t saved_view; + + grub_video_set_active_render_target (render_target); + /* Save viewport and set it to our window. */ + grub_video_get_viewport ((unsigned *) &saved_view.x, + (unsigned *) &saved_view.y, + (unsigned *) &saved_view.width, + (unsigned *) &saved_view.height); + grub_video_set_viewport (window.x, window.y, window.width, window.height); if (bitmap) { @@ -385,6 +469,14 @@ y - virtual_screen.offset_y, width, height); } + + /* Restore saved viewport. */ + grub_video_set_viewport (saved_view.x, saved_view.y, + saved_view.width, saved_view.height); + grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + + if (repaint_callback) + repaint_callback (x, y, width, height); } static void @@ -521,7 +613,7 @@ unsigned int height; grub_video_color_t color; - /* Determine cursor properties and position on text layer. */ + /* Determine cursor properties and position on text layer. */ x = virtual_screen.cursor_x * virtual_screen.normal_char_width; width = virtual_screen.normal_char_width; color = virtual_screen.fg_color; @@ -547,7 +639,7 @@ unsigned int i; grub_video_color_t color; - /* If we don't have background bitmap, remove cursor. */ + /* If we don't have background bitmap, remove cursor. */ if (!bitmap) { /* Remove cursor. */ @@ -590,6 +682,15 @@ } else { + grub_video_rect_t saved_view; + grub_video_set_active_render_target (render_target); + /* Save viewport and set it to our window. */ + grub_video_get_viewport ((unsigned *) &saved_view.x, + (unsigned *) &saved_view.y, + (unsigned *) &saved_view.width, + (unsigned *) &saved_view.height); + grub_video_set_viewport (window.x, window.y, window.width, window.height); + /* Clear new border area. */ grub_video_fill_rect (color, virtual_screen.offset_x, virtual_screen.offset_y, @@ -598,10 +699,18 @@ /* Scroll physical screen. */ grub_video_scroll (color, 0, -virtual_screen.normal_char_height); + /* Restore saved viewport. */ + grub_video_set_viewport (saved_view.x, saved_view.y, + saved_view.width, saved_view.height); + grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); + /* Draw cursor if visible. */ if (virtual_screen.cursor_state) draw_cursor (1); } + + if (repaint_callback) + repaint_callback (window.x, window.y, window.width, window.height); } static void @@ -735,7 +844,7 @@ } static grub_ssize_t -grub_gfxterm_getcharwidth (grub_uint32_t c) +grub_gfxterm_getcharwidth (grub_uint32_t c __attribute__((unused))) { struct grub_font_glyph *glyph; unsigned char char_width; @@ -810,7 +919,8 @@ /* Clear text layer. */ grub_video_set_active_render_target (text_layer); color = virtual_screen.bg_color; - grub_video_fill_rect (color, 0, 0, mode_info.width, mode_info.height); + grub_video_fill_rect (color, 0, 0, + virtual_screen.width, virtual_screen.height); grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY); /* Mark virtual screen to be redrawn. */ @@ -879,11 +989,29 @@ dirty_region_redraw (); } +void +grub_gfxterm_set_repaint_callback (grub_gfxterm_repaint_callback_t func) +{ + repaint_callback = func; +} + +/* Option array indices. */ +#define BACKGROUND_CMD_ARGINDEX_MODE 0 + +static const struct grub_arg_option background_image_cmd_options[] = + { + {"mode", 'm', 0, "Background image mode (`stretch', `normal').", 0, + ARG_TYPE_STRING}, + {0, 0, 0, 0, 0, 0} + }; + static grub_err_t -grub_gfxterm_background_image_cmd (grub_command_t cmd __attribute__ ((unused)), +grub_gfxterm_background_image_cmd (grub_extcmd_t cmd, int argc, char **args) { + struct grub_arg_list *state = cmd->state; + /* Check that we have video adapter active. */ if (grub_video_get_info(NULL) != GRUB_ERR_NONE) return grub_errno; @@ -896,7 +1024,7 @@ /* Mark whole screen as dirty. */ dirty_region_reset (); - dirty_region_add (0, 0, mode_info.width, mode_info.height); + dirty_region_add (0, 0, window.width, window.height); } /* If filename was provided, try to load that. */ @@ -907,16 +1035,40 @@ if (grub_errno != GRUB_ERR_NONE) return grub_errno; + /* Determine if the bitmap should be scaled to fit the screen. */ + if (!state[BACKGROUND_CMD_ARGINDEX_MODE].set + || grub_strcmp (state[BACKGROUND_CMD_ARGINDEX_MODE].arg, + "stretch") == 0) + { + if (window.width != (int) grub_video_bitmap_get_width (bitmap) + || window.height != (int) grub_video_bitmap_get_height (bitmap)) + { + struct grub_video_bitmap *scaled_bitmap; + grub_video_bitmap_create_scaled (&scaled_bitmap, + window.width, + window.height, + bitmap, + GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST); + if (grub_errno == GRUB_ERR_NONE) + { + /* Replace the original bitmap with the scaled one. */ + grub_video_bitmap_destroy (bitmap); + bitmap = scaled_bitmap; + } + } + } + + /* If bitmap was loaded correctly, display it. */ if (bitmap) { /* Determine bitmap dimensions. */ bitmap_width = grub_video_bitmap_get_width (bitmap); - bitmap_height = grub_video_bitmap_get_width (bitmap); + bitmap_height = grub_video_bitmap_get_height (bitmap); /* Mark whole screen as dirty. */ dirty_region_reset (); - dirty_region_add (0, 0, mode_info.width, mode_info.height); + dirty_region_add (0, 0, window.width, window.height); } } @@ -945,18 +1097,30 @@ .next = 0 }; -static grub_command_t cmd; +grub_term_output_t +grub_gfxterm_get_term (void) +{ + return &grub_video_term; +} + +static grub_extcmd_t background_image_cmd_handle; GRUB_MOD_INIT(term_gfxterm) { + refcount = 0; + grub_term_register_output ("gfxterm", &grub_video_term); - cmd = grub_register_command ("background_image", - grub_gfxterm_background_image_cmd, - 0, "Load background image for active terminal"); + background_image_cmd_handle = + grub_register_extcmd ("background_image", + grub_gfxterm_background_image_cmd, + GRUB_COMMAND_FLAG_BOTH, + "background_image [-m (stretch|normal)] FILE", + "Load background image for active terminal.", + background_image_cmd_options); } GRUB_MOD_FINI(term_gfxterm) { - grub_unregister_command (cmd); + grub_unregister_extcmd (background_image_cmd_handle); grub_term_unregister_output (&grub_video_term); } === added file 'video/bitmap_scale.c' --- video/bitmap_scale.c 1970-01-01 00:00:00 +0000 +++ video/bitmap_scale.c 2009-06-09 21:49:06 +0000 @@ -0,0 +1,308 @@ +/* bitmap_scale.c - Bitmap scaling. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2006,2007,2008,2009 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include +#include + +/* Prototypes for module-local functions. */ +static grub_err_t scale_nn (struct grub_video_bitmap *dst, + struct grub_video_bitmap *src); +static grub_err_t scale_bilinear (struct grub_video_bitmap *dst, + struct grub_video_bitmap *src); + +/* This function creates a new scaled version of the bitmap SRC. The new + bitmap has dimensions DST_WIDTH by DST_HEIGHT. The scaling algorithm + is given by SCALE_METHOD. If an error is encountered, the return code is + not equal to GRUB_ERR_NONE, and the bitmap DST is either not created, or + it is destroyed before this function returns. + + Supports only direct color modes which have components separated + into bytes (e.g., RGBA 8:8:8:8 or BGR 8:8:8 true color). + But because of this simplifying assumption, the implementation is + greatly simplified. */ +grub_err_t +grub_video_bitmap_create_scaled (struct grub_video_bitmap **dst, + int dst_width, int dst_height, + struct grub_video_bitmap *src, + enum grub_video_bitmap_scale_method + scale_method) +{ + *dst = 0; + + /* Verify the simplifying assumptions. */ + if (src == 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "null src bitmap in grub_video_bitmap_create_scaled"); + if (src->mode_info.red_field_pos % 8 != 0 + || src->mode_info.green_field_pos % 8 != 0 + || src->mode_info.blue_field_pos % 8 != 0 + || src->mode_info.reserved_field_pos % 8 != 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "src format not supported for scale"); + if (src->mode_info.width == 0 || src->mode_info.height == 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "source bitmap has a zero dimension"); + if (dst_width <= 0 || dst_height <= 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "requested to scale to a size w/ a zero dimension"); + if (src->mode_info.bytes_per_pixel * 8 != src->mode_info.bpp) + return grub_error (GRUB_ERR_BAD_ARGUMENT, + "bitmap to scale has inconsistent Bpp and bpp"); + + /* Create the new bitmap. */ + grub_err_t ret; + ret = grub_video_bitmap_create (dst, dst_width, dst_height, + src->mode_info.blit_format); + if (ret != GRUB_ERR_NONE) + return ret; /* Error. */ + + switch (scale_method) + { + case GRUB_VIDEO_BITMAP_SCALE_METHOD_FASTEST: + case GRUB_VIDEO_BITMAP_SCALE_METHOD_NEAREST: + ret = scale_nn (*dst, src); + break; + case GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST: + case GRUB_VIDEO_BITMAP_SCALE_METHOD_BILINEAR: + ret = scale_bilinear (*dst, src); + break; + default: + ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid scale_method value"); + break; + } + + if (ret == GRUB_ERR_NONE) + { + /* Success: *dst is now a pointer to the scaled bitmap. */ + return GRUB_ERR_NONE; + } + else + { + /* Destroy the bitmap and return the error code. */ + grub_video_bitmap_destroy (*dst); + *dst = 0; + return ret; + } +} + +/* Nearest neighbor bitmap scaling algorithm. + + Copy the bitmap SRC to the bitmap DST, scaling the bitmap to fit the + dimensions of DST. This function uses the nearest neighbor algorithm to + interpolate the pixels. + + Supports only direct color modes which have components separated + into bytes (e.g., RGBA 8:8:8:8 or BGR 8:8:8 true color). + But because of this simplifying assumption, the implementation is + greatly simplified. */ +static grub_err_t +scale_nn (struct grub_video_bitmap *dst, struct grub_video_bitmap *src) +{ + /* Verify the simplifying assumptions. */ + if (dst == 0 || src == 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "null bitmap in scale_nn"); + if (dst->mode_info.red_field_pos % 8 != 0 + || dst->mode_info.green_field_pos % 8 != 0 + || dst->mode_info.blue_field_pos % 8 != 0 + || dst->mode_info.reserved_field_pos % 8 != 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst format not supported"); + if (src->mode_info.red_field_pos % 8 != 0 + || src->mode_info.green_field_pos % 8 != 0 + || src->mode_info.blue_field_pos % 8 != 0 + || src->mode_info.reserved_field_pos % 8 != 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "src format not supported"); + if (dst->mode_info.red_field_pos != src->mode_info.red_field_pos + || dst->mode_info.red_mask_size != src->mode_info.red_mask_size + || dst->mode_info.green_field_pos != src->mode_info.green_field_pos + || dst->mode_info.green_mask_size != src->mode_info.green_mask_size + || dst->mode_info.blue_field_pos != src->mode_info.blue_field_pos + || dst->mode_info.blue_mask_size != src->mode_info.blue_mask_size + || dst->mode_info.reserved_field_pos != + src->mode_info.reserved_field_pos + || dst->mode_info.reserved_mask_size != + src->mode_info.reserved_mask_size) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst and src not compatible"); + if (dst->mode_info.bytes_per_pixel != src->mode_info.bytes_per_pixel) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst and src not compatible"); + if (dst->mode_info.width == 0 || dst->mode_info.height == 0 + || src->mode_info.width == 0 || src->mode_info.height == 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "bitmap has a zero dimension"); + + grub_uint8_t *ddata = dst->data; + grub_uint8_t *sdata = src->data; + int dw = dst->mode_info.width; + int dh = dst->mode_info.height; + int sw = src->mode_info.width; + int sh = src->mode_info.height; + int dstride = dst->mode_info.pitch; + int sstride = src->mode_info.pitch; + /* bytes_per_pixel is the same for both src and dst. */ + int bytes_per_pixel = dst->mode_info.bytes_per_pixel; + + int dy; + for (dy = 0; dy < dh; dy++) + { + int dx; + for (dx = 0; dx < dw; dx++) + { + grub_uint8_t *dptr; + grub_uint8_t *sptr; + int sx; + int sy; + int comp; + + /* Compute the source coordinate that the destination coordinate + maps to. Note: sx/sw = dx/dw => sx = sw*dx/dw. */ + sx = sw * dx / dw; + sy = sh * dy / dh; + + /* Get the address of the pixels in src and dst. */ + dptr = ddata + dy * dstride + dx * bytes_per_pixel; + sptr = sdata + sy * sstride + sx * bytes_per_pixel; + + /* Copy the pixel color value. */ + for (comp = 0; comp < bytes_per_pixel; comp++) + dptr[comp] = sptr[comp]; + } + } + return GRUB_ERR_NONE; +} + +/* Bilinear interpolation image scaling algorithm. + + Copy the bitmap SRC to the bitmap DST, scaling the bitmap to fit the + dimensions of DST. This function uses the bilinear interpolation algorithm + to interpolate the pixels. + + Supports only direct color modes which have components separated + into bytes (e.g., RGBA 8:8:8:8 or BGR 8:8:8 true color). + But because of this simplifying assumption, the implementation is + greatly simplified. */ +static grub_err_t +scale_bilinear (struct grub_video_bitmap *dst, struct grub_video_bitmap *src) +{ + /* Verify the simplifying assumptions. */ + if (dst == 0 || src == 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "null bitmap in scale func"); + if (dst->mode_info.red_field_pos % 8 != 0 + || dst->mode_info.green_field_pos % 8 != 0 + || dst->mode_info.blue_field_pos % 8 != 0 + || dst->mode_info.reserved_field_pos % 8 != 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst format not supported"); + if (src->mode_info.red_field_pos % 8 != 0 + || src->mode_info.green_field_pos % 8 != 0 + || src->mode_info.blue_field_pos % 8 != 0 + || src->mode_info.reserved_field_pos % 8 != 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "src format not supported"); + if (dst->mode_info.red_field_pos != src->mode_info.red_field_pos + || dst->mode_info.red_mask_size != src->mode_info.red_mask_size + || dst->mode_info.green_field_pos != src->mode_info.green_field_pos + || dst->mode_info.green_mask_size != src->mode_info.green_mask_size + || dst->mode_info.blue_field_pos != src->mode_info.blue_field_pos + || dst->mode_info.blue_mask_size != src->mode_info.blue_mask_size + || dst->mode_info.reserved_field_pos != + src->mode_info.reserved_field_pos + || dst->mode_info.reserved_mask_size != + src->mode_info.reserved_mask_size) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst and src not compatible"); + if (dst->mode_info.bytes_per_pixel != src->mode_info.bytes_per_pixel) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst and src not compatible"); + if (dst->mode_info.width == 0 || dst->mode_info.height == 0 + || src->mode_info.width == 0 || src->mode_info.height == 0) + return grub_error (GRUB_ERR_BAD_ARGUMENT, "bitmap has a zero dimension"); + + grub_uint8_t *ddata = dst->data; + grub_uint8_t *sdata = src->data; + int dw = dst->mode_info.width; + int dh = dst->mode_info.height; + int sw = src->mode_info.width; + int sh = src->mode_info.height; + int dstride = dst->mode_info.pitch; + int sstride = src->mode_info.pitch; + /* bytes_per_pixel is the same for both src and dst. */ + int bytes_per_pixel = dst->mode_info.bytes_per_pixel; + + int dy; + for (dy = 0; dy < dh; dy++) + { + int dx; + for (dx = 0; dx < dw; dx++) + { + grub_uint8_t *dptr; + grub_uint8_t *sptr; + int sx; + int sy; + int comp; + + /* Compute the source coordinate that the destination coordinate + maps to. Note: sx/sw = dx/dw => sx = sw*dx/dw. */ + sx = sw * dx / dw; + sy = sh * dy / dh; + + /* Get the address of the pixels in src and dst. */ + dptr = ddata + dy * dstride + dx * bytes_per_pixel; + sptr = sdata + sy * sstride + sx * bytes_per_pixel; + + /* If we have enough space to do so, use bilinear interpolation. + Otherwise, fall back to nearest neighbor for this pixel. */ + if (sx < sw - 1 && sy < sh - 1) + { + /* Do bilinear interpolation. */ + + /* Fixed-point .8 numbers representing the fraction of the + distance in the x (u) and y (v) direction within the + box of 4 pixels in the source. */ + int u = (256 * sw * dx / dw) - (sx * 256); + int v = (256 * sh * dy / dh) - (sy * 256); + + for (comp = 0; comp < bytes_per_pixel; comp++) + { + /* Get the component's values for the + four source corner pixels. */ + grub_uint8_t f00 = sptr[comp]; + grub_uint8_t f10 = sptr[comp + bytes_per_pixel]; + grub_uint8_t f01 = sptr[comp + sstride]; + grub_uint8_t f11 = sptr[comp + sstride + bytes_per_pixel]; + + /* Do linear interpolations along the top and bottom + rows of the box. */ + grub_uint8_t f0y = (256 - v) * f00 / 256 + v * f01 / 256; + grub_uint8_t f1y = (256 - v) * f10 / 256 + v * f11 / 256; + + /* Interpolate vertically. */ + grub_uint8_t fxy = (256 - u) * f0y / 256 + u * f1y / 256; + + dptr[comp] = fxy; + } + } + else + { + /* Fall back to nearest neighbor interpolation. */ + /* Copy the pixel color value. */ + for (comp = 0; comp < bytes_per_pixel; comp++) + dptr[comp] = sptr[comp]; + } + } + } + return GRUB_ERR_NONE; +} === modified file 'video/i386/pc/vbe.c' --- video/i386/pc/vbe.c 2009-05-04 19:06:05 +0000 +++ video/i386/pc/vbe.c 2009-06-08 06:46:58 +0000 @@ -76,6 +76,24 @@ static grub_uint32_t mode_in_use = 0x55aa; static grub_uint16_t *mode_list; +static struct +{ + grub_size_t page_size; /* The size of a page in bytes. */ + + /* For page flipping strategy. */ + int displayed_page; /* The page # that is the front buffer. */ + int render_page; /* The page # that is the back buffer. */ + + /* For blit strategy. */ + grub_uint8_t *offscreen_buffer; + + /* Virtual functions. */ + int (*update_screen) (void); + int (*destroy) (void); +} doublebuf_state; + +static void double_buffering_init (int enable); + static void * real2pm (grub_vbe_farptr_t ptr) { @@ -388,6 +406,7 @@ /* Reset frame buffer and render target variables. */ grub_memset (&framebuffer, 0, sizeof(framebuffer)); render_target = &framebuffer.render_target; + grub_memset (&doublebuf_state, 0, sizeof(doublebuf_state)); return GRUB_ERR_NONE; } @@ -403,6 +422,9 @@ /* TODO: Decide, is this something we want to do. */ return grub_errno; + if (doublebuf_state.destroy) + doublebuf_state.destroy(); + /* TODO: Free any resources allocated by driver. */ grub_free (mode_list); mode_list = 0; @@ -545,9 +567,11 @@ render_target->viewport.width = active_mode_info.x_resolution; render_target->viewport.height = active_mode_info.y_resolution; - /* Set framebuffer pointer and mark it as non allocated. */ + /* Mark framebuffer memory as non allocated. */ render_target->is_allocated = 0; - render_target->data = framebuffer.ptr; + + /* Set up double buffering, initially disabled. */ + double_buffering_init (0); /* Copy default palette to initialize emulated palette. */ for (i = 0; @@ -568,6 +592,166 @@ return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no matching mode found."); } +/* + Set framebuffer render target page and display the proper page, based on + `doublebuf_state.render_page' and `doublebuf_state.displayed_page', + respectively. + + Returns 0 upon success, nonzero upon failure. + */ +static int +doublebuf_pageflipping_commit (void) +{ + /* Set the render target's data pointer to the start of the render_page. */ + framebuffer.render_target.data = + ((char *) framebuffer.ptr) + + doublebuf_state.page_size * doublebuf_state.render_page; + + /* Tell the video adapter to display the new front page. */ + int display_start_line = + framebuffer.render_target.mode_info.height + * doublebuf_state.displayed_page; + + grub_vbe_status_t vbe_err = + grub_vbe_bios_set_display_start (0, display_start_line); + if (vbe_err != GRUB_VBE_STATUS_OK) + return 1; + + return 0; +} + +static int +doublebuf_pageflipping_update_screen (void) +{ + /* Swap the page numbers in the framebuffer struct. */ + int new_displayed_page = doublebuf_state.render_page; + doublebuf_state.render_page = doublebuf_state.displayed_page; + doublebuf_state.displayed_page = new_displayed_page; + + return doublebuf_pageflipping_commit (); +} + +static int +doublebuf_pageflipping_destroy (void) +{ + doublebuf_state.update_screen = 0; + doublebuf_state.destroy = 0; + return 0; +} + +static int +doublebuf_pageflipping_init (void) +{ + doublebuf_state.page_size = + framebuffer.bytes_per_scan_line * render_target->mode_info.height; + + /* Get video RAM size in bytes. */ + grub_size_t vram_size = controller_info.total_memory << 16; + + if (2 * doublebuf_state.page_size > vram_size) + return 1; /* Not enough video memory for 2 pages. */ + + doublebuf_state.displayed_page = 0; + doublebuf_state.render_page = 1; + + doublebuf_state.update_screen = doublebuf_pageflipping_update_screen; + doublebuf_state.destroy = doublebuf_pageflipping_destroy; + + /* Set the framebuffer memory data pointer and display the right page. */ + if (doublebuf_pageflipping_commit () != GRUB_ERR_NONE) + return 1; /* Unable to set the display start. */ + + framebuffer.render_target.mode_info.mode_type + |= GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED; + return 0; +} + +static int +doublebuf_blit_update_screen (void) +{ + grub_memcpy (framebuffer.ptr, + doublebuf_state.offscreen_buffer, + doublebuf_state.page_size); + return 0; +} + +static int +doublebuf_blit_destroy (void) +{ + grub_free (doublebuf_state.offscreen_buffer); + doublebuf_state.offscreen_buffer = 0; + + doublebuf_state.update_screen = 0; + doublebuf_state.destroy = 0; + return 0; +} + +static int +doublebuf_blit_init (void) +{ + doublebuf_state.page_size = + framebuffer.bytes_per_scan_line * render_target->mode_info.height; + + doublebuf_state.offscreen_buffer = (grub_uint8_t *) + grub_malloc (doublebuf_state.page_size); + if (doublebuf_state.offscreen_buffer == 0) + return 1; /* Error. */ + + framebuffer.render_target.data = doublebuf_state.offscreen_buffer; + doublebuf_state.update_screen = doublebuf_blit_update_screen; + doublebuf_state.destroy = doublebuf_blit_destroy; + + framebuffer.render_target.mode_info.mode_type + |= GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED; + return 0; +} + +static int +doublebuf_null_update_screen (void) +{ + return 0; +} + +static int +doublebuf_null_destroy (void) +{ + doublebuf_state.update_screen = 0; + doublebuf_state.destroy = 0; + return 0; +} + +static int +doublebuf_null_init (void) +{ + framebuffer.render_target.data = framebuffer.ptr; + doublebuf_state.update_screen = doublebuf_null_update_screen; + doublebuf_state.destroy = doublebuf_null_destroy; + + framebuffer.render_target.mode_info.mode_type + &= ~GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED; + return 0; +} + +/* Select the best double buffering mode available. */ +static void +double_buffering_init (int enable) +{ + if (doublebuf_state.destroy) + doublebuf_state.destroy (); + + if (enable) + { + if (doublebuf_pageflipping_init () == 0) + return; + + if (doublebuf_blit_init () == 0) + return; + } + + /* Fall back to no double buffering. */ + doublebuf_null_init (); +} + static grub_err_t grub_video_vbe_get_info (struct grub_video_mode_info *mode_info) { @@ -1468,7 +1652,17 @@ static grub_err_t grub_video_vbe_swap_buffers (void) { - /* TODO: Implement buffer swapping. */ + if (doublebuf_state.update_screen () != 0) + return grub_error (GRUB_ERR_INVALID_COMMAND, + "Double buffer update failed"); + + return GRUB_ERR_NONE; +} + +static grub_err_t +grub_video_vbe_enable_double_buffering (int enable) +{ + double_buffering_init (enable); return GRUB_ERR_NONE; } @@ -1567,17 +1761,13 @@ static grub_err_t grub_video_vbe_set_active_render_target (struct grub_video_render_target *target) { - if (target == GRUB_VIDEO_RENDER_TARGET_FRONT_BUFFER) + if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY) { render_target = &framebuffer.render_target; return GRUB_ERR_NONE; } - if (target == GRUB_VIDEO_RENDER_TARGET_BACK_BUFFER) - return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, - "double buffering not implemented yet."); - if (! target->data) return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid render target given."); @@ -1616,6 +1806,7 @@ .blit_render_target = grub_video_vbe_blit_render_target, .scroll = grub_video_vbe_scroll, .swap_buffers = grub_video_vbe_swap_buffers, + .enable_double_buffering = grub_video_vbe_enable_double_buffering, .create_render_target = grub_video_vbe_create_render_target, .delete_render_target = grub_video_vbe_delete_render_target, .set_active_render_target = grub_video_vbe_set_active_render_target, === modified file 'video/video.c' --- video/video.c 2009-06-10 20:04:23 +0000 +++ video/video.c 2009-06-13 13:42:27 +0000 @@ -335,6 +335,16 @@ return grub_video_adapter_active->swap_buffers (); } +/* Enable or disable double buffering. */ +grub_err_t +grub_video_enable_double_buffering (int enable) +{ + if (! grub_video_adapter_active) + return grub_error (GRUB_ERR_BAD_DEVICE, "No video mode activated"); + + return grub_video_adapter_active->enable_double_buffering (enable); +} + /* Create new render target. */ grub_err_t grub_video_create_render_target (struct grub_video_render_target **result, @@ -380,7 +390,7 @@ } grub_err_t -grub_video_set_mode (char *modestring, +grub_video_set_mode (const char *modestring, int NESTED_FUNC_ATTR (*hook) (grub_video_adapter_t p, struct grub_video_mode_info *mode_info)) { # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWUBttUkCukP/gH////////// //////////9iz3976Cnwa92F0HsOm7HAfAgqIAMmlT6Pvvvr4965WCcdr2zDRa3tu6FKXS97T3sz 00d7XYe7AqLKNuPtzkpsANa0BTQPtjrdd81Tbm7x80AbfeDpe53w8+9n2Q0AABu7uz7671649Vq+ LcSJlU21EZVmtrYGSpmuh5eI1z3unttvXcHctU+unvY9PIdbZdZ1Xtu7a6nJHxrVKrenkemCnTu1 ba6eV6BSgBDWFvfPurmO0KBLTffbk3tOH1pFyUFKGQA2YYsy3Dy9VXt5o1aNu4Pd6hy9zcbm9s9a qidtSqN5q66rNG+3c3du1qr31YB10pu7nbsdUhezNNfEMdfdl2Wz6aFSkkdN7s7t3daHdm2yW2c+ 803HQm73rtnq4x6B7nZrgKXZXrWinfbVT618+y7LldWcpA0NmdcqU7QduLY7mk3mA+vqtPtk6adu gAfR6PVOyjub2M82fEbNkAFG73eCm+d160+fWgVeSVs6crujvepZ3Ymz6Qh69HoGmpsJSS+8Po9H QAJxj0l7D0F5469AdHoGqGhJQHkGQcvh9AD7VofdztVPaAH0H17W9u2Ozs6AUKU9BjulS9Gvu9fO TmduQ3lnbk8WV7J7X1rewNBpQD0065boGoDE4UpcC1B73gqd5FGXu970vfZ27OijWVrvs6rStvPq vet3fdW9thhuveT58cN2td267as2tuu7FzdvO7e7veW5VVBue0O8D33X3r6Pk+oD0d73B4oF0Cu7 KAPcz166HkPR6+ezkioe+95xKe91tPfWD6Cj2wdFJ9gade9jdrjAZB3uyA69xx3rHoPXPbV0altk NAyQQ2iUVZQapLTSrZio1oPTVEmnd7MCaOFDpK2Fa73cqikKBD2KE9vce6+u4Z97e9qDTTY1p92E u2umAHdcdLWrbOmjp9cgQEEdB73N4vMCi7GrZke+znYwIfWAfdO6p2wKU6emnQqVAeum+fZ3oaKK M2aJrN8u9PdV1i6o0iiK1SuQGi7Npg7st8wTQtNtgGFOqyKp1RoHQG7DVA0HQaKC8snVtAr1QCjQ BhGqVQAAFHdg6oAMgA66qiujoB7sA9D0ABkCj6enQrbDbeg+7ad2K3TuVpV97dtgPQHJhGfdz7N7 NWR97vO7uvTe2O632bfb4fWPq6871cZM72NXeCjj7ji+fUIiV0Ts+zlfPXO24XuzxOjXTYCdd0Np uN3Hca7YrW0627sXQcnXn1QkQWi+spzZJDvDfOx6Ne9A29u5r2CxnXp1nwKqgRuKzpd894k+869Z Xrd7czadoArN1ijbRVdSbbPTvNT1t1rtduuqNbePgQFPeeTiL1VPi69un251eN66R3bvb0PND7tt 24lyO7feb0xtE3nXt3nqd2+bXY85s0fTzPB7JzoL0QWRVS7tfOA99qKZu5ua+x4Xx3sYq7p9miRs fCT1uKVndo6zbXQd3Wrqr5983aj3dr63266+y+fTz0+zJ92gHFtbDYlbtXcyfHyJVCmzk6K6d7my ahVJ8m7apJ2N2fT333NfPeHVxceweu9bvUnnsbN7dw3TIKlE25steuOmsWiZawyKVtPBVuxtZbPW 5hMqxLdaJzVbztbXW9HjwrVbud7e5TWuHRGilu53b3eXbaw2rDapXpnducLW1bvZ2Nq2yNVbXvKd L117bQpreDtuqtrNTGoELs1Upm3Tlmu729B1sZWem6XNMaFdnXJT23JZHrdnRrtt0ydPboOxNFeC 2Gi2xOlxjtPMNrrmoopRQVVKktHWJFQNmrsXo511joKLSatNYGb267TPNt3HKSbNqbdm2Ord313U fdkk77Hcwe69cdOQe7U62wHgnT1F4AW19dTi+XvbwBfHbSu6OdIa019D3N7tqp01TMPXOrJaLO9e 333Z7ubvat9vO9GK5Uc67j7NRRm2r429tmNc2q3aobnYzSq9Z73Xajt7jeJvGw0NXd3U4bQvdvPf bdgddF3O7tt20ded3NZUQ9K3WXp93l0LYz3d8t4+c0IAHyXsum9ep2My33zFHjzOvveT2GivapVK 7gOjuT3ecTM2bS9mnoxpp7V112yquz3YvWPW1pCqLY8V2692F7ux7Oj22vDLAGmnprOwCa2lt3ap 3OX1p7t3NmH2b6xW5UpqDCSQAIBAgCAJoE00AmCTNTCaaKntkJqZlTzU0yNRnlGo3pqjQJQAiAkS JoVPxFT8ZNJop6n6RBo0aaGmnqAaHqAAyZAAAACQSIQgQECNMgmmJPITKnmEmaaUbTZEmnlPU/Se qep6J6j1PU2ptQ8ptTRkBU1KSKZENE01PCMJlPKn5E9GpphMibVPZTPSUH7VQeyU/Kag8RMaTMIN T9U2kCFJE0gAQmARMTJpiDImFPTQ0mCAT0jaQ1PUzTSeo9GTSYRo0BUSQggEACABNGgAEaMgExMp mpkaniaaKn5NoFT8Uwm1NT0ny9U7H7JCfmlaNkZILJFFRSgf6eciZjeywelt5gjeFswVdP/EPzia X74FT8oyqkMqgYUqGZ7MmbBv4v3HBvSJZm8mbMZ4TDM9bMfDbf9DLMcKQ1q01GqWWa3/M/menm9J kmf+qM4VLa2stkmyVZtLSSVpYtk2VrIUKImkJSEkZj+XBHhCVE69tIH9Zh/lT+j9BP/hv86b474W 91tlA5S2fvw8h5N0Rpt2zjc2fXP4mlf4eHDTO3/l/hf/noWmL+Y0M/2tRfB/1/8uq88WjG+e7WsF mm4omzD/3vT7HY+bRtaGmepejQz/oUIdmGcttHIH83purh9hjfdMi/w+41mMIDDb8nzcviInSc0c VvbHoP9Yv+G8564RQsOb95shmnSwdZ3pfDNC1lqkT583h/QLkWAveo7TErwm8DkagNeOcpO/lhrP n/39HxdJRP/pufL/ls/36vx/5bM1xeH/xPzH/65+F/c7dfXBs9Se6ndgtGTOazs+0NDrF3jy3P+n /U1f3zCjeVnvDz8hmGZLxCD6vnFP1Tf1Rk9h49FaRKxj/kMivaYML9z+6xEY+ZGcSBBj/ZDBaIxp tL6WRsbGNtDjJYV213b3opohjb9GvK5RjPua8ZoqiNREkRGNjYRjpSg3+4whzPxN2f8OLT0wirab Yf1f1FufSbjn1OOyam/SWY5JKLWooi/6ZwgUiUGO3Dx1T6AnUUNZTX1u301seI5B1tWnccsy1r6O 7dZTeI5YkJq0irEnz22ciJLbTUhJLIkrWyESb5EOSs0nqw6yKvGhyzU2h5nHW0WJJVVSslh40Gjp d3/tXSxrfkrIp6C7y2ITYjHJsFmyHAgooGbkR2G3XowJXdko4Gy3JctM4ztYEGmeu2uUibvwyjnc wn6Yd5YIZj0WQPlHj8+KdhKpvNAwSFB0TlHUQRjaEyxKIcaRO8QFp4ohpqBO5mJqFkhMgabnBjJC HDGRjC5M22GDBRUGQeMLqViyTjTtaynL15I5NmKWWwpasWKdHnm8ysWQSkoT/y430J8L1DTuGLEJ koZIZdgfKeHt9G6+kdsOcPcTXQQExM6ZwgIZxHeE3SCGSgGCEo2PRyzlDsXDLwattLhlxbYHm+5y GUk9p5/oD9i/dWztyxmERXRjb8Eg2PkjpJT5nft8p/3dbPPtt58j7fH/WYcqobFGpHPanuMMPed9 ZmEoxUGev2ohIduKGfHiF8nITfKJ5fJm8mdyZxpZJpsZmsv0by7+Pz7871svVtdyMr/PLpjTjIxN scHjdI6m5aQ20qqSB3ZAY1W15H31FGv1ZP/Ti/u/3ff/h7z8nzJH5M/CfjsKa+j81ubmOfaaq51T ngYti0X+jNUjKQoKTU0umerpyXxcGVcM02jWmIqYKNMlabKdTIoeCMVy3JcNWjqi6KSChitYrZWE 2miNJpVZ4HglhYnJtldV1OtOLqGNCxDSzYS8Ko9uSRK0lLONSpqRtLjWDtUQ0xRpVnTLL4KkM5Fa bUxC3BpLqLIJZc1cC1moZqu81pqK0QtvLpNalahDW4cHR1u72dSZrzPj7mfG/Owh+4H1kpafKcb2 qMTGfm4VvEigQuUKZs0UwMBvh0oyZkUKSNjb7z9eff9vPG2NkmY51tTW+LunfIuz/S9mRZwt00/m anQ8bs9/E83r/UdmTTznDnHrR+sw/uPpvCGat8FKNj/mhqxs/Vx4MM+C+qCj87iiGGV34gbuUx2t qHRha22Sws2hbI18E1L11kGLxn3L6O/QZ0ceCn4+1zvTfOBLrh9sDW3SlFI09fyGdfyYxTkXEHGJ FU5G0KEMwyyOqjEp8V5aL4usqkLIoVR0oGUQ3B7PeaTBs/cKlf/zScvaul7cZ2IVh9EXg1NcNHfM rP5HD6nGbfI99tdIzwtZW4m3SwZ3nB7tUDSYaVnvnwznRH2Z0Uh3ZDXUoYwznRLPuiOOYnzHSJnv ZFs4h4NKGvrPzcfhOfoOODtPZLiekhia4d06WDbTwnp/rJjPR6Z8X6NvnT3Uns6KqY91ax6Wq7hw 961rIxjGxjCtd8lMUo4zzZXGcN4oeOPK9ammt9Re9zGTWn2MVxYfXhVrIn4IV4qfumsEnSBlkYo2 2Pw2yXZUr+MztmhuatsL9fa+TD6Hz5Tl9xuw6ca7ZlHxD0aIMOGBthzJWiVkbXxsODr3Wj0MzvDN w4bbpCtyjq7ljG+xrWphaQ/J94fS40OVmeqA922EeWeydZy+Z2qiL5j3PRo9Pb19/uk+T4hx/T6f yywTTMUBMNCzfqsj/9IZ+ST++aP+W4TFoTBsZcrrkFkPi46j1mPWTLavi9880NsbE3zPhX8o+3V+ j5fOc+Rrb297aWJhXao6khROempXMktYMp4gdiQZ8kmt9cawitVuHXIcva3u1R2VW3c4drUYtuMb bTb6pxxreUe9VRorGMTbJmpZpHFQeJdxSTqenXXX6NHeueFTgl1c5hCFej9MxeJE2HXFuuJWRLD0 IKB3O30HbBtDtywvHnk0HFsD1QwOUqRLu0MQM3hCzD2ySo5Wx9LMY7qouNvMzN5rAucqK1rNSTpl N8HuKuidPRu7qdlPqdwMKRKPcQRFkOBgeL9rCoqBEMqx8+u1Pez2T5X07wreVZlfRrVxems1Jk0O ZIU8axovKQwh1Fqsy1lK0q446kZogm60KYVqiaTHK18+/rsQTxED1RkQJfp0109e+pDit1uUY8fK aR5pY2skyh2qSIsJ9Xutvv2Xdt9CNyU1agyDIyXkS5CTNagMjY43uOd57gXj2ZA3hBsGLDrvfk1p dNBpiaQyxY3gRgkQFA1Az2EdPlhfP3G+HZGaBHh7EegL3AwKgxHUu3zPcch4eDe89hzMzsdBAkSE xg+Jy7LckHIY1sd66ZC1GO8YMkTTBgOnb4D83N+iBKbM1wWebwk3/jHSMEBcZBlZv4mMqTPbiOxY m6nf06ZpJ71HenZ4Tnzrudkjk5Ltz6d49Ry9ck5xj2lYYyTupG29wUefjEPoskY+fAdopOJXz2Sq W6YIHoGOsTxhGkQurAmE8iQHjowQPKTcgfKTxoeglvF4dfGdzrkeNkdl3derarZBoss+MNAdpdT2 2JolTwMwfohXJU5QfNYfevLCmb1bFKwPhdFHu7pJJIiTeW2zyDzWPpfd2Md/Y+c+8tskaSIMk2ls yW/SnJ263Y67TdWsictjllrNLEWc+7u2eJTyw6Vk7s4QpmYi0q1Tgz00WpKKA0ZiSyZhYpkhSXfi GRmjE0EKeiN/sP1HgdM06TWb/y5uqx/J3Pv+bj6bz6kzSPn/+XT9/7J+4h49Tmxz26y+Znp5bU08 9v/d+d/A0xyw/jY91Iq1uPWGUvp/8V7CeMnsDxHq2Xsez2zyT0ZokyVWQKa/EYVRg4p0VSvHRiq8 69ribX49NtFlsbMtwyGmCQOq+bRiSde+Zo5ajDlr+z7fsEU9Xl9pZ2OXWY69meJU1JU0tq2Lummt Cmn/antrbbozmWhe2Zgj9XMbQsEzOx/40HFE8ZMLlhvPJh0x+bDY5bOQGhSco3p3Nrh9/TjY4blU cWRl3st1hHnrSl0Yy2xs3waUbZZcLGy9MugwNIYMYNQkHjx1aLVQUYyCYM0EZDeKBXVUQTIooluC gmZvDAxtGxgxo0O6eVtaBlINLTqZEQWDLl3ix0WRLTSbzYVGXXO1g9BhuhppmTJdkOeDpjZi2MOq cNcMcYbVeiiY8ao6BifT2wq0Q1W1fiHAjgww0gw2hmeWYYzKD00rRSuAWkMlqhiNlVTLIkMZG2ak baZU01AbhrFqg7Y0ejOQRqXg4wgjioqKHROGpE0sRXSYcl0cMkndZoVTHLByEqnaaacGoYpIcNTL 7gUFBb29KDT6hDgIGhjGqapSpb1Is9Lw5zeOeteKVbJ3ic09l1n4B/MPsHBwcBwcHBkU//vzn1c/ 4EdkvJnkUH5mRMJG6DMyEa93uA9fU5Wmbi1MLExXg/Grx+AQ7zkjkfg42abPgjj5Uv7NePD0mnE5 xJWkKWDFTGNzRZW6tOwxuppTFDWmN1PFZNvVOHDGyeNaKnI92tKocnJu/D4bk4NjGK9lYozMKpVO FbWPNZ77NHi48LHIdkRz2yd0qOZ7p7nOTkn3+83n3bngiccdSGGr+SOY8eNnr5DSqo8aRs8Mhsrl V2xZqYY7+00ZkGGmylMGh5ntzPZnj04keIucTnEmt9iYVwxslFbq81c91xu7c5GmKYmNt3SNoxs6 8MSyV32YqllKVVKkmkWlppE3pIsXt7kelNnPEw39mKa6Y3DiSlJkQpYmLNpArVg/G+ie5pbYn1XO WaIVnujeLYeSWZW2ymcS6IdAREERC+kej9NVzOo4/CHU7PQt3C2GBdAjf7cBPoXCxZjdgyEMHAwA 4YqpCDCHvpBUaI/YaoOwIRkGNmZBGOYGGcpcfP5GGglqndk9ooqIwzFFbE0qKqJUG2FYUBhBhUhQ VGog4EYYGLFwXENozCMTi3Kw9lk4XXN1Yc6bal5c201S0lGmmpSPLPY3nTyF9vc9h45bQHIaIcTE yr/JVUjYYc4vsMNDO7NAzWzQNIgytITRJaoDhXFSjVYEFzsyGn56ZsrMwU4MRw2MRxeXDEsW0m6e /iGhWxMOXgxJNlKawgAzPQSZ/AiwHPn4fXzOwUVWGa4w/sPEsOjZ6yT8Ldu6Ob2mmJWxMJ72NmNJ SrWymxflfhdvA2FbnvadK9ebLp0qrUhtYQMBnECFILA8k0gfJTRojkr37TdqbNNNIxRWMjlowp2y jRyWTE4VN00nCzDZjFerc0VoFS9zTU57OFjrCi2IdjhHSkVJEkTIkkTLTU0kREJ5jVRW3VyPe6/l QuPic7ezz9R2Y6yHsxMVTnTLJvLreKTZYKqYN62azcekceTsbkMUGpiyiE4IYLbVmAYmDGBpGiKm ES0NI0OkNrURv59PYdj7ymuJzd74aGpSbqfPx7TuJ3mmGJSsmDD6FaNPHwuGzFdlmKmiqlOlMZwm HVsaHbsMVPTnmWRvD0K0p9Olw0VpWKlsJ22Ttsmj1bU8d8jRDc05HWbATTngjZYGR5XkcIOEyY7g 5rp1qoPSOBHRYeuQw8Z4EnhxesUfHjr/Uux7+xvPH/wSedPMOZ3niKqelUYoqK0mHws09imDxVFV O/TFVNlVQxRivNpWJtI7oYmxODHBStGFbqYl4q2PftyunRwkmp20k8vtnSxrxWSaqR4VzOtdVNSY 6tNmhpjHG+DZkxuSqmhjU4WelXIkdEEtl4yHMqCgaGhKEdVbLT9YLJDVjZehY+nwZI5dMmik3GHs J5sjyn8AbhiobGVuezz7h6CHmRNEieJJsSaO0H2ulOmGlJ0YuVRBR/FZDyg2IfceJvpBKQIPuGIT vqGG7uf/hyboPYp312XrXYkMkOGBMZse+MBC25e4lufow5d8PEZjYu86jI+jf+p9XU7bETIQZFz4 uknC9h19D47LrE3yg/4DJwcn0s9WyvYpubJ5WMl3lGqtavl/Z5Oxe1PGD+Uc46J55uHn64E/3eh/ W7v7SOiqaDJ5UtbugoZHul4QUe+ctNb7Tdbo5D16uH/MToMzFtXPKjipOTehnQZ5oUKQUc1U0dMp aQ48z617lyXie7dDJDax99QQREdAjyg3DeTE5S6g0MpONNscij5a50cOMaUcqj8ZZJl3Z2GMPguP 17mzd7zporQ2qytMaK12xUqZmFFmBOz7sDyGjTRwxdDOE0VPf1lKkwzsawrA29HEjBdvxwrFppUZ bCrNMahGBRZb9Bi4tZDfIxwqQKCoopbctOU0fhxs1tLVTEpmgdQyj8ZIMYaGjaK7M5FEymsMFiOq OicjUkNhOBMMasYPCDOvEPf2ba6eLBurbCDGDLC1oibbYxNMVsrMcdcGBimMR7Fxa0oyNTRqTM0U wZCs0wRx57/DoTfgwwh5VLlThCQQMOe25HPn2aT+K/V3OdIZQpEkjSBR3dvZ75oE2CgwjBLQeB/K T0eOtdMK4qHKBMSaDxvRBoCRK4fI69th2Zwh65NNGhwFiJmczHDCC+GZNOnKlSpfFXXubTS9Mwl4 pbcvo5nft5+HR0anlqh3IC7GoHAMG7vD1KY7GDYxrjnKGHBqQBjSk4OYYnpi2DJkTaUNxRh4ZG+7 akMhtq94NSRqTKaZlZAYxLlojBTUtjhNy0j7OIKf2WkFTaQNsLGIgCNkdUkK1W0+qI55DAZoUVGo mYYZmGW9iFKYWargiAYbgQpDDJ67PDW15Dr66OBsUaRtcoKJgql1sWykbJOz8tk202ctRrYdjAoq muWWOs0EGYQTTHDCDaGRjpt4FUgtDSKz08RUYuBNCUBpM4InFcYZu5W8mDGpbQmBbWL22reCwhao D1ERgxobbD92RLPLdwRSJFK0rjMFlhpmaYZVil7663dtGMBnENl83GYn4kSNDQDGhtG9ON2YIUDo Zzli7NW1tKUBlFqKEmpbEezA0NYmDMIBTsZUmh7nbcyJomMiZ6s46YsACjhNpph2ww0jTZUPRI0u O2LRsyGtr6lmsSwRJCvZQbCMMZRj3A1pSZdAYwbrqrHBigxQIbVWt6NWGY0bBoqPP087j57jhQXn e3qRLG9E7USpXH+TKLbXZ+OA4p0wo29mEGMAdjYNnEKViZCKapFjbFsWt8d4HQw7Ot9UAU8Tgb5Q 4hQwIvXigFGRgjVhubM3K41bNNxnFInSVwGC21q6NYayGMDBig0FdaZqqozfZvsTFSVW+btEqmLC oMafwIRC5kFkRoE9vNe/RQ2+zDY83zmPmLTctfDgNQIIaaiyRB8+f/4Q2a0+/MdMHUo0vZ92Bgxq QgwfYiZA1YvDU7tY3SNeTIMao9MUPsMRsTEY2mZ1KMDkQ2yJ9DFowgNYEIiOKUiqarqYQbEqSKVV byivnSisR72+h6Orb1u3OgfQscjUVTZRNrGKOeT26h5qc9g5ksZqGKKJo2MRAaEYDVTxnxphYEJA OocGyMwhGSTVBQhGUspDgqyZiTGIjGOJ5DKPMsG8jcs3YB5Mm2Qb7cGA6YAwZiFw7MRyChoDfYx7 jlkLqapBHQwwwjtayB5sVaGKsm9lbMuGy6cmR+Y5fDgodMd+jvPwQD7kZn4Bj4SO7dNJloZa+poH 3QhPfIFkDJA5yB9iQPqOYbnmBkwkcZZI/BOkNSYudRgL0h4yTiHyVCvyPsKOFIDyHh6JiSKCZSUr PCZAWD5FFQoxNMnuT09Q1KKYxIwfjdCE6yrSHrf0u8Y+VVVVVVYjm+HKeqgZEf711Z2X/Xsf/if2 1+eQN49sEYjMxSNsHu9W9ptP4/sn5vg/M/vV2vB+Gfh++8nh4nEpXirJmb3/Ms3X/EOT0nML6odn 1dTnWtq+aBzKhEmOIEGrDyeXUXMxmzkDMp4ni2J4aB9a/v/++bxCe7g4IKYySlyNzXgr2EBycPMf Zs9cpuyd0PfKaYUg/C38seak6rIWQ4YhYVRVVju23qbyZTLWlTpyeTyeEKNvLMikRry6HiHW63nb zxVDWZlEMwSlmZIU08lfl/XHwfceXX7jqz/P4E6CbG73L8rXNfuf0JhqmGSDdhHm0YJaQHyYuzQs fyzwU7nUSMfv0iNh8mu4+OOqktidHtnwOmcHXC4YtoZ5eLRsO8SbSPJhtmSJKAwPB3OswWh9uoka a0EjEqhbsFzg6J0sqkKPQt2Pw8EbBxjihaeOovkrCRYvGWaRiuCKWHjWnylNiJSogdAwQhKsRQLj iAxJfpP44q0q2DGWHrNh7nOk0L29s93di20sKDqmTmaiUW8diO4WNa1MUpkQ7GtvC7aseGW625Ny 4xTOqLC2rI8Xkyy0uNW9u1su73toi6l7YZpuZ2uVUxctqoGeszcPVI5qoixYjJlp1p3jerkqsm8x tE21XpZxspSId8yFnM1UjacVWHXbRd6fW43eGnopjBtXGrt8nK0xutyu1d20u7rWK+Yu8KhY3mTA 7m6dNtq6qaycUxyBy9bJiSJm9UuRi6nFyWzJpWgvJlsbTtuYinrLrF00REtCvuy8bVRFNmQNkvmP WP/Q/CaVGUJxuF4XTsbca269MDjnvUZqV8NPqcd7UV9nWY1bMYHNaDnMJByGO2r3lBkijI5DKebj nM1F7p5eljv8mtTu4yrH5zkczqiCdLKp3KQ75XxIEeotSeBdkvdG5JXfIvOcJU4jUPRvgvErS7w7 SjqQ5SJxIJxCGQeMdMinQSLzlCg4gN8MDouRInE6tQhtJQZKNCmSPEUFA5IlZIdEvFyhHeHiFCkO z6YjfaAl0+mLl9mkFYhY1zqLkaXYh3qoTOfToHXGIaliR2hdbYO8j0axTJF2lNoQOmyHnBxIY3OD eQ0xG2JIxMMGC4aXZrTMYCF1z265vVJ0PW9w9apbrdU81rd++J6on5p96SA8kp2VQ2N1mML9upNJ YIhSWX8DbCa00rfm03JTvqMOF+5Tk1OPlyZ5MRtu7Ue1IPGUggxyEcwyUyCwMZmt1TH0zzxPMdOS drdtJ43PDxed5lLbSdlvNPKq45E3dnNyTd4cm8Oamqqlni55zlTSlrzdO3FO2WOOO0cdunAAihYq 4hOQkoRA0ypMsFBJ11FsSoQtaiG47WAxpEfrKq3ko2NTzqC0EwqcsiaIAw6ewwzJpsdevWFBRWKK sjlHmKq9cZPGzXEMHnSni5A8JMTGHkGHRwGtJYPRSQ1kLj0NO4WDB6vYzhqUDG3rAbQ0xwajPduA 4KuX9Gh3h6eg/PW9szzUL8w0CqIaBhbvnzGqVza5dXrbt3DGMVWMYxTwVhpjGMVWOpox1XYypjk3 cOTx6dVqGN2MhKeMUSsq8NXI1RDY+S7DOrPWBNQulddPg11GKZLZpXjTq2M8M9MKNcsKaGlLdqtr KStFrhj3DTCiYKS8hgSQS8KaHVdMO2UFEFqymiGUGBa1UMmjKAUMUKa4NYMKYzY8bIbzhzLnRrZC 7HwjPlGUpqsqictruL1SZI8LEkI6SjMxRBQWZAqMPI5mQzOSphEahyrrT00UtPqhsgqZfMqsa6aG bMFd709FvprfVvWlFFUFCbFwrQ4QMglLdsqq6kySYMku1k6nGcnpCS5nGIphhyBltVRRw2WbFHSa mSGCpuxiipNsusvWit3pglWeiyjRFvYaHIMN7bSqO63Gxl3NTlAKm2Depch8qZIzbpg5kUjLlJqh piRk0G73MDbWCLmFNviqruj08TSNTSUbWzCbutFDApGWaZ5RR9DGmNFsYStSOPLs1S5qh4MnJUjU ZMVTkwxQ66dimNUjNDXWNelfKraNtWTB2EneVCKilKNtgYoLlHGMZGKXbMPG6uTQtZhUKRZcPAu1 XVkwkaYYsbWRBqySJJrBy6W5kKsMl71tMZshsHbc4PZTCxt1nRhLXbNOM0xMQ+jZkik1rStmJOWO OGplyEU2iqDrFsmpNyaF2F7pCBzeTGS1TdD3qlNKYpOaIHZbaxR5NaW2pjeY7YPpEuRk1CvKvA0s lKkPm1NC5aum90KNTU5EaH0Qm02UTux1QpeuQGP7zs9llUIE+IikqxVioK6ZBiu/vad9keSlOMLD JPiMOQwwsnRgw7IXbqU1lSUTIz2cg1e5mlCKNeGvJ+c3f39e3Jvro7KtDIKJcqkOvCn4XrhPDxfo mZdnoUj8WZWuCg5DrpWO5ZVQ2HnVKeljFczeThxMZKaai+NkNdMw6ThwZF60vUPVqDBp9Pw1Rewh REe2giYshDzHqs0NY1cSGMJAcicTwxItVbTi2RjQTGxrkZFtGw4/JbHaVrx3WRahRrUQrN8MfIzG lG6OnTqqgCIKZJpN7iU0x3dlabO9ZHOzSpYc6xatJR9Eug+OMOUw54daG48GBnTPV2GhlRQW5Up1 Ux23snW9ZlTu286ulKlh2sXBT0gCgxN1nzvdFEZwexhdPe+6PmvpCH82k1E1cd1kd6xPe/a5fM3b xyfoznXz8Zwu6A6JH3Xw19+hPvgndwQN0hBOZJyk/QSqHyydBfMQi8BKazbq427qM25IO37DB8QP i9kNL8IyBoIj1WQ5GJgVnNaOtitX15uWUqllpJUFUspQwHsN/59CfVBvFHEA5DbptI4VU6lSRvr+ cfJbl6lDJoKT45NWrJTCDMMCW4gdaYk+nGPPTrp9rTbgyfEV+T/RnunwvKfNs41jmhiEfJA+MkXz AwCCf55RFaEkkQPU76vw5Nl8XRvs1LOnGzDlLWx83uT5fT6SLr87LpM92w6rD01mWSCIyh+uDwgM kk5hEWQq1tkROlhyhkP++DZmPcTQppfWhMytEXvLXkE0uQwIVGEgW5VyQhe+/N6ECSEPH1LHXSvZ JpTQSSRDOjJCCOtoV/aXgEoHnD0YpzgDthUH7mH+xs38qSf8N+6580yZFtYsTZlBVD5yYbHLG1ss YahsWyCg2Vm2N8T5+x9pY39EYkfiGUeU/KQmQiHdIcyEXUAnngAyUUL7s3k/NKbEyEgMwP6U62Kb aQKY1NJaphpqKVAoZpDVsllNtTDUUMVsxRqxZGFoi/VKm0gOmmUiRIKYShRKUaFQ/brFAPugdo80 oidZ/MbaF9bvxSP2vM7n6XKfsfT+edCbLJP5cufGpO98bIne72QST3KJPSzJICPgscKN4/WYgOgh 7yFXIVHwIFfohBFP9am1k5XteWROqvhUPW//thEh5LEJMog81NycFOgkwkJlGkUB4q+GpkQHwb5N B9dTCSc/cyQ2rZmAm+jJIT7aQk9CtIsIs/LkT4fHmbD+SGzPIDfj/X7dYZZqIlU/yEiIfzXxE/Bh N1AoRhS+gLgWRSaU7YJ++pani8JsH81RyOhhyHnA+8hA/YHhisyjsSru0fYxIyyfgWJJ+aUaFpVg m6Z0eTZVB5jhWSCrJOLJJqoOIs81Pxz6ZA+y60lhuLCRkfEtKPipqof8pGhKUpVX/gEovTBsdwxA mKJkIeEG8qcpVDmQiZKIbnZPSj0GJiSawyRlTaP7EQOvZR0EOH76DltFhvswSbKYrdpyyJo/B2zx bNbzfDwbyKwqWKK/GEhto63SmqnRBMC44RZt25yWk3W/dmbyzaaaH13HN344fwIwVuvEDED58cE9 ueEIP2EKu38yeHn0r+qYbzRy7WbT72ZX9P7/5WzwSQ+Kxjv5emtdj36d234Jpn80/XXcysmLIVRl jFabuzdPH3H0Ng+jGFGFGFa6Q/fEHa6m0stTzMyLSQtRTiQA4taf2XzGlmTAkgKGSZIiJFqwz3W7 fxc5Yn1XYdKalpGIoCCUiEgloeFAOd1Ox04mNtiDGr68ZXRYmRYGopDaQPa9Hr1jlsps3Ww7WyW1 M6bOQkTuHWPUPPHFbNu02Y7I3dxsdqXW0jbOWEsZ2TEth+B27beW1ZuO41Zna2wVtts65btLnG3I GrKbKzFbdMx0MZ02ZukoBKSYBoFoQpFaVRpBscVkkQRgggN1AN7WpUoalemhRum0+Tth17mc63pw lbx7HnpNonzbmc0vak583DJUNSiFItUhEiLhIRKm0gkllrDWt1ujZnT+00DRclAOi0BpSCWCNSK4 Ss1KlCBEqm8NUjhCsQf5d1f7nFqmz1p9yfrT9qPu1Zsst+Ez3uMR/HsvuRGxsT7cv+OpNkln8UpO awfB/gxy/57z/r2M+ZE0tM6faspT6K5bJWkpZVttPdmu+nCuasbJmdp5PJ+hps4jCiKotj4ieJ4m Ewo8l0+8NFYZTMj4kA2idz+n5YeZ3u9on+ZK7lV2jCKmN2jH+KGc7Xizzu6f/L/+M73qdjGL9W1/ /VzZ/W87htj5/rOL+7rOPMeYh+3/D2e92q3T8Dpg55cN8eulWPlr1pr8Ssar+Rz1srvZKaSnYrJq JkgfV7znBLO75eKNpcB+lYKVC2MqRCYFiBjBrb/pRV+kpamxDDyJKD7ut8Tq1E1LUSiZRiyzfFyT z8G2lCJ4Ic3shSekcMkOvDKfqOMNJsEutI9RwYbUNB0WMzDHLAwoNrkWkKjRtpyHUVRTsRj07n2e QbHn5nyHD9b6XZEj5/pTkkqV/ElP41VVN5OHNz7/yPOnV8o5j5ngng0J/hD4PnbOT3vzPw/yHzCT 6BU9E+96J8VV4Dh88epo0rKvr27orrOygaVA0veUAxMW+EgPdZjiWESX8y7I/Ic5+F7HbO2P/40/ QKxS9kwTjecRwo8MkxFXZfYjBqcjIwLgxk1zDxRFYMpvUX/5S5BD7Pul3sPbM0otCZEkf5jgiezq hMhkhjy3b5cTdpq8cOa1rhOUzwhJCMMDFxWNB2OaYNgQlH41/GbDPQ9j0thxLOTOk0ck3NhTYm2e TaOnUXl06dshwKl+dgCcYcEJlYZh7sB+MnYh1/jOZsjQtUsTHd1Ydf0BA5HrSEbMMgw7hi5sEfl2 fhWIhx2r6URspB+mkhkskWwk2djPid7IuHoojGZH52NtGsTIpLSOtY4DpQEHzgQwZZD1IsCjBVBY ml7GCs/5mYF2YMa//jRxws7UtK92H4RSnlK6JIG0BjE+rOaKDNPA0e4Q5Fz5A+RCTJHyuh2+X4/j eijVfjM62dvrYNlyVG1i+w61N34neQJiDxE2zt+VaqIithMHVPCp8tb9ePX5DOrTk1Ycbhx+RrlU Fu2U/vc9a564FW2cyZzMxQhJm8pshFnyv+J4jpQ1ado87ZrRnTyo6VbgBxFnBLTtVuc7vGh95lyr VMA7h7BBpRc08+w29cjRrbGwcA9lIkxYRknuCSjWu3VWgwmijO/kmKDR/rB53fpAy8ofYl72RlVe wiMZI0K7N6M7oesWefhWLp3n0E2iNkN2w/JN2+9K4i45p+v0PYeJEfOOTidp0p4zUiJy1RuDJDI/ CjgP3nL3GSAqiRcSiszYiKBczYxFp2YtGH2fF+olUGls38rgaJxH5hvCEBJQuGWKeIed4ooU/0Dh hh6QMFByZjzXTA+oTIJXLgMMWZbQ/NvuB27/gJ8GjpIi26RM6hELJ6cEkk5Lq0w2HHDINBcwoGzY 8vmIJsKBUeCyOBxXnJQyIBFOGRMBLDpAUDzDgo8UNnh2jUZgvxhhlfZ2JmFTvOsAhOwzHMmVMyRN ILAtWzDMYOYUxeR5GRNX06znh9Tr279rc3aTsckMEKLCHAmU8C32FySInIaq+NaI02FctQCh+jmP NXs5BZe9EkLkqi1SD3piyYXZRKk9ueup8HXp2TEfNDGD6CTE5lMjpO0oksWJprwu6oqveeFRcrOC EboQZwL6M8iERy6fr/6fKQiwhgJjCKA3M6carxZRQjhgRJirCFQNQ6i6KaS2F0U1mBUqOF1Qw97k hz2XUYdMig6QY1d9xhZh4VRRu7udeMWbVNZV/X8ljfp+p+ol5UWJWMFb5t+p1erhaptvC/k5+RAx CJpFx8MOyA1G6g1bDLoKrm0d081KQ9MkLPRxtPh0VXhLcGwOLJHLu02WSQebISTxpDceacEe3Xon V7HHxeHMjFR0J6ljVPQVDtp6jkfHi6j9OserMj0SBXN5o8fBmzhX2JbTRCIokkHh1KRDoMKZatw5 DGxc8HlgYMZV0gFuQEj8bBMWYTbwLlDVJ8AmysawohPWUclZDjmMqg4e8CJ3tRpOy5vJLsZL3Exg glbxvn1BksknoJB5GNXpwo6Dll4CRFOoexQiTFfT+KowPRnIQhtISmICMpkUegKIsMA/4nP4yJzR Rz0rFSIPFAitmNy9tZmVmJXqrf1tRy8Z/Ly+NwwbqsW3nj4Uz2kaGmb7+46xa9PJy7YbO8WJiGJi ZfFxNdRyJRCjDVkvVe8URLzYJFnFeGHCR7j1tmlUQ4iJGD2cG6hFgehjhMI2ATAU8fZRUldR9Hhm ST2hOs/BmCLo7MGfIxvM/WioleKu2Zk6rKiarL/eiwExdsmQyEk/ociszh8atIj1aFxzok04PK++ ZFJAkjkvETwH7FNoi7zNwVLXc+vkmS3ELP2uEH9a2nIAuCYScwop3VWMLcgsyawRc9OHLYXQYePn uV5LOU72JsriOsd8W32fwP7R8isYpwwfEOwOB6TAwB2y3jrd13Q6kV9GTMjTvTSynYdpUqWK6qrM NRDxbd3Xmy3dc8fkJIXMTLrqTLlY57xDANO4+3dlI4slkk89ro6ueH4V/93meL0HtPf1KaU7ojus LIjp0k0aVLSmaTWJ48ojJZwT+H4X4W2/qvy3XrzuyC7nRvpXN704c552j0s7dNWkylI1TDc3Kf1B ydGxbF4/CI5Pu6oqjffxGyMbG3JGNmThZfDSHahvvVVuhpDSGYVlmHj3ZcclEfFS8GcGVZTTEp7j +KE7O9gfoAYNHl6H23O/eFu7NkMyHfWs0fAQqvguzp9UBT6xnmkTBy//QKBARA/mKBs38hIQuUlA lgwopRWLF2wZrlykCqhJIp9p7Tg8zd5HH2B/vP+JYyzP0LYKpd/86yGmbL2C5CzZOQML98PQ/zP7 3xOm/pC14zy8Z37RHmWElUi31O162MY1Hm3nVrFOx+ImSaeYmJMeZNPjgcIaPRyfV0v8GGfldl3D w6vkF2Bw4srpUhcJe0sZO3Mdy4/UGIetvPyu38x3icnkdNnIqkV2Jpu0xWPYkm7zjQ7oYq5NJHHq h9RYUh0Sa1jua1pZRKy7BIdxOn4zAn3j9Q7I6S3bHc6D9aftHBJJmCoi9OZEST4TCAZZm/+HlFS0 Gz6INwv2GGMlcrIofXORJFzh686r2nEojUvsdjklms/kQ9vHTJon2u3Uv7/HYiT4n6r53jetKlUt pNSjLPqI/vXSyjsT0puUw2JsqpyrLuWZJZU2TWZaC1rQtlvoaPrzoiqDuIRwS4nGWqlIJGK1rVFJ ElqKpbUrKSVUVVMRE0BEw3dYz1h0HWbO2kSxLUkpCXz25WiVLC525JipBEWaoh7/h7TeyxiIpYKa kMxQyQPtCcrrObmuukqr6Ls+s08VJzi7uusAzDGcbGHHliaGlnWBgwRGR07s4m5WabrtZJrxzn/L BiKWvBu/w/L88x5TzV8nf8OxjdKak3K2zz1VQSkQUEfsQWlUBfmIe76FnD7LCJMm84a0fqntD5+b fk/lUaXRU7DuSNopUsgruNibl7ZnFhpOmQ+ONikUBh8ERHe9j4f1fVDWUozm99z4DwmGuSP42Qo6 oq4Cbz7bKkZy6LDodLyZnhMGSSIplmOGBU6aaxsxZ54wOW70/vfpHXmfqshzOWOZvbcWPGKx8tTb aM2qp3DJ4IrSbQeyQXO9EpNlJ1YHhOxmyyRxYYqXpegQ0nUkJsQzJoFTkr3BsfxDhjE4PNqJ2ppj Exj5/tB3FQadHe8U/Cxybtzc2aV8bZX+d0fEfKrzuam2vIyOaT4DAML5/P9qK/0bH2b/mGNw+Wry hN4ToxYxTx8aan+UheH1yesKA4cbIs9IcPHHMzZHRcwh0VCz2OiiBAcMMPBmZnEFl2WqmQNzmVIA axBxfVmaA8qL6hTHgpsCxtCc2Ibl/dmo1CRY6jgGX4q3CyUg8kDYFZWBPAkkzjmrwdq3HCiwqqjf JO/HVVaR3psQMC1FSvOM9AWhEUhRYBwF6iMD19EMBI3gSFAPEGC5GI8Khqb1qN1GFsmEQcxwYIzR xpUv1B3Wjg1yDGJhSkORFEP0SwMiInrgTtFrcMLLNu4h81QdUUT8uWxosyg0yMKRGMq5APcT8Tve /SSVS5Z+R+I8/Ke1RJ804QYct9BtCQQ0VfpF9A7Ho2InsdjHU3TE9622Y6FnnS7W7SoZqeBofEHL 2ViopTCTkVIjUZ9pB5jLCgl6Hcsk6sw2VmWcTRLO1T8bEd3b3cPVW3uPkh2D9j4AdEIDL4aZrvDZ 8v2A76H2HQ2PaYGyUBkgPsV6/Ds2OwXMJoYlmiJRjsNBoqyps9L1OEmZ+N9TzExM/0vvHTo9L2v7 mk7XZfq/Ye4/zWMjw/M7sllY8z2+NyPYDYqfWfqyD2LxHruPVPMnxiwlSwf3SxGMV8Da/M+xjtKs P53pEpKw0WEIkUYL9/71wL94g21rS5WTVn3o+k4PzeZ7BxJutFj606St3KHVHEPx8ps0pTzR5H3o MSSH20GC2DrZqZsrJDZ4zWbn2R8U22fMmb+2jbfxpg8TaTE/wt0fHf/mvnmfytoI2U/Vu+TX9Kor 5mPrRJI+2rN9uNEppajU1EtVSJVVE0rQ0BSlNAsQjTLKFBWVsqmVtqCmrVtaFZVGorKKo7uzVlKr U1a1IVIdk7nJksrNWi2rais1VsUyimltRUtpCWLTVkqas1ppYSbViRWSUIhLalaKAmUmGiokpIgm ZZpZVZq1oprWllkVo0KUpLKaLKytQmsqgEJIzDQlMsDElMLJMk1iabKKxbaCtRTRNaymtKImVWU1 i2stk1mtZZYtGkaqGpFtqq1WWtEKiNaxWy0ky0yWtZqahJbWa0U2kTWTRJKlWTa1mUiNUiJkttaa 1iTUshFsqVzs3LYk1NI1ZrSTNVltW0VbRZJlCRIylNq1ZFtZbS2kkoRCVUQtC6Oz7D2Po0P0O0nQ aH5yV606+gCSVg5i369FOEZ7TETJShE1DGBODDKmSo0hSKYYEYpSZto1oTTiGgiYcVaVZkqUUlSW Ug+qoh76RypGzniMlYlN9+hOvc5HwNaHmSmTU5gZMyiy1qWkWWqqJnLbdZU1rRYpO7djoso7rVG6 bSziZpRMUU1bZrWapbKMoygrbUYo5HKMzAKoIJaKiJpVXkftSGXowx6mImJI0h9MSH8JH7K3/63v a3CB4MkrCYQI8GEAd/6/p8md9T/P/T9JyKB+5UKRnFCBcyzf8ba5a6ZdYzVe1KBSDRJgzrlUtRUS +RcW4xlrOZmRmaaGMgpacaykyBibGVOC9ZJeCzjOd7JewI/O//Up/zJff+VAg8kNJ3rVJanu/i+P 5PxfNMp8ce2N5kfW8Dv8H1H1NmfYvvoQsb5VVClOJIohpwZBg0k1xklkpVmMditafpTs5O52NPDP p5PVPtpHp5dvE83d54yDymedB4Q2Cgf++i9NkeHVdyGkMgP7RnHc8PMglz54S0NspB0YE5fRgkfL d4Qi8brGma6+R2pMMo/nEfH5kTGBGLdHHk+dw9PY8D1s4e2m0p3PWlZ6HiVjOODwYiM+j8cNDyTz 1wznBcaiXcdpERinfVFzog8GCFRHFlQ1O3C6OQ8URdH81QKwvcdSpbBkRiZR8TmopwuxaNolA3N3 CtgyHjnTfXN7zYpQpSKl19Xm6PFr/PRrpp0KmiyBzgVLXTMULIoDrysKqj6YjNKPivJy6Jcawhpn bZKqrsJZenbc7ES6V1caYyixsZ6LHI3+z9qeniT1aWQG9wd9jdHrASqQuKBpYFVS1Wgw6H46kFGY 4GZ0RwixOssLmmlKrksnyxM87Q3FrWHLvx4or8Sat1aWhRMuqgnpfB02RElSbVVQ1DKi6mFNXdJG b3CHCvLazi3YjjBZy6iKGvbTH0ifxRx0zhj0RU61opeZtSGZDpu3+jgYJFFF7UYbfmRr4YZFyNaw tq8RVMjihy7Mtw3XJlkCgqBHcuhW6HO1Nqq6XhUMeHa5eGDGMzrjCYy+AYdeW/gdh/WIeoOJo8Rm ZB0QUrpAHb42ejXebnreRMenMLZt1DxzHOgEMhxe7kPbJrNfjFWhEZ5Ac4rKWqXTUOcZvetGoiML pYWNDJTMLjTxLliwOmlVybIR+DknDXTXhgumK8i7c9OaXQ7Nu4UzBzC6TPzjjsJNCnLDMocqHEiu 5BqOeZLZqFCGnZOh9j2im3mhMpOVZWUrTPjvK5OdIUfB4DpuIMoMgmMFWovLvF5+iNmZG6e47zkp aO7dVR087bsyuu88J4dOsG1iGaXCQCXR8qXnQ5PwcXyHtRH4exwBVMgHMkkOEyEHLPTny5uh05Og 6I6mYKtOAs/m2adWc1F5T6bMVnb89PjPlXKGLp1nT1Yw+NCl4uPba0arBxS8aHGMNUkrZR0p2Qi4 c+GZmXc5w80R4MRRb+5d5IcHZdgekFDogqDVFELqCHi/qGJjxGBnxTzI17fN5eXnxo2tsPPpd8PL vHRtinayvsBChUfbJTRrw+7Pn9BJk1559Gb8uKuWt+enV020bcg63BG9ImrWaxi+B8yIhyZ7LONX lWDv9he+k13nFag0d/J8ds22zlrmyGc02NDMjb8pxk3w4Lb8Mtg4aqWn12XRU2ro6qW8tSx48uhC 5LDaYU2xTsDBbYqFXDmot0nbEbYZ0NUsSK1tj4RSPVIWNTwqC2//L+z9ZSbUoXSnSmLyy11Ayu6M jVHX9IOlTF5nbU6CdmbuEhvvUfGjI39DJxrl0sjnnGl7ZPr/dmeyRsGOm07J4MMSRR6CWS9eE0ah z7bsmX2pCB9lxXxeXNeRuvaPtSfr3NklK1MpDIIMFbm2BnI0dPbhri0emYzNc1eyJDrqJRiQ1OiF yNrTGKQtrpVFlZFKFMWLqR9k2qIms3NbqF2wmPFsy0KKWMMqmCtvobhUVt41Ou5UVo5xvx36zG9I fMS5GsePl1kbwIPUOHtptZ5/Q+34oBCv6iip/nMPge5ICJiQ0IYIPPp+hfcXx6owWerL6W2U9fdO DMmy3J0iVK06RjPLXdjNLzEDim8unlYuoQrMg+cC3sZGCGGYYMM4q26EBnI4GOYuRwOFEXMgYC+t 8Py33embdnRZwF1Bs05Pg2l2i6j74oy03S/azq1J0xBN4EpBLSwI2NzoYlUdqdXp1UNr+h/wODqe qNKmln8t9L11TLWMFJz9DnsvDqo4YoFQuMIxEu8hB8OcRzcgwbn19KScczD8KsogvDUvMU8qcL8l auAaHiDUKRYusmlZWDUsMoRjuUorsKsrtbNEvJphlJwZEFYbSv7O4NKbS7dN0wzzRU1O6aSR4IXI xSi2hUaGQtmMSWHkZK4zTKalGVhUOCGJlrW9kaqc1pqge9uXjIk6Y0qGJTkaMFrRvMqOfJmuwQm4 sz2V+TkY07jNyHDNIh2gfqVEEOw58Xam1iTumCqrlH77WDHd8G1LX5hEva6kalUYcYeWwp6Np8Ow 65E2shGhyD61I7KCKiYQxySAku4iPAkaVVDhvRT4MMidGBAOUofGT6e2fv4cTbfZiSoPxplhID7O FbSkqCaHFPxyYSkKZbGiSeJqn3+hcCdr5W3NCml0uDM4pAqOqW3YzgnK0LWrhoO1L3DjqdcNcDRr UmYVeaxsJJFDjWyxtkkU2spqTljH4BFnZ6f0TuUng6Kt94Pe/LAmRBGQ+fK+YTpL6RhiaQeODMXX q8t77VVdimGPkliwNJVyZ3qJdVzCdn4C8tvwfQibLIGnfSkUifkojcq3gxNN5wHA52odMb6gDxUf +Pickc021SRrcy3HSVH0MTIydTl9LZu0TO3jqcUTlQtJIZ0TFRKUIFOV2vKkKLXJpY0t0x+e23pk Veaa6bNMZu1l3tpRVApmJhsW1aq5XZug2pCtumi51pr0wPQrAQKEXkkRCqpY6RpoVNUb/HRtASar jiXgeIQncDC6rc29YTykNVKQc0VLi4bIxfRxkxdabhW27wKh4LzAyV0xi6OhhDptltRLy0qKLi8S TiQgOSyJCj7Y3WXA5YLgyRroRxbOFciTzJwHfYhnYzoQyVqmjLGRkPGqHIZuSk3IPbDPEGrA0+c2 6b4gphFrqLRZDsQ7dLVlIBeYTUZJ9PniFc8tmZpx+eMw5yILMMJLRmWVtWH1DE74C4Ph+EQ8FOiB RTpUI+HLiqdcJUK8HbDCGDq8dT34ydrttPpURRTM06bdpNzt1hSLdUUSVpUNpO3mmh2EZQt31q7t D8k6BDfMyLjCeLLKV4lHMpQZUaDLKDgZuRsEz+TAi2L3rE1lbVsVmxSMHRauRLpdfUAluFC7Gnn8 nADugwh3Ah5zCAusF/WU1OWb1w2/NyuEJpoMOlHQwYQoFdkloI/JSVAq2ZdUwQv4F/wqMMUzgfHy cBiuTvuJ8Rpo33tCO8bu00Y3mfdi5Z0M40QB9Zzh1qGOM3I2HVLScH7qCyDwNg7CZJhjoB7DzxBG yFlxmzameuz6uaG7Ok8YfSobvpE9e46E43aRlQhd0LtC73vZHmwdHRurz+07lOWpxaVjca67Q6Gl 0bcUfgFQlaIHmEdnUHhq3HgulN3pHw0x1sY+zj+ie/9afX/pVJ2/jZOv0P6jd906P2R7v73X2v43 +xWK7n+6e2fpj9780xjMuTH0f1Jppew8JweBzj9dNK5pR+inPbIfj6mxSlU2n9MN05Kd6cJwmVxt NmlVn9pN2dyR35HnXmscbqn8DOXQ7mmmB+kFPSJs/tMO4jrhPWT5aMCP6zp2O08+dRoihV6NkBQ7 IVXX6WH6/Linw9RN9dNE0w22S6dXxbKU/WL2A5BwHe8nUoSjyipMTeUP2+h+YeeS/tPiWtiR/O3b K5TZp4Vi4p9luTJzdqPpT6nh9L4ufmadV6pnAwRjHGknqMV2c57LNItaqiHk4aa/WoiaP435nJyd XV1bJ9YrxGFMPh2eDr4PwzAYXuqJIgSPgRJjVGPQHULNaMk67yURjZZ4k5w7oeB8zEx4picJzSlK +Ds7Bg1hYm22PuRRU8aIDCh2PkHQchw/P4lWMzgsFIya8DVsrwfDmnB7Qylg+V+9sOiMwY/TDJ0k T5bqtBsUxUK64EjeDgQ7upRscw1JBKRtiyELTiNE5w8Hef7V8JDSOvM1RMmtv62Yx5MZ45iRmvmF DFpRYmLlxv0HJHVatPzPyziJXlTY5A8sz4o4+m5HKdpvi4H8srUqJRLpcUmJCWmS49Mi9JOk/U0F Le4owBhdJaNt2deVJcXEfs5P5xP6uuzQ52gMJgXJCDMYEWBNyIgoiVzqH946hkSHjst8F9i1b4kI /5CykCjkDpgfQqH6CPU2oa4m9mwWKEaBVagx9AjON437HZDCYP2DPIlyq8v3zAhgdNv45wd/IpvY uJOlCGyZGFCqYyke0PgAwwe41JhE7y5BUTheYhe0vQICLB5j1Y+QxIKqepIuQJEiAw49DmMc9woB YVDxGO8sQqJuYYGHHityRmSKkDA4iJsTsWT9pvgQYXem1IortF9gnCKngbfVZnTcl/EewGGBwMYx gavGcDryqnyfRo9qdhjDn8ObTvemnM8ZDJtDaab/C9XVsCTIZBlmQLDHhMVxaCkKwoi4OhgiqERS 5FWHXxk42Nx44YkWYZwx1PqJEIDZHW487xjBZ4FBQRFDHApJ6kor4ikKCZoOcGfNQ7yonSPYZnBj fI1B5QIQTGZytU5DhysmQ4YtXVQUHIcnJyQqhMnEJqIdT47oiQOAjcdPU9JhX6JPou+PokHuRaSO hewOh+BU4lMY0/QkQzzOPoRz8O50zHh6fmiA69ZzQ1po4P7CR1aUn6SLe+KVgtI7uExNI6bSkmF2 Iu4eeXwP6nHYehCfHsQZ/QTwlx9ZZ3ccFVROdO6mIf08I4qn8Fl5pzbtUV+wsoo17dqsJ+GvYMaE FKVKmfuFlJmYiQ6/MVD6FQsVihkTtexdioZsVAjt3lVZnU6Nu6B319anGrQrrDgYZA4H7QUPwVcw rK8NaEBzLamxntDnIzMEelAcZkhyqvAuPIDNeJyplN73vuU2iVkTMFTY3IjxioRNEGimSGTFywww UI5wCjDGCOOcn9A4KWkpV96DwIgFLs6TUcSPmlk7mnqVx4eTTg8VbPFXi72MGGwtXpoOl8HjTGMH tRB6I7ehcNEEw6F6pdXNDrxmJnAzg+0WbWa9Q5JROLFQp3LPoKObNj1fInCMdnB0KTYkqKh9qpoI IUGXCmP1YxUYtEZ8EVRi885FHzbQ1DQXIIL0XkJmO4TlM3DoLUUxaCzBxEzMx4mHmZdwooWfPvp4 cWl3uGYiczQ1OplBhlFh7CDNjPR5PXt9GtNyX6w3djzgoyh7yHuKrdps9xEdmnEOOuRwp6ENjFhz Nlnyvmeg5IPi3eTHl/lvIeylX10xUhhlfL3DGrgHscarZQUkyCJHIgKAmAYrEyQ0Q6NASHWdHQY7 xu4r4jID1Sw9Z0zdWdpj32Ym59vQaKbPdzVO7cekCcccjMHBgiUCqcGY0GHrwm0iHNjBQoPHBQSz KkCIxAYYyIuJHBcufeLf/PYX7DlhRU5Xo9HNuOfxoPDxgUTAYYUY8B+uxyrAIkkdE7UhAeMR94qQ FBH+rpof1i9Qycgx3YJhZ2w6Hkq9zttclx6D3oPnnOYcHiKxQMlw5QMON4gnH6hI+v3t+Y/ihAdz u8+39v8k+3x9CdYg+dnhHBjq/1O1j9hrJpoz96gHMkvqTAelSDDz7SRNWX7ZLvh4lh5B+pmMbPrP me1OT+Z3qqq6Q73i75XH3prnvMpaF4wPVYOCqX8+YVB9v9aP8sR6kREyGHMBVIuL9o8/qPSRyQgI KpgTtDofWQF9pIp4/6XKonMZkSFX9HuDz/O5eSZBDTvO7vScBZAV+X7ip7NEofEo+NTy7/y4zvY9 bFY6NNNHqjTI09Y3bNnPZRO+h53R8Vff4nJw5mI6lH362F7TyMT1eBuaDqJGBEtEeEj1b4+je1Hp R0g4Xc0GPMj4HkQGJhb/drz9EGBOWiqeb0PUeb0XqWTCwtKPT4x5/9beN+a+x0NggMgg2zlN4iAM AwMLGZD4nPaOj2M9TlFsxjqnE24jVhxLPf1bIfpsd9jvPB6GpOJhmWbMnJ3O+LOyWe52R2nLo7og qnIQRU1PirLZZJwZCESJDCPsQgLqK+X6s4IlV83k9DXrehU9imFaTwKicnKLh8kMB7EPW57SAxAu LCgOAksiA4MjKIwcFvmcSfGdLknCx1EhsiH9dGRBo7LI0sKp2vLc/iqIN0QWf9h8uOzZEGeW33hD xf6m8eM/vlTJZTY2Mn+M3TeeSx8zIIe9hxCYkgCQ5nM5meOZkktLG5JJYS4QwwhCFP0L+yNd/jTR ruifovB8hvITz0zQPIHGb93JO6jRNkh8jy89CbnJiqqrK5Q0h4LFd/hNJN2xBKGUehU/xr/PBsi8 g9Sl2cpLhHEQaL1iDyJ65JCeITSyHvOHONTFm0+Q8jySUxTQTCqgPWpUHhFSHIej72jabg+znH5X /7+vSJ3IjsIfd2OxT8OGWMzCrUMEIhEY3sLRSlgbiH4dvRb5HcpGombsOV9Im52edtpZOUr7k8XD 77wTA6hiL8psca+F8NB+jpdl+3Z9aqDpEDxBmj6a8FSqT0r5GMk7j+feIPyfCdb49CDyp5ONNKNg 7mDzkDpCGOw0lL+0elCXUHnBqOCDj5n1B7CG7ZOlMK9PJLTxA3cPVj4hkvrL7YmDwRn44f6TczlD g28ZPgnpMTTp9dpekwDDCCK6IQHJdNJ+2GlTyOnQoew/QRImh27Eygx3HcPD1HkF+xJAcwX3EzOl +mczw7G+BwxAXh3jkLJJIFI7fpmv6LmfuQkggGiY7uh6uXvt3T1p83zvQ83ksQxjFWHScR6tJsq4 7bchRKFoSZElF7Dk5MKAv2cZr34//Zt0xH4C4Zezk38fUxQIZiy8HGoCEZD4kg4R4gbODMxBhCPu 5hId58DZxU58mbQnk5MV6SyY6N56YjoyRZYfmP2frbdfwvm7D/a9Dm9Z+h73z+1+T0nkXmwzIFha Hm4Z/v173RCLe5jQwU5DJMMse8eeeO3b67nHO4slmWK2tNJQkkkh90hh68TcupNgMJmENHy/KQgE xk5DJlfQ8zMPIwSEUgvoarm/4sri+QKZ9Ppfb6eM7Z9KzltT1RBs289Kp6l1Fc3t3DRRt4cHm666 TqI++aKopH8J7z06DqR7Hvc1dXtZ3zu/bEHEQeh1dZ15RjFxYbvcOUMOT/M5pFx55Mwx/ceR0VEI DjMwxt5Fg+98H+tPXPypU7q5T7U/6H8MbD7nzNfBv/r+h87r75n4jB+5gsC/IKQTOgheTI7N3r28 vfWfgKi5plVdjf6fsS9scQv9z6TufW6urRnYu7TtY4PRkPIpptgjP36P6ukR6jUJUcq0mmGMHA03 URQpwM4XD0tV8ObKaIRD9PIycYpPbmIQDheiC1QfVARoKQkDAba/cE4kExcHY4ptZImjVJX2VLDb p3NojhRER2L/wFYhnIdHF8Rp1zRWi2sVB6aSt0QqicMSvkRA+J8gW4KTj2jgxWZjA/8TOSexPM/X zgYIEBxAmOGFGTlMctjkRIHgOPtKmp/PULfPmkU2LnCGFMCw6gkbDoREfQecoDkORqde4IvwwxBO HDMAweT8hsH1Vli5zIXhmdylHK6uxNTQgPssbXObfX9eSiNdlYLjnD5jPec99pjgdhEUppTi1aOJ lNZUTNYikb9wkLl5GA5DfZ/TofFlgr/f/V+BkrIqd/5f2F139fz/N6xp3MuoFHmS6nP1REOxlPX1 LXkCiOP2+a5zMZjEy9FBfNFTLWf3nycc3fNnk7K2/EaHkSzlGymx7Wo06teKmhAaN6DGnKpyY9hN O4KoQGhoSUfZYafczpqJHB79CDyN+VSPeuSLZETkcJ5/xZWQLf0B3BwfAQZFAX6U3e74xG+37A+8 GqcMpFj2H6/HtAd8+FyGPY3sYLqZ5/lP5RCAMoA3hFOOs5Bj5jINNHP2FT+vns0+rTD3RCA0MM16 BfrqOYwOQwczA8evU5GRUK6t3ue86eKA+o1uRbSU/cRKIkNyLIelA10sbGpuSPgPEhUpM31nhFOY 4qqanSMHq8Ha87kNz4Hj8mzcpgIFAUZE7s6FX3aKJ2pB2p26i2bkPOwOF+T8H7pohsZBjGDGYsyV 6srwYv5j3kSZEicDCcUGampiLzNZfivt2hqdBx1rAz90VktjImMbPek8i88tyJEF2DgePBhbkyDT +huYm7dyabExyOTZuxjk07BoqaXkM6PhBYj1GhsiR9phRYaKtPRoiiSSCWQ8LGoW0EAoFHZHQPgh b+v+ZRycRuclnKLJJydYx96+lxx9r0N1U2HvYweLumvfwva5OSG8sbsTtmn8lmn5PU7EfG3Sva+N pVV3vce42GzmdT5CkeAxQ2O/vOg76zvFMe47E8ojyY4TERgtb2YWyparnnzKzH9L5XD1Oi297ljv OpVVktVO2QOcluHmZNAXeLUcSFIJGRcPedx9q/Z6La52TxVzPS8xWna+nJjzow/Q8umsfE+NhKV5 2zZsmyTZ4HCu0+JFN37vX3WNdm6uZsKS+ATklqcg1DQ9Q8zCRJbA3qDzxPE+0iaeoz+mi+9WErjM MwzDAqwVwgSGcdjV4mZyeN8TeHX5OkSU3poueQPZX37hAGoyYX4m5A0Jo1X7/yBJ7NmMvE8uagkU OXqL6xLIuF+qYHa7E2xPfj0lcSqpubk707j1TJ8JieCQhITofM6dOhPczj1ISGBmzp9AGAuDwvFw Tc8rTv48zX3GA6VLoQE7h7j8S487HssBCFx6SA6H6F7NcLmSEaKbhxEdoooc3lHa3ZGo4NLMTYz8 Lhkyd0xPoh3z5lV9Zo6w7fR870s8Z+vEPrbv527uTxQ+OD2j+OPgdnLaDTR4uFsyfDMqqtHR7S8f TlLVnszJZPbOLgzmumnxu42dj1Hd+Rtqx3/R7+tbTIyxtZHhv8XE4GNz8ssyIOXmcal/2S+gvISE 7TlZmf8XAWLyRkyOER7iXrajB/AE9G7zuo7lVPRW31+3M8PQfR1a8a2HH0VKtz18Hk7orW3HbdqG kkslSWmcgrcVrznFU3lnaSaIkyFaJprWltIdK5K/TcSkmfB2Pvu99JzYfarm7X4XvcG70tnBsfK3 TStzjnMdzePW5xj0rEfQ6DxjsMYrR3tPO8p9bmyPhKHjK9E+EetpXr/h53rb9VdzHfpksxU/LKyV 933jUam7zMW/YOsfkt/ab6HMLB7R44dBTPOHo3eKbB77iIlsdg6MJLyTyEixuxAimPh7BIW64DNV KECbiBCDDhsENyTDGpgcf086kyri5rBH2tJWLGgnqOt/L2PUyPUvuODnEb7n4CRhjkRDCVwgFCSq wj6yQxM+QBqlQJmR4IpX+yJ+9iDPq2LVSMS7jTQhg0E1gTOhoP0ilavvtwyV4qebnizZ102fV38e p2+aHQ7iiHINgcJ4dDWRc7/YpgtI3OmQddNpNCNB4XPNOST1pAeEj5kQ1ZIR7ZuzZgrfpZA5jVbs e5tbnSdvsfS2Ty9hPU8DT4o17GYyWlkJJkmgmVxVwwGAwfk4PF5fSe0PTmSBpjEz3wHEkOQd5czT 4Jj3csqHZyNUegu+h08SkH3FobsTEzwYePJEXMhAMjebjCb37Qk2OiXfNzHwe00ezMC7zHk9pw9w net2Qwq1cKyPW+mxI5LW+U2h/f2/J64utGREZQDsH2EL32x+J7NzM6hUDTsui7t3H6DqDjTtEopG xoSBwDHU9h1rSgyHkZHIu7X1meFn6vp66HMOxk8xHiBmFBhhkF+LtQ/zCEXGh7zhZHxcdSNU5J3O hHJS0ITN6BoQQeAMOKDl4RHDfAWong8VhhOA0KRMEckzfSZG+6QeDo+hjj86ng9LFV3dFxVR9cPF OoGbC++eangRnqtdRmNkTbvbp7t4jy4WQeqe9LsRHeP/AzlLRSGwUH3aWZQBBoHuVZFU5HxGf3Ih fyPqS3V53isj2UiMKYMDgGZjIzOg9fS8gO437zyO/fkOHkwhBPst0RZaqsB0pC9RFTsQqUSkolTo THQ5rVjogd4SFqKAoAuhQURDC2GRqZLPvG8zYsrlmkxTo56TUPjTHxvF3TU71VMeEj1JsqaTE2G0 Nk0qYxP472/J3BodI5gwVcJiAQNvajw8InPlHAL8/Ju+5nWhb0UTrVS5RByXfv1cX9PTvO4I/Sll FIlJYUilSMdeZev7O99abTa/609E8J2cnT3LAHFNVIgOBsE/CEe90GkfMZBWyY9+cD74fa5M1GGK noxrqRT/tRWqhAzTuzFpDpOFee8SR6DC81LS2N9l7V7t5mZP4qb8UU4b+G75G7nO3JyMjJim5WLJ p/Mmiqna2fbHNsEtD2OTxMExOmIFyme08zLt9v+fUKoQFKg9ldszK7HtGhm6h1LJTYz4LPMFS3Ic PMDw8hw4wZKJIXu8RoHuYKH3nnlYiFxfUDDY2YeIOwh1WqObzZgmCYJgmDgL8Xl0l90ICNdzvkHp rWM4o0CDCFmEMvW/BoiUmmGwMCYMAw4qqH7k7AUQQUzb4DZzCZN5p/VzNlkTx2096oZPiWPGydKm 70P7Pivqh0HwaF01yi+F+vdp8X/L9+fbrX7GEAYJiX7IFrWgOlfYEdYkz453GnpCeCWY9gE+J6mG 6t27vPc/rUnE/T+jufE5/R952vGlKfcx9DjZ4Kqq5pEx6Cvock7YSlUGGBPmZlV50iFl5+pUPGqL UO8Yq0kKJ5NBknc7UPAhrM3alyQi+98jP0M8HcIea4F2KlKNRqfMO187dvE3mmGpTmp62jH1PYOO EJgBzAx5sBjL8GHp3X3kV0igtg/WPRmfE5c1qAckwCGGXwGSdJe5dSCi2oosRhUVVFKmNQhBVVYv yLsczc4B5zGSwhy+82NS4rpj3DC8v/AYIIYHGeL2h0hi6J8RwwiZs+AP4j0nB1HW8Csc6BUcZBFI CZqxoarGwjwNRXMRMCEk6Dlkh+gUI9yceJ9D39Nz2mW55mGMEGC4rg0jqEx8VfmaUPzl0Wy1ltbF TCJuHIQHU9jpEEUZTQyhyHOM0OOHp2SuGRUcR8TlWk1+V3wNKPHZPD0tnOUqzzq+B28nJsT3kWeC WYAxr2AoqlgDWH2FMN+qi93EPNMTrtHi3JhzAgEUzCXLPdh1V0ESHgMiEXNrN7R8Jt3ve90TIdxj CSA0B4OgGZcDWdCTuSHTW+K7nPsbP8e1hwh8kyNztfAp/bsZ2ubfboPth7VYSefQdDXFiD8rDo+o gcTfWJT1VfnF1oPc8d+ir2SM79/MmEejDg1TC9UjQOpByzak0/pVPBeTz/6MeTudrrt2MYeNfC3H v2H3Kfc+1id7Zh51PMnndiubRyblVHgTHEBiAwwDG4CckZYn3y75QJL62y7NV0ib1xl8B9uSqDHi OCQwkOyW6WiQMjmrpUJpfJG0w5Sp1k4jYWbjaafU/BNOh6UsqfFe7+E7kMR8YfllKcmjuomveGGi D2yA2PR9hAhAgoDKYMMjVRTyB3ET85UO4oqKhR6Yn0dZ3STodkwp2RsY0foseynDm9Turt8E2lRs fneG+vk9WBpCpYLIp7hg4JzB4GODbLY88l3Ym5Jvue4FxYIA6mJ5AhusAut5KodIHpTMYaebPnTy teBWb4nd0pafXTyrDGJHI1yNGm+xNutMSRs0VBSr1hEdzhFKJVobGwEvxUDW0Lrn72/c7iXcwBv2 YcHa8d+z1inf1mA9s0UbOojnq7fk1rNDaig6xobBqF9WqikhJAbnFUsI0iFgKGnBDUO+zEkf2tEG kUTs43vjnjLHkyTJ7rsR0grIFqOV2io9DwLR8Vnoezoz3/Dsjv8HEkeVilklqVQ7YNxFP3d+Kf6s mxmR4l1xMWTGNKwlyng1h5FnljufK3CbREb9qS8EArpcQsB7erAopFvQsNpZYOsI81ed1lbJvWrD 5cyskZDz2WLAyeTBu6Xvvtz3539fBavE45cctnhLIWSkiynP25BwdGIlsDFSynV5Zht4u1iJGm0z TEmhOyXwtiTUdTBok3WPFI40KaIDr6sRaaqjJDaVGBR3EOIJlHyPGeVVVVVUk9Ye9hzTPUCQ+RQ8 wXAfVzFwgdKQqGl1PvPZFo+u5Eh6kPHj2AVrMIx9JLSkyM1P8PqeERiRh1wvDeal1EHM93Ztl9mi cejyjlY7JvKOGDw5kfqGK+4TIueTHZIoZIzZQG93M5kSvMdI+H304vs8lFViJZi2Sa1oXb03UeRu wsvayYtfOT6hPR04b2Najk9705znp9F4ZF+09su/1f1ovDDigOdB2ZGoRSEGVHBCcU8VDQSF+y5q t2XxSQGc1r7YHUgJwIERCccuN+3t792mCOVhNIMd3gd4TZ4zDRbwb9hAHNF3mNa0YcCQnVVlnk/2 PcHkQd4Wkg47rOex7869jEA7RiRYmQWmstBJi1Wxpoo20a00jKaiisymlrM0a21Kok2mmjLZQy0z b4kOo3T+ipnqfxPX8A3PJfzUD7HBgeHcGPxUMKacQRIB0w7lp4FN5Bddc0c4Lss/Y/wqkOoT8+3e LJg+GUOEaCpYFF3zK2j6TJj4gyEB2d4wO+B/Fk8Z3OT87iOlH1P0HvZ8hmLenCNj8zIYYuBdtg/E eOJHHoOsESkjxUbC0P3FRSJooTS1Yee938ALQe1DWO8DwQ9FUUSsqxJIQEBkwyPJQVCQpczyYzps frHBVdTzAmMMakDM+CGy1HfPWSyJDl0awHyIOSMhlUzVXkT0IicDLRiZ9Z2IEBxQ5rkm0UV4mqWu 4RRkFEN2VESGJMOPtNJQR7DgzWsIox7banmvs9/DlISomELsO08wPjTDTSjdmCVHcrdSsTebknnj wJLaRbexzvLPZx49HptF5kxLFI8d0Xu2PCndkTzDZSpLYxCNFYwI2xCo1w5LTU2MRlBd0mJw1lsT hkZJSWGrGK3MhG7SFlbLG5dq1oxuTw08JnL0m9Iby2iG9tdVgm7RqSaJi5EpEyXBuZOPG8NRDA5R 5FTqotMs72TNsMeJ3qvVOHDIDNsxf1leaYfIsqiqa/tlLUpg+KdcuEw9oUAO4PvTAnH1rIrdeY72 kFATx6bBAmMtVN/uGX+yNWmf1aSBxZDlFHR/kw84aL+LD1Pl+lCAmvrXjEPZxx/2GSqhAZ+3TxNT WzM84eEFpYcz1xoPowGkzZ75pxQr/NAmxMDjdFiF0MD/yI00HIdPv+xkZVAjVjv9giJ4o43C4eGx Y5IYTgpGMGGE/N/oT1rt59zoT7DnV58fXMiDe6TvVqu+bJwMB3/CNII36lo1UiTMdg+pXmYlKY4d EZOQ4RZCAnGCEBKc8yIOg46DlbsSH8iqyD51d++R393BacSxmskxRbL+NkWa73eizqRB13GfMhsd 7r3bP1gJgvY6CCw8iJAFWEuZb6wtBflnoD4ZDjofXs5oNsvIjFGbAUTKp2bOx+Y7iAG58nHNl16M hfTk9C5H294ZsD6DXQjf6ecueSEB84zBfqpddnrA2WL9gM7XCcUjkj70IclVGyUc4myeOenpPJBo gkTWg0NQXJPUY+v2p607k2PndOhlfebJPZV+14kcxeDGYpQYBZHsCPkpp2rPJd5RHcv4CF2Q0vow wMaYn0M0DGBUs1QoeaOqQ0WRIfaZA+2VPwkC4KhABwOHEzoMujz7nsd+TGB+BsZdCdhGQ/vPlOs8 nl87HB4mPqHlhMMZfIeP2cNN4Pa8LqAf93+fPLIoFFN9U4emqkSHbQRyTJpDHwypzuSAYO8+dMwg kon6j1qOCUEmLt9eosBFfLZOeMj4oYsyWCAxGJskbS7GxGLueCS4fkfyHS+cOwzkkwPBgeNwu9cx fcffGcS70qZO7HHuepONR7hl3WTgjEsjSBC6TggtLkQFucmQSwMs8V7ik18zFxPwKrPb6zZ99y8q 4bK7GOjFbvL8Kv7xjZPqn2CogbLtgRkNIotsMpEboXieXPzUj3nzW/uCq168zgqzMOQyHvHJnNmO gyNYW0fY4ezYnnFbtnXsfg9DhE2Z5mWuT7+tDJnsNx93N9JMX7213QON2UZvuNFCAgkcnve9tlY8 nY2ahDZvqp1Yp+R8zybTye97f2+MdDtm/NZO+hI1RY08Pym5yZWmsemEzHiI1ThDCN5z4V5mNO9w yPdLOyWe91kR+NKbcOTHNXtve6T3TyMU2TcTSJzVVKlGm0xJkSaSaJsQkfcwYTYrEjYY5yzqntmT E1j4s83r2cyxhIuhhQg8PMwOHKBmwacDkhZoGVAOXtrHcT6AphiYqoZLDEiUbMCqicGMEYYboiBU xh/NF5DveJQLIfFbF2ZRfPL2ukUGDDSSD7Gw5iVE20ljg7HtHtO4w0OLD5jHuZ6jcOw62egd08Cn gZ4GlN5HhFllhR1m8xHIfLNu85YyK7ovcwxZOCrt6Hq+hftxnA8TdavTa3Bw8XQdvBi7Q/jOpM+k n0JETe4nuGQQgQEugw+CmhAXLFIcCmMehp+Z483Di2HwKhNOfLz6myDg6sw8sz6UrreT1uomX+ea 9jednYOw8lSiowmDhhOFgiMepyVcqS55OVw1XycVWqEB+CkdZi9kdLev14UMCHRs37PXOj4lgIwe xgQUT/RngXRlpSU9CQO+H6guxB3WI7BxjHryHPohAXQgP9SEBIwKw5QRYo+oRfEOlxVEYcGh4YQC HwTKuTekgZdiy9yTm8O6TG/Z7TOxjcTc4Y6fo5+l9xiHImH9D0fI7nc78aDhttJjY2S8ema0H3r7 TCgwg2PoMQTAZRIFjmcDj8g+Ls4ziRoxIdPluRDyTjkquBlJeaX3oYdNlaR4vmMq/r+5FUzEFE7n I7+wnLpcPyBDvPac5pWmJuBDY8ptuzGLWZzsPJXKzj3vBTZ0HM8HqOU3hzbjwTxiD+vmdeR3tPSI Zf5Pqg+9CAfHg+7y9uTv7jAUNRl1DqOrp4nnJG5NYRZKoOp6WJ6mn1t3ZK/BHTzvtdXXrU+7ymzr zOHHOyq27VK2/3Ej445xK8zvfofW+SdzFyG2hy+oXCQ1YB9oIsPEnu5OjEhF0Hr2xzgbGRmtkMO+ nV6nBOOgZJw9IHIHdZ0giKFErEPZQOyxgHzqyx7nEGPw4VEno5sqHOstYW61GbcTvv3S44Pu60WS 8nBqvMGFA5DgcOTLyRdOgL+5fkPEHiOoRTA4wMd+MOG8QgcjZZtYtNpAPGIdXLgXUkRR/jF2bJfe 8ciMxOXyDILkOR+Ex4/x7ew6zdwMe01pIxMWSZx9Wydg/H24fCqKCofgOE4cRCZ+MvENLae1GCRV lzGBwPHGBH8z14e0cusi6ecJvjlcLmgRE8dqGz3wK+41/dMnMk6pzZkZsFQhiw5xEoPJpweLz9Qb 8dwTRPKl7dJbPQgJTCBoDJyyCJ4AO2iHF7j2r1fX8rxbTkbtmzabJdlxWLyjSVPpLpMLzH6jAKHx Lg83AvJPHweDYfIz8Bt5HYVyjDmYOiE8ENM4H7J7Bfgwd8iAmmP3HUgIgEmqhAQMEx3UTjJjW52W gQoSP0H3boySC7T8QgMJCfkqAyyUk4Ghol6+pTBnUPo/in4wO69qfp8onkTR1CdhdYFfiAMyZgIG RxqYLMUPMyJTPDI1Tq89wxkCzO55Opyae2cJk4VWIda81kkdyyFqc5R94VA77EtSS7OGzY3s1GMc RJyBmGWrCTkQNEGCy9BUFhTX2BdwjIqtb8K8Z9LCtMfS0878TdPU4exVV9L/Q5YOTGTLPs5zuRYx +f9gZgP7HwO4eJ53DjPAk6W8h/yfSoOMDAwWWiexqQf4Ic6K3sghHLsyWl+s8eDpsfTY7cPBMxp8 j9LxaquS8WLVpQZmZaqBjP7XH9OIGs08qKkLKkrkldPU0eZZfqRQgVIGZMHIzPVEk4giaecjmnKa Y/WpL4v6DHc3SfsYe1+86XyTxTB7nHDsdk0h+x6Z8JpFVNp6XxtjvYsaa6rE2Saf2Ok4c09DMzMz MzMzM/UGIgdPM3+brzpPT69v074HUerXFeMYBmGdZ1nGr5+TpET5GV8pmV1znaEyZCYCGQjniOEt qcvpzNszPx5qPn2zl6M1PWl8dXBVFEn6sw4ww6cwK+uB4QnSTJG+BldVllkdWZin9xtmM8CyGt2h plYsBz1816KH4fcjb7Jt6N5mLlzG09TwcpHvezF4Lkex3Pin4mzHbLBqOiBYAOMFps0b5Iel3BMc JhZJhdk8VP9jajCoYHC+QSSPFspfadDY6Ew/mQgHzC4DOIlx/+SA4tAuOGdzz2UYu3/11/jH73+8 oOM7K3bLO387zSPCHIc3DwnOjK33XI4KFPwVd/wrg0cePe7E0rOTSD6jsNxamlvIEsnDsPCBumJK nuOGZeDIcOhBMWJBRbogtkZtGRkmifp2dL9g8tAKPcf1dkf4q6EBxZSOf0FEX8Xs5XCIkHMHr9Yy NyI6JX4rmHNgnlMcc/06PXMT0E5NIeeOtl8nDqPWidYRoY86dyd6fQ3d5PFOSffJU5ikUVKKJUlH tcuwntSk7U3ToTq1PSmJi6i+hIWjzck67iJorpj6GqHrcqcCzNBwiDh4Ojsh2MY2WrpHWYsXRZUy 53U7253tn6eTsvSWMdrk8xpUqVSxTk6lSbk1HCyYkJ1U8cshyeB7Pr6qaZDMIrfccX7DgctNk4eu dQ7CykR/VeB7jVUyXzPJHpCczGHWdw4euPQeXi9p6TxJkBo0w50OKGwfsNz33s5taQ8zllnVu7OO O7nInLZzk57POe87LVtnI9PLgZ2j1QN9Foy+oeRIyuM4uCC0HJiUi51LFGBmY/Gk80lUYGbtM2W4 vioicL8zs1LD7ZrxFIWgoieLwTku/zNl7sLu/N3vimKphZd6cukUu42F8Dqdjb8vNe4Z7M2Sc5w5 3M7h/ubRsOyOg5CAgV+GpA7xjMYc4cJxI9ThwdxckdwoBV4todn2kZR9Ir+8KMBKTHADcx4hy59Y zgRWpVvVw4y6Gp2TUISkDPPqHQPBhyEB5n6bL/s5xFe6HYwyOVEflLhLirO/4nRZEijIgBjIxYxE QgQYgMSao2AtV9ap3nVFl42FwhAUEICH17lQgIdoPr3dErDbNq+A5t434S+zk83lLivIYBxErzHG xkQ+0chKZmYMZKacOS2LoXdM0Q8xMw0OL27XsRQXLO0QOnod1EoVRJMnocPFAZ0ypnHeGx2VUaSs WLmXQkslg7BU4A0QhrSB7u5iIeQZvtRKEhIZh8aDZu2uII2VUXHBgYHq6orzUmcXoWgEBlqxyUVO qJDDLCgs2IETEjJ0AtOKKIrtlnYcHNHNqdw6zdjU2bN2MOJOqy0+SaTsadnTHBFbDRwMDAcgwjm0 JKB65FFwSJq8HXE5MhATMzWeV883VTUtVBSyEBUYkMmEPLlwreAQiWRRQkDFC+TBKKFpWmZRQSIm CtLlHfoow8IVPQlpSKGyktOMDQp2irgx02WDYIogKgpKQAlaj9kcEJwMw83xqdhUVFsZiGHPcZ3J qqvCX2aKt+YhZ4ISvliWbMxBRLGJOzr4LW60O/gogppBkjITYEWb6bxROEdPEw9WRgLImOE60hno zlFMSBygtldU2ZCAiOaOhj08p6TUW/UsHIzVyDGDm0mTZF2nW3hO/BT074sMvPnZ0ic90cO0JtgV UUMK4Ga4n19NdZXje74857vJPTWQ+1MWwfM2ZJ6K4MxGqUJlSAFgIJw62arV0P6FzJKROOvxYsdY e9h4fwGZ6EvyMwauHEgfi7oPjsmN+tIdinuAFXb2M4kmXsb5udyze9/vDT3KBvl2eSZNdzk3m8Gg OJxNo7TlOrm8PL7NzpRatRjkywPTO6k4B2H9U9KFJJmTnObVx0O53U6L1weWRg5jx6ec+zh1EWSe L8rknKir+u60ifz2fYbc7iQ/OJb+AwCdzlnNLBJczl0eO7yxVDU+eTjxhyZLO6df9wziLObHYhiM 3Icaq7PRimCHwZETZlgoO7ExSIhSoPsciO1bPCYa8i3OpPZYorK3oMVYW+aTvUc5iRRI3E8vCL0N t8f43Kz8jD3gwTKIzLdHjj4THzHHdU/niU5bcbngNmGw4yA5UEG4n6YNiaKocRNemZBUGDcKh/EK FU1uSd9ZUgBODlZxCEx1l58zkTK+ZIHsA8YnwIgPb3MvuCJmDKhAUQ97oNj57A9/xk8eOd3k+8cT DvCH4oKBz9wy9ARfdrPZVuXm5r5fEYuz8m+GjmMclk45mov3nl4ByVV0Tn3PlmfabfeBVCAd+f65 agbLeSkuQ5JdCSqoE2igTDA4ychMu6P0DnQxAMI2UQPRI+oERLAwRw5zHzkWbNMiLKZVbtJIsKII INhWrGZEX/Va1TFhUEAVFCQyX3Nt82bc9SAcTdYUsg+o/K6HixHL1InQ+fmJ6VBfkHmp4HRcIXy2 Do6y1Ia/0ngMMdbjExldxQm9AxYGUHpc919F1oOe72zgQHkoFRZnzFqeTkWJi3tLPu+xEh3jSUVP Hzx7p4QyYyPi3gwPKjDAx2XaA5i7wXEdNUZMjyKk/S4ViViu96ntjIgs2a42myxB2TwDM4KDiJ7H j1lBfvHouSHKR3uJD5+wgsHQ2BvH5lEI1Ymssj8kWgHWSSIKzezu6vczMQYYYspic5WiNE0a4+HZ wcEPMw5gRohjZWmlH4X72mhjGJOwZ35mszMUvX5u+NVKd7Jwsz4/wO5pOxWOR63ogOyVQTcfQQv8 t/g7nNzkNERCQynpCAmFU6+e+jtJ5K/KTCI+Y96RO1zR2mm85Jd2dWz1GlPnoyOIfUyfP4wh0adH zenp1mbm4/PmHKWfI7sU9Z0b7FPm7R2FzoZSA/qgw/zKPb8kVtNLtqP6jt7QrlXQGSODsZjkkj+4 Ts4+wfzQQBtyx+RDDLmewmPWO3cDhxPAxmy5yTtyraZjnjBKqqTEwC7pT7xpEnmNuM427iqkrztM LLTRIiDKfkBdwF6d1qT0RbZUWqK9l2+bL3GhAUGCw20Tl19Ip5AVlQehAPfJyngui0A77FNiqqbm MSK8hwZnOmniK6KaBn71+tCAuZlxp+c2Tni8wZ3fPl4uE2hAifiMtjgmHeWXwHvj3mG2HmJ9+eYm 34XCa5zqxyScYRPBBZZZ4d/zfT7G/gl7SilW9GjPGbJpHpE7w7jsF4OZKWjOfcPcaeYDRwLYEtMR ApKkk0z0sM9Af9I9QbHrEcM3bVCAbeu/RSQgG2CwP+neI2OSqMnccmj0q8joWUzFZMYlllm7hX1Z LOw+dyTwl8GO14t2ubjDhyc5uqqKSSyEkWxRLJp9Nx22xJmh7LmfpE2SyItCI+JJDdofKSTMkSJE iTFDFYpMVCpT2vf3aKkPDebE7E+3ONCWTu+Vj9DPk1+rRyTTjoSv1+TO/hxH/W/Kfr6p/Gv4eNhy e3GPDu0kbOTjyv+lpMzT1WUQQgoohSH+5QAXmup8j858g/O31l/q/wckmBRqZRRmobUZ9n9X3eHp JJfd72fvHZm2/mmUEjf6LaRjcRbAqyLZB9Py9PW/L7s+LbPzPZ/j8Wzfhx9o7EZBUgOA/sBgj5OZ gPAYx8D0wfyMz7uHNCO0MbB8RGvzcRGG1fHm2UJt/PyGfP/djX2fpxabd6RM6OX82YPV5PS7deYf 1qT/rFc0nsVD3PeYPtUadrCbGzGH4jCbKmkqpsrds2fQ753ed1fhfc4aSedTdRMV/nYmMVHnU/mV PlbMe17GPkfM+disVRsdzq7z5E/Q0+Dq+JzOiqqVU+l71dWzZOA8VYlV/a/rf7H+xuexUfQetWPY 3eLHc5PwvrYm7k8Hveh8T5HJX/Jppd8X/2/97dp/r2z6H/O9ivlVjuf8Wmyo+dibq0aVPt9Gnned Ini7fM7myRO5Ju4eljwad5Wz2JoqVKlRP0Tiepf8J/+jHa4TsVDzKpTzpTSmiVHofM+c8na6vB86 tNOG7BU+1sxoMMfPo45lTBI1OjByYXd860mbn5A+oSFg/AmOH/M/1PvI/C9apU/0u45PtVWN2mKb HJ/qUm7Tg05NmPcxurT7n8zDE2U5v0uj8THJwcmJhjd4PN+J8r5XxnhK9SzHxw/M+3MfdO2n/S88 TuZyNTZIjxv69BgfpeNC4nY4KbPBhv/0xmZ/R8ubD7Rj3H7h+0iHx+3YosHi/wSGeZ0f3tPCMb8u 3OchqDTls2eljh9r9rlxzp3m+n2Hj8HxPkfSf2n/YxofI958z1Rpy7H+J94/wPH304HO+v8x8jqG S9xI/4n+VQ+3xdT2+RdvaMnPPeSyIwE02P38EsOUHSPseHVnh+ocDkxy96enr0Tgu/q8/J00H8Kq cTX/UsOCB3nBzgzOJnA85DLYmQPAgOIn+JE+2I3w5XgJjoHqfMgKYx8xhfA+HwGoQQu3I8OaO9kC d9Y/kencLqTk9i3SY+Mz1Y03Gz0um3ycYJ06zI2fjPX9i3UT/ODJHCzXA9SenB9Ca+OTh2zhf0DA fF/9NB4yXsKb+0zM1sBqv+K6ntoVu8s2at+QcGoMyDD6c/e/T+1wux7nBt/Y4YP7YErGyDPT6t6W ZMWFknxU1RP/k7f4tTgzo/+l/od7Xl+95ytUxijqsNfR1qKV0n14Uf9f993VaTxs8aUgUZB2axj8 j+7I71k2Un1q73jOU/G98ehs8mMO33NGqMMMi8Cy/Yl/ui8XzV0vT4AT8b6ZEhSExM//AkqjK0/Q 8x9B3u9Xi0/E9zqft7czT+d+F4KdJ2nC80wUchUJJSDAwXCCIgpjEkZSSZRPs356f6snKev/+dfy 8f4Z+mP3n5z85/vIV933/n5HY8Bj/v/H5T+/iv4c8PP+4/0gx+FPM1/yN7z9D7X1vQx9o3VVMKpV f9rzPzv5H850SJzVPuH+YPjdj7W7T7UPwHnYieZX/Gf8z/4b2bZ6ezm6Tk523E0k0/ntvNPBpzmn aOaTnYpnP63jx44xQItH/hb/1H/emMSpowNgmIoRRkGutRdQqSlORNybkvW83P/l/+5w2bODCpMG SyGMVKr+2Y1ph/wQp5njbXOT9dPHjdk6Z4m/zPn57PYiz4I7PHJHaLbm0dnQcs5ucSB+dOsrW805 P5yctI3xc4R63NMvo681jx245u0cb/+XNGf9aestJJj5FuJPTG3NDLtcyycfSf6nrxb1py92TB/9 7JhRVbLOp5jkyabxLJuKM06OW2k9NHmtNaJ8+mYWq/8ckyO1XD/2qRh3Kc064jwc5ikwzEsQ8Mux p4NG2rBwPtM5EBqAhpJ4HMB5FsQ4E6Qu8kwrQZE6tIxpAWqx4MkOjWNks9sf9r3Mkn01//Vk/q7t +G2rHopzlCqGxjHucHpfDF2QRwgRcZBQ/zkKAxIqYo5iuBg/3h/nB4O4eD+g46CEPSLBuwmJGl5p W5LOLD3Kjwf/DE2Uw8xh2CbEfkNDrrwXGBlJJYkImS2iaR83508PjbZn0oftt/f3/U37X4P0JP9C VD+AUkP+qf4zif55tKn9+R/oHQScP0D+WCI5yaFOyTpKKlKfqTByIp4SS/ybGxvuAl/l/0deIRt2 2yyOpGEOc8Dt5rVWnhKNqXSU3JLDU3A4J2SdxDZu2nKbw5IZNRNpytuwnSCMAhzXS7ocD5L4wyS3 pTHmrJ5iJ9jgnpSZWA0GO+nZjQwlGEyGxqZJ/8CyD+p/pf9OuZe2xc/74+SfEG67BKP+4SWAGRX/ 1Y+qHQqQwRNlrZZ+Rf+acU/H/Zf9jZ29ZufnglJBZSAE/txUZt7arWxpIPIYmNaW2lNqJizal/Wc ci1mshEskPpbsbizWTLbLbStMsW1oiGUjWH+p+1+B9/7s3m2GHnNY+5RzS/B+Db9f//W23SZ/k7J n9/w/h9O40PYSf+4+yJ/vmfUZB/3xCn+v9Opcz2r+apUP8PtZf7l/3Lkv8T97P+ln3C9ISHaEPxn u/z58PjeDuP3nI/+rtwR++P6J1/+f8P+H+3Fv8GGPmdCO/uP/3bZk4Zx9iXzIh+33Bu8+z9x5w/+ 34OA5A+yEM/7H/Y/9r73/eP/WP4X/k6dnh/3PqeTp/E/4nufpYeTpwfrPsP6D7j8unzA/l+81nt0 f6/t2PUfMF+UYDBZH6l/S4Fl8a4zX/tH/lMP0oWBx7QZCQ7VH6ipPPLGWJaJzsKdVKn2qd3qxsU0 zwfY2MXVepZsXe85DiCWEH87jb6MGP0ljZ6I00/GjzjJ1ElLhGXqC8AleRDhgIRGPBjTUrH3MY1K krEuJUKlpyZDCypdlxTZadsxpXCmnNxNR4HDKWTkxRzcbRbItxjm5JsNNmppmU2Ix4DEdyB0yFIz EMhNDJkg9gx+vpcRQOZ/G5wEIf2ne/9+j95rbzEb4LdM/omH+FSkS1baxTu8fJpHmTZjZiq57S1V Yxt6WzRVVa0T/lNNNSbKTSU8XqbmzHK8hkNohISXR7KKz/Y2QWf9Ygc3oX/b/RVU/kdFB73DH7Wm zZs097weLZHk2YY4Ydqmjm8WPicNmwvlmeabEbOro0t4WToqdHAX1o5C32OCuDCkqFnJYKODikrA KKKMYligSQdFjjkSpjkCKhgzIZG3IOacVWWzkwLOCNBSiLFCPgsCogBC/X0yf/AOxqCz7MNDkBhj CqA1oKogjfC27XYNM07X9Tq7VacdTm5t3ex4qqyabGTzuTHZ0ePJsd/gsU11mDabUsvVVXTGGGKa SDTZK7Bjy2T317lSRlA4KheTCV52R8QeB//rTDZ/if9D/MfQ8yZ/0P9x/qIFP7/9BU3qZjIeMlsC G6DBsop61GWSeSzFLSedyets5sPgYcGBsvChBKaIcQCVZXifzGwc2nyuMFcMj766l4Uyqse+GRk3 YyHnSncUiPvqKj6GR3tkyGJye9ThsRD/bYTq5ORk03JZJ3OTc8zk3fK3yuenIkkkkkkkklKspu0c 1NPocjmOSVYNnJ+pzSYc2JPxx+ViRqJOxYeqyDp1yOaxIV2nqjUJ8xYjm3YN1SJhw/A0bvoYTl/M 3akh/2ub8Dow2SR0VJ6a00wclNLIYUbFadimK4Y9KnJLJJwbtMYsPQtxzb1RVFUemySJsbH9rx0b qjuf4DF0aMROccEp8ZD/bLCaerB/82D0lTsdGROmnpd7aIj/XN5k71k7zyVkjhpo1KlHao9FDsd7 dPGP0kN/Vtobk95q1N+bfy7nifAWJunYzxfcx2PRMtn+Ckfed5vPyRkmyvuJ9x4GfDTNRj+SlYtL U2brOnRg61YPtk8aWRnjTZIRIqZYhKB8SQJDH+qRXj5cZP+O+J2qiH2WGpYHmbPcak0ulDmqeh6C nkqabKrHxtOFm0/Q5tHmWT9v4GJ2naxO6KsWJZT/9099JhTnSR20nUncwj1KneV4FPNTxqDenmk5 hL2QpQQRJFKnsLRL0kdUqpBo6iHvM8DQ/qNHJQ6LaV93pX0GgR7k7hjhUYqD7OjLUk7qjdZMtsBE gnMPcYP2Sh4krwQnYQ95KmjjZeodkE+UhfMwKYRo8jg3IwiIa8Bsm6dWzEZUkffhSRMsRag6vf4d s2kifXGmIj6hYdpFml4PMyML3RzeT7DSdhCh7WEPpYUTkQApxBzITpJDtOZgGJzHPkOc00rLi4y5 MkRQnYpIjCkiTOTm0j/3h/awAz3/Cffn2j6GY0Jf0f/Wn8zhPEgfl+ifs8Qz8YJ39NTctaerTzYc 04f58/8Ykv8L/+CeZEw0n/9BvIPAeDh7iei1G9xyiev/P/MUIQ5qzyNIRrPEj2/tx7NaUQ7u7mIO aH9432NwYN3zvqPkQgaXZnxLp04DGU6xKlinzjYla0OZyOPZz9R1lAxRDHS45w9DX/sHjlsCtmM5 bFsjuKip+0UGzPpnevokQ2+/0kQtiEeA//Naxl/tXzBeBVZDRzqfD8gWHb+FnGoSB3UecTYJ67+H 4XH1PFmG7F78VIy2229iimKn/Hec6NgyICUxZCchDi6P+W2kTWxManRyTxzgI6uT+1zq6+OGDkcB Onk2tJ2yuTQOjr9vHrwO8iBbtgG0qRlbUis3MQn8n1koBly5xpiQkOYp5LIVBkjLclYuFwIHdxmd 4WS5ql1ewnKNizsya2JvUlNth6Xezj0PULTL/+WT4XSdBwoIovJb+floNcuCr0jhrCO+2u2xbD4i kaSrBKMkaHQkVMXKzCJV3w2H7HHs7iCsHo1pQB+eH+PLbLlLBuMbruTJy5VsXH+pdwZZ0YewDhnl V3rC93YV0bl/Bth5kGsoqFxf/UOcWWO8e+rlqNscrYDeKjAcOcTWE0iwH6prMvOuIXP8/VUCwghe R4HmuJk2Qnn+wMPMOYzBwyLwBDobaOIlwX7w+w2Le1V03DVZHRr+4HrVI1Wp72LjUF5Cf8AnBVGH n3ApnmQIA4d2LthcBYPA/9yR6TyBuBtJ7rwBhhZUvLX2nx8zpDQ6qwPVFzE8YlFaE7uWvLJXIvoE w3LnqQPYe4mZkhBzr4NATbKJ9XlmHnVf7Q94LC2/9ne3y91j/+/b7ZyGrV1YVqVrWNy4fh6o/H5b /d1B66/X73qCY9Xe1/kQDxe+6P9ln1K+ExlF57bZ4aDDnzC8Qwx9EyMKjS09aWkNYzeNPMySGH4t a1qTVHmXs9MsySmO0cVZLhJZNUeXy8qP2hJFnqlOjBMhnl+5e/peocDXDzXReoO9pSQGzSLB0Rfe w2Qv+NuWPrtxGY2dKJmmPiu5xg5U++QPHNna25ZIgyMlht6RUmToVgU8FBeGO1VuSi/FDE4k8I88 LPgX+4cRJuZsj1ovk/3/SbOF+89qh9h6sNqoeYjc4GMhnM7HtgeKcj2L7FEkRUkDlQb7/sFIMjkv ogwBQXcj1cf1PTDLAxhw73PTc/b57IqNIfqf+BPrT8ro/A6Pa9DSVMFY8J8fZtw+dJJ9qo8x5DpU +X3e8goHFHOHh84fKPeEyM6/wl3EXDcr3g9y/gZE497EmL7n1G32LZMu2RJI9nn81zgF/pp7vv5z J2jfpN33Go4YdspsnunE3H15iR9CfGnU7+HzSvXXPFU7CXHR8Uw1p+SR7p7WztIj4dupySHFnFkH 5vYdT2nIYyGA7iYj4qP8fh8o/S3Y5ybdGlF7R+pyEiAhfiPjxPjOA8Ah9VP0TodXuXo7nmVrTm2T E0cz6Z8kQY5vVjc1/L8GN/F9Uw1HZNnNtU9LJE3jpYypUpsmrM0a16TD8bRit4ux8Gnpbf7Y0Tia +N+DqmvuPWddefo+humxtTbdkrNj5jM5T83aQ1BeAjDx9XHp8VTo6AYxEKY7DsMN62ZGA/A7GImz hqdipzV4q2fax4OjGzq3eJ3vI5ni4NmzE0/G+hvGN25p5nk3PiMG59inc5OFOrZ3n5jY9JTh6HDF O29xup3GHVU0qOFG6k3UnY3YjhK7j8/Zp999LyfH+N5nVe5r+ytOcuEsofmZP4D2deNzu9/m0G98 Bxw5FW+WlmHUIVVdmqlyoGGh0lRZyroa7u4qCFKWoyqUupV4zNZc6UkyVJrTGWSf3/wP0H2Vw889 Ese/p2fy+o9nBTg/OS7xmlA9Dv5nw5S2B5W89BIKMjYtI8oUYiF4zswyGGYhAJo36HGZQoVyDIjy yBxsCNSYJ478v3DgrIce8wk8n0LIfc9Dg7GPSqbKfnK4f7X7mibJ+5wfYcgOBjU9exVOe8FoZB8n ioyScMjjvkEq/Fy1r8u7vsL9m/q9XG/y8zJuTROfNh3W5B7yPnIPuGEeAxpFxWxT6rERcipAeTIu SieQMTKL2kRC3+xZU5XoxyksHtyCDx3TqzgjsnWU/ztZSVZA9roJj38a/k7NqjZhmQqoMfQebL5F unXLSXcsBrDvj4Xna1dw7MeUQaYM4cN21Hwg6KUEMg00Bwv+o5Zj0djs4lkSHSUfKakRIi+P/EoE vIl42RDwHEMS+Z4kggRGOQwe0YLmYFlKFPs47HkdTW5fzdhshsmDzR+VlCEY8vyQdCFBWjYg+Aqv ad/yls3Oj9Y+q94cq71pLpV8ZWan+4/vUH/NGUhnv9sfA+jE6U7/SE7sXPrL6LU20piEfGRH5wPP nDDoLmxOpo/2jUyc708iEibipNy5pi5BxI8ZrKCNsSGUU8dud3hMgfSlTo2Z8O5mmGGrTzzKH6TE 5Gw+JydbO3eGHJuDUNlpD9sZndfcQp+1s/IZ9YyxYioKQ8xM7nvKDjSxSEODnp6d9FPbTHQdA8Wx 51PKSpFm9PWj6cw+4/IfgaH6JlDvcuqWXV7uTFJ9JPND9CaNszyOCArLLOJkKJTBB4mGOOo41S7p bRWXxPZvLUsFhh3c8hUrynpr2TPc4d8DWZBcvUHTfy8+Wp6U2yU7bsng5ntMwFXeWbZwziMNIHu0 Y6ETIllqeuB+WnYzdAdF7T9bSnuM/OnK8zKPizzrRzcszMW2dR/D9TKvTELke0S9duPpXc/s/pNl K7VVLoYaFaYHuw55VpEZQ/E39DFX3OpMfksP89oUNBwx4rXxM7jbU37m4/mfH4pjhf/CbG/Olc4p 1cZyz5fol3sZ7SbptjIhHx3kdvKavh2vfuRj7OvIhplY8W9NA7FHSlgczNNhfRHse9KaBQ3ZXe0O fDLmMHsPMdp0jQIA4kQ4HGREXAwohU7x5gY7DOufgPOYyLjH0GM1byru+YOG+s1J6y1TrRd135yx WhRHI1jHERsYNjnw5DIeWzSfT/If2fPv3eXjHxdWcZY+3KYznwjAYkfx6cwmbrWU2CgmuiXAyfFg bduGguphOUlRl7BxbyTg3uutD/hmnHQvivMvpAY/N7PUeoM3ByyO+5xNpZHtenyluwGihVV2j4qJ CFZQRryG3U+1LaVB5J+5Em/pznCnV7psMpDfrDCp5Hqa+k962L5lh0GhyPsD+fn39+4Pki57rB++ /G4qbPL1/MGg7FPmMPMhKUCAwGD5+h9pIoHUkepzdmMewYcTORA/AicjYcUKDyhsHzP0jhewoEBj gOoRLD3DfljC9jvIC2kxho4KaMIkqM2QhT7yBDDCFInicj9JCoxI9pMePGR7j6zh6iRGAm5xcxvy PQkUG0cUHJHm+rxheB2puG2hmW+gVwhj5DETIqRLGnmOC3tTU7cm9B+J6nLPIkO5GIDLMnVKXcug VD0Civ7VAJmiNYzNm1M3ZHBLUsOThw4idhxiYSL/CjxlkcDweBQmJy8TwIEhgho4HjwmDx5MO6I4 uGB/hxXqvMnVdOhnddA3SNREy5mBZgJh9DvIkyIWHozGQT2VVmHQ+t3t5sdGParRqk5HVpTTTZze 5WKrGDZxsmnvOGzd6jCdDmDsiSHUcVCxVxycvzyl9pqVKgPhXwXMF8/3fXEFowDMN9HeD/ymUA/E cb3E5dDmDBCvj68+XV25X3evPUJb973xl49p6T5NLOTITMfk73P5tyNvCo+J7xkpjIX4G449+fd8 82zKszGN2+p+mYS7B3T6a9Bmf29pc8z8pkOGAvMiQgJmXVg314NdKeL/k9UEMdtvwLPHnh+Ato4D HWj8qv3c4DoReXnAzm1hcq8vgQOBm38dGEKo1wNtaVPCPzGhCpf7X+7vi9Z3TuTcRLv18WpIovtF 7tac5wc8Fxh/us2Q4yCCyeqHJynEtcjMs6adatSufnKynQ7sx1nSO+Dhmxo83wOJ+E+PSJyBpcZc W3Pd58c59/ADQ1pKuRliNAdkzmf5gxVywPTCqoD08KpgXmoK32djpNDurWc4r8Nub4MzKee2DYoR bM4GdiN2kXk+DpZ/UruEP+wwn8UrZ8uO7V7OspXWZylOaKzGVVX2GLWvLkhp1hpuRbUXZL616n9P xFz0LLFApl4kj2i+AsyZAwVeHZMC/n/YGyguQon3ikmbv4Q8n/36GKsY0W5w7ccLbmh/TuGeZvJz /58dsHqDK2wrYK2CtgrYK2CtgrYK2C47YO4OSbP6v6nYaGUSJE/5iHGGSJFOAlyFJrbNosbL/W4d bY8WY3LYj1HZmWslm2lC22LWWjf0rNyx6W4lphZGk1C0y21pJNLbEmzQmZNGlLbLazJWTCLZLNWT HxWbtib+dDhYmjSz9Gax4ts3m1l/S3H+GeNGTLNGtkj2yCx1i3wLPLebnyJ4zQSmWfFzsP+7Rvme dil7OOjJCTKxs+7tv1H0X9PrpjEb2GmmTCYTCYmxhJ/+k4U/65X0vgxpWI3EPohOZAQQqvogVOwg ETrlkiHjQg/zqJP96xO9zNg1E+VUfXyMXdTTH/UaOrN9ZKmEKG7MMrGsUZ1n/7WzPEyT0nLZvcmT /aEr5EBrYcOBEgD7BjTtg59n9kX69tghGQkXgkTJTrIcig6qPdhh/pzQyLtL64xKoJdfDDMwdSRK ocTzetwDYJGGCYSIbW2hNtsAGYQIMAtLT1IQGxZlFUVoREyKlSSeJ4ujfe7whipVBdZamVtlo0s2 b6BD+cjiZxzvV1Po941jN+h8HNJn+1ob4J4tsP98o/9l3QgfWokf2Q+yFf9QSnKUOogH8l7SpE68 ZH2/eyPsdceLkw71BfM7s1KawYhEO86zFTrZRP+ELyihE2IkT/yn/6Tk88kg+t8z+JH6KD/n/msR qj/UT+MTBYYHYSGGXZD+J0bHBH6zR/mOHFWfyMzjTkdU6Sp8jUw2MlP6THWk2SXnT9PDZ02iNEda hnz+I80KEnokEKB94PARbSNG/N2dJgifx/D7+mOWOR/oGGJ0lkL/ONrg+7pr++49HFdPJT0QB4mZ +/Tk3uMT/OQzCqwZf1uIy4M3FQmDg2Bf4F0gQf1H+j+y0+aL5IcGB6g0BDoMv6wmeuakBYYkh6gf 6VsnqBEcMbv97j3f23Hikf3ghxfrVbQCjXF1GQyft4q78NNA8m64/+JZ3CwmTCmnJy10SIlTmZ71 CB0EQOZ0pu6Sfz4e0HVPBiLLaZIYfDMN/8M2kPZm469UtAPC60XSnZ5EfF7nKOBFzM3CazS7NpDa TnOc5zknJMzv/5wYAjBo93KVJhvM3MDiplucDrI4cRnU14yz1T9XQE8LS0NxjuHhsbrXVU0czcpD BkPzoUrhOoDIepOV9rr0DjukBnoWI5BckGRcHJYO50lnrGD2HP3WpaGeeXsMj2FHadJ0B9AKiDEH LOEA9/cAxIMiHgTSQ46EElDYcEQYNlNOAmQAtCcRHGU5w9W1aoxtnwF4ptLZDyxAqKJmJyGRU+HQ d9P/ORaZ/2f7GXf7v5vKP+mX+3pF73tGkyP+qXzDYNjQHLkvA9DaQ0AkA4k0/MPiMwNndss2Ybhl vw0mbeHDcfEyQjvSANTUd+DQL/bxkTTl5rVcHyGXsQenjMY76641244K/pJIpL9X4uc7BvCSngP8 x/WfyB56XokdaJ71j0Q5e/YcdTdI/KwfQIRPq8BhiQ8zsDUDGLL76noc9m6HTd/rqOWmTwsde1kn NZXrkRPk0Vh7Mm4EYd9iirM/a70XTRrn+n3PR6WFU/FI5SfiH6/iTU7Xcv4TJ0jDO1ul0JcB2EQQ smX2rjOhq4Z00vWS1VGUWBMySvkPsNgH6+Ax/0+c7V2ezzfMUez8NdDZ8PmvfZee5fk55H+8/En1 qij37RPxejJmYY9Uza+zo8dak4kY41wSAfUyjS219bz9nIfu4LsMVPsHEfFns9WPQeL3BoO21sOH aPhh1+/OBheKRon2Lle7Y2OnWC6NKT/6PE4aQ+FHw2ddPvSulPjlHfTsLapb2xuPBv4q35JxfwuH NI6yWF9jD2OTJ+qfYx+avk/I9I9WC+ZHiCHDG+Ca8xjWTqDMNFDw+TzvKk9CZC/n+7fvPiy3MfDD BiIkIka/SZg83Opvr7GCfU/B/udOn3QyY+84fi8cBO/sv2jjbGqUaULF5HzgLRmwRAoM0HRvAuvy noeTH1t9bDDf7mTj4h0OBgX2H3K8QzR8+hRfUe75C+v/tXI4POofJeXjn7TLaftV2eEOaDZcsJAj qdj1nV1VUtttt/JD0EQ143k9X433Pf+Jx8Cx6leZ4eJA45oipDKHRE/NPH1IjCrDPhHbIO8yJlg7 yJyzaWn0PIkfYC2BwdgtkzZB+gvNpXPMoROrSFIgVOryAkwKBY9cbdDIRLzWE9ByE6D0sx6WAj+y OdlHzUohwnOPqP0H7DvDuReUy2SDY8jsPQQRA0BwnpMaTXAjWzmkrkDCICOhIR5omijLvO4zDKh/ uHQmziZE+m5keAb7IQDVoG/UxVbpgY8Q+o0PTBI3JRPLzdCq1/VjtB3tDYwoE0ZDAQLKY4TkSR5h 2O8MN3RXpOD1fi8d3Z534XNVPjT0sOHgp8ijkeRkSmeNJKaz7hzUMkRzOoI2XQp4IYIB4xT0mWFp 9TcpiMY9SLhMwAUe2HZPd4WLECnQvPbwzPUoIzMwhoOHhoC1RIThw4OaOcRKPm5jMQxI7pe8glUY Iz7wZEh8Q0y2kpshEvZ5S+HNkcyYOyQX1OxaWdG2j5uqcSoQMqGA7CpQELj0GouszO2NtLOh4HTp j37DH4A5w15iYgg97z2OnLLwecvo5hmYiqpWsgRv3ninCdkM2nhDlKlfDz69vBPg9xNyT4HAj1qh AMPeQeHd2aREGM8jkdg4Z5jJXCNf0sU8JuTnLeY6B9XnARoaeIpdzPtXuT0aploJ6TkYRRBO0EAU hrMh4fDmU/cCkFN+A3gWnKa5KaoN8AzOpASD6hhZKBU9TlFTqnGycnvJnNQin5NEchSU3uHFkDKa 8nKCXQiRFHaxH8+sqANYLTehw+xC/aBJvBQlLDzB4dcHM+yh1VljuJqfLTrodz5xcwzKgEgIivrB zmIp6cBMRQCAk+Ngku85HIbAzMrrfeBFHN48yuan3fh+/tPNHgsimDxZXNgtLUsPJPM9C+65mQ6/ LgbVbG1E+/7uxOnY08ni4nE75kz0/FD7NL95j7Wn52zX5l/Ntw2a4WNaXFYIaKbMKGX+MphhfMf6 c6MNGDKDWh5aIIIHcVyhmkgkgkgwgfQtQ4MWwstQwoUgVjtHmKmylBzZTDDgwodSg7SnJhdjso20 +sls4sf8homa1SMzq6jkejpY7ZIjMywqmyYzIcoiNkmFHJiKUZAhNJjbbGclg2WZ3nWm+DowmQmF patimLNWYaVQu7NFEZRQ84LmU7QqqSw2CkDlEFzI5BcxLEDE0LMaxvgzow2YUI7zQc6DUZZmXm9b 0be8u29z5AcKc6kjOTSHBkmEOzrDUkNLoEdCznrcVfLpOM1o6NsdyF6lfO1xVzMu2rqahrMvOtZl hGN8my04am5MkG2c8XWEfGXMjXUjkjGsnM5Hc4l6561w3wqFCLqSiNThYxpiyZHQphydE2Ks2pNb qptcGGg3Da3o0XjRj2Qqhf2/u/N/J8T7/n7s+x/79tjmzFMH+ebNybKIthiQQpSkYfQzgEBIge09 OKUt+qbD+raP4Pon1+S9unT/j+v/V0mmjH+WML2KxN3y9x7Q9vxhSKgHxqe5967gX6rYw/D7/kJS G/PgbnJMuneN52PvHf9Xzyz3bv21aak1svqpm//Wfq3jy/EvxnnKGxx89qt04+Psd169uuPq08hf 7PcBQeAj+pDBCHzP+43Odjqjlm6vXHiCXlQ+8s6o833uw8qN/I9bs8qzKonCHJCW4B4GQDjvOO7V nNzOnE5tz8W9IMeBPuKGPTZnd/hrEkU0llnYvpno2umuODQ5B5r7/YI/EHKEeifO/mMO4LK/dLIm TunN2T1nN0QnJYN0nWZIZDIwaKEbbTIs2mbcdjhuu1mObm7Z27cZ27c2d3Mducbu4zu4Na5u3Y4m DocMSgmJkIYGdY4yP3HodbbLlAdFSSalkkGikGp7/lyZ6sHluzOQnAy6C9509y+CfRRaJ5+LndYQ PAfEerOg8jLxmSmVFgNP5/eh4GiDGFS73vHfqcSQbM0TAEHSfVOpycORu3SYcBTiGnchiTz/TOk4 6WqacnojEMWdMc3JwNKcbNnhE5t7bTmuW0/+XSJIG0jkhOqYeno5HmpwL0t5OfKV+RGwn3Hve7se z4TBflj8YH0n0mOEBtbyPzz8hTQaINBwLYgUCCghHTEbSR+Lu+vxYq0Dx5mKsB48zFWPHmYq0HAc ndIDYjlA2kQyjCwroDPoA5A8gHqOY6Rhuvi/ql71TsSp9aHE7jtOZ30WbJ1yyMlWWo2DtTwSpMrv J3OBsPA8B2isCvKWHC+bLJQGSgkfI/KkFzYinGhBOBwwSuE4rOOIIeIdQbDuvaXRCdIo13J4nksh jAqLCjjINGNe4F7vAHBnYXTR0ps/bGYqBj97kHI21GgjjjZDGs6uNKmczNqKqiKiqIopoKMOvHfv BO9OtSYJJgJnY7+h7xaCnmfC2U+WVFFZG9HrS2SJEkhvommI3EONNppNCzTRptGhTQmmjAwsMMMQ wwwwwEMPOXtWw50meFBdkMSpuIqZ5DICzskjsocJ/mCrg9fJYs2ddqjhJcMRENNo5JA3+lcCPQh0 pyUXmyMNDI+AvD+846gzDpPYMDtpUIobD3N9Z3VYg9wkuBAi6xIzMkOqZOsss15TWBvYW9ENHZ0G +6JSckQhTpYyKqJimqqqkKbgDnvz5YnlO6HRyTm+Y5rEHS4ENpXg2idgZLO05OiHa4RO6ptxUtyJ sHKNfu3kPSnc7ucWVxOw0K6myPOGDMNN1IGUqlguQQ+DigVgnDnL6kHeCPk+xs4CPjRUA+M+oTtH E9oo/V2D+67JvOJC+kai94mByieP2sMeXe97/gZiB2t0qh9gopb67/X9EDdqykEn83eKeleKfw7S hhEQPUT8BhB5CQnhmH5Yr7QfJGwKBzmEEcJECKQxtDs+QusJIqqgMTR2gc/I0MDgZm2+7Jw45Dnj zgDW4YVzVZu6wE31i2SFuHwwRCTpF2JsDSFAHJvAGwr+FszMwosIpCSOD9wBv5r1XKX4QOEvbZEp 3h9Aeq9AJAO0gQAgMeAkJ64ImuRyyT1yhkGfvNT2o6A/KScg5VBPClh4OzPiOcaKwOU5JWJV5HIu eJ7bmycNskx4Dl1WiKneWQuz0C23A6K4JC8d1agb4C4noBFwIjlcnuJIjJUZIR833wAo2NzQ9JBv oHy8/2B6Gh2bv38fe6su6dNG8vNzPc1e53Wfzt7fGvrK3L1yhHz6YakOdH8ffV/g3reHKpaW/d3N fVV+czYrVX1d3VsWy3+/9vsZxetHsS8fn+r3PHRp1p1bplTu0jCkv/F+btI548LZ6a2npCNc3PnO f151nWueJVzprS8/ppCGsYe6ZdtcZZR3yq+27husvLsfHXlHrk/z9OWWeeV+vPWV6cZQ8nd0q1rW Xp3vjDeULTvScHO4p3ezT04diL2xL46+UZNGlJb6eXq7ZztGexd1MdfHr5efnatm6ztfu9e0s/Y3 n2+Hlp7LOdP2Y9OId8IQ2hF7OdDl7PHn0ht4ulKL4x7t+G23Oml+Bqabttbkh3yX6/u1nuc43W24 5HPq9/0/h4z4fXV0dm1g/2Y7P8vf6dcc96jMzMzYyv645wgdOWvWnW1Kba7Otw/DsTfudNO3f5O5 Ra3Pnj29LePd7I5QlJw5zumXi7zxxnqzfZ9nuzMcknveO/H5fa/sm975km/Lj0+ot9ZMvbPTnv27 xna9+fK+TEvRy5+DOPU4fuR2d6nltr5Y105eArd+bst39Gdzidme2d2lw7w5ZC268N0bcGYb1ZYc vXuMxr68p6yDwDY863x4vM+z69fPbocjx213NpPdmde3N9It08esSu3hyhWRyblODWrbTxyZxKM8 RxrHa1ue05e3ny04n3a7P69vCFeo3s9O6vGbquzz7+k/ZGmjZPbvfB/dyx7DrprLxxd/Lu8uuM2m eXdN2Vc74dtyjDF+zeWMaVpyn55T2x49K5a85ePplxtnHw78cvYXhHz79OXXSWV3jHrlrTv8q842 OcqD/VsYpSdec3T7tIecbeFnHt0rpD2fA7kHA4mlsAfw9nNeofLzXnNd53GW68Hg3zuhEScm8bkh NjtDvh8UNuoHcbCMkBcj3pk8MCUsIeHgUHYzFMmIgWKBckMlkQLlARknkfyiP1nJZeXm9vvunt8a EsecX8vzf2fqvjlI4Zn5Jt8M7P8zU3z3pmyal3qPdAg6bsyHpLDUhIoOPUGB6Zlth/kYos2i2Rnj 0qEwUnGg+ZAuP0/lag8zKGZr/RGK15OFqDLgY2f5TwceSTkYeCTr8Hwg/1CEYUk/pHswUY+wNzBM NS+rK/sg5+n1XP4/znQufranH1Lc1oSJw88ge5A7ZA0lTKeLlO1TnHL4uHZHRtuxV98geZMP7mxy cPGeqcRj4pxpjh/2nM6Ehxdx8r8UHcug6ENWssyyHnnyHwFiQS1ezS7CK8H5QH8ViGJZv0D+qT/D xq/rzn+mYatL1xR82s7Zt/X8ud59rLy1+4ys+c4dOzb0w97679X8EJy/36LVz6HIWcD6q4b+xSoJ fSKoqKMYQTEnRjSlvsHj6X+7GhkbhS9QaK/WV9OZ0QiFCiNgSGg6P6qklgZFRjwVprXfUzTDinzG RcFV7Rv+FP9FMiwc/o3pPfJ3jBR32tpKwOzN2z/atTNDJg6EKjqlD+U/hH+m/F5zQfE3vsu1sboX VykRB+QuI/7H9uFF5OmckGdkd+Isg9FM4xPo5xq1uro5yyZVIHvk7+3MeRg8fmx1XoReP/sJHOMr 1nnn/Z/BBa0fMPSJRf3ttPsUgwhhV7m/8UHLLxaq8NLB5LuyscLlWzkfyR9SEA7uj34yZXUNBMKR CyyR4IsECnZWKxQgIqj5cnjz2EfAgo0SYB2fQd2Uz5lo8KumU0fUTAkLsrw73mchgnYJugvirnLW ZRxkplE1h0pBPNQ5SxSCyfI87/d6e8qGZSVbXYk+LELkxQCZotBTP8tQLWZs3JSVLA8k+CT1sMQL DSNhxhOIjieykKAvmfLuT8lenAs1EV1Nbp4/zbPYDnQJt7t5iqtlJPVPKcVSSenc+2jw1ffwoGXF Ph9J+ozwHlNr3nQotLzIVNm8F3zFCH59Yd/pKuF8lwg+riqgsDwExNeo4MxdSh2XS7LnAZ3ITcPi oM5yg5KD8+LxoZef0+VSS1N6NeGHjjRAymQGuMe3Iif+Ki+BH7FqfM+VrspXqvCD4x5US/KScJL5 MNF9xyY54Zo+R8JradpWN3HJjY5sYVwVtS8JubPkK6aTY5HOfEpzakOk4V/6HytvxPO7k7j3qx1K HdFeMydsR5LLYnyqFcMJ3qjY9yvbKnL/NjzZrOaCw/vTwD/6//Z3vOY4yX9gxAX4my+0nE+ZJI1D qdmY9bq+N5ParZ6BU4NjZsgxNo2ffcGSbE9yTkpDkjc3OHIdlmNm5zIEhhkML7CI8zPBWuplU9x8 R5QgOZeQFNB1HD62pnll7D5Tqf/ZpWn+TxVs/g/pjk8g+uQw/Kz0nLZk7u+zvxdIn3pSWbvQ1GgH jkIj6FwU3qp2cQeUvC3ILKchl98zUYfJDGkgwG/r/nwVO26oaEbGNZWWJbsGzel1CijajGrdGlTS g21XQ29qKqqLbyKovMSTesUZl2Xy+Q1DxjLlrWC8aFxqrfOv18h1XN8+9S8CgM5WyBRVLTSOOZw8 v4Eyfpk8JV1fXQdYRU9J+x5qlVjbCjhST2h2EdKUCpgqWSQQkJCQUGAYhYYnSQEdJ2ip2jqhynqI SFFOT0yss5ODKzDppxBBcCxn4WJ/A5P6jm9wr2zYuO2SCScosY9h5/LlmW6HkjcHBIXFHm1yoPUP 6SzMMzPMg0E4/YWXpkf9T+Ed88jyUqPkV0VSPiYxWB6VY6GHvRGHkm3JsRybK9siuJXVVSfBIbvS 6IbvWpsn3DmlVZSqNOitMUmNjCtTlJPO4bQ3h2LJOTSq6IpsdrDk4kPS9Vq2qtq2qmoq8joNyDpF DzIgaOVPuO0R9TAmsF+BJBz9R5B6rgoXk1xvWtjI2VaiLiqLA7FEwNAwp+lmD83D87B9BCaQpMQk PiSYCpiYobStgNnBIc8IcaXWyVWZFw3v8Lx0XycsaXiFq3uCnQTke+B0oHWkUVQkZR4sfpeVKXC8 1LNCyLwKidUKgihzgcgpqwlVVRTkUNEhW1crZzpdNocUNHFwNvs+M7DHIZ3Z/gM68KBATe1BkFDl J0QyQK0muZd2MSs1ogSUlAxglR6EVI6dKbXII5NLyPkx6PjoKPALUYOjZ20ge4E2zY8EmFNEMhC7 dApW8KD1mjdbpxKphNmeTzPgTq6dklPSqWmCZmHQ1F6CSmsyoMjrkM1SK+IwHqtCiou8NzcHkFqn IsmS2T08oH8jcHnqHgl0SeTmaKxWK1PSUnV2tMhtNkxOEes9/gS9I8Esi2NT2HaekydRLSfJNjt9 PbWMt2RbLlvUk9jonWTmfz90QdnuI1O8ozDMzhC8C/n95+w/y/l0QvGuY/iAQOYwMcjCvJ8atGld 7DZp6k0ep06H0Z9de6HbOcs5nYdUqqpFJUnReR2KsbGT5o9x8DwUKLJPbzr8vtedE8ZSWeBubAwS D9w8fl57hM83mErweQimEkscplpLcUySKwySSNkkTyE1ewvAH2pcAvmeT50btkmTZs0myjY+lg2f eN3D5nlRU1FTUVXp6zkGBoPmO05kdYfKQK4ADzuPP7W6enouaJDy55jHeTUSB8QaQheHXSFib/Lh xg/amgig5SRoIcCRlGBYQNfSHE21waCYJMMNnCBrDEUaqIBDc2SypfO4mPZhO1Q0inJa6M5tHTAw zRoYwaCSjWGjUSw1rQYJcnofFaW9EOYcMDOTDQxg0FlGoaWksIxMba0jm4Pw9JEHtWlRPqoR1VAQ XPNiij/YHMT/uP9uKn/qwouwQwNayRtvoJJycTdjlsccVYw00aNE7f9Dplu54eZMJ5kPsZXy5On6 iRLJHTxd/m/5m7/qz/jOc3bz/hm6poiqH9fNrG9wbQxiZI5CGlANtCMQYSieO5JJJZQk8lr01xU2 g0U46qwgzUGMQJrRn1kbJPoUWFUQ2mtzkWE/0gNGm0Nh3UNFiIv9yiKmb7VjhE2MrINwp0oiJta5 K04YcVpZZUribb03Tc3opnR2ths0ja2NgQ4TEaFg4xKNmf7MrMQsqIRFOlcdB5Yi7XZdtaF/rT4O CKJhn+8gYaMUK0adIFp4cDstBEKjJonp2m54MVWFb4YVVUW8TeypZrfGzTFWoairR4UUDDLUxg2B bFf/6mQaw8hx1EEyNRtaKVLqUuB4wshHhEbPLMMUGD2QjJZR1kTCUiLIXWDhJ3M4MTBd2xho7p5a MYkma9aaLDPMqqxhAZkYxDjsXmPnW9xiKdhWCppkmVKmjETETdpGo1Y2UTEqdPabGO1ux/1q/lbM SmMNQUKUMNFMMGBow4D6KaGGzaIMqqppiuGzTg/4k/3HbGmpEPqH6KL+WP5pBdQ/mv8cGSmpEoSl KPyQssXWftu9+rj/Z+/93V0ZfW5wTlSSf9LZidtfZWPrN+Imw0m2iNIzfuJ8cwf9V/7n1C/wUP+Y H9Z9vb8UuJcC0E7r+C/UH8hAwREOQpiU86TDJJqQ/nxP/d5OjUkr9DAiHNImnDzkj+iuXDfoejdE 9SfzNold4NyL5PkOrkCcz937tI9bsbLhpZxZcGZ5FTw8niqY7nB8XHWSP2t9Nop/MscKSQxMhL1k B1hdwKDOwsvxQuFj+jo/lk7SbtG/Fa9e39v8OEasiLX+ZzXtIyI6fBdGZnQA7CQmASyM2U11IHqh Ad0DsTkOR6+9Vam2mRtExJhdsGkbuxJqWbRtEhqdC5E/tTSe2IK2OR1dR6R1XQkEhgs4ie0X+KiZ RMmQPPWdF4kVYfMPiTzvFinJanWRXxpjg7ExOTdNkg0PPMffUOw6MPFcaC2NCht/QKPklT2+Q4VS aAZZslQgVenDzy5pCDI2+sR7T9Htf1U+kQofdfxbHdrR/Rrf7k4n/O3s41/1vRhXyue6LyqsLyTh t9N7OFxuCAJFBBeMW3GngTSpUEDS7Xu9bitwajQzropTLfTzZV0TrT5wsbeyh0dTobKISFyuN8at 1ujo5aWxajApJnQqSilk2K1W4+XFtp6e1srWhV3p8mp262TRAgl9RAqGikw+v9FHMNzaWYSSE36Z 3dvWzsbR3UHRS0OKrzqAaDRKnKHsJeVwScEciUOm1VqHCw3o0vTlkN6aWE3VOd0wJIkno3Q6YHYa Rt9NBWkiNE3urSiIkKIhpRMFAN0xSoAGo0PVsJEwZtvB0koESTKGtcGleRO8jxwYhtGp7zbe8G6b yN8bHtMPgs2T00kNhj6aFtguzNNCLM47ZoDGiMNpY91R5eRmoytlPhN6jeoY0ttDYk2gCvdJIbKg XQxE7GFGbghKBp5whwSG0Lynp4x5Shqy9bA4sR0pGVbIypG1E4xjrY7Q63xoDGKsRGHXUSo0NiQx gI07I8cuRo5ybwlChkomQ5yxdMLUkcU50S0nSU46sTrUmrJzoasHb2voe53GynfL2JyjZZqVDZU/ Q1rQk78dnhtPtdFeKcFPFWk0KnaUhpNFJiJpxDrNP+Cta5U/0wak50kkdKoDSBGLqRsGkVrzGIM4 XXs/PrMxedhM1DeXt55jyW2qyXe7X0LuP+kBh1wTBlGlOIg2ziQuE02JNM0RBBnDXYyDLyFNwTER G2LGFaQ2UsGUggtm+cHTweRsf8ZeKrbxy6tlDUFAh8l4gzfR2t8H8xw8miM8SJz/q/739b/X/x9/ d6zhqpDtZQ6xofIztI8Tt9BcGzucCblDjkjBY5R+CDipe0RD8UBuTASwUMXJpbbiWqqTVdDZsaPX Zuvv1huWcKcMkvsmo/11JyTlM73N3GFnsd6vazxiiqSVHNsn+Lz1UVSy/bPkMYlQ7QRthh/mLzzr QZO8u7NdNKvJmjUqowzUtAxCqt8Cx3MgVGGTFVgqv8FFZInhEXPhk0EfX7vj+CHMRVAZgzOZYcvQ YCd4MIxvQrqSkrDsxRVHkDSNaPyqmkUZg2bOcu1s395oNDKbIGhUH0VIgWBHATEMOfcUN07BytnG +0EVIKNM0EYTVFyM4PnNaDR8L3p8CFuidv5J+Hl0JvRROWEO6jl2buzlubpXVTRvBTtaN4nXx0V4 cuVgdDfszUk0sRzHDou20SSqiiySSBuz+XuzaHGMhB+p1dXVTZ0xwpjb/wnmcel55nomh92MLO8e VKTOJsZ8a/oH3zlbA9amYZKTgo0hVXp2Op5sMNIOqdoIiACyOG0AsLzgjEjJJLCx2YY772jkdzeX o7OA5pYgferSA6JyVdvUqh7WFM733CrlJ2p+SzzRlqYghkJPBRZLGk7wQTuZFMFbOHSpzetVGhSH AgnGG+pECvhzR5wXzBquy374X3WUjBr2rldut+3E9GdeZfPDu6jlq2ZGOGDzgTgOY5E1pT/uVxrb yRtOfeb9sJxKHRxJGckRwmkDRd9WP9MMkBreY8SqoCPh46IkAzJsELWtLJ9GoYjSW06oSQBKOa3r gFZGWjtkf+fwE66ODunzv3ivKj/3AssY3z1ZTw/xmESF/g8lRjE/WCPdT0s9TcWwS1pQGkLrhC4Q ktrPittKPJiAScAwkDJI2Hmk71wa4sgUEsmMqPzJkcINzw3kcf1BaCJVAW5SCkwvyzWNHKUqIFpO 8rKlSZBjROsBR9ZUsd2Na13zwsMuvaTxst70qH4TfldKp2fZ3Ki9Mm1mMckijGepyDD0IYymltEV XAzDRtvsLypyxGuYGsazYZAuJIIJMPZxIQ2vSPEANaUiPZOa9qyRAYYSREyHlEuuehWiM1NGTSx9 dIzR5rzzyr3Yyee0DgFen0J2UnHcqF8RV9nTbQiaM4zOoczcW1wmOxyIUgSe6jB5jpqkPQyMYsDk JQaoOVAMhAasTQlAUHoqqFGdsFdIgoI+k3bp65SLJHJgwqS2HGFbdb2bx1bZ1HORrzaAxb9QGYr7 zhE3FFo6OD7hnFgP4WG1PMR9OPxFsWzgOdUnnHauumqEkANlJsy9rznwQB5iXFtHIT3efDfuIoQb IpBoFgx6w9+wrsWE0cJoMH23uqFD81DRCMh9O3RZrN0/snXKNPsL0xM4qTzW6xqjPm6A811nL9HW cazIcnlhvONym2NJF9poZ/nHrutQF9oiKwKKUQzCZZsuUIwgInsdISQB0HSw73wk0PKII5ikTNp0 aEcXtrhp28Z5t0iPLZ0eU7WG8ibywJikHdO7yb4TuJYqOwGlTszvAI19U9X1cdC6yqVIoX6zfq0k TVFkWVzTQGMs8sp2lnizZ6XJRHPQkmGG1ZVl8LpHlw8WwcTcc4moYkiSYMiqEISyIQgD17Yq6RgC CQJXsnFNHS6VQxV68BOs57J0R0kiIghyCAGLKyAmdCwRxovvIVOeLmE8S1S1aYtfNOzdQdqU2pRS pdzrTrosBk5R/SHBmkf5HrHw47OZau3O3n5sHbZDdq1hJzg7yAZPRpEQxgIPhIJLfHfv6kxaMEK8 Rwm2CbAFMcILRCl+1L030cfQ+vvXuXdWTbvvWPMxiMXGOTiFX60xbTPXGRbQjo/TKBHR1/cvzEV5 no6BEOfnJCaTusLSFalxMzCShRdoza82gX3kJykTYnDYjFBOco4QbBmOBKvngFw1ijZgIB5OnBqE a8ZxJvGWOGP/Nntjqx/4xC1y7piq37NHnzHuRrHQ6J/U20KDDXtjGLQr3lyYdndx66bfrqq5yu++ dp6vPprLU95vYgmfRzta5yhctM4gKFLR26Tv5w42cz11JCK3pBKZpc163a2eK94rU1naea1y8w8V /ttam2z6LeXBpvpOellQjq8pKgsV7oX7auZ+zcfYhz2LM9rzXHIqO/lce7IOuqrPBClqSer6KRSc g1e6EAsOsv5L+CN9CW+J2g/V7KwgnTNxDH03VI/cKcEYr+vf1McnHzkZqxaU/ghJAEg01rlLDCSQ BGDi6ykcZ/xQeu1zQPtfvUyRvl99eN91OlYhUGU+3vPoMs9HiO/pGt2s2VZE4aRwzi48uZtp/AMU 1zyHTz0yhpgfY14ju/eRHVPy2Ge7JEy+eM7KeSZZ1LEYy1pbNRxnLeYWZxpOLs3SywOxe7adfZ5H VIpkD1gCh2cGa9p0gB4hU6iO9IX1mqXyN16Hv/ej494kcBVI5iNO5bnSqVMJeotfQ/j2X5F/oPmf gH+oD+4eH+k/wHJPGU/h3Hzvn2z5jB1SpWseKgfoT0j7q+t7wPe8hDzMihM+MQTVJ+I18/4js0d9 9W+H0T9dtYc9a+uDnz36TY7BE6ZSJFyKXmXrnrWjDuaXIsBgH5f1xCSo0JLyYBCodl7LIjrRNqIb 1A52WoTO7IVmh3wQvhuDe54l64vDONdF8rvUR1eXbrtxTDfMEyBlbvZ9ry10tc1LbBTUEHLfEFJC MKwXTSW2PqIbN6qN50NEGcsrQLgkMYNlmiqJiG1GimolwayswFKE6QFFkD8f3H/IzIhEGLOHI6n4 FVhQEEDrz3A7gpykGlXeNtYtiue6lHxGiS49zL0TptNq9QVA8S29lUw5mtbGbLXdD1G3rcZIk2Nu c1qrdaIenseCRV2zTVqQjE2rVqbhB5ZLYWXLWdWb3t6dbnQu9mS1EkTt3eauoNm5l6vbwkjsixq4 SIfepNwSrsNWKiklELVO5NXGyRXinFjBqNXJH5nSIif4H/B7Xm1yD9L4YI/If5f8mjaj5D5wcGHo FwwiZ6OiWtlFH0Ms5oj5p/CveMyH4OzyYwfMKE0c+vEiLFmag5mY4GHKA9zeFuJ2liaI5qWzw852 WTQqnq7fUu24qcPY5NKqlTm3ZaMKMqHIaTQaTkOXkN0EQVIQwq0H6QI7p+Gqp7dmR9+JIGp1DjmC DtTbZYJHAEVApVoGH5vr/Rr9zD9QY8urO3KA0U6482x7UpS1/F2fW2cc8jnn9XRvvD/UsyuLcZEV 9ZhqMPtm2yytnm9ttcHBvI+lRxUTkWJj2Rz/6nLeJ5LD41Ko+TME7JE/qB6gOlBO1ZvfvoNJid/R M+vXvI72R8uBQx33x5g+Y/UWh95s5zuwhOR407GjmkXlYbn9ZKZ2JPT9Gp07DE7FVUtnQd8iizM7 HlzbG6J1seR5bVvLfo/AyRFidzkIeD2ZD2QhMO09fsUgCmvEOh51mfx9UhnbTzvJch0c8eenLfDj 6NPRMYLUZwxwDFnlQkOo52NmOOWUQWTKRqklyDaBQgJDOOLOLskM2TKSQ9wrMEWkdqPQbDKKX7Md TGQ3XeasT36KLNKWZryj3cq4355vA/AP0K65LpsM9lRuWThdDeJQRxRyS3Thwxs5zWgDgDtcKgMF BGHCRM4NRVzsg7hjQMJwiDBMZzb6aKEEiyzcaJKai/gc4JjAWbA5aheREOjYg7pkOWgVDaEcmfm3 R/I33blA1E6A5liwU8PsGGoRkQcUpS3RE11FKfGchXGQ7UKhe211pNOokQMkbPf3JIZE6lIoByCA TQGjEHtzcOQD45BkGkzWebLmUQVAMSjyfDKNCYt47LWuq3dXS/HJSxsmjkSLc8Tdw0er7jyPJfCB 5S03lgKeg3R3LYzMIA7s+DKQYRts4PF9NzNCwlqYqjgqjpqDODwne12HqNnXkGQ3HhwcaruMI4QF nlcRJoGJkYKCCH+pddOXO2b4PUMa2BU0zZMudohkyzyZ+DiGrdZkmIXC4QLZ5kxBBo5jQM7DaJCM HYB2kpVSVPQWbhPRdnDhkMmJhliPiINoaLeI4ZDMiAFqsmUlOQEsievCQrt31dCJy5aVfxxedeo+ VrQd2loPkYL2TF5GyX3zw6z1kdvrjWPZ3x3z05x3usUY6rWS2byumhz9Feud999OWVenht0r89VM 747yWq3qdt1vpfOmTY3Wed8UOX1s5h36vcHe+DlZM40Lxrfe178ZsGelc6hDGdx5kYjYqZ4yvnDF WsrQHF7yxJ4/nc6NdzqtGuX4ZoLx/IOToy+26nDsXzzjab2tGqrOK01+VxrpdXS9cKtdtxzS9z13 1w78mtazrc8cZLKul6rzk8Oyu1g6zPPJyo2Ka33fSG2OW6644fjsXrR1Sr2eaTjrnpoaI1vDTx25 tbeb755jyznZqTziunxqc6L4N8Q1dtXC55jty1980xnPe/O8VejyM87ncbxt9cGutVG95XfL773G /N61xksc14eWw0LtLGHTqFtVOVCRb80B1DYNbzu7YzJrXnU2FPiX2Rncj8OV1CESIDuqpSSD96kd 7KIgyVATwCASBc1WdLkXDIZPEp8rXWTF5JGQYszPYWoUyTjmMHZOlnGzzRVAiMWNR5rZF7UmZAxQ jvGyIwDdkJYGUYoI9TaIddwr+4SqFSpzzByfy7OkwtgOSaKXNHNyDrymBxXAYC74pOGHhcJDhwOd G4GN+fDuXPEyB1ju2RTbgpg51qNlKVXh9SPrQYMC7wNBbPifFdMbMfs0Rqd4FPcNRlbMibPpwRB7 7oqnARQcxhSBzBBMGNKvDnyWYUDManEgPZwx5wiHq47jxXu4SclnuSwDpzxHr1EYZx09DUeVKBJ2 6Mi+hIMgHxkImykGfXEUpk0My7ZE9EioRzFXsgNcnAoAMAoGEsLDTRCIEq5hKjEnKPGUiCC+wsfY EdAnn3xljLWa5VFSn66p7Qo7sT4EghKKg4qEg5x0ddqYpJxPcuGqytmxBUyoyZeYJ50F3ybmPro1 3cnY2pA5LqchiwNDjrKeIZZmW6fy67kWJIAYCYwupDYgIkRlAg4ojIt1EJCmI8RB1ug055CqZGiH VAlyz5ZhiTNVVqNyvGW+5cCgkxoINEyJGAY5SUKhArTpjoi/Teos2SZrNbAgyWMwkpX6cPEb7G4n w3OyLBYHklp1oD2ec5hMNU85SBxygpBIH75FaCjczaAF+lglNjPPgrET6Oe05smUnHMWL1vh/DZb RmTZ5MiQ6cyzuez5lN1hZLh138skjvDc8bxbl5gzaMyMqeAg0R9LwhDg77Vxe7W0y6f/djlBZDez kU86z2tGQ0mzEZIjIdyanrp1MpeWuruNtV36MChqRQc+b73pRky7XRFbpPKwsA0wm9mrWgBzxImD EIwlllVJWcFQqoX5dNOlE4EPcdEU6DoJ6lCh6g4DXseFSw8kkNKexTpUKIGvwwQinFxnzqFTjFQv 2zQG6zaRUDfq46R5AdvgoXv64sQm1/RPV00SHoelhlMm9joFAOohGsOu7tDdPfBclYxw8rT94B5S FOj2HeGnuYzexli1vXssNSPTPT6Hb6Xm5R/ck6/XnwPrDC593flKwvAThhM5GCNd7AoGbE5i6uuN myq4Aog33KKlhWEqiHY3KgTZDOtJX4kr0WoBMNGRQN5oJmOOFlMhhsqCVYgRuLPbD5Uy08BtzSJl Yy21wYVNd9YkHGmUM60rsXhZ0vEd/HjY8/3a6H4jbxHtaZopOqKyF67O+pw2dsk0ee9G34uT2Pid 4so+jkeggpPMCywM6daBTJ5upJcrzU7q/TwzdkKyTJbPeVAKveHJ0hLMZC1pgql2tIFRX10miTSi dTMeiiDGSdutNZ2DOSstUDQKQ3NNiIa1xPOacNv030lauwhV2Zdgd4cGGrliWXM52mPhrzUWKzv9 Adex5NCN+vnmPImDnypZkzPg4YgaDoDMOTTRxLK50cBB8kSC5UhgODgYHF8zJIRmAXQgJQqK6uc2 wIJoDNZ3VMdC1eKHaoq661Kp00SUm0eNFRZznkWdBK1AZgplzujgRlQycEHRhRgTiyDqRGlA90/w r0rvre/HLSxo+AWJkrjHKJXg35XfTpj7zYXZhdmQwyTLW3ju1QralkkMlNH0V+sniUalU+5ciVot PZbdBQqeKHgPihisnmUxfyo6Nt/4j9KJuuh23rU47HY6mfROowycu0itjn1LuKRKUaozt61i5o2J yT+18Qyhks20npB2LmB1JkAZYr+5KWEZEGwXNNhW4gzsrozoJ74RyKlX3RV/uvlejOY8a2ns73pa zR72mdab4dbdAPWeqyNLbC+c85rhjO99aD1g+AVflIraIZvzWHyi2z81Of31pluOc4u0h+WV9XaK jrFnGXYA4i+qrLdw8MlvlLRtJMWHfP14bRVK7kGr66YO/L24swRXTru81ra8lGdyp203z9HhSchw k3vzw4ue2heeE81vXKe3Pkn+Xzu2Rcx1c8ad8eHPnzqs8hIxjnecOnsYVHRZAz5PVlplgjLQ/dc1 JGT8nL2ESNhtiWAdrQ0nR82qurb0fPU1343Xzs5KTt25+OORmeBvOOPs2bV2VI5Qg7BnhzrV6Ae8 QtosMmZkmTI6n5jyPpuHtPH9iPoheR77nY+1ckVDAnoMjCNSESOQPFw5AI+CPz+z7w7nBzA9AN+g r5iFEiJ4vDi6PNKImsbvDqSOQg/fkGDCEdZGT0vWHnn5ze2brrR97PoaVO2fhw2NbHrjtxjaY+bA x8nHOmVv2ZJHKwdrlQWxaTFOfTl11Ok6nVyerojrzFQiUKTqgAwihoTZ6RhB0XnUl8RhJd0pNbHk W1i2S1lmt9PZMcbWVmHNqyhSsRp2hs3dWSSqMqLbIwqUMFywr40TloyxWRBIoSjhxNGsTaDhrZ0d jjDGb7QzINiMOOYqphFm4jTMGVqjr20OaqjQutHc/7jgP+1oFsQNCif2ionL71xtjgeem7x+1Jss liVoYmyBVxlR1sWqlSIhpzTyMuhbIfHyojLBsbHpsl6sMHnBxOrXp8jfTac55VOOqZjNDwnGmkJZ MSLWJIlZRhlfHS7Rsth4KGdSZMlUjbD73px81pdjOOo6K40XLKY9/8wipqONxfTg9veeTv/karcm OF+x4nDCZNJh/Mx+YQxAeY4MNKr7HwCI/TNnXk5RlhOqn6F+4YtG9z5fO/KGfK8BV+zo7zkCmlqy mQIBDVLofFbUaWOvvntTqjbmXhVMM/tLuJhRMjDIwPBsZMxcxIE5vGRShKEQkwYbRwqXkGFClQjl yQr+kISLRoRs5neLcKn5eDM0P2GbmYs673sJMZs8elAg6Ax3DKCY74HMYkDlgPzzTgdBP5clfQLo wIYXrlfLrOr8+s+23BoYmSegMUPLyyY2JNFZLYoysqJatELQpQVH/RlaVVANDmjSoB2Gj5fx/Dv5 xTICUGBDe9EIpiLGIZ9A9k5pflj3ou6yDXoQOq/FS5QpRFCxsYCCexAHB1YcmHbrdAu4MJd6EkAV qiqcb8qKIDgLjVHVMoorBArdidDlfEqoqYAIvX8jAViccuUNujQcW3XOhznV0CevZbarjmOQzA5h Q1gaQdFzMDMtXmj4bJcqPtZAJRmG4o4QUr8zENVAkHAiHkn+y7a3UxZYV865HM3brptl0dpnSRSW sNYOJrKL3WMPfz12QhDBtoPM60QmOVaBR4HAE5smHhdzElzeEFpdICNTa4iTdFKQpdGwgiYvu9VK VjAHG8h+tMzOqMjK06Gq3q1AJ05HKdOWvPe/J5rItWKAns9PVlJ2utrkyzcjFf5gLLouHMkzFGQO RQg5m9jBLlAyOvqjOJw5JBanoMmoXUkcLhmtEOY0RRjQv0nxRI6GWVlZ0Y/fhBqD3TU3459evW5L ayLGSLDI1d+s4Vuk8ncO4uoF2TkiS6d2rllckQcnmwaDGN1oMurNnnznf3HLO3x94/pVxIxgRpkJ 6w2UGDbPJqlmkeCI+mLLkvtZSA5SRVHcHHFFOywUtLE5I6tHlHutzMVCIS5QnvpMLx0XM55yA0oB XLRG6sppN1DOf6QoKgBXbioDgskbKsA5sTSw90OaiAPS5nJ9RayZyLROBnp4bszPXFrtJEdtVm4n jLaAVPkQSQEWYxI5c62monSEeWUpYeqc63wvxxuLsh3Bkwkp/ITh70HDPMxl1ZZmCN9FJt6A6UHD a3XoHokl71js39D0VTfMHhQEXYuBcy1OxooLtrDFa60Ry6mKrnFqR3lxIDjGw9bqDJlsKZLBpNFS FdNImN2HJZZMRp0W15qADA/eUixupjakZYclxxOBvQpKOpsc+le3olPM53L5SJ4majUEZ5Z5jWRH VYcp3JImJMkUmSCTJmZmdiQMSelHljU0U0LJKrqIpvGtXxSvPNFxBjGUB8E+YjU0oMPDoBgDthgZ FyQPjxKV0kFLTSRNMmGBkd71JdfTrq5iOusR7NIfsU6JZ8dSshkjMxOgyfxPDs5+rx7ejrVqGZVG DIVwNx03OhBU7QK+HQmbBp0kanST5q8nSVo0Cu0n9zoFKuomWWV5J736B2VaZrNkBsySTrjgGcOC I6mwGi6EwmDyBDdaBfSgSKLAFaxw5m2Bpu01nAfVOT0XJYuspiipiXoaTWUo0ybOtsONNbuxY0iB ufgZiNGIMozgbmTsZr4x5ytTd+xQfGZMhFzNByY1JZr74ZmoxhhHoDzd/iBwlVK9r1Gk8eRm90ZS GT24YXN0nxYJ8VID3+qRMLAVoogWm8o50wy38zc6P0T5AQshGDnGqaayoLnSmjGfEkTQspPFoBpQ A1Q7pMgjHhnP0QB7+liE+Gu6J5UHQkgCIYMoKdq6NU0tkbDm2jpBYJTIXz00yfl0p5+5d/Fg/3g9 uPd8VUdNbbYM66irKBD2K67XNk1mO2mWkNTzN+RNjJwHDsOvxsmVnhOuJnLdyWESpQGGBF4wbfaz ypo1nqF9y2IjODjasYAPw04Xh+0ejMQauQOxos4UlpLXginVlVyfCBhw6WwZIq3cvcUK/ERfon6G TOYDD3MjFZBl+EFV8JvfoX1NHPqoHIGkcGXzAU+UCAWB+W/cx3Y2jfc2mAEkHLBykcu6LqqCNKjg flUno7GarQeBYpaAs1lpzdAMVr+eeH0Jb86R3H7OhiL6Hn6biZuNVAiUCQnYhJF6QRDu99m/1M+E qNsY+muFjzO+szWmnpHbCyzXNsr7BER+EskIKSH5h+Y/AH/O5OY9yWIk+1P4z3d3aXw6+e6ly5PP 3Jjyn4ftAcEn+cTYgW09C1DPzPBBMduQfre5gyD2Z8a1KMTes8Pdd73mlqvzzleyu68cSyx6hh83 PKW5VZWpXWga1xLMmw7GqykX0x5wVBkyJFbcktnmNsaZvWRXaChTLEIaVst9zGY7FQo5VhmXtvYx lC0cSktH6OsUITdTD8aaXpe881skL+Y/X+fMPYB9e9stn7Ty2mZj6QCLaSWlFrPnU3fjHFnA6RkR MEJlpckyxUxTP3JGp39QW98bJ2C1syVIyuY+cykCo6okRdbY8k2nyRqHTKkVPktb9Z3i7DcppXkh XXj55wnmYm/3m441vfJnZ3ww19N4/WkVWul+Ngu+ys3gUU65vxlmZQnlrtrpjTJ+NmpKJJPrGV4k rPjqqYPr6Bkp6rU5i6B9QftAzS9RJGZ4nrT8pF6OEfQCS/mA7CXqi3cGw9TMKoe0NQ7ypIKL9otP FdH2XCFQ6TWA5nvOQMSA1qu4Hi+0YWsfAY9p2XQPglToMg94Bv7Op1PYw3Hz0bn30V+q8XczITMG 7TXBz6cMENjawbtxvtb884x26V/dIuSKWxnEUPURsSGhrjQfvLhWW9kXM1KvRLNbtD8y9rT7YjFX i8tjfA1w1nOaQhGC5GtqkK40RnT6ZhuHMIbycUpSZa2ItDRxnA0dXV00S1QltrJFMwEqhK2pil6e x4BVLWhTSkKVC6hoQ4n/AsUg0j1ZkLoWOUZ+DZbayCqY1mnKyY0o4sLCVHKrmqahGaCDe2vTMpbR baprt2Giy5K3Dmx2lU1EjjOyOxtWeavWZAqtS4Kw+xN3Sk7tmRVVQ3DI5Y49ba5UJV6MNssQ+zbj xrkjglbdisGtSKReKsiHS1UIcuCTToo4+zTy/E6Cm08TNuM97T7fXhCAnX84CLqCJYcaDCyvgrnk 7Os/fU4bgFcCDuhxI4Vi1IDpJFU6DEdAyQxuqtu7gw3I7s3y78D6JXfOFiNm8jA/PTAVMAOcKmBn A/k19bjGr+H0RiuEr1qVlhDrugf3Z6/sO5wcHrnrtGvORg2Jvs/QdCYVjvUSvRMXt/a/fuw0n8bG +CfLsDDIn1GjpJIT18vbmfViV2+veSSLTspKdPhDT3Zz5sBTaZ8VQzzmhJN3GNLBGVR4HzQaRqW4 a+lRPgrTuu0iGXFx8CamVNqe0UJzzpPNSe3K0pZZ55UaJR2xttXPHAh50hHTIiOqH+Qccc2yM+2T awqG3GUGrNtPVuBuHIHxgR5yL2So9ALrkq3n8ik4EGKChwbqF483BpiW97RtE/F2fkDGoMMDDJCo mC2pTQIIEJa50amcM86E0FEkc3G2syJIigy+yBJqQt6Cpe9MqmhfKVEoaq7zAqcw8IM3OSRWqmQv z53pn+VOVm0ZV6F45h+F7/A3r0Uyp8h7XzSGJ91u0498yYoTZD1m67L/w+Tu3tAcqucFA2AOLZBE /gHJeQkkAeni9FK+LeG43GeAU3LPwvSQF53y84hNKxJTFAgiYD1UdgQpI8ihYqpA8OKOVxoqA3nE 1i4gTCV6wMneTxW5ISSqU8Gtcc7SMY5sam7RN8tFxYdjB9i+wZYnJxfYnQg8BhpVnBQbb0MY0akS eTFHl8pdNHJwB8jh/GI2Bzzr0tJQvV4cOuuFpkZYpUnC6IqchRAMNQxo/M+7N6JaPknKHap7C+tJ cpnF+0Z6mAXwUdt7I8+eX2kan8ZVGuJoHmZ7Pm808xs3zs8XydWdE6vHHG8N479hwiPD1HCcerWn oPEQl+boTgJhzjwRL0QwSdcYE/iKH5jaKZorE5vOUr6BTW6DaBQ4OKI/X31Xa7iwC1FsxBrvuOjW Mk9IpK8SKzSFHhxSSK8pGWXciSz6aaJufW+jW+jcZXmVwT4lb1f5wG6OkX4jKgMit22hmXWgyxxL G3Dm6wPM3M+Nw0MUwfZAIQ1Bf0bgFQE5EbmKCb26UfexE33a0HYBaI4vxVK6enGlhDC+vtODDE75 7cTg8txB3DO91sJ80Bwvb1SQOkv6fYKSh+O0RhSwVdvtcy5bn0XAEYEh+C790wSdG28cRpCglfuD 6chRhEXDHVR2GFimg9DaFIek/f5e9fs81VTdh2zkZoziY60lEDq/adANDTnJYAsBsWmFd6OuPcku U7J4FH4CnGc00rb0irXV9PzD5VWVmuStUfdc14DLzG/ZW3NJwoq8CsCso/x3+bL7/B7I9z8SIG/K zTMG4NkCPGFqRtAo3AxNEcy45LayvJ5mEB6raYtgxwXlEDD3y/TfqVzwDJiNMOviDcVrDvxNczyH uWqonziRt/EN/D5ltZyetNvPmi+LPOiFRbGEPWZRhhkVHOVmjRzgIPBZpe4SIKtNb6bLQlhPjDLa 1AjmxdTNqb3W7sG1YphWAzdtpMhJKGBJErtA8WZJJLLiU1BISFtu0755FGs2Uk2TOfktxqJ0oLTc 1wSQkgBxvR2IJ2e0KGnZYD8gHl7G/YrTG232GQrI35Dw6LQ9c15NHsNMmT2Q4ZmZAPECzWyfXfps VgI4lxvFT57Z6xyeluYNpLTLcgo1Ni6ug2xJIzMEgN88OQrzpSi1Nb1MRrvB/gHgnRz5PFppvXZY ryzSFQzCRK5rQHwpLd0CJvOMuWXyEpn17LxbuZBAAXCBkkMAdkVEyTJB8NPafig6JdZa0B3RUc7o 6HTrlTOa5+I1oUwxCFjrd8ZZkkZ5Tg/rbsRWsCtL2pZ5RiVCdl9YZP7xmR+VJKPEF7me7+c9+6bv orrjpf3Ua7wG+C/HYlr65qhTfPKd+dxud+9pqfemvIoSrzPUmlvnvXazzfBSU4Pw4fPJUUSqzNbV 3lLEysrb3IkJNAzne1obQ3IUDk6JoflFvPblr3V2nWKeZ4vsEHv3vo/FW964X6tdllc6T8dt9GZn T+bxnJbPN7huDUIcXxSp5rytJrsDkrlu2PGbnLsrtt8V3Z2Mfim8F47Yf31Xzi185FrMTptpHR6Z 3UvJfNxLLrSbOxBL83ZrrNe66/qHI60vSnG098VJys4DqsSujY38maWSPpH+T8I6rp05y/OdfUZI yGK7yi6DWWIXUfYg59y8jgOqZHT8D4DhFfyxQe0oY+oDmlthHelhYPvWqkqYKnuRgOp3mgpCheJ9 YYCp7UcITIXJL8jGSMjMyA8VUQL6kCwbblUdO/x/Jw/1dkcZt7BqEAhWUYEfRUjMc59Sh/OMPxIY xPoeuWw66XTzWYeRRpZ+8c1I8miJKg6oPoZOZbOuCrfiV4wyaY08Pj7WFptrNxtnF23p5B2duswp Mao+0I4W1qlnLVYVhGMZlInI1N0JkIcb0t8m1N64JmSNMt5oLGVo5JxTe9Er2Wb1o/b/gtz9bHKI zAzfyQhDjc9nbtnXRMdl0xJHYperKzReBV6VbtmLYYgZ43OxsqxdvoYu8emEfDOnqjOVl1kxnPTY +sM5Nlb3kIMaNPkRBvJ3MrBixck5pY3VtBRuaqSTJNrdzO0R5VRdQRWUsDLSGhW1pxlmcceBdtZQ zTpcNk7aChMl2mFaR3p7kvaIe/VH+YOo29wTW0JKnjseV8s4MNrubFyx0ROSGUQCH+sWSdBs0QKM JpIBWIGhGFyA1rHcjcNswjZUqfaN7GqLu6tFQxA1NBBEgJpQcooekPSgk8iSEkad3h4+4eE/bd85 knwYjZL7UCEJZA4Yicz9g5QNOB4aOKw4IvN+7CWNgtWDycKhNQIfHkEUIJkRcDC3UKRVaAqH+c/v 4kErg4+uiv/4uJgdstoMfiMxraJsC7Uvl90wb3jvxLAOUiezpH5JkBVoCoAyCjEo1jvEQ5Wlt87w iqld7wSACcbdYOPPYfq1Exvu4AQguWEPWm5tCkdymH6ReGs440sz9NYhHOLGPBRlvsK7Ik03loJ1 1tIJrI6s+GgKRQm1ERoH6r7ooVOOkxA9VAgWIY5D0QQBxjIM3OB1TfWg9/HKMDOJI0Iax6mzZy7i jc1xy1KnxLBOCRc4DhC02lDEGclAjhs6JDkA28jEADjgcLVhKl3BUq5CQ5Wc/MvvptpGoXUaxpVj cvratBtt8ZxyWd55vpFJ+N7Yo52oVpjhSBewVVRGFlTf2oFN9l8gpfzdtDIlH0m9wWAyLq0g9ozy TxKkNAOVyEx6iW1yJXclwxbeSrRgLAYUwIGg0zaAxP2YHTQtDpfIvTM1Ai8teNnTpxN0lc40zvTE IGGKK8WrnZ+mkuDPUezBrveBAaKBwLhiKCZE9hvQ2rnua8qzxyjHfWKRBgopLZDojF4XEmpAdB1Q S7QLz7/FM+q/GUCLu/q8kSAuGKUMugcwhzvtc1YAVONtDlqAn3ugVZ51vstVsUrPF5y3xW2M8zPO sHtAmcnigMmyinqqeiEZGWRlRvydyEChk64YfPp9bnrR9HEkwM9S9ecd2xtcmsnEQKSorrBaE0pa a8WkVnQcIUg70U0EAfILs8Pee4VuRTpupbVk8a6PVkfPY/XD3B6etGDYL2faxl9CrZmVKMwc4uzQ 5sghIW+oPCADY4Ndj9KxlM4YCWM31y3qVXFqOjWUtly4g08Ar4QV3qsk6dtnhLR1TN66Oih1rmaM +H1XvPe4WvnGC15D7KK82LxfgmCjc3EeDVUyqL4qELH5dAeAGUIWiasxO+aZhynn6sje+Sj3nY7A OkaFu1uuTiJjzPzHpd9dbxWCEr1ipg0rz02bhCSAMrk7ytCOhxM915j/Rzx9MuV/yUTmfSs+eqcq F/GYthWFGsUiO0ek2Y5lQHF0i2WvIdXLPXS+9JT5U5Nec+RDPexqDI9EtdWbGvcHIHTL6bdclkQj NXKO3NFw+CJL2HOvW5fFsRMzBmb2e0JydpCJghczPyHVKGwXdNU9QQlyscPBKOHqcZdS6mDyB3PL REBES7MghpG/162O5gIPiStgDYi8kp0kGmHScTKl7t0jvaDjPXFn6+eExPlPW1CU8BRvhnKq+Ce2 nItPF9YcpP7bWH0iZbSq2rZ76D5bEWWGBzEWIu3HDyDEt5SAlsDFyiVnhuy1unYLJCdplpOWZtsN mWkoUSfQouxgyV8rMQEyzcnZb6xiWkBuwKg4/Ksm4AN9zf70mlbXZ9BrOhCC24J8nO8fIMAkCmAI Qcg44YZpmzkaFoizRw0cRk0TCeh4pqT7n6SH/Q5SQ9HTlew544nk2lTlzJx6rVzTtxOMZ9ieZpeE x2VFKZpRNexChCt3YVsPwNIxd2HowaCFV0JGj2rpUqq5LI/t2nho5Tzn1iUnZ6R56kz0QsvHe9pz 3iTZvx3reBikjKTSzGhWcpJdO9CSAN9q1M1lo/KUtR2UJbeZ2nisGfCP2wNQfSIL3uDUwcNBsnSm u+IyKmkyzo30Hjn5+4/Ogeky2s22kX3utrGo80lNsycR6ucqSrst97ycxmNuZaWmYaazpfKdX11V MyepnTLEJjXzi6uUPI5KfCTZyypRaEWNt9YKUzJLekbjjiyhYZXGf4O8/Y7s3K0sQ3113eQOxzn1 zyd7jvku7wdJqufOTWa+9keCxzSOnpzEdnnMJ1o5tYrGYWNNTWV8Um6jTdgdc1rA0vdv6sYMKrsy FX64k2Lmjs5kZWzIS/Ef8T84g/bmlqfoEGXuRoHeHV6R+YePgfYnne4dH3pO4xPGb+xGyCuA9ZKr z0eeHmsyCNh6/J7z9GDBU/V1QUDqTsBIOoPPmgn18+wS526xiMd7RIPZTlR46cQU0zyM3ht7N/Lu GMTZWLTj3SFYd1dk12ymIR4sh51xatFSZtbfMjMd1eN0oK8teyc59CidLIRBQ0EEQypSCSrXZa6b YZZBgcSHLajvXIa5YZlpELjicYYN5CkjmuMWacknHY51mhmMZqY85ZJhKmDf+IwRP8AkkKKvlUnX CSLXCxymOlmEDuTxlGE0mmhZpazSjJNkFqsu9Pd4pCj1iTiwNpmctog0TrGmHXU0XaiQPOQkq86t IhVWLtdw8AwzI0krDu8Ljq+EsjbablnjTvsnamNBE3QoyClrscnBq2alKlYUNax8coOBRRYA/vDH E2Lim10owqbZhaztNXNVi4Q0B21rv4LoGNbEzppAaFU1ChA0GltIq0uzjPDMB3juwhRnOnrm5mho mQNO+sjqq2nK54GFXOFx5ySA2EBz8OjSVQojBWCXZECiVSIHKARpc6TbGdpI40x8GtgTuYaSFwfc 2NRHHf9Pft0RnYQkJtMa5fFhlpXMj8oKAghCJ9zDPQtwjAgz2FoEnSFwfxILzjFg0CC7yAOug4b4 uc5PQKZ3G/Lnz51E1gt9SgbiyyFWkTTL3wWRiOJQzIpD2BP2qtlLUg46sGgZ60NtjeI6fzxQ0ztb BpKQ5b2zM2FWL35RipvNJleMbFjlduJm/bywxnlz269e+uH7qA9CuCN3Q2bLBXE1Qfo+9yUJusUw E5KmJgW5h1BiVCklfMreRkLVhZjZbPHa7YiiwJOGSaThA92IbkEqpSnmmwPQOjKUMi0JXVx49r8W OMm2yhVNpd0WftrytuPVkwMzNmxWBQeZsDSa2aGA+g+R5OFAFljGUec2h1yjZoClRIVKkLqQ6O2Z UzqCMKeQr61UlVpI2mp4tmRcVtGwlQhOwKNiIPgxus7NwJU4IZsaGLFdss9jyPITyI6T7hagrxXV k+8aFZW9FU4UdVQhU43lkWBbsiEAHN1nfjanu/pT767PTpE0h5KZOappLZXvGwgru2B+lxh1764p 8KVkitALayNIY39vqvWX6+R1o+6l6I7nL6z+8C8JTKZlXSP+Nt+5Bdteu/K+QO2NUnTgqoMjgx2C di7ehHsMFyqwJIgT0japAohEzOZPkVJW5ySwQAygYgjBPm1q7XTlbN0Y24mF9FeW0SYh8jWmUjaF MlroxCpc1QG11FRjCMzA7DIwCryYpmtddJ/kks+JZlit5Z6RjqcavZTM0FshlsFnueJNW4mQrUNx OGI9WAIO6FtfEWvh6ZtXpZPRnsBY4dUt1DtZigBAChjMgG2tJtt0ioeG9WlydloBxUIKFGQJAGfl PAkIRpGggCfLaA693PWFOdmEKW8HpCirleeZd4D6RdUNo595nknO27vNj3RRNBIB27atGWS4yyZY pOZSnM27urknEa208ETSL4nHsMX6WYchxsvmDQRpuKlM9DnE+HHpx7o6zxrD1BcaAbsqR0tArfVs NDhyArHeHGA1OLyNqjjPh9LxtXhBoocwC6nWCNis23RuyLOfvBzkVx5VBeVAkRHbwKojfdclYc6L T/KImgd0a7FAMcSIK94p+irqWvPiWz4XpYDXPE91mGin55pVeDYOdkUboytU3TDNCpyrK8Lyo9Kl MKRd0YiUk4eeRFYeZy42doszTehNRyfK+6z3ec9+BxdYJoHDateSlTYzbN1dQ4sBlXn1ZMn7clqT 3scsQnyzITkb7UHw0yctEGaDlPY35PBgYXPWPnUOdqR9Q4MpKQDBIHfwPXT6Mte9JEhldbwzZIdp yNi9mnq1AziqLBVPmcXM3OtaLnZuAxpDXCZb7570g4spUTW0Hsm+CRIuwgyYUUKA1wn36d5T153U 3aRP13ik/I+8+QczbROm+bOd1P1HCX5V8Z174UqpZieCfgYDuPdL5uITCOBslvFM13HTah6/ib2c Q/a6XrHOvO6n1fle79OyoXo33DFR0b7hRBP5fu8R1U54D33xoNX73oqCjuTZWhmnFFjYqSpDEq2h I24yfKSqXnyQs8Y4dlcifm9C/A+k+tz7KVGIQmvWAlYb5zt8vnqDlbfOeM76+vgcpFruuIQ6yHy2 MJ6PpIfZv3k6uzvoXvEU8S430mNxfRpsBzzv3vOfOfVNavvcL/WfMQREAOST556z9w6N0rdOZ7fX rcbUQRRu9JnDfz+jm1w4johJJ+eaiu9LiwldVKb775vwzSa5aP4muvkVCmQHw6uPMvo73yeC7Jcz RrFTe2Pf1+p+FXLRObGcLyZ+kovbFSEaYhu+4j4CR6iVQ9gvaC7ApfckOXivfuJcuSBLY6Z1mHkj mkeCHCX60EE9fWgT0XXwynf6LM9AO/IIevpRfYLJYDw+aNCjjQO89A9+kPgez3tz9aSIciAN7Ss4 znGE3j5x0Oec97hCdrofbDtncKw5aR3dd2W7kvZWD49vqIJucxb1GQPVKrZDK1Crj1qXkrhGhXVD VI9lvVCOoyiiirTs6bUe6yLTMFJBtUzqbq3Rdowou9sOtUO7Aub0sFCyuh507vQTIcdoUwQMGxNN CH1OjtzOur1raYrw7OKzMRvTPLPlsz7bYTuykUuIKLqmhpHSM21Kj5eNRePWWPeVMIaqgClFIxnE 02rSZa7irUuIhLMjV47lSKqYzvdWSNqydLCSLjaS5YpRXDbpCCjyo93sfZtaoPHI9wJwTrjrk0c9 oDrOEtQP0CSP0mIEFSDoaS47OLhRRsIDDp9rxOzyqaNJSNgRmRu7HBERsU8BsHI4IohFLGF4kLw5 GYWlKxwRNM7g4WGpFU435nQbyhpkvSa0mMR0RxJzOIxGAQvCNhdJY0zREKCq2kIZ7/k/xMI5BjXz KNukVGxMo20X6cpXsRxwmRECH2HQl6/nPbUL5enVHYq16PsQnDnXF2xMMp1h9TBuMDAyPow4mTPn cywbfE+k7RM9XVBAfz+Px284PP7l0cyP+l81QR0RJuggDpoJ5uSCGUtFhwYeqq05q5rcto5Zjn1D bF4z6JJB9BpFJpSVWtTWTaQVGBgGQmYBm9ZOlbZOvZbEJP2KdhpEdjI1dDwNhkCcxnHsOmBplZoX yZmvx/FfDuZA60La9tBctHvaML13nM/H/Dm6k+XP5ZH3XMcLSpyLnQsc6neyX1vzr37TpBpuuRUI QGR8hDzrj0vOFAiNpo43xelEbMz3jdvRuj3gqIfg23Vb49LTn0+T3yVnyDz0Y5/Zn3hX0dF/cKjO 0EMQiw7p5uwQH53DLjOIFNBxUsr577HGU4p+jy4GdkXAOFIm8yfn9qT5jbm+2VQMJmHHmHQJwybp 8PP1HVt0+HpEDxmilCgaIgCohEtqWsrMpkWTWozVtgZkhmQDMIXPTA5tx+2T4BeL6XToQfx0S1Qv X29Q3xGxn8pza002MyE91tZj93HWjYxK7fc2HmcqCb9VGPfbyGtkDj52dWBsKALZoOEGBicekIlQ NsZPVxt6XAqwYYDq+RnuJENwqXYH0gF+6XERCCI9Vwn8WVRWn+Tob2qnZSbR2xXcGAxnuahN+H5D 3GdSDcbpw8Dwh6T/elNI+0cOVElP9wMGnFDXPqRKZgQCHI194VKWoWXTuhSU0lyk7uHOQ6uKbR0K TIE8DqQbpE7imt7rOxnctnfbI0sZMRinZVxLxzR9iSDa+zW2L4HYIZDml310T8LZgYYLKNmc88Hc b75sMyNTVjx1qD9PkgoRatCFBo7Hf25z47PPi8sQHauzhGuZcsi0jZbX4MVVkBV/oBbghR6zWdcJ KZrphcrQGdlBt5veRwE5u22WemWFvY+AbZndvnz1alhVRGDTDL00n4SCmbrqCmRgUFKAtHdeJ6qe ZY3nLOdm0dmQkGeCukuvkyZVMZRlzy2iuAGDdc7ctZhICWmroobh795vy4fA1zJRzDvJ22/Xqo8L 17D58wdN0vnMhtywhHIPVR7BUHYGhZSOz2evxu8G+qKRQ16j0JxtFZPRvfiVqdp1mzheW+R9Ad9a XjUh5uJfWdV9Z42X9fN7FqeTzjztVVNsRUPJ0w9MVMM7CKpiCHtlF91njFAnlA2fqZwChmm1020U Bn4We2A022drrOL2sDI6ubT2W1VEh3ffEeYix/j80fXYIyp9MmQXhh5PDwHwYQJT277GTRh7/Js9 t+Fano5+s6ek7JSe6tt1X3ZF9L+ODvljmg40c9h3qfxDm9fgPNnOc0V1JyFT52c+dL6e+wNgu/jK m148E2u70uPTPNtBEO2JIHU5pVWm2IcaLVTAzg9iCCIhDJCQp1hnzM9CFqSJpMt5o+R9X972Rncm uOW4O+Lk85Gi4OxvtG134hvS9x9eNfRWjnRF+ts6duTzxS7rwLtaUPPLpMOXCBHEEim5820550HA 6cdcpyPfu/dqpyb1rD+8O9XOc66POQ86fQ8ceQcOr0xqKHOT4yR61aula7obFsZUn2CRlAaN9Z6a FBprWjs2z8/tXI1ON76aFbX2c521G2Npapys6OecHs62KF8Z4tFsJ9scQdbnu51unZjcqeHcizJu f2oB+h+5OjPNnpDfUq7DT9YRrTIwccfnkl+J5e7SnPWt5e6163H0ldTBkyrO1dSj8t4qNrWqtxtA +oIK9GlLlbLI7AP7kpUjpw6RpSI9OE4nVwW18TPHnXvz+0jzWPHVc18ZWc2nXNOLTEkdwDLSqJHA +9CFpvf3nsj7YdsxDnH3LBH3z7kJ8XtD4+4dOjmpEA+5BBeCUSwP5pjZJyL+K7y4ZnefXU+AgoL7 kCxQFugXuXv7NzzyHbN4jJ3gNDrnGr2cPjN3LrNRbQiQqqKq+jfwgsYs1McMKuCwrD1Syu44kZam I0zRKTWq1ZRxG32r6otljDUaVt0WKik1e9yhV04jqiLOxyY281u6C7GHFgcskWVZYnT07Clj0atp oJgsdoGqZFjVlZaIjg4RTs27VYjdaulUzQzvuBdjmzJIq0NUazaVc7YizCaHx1BZapUeaW1Z2rdB OjNXG5JHihng3Eiw763YDLbw6sUzk3VyWwPkYl1o1Emh0m1HV7p3fDWRVPCXCUtRqWoHaXdRZgcv E0aIVQelmS1iHeJ1gqX/cHCCbOFwNVJeKUqWDo4OhwyYGBAFseLRfxQDC6FSoSQBYow4nZsZCbjD 6Kqz4mYbw4nVy7vrnb3d965iYzkgTog+HChw16Ors2tB+eBA9G9u4fOjNpcyuQckfF7vXGqjN0QM D8KhUihIEODWNyNkbcqJCKMgZKFvkpjgOJXo5Q3lYdaViWQxCqaZUdD4QoSkIWbArMe3UhetyWGt wReZxm35hoJVB239Gr6PoWsnrnwDO5HVXUk6ThzxHHqJZG2HFd7GvG/HE9mZxB2syVi5vWPGfHFd LZZaylpCkCuIDAvew8yZyUbuRs7WRnsto4cM7QgRBDjob5HoiYd+/K8DZE0rpOGOd8ncvc7HHSr6 6+J12fcfxHxPV3TnkPVkg2eztSsK3wa1P1GQnnkm00fD4zk+44GlRDuzqn9AqNBWmCcIJ1+9JARi p4GFFD0kZclDhrFYWgj9yY9IKklqI0Eqya4lBD5WvwMn4kAK709krKQkA4AtK2RnaoOzhm2ZVHvS F0532q1oGfHPQ8vjxpZ4gl6p+UXsiMGO07FMbwO6dwnGfK94INLRx9HvfXfHT8MWLHlF+9793vYn RbRDo2JM+QlHuO8GLxiIk1016e7TcFrZ2pnFYN2Nr4yjxgz0ynQMX4rLgY0zgxNPWL9B0Vn3PGWu WYdb4uTYzGS5jUuMk4ep4/aL4OxLXIisYCcnII9yBczPY0i8fw7mByq92UL5AVHygr7hocWvOeIh muc8sGcIaPHUTWjmllaqcbz59gfrA0eJ4tr6or89OqpCR8ZUqeyIUGoDvjF7CYAG2G43dc4qP61M k+0cjjeeOm1CVYv56LvGqCMq0AynjZRpTomRpFwcuFSBCRVTzXEjO+tHs0LyyUN2RlUpIhN+8ql4 6rOasUpjLLyoZbz29zGk/ScxbswhIwY9jqPcGDDYGvA20ImtXvWc9HrlTouU9NC1IIHmn7RjjlnE fu7lxk+gI0ffmvvUgM+Q5qhN/KbGK6ZKg62exg5Q4NjPTZmWBmOQ2NEleHbv6xero9Ie557dPX29 N1ZPilO281nKXCa17tItKEChSb+zuOVuhgHSYZRoeDrdFG16RVwUGX7dnnHLAchBEQAkviCA7ZYF /FnYAqoL5HXGdROk33x0c+qeHfldUrrPWkoTxtaEcQzvnPWdZg4flzltebHy+8AyVtTVXw3A2koN vtlyN2c0Wm+I9RU9HvarHMrSAMnOByefMF0zNNeIZxzOWw4DeUyWfSw+W5tChSmvGXSkY6OKaYfD Vxaz7QHq8Fkca8pOjlvK+0gBCDYUxfMK2Zpjty2b9HYu/baWpOvpmToocn2WTUc2yiOJJ0TOjV4O Hpn6asYl5An4Mr0MyiqSzpHcqR+c+VG15uD6tNislXKeh7S6VIo70da+a1Ns56bN+b1nN9nnHniU f1p6c2Sp755PkbKB0buhjnOd9cwMlI5ruKg5pEXINkdb1vWctGijgtlOfnGEDJ0ijGFJ8cknZxMw y88dLz2zGkdn1843P9qAITOC769tyJzmdncbuGF1Kx5WYPbEu3XO+LwXir/0ob3g4477W/V6Prr6 T1RvRsFsh4FiO2M2SVe9dYRd76/lM/kH19r8+uF9wjn53TqxTdekeyHQetdtWMF6RVOXvs+s3Gux ksKDayGNQ2y0bFrYguQ+u2B01Ua01C91IzMDyO+We5E5nqB9F8V3I5LMpkoL2HidxQPehhFRL619 A7/am5+fhmFB5VHmH1kPXwDICBkIKn2HHU75nVLQDwCZ9aotAPd7EhAe/2NRvWHaEYQPOJH3Eva4 iabFBp0GPaazUsPxoVBIFvBgdIZoCN3TzfDOYzYwQtY2K7RcOsEvS2Y8mtF3OaaIiCoZZHzRGXmg QRNZF3GUNEkEwkLwKNEhq3B5HWHQziQKmzg7diXDOKEptambZIhJQQRLEQFLjVKTEb05hscYW7Go uMp7V1Whl3uWiFrJgjbZmmMncanTkGhXR0Wyrd4eoXWLSkrCjPYM5hl25hS3OG8Jnem2Mphj6eEU tyEy5XcyXtQxSyqaCJIXHFenKjFUcV2JZ2ilcV2Gm7iqup3WZmnrb6yd5XLH5c7W6vyz6odNZC92 t8k/EhsnQbLST6YxGS36s46j5zSn4wgeT21V3Z0BsDMIvUaoVHYEYoHu7wDjY4aXu1LH0LibItTA iEkAPS2JQNmzDppcAtrVEN8DaTzX2WMq1S/N6taSpVzWmr1BJTGAGQD1vdDs8GN7WaUJ2ZJzEScH lk9y2FwQ+lCI8RQ/ZQ+6QRkPHIqMEwixA0Lh6L9Mk9BnD5PDU53llhCdKoT4X25BuE18rmPHCOc8 Pc5szudvEJJHiiVJaJB07juPD8Gj+L2CACR4wIecdUT4d4+VB8Rb4IHbGFn2v26PsDhalkKweVCE VYOJHQWgJQhAEd3GmtsvFLZZZoLJKWud4PYS5QM53m0SnON6G+HxiUNsUauL8QWKRDixVKSQTiOK MAOKuEDKCrQIJRQDITbZvIZGsJ75ATP4Ci8wQSSfnob62RDaMNrVqpZXnviG2jGe9jKfxD7F2Pt7 T0c4t1XPEhnj2bUe8czeIod7HNDacg6F7ccPJmCScVEc3Q0UESgK9DqE6xSoYvYlFKNDVNbFrNpr gqCkpHJCX3Vadzr20N65f8+/OYvFUZPFTHUFppPGsbruwpa8tpamW7DDZu0ppGBQclBh8RzlRydF AtKZlCs5zEkirIEnhncAjmZXnjBrPRXM5oBDgDJVCITsYFXG8jfKOBAj8oJ76aPHT4dpzykzT9Gn rax4Srnvmu7s9rs9THU4zznekC13hmj4DNjKQF7Dnc9DDijtZUAnwugcw33s06ILsVhss4GeWUNY qhVhi/MaHDk95mWdkOhV4kZ7ijZ8SunPJVnKbuWkK8hpGXOWDDoQ4tGS+wB+ZwWdwXgkgCLuJJzj QbUQqPI9uYH7lD85I/B9Gtfg/FtYN08wYWIkPHarOkh2c3qz9g5HGQZ4ogvknSln0L86GhRK9F09 KmoJltcNRn0fHX5hwL5kJzhv43X4TxKVeXrI9wnmcQ9oQXr8tNPTQIOehsGmNc0SFPJ1Fxu55ntP J46zlmuHWfeWZkqZOSNld+j9FTNVz4I1TZap056GT2pmtkFEhITqnF9Nd0RumSK/JffkRwfYq21/ NKHqjKdijrSifjlvwQZ31XL7rb9lHR9nLX8jpfY0LG4+XX6g+Bub+cp7zyJtB2UORlnywpvZw2hl cyY1UYMh8dibJCAxIsGcBIGCsCChFRgzRKkUknnJuTjmOtmomGT9HqF4mN+axLWippTmOf71eSbP a+XPBpnFIQG4odX3KvHT/QfOREREFEEBDDFr1jOE1s3Nw/ofIk1pJJMMwww2dDn01wCRmugPzzi7 jtDaBvVQkipLsIHtflk62x11VGozruWo0YxZPGBtNRxOIPckJ5Pvhqc74TzwBS+u25cH2lk3tF2b kcDxrHuPd95sI+UKX7+lSMkGcr/kQBDb51Xz+ZBpEHvEOuO7bwnQxKnmJ9lGzH9yd58Scu7sOaKg g9iSEjqtvJCSAGW9Kddaruk5Gae9ocPvmdTHIZYr2hbFMMorrdXz7pvyNK5Tdraq0YpYdauVF2Sn SuwawNPsQF4aO00W99AwXQkgDPWDqc+0Qz56dPccncPp9XwdQmR6bPJ0vFv9zxhPPHjOQc331FPq nJjX2lNhwd88Lr5icdqlKxobbZ31zFca8rqsbzBjWcla50rwV+xEjOeeH4N9c9KnNHu4Zd42pTNd eTxBO/m+W37eY3ypy/SRufSuDzfl7rtOuX6nfpJYyAe+BvXOxePU9I1xmu/Jlap34x/Oq9c8O791 QaVxdqjCysM2palQ/zHPXPerFJZFX53WryUzIvRyLqXAgWp9C+bV3jpw7UgPnwbG4SUHRNfw4eZa vrjfIkTKkB0+AqxoOtqtVVnQ4u6+T6aVrktVP7kfgiK/AdyEPPqj87yXYX1eaPwqegVFk/se4Q4R 2FBZ74DIGql0DfhA4wT4vfNobSMPA8yPSm0+8qd8H6Z0TbmP0AXie/t4y8tJ4k+UXjnN18XxGnMd B9Dymwzcx0ZlMqYc4IVBZZCN62r3XG11ljNVxpqcWjT4233g1w0WkO6qVoazLWLNvKipmAqaclsT bTtqWZcHpgYyXXTKsG1xk1ELNDKEVMJBmkSd1aiitkbaWTNk5Op3DaGwYZ10VslWicqXyYjdFarL 0mtNpqneRj6SrVWTcLA7UWw2tKqRpSap1pXxYKhHZoR3u5s1StVypRgLOqqy2Vkcedw9zTrppe5c 2Rq9ur3qtKlqPetWjXCjNK6KyW2xGaZTc/64psgUsnRNDxdBA2DVFGarJgUMBphy+uXvdhnDNnxu xqdIciwxJjtYhNDY1LQiT3Tj7X9bb8e9tYZjbqwkwawGWOImzkDsg6/PPSsbPDRqjG5VPSt0X6mc fP2NVeFRwebJJZNdhB7WAGYS9KQzgIQ4khvvfVF8Vfkna/1eHJYBXwGESeYHsD0rwEnK+KUmsWMc aiFpS163eRy0hqFqvhnsOxkSHEUdFp5K+9KjpWR46tLusRBYEBH6g+5U3733MCHrnUOIrM43cIWR vPjlF6dPbTeOja3HJ7iV56ZY5NkylIsRxIsruT45r5AEOdp6lECMMkJtCp1aFkR2aLO92tbBtYZ0 6xJxtE2IioCWxtG6gRBtbfso6117k/aTFZ5te5XUW5HKNuCFRcEmTnDiO0NZOjyd7RDJ1lwTgILc 4aGmX4nLPSJd90BUOMW1XXlpqUM81HCqlrksJxo/MiYeuTzpPZ9irzSeWiRBPNB5d+UOmpXWQ9Vw uNbQxVPw493r2FAac+hdjiUHD1yYhwBTbnvdcbZY53exMmASJTYeQkT2nJRVd5c7pTZ5mWsllaqy xE5kgUgrkOUVk7eDZ6FiJnJPHXVZYzePDzSd6Sv2EFV8njIPqLHe2Y8qHim2By8a+bTy4QZ3G6mj DnJqVzc7KPXsyZT3JR5c9jno/TkcRor2vPWyRxupy27Bq6xPHFiBGGrrus/knaVIm0s6dhGpLpU/ Ng1Y+6bp5dR7GYD/JyUHoi9nvp2mc88otY50dzpotna6SWLuyIyQrEzi8IPEKOpF60lpK63nDXPT atzV2dry11zciLoKFre8N5dGsMaoZkvJk5Y4bWFKHgya+cCCG/Hdex3vn5nw4alLGJIVsg4nSzSz ujdMKh7Daa1xlxS3NaaRy1qxRD93P1y2liOUMtLRQ5ZWytF3yEkV3lXvA8g156u8YugsiiDRnWeJ 1b7eU7+RMwT0a2Ox3vGe3Iea8VvOPIvLXTKbjNSJ5zbPSzNluHQOcuMmAzIcZ7QMuOLKewpmm1KR OMQzmWVzeF6NSjgbJ0dH7sOIop4OrnEN3dlcsZlp9gB7evseXK+HHcDOeKAn6m5vnJgrOs3xA01/ IqczStS+zoVyhQWDHK1iXQvHO/Dsbb1wUcP3IkNbECBkFTyOgLjX3v78f7cUUhexYRXRVgV0Glv1 UdjjZVXGHvFDTTN3MFfpW3goVgOOFygNQUCJMm0p2/5awxljXHRn9bFL8cq8nhrQylSyyHTfyv8E fUZo5DAGx3j2OCzUzxTnxy5T3m57qV5TnycIVpS0cS4MHBAiruVScOVizsrz0MCqTmrxdMlcdi05 pVEnprKltag5VlPCeetdxAQ0beJ666pMgO57Ve+PR0Ysxq80iZTWkp5XhmsXuGjh/yX1iNdjDUwn v2Zb3z4031GiOjD59bOfl740/cTl8GV110b+ErPPT6O14jrhGP3J/RO0qdnzXK+V5XuC7HbLjQ3v CiwYeZLVs+BK7+Rad9TNh86rIjPG30JnGRWtlho5vCOL5a+zenVUMdqf4Ld787nrkvDzgSpD3yO8 r+4OsiEvbihHPSg4zHbYVLly2xCT9uDYpkgEbZYJbq8YlJ4NY5k3j7Wv+gttkYzZzbGH3znpiMhL V8HZy2VbLDPhQplPalDDZXzYtK0MJGgr+xfQQfWFEGyb6CwjMoJVQHpA+oFofZoUQd3qeuR3D1qj SJ0LGNjg6rpgPnYQfX7Ci6PPePPqkkI+ugg9V4o5+3MKCXjX+s/+X73Q/ocHJzhm/8v93xPRuX/r +by/rj/kPgPVf3sduD2nyDgwUJnuGF+C9DzL/k2DDN7XfkZSa3uX2sOTDPxfPEfaeYw7mmnvHazx 4qjIq8GHWhRQ5qiiHwWqyQww+IyKnQtEecgzejySRNLjfm/dyd02zWyEOCI9PtIL+kkDZtMO/uwv EegVmA+jJFlRyMhqh1BxBXGNS4OYcTmJ6ZcmC65wSiTQ5xEFrAMDz+f/y4/fIXoxzeGRB83y/Ue6 drdHxyIfJCPzJCjVqFYpiRlNqGltiy1rWRWtNYY+3Nh+BiNpRhF9Hb787OzYH0p3Fwi+Mqh1CCp+ dfcSE0hJr7YIh+gIhrYIhtBEO/RITeJIHhOq693/pt/gu9fnXF4pz9HDNQgORPVwE2p6vkViLdzo Rcjs3z76vMo4tn0+i9OCtD9P9npeBjW2fUe39irP9P57GUjGQPQ5TeZDESUWf8fgOnoOHMIqydl8 Wq1oi4a5Z34ycZES1HDdB0mSla48cw3tHGRuWJ5knAcDE7HaChIf+7KfvJLqs1Qei0uC5AwO5UTL UjBuPCw+wwwwbgzdHBEZ6bUcOsaHDy9yz1iiUTDaO2xqvj25cmyMWQ4YwnxqRzWfsURBjgX7D/Qa nIUl0JFzQzF1ko3/HrQ7H/p+aYT3Wwv2lwr7z4hyD4hvoK5hMPGDdvQefkHnh4A5TYDzUU5WEwH5 jvNvYvX0kLvGMmmfuEwu7f2leKsfQv6/nyOTf6HR0N6+E6LrauC29VzavSyhAdM1H8xuvuLOeaOO TBTGo0tcO97cm2gOd4OHplZarbe0V6SXzfSvi8zYgBRyIp8G2IIDcGFNVHI3G4eWeFugONZuvKb3 9+Ud5c9IUNGDnLUcl5aPA46rHNTaduQ1kwdbPbpi2RweUQHoIM4ZQMx2NVIezKDCkMfI8TIgLnOT V8NDEY6s6ncO1/J5vo0mJ4aot43aS67T52JEh7KYTlFQdVvCXfCA3ebRnHIZOG5OUyKcfpUnTZcw ZHKGxnpOiojXmvS1+62j/B4NgsPs6Nai2Nmn7m3ZGvH8lPL85lA+X64dT7eF+PR+lH7oyCXkrm+e WewWbm+7JjJlWZKxrTLPB/e4QNvCiVsFZGGCQyimGUHO4uc4LdpMerB7mXdPyHp7HgwuO/ce6Ow8 P0ntxeAvcMI1UxyNHawhxqeZIT3cX0GY9M+1rciFl+29Z7qjrifNh27771aNxkPIDloM4byd3MWg YYvChlMithl+9gsz8ODIYC1Mvf1dE5RyqzoCNGVWR3MF2cxF7ktXjiLBxTgeas8oODXSo9LkMg72 XmMK7H9aZHWEZ18p9I15mTyD1j9YeVIhmRsWx/j95A3+qGjuRfUe+G8tDGD4B+GitP7diFBHNy8/ ymNN3Nu5z3XVqlLbeaxX0+vbx2IjRIRpHzhQwhEIYxY17sIR/h+a9jwWPkZzLrIeSCJORU8TYsWM hkSHJOJw9p25mpmTLG4I+z55B8yTiz3eRB2jJJzAhrjhMVP0vQxt5MYp53nc9vOqq3K3Vs0p2t9C kCgp+0YYMFEssgogc/YYcFHJvp0bZ+D/UPymcL5FdjkGPUuRfqsSkFcUIHTuonfPa+c435OGsWPg 0YeFdyzfY2HLbuqeOjdJT4BOTN04LA7QXot4Z5kDTE2MYxREREkE8GZ8dhDuHeaeu22iLgYV9DTb bdnrZHAsjZgxtYpE2YNi39NPZmhh3DkO1TNESxNcbGVXmfKnIbHA4sEBTEyMhkPFqPFcgLYVPm9R GRrxbnStfS+J6HcxW8jupMsqukiybNK687kSyZBUeeZrA4TAdCd3lBhxJyRJkJjTJ66G8XHDl8OX l8OQ9ZSdb6a7o7fqV6DI6UJ5jQ2cLMZmThmYirhuDySPVwdw2Cqes5mzz6TKBfiGEKJs8cA9UB4e WD7JLdDZUIFefm84VCDxTHJxMygft01J3bnWzXBiHtYxioiqSVj6e3ZxK8DuYJ+xX/op3K4V6VDv dHwxqRPY8sHcK+R8zsdjseThydrDsWR0V8SmlPF3NnztNNoC5jAaECFy0QcZkTxJF1JQGFzJjpDi RUBUMhzn38mjhOEPIVVTBcjAwf5CDiai95ZvuGAeXL5qJEe1F5liJUxXJo4yerR7/StGdDgeYoaO uFVsZ02ankDabG0fA0GYygTjakPrOQ+NzQkkHGZUgH5T3lTUeJ4mGPcYLSYkcw/dsx6HSEyYNoO+ OqdqnJlb2lMyRmfxHj5Kbo/PKLoJXYHPaqd3QdLPxDmLYS5DhyknDu30PdT8GseB6E9Wlp0TsTDH ca6wWhzHQCgePmbRUlGUKRCzHoQTkvzCaTH1IZ4vMTxZEBm8g6BYPMHA4DM5BMnjq3BDbSHBzKTz qnpfaySmmI2fUwd7Tk7HlNxssiq5NncrSVjZ6fofbq3y6vLdz5Dg6HJpye5t2S6qfSox73rMew2T qr62Mhm44MjQ7zI5B4wIEBx3g4ePNKiPcejgWebm7p8NtvhUOKdivg0xN1kafBiehXu9dx3qOyax t7sEddMO9fr7pH5DRPgWH0nCsQ3UGlashzPFkmK9y4PA9g8S0b3IGUz053URxBWuw6XCwVCI2/bV 6mJgrUoMDzF3gaScxJnF5On6ucvdNOTkzr09d+/tiyTbzHPqOrZyp3Op+O8+XFHjg4hRmhF95QTp jjbud308fV16fO4chZFWQ6ks931e1p1UsWQKeqd4tp5n3t5ebRM6M+wOBg4BwZkjNnpKIy+D9xIY mRVWfH0SzD6dnxp8PKUyyoI0j6scRGctv4fhOWWYcw77eLI0iOkdN+RtjSS82QzFBLka9nGJHm/H T+kyD8qD3m3xCN5zHJ+uyNJz+UQcloE1707EYMl8mQIkHIY37k41yUkMOyIL4MHtwoLIr1U8yNFS 7xeAYEVF+cU1kbjgyHIPzxfTiNP8N+j8CmJI7+XPoYsWRNO/UOQj4JQQOtILj0kTbwcBy0dzi4GR Ke7xJ8KnsphOqBdiT1e3DYYR7x6cV4Dzz3e5DY7JIuPiwQ5F2R7Ekeqf08X6gM6KFlmSQ9jzHHUY OpAsxz668iC2aWub04T3vHC5iYOpHiPyqbTkBvO2ug6HcKEg+f4+T6Zl1AeovLEX/J/oCg2Fk808 10NoU5rYNUaKhxiApjCYdqKZ8iyzYl1u9mfR5McMFZPzsmoMQNSPa95mZcsnHcXSrKfd3VSgxFtx z2YsWiObRoH53KwEV32X5FXrXZlBl2ibPYpcB5Yd05wet3IOGTQcHuk5bjdx+ocdfsOwky5QMuYM 5LopumQPi9noKkvZnp435Ye9rf238LfX189PkI6sQVUMJBdavJt84p7D1AV1oPIAU6w829CB6GYs wWYYBwOcqJrFWcsDHhCNXFZkjI+USLWPBzvnO5Y79DDCMYcPXuXROCdAWvs55b5mgL0sB4xdy0dL ubmTJhTMeRRgvrNCgMYzyPfRCYwB9uJ+qdHN+N8aV7GFVvtpuvc85us2nDGHgxIKeQCp1eoFOHcO aifKJlpl2nOwsA5gHIU9Z3hgg5zZMeNXcxg82M+X1PHeTjP7HBsSzes2xnR8p2JfLD216yXqBdU8 z7fjwTyk7Vs9cPi6+y3WGana8O1kU5sY4teC998r3PBkeTc71pvlBydBnPunukTXmfde4fmhj+He eT72UcbZpo8P2eM04/FlZlLW0c04zG15PTrFnG/nAH1iD2YYYqhifUb25xeT+TzSI4YpMZ1+tqq0 qN8nbOa+jPp0OrVAqqKa3fAZZM5kfE6uPaEhL2b4XoSHsB1GcnEU72+/xt5CzN05XYVhlmw6LC9F 6EAqufGy2380OGtTwIElVRIg0BB5sNnAko8gcnSaaIuWQEswYJwTnRXMeL02PbwdREes279jxJDy Q6HdHH1xJNFiH/r872cOSc0qeKevn/+3dvH9ZSVZHnLBvWjAnjtvIsEnyPE/UeYxMj5Y/c4e64x1 3dB7oF4PTJweWYJ8mmNEFmC719B8QIARRsjLukQfW5N/je2fkvk/bEHQnvPJPJWklPBNK7Pb4f5f m5/vf38ufhsiH/aSkQRMESUEEzJSJn+Z2ziOazc1hs4/+rjZ/E4b/E/pf1PTnofM2aT+l6PEeJor ZU2bGjTlETorg4dYSqV8e0QcNJEqvzMdBK6K6nGLIiRuqQf8jdyHJIlKpXVyJoKhKqRKqK5lUmI5 MTgThs4NDFVWjeaTho2Nmz/UZ/2rJChZI/uQPFs2rDkyI2eMjzas6yjWWdmh2mJdmPpQz/jbJ90m 7CD/4yOSgPLCohIWmcDN3MW2hpokbjvG8PHg9029WpvVTmWdkPHOE1ia2TWkPLk3TG5ptLaTLTa2 RSItZVq9DXcw3NbZohggFHKJDRKqw6ZMGhDSWTFkP+BVWE3UTUODDiDTAUnIJRwBiCANidlZXTLt Cb4AWCcyEd4YndlMU3JUmC0UEtw0nT3n+Tl/ueh6m2fLmxaMqeKhy1FyTAqInBZE5pX+N6HZh0zs 4hjBajORKkECYEs99bItmHMszxJ442e1tuIz127NjlTNiWYrA5VsM5Uzb0tkmzcW6xvPS5lM1Met M9ZYOSW3rTbxG7R7b0tZWtbgZ6ezaQkEiadsPbnjx6hutm7WYkkM82uazbxDxMx2g+VNs4EaND00 z2LB21XujbPJ4tsjaw4rZm2khPwv1PnfM/p/iXA+zZpxp8huVN34WhskSnNP1psQqJZGJMKNk4bk 4Q2Nzdum7c3TdChpuVuTZCcIafiUJtRJ/UqGQrSY2/abtxN7OTR7NPGjbkwbIcyH5WzEbN5VVimk JWlJOCgaTTDghw/c3buSHBw2cp3R1lNH/NDI/5o0UVomR+5fciRsX4fN91/sG+Tj8C79uWtuXsTo EfZLEiJiYfpaS/7Z/bPcdXnnif3J5/mWa/m6qRykZMZQcv8B/of/pjrIkOP7Vzf5szojzJJK2yQj /YxW57VYncp2EqKrSTRpMRJMJJnwcc+Dj3eOb6aaNJJCaTSJJqqSqY5kStFaUqDdzc3J4t3Akoqt 2MGKOitKTm+RoTBw3ac3DFY0rhpHJTdUclRVH6HOPkT5XsmckhEOc4SRVcq7ZIkmmK/+5p70+s9E PvKkYik2iCzSIW3wfrbk93zr50ettPbs2bN3C7efuiDfnJJ/VZ1UiT/6sTEdryV4uTCEJFVPvefb t1r9jnJpuv+d+hsn6scQJuX93M0ekU9X6A/aOxCnMf8wv+cf3v9CP+kP0J/mGk/v5I4k2hpNSbSi p/fNI0kSO5pw2Wd3cMCSUxndgC0y2GoscnA1E3JTaRhMiZJrsI9pIST5vwvx7Tl/vY/r2h9b/zbR Bp6mNpy+9jP1yGHXk6PF+g08nXzfrZmMU5TeST9pVVIpJJJPW9HyjH9L/y/5zP63w/gZJjodHH6n oRYiY4ETD/i5usdOsDsWSpziZPM2TtdqYjh+uQO4PWydsnWQ/U7U/1KSTsf70czveLujH/995qJy dqbjxiDY2iDxiDwddpO9d5vMRzfUyJDtHNkTHe6nZEH8ZibPPDseTGo8EJyOkTuf6HemMMAzFPsb En8shG5gMioi6EIzCAYGQkWOhQR+KBjssA8E0ses/fIx6Co9CTvkmhhVfQpo7yOZZHidUROsTZ/Z 5jIleZunJUSdonVT4ngjSrClVFUrufBXnfxh+N9594rYDTQx+lZ+l7WRo/pTcf1tn6WnROiS1LbZ yDnH+Af2uT+N/GVunVU+Tx+pIKRYbWKxlsSD8Nf7tMj8mSYIfwnkEj+uxFIksqBPtsmdsa1q21mZ FgtjZ+JBukQ9sDiIG0jkoMJwIsGwSfMomkdpYfjVVkkfJp+A+oRMmySf8fO0+lYwhYe8p3qfzqe1 879v5ch2jhOEn2NQbRE+zaGg/mYxInwiCydywj+KJ1bH9jhukWfCSPCY1EiPws71b6yRFJopZI+L 2PkT1YXsrJJDziSu13npSPknyhiSe+dSSZGYgNnu+OSfXTT8bRz/Uh/i/GbMF4UeD3shzPwFU/dN Q4c4k3bqqMRjaN5ZI06pUwkON2mphRp/MbPtUpVVVVVNv8jtcmmmmP6adqncr8Kx2P7CfbjUObH6 GGp5H2tNHVoeKpP0v0P1s+h+I2Uqlf9/7puVM+/vNSy7VabpTaz80P2QmbHBKqekiP6RzNo3Zym/ 8u/7gvxYfw+k5h9vQYJ4EiPN+ox6n4Cdj+ZunBXNKjxVPyNn4g3SdXah0dGNmxHN2LNIeipP/t6W yPMrdvEGHoK+R3nRqTGJhPwdi7MVob5HlMWOhJ3OrlI+41B4k6P2P7HZGnRFkwGGIkP9z87ETtRX cV+j7K+/c+/lv/hHZ8EJiNFuWHiihgaCXLkcGzBVAooQEDyBzOjfh15Kt6pI3SvrFR5PWx9rH50a 3fc3VVSfyP+lunN7j1NJ+ZHyEkpkk3lkj/ymxJODZt1K7lRPzyeD8rQ6ppkmK+/+80J4hubyNI6p yaYWE+dLu8ztYpw2VORuak/SrTtfwdjaNjQmOiGjtCMYBGYqIU9PtPWfvj3ufXo/r4je18f71fgu uKybOexxyfmhpN1ciTsfROWmyrE6NH0LO9h2wfw6I6SBskjcnD3XFjSksjaI6nQkkm7YosOUEdhH vRNjYThjZFOEAeD8wqfu/v4LzIobTiODkk5/gZJ99ZB0eXYj7X8yOgjxcpJOxZ4tknbEYbO6RMN2 5N3iridk6J0Aw4iNkxpWkak0kMk8WjZWoyb7mfEnJ7jE+xpVe92MnxkinxLH/KhpZo+c0E0jc2SY P5kSToh0MP8jGnkYo6kHR/8Ie8aA7zyCr7D+UUVSYrn1DMMY4NQhEfR8PrONfWzxyc/wnZJaaOFo 1xEamECigYQP/kQUNFP6jg4Dkck7TRg/MDHuXdlWZZhSKFmNmTLpTK6LjU7WI5EV+xxv8i55Mm8c 3R+hSydpWTIuHKINTefiVv/W7P4v/z/w+8D93HgR8T3p3uicmWk7wgwIF84+lUfIPMYBsp5Kveec wBeQPnEl/OIRcdjNdBhwPdIch7II/zr/MWLmhUon0qv5jJHUQB1DivWsO/UdoRRBEEe5/jdyDFgZ JaAwP+xVNzArhzEH//UCQR9QS7EfO8m6+p/6duyReZHIz1NpqCYcDtUIVYJl5HJE50MqeG6ocCHq DdH5j8Dm8CSSeSYhkiO22g9DHR3uDUZH5HcTtO6IPS9qHJvKhJ7pPQ8wkk9LvN3dFVXveHvWl08k rueCTvjYjyG7IjJ5VKpUeqQ7GYksmHq+fh41Hpna9EQZHYm1eYmmMWrjNtNlibEeh1I8VQ9MgyYK lqI8Dk7yUX0Hcn56g/kge8Owhjkq49N26OsY9D502TukjJFbqZBp3nHRulJvGmk8upVUql2Cxnj0 z3eonyt6EY3MbHNyCN3Yh7D5GT9qyNPwPzPqSPTR+c5+Ye6fnPzEQnretottdrqTFPqH8ap8xo5t JHcsjgxkNk2FMIYxNKMUVU/+pscNzBxGDdjowrP0X0PQ/vfc+rqngkj2fuzvv54Yj8awtlfEk2dK 5zdET8aieL5kqmonaz4r+5G7iDixyS/EkeZESidiR+7fDtTzo9AbFjq+swV3Rj+mVjZKh3KnRIlh tEGgqzxjrG2pkajuTaTYmyTwO1J5OY4kFiynV2mJJOccjxucSJEizD+68Zm5OCGCZ0nl3RG6N0/c 3kyE4+sPByOZ5OSeD4OYd8+MPJEhFbKqm0n7kuHRuqtNGyVfJZojDRGTYSVElDgwEmcEH3ptgakU ND+A4IVW0n5lRykn9L+RsNhslJKp2LOx2mOZ2tK0xWnYpW0xNN1nM0TsU25EdXJjkR1aR0R95w3c lj/Y4RgkO9IjqclKwhqIkdhumiSanYizEWwkPMkj9PsD8j+afuj2NNz9CQJ+f+E5vjep8aVzKTJV Sld5T2NMSqhvHR75SJoPBHNE58bxJ8aOqfFxOpykkJZgfbD8tgdksH6U4SDiq/wVjyshDCwR4yk/ zSiMSSVYxaaNv4EZJtjlmz2N3GsUK1q0ftduUqUiZLNc7bo2fr/+yz+B//t6Py22/3D+Xv9hN6TE tpJ/v5OODjknG6Kccnbews2KiOOrELB5pJkQePpe6D2IYrAxNNieqe4DibpxIoxDUNG5JE/4OWCT /8Puhh2R/g1NGlD7yqkI/1sDj+InDQwaNK/WEbkfabqY6k/KrT49na8XmP0LHsljC0j+x/EmQn7I 5v6n7VQDg3PjMRHqJQtYQbuO6v1YOEm0DJXksQac2J/PNnER/MpyOTiHI4k9bEnpP8LFlJWPREaL FVESQuoP2uGBEhHabwJfvwx6/O/lNEjyZmWfND8b+8nrTY5To5lfoeZ+eOuP5XdW5oH0MH9DIgfQ 9L1z/acAquH9QrwckWxP1q/Abdm0jeiq+OaD+CNk4snxw8/gx/K/DE8T2ukiVUlQsnQ8wWIMie0a Q9b6U1J6or0sOss+NjOaHRpO+DYpKT1PMjhUOxuTofYpVKpVKpXmedHuMHiUpqdiK6pzh4J1YNnX zfDP5g3FcjuSbJIfQTtPYpVKskUpJ8T0O9IncHkJkK9Dp4tSDziSvBNGp550xvo8HoiDGkdzgkdk QXzTnEGJUB6mSYhyjucHvklJhqeU9khNmQJws8nmeqed5lSQfvFQ/Aj6GD2WQjd/M+olUqf0uI0r eU/6DTdU3TaRzG0j+sqNyyYsTlI+0/6nY2MbSdi6c0WSH+mDSOEsibwssip+6jq70qfXo+Z/L/P1 dH0p4HI+pDRjubsNKVKpKqtMI8GmxZRis7J7JfoczSyz4zZG53z2tJ8YpPePtpFcHoU/1PjnMZS7 tPjv4Z/lia/qzl3mbYZlkcrPoQ7X0CMnkqjiIPI8ZG5NyNHNjn1ebdGH1O1MpT6SUwlNHUYGhYHR usQSjgpsOjURzaTdPwJYHE3buNmPswPxMcG6iqPY8XJjGNk0rStKGmmlYxzjeIKkknBUObUdRzsk 131O/2vp2S2SEI4MiatQ+wwBhAKKQOAYwMJtpl3O7l2cy003sR+B+yfSTcc+18jTEx4f3jefpf50 pTaWTFSTAkNx/ElJMj63CdXBPwKqqpVbyJsj+2fIv1MYVKqq1DhP7lR4P1oxGznE8k+uHsYtSn0p Y9sTR9KH54KlklIUNonzElHCIlhOiOj78VJpX3HwQPce9IV+PqNHIQ+o4FX6IHQ9anCVKZEHNqBy TmrbZGxMnUw7TkqYCuzKDAkESPSLD/cMj5I8kOITq2eLm30GyamzuFQWIvCkxLIipeCybJ6FT1nq e5VU9z2NMZI8lcpMU5KjUMYv702fOkcyTaOCpMR+XH8ln41fslbvg+lruI6Jk7HNK+lpjGRssfh5 z4eu0ls2noarT1oafNP2PYbx7qt4r9yt7ykpOaboxPkcp1VSnYpi2W/383Dm3fFCdvVURmTjUSYW zDhNEWJFirGyaibEhsXdYiYZFPn5G3KSdkQdeXJDclQm6KHMWBoUb8kmQ6KlHRyScyQeZyn941I2 R0cohhzaDDqwwiciRzZYiy0mmNzs607MOdngjw9OzN2YemzkQbJSUKmCpjokRNSc4Tkqf3MkTSRZ yiCxXCcoNkOyYmFRpzDHgKjRx8g9Cvaqu2PsR8b2Jw4HCpMYwjhHpsSyyiyVFNkbHxv2bzcjYqT8 n5p+f24knuG0yWvqSfl4bNnV62N1H3T7z7iKpLEQp2CMRNQliWO2eoRPdJPf1K/MH42kNHB1kRHO UJ1dIk/C0ioDpWI7hsHlET/FUJO+OxsGRjiaJ+jHqNgpGOxN3Q5xB3u5u2SSHSI+RNbO5ORInI74 0sibnchTZ0h6TdPHTECMHpVZJaHJJFhZCuJIzQgPrHG5MGP/QqucdR0TqhL3vUEjy8Ijuqd5Cjkr sIuxAnMT6j7w+RPgjESQ+f8ANSPvaYTz1/C/ucFVWz9wPseA8WPwzRx/GRXQ+oT3eOHkPsw3RA2E wcYok96nxviSjZ4KjQkbIaSvxn62J7VED/pIRMHsH3PcPWKdSg9wh6nDvFPFzOSOG53qjnvH64TG k+SIO2ZI+lOh6Y6k2DmdXJo/WlNFOSfMRhyh6gc3DrHSIPmGRuOkeKpVSrDSg4S4MO/zPD8QkfIf 6T6z8hBhho0fsY/AVilOkjTd9Z+9sVPe0anYV0R+bm9Zk+4jh6RpZsTE25bT7HBsoroqsP/s/rcn Jwyfn/i827ZH/gnBh4t05OGHmdzkcu5UInqe+euwW17DPVLooP1Q2iDGoQxiVVVh2HvEvpESEHt+ MyZAcUabz0PNNEA9iITGUw5LvB858bhyfTEG84NlSfkYbNoPIjVTvIqg4iDTTFdkieYuz7j7xO+T lB38tgrvNu8jmxkRuajJEb2JCwskn+l87ATURDYkhxPKI29LCTmodzgk4YhJSJMSWbCeQ8k8x4uf miDnJBzRJJ0VhTR5Qxs2KruQpkqrERZE5TpEiBzdzlGk03KKhwZEbNodgiabbhFoqpQoUiiCJVgi FGJplKLGiYHN45HrTIssjJD1hgwqyybFTufE5JB+B2I8xYkntT+pWfY/kW/ytTk9TI/pLH0KkfKd DJA730Gz6G0VY/0v7WHD+PhZpPRPevsp+Iqvy+t8ss2Q/f9GkaDp9MQdNbG36X0tHzKVTdT7FaU+ 8m2R86yPDDSTtvhnf9O94+uHVzPLqzFx6cNn1PNBpYssnRJPNKDY2KVVVWjJGmx+tqdXa3WIKj0u UyR/GdJ2OT1J6iOKWko812TnbtudpBgdSPJ4Z8IcG/bLd+2hNmZkVlHayeA7myqaR4TtNJPlVJPs eG8g07RpKlPcv8K/id0QdwpYvNKlE895y6qVSVDCWTo5fw8GK0bVzMc2+0k3VhT6m/oXTqnjDsmN omSkQRNlwMHYiEhHIiqHIOpIcPOqNAcYO8T3veR4o9ynlPPK3XFfgPlSY0+tPrqr9bcpVKmNSrpp ppTGyttrKSfyGif0Ik5CHCz+hE6P3Pvv2zeIfpdH8Yr+9wVw/A8G54RMJ7JJYOsTvsm5ZW6kmPEo Md6VVTIkh/E/y0fc2P1P6n1tOwvQ5I6n9r2MVMbppo4N0/WTfZXohLsh+xUpXobmI2hPvn62GKqv 879jRNmNippNmmxsyNnoaVhNNjZWRRzP86VqKxUY/iV0OExOaVP0ukfA4Ke4+VOJH9VkfyWeh2Ds PFSsMKf9ikwmjtNmnDZpp5Gyvf90fc/pV+eaffZMTdmE0aVWE/Ec31RBdcN+DRy2+7X9q7nipz6n Vumwr906GB3F2OognS6SKdKBDCrogiLB6tJp0PBrBncGM5v979SmbIgfhEiPQK0VipUpHCTqkcPC Y1pleKc34Fd68K5pI3lkJ+o0mO5jkfoV3DmVxJK6ieCTtfpSaFGmnemlra03mnV2QOTviD9B1WGO bRODrEHaHKbRNneOCfr5o6CaU0Ux2tkdQpDzvBkQbEPVTTsTkzoYduyg6TjrRNk51JzRYnSr1qB0 5uHeEkcHHN4TsKLINmzDmIc4g2SSOjdN3CWTdFROE1UjykwNkndPFpNCTSd5ojac4bpyETRHjCXa dG4jkGA5h6YOkjGDupAoSSgMJQYg6FAw0kbFHM5xMTMnmfc/Mr5p5o/9Esn9b+bPhjFv2K+0/C6P 0Kqtn77EdKOQ3Rt+ImH9lNvLNTNPOx+O0WmK73+JPuST9aTRG06n9I4MeEbPKod7ozGMmPW/7P3Z IRPplm7vV4i6k2+o/uPwICh9Kp+EwFVTh+Ch/Og/OEqB/NE2XxOzY22nb/j9/PriDwVUZJHmD7I+ sijTmB4OQ1EnCVPvonmTq7XtSkfcUmuizti8ETxiDsPXDZRy7dnpPpknOIOauJ+Ozml08nlLg4KV X+E8QdBCcHDEegJxhiRApkkmQryaTfUnwGpiw/uv99PyvUyT734nV4Qen8qWkfXPF5827tzsdSqp VKKoqqUg+I9T+YI/MbHsg5G5gKrhI5qzuU7CfkGV5hj3P3MHe/Ax+OI6YtT7VOa8LO6/mfomu/xf DL/LHlOjYnSIPkaaSuadZofUpSyOIg4kYwxMnW9eRvP5+j7tEeR/FYsrzlRjTyibNjE5zSzlk37a zxJZH8OnvrebSHDI+Y4eiPSE504L/OOg9h7WH6u08Vg0mylPJo9U2q+L/i1nA/B8TmfiOTdXxRHI gJgV1cTOCgyyBloVEj2CyKGYWJpwxiE/CjIk+CjJWzJwOg4myTeE4CaNSSzScnqO6J635Gmxz+EQ dHc9DyiDuNH5G/VXZZO25Yyuxs2OGnOINypJHDsbp9zdiFc2HCk0sOv2qIfK9XmSSO0bRu9TvjU/ 8jz/Er+efK0/9f7q5SoYf2xr5bOg0bSvCpsp1xpbRs/3cEMWyZ2v4n+lx2Z6HHkwRPOB4VO0A6HD G90/9n9fX7W8nm6NRYNKOH3OY2dUkr3JT9bGm/SZYNrkZSqDTSqaFsPZRVZAw8khuf2SQckmzlP+ Z2vKH64panrrLZf4P92RPS9FMSZThf+T1/+j29+55yuD5ICh2HAWXd9y/4L/l/6f4flmH6v/UoA8 8NokVYzTjYah/8Epx/Wf5n9rgbM+pnsNnan9Tjhsxh0p5joxqcztmllSzSbjocb3R/i/BY+f9PJ/ s4f/l2wyTF/e9v8p/I/Uw96lf+L+99Bp/wf9bTT8r2/7nqT2DwOh6nR+lyR6DjT9E1w+0n/KSi/o l4Ok0Oyh0L3KPWgcpLicFIs2+Q/SQzETaj4P3cGyXwevo2RtH+/1+yq33bo/k/n/odR75qDoQ/Xk ch8xykpzWf4ESbWLjJgwnrNPSwwKNNQ+XdEBYb04ShiPtIFaPrXkSNIOHJdDg7LLIgfMgqGZgkXC K+QeB4SLG2d9OmFEhJeSJ90Hgv/gJhe/wMB7yAsj9wgMth3qL/yHpdC+f/z+Tjn+d8w9K/0vnOQ9 yHzC/KkBEfiZIqY/0vOdZ/kn9zuSDTuR/ixyOG77H2Mdn9yu0ROg2g88SdkFSw+8evY7nKbjzHoF cVJAQ6AMX+wexewOahwKTlEYf3Nn9rmn71Uo6R+uN44dr+5Xuk5AtXJOJGospEDNCEDnSWugwopX F1JH+8sqYmxwedNJI6x2JXndzthujqxiVKdJSK6RNx3N4K5vJvjHYdu3ZYhZTBMgmSOhoIElLIiX NQwFRRCJEO3J3obpkNsiR0TkInVSO48EyE8RVTC5nMHAKgBkmTgOTJmbBl2HFw/CHFa/64x45T2l ZESXF5kVCkkDLeUPYEnioKqehfedBvCB5pmhlILgqgl3Ee5L3FNCiSDBAUii4CYdkTRdLvCAUTFC pkOHMdjTRVaOx5+Tq5rOsYqadP8JWzSzwtg4UpSBwksEFFyCiAJmo44ea6OxgmklqjdMhQB4i4hL vP7QyQpFQDU73ZK2Uxs2eUX0PBAdqpUearEd6bjXR0KrqcnNHe003k2nBUrhVR1nVOqI3cOwqleZ PJHH/ANjqdh0NR6HeRiG0+BHCSafof9ZX0FMKxjGMyU+UjdG7Zu3ViYKxjN0mySaabFjFYxmkk9H nVR5FJhDm0x1R540w7HnOZx4TwnoTlqbm4rJUxqtnEnTrdth+52eDyIj2AHzrL0nSd51eCPfNPmf Mcne5TJPBpHtOHA4I98Cc3x+TmZhfJs9DhHETzJs1I5u88GJsI6FEVjw0zHK7OhzkTG5hJJOaNz3 NlHVMFSyfG+duaDzwve+52+3xP8vrhK/PiT1kk/FZ/UfPB/OfR+yy18s2h+2H4mD+JPvhh26kO4N CdE9cx9NW26TQjiTuf9Z5N+P4rcSJzJ2IUnbP6DyDXHaRgxxwfdArrEI4YgY9oEi99PCXJMWmOuI 8xMVySPZTTGFzWJpshdiyxds22nCIj/QjniEt/ucGp5I6zeNUu5/CHZOx4OSehVlkD0fu3zXn6wx YmNb62NW+ZEVEUVTSElGazSExFXjmFVQVTVNU1vtOZajbc062wyCiqqrfFKVlJGZaDweF7AIF6VA 8hQe4POeCHWZMeCuTu89bMyaW6NZNLO4jiTzSjmeUg9CWQeQO6I5ucnNE86VLJKHU6x53ETyLFOe N4mTCnTt6+Jm55SVI68758nG5FrblbebhrNu6krV1c41t043ceZxqmHC1q4zRvVNMujbuW0C209/ KXYRs882+U+ZaymUtZpSSKWkRMUxJf5dD0qdT1MzG4i+YEhVwP4xtDsds7UHYSaNu8ndJtiRzkOT qcSrNQnNZxwZBsm3LaSOx4PJoHVDf1i5dPrU4PFqZdZ8GRKFAUVEBVAWAiBtC8C8OkxDpOwTQctO z1qRFNI95nlM1wu3WBw3mNzLv2QtjBdEmnccxUWzt8XLG0cJtVuKqNQ0qyEVTW4LNBgqR46CchGw 0AhncohxOUg00XBoieoEBgIFW2BOskpDzBo4OE1EnVSyRG3fNLtTdOEMTExKlTEwYMFSUoRgYzOP XvRV3OZj1CgcCyKncpO15+c3OaehqqWnhzdk3bIVVUqqiwj7HBKxjVMUDahMMIJkkhIShIUNN1ot uAhC0gYkHuKm1ECJx51IlK5JwxwxjJczMlYqsYxjnJI4QRjscztNhRyasS0VVWXoO+b7B/phYqkP R6OV7u7u1xVu/HG/GdxFeSsgLikPSZmQ8AUQFMK3s+L2hCHQQIFioHxkSr6XIx7WVZaqqeKWZl6e XHe977gLgWxHkVICp/Jr+puEEpDzBYGDzHsU7RTSIeLIivSuEsyeMFCUCniyzAQrDAw7CwdomIJC MzZAbILG0FNAyZJMtgXJ48wi7lKDlCqQK3Q92JF0jCl+WlITNS7DVQQiqk83eZg+GDDUukQCOJwM bOSvLiZVvs5vhjPfFFU3eGgk2BwiI61FFv1pyQZHSLZwkIgsSyfFpfJptDgHQ48uequeJiysMmSY k5SSYcKd10PtxObdTyT43VLi3wGlN6W9KaWxqGyKTiVZHFbeNcG0HAIaEMF3YNgAnyJChoZBSQlV m8jM5EYRFNSjMBkBrBXXcggI5LkgJgnALYWEh1OT48d5mZm0C38xHqAg2hoVTPB7IaY2200t0FVU VePUgIh0uAnih5jrE5oeaSusHoWim6OhWkKGx7jWNkHmbTjDmOPYEnZAcu8HHkawKSh7QjSld+TD FXBqO2Jg75OpyjQ4nk0A7CZHDJCDJEhMkhXSsIFkDxZiuSpUxMRhhiWVMnEOqWFTGOcQfMEnYaiI eMsCkp0QGtbOxhCPZkbZ8+WsjHs0ezuadqcyOcbSbLbz4I3PTSMqOw9CnJMYeR1k2529Vxak3OHl IqWWEOhDv3WA9ZAESlLwbD4ww1CdWsOkwM5HNZzuJTTy3UkUtPqfI89DwASiuivRj7SIVuIh9KPM egHqFoiFgCd27MlursbLwwd4SR1PHJh5G5hiIORA0pRg02u3Zk9ddt5jgxsG1Nbe963vTCoR0QYy JIXwXo4McY22RwkUbbbG5I2+JG2moXvOc9vo2UOCQjbchNzMwZTG2EzKZvfHAGl0aTG5I22GyC18 myvIfRos5pSlJxEElyEK44B4kh5xcltpmOZkWWGZmZjzkEC0CSNCPY3Dw7M+IO3e5WZlRFZGWQUl DTVNVF/P0iPkdK7AI9YQsPBgPiaQDseFBDkPaqSOyHKSJQ9Y+IwhsHAV0STYqU8zmmJHmkJXRZIN xwol3E4eAJDSHQd/VNHDsobcwp5OUNIdiPIcpJyTr3gtklsxHZ1S4wwNxycAsKRtwQkyZmyCwJBI SL7ADoO/pbvLaq9OKup6YWRZ4Bg8Z4nADingKiQgH18pa629rKstVVMIfRaI4joTUK9S9rKstVVR SlVVVNKTMzVo5CIkJ+Tku54KdJ3iyh1CcIwu4nQJuaOl7xEaPMPCh6DKyJoiC4nBFqjBNGRJ1rBh lZhDJ24BXSeboHDgomcAwQcL4Ja7nKZEyIIUpRKkIMhArTa2rb5jZMScHtNBWCRNoO6d+DnKtNSs kWeBiPHhEnodu3ERynY6QK3Tz12lKKcnt/jTfbw7vT27OdlltHRIHOFIjR+0ekT9AxDDDEjjDoE6 nd0JvAxB1eXLQTI7EMnBrnwbulkvRu2OThWcFpRVmHExq7w4TaPP4ExsbvVL5dAwlSzaIqd1V2YF JlODwUTW1VTVQLR4SRwwjDaEDFspiSQQPDFT7O+xFK1OATIccTn29vb5Nr0KmdoKdpzDS7KAOFBa 66JKRUQVKW5FgQ1QgknISgVJCMOHqrFwyJUSBliiotJFWhYlmgINaGJ7wwq6OF7ERhh6zuR5JaXr CGQrhMpmYYrMzMHmGUMMwzDB5hlSxpjTiuWVrBDZjjRFiEwJQ0aBQgTElM78aRaRkpMyAxIqxCiT 4CCOPAFGvQ5OjEc7DguoVUIl0J6M6sN1x6fn5x8Ne/QbquuC3xqdhlT6AodVKNJyKJ0KSxNRs9Mc 3Zq0xdK9RnbnGdRFZox22gO0N2qXtRIyJ4DZ6B8wY9imGVtWZWdi+SaDzjKO8NDgxkGEjkdwpKKc EocEHR3BQVdHV1VEVmZPciwL2HUuJAnPxeBeyC0L4rRRdowcqmLEfMPNQnaTsmE2iEi09ph7pqew 9x55zTh1czY4XoQ9Sij0KHBwbogqQkAiedJDsPF8BhKV3YVQhOSkpURo9pCdyaoIa4Q8RPHtd18H GcGkIgfBMR9BhDyQ1vUAa8ChqEr3qmtinz2kVFJrPhKumcHRONsWUGmiccYKjXWrvgqTH0jegiNY jGg+cT2IorgQgpNsfZNbvHOPXCttJolZmmZL+h+6f/580go82HDxZ/mWN7P3yyP8qP1rJyK+Ox69 IuXEmjV94yF3np32O0/3qmj+4o2XSoqk4FZjZtOUiybpPq8xrQD19SdBpUHZkD3wJ4Mi6ZApWhXc lMPaYOEciVNvf5Z8RHMTbj2dOG7B0NS9ADB0wGoImZTXu+SqU4kkdhuknX0/0/T63DhLZykPHxQw GxBOEKamU/+cvc5x8yXyh6NBnf1Io6Sr9JSJ/U60PpIikkgD5ecXtJVVH1yeixjFXDS/vvpGbndZ 66OheTux0/NFPeON4bPNx5Pzrq6d1fBTjUZBo2/zNDuShtbuAEIKSltpjGTsoWqavzaapfWwamtW zdrVZvhK7jfkniqSTlnjz3md/sbRr0ukxH129HPl+onHnmxqbjdeqcem68gLQokOGVVsO2HeyY22 fxCsBcpJ6ODfCtvC8O9d11wvkviNMveMX5FCCeodjE8Y2JB0cZTNSm9HOKIJOUm2TGS2wTMqlGvD VRar1peelKx10xfW2MSfKMr1dy1Mjar/mlq+rtSpd3kx6hkO0aTyrh7840Didy+tBNLa8IGzty7m dthRdMvQhOGdNyWUTPPStWy4MXVzMDfue76wXzhbTCOfT1uEnd6TBusF4Og6bpFy0xtHeyKY2+uV 8OrX3ts786NhKXtPNqyd8Y3V+tMcVO+quuMrxPek5JrN0HOX7TbT4AeoQnB1m6ZPBnm8wspZwJrb Klx6e3/suwlE79eWVjGS2NCGZI45UqttpKmZWEaDQDJbKpUlwuIs+d20rZyv/eh3PUVXGE2nO/jc lfNeU3ORolpIBn6c2p86LqhZ9y2LRL3rrjbIfEcoZkpGSDc7xhMMHqYS4DhLVHuIT3EonkJIPb5H d39VEOXHEXEoPi+D6zlLamy3vwo3WI2MMkU5j5Wo+3OHPCpMzq+eZi+YOP/61DYO9gsVMUrh2xqa yIdTSD1VRhxTi22JkrSbevGWd9RWfjcy2co57T2b9RYmU5Pj49XZy8fH5xPvGFgiCYgWIRTtd8B9 /YpHylnzrsBFhrKHRBB7nwDU7kPw8NmrFfBIlTlss3sajpHMP+6vvn+5zMk4GGBgcMRKlGEaa+Pc eJy8uo+Eoy8Dwpt31aESkzw8qBlXIVPLQjPKtL+GUi45+ZRT4QO2T+/Xf9tADBoX1faSJhSKSSg0 iyItF5zy2kbO2v/xonGv6XTy6dvzeo/nUfznvSJ5DuWf3SpJ96nEsPU+6I1xB8COdPJVxkEyak9A QptCxO0mEYEgbCp/GsYv8xCHI3ljMPIO06YtHECr1IfqFWD1P2tH0qqyOHhPIMJgYVI4MEMkIFdx CmLEQM9ySbKm3LZ2527WzITIWplbwslbSki0W2jftPOibPsH3fsG38j05eB6vqEJjbz7pU9rh3uU p5PpXGS8224bQHJOdaVYmfUETbW22iwWhbKKsslkKeDlpHo9Zzeede/zf4OD/Qc5JX+9Up97Y00f 5vhPZ6Hd0edYs6SyT7fkbBR9knwFRE9HrPSKOlFWQQ+KhhSakGtCMe+9faeejJZIlaliw/nOI6bP O++zSR+1Xouj6o9Ht14PR4+/iB5N5fREuRPz9YeytSw8yJv8V2CEs7SrjPLKyxetNGWjsPa97VLV 0j3pCMa/WylSpsSHVvistNUx/5oSQBK1arSehrc2pEgXyPxWwRmisdoRGiHHCM95S2VFhr1EJ1Ta xplK+S4IatcIc0kmXog6A+1Kqtj5PleMlxmLktYtLa3a1o+OFYKIp3IfvCu90AKYIo0EHBMyDt5z kTo3NrdrbtudJTSOHCQyFSosEQsjUsTWGmn5EkStNmI4T8eSDzw7jtga4wnxPaj4fiQe/fuR6ZiQ ZAiRYgWGCRk+QBID8iyHg0bZCgSiam6xfvCVNgVJlzwEXkKhH+N/Wp3Cfe806vNITrH6fzbyVVVb KUxpP1te1xs9sT106EXjEyJ4SSE3fM1Em1z9jFVtTu2l2TshLk1RIDSgjg7XgNjho3pbV4v9Iac4 4bc2iTVdS4xMVZNNHUOcw2RZFQfzbnGqbZ1ehKTqwmxO2b0sySyYbVdwakdZtPRP4+J+wFtDnUBX Y/SR48xfYo7pxCRPQCH3dqL5O0J3zt6Q71G0o5ut95741G/awZvN2SlQqJFp611YiW1kLQylqJ5O G3MkOTuntwWKf9Vnw6d97fZngrY2Z4NLWaWWU9s+W9BD6PzT/FZ+z/qftcnh4y5Q4H3rB1iq+cFU x/OvsA9hI4i2ZJm2aQPH3vq62/TJCLbJJLQ+D8X0fzj292zkljdGcRLOh2tvMnhzds8TeNvHbnjL tw44yqxuRERZs6c524gRrZLbOhSgzkNJtushbKprWNxcytxzhocjkltjHNYOYQzEkDKthKOEIMSd R7VCA6D5Q36fjPU7o+nYsGXBhgscJAjCIiWRRJYhmCTRYMBAxrKBSpg/lPXaPkHYDJUfjF/CAyLE gnHgcwdPORkWHWsixtuIb2LBZI/ZEEx2tj+vtxtWWLYkbb8KDv5P+JjU4yRkQWJPhHVOz/KrbS2R wG6J7ftR3FSTtcPSW2Usg8WdnYr/uyTupqx4KNawfUaPRH907npG3s8eJTid/dDjkdX4rnUev8G0 cog9DtHKA8I11kRKc9j9dM+DuoidkCdEHRIjpgFXNO0dk2D9OmsaxD1dm1sDsoEqKHSvnMB3UfF6 5jwPnFbFY+9OQrkKh5P3nar7z4HeIPIH0KJ6T9Lv9m98gs9L8ngTrMMlMTCBlgJ1PpSLjRFJ/eHo 9tmtLEL+AZsZVshoQaIjVp7sDRyPQqAtkSlGXYLgU1DFjeRLBhstoRGhpKjaaDRSYA80TRsCIH/c aMERlN0kVwVSAOFFtjxbzFCWVitlGlsw7ZE2klE97c3j1bQaTGjj3RbHqT3GmoSG8R++jnKk1Kjr YZIhZmnRYkJFDtbD8U/Jj4PmklmGFSfKH/+IVDBNMP3XDc7o+CAEcBc0+iS0ZM4k1JIbY4WBjM/+ 8Jyldo2K9InsO7A6gw3Ng+WVHzkwky+gDx4POHmfvYDjoestIgduKzFMLHIHmQL9CHYSGJZ2DHnE jSodaQMk2RkIZtifA/Smk3F/a/Qbz4ORg79fl3FkQJoeHOFnd1qW553iya8DubDJT9daWTaI/eSz RFhPILIqRt4h6n2FpCdRsaXRjpNAUkY+8FPOR3lSfSBi/gkB9Qd8nYH2KnPW7yYgJOewbPpHrIET qf4143QQ9RPrJXBhX2xYJMHN/SK84bETEk4buz+xvNSAoT7nY8DtO4egicDuKgtxxyEXf1OLOuW/ x63ayNtYZ5KcF0kEsloTCcTFKIdNgehEDlsfJK5Kk04w2sk+ut1D4iJ/iUVZJJEZLbNISGjTB8w3 2fTvIn0JUKsP1p29jGI97ou0aXGrcTb4kmyw3VHWyRuNI87jlrQ3HG6oJJpfTEkqRQ1zzArhBLex cbFU2ui9DmyRLdl44jJyEuJzicJEw3UqeZE3hG9HONGeLaFm3m7baUJBo5JDbRhToOTVw4WyCWwC QUDTuPBbM47I+dEMgVPiJAIIh1IjVkiSLNnWdXJ0x0jNZJXLC0YIYxbQuDQtYv8C1oxIxoGZIxo2 RMWUahdYXCAQYjwAkFNVNYaMGt5FWmELCGjQwobIFDa2SjYwZwwcifg4mUOkOnLihustK70mxRPw tmj66b6WPnQk2IW0tkfa+83e1jHrRVhFVTqndPGEPfJEPJ4h5fwSOaROqdn39f71P+udH4/jKLIC rJVlNojlQ8NkD5CT9Swh90iO9wPNNe5t+DfpI2hJ7vgyIRs/TySaS/XIfF2FTZ8q5poDIj5ElSRU lgwusQU7AjRIfaMoxB6lE4ToDQYP2nuxdjYwMTbFDCfaOOEMCSnzVH6rB9qWFS1UnDdMPqfd3nuj 85+ng+3nHf8Z8sE8bftPc7T+pjTSUxOVdqlGDC/cYTt7Xf9wBJ6Z/8J5CpPDGVbMhsblJ9EcPcz8 sPl1MeezZqbur78c0h7P8+QAhwyEIW85/1vf/ZT9LlL+nt/J/wl7NlDUg6UIGP30ymw7zvRUtoPq ptDLPRNk9mCWX9bV0V7zmrW1EKcSCA7gl2OfNV/Yidndhrjj33iEA3yy1kR8hcX5eEIz01teOMrL auH7RMUqEjNQJk70eh89T2pENA3zUXiyp6qP2etYtIcxXRVxXWC3nZCabif2n4DDDDH/8DgcfMOo AhGfTHNZb6x2NUxoaVcQNRrz34hlksGQ/E6cZmiEgWIzDLCorUiZWrU5LM6FDTbacVlmolPEqczm MMMMdBwOIqBOy51NM+M9G2twhJAHFrEia3sF3BTEcyinij9smj7DtOb0W9aeEbm+fx0t2+h7rhB/ ZM0+2fmte7yzvmu/J143uS0Kd+e+nelUx1Tgfk5lbEExMe2DKaRJ0XUhAyg9rMz9aGWWpO7264PY om8q9dtt51OHUzau2441rwjO8SadDjcwi6xpo997VH3pLhyldaY01xnCEpSpKksvp7wDfYthSe0N i9Te5MzDv3i78q+vmyQazhI4Yns7v6fk19HvvCWns9R0/tdbyu11/no5zk8wvfQUT5Zy/N+RufTk 5XT9Hy+eEna942z1B8vmTa6vL+NzxRfvORrhaPG8SBu4dVH4Ouww7tHPclKf2eZ1KbK8ir6JiVbq d3dzQ3vZKb7V65Hmae2XnjqZ74TgxLymUatJ1toayvHMfeZfJxXD1mMFKtnULmLQWuWDUW4x2TEX 5nYzxT4z1yEJD9KuIsEJJ9k+vlXjp04x0n2ds/mcOCD+RNhsFOrsJ9X1mQwWwqlXjGgjEgpKS/nM u39yHaZjviIXZDJJgYYRuOBI6g8R8l7P0wP5yJK1c9G7bQW/XQ19pukBospVqp3szFW+ZMT86Vsb PkVlNMP4Trjw82/2LSaTJO28HJab0fW00n5KGTeRZRXSVVR/gqV+5ppFRv/oyHsVMOAF/qLjmP8q cfc3Ln9Hde4Pf4+08Iyn4Hj5LzZ16Ui0mb6K0C5e3x+MYRLqtdIWhGs35vxEnpJ/hudu/OTxetUN 1f8lfxNmD1KNlbK/gYAiMJEBhxE/c8IDBEY0rbffQ+cowbXn1N3nTnGBGZynfrSCmdHY0szWIXhp R9Xzj1prXKueVVlNWqW9lOqs9vU5Jy89+8sex7s8Xt7vg8WO0O068PffPOxjHRd2arhOpboKWYxs /0wDeZzzXHPrzz+l7Z7E+D1u7jE/GHsE/lsiFpEfnk++sZaHZfvPFzdnRdFxBdzuUM3acunZx49x ZFgZo4g3d+OyS+ghDed9pQSEhX35oWenFs3h1N4x2OTVAwHFSMiTxk/qmSD37JkPUIftUkjEuxwa Q+gp+Uo+tY5jwkJ+pfssbbAmAYO77ltz45s45ePaDu/qfGJ0PHzLyMHhK5DBfyaYqxka1y0k48ny dHGHNo0dXCE99ikkGx+ByY7/vp9P5T7OH5cuK+W22PmzDVTbWn5GtadVHVGKWnvk9xKkfG+okJJw j9Z8qdsTULGw8DxSJ+gbSePD/zdzhJqlSytOZISTENihVSPCnJiVIF8buXTx3Of7nnNt58R2wkOW vEMYPZI3VFRuxDkZJCxlI2nRyMIrERhP3iDqjyH5ypwWhtI/xi8wrEDAKbEloXARCjYUqqrlONEJ CDQUbckdlHYlgMYxFUP0lNAzBB99jEkV/7mCTdr/VqJuc9upZYqyHYcMcVwxYP3EBo7DAjBwWIH1 MKflBP0kH/WSe/8z+VD8jw9PkYZs+5+oH1ki2tEf4GduGtGWi20TW2Wp8yslJJqIsyMiMHaPYjom k2hIkwfPIR5hFHxcITTGI2aRsAuKls0iMjKjbLGtHqV+b6PDw9XUcfp+MIPc8e/GBuC73jhknCFk JkkwMrcW11nmwp0InoR/I/M2DzHidCYna7U6D9B5v+l9bztzSqp86mlP4laX0pXSXfUw7pPmSabf gbtFsWnxhZ9rwe1rrnGr8vnDtt4ptbRt6xB9zEg8TkkNI0FElGpcxbLamI9p+Dd2ZHEJfcaiCCai uQ+OGihjP+pim29eZg0TrY/vjubP0777IdetZrxSOqaXGGkyWdwLUjnjiSSSSSSSST9Elkkkkklk xGMb0xQTjRBONERmRafvettEF43eJPvULV0aWbMbMBscYGmQyFtf3H7eZkkRbbJZLJa7bJZLJaBo bJDMbkneTJMk0C8vJ6WtbkorbZLJZJJZNpKMSkjkJG4pJJJJI3Ek5Eo3IYkxLatkN5HQnglSfidi fUHoeyuZjuNGjR8XAOv2X4BfNK4nnKU/0e80aHD+Qfk/AflPcf64Jx8T4fO6HfDofDt9x9R8kkj0 PewzBY8mGmJH7PxDH8k75G7h6j2SWY+Sm8+NrUriPolFU4ESiPuywqY19BVoMElpaMGJiCE4V2TR 8caIov43ZNTSw6ROMHSlDSjMtDXeYtVMOxgOJIwpSoespk3TnJpD/5lST7ZFTvnxOO7Iyhp72dDj ODgOtGUbM6dDnebjzTflIhEzRviZ+uaZnlqTerZ3JHH8GjvXU8bGK0/2ql086vpdhn5kfBj/g9x/ POuyQeBZIyV9sBO5+RD88/Eh+WFT55PlDB9dj9/1yfz/nSO6EN1U+6sIqwjPvGnrkbJ8b8bJD0K+ 9ZGKbKx//wZI+DZT9TUjT8jEJ8g/Yba40000H/RZd+yx+L8Db+PD0+5vh8NA4XslFS+ZxNBmY9X5 /zHAH6WAz1nFQEIRQOMAO23ZuPBIptHQfjVRH65AoBVKEVQoREOp6vzHR0B1papXtxnfHa35tt64 HDnKmaccRIHbIcRiMrgmTJiiJWbaiTIea7BQjEkIZ/xIoFBQVT7YeZUJL0BpWLC0EnWcn3q4bMZR ibTDlX9oCqS+2ommKzJibgcMzBwmNKisbbRenDgpz3335TlcVWLYxSr5SiMHOPL69zrxIbzPDafR NvCHCwkdWJYqRD/+R2NPyn+k+4/9DY5D1oej+f8t/Sr+WQMkLfE7XzqCXrOp6IirDzUqyQ9TXm6E 88/F4c42VA9aaISQB/lLe2J9zv7P7JeKx+WdXNeH4tN/9mF/Sp/pGtSsiEjFindbWqjVFMa1Lqb3 ww8jaFJ3g/60yUEJEAOG2bL9HU9+e+xzxr3n08sv5FrxRXXmtLyuHfzN99bzjhu45m8NEcs/BQtT Dzz2ec6PUvhPBfdedvSk+Zx6e6jjbQP1xYa7zVdhMv/ShWHp409cP1M0/UEk3TvupSvk6TkNeMVW LO3849/4py22PlLfaVwXyneJxfQ9IyeFdj1M74OGLoD3RnY09H02+/M+T1xryObfmk8rsyu+ttqT zRKOc/aJsefqEC/lplB1TBuQIYB2/HBpvZVNYFBtsZPxvtnNd1S3r7tPb8LaU4GlISfDk67OOePP Op7FwXnodhQvnYzcZlNdNXNSN1nG+cK3umUj685l9NH65tFbbMu0b57U86fok9TOYlBfN/OX31D5 8QT074wcvOtNkrbSvV/cgG1L6l1PDtx+ywGmRpqPrVStA8Ttk+RCSnPXnRXh5Hf0wXCXfEcxv05G 3Gh1GPb64rrs8rg6SjiOTyPNFnO634m9Guenqknpezg4aSOm67cbid1WU3r89+Jo51B753xrvl84 Nrh9BvrbeHfnWu/fOTqOHrnyeOH8k3Oth6nR8byu/As56J2p2vHVXViki3Z+PI2iHvfc37CT1J1x Pm/gm4Sj10E01RpPe+uONa4hvdHR2jcd+d72Ppo5mrK6UOltNdkH8cjYPTol6+AvN6G9CHze4Y+a /oJfavrO4skL7GLpL4oYdcTkOQLv7ervHr6ciDu7L0n6FOyf51tOPpCOB075MvKsi9IDjJs/WM1Z z8WlTv/Ykwj8RWWE823tvd5uvktebX0+me5UWqp2J+tR9Kn+WEBKGlF7k0EM4g7uGg75PktSVMF9 35ta+V+t0BpV5oyfzyqh0x98f0c85Jwdem2nFm0E8qqqsb+bWEW1dIfGaTuSVZJ3Ha0+up7/+Saa E9Ee1IYgD58cZCD2ELkA2I7P2j2DhvrDy9/lt7vM9IwufdD3EPgOPdP5fM6jSmVn863tB2LI0Y0x SZSvzlrriZPMc+64I7Gcbw10fjOeuhg2tYaPuxuuXHPTWL8Xe1njvgfw4iCDPOU+LMNrvHsLvMQN B2U1gjXW1Kmupn01NUaDlkYyGu9D8pWnfJf/Eel96BDgBkq0xEySyUX23e6eOMpG18zUrW9u8W7c 8cpwxzqZ39ddfcaj6p65zsXipCjvzOPNvcj3dmMMFVFise4waW4VgqKyRPMToyl3aXRnFtuVbTQt COiW0ZyVna2MCFMwohinGwefGeHXeHjj1dYbet59muCpUtmTZW1KX4fFSC96xyrMfik7DwNQZaiS cIWqTCI2peG1dI3y3dtHIDJZnNwalr7yZa5a/iHTXjepEDuBUQgLGhqLkgSEfAARRgReF+V/HJ88 FpP/S6n0HYqA9AODQdREdUax1o3djsFDwmlTRmLf2h6XpPR48beB27nug5dTHgivk63jAlfRnVHe IVoFKHo53kGadk/GCxd+b/JiBXKCvnmZRiTSFmaaKuemLyZcg/7Efv/R9B+wQl4d/Ep9VK0YgyHL ES6Kgxi1pN1l3yOFe19zdEnzOOk4Q6Wcp9SUqjDDI+/aqOkSX+5/NPwTRKsR/GritawMlTVECZAp Q6lwv98BkivCxtYVrIlYxP5zNjSQ2s/zTT85pifyCbmhJznN+8nJvDePT0ejCsVI01NOe5um7ZT+ toNNJVaRo5HasQUA/YITP2OOOypiwGxjh1E5qeYaDAYYNyMCZVH+A4AYbtPx08/wHtkHQ6Cc5b+i w5PRvrGZl1Ilx6ZR9nUIn3P7QN3c35DwQmlOA3H/7RSEC+4QiQjX9v80xZTEhSqgPbGqXsCRggHI TY4qqqo8vi/ZttVFd6yHlb/V0us7H0dsmIj+Qfyxfr2NpSlkVW8pZZe5y47HBbyzlZbzzm6eHEQE To1bERpsbQfLKVtGB/YP7eqtQc3NSUwmTEwsoxNRI0KaTJEcIV0iS77O0Bowxy2lcPqeAP1boHcH giy+JEQ+mFD1HxzboaIbDEP/EokKCvxPv+nS+jCFdByEVX5zgRpYH3DNnJlXAM2DNDCvwT8H3XDy JG0dHKUOap/1HEyrwreD9BSzkGRpfiiRD5EjfyB7QNKPdudrxCYjT2aDAN97ckk/mlAolD9U9sdP YdPaTpO+aT3pRuskxSbSrNMZTGMPnyd6zT7lG6elv7SfAm8RJpIn9pHYmQELHAB0IRoXvV/QuD8n 6fcoQDESRrbSRi21mpTJpRFkSsQmTSVatJIkUqtItNNZEpVa0WqrSIqyKi0okU0VUlqNEJpossto mllrVtJpNFkVUVpaqqtTWtSi1WrJEqltbJSWlstkWWqWTUm1sqpVYJtKVUtJUpJMhaUmhUkVJMFB NUSxK1SsVZWUIVViaplFZSlb/dGyHqnWU8liqqyJr5D3lTUTtobV9bPYxitZ52Zox8tjqRsVFhMq HvwfwhkLm89FuhZcyDTxIXMS1pchKKnRQiWRYMVGlsOUjCsYfFoglihdR+A/rNkRdR9g0T3jwggr 2jY8yRLFcDeCz+6kxKOlf6kL5KaefNg7YZDxhQpZGTDc0k0h2TBOMOxnTZF72Flna542cSPAaPQV faY9KSvWkEQ7xBEEnQCnMMkRU5rG1hGt6idLDYWHtFe6JP/RZEDI9cjyiDCdB5mP+inYm8mzcnk3 fvHSRDseGzzylvVVln7cx4+9moP+Qw/n4P/LXDNNgcuCGJo5MJ+R4z/J/JT/Q+CTdf67BjoqP/5+ LY0B/jITeVdF+CRwiPZjEetJCj2PiPJqR8k4acjZwSS/IPyGHqLYAhTghieP3eP4D1Drc9A8MPu0 CdNEq31mHUJIIS/P3/1eS7jo+MyhDkdX+HfP5dncWB+qAiEmCzhSOZMfQ6/BEkd5yB1v+P50lm+I /jOkOh18exM6DIbijHYes2eBghZUh2A8UFeHuxP4WSOyVhSJjuIfyf1/3B64f8lcWD+D5tjQYc08 /7lH+IA4fAFZiVCBlZJkmN8UGzctpZJLZUsiQhJIuQKPzA+MMQmCBqCqGZNm3x3PZ+l2SZ0bO0SY sks62zcPWs7QTW0wpqUQxMCrAjKxwJVaFVYSJWAWnSESpH8HZMU0RKmSY/d5of3PCeFWQr9qE73y 6eCI+SWKE/EfyD9Dy3o3TQlsf3N+Tca1vez0/jf8xocaCkMcB1QGvgPUGx8bI7kPnfOrRpWNK0cm zdM//x/8zbeOc9ZPrOqbMNSB8R7A/zPa+w393unzbGnyz3kiV/T0y0/xQa/6R2gFhZqzXR6AyTwe Me1h0B7OeazDJS0xUyVMm8JDVRJszTbbb7T/Wqj7qnJ5lcl653RrkcWy9k3674WRdaTRE3eeazI2 o8jZPPPH7HpyRguxUULkDSIGYwEUGIYJJTEAxtCOmd2I14QNMhHYtFHyUpwlBZjNqYrFio4Uc97W 5oVvclCoZQyrCmQaArKqKMZo1QwMGrGJBp1jOJZo4nE3m9RvYporhMEMKcajKzNRBoYkuRxLqWcE 7M4WjWGOyIYuxC6IgiI2E5mxyG0gm5pkN3RnJqa1G5vWN1Sjgc6RouJ6GlBNoTEHIcGF0UURqGHc 06E2l0waIDY5hGK7k7Mtbw9jxyTZarvRWMecRW2mA7iXGRE0EmySg7yatsMMuhqhRg1QGTTqhRKg oBkoaWIgiNtnEobUa33AxU4c5nIcIQpXkqKqypyODGLNGGs0ql0ZGtZaNQpCDRrBmBiwaNLQ1BWB SAwNMHTJDCUlabTBoVvsnPZs3bnd1t2Qky26OaPHOWlbDulClVGRoSbSDbFoaArTwhwcBiImwUTS sbaHrDTslsY/+JdP92Gx5DN2C5RSFSZCCWxPOnByMetSBkW763k4ScKrtUxOBTFNJpk0rBqgUpwm ni80+h4qQg2FDEYMwYm93ULZJbZsOPHhvubmNLqxYo2UYygIsxtg6J0SpFTgyDCg2ZmGFGsjHQqI qWKBp4LDK+wojBtmNEXITWCYvSUYFabINIZBGucR1JHcvSvIGDpNwN2UfD2cvLLM2XplXZHHNUaf eRcMg2GDEKDSSbHmauBFqKsaPana70XffUV3ROJ0FCpMBsIQm6IEvn/p+m/tPxn5DX9jfDN/Qa7+ /od9TkSP8IvrK+Drl/IqrxdGE3f4iIzzpJ4f9EAhH9wJArFSk3adFnfT/SJDv9AnzsZfupfa+650 5Xk8pw+Mir6V1yioRs7KG1rTu9ma3MbEsYzmtvIT66GcrxtXaSN4jUVMWm2H5Nfia+eULHmdhUVk 1GhU6Y2V7manmc+dLiE9JCHJ7L3PU62+csso+a7frlhWocPW77xLnnrE9MOuzg14/H6ms7+KIJ5f er6jvrzVZmjT0cV7jPgfwBdk/GxCsXQ5t+f9BnM4Zx9Cr5pd1XkaQ+6sffx7i0ODNtEcON6z/aRn zSay+aF6X56c9jHMNN8eo98+JFR65IsRw/7kSyD8WGfj6jl2XsODNZZg9q67v5GSca0c5+tZWjU4 sEHykmXIvR733ITghub95RHQxbF+eKaaF+U6WdeFKapyyZo2a0NGxfQnqRc2WrY9UEtJa42rLDlj TGejsXzMttsPJThsrSY9EAhBSV8tC1GcVyH7ZGejUhzQyAR4rYjbQiPRxrxrlrTaPG2t5FXkd2hk q3LWsZ28QBCCeSZ5xgrrfO2FTTWEZPKzrX+au6QtnaTnRtNt3ENa7ZXe+E85bKmVi9mzz1tAxptY kSTkLzLrmEa7XnoqBn7I33wnv8BPieX6w5neRq5R+JPWGi/PXqMUyNpbbrKc3Vym5VTyuRGNdXrd 5pOxCRrCrGGba7bEbbKXVj2JnJkUcnJvR7mTi/cLMKQIk2iNZEQCJlJA/C1EZxdafOuWE0rxYMU5 m7TdCsNhGJFRsxyNDck4OE3R/iow2hvC6CCYgeAxH6TQ+PWFIdSAcPJR3FMQwMeBYcIIgF/AznVT IbjO6WNkTRwVNSNCDibxg5N5o1IxKthOEBkx3HKbSTYNhGpsOEmIEAgiCSTBEcIXTm4ctueOSXR4 au6w5zELIcV75Pa/f32fHM7+/UM0Ti+Mo5Rg+Ea5aP1plm+2CkqvsZxiE8WyES7B5p/+wQwcxfWk DI/YH5yedPrT8OxWkvU/OpunzDJF5bMNN35TTdi4sxWGz+V+0lYrErJHU5sb6RalOJ+1J/MqqhkJ +k+mngJBxgPrBdPY3n69/r4Qe3n6+1vkOPJHr5SvYxAvL3+8ziQdqQUfzv9gC8Fn9e/ic0uQMcx2 M/JOQzM/soH3H2gvcagGkaJn3QkgDFz44xxGDWWsFrad7g7a/EnxPrxt5THBpqoy/DhmH8fk/tDj n30s6NZzHFzRD4662joaTsENOcFQpbOmgj4pMzJDAqgqCHZMm18fZBrtuL6jrW7nxNkdkJUZtvTW xAgRjliNXaCL5g/S/QXtFLIiaGWHLlnlA2oTq6JMadDe3CiCbUco1NHiAcB9Q4YSSPHbf382bOOa NpothIWiVnhHJrNZq27uZ27nh3ORnZzzx5beDa2Dow5bPI0NsJyGSSS5oSQB9pfbchVwzsZ4GGq/ Z/V8ERGrA169+bbjo8/VbOunghI8SySIJlMWM+A3j0DzEfMGHGoyAssmwmAHcxM4T43bSGE6Dkz3 ThC9Zs+by7N1FW7+/2nZITanX5bEKu/Z5vR5I6WfzpE/lEz7ZWk34X9j15jzRnk3/DNExkUthVTt VI+16wJnNZysp4nyvoNtR7T2yxCQeyRps6I+l3mvVmTtdz2yBzVjqhF4BkTTgxDKYhIIFCjCELSn pz0jxHiXiN2sSck7ZpIkTGKOAbApnyZwEGwIcur2zzZSqZge9Xg+p95Ys9kbGh0aTTochWT1O9+d udFknseVXmaUfUxLR2urYlTeQOuHURmOEpjkO4mGjkSGoqwR4VyWTtTwx5k5k6NIYlVu/FuAkI+h 7QD4t3nrn6Hs8/Nvae8n7mhSMbjfH42hL3GCJkr0yGmVhe7ET50+Vyz1clKlL6qSBk5JbHtF5gsg 7C4S9zLy9ghXihHT4fd+jwQVEwIkkvxdmlRO4ARDY61BJ5oW0K/OfgUd/lZ9S+BRlPacjQvJqmGL QYiJcNIhWcGgnGXcdCjGkO2H9afMHzg4dmL8UfAKDVj622RPBs6KcLI2SLIVP9YzkU9+KYhHSZFG H0A/3YdCIEiBIf85KdrxsyGfa/7T9Y+L7Q8wH1o7fF37I/FSPR+pnMO1yj7Bz+vSeMnyLE/gn6H5 Gv527Pp+PI7Tzvn1Bssh+J5BkTnF/VT+in97GQ+EfM+YmnYWOx9LHVWz3O1NJfb6L+xPBOgv7V+x f61wvMSRoLQF6H0A/RqL48lLoOSZggHQ9IEPwjbSPwcY2/D/B0tU0MxzpPLHpCWFOmtt8y1OwnyE 7w09jRYiPD5mJ4tYInhCpufuwVH44T1u/zncHkPvEMVE5CY+ibfpmjOaZkaGmtkqyeTzIYkbojSh iROST/ZOvxvW/2O/mkAkl+CAnzrZKP6/wRAEEANWUhJcmQTCaSyT/DkHqI/DCj6U/lfuffTnCpSf fV1V738Jg0p7JPmH8odk2hN0rx9cmJ9FT4J7WJ+2yRySvMqVR6vX9TX8Yd7iPwv1T4R5us/I+u/r 3fbun32khvxf+pD5GNuFQX7Q/h5B/FsxNiKQnlDsJsvIg1iVPChKQIhpADSAHURMKqtmEYN5hgH9 HhcGsUSJ6ZpYRVwggQPIiYnh3xAJqMciE6XcB0CiY+WuV5vkc7hMQ0PBaEMDNFKMPYPLv5g8Gxmq oPGpIrkDgoxtsaKjELYFTO5kQdgocaMXB3OahcmkclBnI25sYomorgYFUQXuMZGdNjpQXTG0MChQ ekSVMR8UE1AwluOU2dU7FmE4VSqLIVss7NOF5NhDaqaKMUYjikU4zuGIOyu0qdu8CiKCtMvDKhRa HgQgTwa4VhSjQhXEkp6ipHKxDTgZC88TEcpHFmZM69vRvMYqpqNiBMWQoLmBQZJ8XqyywIQkZoQC pXVlX51A6jnIyId0hRQeCtO08Boi5wJYN5JFe2UezLjMwWjkXYRiKMY7nlG5i0M6F/j58hgdLO66 qKsQGgYuAYVKCW4lf1fQa4b1oKm13wrR9Izt5PXmAwYKBRrOyzTo4py4Ho4SiWluMOyFEI2SFiOA vZBM8cWOiiglppIAUSAUnQqMH1iE9I94M9pA0vCwvQUiNI7vQs1FdLrTztSzJMmhwJDIg5FRBy2Y 7uIkqUxYjCVGk7lnfHILD+TAOKgYkAzZQzv0aM2MOExkV4IjAoYHwASCpECmCKFVoxpNJdmm1QZe JoCHYzwNrxyt+L6lAzTpehjpEdKXGHjJQ0MwpmrjdZldsSqxnk+96SIIvNxW1tOCSUPSPBXvcCwn xROAxEQBw5betnQM5Ech0CiXdWHLXbsGKpJcnUDBoOTAuiE647DpA798TZS6xOlnuU2XdkrhKHe4 lf+TXBU5N8c6RVO3W2TA1Idk0zR5p2TSTxhXFO9Rzbs6WQdkGyHTDRSJKJnYUPdFSnnKbUjQetpX Mn0DBNCkAgZavHBbFhaBrUwSurlrJbBoQcDWHf0VSFpYQvg5BjSq67BEGPt7su0wwYLQ0+yMMEli bEuwMMXNcmiOpYkcSwnIdHg5Oqc+neXEg8qxv5tusOsJVjdkbkruG86obbTidOXXrK2lN3Rp3am9 XmyEdylWYpGDGgRByGIlh7WY3fG+LldmTSQZDKAzgZAg0UOiojB+PCEkjWlqk8y+PaBvxEizIQGS vqjV5IwOL5FlaDFoDBqitVMzUkksrj4mV8rKD0M8vZ5YcRAymRRPE0IC+akqIqFHOCAOsagyFmmK Mlo1mAuMkQ7B6CC7aD0aQRdn4SxeWuwrA1tQwYovZEAbXZmbgNoDuSIuzvUmeXYq2xj5NFMjY8mE 7LITxodJq4Jxe55cTuaeumX69ztteJ0MQWmJwgLRBCdI+UQON8l0OxHdKDoTQASErdCSJzykgjqm 1VbcdRjNQEwMCkDFChhCxBKuHJGBibLDIPoXkEVMQlUtBX6NIIA5JRg7UJwWzdsbNqE3JTAITkQJ GY9S3VA+EnUSIphGTZA7G9CQbY2N3FDW8xkjUiMOA0aV2RBialHbwznTnTxsTiYYG/ApIDXqmECo 8Ji35m6vZiSR2PIUNrk1D0QgKKsvu80CC54JFIjH7Hg12xaO/qesKSdLIj+sDhiZx9BaOkGJtk3B voGhQgDTE0I7qwXRoN9/LxwHXPjREtJkOpk3nDg/KChsOo1o2C8jOm0rGNCFqjCgUowfC0ChzUIW 54pKf65J0cxPfY5S4SDIrUnhK6GISScMqE1LJaqjbDwyHoQFbMPscrzOuQ2rdTR0mIyWHhNCcnRH KGQYwPnRo0qoYAnJ4eRPXZyH3II5RYG+XfE3x30z0RIk0k0yJEkIQSESTnM24STRVVSK8BpXc2Tk jdO6OO+m13UorJsYE8U4P7ONyWa0EO0qO2ewMsKfHb5x9zteuzNcsZlWttmmlKpKKFKUTBwQuAk+ Obf1f+3RGAmGksA4ZVLg4sMMQfTsOFn7bcIMDsUuNAdh8AgcIKHIPS1JMFE0BoVFLG4FAJMIRwUo xsDOSSuDBhixv6ZP2M/B11Q6pCgw7oxLCdYaF7zEUN96iLS3VVpci0mVVncbBqg2bimwhtp1Gxpf JEMTDS1hg0GvBrbrfJydbHKRs4TsKTSyK07hwp2lJtNjeQcqZU7FlVo47TLNNN+11TIPukY6JTZ4 WMCjoL3tOBhR0eBiUZClQycA+2BMIuGbyQY0g6GicjkJDyiq0spRUaO5cBiOgZ3GFWBwTZG3Z2Ju 2O1N02WMKUV1cnbySNsNCsO+Z9TM5GPEjgbO8w5BxtaVLfIfblLBmocnC8g57QIwVxODZ3CRg0dl yOgnzZMTWKJGDIoYufOIYmUTSCNKHJ7AkNlmh6IV43DZE7k30aXd00XBQ8ecDDfJnBpIGLCBpeBi MVKn5mEQeFoghho5q8zfLSKn4U78IQGGs7Xih4EUhYVzs5NAULqonwYUA0KZSqOP6VmoYRVJK8wq DwUWAtmOEhwpk1EkIJoDvuBROTg2BxKcbKQo4B4/+Djp8NztBR6dB82quT3tKxLR023B1G55+feP UQOrgpqkZPsUmUQo9E10TxzxkEqNogLfgKnU8DBFmDbq1KUdhIRJcdowdUmLDhIZkW4+361xSS/L U4pfXXH1iQaNptsw0bcdEbBkO67Kvm7GysHsSDtGIKRUZUpGITklLdJcnvBiiDaOICsmKliKhOjV rCDdkCcn5o3jXJ2uxVkd+51+DLKrGHHfw0mZp26zjg4PfHAh4HgZ6RD0DEb64sLDMliZhmCgpHDA e3RRDi8HSczqeodJyeph+05nFE8EiSOAiFiEc1I4WJ+T+VfV+DMue/3P6WZtyiSBfy+p1c/t39O6 f9pBkxG8I5WxS7DVyjaueDDjB/J5Mfofyli7GHDsnqWmFdjuCET8ZUlqtb5pCMv57SIOhm7Az6Uv HizXD4qLryrzJ5utq6Mse8a11cHd2/XEL9f5fCqjdcLPE5Zu0e7OmakaEM4RGYvLsY2tDPfFsWdl XIsrQ03TPZxJtnSxBVRZZvMtiMoZ2RimBoVw7apXLXLRqp2VpRyJTdOF2jdZQd2EbUz17GuKy2Nr uzBs5YxrKy3g4fas4YxnhKe21WrQxvFZhI/IfOJqmaLm3qT1zjNy2G012dpaUJFyfwQYQkgCO8/0 pP3Xmj3xYVx397/JU8UVQ/CKjhXKtTXPFDZYwnTBtejWmseh9hzzla7jDQymoq26YQ1QxteKzhYQ 1ajLjMo8MKq0xktLMQadMhNC/7FkuKXLtV6rly3LTa8Mr48OMafRjLOsxJhV5njIKowXiGC1ZVXg WnZQtr4d2WBptjB967vU2+3bjOdJ2aGjlozvCPpqdTQysZx1Y1phhqKd+1uiQsyTe4axwd4t51Q7 HENMfDCMds77gV9hraeWC1uaOcvZndrT6aI+XydXB4TUgw7vXcmsi29lcTe5OoKDEHMeEKPUibGN 3qlTCGZ5kepSV3CQqaFNLIuLX3w3JCeN5R9H5ncbGsSVUWzM/w2UcaVbPO84TNtYErtKdg5so7aV WSuy3QWJz2lBs97GMOxuUtrAnUQpDaY19pKudjDr6EQQbhTxaK+uLYVADn26xNMdyZR8TTubalVU 38eTmUpfgebw6dXGEE551e9h47dU0k7/stOPSkSfDXq+crBDU5WVOeF87Dcdv78Nam9FiENnZZZ1 WWQ/JlV+kh7sWxeNdjWykW8QKZ2yDV+tySb6Hxr8TCOevIw+LgLzZ2Dod8QnJzOGB5ttnnZ85TdR 0da4m/DyLp2+t/qvIDGVq1GdbjSh/ft2+il3B9ffhznMRY9/fb611PbPW9vxwsLyfYUWRKRbvNzD dvP4sDcIs94wMNzPb7yagCiQQgHiPGVGeVIMe6d3kYk/UISifMiMmRUnDFfzSkklCshFOoSAjRSg KdpoYFUpFShctOxpXKbuTibNJjZN1mNhVKlVTRElyU0F2HUSobDBaR0+yV0mFEUhhQ4k/yHc/xeb TKXSNOXpElDgaICFUNis5URRhrzuBve06HnoJ+MTWi9zoCmck29jeOePoPTwJjSJGJG0iTPdJzhI zRCSTaezExJNlGkiabKKqRpjBs0iTG7doqjoefxMHcOb0xCDzWRGnV2MRjFV5xpzUrmorwGkqcJW KpUbOhvFTY7UUjUDDBsVVUizRit0xGI2O5wx2JORwNk2kkx5zR4EDaDZU3CrEmizd2EY4ROoyOwT lLMLLJDAOHB9r3Y3lYNlgUyYkVZJRSeINkGFgiCbAsjCHUPMRxCOYgRmq0KuU6KsWWyk3CyDunVw Ws76KkERPCOw7AdQ6OA5vI0vJFBbVNUdqy2OCcpCIbG5tHSQxyRtEbIRvkkY2YSNGnh1W4y4lTa2 y0lpbFR1k7GENk0LC2C9ybE6zQLuKfMdBzVgldOOPWTBDC8kobDqkWCXfAwkZIsmFmdhNEZch3Qw VKs741ITImxjm7mQhiQpgwYEXSIjAyPDwO7xXgdYeSl6qTovDz1N/T1s49lpEK95j3ZkYLjTFrxz WivrJx7AN2TL4e9xUaCT6wYScIScA+IMHShLFE82tZQiNTZ8/z7g8CG1jMRZMIasPYqPN331dseh 4PGf+HOfKUSf+fj4aiRjuSR8Uqz1mHkTxQnwh5mELZxlyLEsU6hjT/wmGfRudRyglYgKrEAEI8FF fwSx15der1z6s0jclODh55Ep+B3T76+UPF550hKC2zldVpTCIWTsrQzGrNSyzvWOPsJzkSJ73jfY ekenKsLB7ISu9I6bD9TdjK+euTtV1hzgcusckdRosc+lx9nbEatJdScmOOlTuJ4zHvypRvyMQSjd THvm787yeWe+AED+5Pg5793/GfF+X+H8P8DNmrNJKqx/l7pIPa7588EZJPqfgPOPmPkkfin5DoSf mWSRaU+liT6lNRpprTWTPtTMKsqRQ1izkh22HT1iWSJnPpEie67m5snM3Ybew/yrZo1sclGbk2lj 2y3NmttLGzyA5SWCSSw3GTZvTw3bYTNqexrdJwpPskD7dPx62aef5Z8mimRiZXadwaFNkSn2gIoj mjJMj/WON7HBUpdNBg1vhJANe/5rpvRk/WhARHGv1SqrSg7i8UKl+w8HocGePRCA0H0c72ZsaoFj SKgQnfi2SeBPDIQaxALcTsAXYipxyA40DewpQYxYBiiiVrdPkwMkOBkYgQyfPUNNHZPoiEA07Q5B IYowpc9oeoZm0owyLfKmhctMRaiLwlo8DM29eQcnSw6Da5LoY1iKKHJjQucuAvKAengfOlSs8Tig UdLNtwhBtx1IJIlk5UgS2Ykpl0YYEDgrEjBycjhYMggGz5mg0loHobBjFFTkYRxRKE0npwdkgnyr KKJpDXhTTIsARQwwQ2R7HBtkB2wTkFCzhIT2ghkeQLRgEYvGBUVJwTtbm9jvOR07bMj7YXXkao5E TcQQ5Wx9mVcFcm6ZNi3dgquDJ9z8P2fe+77Pv1vx0fb+San4/b91PtwXcm8CLUyd5XnXS8WoRiYv G8aqFs3fc3PzPN8T3Pdu3+HuhwyZu2I9zmxjkbo0jxNPiNhvJW6MmpyQ5nwhucJuSkUWQDEQeAwd DCQyaH3IcKuhQoB1SE4Quo7Xfyd3kCPJeBz6rlEORXvHWLI9EkGZ3FqhsvqXQVOhRCAh9rJfnJIO kz3kwEc4gsiQykRYgsRlHyTt9TpNIQ/j12fy3XR3XuT3Tazm7SMpJCSXivUygQkd+ohVuYwspFJa HsY+SVo1Jla7bjocGrCQZZMr5mb1xbFEHqAYq5IUtx2iGPckIiS1NX6lp6pFo+ZjIpP0qJ3JVxcA nyJ9C1f/uWSJ624+OfcaElLCKhanw9K8Ydte85dpFH8+Q6z1XvnUf4TPAhBsX+sSokIwTPHSTQcT y7yGohcT3BROQ8Q8GEJDDISMWLW03T4NXEJ4WZnrfqfRkMzMmGSBIhVQ9x/wXmQPmT2B6BTzCCHn mGIWCmJJkoo+XtSTxbg9c1DhI4VE0j9BYVUqwk+QQ+xhZH16mkOu8+eA6HV/32SiwLiSOU5bxfm6 am8j5A7Hqe8PYPl+gH5GY/7yY1YtJbbWW0s1SbSWtjSEmLbNGktbCWajNaxIBayW20RILKrWZkjb 8IthwTyOE+5j4tSVXWDg9sSHKIOaOCPZJ2PF16vtSGZUsZsqY0rTUTRVG8PPJzEniSTcnnnNxuvp TOtLercces8O7webJbLLSAWoJALAagREIMorIKEUEyLsc2b2bzeCPCwiZJGmqSSi2uvkPiWGsdXo h96JIeCVPvmlKhkQCBP5uj64TxOkPYxDwqIjsEqpEgHgvT/5WAr8R9qHpfMCnkRBtyfMqGwdP8pE QoSj9/+JH+L+1IndEN7D96sVLJJZAqgxSOpHM70770kvzybId2KdxKLSrJM/gwUT6TShgor+8ZRP e+l/AoO4IhwgbUQuJfmjc293Ak3QPlLCcx5CyJy7khwFeT+9ddQybkBjL8xAmYYRvg47bamW0j0z 07Y53Hh5zRNrTSklpZvDOk+nuOaza5H7NbpAwGtDg0QkCIQGIpWmxkPoqZzORJzJGqRtJycmtJwl Rs5ktpFMmsns3HGbjTfEdnnboR3RynbT+KwpUj0D7FJHmdJ51g3+Zs12ln98+iY/7m3huxln1aY/ w+VnySudTS9jq2nkqQ/qepJN5/o7d3Niw213ajFNvkNH4XZwnYsK7WT0g9md0ZU9Y+QnshItPSPo 86kThUksdDzk5k9eIP/ttsb6ayRETS22fsnulsSJGkaWSba1mLNa1iWShIDEAch+Av2u6/Z7h6g9 w8hX1KpPasQasQfQHeVFFRTiTz/RY9ttTKZMTrb1x7+uV6buTTnJhgZBxWFVNG7WzVlnVmvSMjjU 4ItMSSyQyA8goNjKozg3Uygm6SlDhtxDSVYmxWqa1UYosxZHG2hWVaxNpwjNStwqLG0KZGxhpCo3 bEjdNkk2SmjbCZCTAsIw212sSdVWwdKcp/7x2YZUjnObl2FJw/95u4ljz9j38UPlLMphRi4e607O bEJ0krSGEqbuHtNZHXJ+rbijPvz/MNNunmRLPfsppgxuEjQsTCPai/xqqrSCEWKqrN7Ldm6TzOqS RNt6cdh8vLjzIAfHzRJHili4hIYkNBiEnbXETu5bIb5wzH1fTG/2o2UAESUqKD/vOr48I63YR/S9 Qpr8XkqSB/TJJPGQsH+ebyfN9ArhEdZCOfgEkeGCZKpspAaRPaD+kJWI4P5Nh+M5Hzn4ptZ3RsjT rjJJnypolkB/WesOT4AMQq+kDAO1OgU6Zf0r4fmkna48mzSQfbf262x9PfNh61NnFaNOPsmrSCbt w+YjIOI5CjEhwJQksyJQqcLuyMIgtAxH/t0Wg5A1UaD8jZaIKWDClBOD4DCmi5lQsimHGCgqgK9p FzCiBS7Nc6JsWuCbpMNEyGEKvB2GkBhycJNQ14W34zsqauAdct5gqcE4+oT7j2fUUWu6YEKbCEEA YHRd7x0EgtwcEGo2oP2FRBZkQY7sdl3qyujm5DTZtmJ6laIaMgQq0g8b3oS7qC2MGd9FGMQy00pi juTtTuTTcqm7k522p1abE15ECGoG0aKGwaA0jEo+5UYGPZswZ3XBpsMTKnpWLga1Zx58AUMS3DbH TeoHJQhBmMrOYNuJSQBgwijQwbHUO7vJEJsm7PBJOgwDNxgkQR+gkslAg2jgjKIILwNPSkbLkJrd U6cG3Vjdydk7TkZDsbo3GzB94bh1CHMWXkByTkuymMjBO6unZi27pCk2h3xxO7cdyOQ3JI5Cz3x2 b1uttw7rlm7Y4tnXPRjkW4eR2k3ISbIqdXNo045c7yDXao9gGQr+iF60OgOeYtIQJzCUBySspr26 WMLcYBkmBA48l/wA0BXA/XkOULbUdvgd7O3kGSaSPUqA/isjUUY/ZgejE2yM1sWho1nrEnmhkQ9f yPwKn1QfMiPlPqiDyhEO5AcBUdJQ0p/yIVTkfUZsrD+h/0vrfreHZA+BlMzxuoyYNLHxe4h8u/o0 bNxE3cMW2JVmmg9qDQhI5YhpgSiyB7iIlPUjDAgfzn6eOSKe9D5jg187N7Tq+ktUc03CQxwM+nSx Bot/DyKUem41pFKDNhI6M/YYuecFfxHl+Y58yQZMGC/5qnQUiwcAc6D8dSqlA9yf6qAkpaBB2Ew9 HVakpEhqYOHDtHTb9ksIHYkwqnBgbYa0YoNaUL5DHyB5UcblhbgOIgnuGG2dfGaCQYUFsF6E5SUa nKEg6JTXTxOn0LExFSjSTVcsV8Lo1LXFOkiuov0Ijxm06xB3ddUyVVlcp3HN0OTRSjV7smHJOfYK UU2c3k66tUnWFB6UYHsRUwPd2J9nY8CB9gsgEk0ZCvKGCSu4xVh12N1VElkn4ZtvONkjs9UNxxZF KilmkSoceBxpc7m7dnCbJqstrVtEBIgdAv1jKOjQ0p2Tgwx9Q8CEQe/MCCCKl2EOoet2XytwDaQc VJVUsQbzgmz18RvTES5N9k1MQ7ltJpIjwUWpJuTmrDYQ9QeY73zAbJJ6BClkhCZ2IyKVmIQY04Cs DMRGYAfeufZeMbKMqgDYsKKxMI19dWtaKBoGk2h1SnaaateeZyYjs4+G7ni3CGgUpRImhphmFCSQ SVKW3036rnmfHTSCTuduSJMhYyZE0wjTITRNNDWmSaSINGhNCab2cONMhIQkttoyWzRiEsTKqqqq qVlkRMsgpbBYswiMTWGWLFiqqqqqqmsizEYthIttGmsbIWpVYLEsiyklJIdohk6G5k2SZzSbngrB 6WNRVvoNQntI3nNBzY2nrK22WQ7kzd6rZkncLFSVXawSGw+tWRlrbbCWwWQWlVCUakJYkmTfFHcO Nw9e5vuPkmJJ3yWJ6G79KbMPNEG8++j5/8fEY5FPOMI+3o5p712PY8w7CQYYXpkUHMmJN07cduXN DkU3Rx3G2pJInxvOVciRHwocOIjFVEsRUhJ63b6CTYjYRQnSQk7lEjoUkH3TzfPR8kv319Nfvn4E hkP8rH6zR17Ww5KlIp99Z9xUfcqVXJX/RjDsTwEKCkZYAmQSKhiWEilVitsjWtNM3XMrbWslTYmP yJEicbQWy2rQmhB429KmfvDzPWzTfW2x+l7MD3r/YYfK8YAe9/oQE9x7VQ85PyEzIQIE0Hvo0eY0 dZzPxuhVXvQUi2RIkzPgltRlRatZhQoizIi5AiUALipCK8xJzmQP98bT5FhvPKXT0P3vzvg3bHBE ccp0l1BNoghDKJFjBuzxhQaST0h4IbuWWZkuQJsEoYSVQuWHGCRGNBESLKkUrSGDCSCEHwIqId5N i3UDbEQWIXRImAStGNvaSMdMlqyt5p3XRbtdbmK1UZpjZhjGiq3LvXanoiCv+eTwJH/qdJOhUdOw swwJ1TZhX9j/Bp22MXlUTEQjNKYYhkh/gNBp0iUCQQrBSNAexwFUDmf2Z979r+Sa2aW4255PzOj2 ntf9Lhp7XxKS3SuZpscOG8RqypNnJpn/muc27lKhVWKZ8Rmi4Op2BOF/LXg5f2v9JJS/RXt0r/eK 1du8/0H8GaP7/9DfOazV8d+IF7RsoTz4zhWDOznrOWlNKGVHXiw1PIhUy+Yfo5pc4Dknct92glDZ Q2OiuN0q1XptOe2r3vVvqMv7OH0Wt7IG1z11fP5X86KNb510js6eeJhObh36M4mNVdPoI7/kcdFI 3GoH8vaeHkHPiSlsmhoytPdLf+JmMDAMhp6b7HG2kbvzg5aWfCcypvrT9eMtqq2X2FYctBXy1kaw kPMa8u68JUN3sGeziWaPeDCnG9ctJXxitVJQnCeeZsXLuN7RbRs33IX2I75bw0cB8KlUpydoIiAH BfTaP60XfVXnTyx57vlWhyM89/r/2xCTXgnDbDsxl36lZfBXXztVpvsZDF3JtsFnzwqFt3qJfENA hnopYgmvfSZxpY+utvSU9xdrrrvJOeusOt8Mdb8KOvNnFtmc92+Eb4GtMk9Akw6wzzyMrm180QeZ ZQzxiMwxDvSkme+JfAbSs8OxZDO0OcXHOvW2HOHdWvJo6QqWONfIfzvrZNV1Xi+Tnqg2/aPPYRx2 L8PDxTeVvVutSyc+HVBzwLzEdo9Gn830aiH4s4T9wUeBny9Qed2i1NGjzhG6dOhxTXbFEwe657VU k7L5qz1lcoZZLOG2B5q2KE16iPQVqXo/dvrZ5vnBvkWkb2s51IglJoqUzw0sH8ATVnwwZ98LxycI BcnTdNPx6pjzNx3KN0OcF3/Qif0AxMkZYfVRSiT4pSniTUkGWNxDCZIYNKm2kyxnJba6D+NtrRhE xJOhMMPmqXet5Oe8oz+AgX7KcllyPtSTFtWgNXhaxPRBP7Dz/kH0RbAahF1U/36/6jH9MH0yfcyE FEK/37EZ/3Ru6HE3nQAJgYA9RKLpIQeSOOq7+48IRhHo/3QIrzi6ZKfTzjWPiXMX73vO/whGyf5W T2p8Utddds9naSYeRkbGg+gkjPLGyeP18ZT52kxoDo/mVJ7WcDecXo49qkXWu731FY2RFS1jfe0s 4utqsbP2LzHNSRDwXJht0heenK2HuLOkZYloZI4JEikCsPgREJ/MteY/5JRuiWWJQafHHOH8EGNd ZZZRTuso6wykewCj7lM56/m7LnEyyUIvymKjS/cS1+JWj9fSa1n458FrF1H4vu4zjoAQQOqdlO86 uaY7JlNTJpCmuDYoINUMJCFkFSFhIVBVPRPzT628vFk37vT065F38pR34+0R1q5AdOr8R5zsxePO uaiUKEcA1mp0s9SVXP2BbiGTAbLLbK7tI1NZx4AEIMFlUXIrpgUztesFfulGCWIQJREastZaiAlF sxvr77z7z5mn92S4r6bV+m4NbTWPoamtPph73ph9qT3eEOPt649AnmklsSSZJ4jvQGJofWIuPV7g xdyO5JRgwxQPBhebHks8/Ruyi99x/b98ieab5CcXqzmmsQWTebtxG8OsdudY7dk7J03/RfotEd/2 4mWaxB4VxxwQ/5oeONnUBu2DBIY5jY45DBD04iH8j+Wlieg7AiG08EVO+yS2D1vJPc0nah3BfpVI hl69qMVQOp3D9JGwRuKTBixbBkpKd9kj73U/mObebTePAVA7ZiTZGnZISp0V7dMfs/aYehYT97Zi aKVNlNYaRo1MMGTDI/yTm0OXpx/2UxZ2kkLRJ9YgnxaXghPbZhnsjNGK0ZA9D3jlzwAg9iyxRVUq rGTh/5f+K6ORunvn65PxyH3fd9+cBzGCW9DGEkQf6gc8lj8T5vZ/cbE7idUkfvj80PzPwySfyOiS SHoUEjm6PZ45KIpX/bmFh976GK1H0vibNfFpk1djWFLr5TYxPgzyPQ4qnySgPDAB8Rh9zG7qdAfs +t5ByfyB1GsOlx7I7oWdGNANXRJdkdwwYwCAigmFKGDSzEQyDaUPx/95/tCgt6NnFqyCa/aa/wn/ 0PcqkdjwOO7PKcJDSjOp0QmadG7yN08nk8PDOxjucnDRMhonTAHMlT7WJN2KpXqZMVPJNpMPZMn1 /he1VUqkkTSSSRHtsenyZ9X9PnqO7HMX4kgeshPL0YGloogihkTsnpD2JtJpJUiJWoYzoYenRhys yqVNh8B/ObG255iNBGuROMGkWIZkJUf1JZCp73WT2phkkYD7ybyPQP4iIPZr2PcOKGhlpRKIGdE7 G5ER6zA0o7iQL0kIkSvBKRDxVBHVXzAsb/LhZPXkn3LJ2HlMfnYhPQaMWJDhZzdWxuK2iN06z6AO jyOrrTXDCTK/74PxP4Rfp3HYgGIYA/YfrT9gGnYlbuWsKKTBOpgXAR8hDSiGL52P/VCPfztGZFWY NbANNSQZBFlr3Ye0q6bGJonoh6ck/z2H+Es3zGVJJyKU+k5Jg/diaQqPYUPpbjCfffnDm7tJBJ+2 Nh+ecfmpCICKIAeOtRP5NC/zfuFBeH5v1G6I/XWj52z5SKVtG/JNvrRqrCfzI/xPPP7vcfNL/cCH z2SRzk9Ikfx+YtNjQTsSLEcn38ehH4D2qaUE+B6AcOgjBgkmh2EcToT9h2YUSMPKIMI5Tx5oyCcl iDqqG1k7KgmxSEVSZRJHrV61JJyUqwh1Yi8M+xeApwdjyfcZgzZhs0Z4MIHI0RJTk5MPY9omjeTk v+cgmFEKRZhmPm8B39fcdtmzMzqUDxCA+0QlF6+QYFUxVVc6W/A+2TYfsn/qPOk8khykb4ORyiYH +apB8X4ne9zEOrmn4/xx8c9xzk/mT907j50XP2B/OgXVB9CC3R/Uv7Oq2P8yXqGoexcOJJHwGHg9 aekwpinuZs8qge5TaoTmoz4LPbnzfgSUpUnonFKqlKolUklX29491t8u4entVJ6winILDDDAwBkK Y22MotrBJnkv2lYikijoD6/OIcHcHca5ncdiqx9uKn/3f0HT+boPBV5L7+0U8Dz4obUEmiBKUruZ FMNa0al7cMUiUHUVQiYEKEAQiAkrHS9z0oH5JfygdkzIv74xyXt/XjUT43SMslI7FgyClCUhGglE 69aNCnQg9ohLEpSdj9V5NQzC5+Ab5CRsshpspVKiWzTSREE0SSJ+ZzkxImRFsj+B5zxFmlkREEnO cJJYnE45bliz9euQn6zVfyb42hxDbIdOHDVSooExJNgcSyoSDoTC5zUcoaDDFgRgc3EIMiiDSDIg 0hoKgsQVGndYISG0l6SQbRCvlzAVYaRtoM1iEigqpyEDPHg5C+nsRoGmoqFBdBZJ+cC2nqw0gngV mxiIZZchiRLM4/Ln/dXsG8cHCo20T2n6Pvxj/2n3/B+KbfTKU+KZEfuSR65kiODvwiE4skCOxCf9 5IST1SD4nrbvYqhRUHKpIyJ5keDtQ9sd0SPuKfBD/m5IP2R6oV6+w9KIm6fG/G4Y+B/e0jEREkR/ HydJ9rmmJIaRjk0t0KT+jo3kyzZtCwxQZFxyUZUy0CqltVLaqX+Mw/vtLe6SfB24+DjcJaeOx/x0 8aH6y/eXJdjGkd1BQIQi8KqhjOBoP5BhXgw2Y/nam1bLJwTtswYVMheFckKwSntf2B7fyfmX93xo ov+P8n9umCIC+ZDoGaQhe4/ToiXsQH0+CUA+pzceM0g/mSF09rH8AxX5aU18uwJH5w3DaWXcdGva L60/cdP2H7kAsj7Qcf5ECEJdEuQqsWDccijE3nHKL+w6QiYwh7mR8Xh8hidOx93la/g97PZsfEtk 8dFGCPYErBPVt3qKd3M27erWDEwxRVI/Icx+B9wCwR0wGhQ2BU2kCihmoHwdnMHoMzjY17MPta1r baIf8hHa1rEQPgHqJQT+zD+lkwNs0STPwOqtFZEmC0NSuwhCERL/lcHZE+Mt9TTrfQOywkLKKbAk aDHGZimjbWi0YxrbRMmgj43A1oCEmBmSaXI9hPDLbcbm4mW38yzepswYljCDJ/0RItINkGk4RAeK oL+QaMGUy0KNj7kpYOkpRqGSqjCMAesI2SQ07GGTgTMvMdKhiQqxZMU1UmmzY0pZxjE3dvbNlKBj XgTRXUtGla2DbTwY1uFpBERa1K1FKKp3dznSUse3ycG88wgNocZZlTEg/bOljWtaYh2IHicAjfZw 4k1AbwbKzcY7SVyLLMMao5FkRbg286qKzOg2zahpKqiKPtw0Ifshx5b4lUUuWEMbHUCZaQrg5YuB ibG0BVYsajKyy2d9m1GqH7v78JqOT/vU0jiUyypcxJYhgYSJBiRlKxiLYViKW0GxEZGPeHLxieNA bZGIoPeCxDaKUqJDa21i9m5gRkWDuMrS6jKu2yAjtMQQxRg2DccRHblMY3o/7eKv97w/9ERD6iLn uQMeEpehndx7GakVMwovMZE0aZCSOM0UpYCHsaFR1hCEOaSw0QZQIGiLOwRNvBEEx3/8kbU1AN+W U38SKEncYDMIGhDNsazIUR8MRQqpaqIgwUQ0PbHEnpw20ITDuyumE5FMVWGYC31EoxIw6tjQcD+T UGI0lFBKv4+PdeUPOXmwAEoUisURKUHIYmZCRcqBpQpB1EEHXc52WQxhE0NMNnSIEJmIRiRhIDGv aLDcZVwhDbDdNWZkkxohdChA7DCQQwyxQynoVIWDBxIaGHQybwoOCTHHJ1GxmGBjhvyKigysHCNa 890zz2zTMMo0jwz4M/9ZJ3yAm0V2wjEPcOzKNs7AyNfEZQreilV2K6rdOyw9FNlhP2P7//98P/b/ XhyUOJbqLKwk6yDTFBFEp1mBhkW3q3W+kWz2PU1CmkaRJkmk2kSbjZvTiI7Z6S2AtSajtbagcbNa iTeDLkakUQ1LnZmHGxv9Z+NP5YoknEiSCF+41qScMVxLQEGDhodDExfcOP7Qm0QH+M/xO370H5WZ MkMyYkzJgIzuDu3Yd25t3bhnduDR1u5zEnSSTmRw5SGn7YNfztJ+R+o5H5jw/afvEfwS/QC/YEXj 0H8l/R+1f3oN9My38wB/JaPS6hM3d5PM7P5n7hJdD/CmTGIdFGliYwTKXQDLaTGKFmE2xyYwwjMi NErhKQUhJRshKb6FcE1K9EpjAHIHRivIQjTMEYDDpD9UtvfJj3s7SWUw9JtuQf5xkNFyx2TQyLIQ yHywco0kJtI6HRgcEg/HtiBsSQSumB4lg2s2V0smnViN1su4xSqLtphZtJkDZjrS6h0GRYmCBGKY 43Jdt27LK7OcXCbm4QdbzwejwtN6atHWdKUk14Kbs4529S8ds3hJDLG1sWkgiIapmTnK/ph0RPU4 IYEVU22jCTSx1KMLOtBlE3WSZIbBLkLgQvBCJpSGJTCUAMZdiFcHpBToZJwQDcRf3+UHo1rSZXBu HLErTZBpmZZ7GBQ5rRrnD0SJf5nI+A+NHuH9ycf262f2Jzk+vxHYfXI/0jwfTs8PGKu1yWML7U9W I0rahyeXLVarWtiRLZ2WOW3bRvrNB4pZjmnLZLEabpRPWWB6YkSNoXDDkWSMZImCODIyBDKEq8nA ScHFPwmsllibbRJQiFR3OmxvkPjSp/4aXMi0PXmfa8MzPSNtMkyGjTRNkI2TJsjbW0WaEkbWNJpa Eba2xtFiTUw8TY4miHMPlMk3VPGVQiFdIg7AfgP8r7QDt3H+OX4QVoj8dVVWFrWEVFoHzCnND2fH 9Pyn3nztnzzbZ/nRuarJ3bVpAxWCRqbNpbEjNJIEjaW22ddGJWs2oZFsJIJEiMrLSFNKgRIZIi6O sbrbWtkWFrZpEiWxWtG0m2SYSy02aaIhIIISVZlUglYmhQpNLbbO0xyzU0hpNq1CoyQvadlfickY jXR4ORdNSXZkrK2KYYZsQVhqT/RhgPl50TdZoCZJB7ogsSb7vVjoxr+1rTaSSlbMiyMmKfDJH9n8 vHF2OKqpqsjuZmqVrKvLqriVUrH9xlR7Gy/4jA+kZw2/tYujY2OY6cJjtGjygsPxGWtMA0dyogv3 mKH2BDzKpxIiQaCST8CocDDkMGEaYwkI2B4ZGU34IR4GBvvaq68DEGCrNlpSY2YDGyJoYyAwoMsN zB+zYcLImsZEyWFsuWZDhZ2KYY4T1KQ1krUISCIxtFuYBEMTkq7LmZFbUnI5sE3f3OJoHI5p6WnS nzfnEMX3Sih64IICGiCJzOf9vORZduH2mtppvwIM4z1uQtb5MQ54yfWWHXhF4jUtnKcGav+ucThw kj78/DNh+qfWdvv1B9jX3knsR4PJQZB0Tu/7VVyh19WUWmP3tH7mmPhLY9/9ej19Qh2Kg/ELikel zCcMfie4N9naZllrTa1CJkJTRFshMlMJQTKifrva7DwQJ5Q6TS8uver9gf4w7ZEdUT1uaEx6/im5 r9Pu/Q7zy6IjxWRykj80eB+1Y229XvRo/GKbxAIUYdBNPnFfcgsGJ38aU2CARZhaZpbHwDL2eO+N g8TD5zxds+T9Du+afOyDB6g7ogcIlVJVkKemG/akT8DySQD7H/qxH8Tf7YgDhnh2EuoguArdzvJA I9FuvHzQfpVoKSiG8d/zUej8gJDtlgfCkCNpvLIys/3xnEslm2j96fmfHfK+76VjH8koHP9X/Xo6 SU6B972fnr1EkRRIVEJ+fMEgiiim1hk5f7HmniId6Jwn29R5e78/sPsbD7J/CfFPP/lJIfXRVS5m ZiMD55EifCE/h7B+P7h2J3JP9jb3fPCbn86HnN/V88Hniu/zZUnosD/sPeiT5SQsgJ29/835Ee+f fsh2JLBiaZO+H0NQ2NDgntPQvq+UFBXqHzn7gUFcDqIaGZgYWk9YBwi9CADtEbHDsi6BbbZvXbm5 Ox9+dkiRY9uOREZ5xsrNvSxtazJYzwJCRGbjmkCETW8bpLhpRQ2JyaJI2ch5kU3tOcLZuP4zYDZA w20m6p3CQ+5t5TmnMO1XLzBNf+ZEFiDRzIddcpPQV8RtiQ2VJOyD2fIS38mL+P7J9v9W8Tiv4WRl cjiqzD6/1Px/Q1NNb/xltEnMsmc8fulpxcoUH+D/wdBwbIZ0NFpUYdFNJywMaYdiI1IL265hHReR 6Fg9eCeZfmPQCp+gEnSpHfJQHejHXIw1N5UKIFpi2mSZNMb6WfHfZ8bNFhCJIYTjJlX6u8UFBlea NAgBWGFBIS8tGt+7mn3nmdZfIRt/2LbDD3JBvGX+Po5k/lsTfh6en0eZxERyLJJLRZYymiEtLSbS Wja0zJBLbLM0LJsirWrUWZrSWzLWDJY1bLEmpKq1BKWIPvfRB+L2zoInWILEfmHyyJ8UfL6fdxJw lFSiD0c3q0dxnURErEt6jDEolKIog+snD0HtPiD1EsUQkSESojMgMMrmkY1EttWS0ts0INvqir1d yfCB+Y8cdVKasMxBMhCAgpzztvKtTNaP8ifhU528SWHsz/zDJsTs4f6zYH6Td5EcGwYBqeHEssKT iVnGTLa4XdGNzUcit5hs2VYI1oeimNaNCoUY6UtNBAKF4NmzApmxpIKUm2NwKbIVLY9bejR63k91 ua1ubiXunHiPSeM8tn2YcnSbG2MNpsmMhhkKrpNSZIXTElls2lTJI87Du58c85wRKN0KQZYMyhKy yD6NAYv48b0FK0wyadWRo4WGJSlK34a1LRpptiaqgQGNQZBkkcApd4p1EIciA5LPM4IMHTIciRKp CFkk8FKqpiomNMGDBhBGGERyfzi1DZyOTg2UlLNouWaZO6E+0bSUhHho8xBnJzSadHAgPtOilMgr CBCDl1A+6KLEF1aomVO2GsPYc0jlRyk3SDeThehHKRNobQbHV75I/GORklFfmfk/iN3ZP/S7BQnX EOZEWQRMzOmDraEXXZ0wKGKWsUAkHKVSw5CWwILZZMdtuzspr57Z2h00D1o/Iii497r5gDT8faLj A/KUx2B4gZ19mB9x2AryGH/ifeC7H0n5l6ZZmEjxBkcECZQkIYQQ/Wn0972DCp+MIAwHUdpKqSqX eYQyu6zrHJjzbxm7DbPEAzrYJJEhYISJIWVnmSgjzAlEjdBRH4vwPKJ/IssstG7hORpQ+nr6CftZ ATqbk20yoJ1CrzAV4yJPUev1fc/JJ+a/CrB/rWOFa/RZMSfrYbbY7UQ/hyqqqy/r1lUWkcPvEvoP wD84PrMPnTB+fW6Bl/1vxMiM8CR7wz/j96WEaoc9Q3oWKgwMCelQX8FshH7Huemboeq2hGgbLLnq kSL7fSnmidkht+FYnmVOnvfDNE3s4fjMap+dzMedLB+iikh6LIXY1gvIkU2CBVoUxF6/jNoJruM2 YNIl+dJcBoTBHc/gG0PrKnV6ZOHcSEk1E2dG3RDb6ERjnEjC4rLm7N9ppBIq3rGfqE7hA/Oiin8A 6g+kBZXrgOl0RJEjPPP5kBENC/s5Hv4+AQEKaIRyqNrbWqlslZYrOOfaIHQ/yEKH6tG7p/Zsadh9 beyBL1Cj9g/b2h60UhBCFgqDxMnBynAkcc+d+lJpI+Uq2EVZDCSwyUibkvcCpy06I2+bwEF7Ekgj 7zBxEB5Zk0xktmHbnO1m0Z+y+0+77u/u7Pwm+hj+Y+Q0gFK0q1r8laNDrXPDSwYBD2IGFOqVUhoZ 1bT1OBHpnZpLQRAVF5NKHDGfb41ytMHuo4MDgsBEQaIQwphndM1rZQ1hOykGcE0QnDkIDItUDZTZ TlJtIXeJaNQeJipyNavFVvFLOlQ3V+V0w0vOZWOyzGi53hyulw1CjH4NzEqMhzpF56/5goYtjQYu SlW4gP36UuJq+kCT0P8mCSXQNBw0PYcI9cgyrGrnAhLWmdKkBg/Acducu11VmVJJownRBoUYQyaY G/Y3iypNNjDJDzve/8oe2V64kfVIexGE4LMHsGk+mz3wnnPgVPQWDnvAaD6RA60p0Jt/JiuEkh7y 7yVyRKlsRXuNaOElkPusv+LH+3/hiP/j7GOiOcosVbIdYmk+12MT+n/hP8n3TZ1VPBjDWMhMX7rI /qVyViijdT+t2BsrxNVVNBsGxg63LDtJDcidwrdDRVcJYn+zMjq2Y3VBuawmmzdzStoNFia1kI2q 077SKxY2SNo0WrrlF/4h/rMFNiQT/b02B4ltDaX+xgEYl/Gf1/5/6/6v6/UPgdHS9hs969CpUqpW x9J6d4vZSDndpJJD3R6SqP5Hk/qLPPFlaV2sMY3GGzJE6ux2NSFsj+Z2ZpexU01GThSTZYNEbEPY DIdkntSXcJODcMH4mJ4OZQnOim1aNjGFEjQ0VFpKfNi95526ev/j8NnzKkO9YjpWPFWrNJZU9A9B 2pHMOYH++c16buQWGIBunG/A5BBgBTm5I0E7H+3DBT4Axs5IGAOISrp/g/O2WmsTSWsi2TWwi22l sweG9EZvtEQ/jeZ2zSP3tv2cweieQ/mFHmv8ki/thGyNweseJTBC7ozqkQyokyQbadiSFfrSfsfm /bZ/d+En15v8W/dG4miIi1m+bbtjCY4gpgSIuOPxsHiK7AHSQs/j/kMG4ppKiH+YeX7JP5o8h7ak spCJUkQIRJJUaVWIRQK2Wm1MKGlBbbaWjWbZINJtRjVjGtMZI1sElqUbNazEaMzVhlMLWyCLIFk2 2RNt6f0SStqp++fzg9GNmkxRiyRlRwQqwGse53DQr/BA/1g/1jx6zvVNwlUf0pI2eWof3CwlVJ5P nR5rUlHyI7AePCr/OEjDIuABpXy9AsyMzVt9sd2ols/ks3azfvW5JIWbEWrK1ZE2FttNKVb+Ozcr F6m4qZ7JrTOyZaFbJphatG1sWZLMtLUpUvpMCO7T1lfGr9ytK0rFPpyZ/g0mkk0bFdno2DB+lUcE /CHmRDc9yeqUHoD/WsjaaDydWCSz3KSfL2o7ZDdV+gvwrLjCzEQIByKJAhgrs7MmmwlVK9D+qIer dEGQ5xv15vPHv/5n2QnKY8ClVZm8SGSN5kHzujANkn4iE9sLpmLiJ3MeoNsCbrY2TolVkruwiOtI jtjoVKJyhvL4OiAXaKU+BV1wyAYLsMQ2k0MRskJJieE/ydWtkSlSWIO2FCcFiQpomAMMRmHcWfN7 3xnYPe/gVYgZPp8Be4ZAGPIw9anH9Qoz/iDpb5rGywyqrT9oo8gV+UotZvrNWYpOfqdyvXd5F66e VeLW3jlJep/t/zmKraItUlSjGNf9i/n/jHgf8Ae1wyHEVjRp/k6k5P3u/PoMDghJHaXI/7uA5sRo 2MyT+V+PbLa8ufJLeEnoh3M4fvo9cif63uSB+0sH6IkMmSOkSZMiQ+Uhr55+Zb8L9f0flx/bs+RW gi0WRobzzAfJ+PbGfk0NpZFTaRLFm1mS2EQyTCWxNbAmWNLYwox8m1vnaE3jnTIzJZTnZk5HWc3M 4moYr8TJEbToO58q5wKCbCFL9k8465oQO9EDRqNWTaG/P8rnMlh833/xHCqfoJmFiqE2/fzcch5o Wh+VmP9rIbWlBpFDv0PY/lA/UD/ceI6NkVf+gogHlt2s6atCqgckLRpliFIhUSGFYjRpxFCcAnKo R4kysbGu2Q9Mesns+cla/oubE/ywAv+rs0v+z7zX8OU1BQjNa/0AkuEf3Uvkl8Pkdj/vD+BH+dxw fIF7l+mZ/xX7tvJAIyS+QjsC5cfDz/D/4fufYPvKqq/kdXbTZsqEyJD/xnLnzcb/RjBUJU8o+Ej9 /sMnb/BGkn2z8ZP+L6R+RwdRB+Do9L8gzFBMAfnEkn5xU7XcT2+v1nn9RsGxthLgsZ/aED0A+sQd VQKAbi9D70j/iOGOmiD6ktsGR9QbFR4B8w71DkHec11PBHwLB9XyUATkvIPQQfWMjy+0OmRyEtgP tF2nEHyybnqe1oqn4BumJiluypbOwMHBMJVN8MMhOUtgZvgYhpmomWZHxRnmWTR6cyCI/FyGnNZ0 LSHpl5kxtz1mjp1BMB/vzikjTE74HCPg+4JAmTBwL7g+COIo5XS9fJHuOoFgX3pzes5nP9UeTuTw gxynDyjU9kFlFskhh04voPODgaVlfOCSDARwIkMDMMDAwgYUScvlMFTp2e/q/CNdsnvdItRaOyGV OunWa5pMlxknyGxxtCGG7nOj6yHJ/TbatVSySv7WFZgv0zJM2muY6u+kn6Yj6EHM+pYURsz4oOn2 Jd4e9LcOSQoJHzAy+6BqfYLMD9kEQ227/gD9JVWVEsiHbE3iL9q8UbrxIpe4+U+iiCA0X2H2rslL mkxX7xX8BKCeuX54e/cmvTgy30FwK5xZ8T6pPL7OHJES+Xx9upzj8TZGR0PsEvsEC8gWSc3Vg956 o7xx8Uem+Y0YMd3p3M+vg7ugxISuK/KoSBOHRBz56Ju2JVcqmhZcZFmdLBzlBXVszpFSIYSLAoeW aA5bGnnOBOdbS0Ydt5OOsee27dwRKNoGYEIQHEFbMzFyNVvFmjPsCksEmCoodGylDQhujQaRYtiI 25yeE3EhN4seM03I9fDAFrNMo0isVY2ymjKGByhANQbllQdG6qDCMh9/CabQ0uhQKBtpTlLBlQ4d K6+ieezFV2bBvZx2WMmx0LxLiIU0aGDBDMAwo23G2000xUKXSYxQcZkiZFCREBxo9wyjwZu1kNTU RqbFRmy4wjd9SnweeDjerh6XkOGXoJFjsugehyAKLQ29EiSECT7g5vLyeZHn0ZPFOqYKtkpO9ZrH kbdyeNu5jts5o5r1lXkOdikqMaSJoh2EqGk03MJpK0sDj44OAXJIwdhcYHEWYMQ01p+LlK55sbgc bPrFqqqrYVcSYs5b/Rf4/tP3bJP6vwM/hf0lRuWcz6DfT5Cj/FlVW4X79ZVFoTp8QE8F+E/tX8Y2 j1E/LKqpD2fFw4qfEPb7nvkTiDxj3GnB2WPfOEE/7yxEVYSOUj1Sn9/uzpA6pVKdJUlTSQebvJuH mqTwkPt+D8P0pM5N6j0wpHXGYTT2wz5RPdeHs1XMNg+z0ig9xBEK+p8jr9NvIY/kHAxCcTf1HplZ E5KmSQ0/U01pYkNoxhqguYpY7X3mzdLJusGk3jbzG5pk2jmB7YceESqlS88mFuo2TRKl5k8/GmpR RHHvwHCEJl1GEIfmJE1oxDkOP6+DRaPSJIGGK1ETSFImZQbLwyJjOCIWHFKVMMFkXQwKJLlVUho2 Ft4u4NkOTlYVQijQaHS8miC44e4hhTYwwaWjEuDfFGaUNaioPkLVxqAocl2GNIehwAgyKUqB0ICg 6s6LwnbKPFt2rSPdO2Nadg2DFTRCaEniEMk1CokBplQofgpFhFkommkqNQsMpUcLDkGWdljZzbGi UpRYU0oRD1vZJAH6EHOIWzjuucRDBsCIUKZUlXJNJE6sCqhOrtaK1N26fNpzQ1BEQLEGixCZiYVU KCK0kci0kJiLJIK2SdqKel39hCqWfKpSKiV18z4dSJ4gCnnzqRK63JwjWLqKNJjNCeUYEiUBmSJw kwhmUqSmj8T5lV7zh6V7gZkglG6iX1JIew6IdXb3emLVFQWfFqTl8Ullv25h1VGK+3C++Sbu/hZ9 J9slmsZonM99jnWnxj4MWJQGaOiJNg2FajSLigMa3Zu221xl6TSNThlXJS1P+J50I7Q6uktC2mnU xpqgzkqRBhiAMBEWGFTTSowkE0DRFFgH3pkDIzQaKOzs8eYjyIoCSCmAkCV8CMD29WPqgyD3E5M+ fPeQRIcvrP4Rp+N6gOElkw9Z325h3hrc85vwCIjt+UMXwlVPytknx/qZIn3oPtnzQe79Ttfak9v5 HuPBj+R9TuEfaqqzIiEC+cLdEDPpPUCjsB+wPvKreIN3rYSfgST6Fkdkq/FbUfOST5Psvlvnv4P/ 6bHihEk7WIfMZZ/gM6jYxXJOg/HrZqY3SpU5bT8JsqpkqHa3Y+txUsZG439zJHwJNksdnNj1o8pY 95jU0ltXnXcc5I9D8x2z3Z7DrHviCiHI8b3GEsqYR8FeM22NBYQ4Y4OIMHQSaZWJTzbVVVhCeC31 bZsX1ZbffvvVFX5D8hhpDtP4EMQvxpKAJ6RjbPiCH3OKn4iXzH6zf27G/vXbX5DccE0fvkBNh0/+ YRowjGS1Yrjes1Tqu2psTKIYRUFSJslm3rWxucNkG4ca0n+tjsDSsbgrOGyQBAL+w2NhUOCYZQwx cxdzA3g0yhwRCQkXUkPx/SiT5u98N/h5PN+l96M+MiyWybq/2qfUUhgP7SH2xW7j8rfDmpuCneiB CV8pKawUxn6Z2x1bjpDpOUj9TaeRJ/8VPIFDfzWKNBC0npBT6X5BqYAYObbT+AZ2V3P6KnsEPS26 rCvjJEHnqR2wT+NX5vA4pLOPZqOS7HWSfMsLKT1fGHnTSn2p1/g5vRK7ig6wlAIJhtiYJ1H440kS GiSRv709M802+h3BDyfshkiT7Q8zh3G0kZJ83X0vKRJE98z2ZUkstGlosJZi2I1YxIFbYlkmCTK2 klRSYEhRhULoOZ4qpo3NCH7a9MKjfzkY/bHSfzOJ1en11zKdH8Vm20bOeUoz6eDgw2gYshGaNrFg TJqKBD0ORucQyXduxxW5vnKN7zJySlKyOmmWb2N9ffn7ZEck3bSafgaTnEI+oU2sxGWWyyyJoKMk ZDBZrBGsbLa2z5/jPqnfD/AZ5565f2tKb5q4i1cDLDI5Mk97JgzcSwZEPzHMDYkKaUDDBoxKCzIU mIiTMdGkC0MDhbCG0jQ6tpB+svZ4kaI9duWO55Hm9pybM20QL8C/nDXqeTeYWtvLaNyODy3R2GMf E8EajDAZTBV6yDA7JgYkCmXdNEbMjVSJw2d3/p6kT+VUTon5PZDwJMfgLuO5eZ8EjE1r/Sro5JCz A5rkC+4OOhzgKnu2EOo+K7TB9KwbCjImEMfB3NmlFJYraqKytWrU1N9oBImGIG4aB0SsyKzpExXH Q5ASGLoTFcqkDFwExYHuev9/0J+c/K5n1bmtkv4/IxTuQP0BCLEQSifDngOyH7ebh+V/53ENMb/X mv6owY/ej3L3GvFxNweL6eTnmeklBebqUQlIGiNuiagmz0IdZSI4PpiH5bIIqklSoEhKixAqMRyX 7MQRNBoTcbHIKUti35/YueIkEVRFJ7fg+UnEikKV6v5+hsalmCFO6SIlJ6/zZc/hmZpNJ7WH+CWa T0pymvlMO6kZQ1yLKrifsY/of75s1I3EjEbmnDcwx3ZdyiR7F7EIkmxjBJCSHGMddhRp7be22KNK edScGTavMR4B87CSeB+NPqaeoe6Qn30X9KyB5xUjn6EOoJ5RgwuMFgmBG6PhPAoSSKI0aiRppItZ JnpPURN42ktsiICqGChMUKNNODxMKANZBIOjbVm22kzp0Vha2LbRn7KG/bZ9wc9LKk2mIVsMEMoB uKsrgpiQImGIskMlSeAoOvPItScJ6YcTl14g80hOgmA+ULJF/2PmdPAIc+A6YxKiM8/3GnaT9Di4 IxIW5YwUB0vNaVPkIyr7mGENKLe6stUjvx4U+S7WvDkHJkJTCA1MaQWoTIgtFGLa/N1VpptfkAn5 WhykEFR3q6fPZax/xQ13jYxlUESa1lVRNJJ8NxU0HBi5180BBUhFOWGTFVcQhFRpgRiF2Bd9xLEg DAVYl/O9LSHh+1RLDwYdhlQxLENnRkddls6zsyOTHEm7Z6kiPKHseJWJWqvnMVUJ+PtRyFdhiTK2 YmKkv3nSYrZ8h0PdSP7iz8cK9k5nl1uFLUSv+aMoI3PvDs+cA9z/yO59G3NPFWxHsmWDBm8SYw+K cVnzyDtWHrsjPZZx8SdYpRHJGtjuPzjCdx8/UkPZFjn8Kv+Z7IfGdH3mMWWeOmnhEOqeUfHCJ/SO aYWUjnE3/W/o0/ZHM9P5EPmgePrQD/iZgRCTQvfNyNL+NthPEkznG7R+f+37pwfc3PlOaiVUlV9S Kkmjsc20I8yGUys1KUpkLRYL9BK4wCmxmC6IHY/7wd0gbLbbcl1mwP6gb/TLbuHMg6ALUYSKcwRV eSqNH9gesPFCDGxGOEg/BI33PNMSRQgTdbjMEQgk/E+w+M0MvmWRzaV8QfT/RPsD4ZdfHzgjQk/K YPrj3x99p4v1lYnKRI9B95h5ec/TCI8lXqe3WgdStLEB8yGIuDMIP/iAIhuGIp/M/j+o/eSp4hOU RSDEG5LIiWESLEkYyJ3DlBRcDqY83hvUXtESCE8sHKhLzgIYlDgFsRZiyZYESaxTw682UZCFidbv XjBVTMzvqI6NqCibf5hBDzLJRHsBNIPTB5fzJskdTzxy/DDXofkKY4xXyRM/nM9opt+rR39/X3im JFQB4OnTow0kmm9MjEUJ/91owoYGhkQ6RMEeFZShwvU1o0xJtVkFYCNVQEwgisiLRixkoI0UYbrr GNOOQlGwGKGtEepMdaVMFwnNoBWkV0iBw2Onn0eWaFi7DA2ZFiZRSQdPxKmAfmWlics0xyVOK0Uq NcNTks6rOH4TJkORVPwK5JptpKwxidh0yGodvDgbMxUSBlwIsBwtofiajAZWsaPQaK2kbpFBOlLi GPQ00Bpk0nEMpElhRxMIlFo1TR42swIbZaiDulievGs7IeHnbRnFnHp27WlKDAWzLZFgUIQYj/nB pZshoWhh/kSxGEm7ZlWI1DXM4N3PfVVXHE3jhhKcmXclVNo3hNQRC77M7YJZdTBgYom0YyiIMFBU YaxQKNGJ3FUhtIpgpgNCIBGLBgUQ5iW2zIPEnZt4m1FnljiDTuGFERCApgqhDTME4QqGiLIYJQqI MaGGsFKjQ0oCOENI4NRps4UDg4hjMtBqkQaGKScOjg1iVMGRA2RAkMlhxNYmnY0EDDEomkqkxbNg VNaZomkmPMImb7s22g3LNo0YypiKhPMlklThmQEOMhkYQr4ugwEYn/QejmdEVvxAZa3HX04LhHAx JYYLZroEGv5xpU3P4ODCqLn38oxiaiPpRURVI0hNMkk3x6Wee7Z56HpvCqqE1GYGYdjXVrKNrihY 1ZhYVM01EHmYw2lJjKUyq86hEMapibC6DGLAixPDPkpDSHJEYhZW6KgNZjMMSQhjwaSAgzGTZNpk Nos2jhkkHRIljgo/X/GT5LmZmn1EhLCdFdVRD0rq6szmdzNb72tMUZmMpFQbua1ThIZBolgPSmMM NhhW6ptLIKkYlIfJTZFDYGwTRTTzPj/mk/uHXnOz78diyCrIEIS+KXT+Iv6z4g5ftA8AH32Uz7f5 h1teQ8hwg8A17nCXCbTalcIDCIighC0K0z5DIhVNOEiWMwKlWkyjBimyZgQYwYyzl0nuuWZrYXfD I5S5y2XMIECWFgUFZHglQT3wbDsjgsFoZkdG7G2yKYgGngAdAsCbL7tAruocLgA4DC4Q4MC+v+dT /yDZDkKjwdAwI8QFZSSGS5IpFytfU3adrzMd4psZP4xfu/2xXCLKLOMVUNDKmUoQqGkQYKkZD8mI KLRoacEagJoEMB6xUSwuhwiHQbBrQsIMVUWRUhoaiQNJRKm01NmVGMwcMUTTfiJPwGJOTSuU5LSy 2VeGxypOiogaNMTBDG7pnhxDCR4TvJzUfxRvLpInzzxHFSO56mMWHESzxbJ9ukX2836XrSMlh90h FR6uUdCZKx2mSRWjRZNLc1gw+6ppqWMGRWzRVYaTF0SBmYIOCjGGhFR6FHx7d17VSuh7Tk7F3ker B14JI2jskMrZW3Jp58GsPG1y8k45h5hknqkD0Woa3O3k6ebTeO4256LBzPSzcsbkyTWaPS26S3k6 PTuz1enPbg5oU1aSiezgk3pp5snb148R4m87MN4IhdkNke0aJNRwWbwpNMTdTHk7IYOgATC7lSiR iSIk49pEOzCM3xPCTNIiJEmkhZbWJEsa0yaJMlktpIm0allrbQmyKIDhZltmXjs9wjSRPvDlEbqh qTBDYmpuUjSYcmY6kbeLZ3ressz5VtyltjJFM0xaKxDeM+pweeHZnaFrKpaxZDcyf2X9zdtI2SpK lQnpkekRnWXyGi/ELkQkZS5JgKZMbG7oXJHRqAMdMlt5vcPqtTU1ZHfa4Pd8xaKKopXLnCJH3jOS yVXRWFcSxjmyYFNkxpiRPDY2SpJLIkG52GodfcshVn1uiYT3wlbClVK/R/oPHiG/vJuRWZLbbSEW /lQ5GPzoHIP3X97tzpd+GSz5XQ21Gq0oKNHO7wpkA/hCBQYUBlJ4R+J9jWStUes463JrW68ZLZn7 h3UWSwo3yJLVyNRGDQFgkjpHfSOt9O3HIFIQYv9KxGynqEE/QJCL6fi9CgvyMkUsEwSMESgrJKKM BCq7EqNKowQBEIsyjFSKsMqBNmH6qzdmF/zYFsmlYHLSNqbY41j97R4sMi2bPGmTEk29bG/lbn8J 4x0232+Z7oT44gLIfx83300fXPwBk5SNh4Q+iMFA+7PrOwOF+bs04qxiYvkrsQR7SSR1Swh6FosJ nKfUz9U6JPt6j7X4EnSOViWJIHqPvwZqDhkjzLUoTy/tLp6INpMQ8LI5IRHxSE789EXF+Dh51+CS H2J3B4rOSSY5jl4ARLiqKOXZCPcMgBkH2khMjglkvykmDBoWJR7RQPldwNhDSwH2MGwacUXEmWaB 6m4lOhoJV9Chywtg/pBf8p07IaQ+9H8pwkJHItx5LKewDQim8qHhCp2X7vwPoeLY022bM0002ewp 1fiZJ89P8JEB7TxmdA6IPYAbgayCdkKgegVEjvElyyMDZGSTChwyU2ZqHx6xLW6pieH/K7b0ntbS Nm9WNuzzjjTU1EzeSIOwxFyIOpvUQfLDfjcEeDkTLwYKo7qkM5iomMEycg3XTvsajQCEZi0BBiTC xpE0mWytnSqlUkjdxUBmKGMqYs3AkGqdQYpogoh3aPEnalcuvOOPMnOE5w1m6UpXYWzrO5O62kcT sOd2bsTTluHacI2zI2ZQdN9BhrQDgybEURKBjDLZLbdMVtmhMcYmmTRnTchbRGkZ2jZ20zDnHNaJ t3OPUc23nOB27MRC4TKhkiYJLgqw4QLEK3cw3btzu5uJmsWltuJlOTbvSc2iebnbZ0x5PLN4szfR mliQmsMncnRoTCcIwlyRqZI6M5x2YHHEi1uWZccW3Ob5HhzSPDnJyQePDmk7lOOaeOHjcOTTTggn RpUzUpTUBNKETBqpzsJOcSOcctZybi9vBzeIO1qHWOcS5RnjPHeM7JyHFu2lk3OeLbOeZzmi1tHT dO7JbLc3bbM7e/BeeCTzZE1omRlbMOML45MadIi5CqMjhLb4mOgjEpjBztEkk1paTi2dvDnbKklg miYUsheDQC4bBo0OhNCZNM5tuY3uJnMtE8ZoGUUckUIccHBhWCWAJCK1qzRWy020srGmMoiNZLkR Ft54M3k2geQgeFBgoFdKoSaopIS/QYCfJDeSpE2cVtx7IWma0E3hRDYfl8XA5HUQ4DHIXo0nCiwk oEiP7s2QNIKHSMIIQyoul5pPZ3JtJit7remzTeNBbJIPWt2sWs8GhpzcGYQiGw59u6IGw6UEfIIV IUJVYgqJCNK4SYYTq+YfKmJJPkT9YSIbvBAfs+AJsw82PasOqObBqYlgwx0G1myEix78U6g7kU6B HwDqU7tPxL84YKejclIlI5oAft4UdMJH5ES9F9ZEXXeh1PIPO4L9RhI+8RmiAhj0lVMOf5jv+UPo 73+U85zVf70UH5nu/IGYDLkWHI1j4D/SqVUlYxI6xGec+iVBlnwci/eZ0N5MiSYWQcnGxJobGyJj ELMk+h5N2izuqTuv+yUOZY4gF0+ocQDhJYw+r/ltyJP/CTlyxO4SU9JJsQHDmIKRgEPM3XZdotgZ yGZqaR3xTZG7KpvYdZW1Q7qnY3jbU1E5F1Ys0Dujlnmc1Ko6pK1Hi5RkruyJlHcqGLJ0ijv7Zil1 nZgYUXasqnIhwIBaRpe3sOnpRkjYOauFi9HNPA4359RDiR2OpyAkJ0cY4dpRYP044BEO86N8DIdt Y9T8R1m4o7CJCSqQrBBAAwEiSoSMHWKPM7j1/pMyo6o5aMoP4i3kdOsdQUb29vFPV1pzMzoB6RXg RDuKSMEJTtJRNLpAiRlfLNKBAyp5oFCgE2F0F+oPY+0X3fSKge89iyWA2CQH6T+d/Y6I+C+Z+B4G x5oD6gC+Z65757VYqLZ9DPcap3YnfxNx2fKOw5p6Wko3nvOZZIkNQwbjUkTRGUEwGV9BKKOkIQdA wYmCMRRhGQJqVIZYGgsbxJpxD6U93YCf6xJZAhBJZmBRiREyGlomTW2REikLMiyDo/O731j9OamX 92vyyxzHePrOpIdVnYoKqlRVVKlHp5Sco+OPqOJCTz0Obkai8swWTk+i4jUdlh8H4txj819oR2yK OwK7TbkA4v8x/uVCp4nERMGDhAsFUGNCkpY9Hh521vIcLdk2WTc1kTnbY5zc07LapzaWFmeGWwRk R5g23Y1saaxNoREwSANmF9J2YoJsrJ8QvXgjwMGfYBx9w8wH7YT5F8REPaqsyFREqKgiUi8nyGpP btPofMt2xioqtn+Qv0DynM+GkaAxgY+TBNjW0BQYRqKsVruYsjYQIIaYJooMgTbf3Chg6GTbGshl f+4gdg0OIR9Efl+hSmkm0lkgtekn+sSHxpIfSjX0eo+t88nYacOBPe+nEE9hMh+Ue5+VXdBH3T8s iJD4z7X+0ssFkKWS4zRMTJtMLCGn7Z8h9A0/BHOT5n5H1h4Q+lVT3J9snB+xpDjqk8Z6fxoiopH5 Gux63CuIOw2RmO40RsskedSHHxmocc2Em8eX+2RzVO8wx6sYk/lx95/y5TSf5OcVuyczd/Qlj0/C doj547yRPzp5EhJOHv9A0sBQ+lZGZ7aM0KLDaKWzZvuPQ+Jp1Q+JUep7Zw4SYUspZTJIiiOJIJJq wGtJkfQGkm0h0bOXtVNmj880xBuskpJUJ5wshHmqHkNrYm2lLMJoIszNBKBDHzn+RPM6vRJytSLB JNMRUzZ5NxMiYls7YlbZ8bB414+sc28TeazFt4SLSXg0TJozFXGVMGFMYFFwMxpCJJgzF0rDJoTB WU1AhWUlVCdgoaqeHb8s9GyeR+UopcRA4lUJIFGmmkSYESkEIsRF7LKfxsjLK1IJlJE6nMMf8mje rEikm0ps0Db3RmRUVFKJFCUJU8u6e8pNnKy2PAKnZGylkiu2dpmhVSp+NOqcIIp4c0BeogYYiPQf VBEygqtffMaHZOyI3z8z2TDsSTipbIKuytis2yNtCN8UxsfP2cI/TGPurJEsxLRJC1s+OnYkkxM0 zRJNFrbZZrYRN1m4gltEC1rYRsk220Wxmltli20hLIsbFpbWwoyGiTGV2UB8yhKjuAwAaQVsJokh oaIaKmIOAHmqx8Qeg7DDD5B+3t/FDzm1TzfbydtjFkQpTbcPsVIeGohf/4AwkFsBkK4dEyYbCQrp KyV0y8yYJR/uGE8+sTYkhQPSvaL3EyJZ9EtpS3Jvy+ct3MH0jfNmBHoPWqP6Q5ZsPvH87j+IZDuQ U8Ttjs/EunoeA4h2EPzS2BSfhdX/k70/6Bu8Vew/oMZN/p1mHuJv8bR7bEmkf7Vkif0DxeceNkQ+ qQqYuER5vZ0SDFYyHnH3GoZIiUlqNRZDJGcKxQSgcJHCk4hTBTc+gdKo4JpT+9iIGBRTEhQ/Bt+H EbGGm9UoMGI0DSWhriBDDcWmlUw2nWa1EzFP2sCi3AwjBuLZCJBZHjEGkg5GlMeTJm54Ro6Vta2S Q9fG2wj0EjMIRAZpYynDc9t1hUkgLUVAWIiMqKIbaCgxg4NYsZBvuGLZMW4r5D2exWyDaSUSOabE CPFr3/EvzZ9kjueZ7oyfOaxFZMTGHvT0qwaHyyJ283ch/L5T7bO+RCxTaZUWGMYtTUGwmOhOSyJt aPIZwusP+z/Qd2SIfOqB6E8dB8II6B+tR9R/xJXxX7T/Ydwh4AiyETyRYkqqlTzJ89evtxI+HktF UhD5TsQhQi944JkyokNkhiiTCwQQL2kL1J1R0IepaFiBp+rGW2d4sHAidr+UySdzEyQKKR85tgaK pZJGiyILJ3kngQR7keMNAwEujmGHJVeCR0Ic17h59Jz55iEolIpRMgH3kGBMSazD87JzN4yaLH0Q /hx56WhyTfW3a/iRHzvAcfBOVJemskSk+dKkHwJI7GrGJPDmOhQ/P3x+//8ywhUyIH6j9cgM9nUT HIU9oeg61LAxcFRIrDOjdr7mkjeVYdW9k9zB68cYMwxgJiUihn3CYp3LhsdufTRtLNJksCQTTETE WyJkjHfFs+SwfqNI8Ug5/GR+6yBSkqonxyeonJSEhgw8vXzgYghl629cEfnMwnxdmtNCAZcKUgFP 0lFLA/WVIsbclS4bzZl2T7xHTNv0fa4Uq7NhSUisakfhYz8yf5PFIPJZJLG0Np/onEw1AfQLy4X3 nd2pjus/SfrNaD8LyNys2PsgRKjSejIVmAzjhE29D/lEkfzFNGkAff/IOTIddmv10/GOcjZOztNT x8+G27I3MaU0EpG6GmySLTtlkkj4CH02PnKTEsRVgiVKgH5UsT1z5p2PG2/G2/ifFmPBMizTW2h+ fEyliffe8/g/pHfPn/zI7n4HhGp9j0vrfodtklFKFZRSlFKPie/9zb0PEh4JQeAjCqUZIpgyODgU YJJko4rGSwpDYCbBIgS8jZmJhOji6h1E84+Rzf7Kbw1/K0dCtjiWJcEG2TBR/85HeiUXtkE0ioCn RCJo7JJUZpjvVrZRjiomlaVMMs7ORu0liYMQ1omGPAOzNLA0GjDJRFEbRzJ1pDFaF3HjADchwOgx nAJOywMS6GjDWiguEhxNJ/4Oh0NBSDG2OMMk3CwkqIN8KeN9If2EG70EdUFI8bB3OYRoHgnJDc+L 8FbLuUQSslRRECcgMBP4zy8ijy0GuWts/rhJkJNJRRcVxMVDr72+tj195H6oEyUE8i7ujA25ew68 W8GMyM9uMWXmne71VvuspUrIUM7DCGw7YOkgDHXf4eDyB23C+0/wPzdAoRKncdSmJ3KbhieD3Off 8z+1P7E+qPnn8qE6PqSd86Rx+RPrfojDl3/RIh4M+t7E+p8YrW7e7PbmJZFVRanGHJjCblBsOsDA ZXZnffN5F5HbgcEIe8D7HET5T+cwOYhCpu0winsAhFxFhKSdGAMSVzR55Ij9op/iqNpO/5E7Afam jt+R/OkPvLMplZZlZYSAj4fFuklJIIYxllkISOQkgjmnvkfZ7XHEya0q2/gdxP5Tkah6Ens1Dc1J j78/jOj+pn4vZH+wsnV9y/gZ6cd0d0g9kHpjwSPKFSWFNG8MWoZMQ1Cz/cEQ3meZE4TpZGrVGqc6 NCfysJhIbAeBg4r899nX3bZ8hu8+ELWjLw+CttwNxtuNQstUNSWxMZjMdhG8QU0aMubrt9Czh63H Z+77Lt/m0lrmL4odmXqlVK60yTS4ysS8XZW1VLtbFY+T+3xA9/60UnmfEebZ+KflPsHscnkEQ+6R HwiCpEfJ88OwfZPOlqRLFPnkFm3M5SQ/dJOgHzxuuSGJJ0GJlh6fo0vrbVNM8U9hCc27/RW8UkMA I1YwkC3SwH9pEX+JQXJIpmahogRF/rD1+le0FUDYlATkqHkqHdpRK80CYPuFc5oSG3XgbO7jsRS7 j5iSyQu9Gz6G2mhNba2EYosVs0hCPQ/7WH5L2hx+L9+YfUH54aDLRDJB5pXB4yT+anmgfm6pY5Ff SyJGqSnLIE39KvyB6PZ+lwj8UPkeL/b7hD7SdET/uesfqeqPS1MjCxSclPwrIT79RzeD1RDmKPoU DzAHiginJfJ5nyHvFDelRMizMyexjI8FkHIRNp3p9OKuJHzkeU/HJ+SZ2uJyczU4mJMOcw2fvmMf yc66xWtfK7+Is+Ve05PmPmbrKRKaiLZPh28/LvT/ApEUkfJ1ctElKWrKWZkGdjh1sTzaJn9lSdio qo8LHm4+Ena+aP6FD5R+KH1WB/sPhGp7sgm0k+BX6T7j945Tk++8oP/pSfyie1DIs9gf9Sw9MVGo jYnraVbPytT3J2STk+Qe5N6qlnyFj5FpeyHx2Gp1MR9KD5kP/35mwofcH7v3Vr5TdI3l94Etn8ur pBMYpWkE6boCROIQwReeuAE+lUlVVgZUh9eQ4r2PoVX5oTU2SX4u2q0eW2B5a1W1llVVW19GjKot BvYnN0NzCh3vJug8rsnAqZsZy7kned0+3cPnHqV+dKlZIqXGJhu3NTWJOxYpssxF/Fp0rRiZWMZU GFSk/hJJ851Np8n8X8TRumzfGFMYyZKaV0D9PSH7gN8EMCPTbQbJjWmbLMIh74skpUl2VKsDQqeT zpJ/EHwTTDEqpSVKYfQ/jT5k009+5wmjERiJWSnCcJsTSGE1Cw5yRO94w7B/PHMG4/rmHufOqUqC qPlJKkMVD3fSMQVRkQfr4c36fk7fSOWp5pJ6IlaYVh/GKVKVuHA2eZ8b+xMSSemex80/WHiJ4o2s SR36jWhpL0Z/qfzi/P+YgCEfV8D0S9xwH3G3zPgie47ofrTnOcftaDnOaDJmIeOhtOILcIr8AMB9 Y4rdB8uq46AvYgmfyP0ol+lZh5/YI09D7FkXQLMSPYkI8g5I7gP8q28EvtP4BySgRQLQNwOF2OEH iBzYWofAX5AXMfofWsCyR1EkeYvQPiMYRy9Q6Dvnl8btgjzD+xPieb4T6p/uMEoVEqpE0HjWBtPL UxNSHUxHt1J80d/mlj4N7DoNx9JzPZ0KfSVBKASIFFLHLMf7eiNNNhiZJ8xh4KabFTFWZMkB0Uml hN0LIYuzGAlxjagEVVTYECowFEstGJEG00IqR7zyMkkTa21ZAqoC7pGQxoZwiC2UI1n4ybMDgWxY YCRgdIYvYXQa6b9xVsobOCpBogqlyQwLFsOKkDKvZrB8o0kLRtEpQzEYiCygHI003TidHDkg4bsI pZELxmRVF6PHNvLaQlkSbRLu2tzlhObhbXcczqLS0k7tuxO93nlrxOUkLK0rWmt2cOSsqrrVpHIg dnIota5FtpyziRa5bcizLLDJYxDtx2m1jO9ZheZI8ddxyW3Oc6PPO2PLI5pDcztLzm7WiytvFuTS TbnU7brcd2yTOGJFWLrNnU0WWWLNhZznLc9HeKia1rDxbExVSimmGMZIsytpWVQGH9g9GWpMSaSw xrgHYEIWQbCLEiW29ImhaHIbk3zwyk4N9FPGqmawjujI6m1r0HedGjyOFcIGRBRhjvLQcVAwChHJ YiBGLRpJrTxKNNfw7r4lZwmhxRmBKUYRa3DORmpxOEicyhyrauaamlVasxJw8N1zgkDNJCgMW8Nk Zzcrh5tHjZ1yGztY5uUrI643Gqk+34J9E7v/yOx2jUTrsU/27+PA4dixCqnFjq2GG/Lll3zHByJb 734H7T5bu9H0ka1ZapREiVQkQspkFUx7pxByUqQWsO1tn1CKjfD+7fs/+PZ9AstOBOSkiubDGMVX NEXVR/5/V/6Xpe7tWDCGQf4Moxk537IXTChCLnRhj8vsYokJewAY5H4B9x7AJpfiHUJn6QO7BFWs kfKv5FJ36n1jduv4jv5SDuoj4n1NTHnjRt803JcP7IIQgUFGGFlw5MLJwShJIGAWQoQGGHPBnArS nNgLlJMNIpr8RQ+HM41FcciZHORTHHJs1tOCcMgKS71vgnE04zsRskGmQyHHG25NkJs5GiZxIsbl hns8Si023vO2Ws8JkaxkWemh2GiGraWHCbNxtZMbmTaTrhbbov33DhG2ebdsQnDtbk0Qejd7Z5oV epTmItu7tqp2k2dbaE3LOW5zu3dkwt2SJ5tuds8JbJeWt6bjHBIxaFWWklNJph4B2/pf7y7kckhf 0vYgiL/Edz1J1AyqqHCgmCiOENwvIZeH+gIWKCBIgRcNcJuRcIdiIHib/7ipJYgg2esD0TzjrO0F BMVEoIqCySI2e8AhmM4aMKqbKlNTBjGKibvFD8P1Z/sk6qzGUpiaNGIP8qZCab/v/8D8Qc9p4A5O zw6Deb2GETc3NzGMaT/vnV56WSWSx5mMSqifvj9HyTxkf61851JQ+92fM+1/ymRUQ4QO5MJLj1GC ekFWGAg3H2tbQfRukxJBo1CbkGrCMI6/keN8h7tRJEz4bNObD8bRt/gDPd2SQuu5ggYJsRyocgJB ZGVFt7rmI80507MOjrPX/Set5vWXrNZeeHbzsi3jTdkduORbTxHW7zzbmcpFEzzTRY8XPOYi0iBp VhhPExjtD8HsV+hUPiDY7WU2dkzYggWQ9pCGK+dwGZ0ObNZuZM/HmZW4rUssPqIfeY6Kn2L/OeD+ FQddE+gH6IAJE/1AUQzAq/gQ86+n9ZwAhPkqhoWPlcZhTEENg6mJjUhiSsR2+nazR9bHq5OOq850 ipi4a9tQ2NUqTaxdmH8vj+W+nk507+rtujoJZv1aaSuHfS6I05IncWYiUmFmIjuSVE/63EQe8Ee1 EhVpbWMRFs/ZcfOnNph4/Jz6xJ6iUikJRZSJUvJDuKjo9SDiQLhCqYSBhKdzoe0MA81NTzvgbtLB 6JFm1NQtdjJImDkY9ep+n4HRVbqp9pLO+QenEdC1eYkPmeOPT7BJs0yLRtpjWtqEQ8tP7B/gc47O nc4cNMRPesh9D5+NMwRPECIcoNhPLSikDmPNB1SXJbiQQO5F/vsnlCt397Dqp6Q7nv7FxLfYmhiY NaahCxiyNKesOI8uxDKiqlP7kuPc9JpSn9zDEaVH5TpGTvjdiVMZD5z4+98Jt2SwWVk7U7RjWWoA fQkf+GRH2B9QtoDYhNrDSttS3vS0PbbduTnZy7Pgc7Wm9OCF6Xu6bpJdcLRJd68zzJHwfcbjSits RiXCzCzGmk17McTUq3drg1sMholWhTEYgDAuMBM0QKBRpEsJ2P2KlTDhcLrA5MOSgimzBWMGLJXX GabSDTc2sn/PhzjhV6VOE5hLzEA7xgYZ79nwQJl0yPGWPXJ+J88k+ZJ7WppPo0g9yIpSgQoEUCdK qygbQCL9Yyp8fYbffbIx+6O46RY4gJtFVLYkdOWk+wSj8iAycSDyIUlSB/rBE8RTmr/sM5Af45/S /Zzpg+XvN9hHqlViUcPxnHkCmpLG1Ld69Op6M9TSQGBqGZZkiQSWF7yRJ9KSKrqOQbJwK4Ox+1/7 VJAHDBx6CJsv5dH+qnRIR+B1J0VJykPe/tk6mrAiBmUDtJD2oyfekbSEczm8+AdBs2kn8JwP57vF Vx8OUaev530ZtG1shURIP3Y4KsIinMIHrFS0qP3ICQiGJ+4xepRmUEYYhIQUrGaTLaMW2KwSMIxS lMy2ghqfhEfP5mzjbjI5pPmhEyIm1FNv5pMiHvWRrMHrHwSx6p1uGiySUshVkgpSUmg44EmSSvnH 1IkfrRT4PkLJ46P+by/U9b2vr8ZHioFLB6SSCxUWhp+qAKP7F5Y+xIYYVxkIwsOEUEUGIL7mX9ne 7CI0dgrCRT/lT1k8SYMYmGDAQmDDAyovdD60NeR7TQoYh5Gg0HlDSq0iBIifkJCGFm/UbzG3oga2 Y4OzMP0aJIUgxDEpBKMkwkiu54pmazFvWh2de2jDx4m5nWpiHWsNQtlFGEzJEjxjDJZJEbk+I/0m I+uT4SEcDmldHzpppYRFpNATfHOSHaHHahZNtnGtpJTmVO2ZbDn5fHIagVcxEoZJMRSRj3wegqF+ 7QbG+UoUBKx1YgaWRhImLIOgi7NWRcjOoN9zcg3ej4JCER3t0iQm87J2B+dXx39eziJIHn7I5pI9 j/TNH+d739HnG0k5Q/pfg1LPvx2jiEsEIMwDR57Aa3Pv06ZXU4GYtvJ4TOQ7LGleO2Nztzba7soR zj4PB2tGeJIkbbhJgEugBAsvqP9Me4Aizubov+6PqXJRncBf2zOZ8k9YuDTI+D3ETGqephUVpDGL vo+4Z2GjGlnvG8h0SJckZC/o/OOEEywxYeAlUmpHWbRwcufdQ774KlGmMT9GaWNAY2enjkPHZCZr TKM6y1g3yccQuNLimIYFklIocqaWhAgLIZBhZTCxyPSZDLeWDtwMZZjSvcB1i9UnQnedO3I7erqn a3cK6ORJxK2adtgnLxV2VO9+MxDtWBeDuUDY8aRRmGExkPPUjimAWUWy3ISBVUi7lNKIaAtGNCif 3I5tO1Dv6IHe7r1SvuHoczMVgYYtU3DMzODYeTCh+4/gOMd3FOzHyFwPQcPiESh1McBHcEE4sQqa HpbJvxicf17+Mbx6TlMmRks5OYz+tuzepZKjI2Ry2ybmzSxutX8Laa7qEVOHXhJd6mRU2jmQgYi9 yoPFoWowD4CYs6A+i6Bw6DbOV4j4j8HKFwk/mMUEMJ951hQlN9lEe5hUxCBs+bEeb0G1Fow5eRIz JBuMhYGZsOpVMOH1UCzhCDWKoM5Bi6Wkku6WQD0A90vbgPV4NuzzPJTWjg4ZYYvaxsOdgV3l4NBT UBsDEWkwwziWxRAiqlUjwfZPP14o5aPjoQAocqOaKBuvNrLzd2fF67EkzwuVNx3aZ4r7XIrVCAY4 UQzLCclAKAaDOVwuMm8Mcp2u5w87Nxo4XuZGp2KnTg2qaeHhjeILHMp2SyZ44OFSTtU6QqFqiAci 7MYWdOIHCOX9fGk8XC9lCjiGPibJVR8GDIol2JWq1pPkqVCwZb/skJU6s2a0iB8BUOCLdpHHBkVO h0PIHFFSA+SV4nAilHM4i4QkNjO4y8pluoiCWHaD5udQgYDaSCRG+I4dWQKKi6+zg6BfKXc9DTEr v8HZPSfPWTn0HNRXcnrPKSMliWHJ2WPQQ82nRiVzeZ2NNJSbs0smjfdjTwbtpyHiqJup5pjE0oLF AUURwOv9HhwQu7K+/2n76ew/C0nry0QkGpt5g69kqqmOlYaedebZwdmzhYdaeYSoNCywye+9UMOe DMfQn6NeGgSHYoVFlRRYIDGRMHA3iXHammpIoKo/qtFFGTHzGUP2+BiSr/k4c0dOva2+Lz8CvAxH mk5qg3NE1Nq1O8rqqli5ALDO5nKIRAmQ5PSTTNjt7HspxG0TyNO5s5O/IybOhVnImDsU3TebzRfa hkHCHA4T1xPf/zvv15u/4u7q28WtleFTaO11VjTiQMU5Giljex68T4zNbOLuz5XE6PQb+3R66JuE G/HSJ78br7SAZoLjw6ZOCmZ8Dg890PBE90DFEXAzjPyEISkQiOkc1gthsDBXRSBwUKFGNkCcRKnJ qMq8zucGgEsGsPkGBHBlblF4hydFBQYK3HAWYedRI+VpHkcna7VTZO45lFW1VaKZSrBeTqk3KKcp wryO1yboqc5jq4VqedzbuG8dEmijYlJMOU85s5lA1Q0svPEwgIgmOUg4c/w+jT+1DH4Mcw+1ByON oKwH53ft8FZdF9zh9v3CNe8F11G08GG6LY8yTuiGPAeck1BhTHHZXzIHcDnIlF59rG5703NIfFTf PnbTY5U7CzTOyMF8MnqTSjnEH0HSb2OCF9NT2SlO6ZSEzm7GuerftipOE8HFlc5V8Y++qcN3maQn NMYzgbO2eZs0lUqiqnztGjFGKb86+DTgT1HndVMTZ6ibBpOR1GCsQKHQ3BEQwIoFACisfoBEgZJW LDk6vIxSr5pI2a59Dg087OJvZkqxc4b8kVjbct3fYbLDYrPNETrQpSeDhNRJPKGJUbpkO+k3d0PZ GxsPIWE7F5DiGyhA8/IODFXehxNkVOR1ux08ww6lhdwCHdubE1VQMM0weCtN/080hDkf1b0BTYAP rSTKnGltIDmk1X/h/65snj2Orwkk+I4fa+7D7TkYfuTAMB5mweXp/xeC/th7homZIJKmIEonm+s6 wyvCIaJTKWv2WOssasjvPw/b/yNbO41xjhS5iFYCcgwf7ITR4ezz/8v5s56JX6N1jdje/630CVpV WqWltUtrS0LJLWr8SSJpJJI7S01tbVJZSlVqrYslZFjJZ+J+T7R6P6XQfcsHUAuqiu6yO2yf82Yb VG1qP8+YGrUmToTR68Ko3f9FP8Ifx/q4R7kaMKIj+t0Z2K8aOlarVNWNXU4h3hWJunPxh5EkfP6V ifGoBpwybNQ0H2Csv48A1oEjRP1GKjO5dbQgLA0QxLZmkICQxMOEJJDS1m6IgNValsbfCg09MMCk cBDv6au1VsI3MJSpbLhcK1OkkFQb28qz80OQmj7So3RKRzViDFYj8P09n4PJM5nJHojtexxnbWNS H/MzjJuySEkBIDzYRmHGJZZ6E90GMWfclicIqclH+6UYUkPGW2hu3a0zkk0tpS0xNk2ifgRxFvgE Zv39H5R8lPSHp0awW8dYtDBCJEUVDsYbN0g5D3z+wajcQ/VN5rsPyYt8/yzN2aDT9VVj8jbAXBVo 81mjGYpKKrY1zY2q1lYtWPTTnphmOP8srGORbczg3NlVPtSSCkGAgkwNMPVEo7djqXncx2PPOx0J YNoHYglQVP6Gdr/+LaB1bSMFpyyINCSj9xA6tsTMzFczbSUyNq0xicZ/dH9TMMDdjRtmXm1n+I/e mmxMy4X++iZN0wd4rCyaKaGzMnFIjjp0sw5drG2o41HGo1IMjQJ90VFAtRUVJpsaYfuQiMZBgiSH DkZbumMzMZ/VmMKGmc84NmsOKVjbaYwG2OjaZJFFRUVLFI45AhBppi/Kn64UCWwtH6mD8k+5vT9f dG5n7EHvWPikn2T5mSJ/2+vdobR2HUJZHWEdH5G+6HDfGtIyFXVcRBZI+Hzx9GT4m+mPqbNlU/9h gOwhNQNESiY58STm/j82brWek2OWBZRfULfLc7merbe7xvZJNEZIltJIkfbTkSEhJznD0RWGG8H0 iw2h8+SGp9VRrjaFe673UjcsOIcYhqLDUNYRtvcicVvI8AqEL5jDc+YZdkCSP1h/hP2/kB9CcHp+ ZLJo0TJ1jzx/K7nfa4ej2y2LkPksqpWmZ+TW8mp+Y4TCTXyhEOIg5bcUY9IZ5vMJsPoq/7ZUA0Pv MMg9cH/zPE2ZW0dx72mnS7uPfug+T/Yeb9XtHniWwpZPJE6foh7ODA/QdICYT5QoGBFWk2YZIYkk wxvkQ7XPu0H7LJNns6CkOY/MfHu1JMOHDkwMin2Yx8MKgTGEIONGGNKGNIqpUQ1mSSxpSTxkf7+H eqvYcgeHmA/CEO1zAQ9Sk67HO5iGfjjcIDZgZwN3sIQqg/GA7p+n8JGbNB9WKsFT8cOY8X8Ei0lo XeI8jnB+c2W9Xnr7bflZpIJo2mJPRnE5UMmGSuWaeJiFotSLJSU+PzvWmVFqK1ZExPwucq0D2vkE J+M9Rj+pP6jFEOR/QKyQK+c+l1afXZudyR8/zev3+BkIScniqvOZLePd45yzMxlQDbwGkSv2t5pR jRz+M+B3v+Q/IDinm7rD+x/o/K9u/8kT83Sfo9WJHyHyMEPMn80EeebI8EN5Ox7fcdKmydeHvaDF SHabJMhpP1HRiNPoex+ZttVPk7Y90m2SMBv8qNHvRB0K0NNpzz0sCp4jNKhj+E0YGxB8AfennXzo hzHlVMjSIaKxPRAH/Bw8AkHXi/6BbiuhHqvE/0GUAkLp4Ser5ZuT/ufBiR3ik8yYqK75NLFKE2Js 0h+In/2YkbKRKKn2pRUqYqficY+3YY5mXP+2ciYhpIUhsR/h5D8h3D6yCCpQ9xIOMqUSFqWmTWVJ usljsk21smrCfm7diyG0ZP971nN4NrbaAiEiR2uf5DJm7Rmm9Qfer6zRASfa+9A5Br5k3U6H8L3q /wm4FeB5HTB7h0j720AaV/ez66Y09AzhWkxzrnyGxK3tc5DOJxqPrRJGJpcAombEzbM2iMS1FiVE RaKbW1hqEALgbxEAMMGg4UDpbRVo2a4FwTFEjehlKDGNMJEPaIGlea4wg1UNzEwxzQkaA1CGsdGg VCXyYlmrFWJdEwyJT1v7ElE7Rp0j6if6+TrvDFKiyRSVkxDB0hZBkRVFGjsUsYk0kVtCuUnNHnne G0sTTsV/KzMsnwcSY/ZhlVT8J8czzHqGQ0ZD7U0EATGfkIYLWHDSwU8FMc2JtTbTNi07FOU55svT fBH61R/G0xjFVk0fyzh0SmzuFx/6v6Wxt9tGKnRpbXtfxthtMhhYVLIjITDIklpBakkjFkZCuZ4j SO52mJtGjtOZo7yjMcKKmyKL+nDR+nhc6+o2eu2yD93b++JI2Id6c8iHwn8xzDZ+BiHzHL9yfneQ dAs+LJEXg4/zoCx9p8rHgtUmWZSs9z75s09FIZFE39CZ9I+iDRExqapEaTeKKKLHokkMRDKkgp53 weCIPlnalSGU3HkieAsFIQypgZKwOYp7KPjaSZPyzKkyMD2OZDwiSTSIbPY+4+M0GGEYTDjFPg7G waVC1jVtmaZxicCWJQxWDAgxMMXHDk8fuenPRLS29LeNM6qrVaqpVMqmVVanUuSRLHJ3p6eJ6bj0 iSuW+2s8TxkPUraTs1yVpTx3+z9x3Xbn+i/QfJup/kV/UsSTgfYbSPsNx2d3N2q6SmZjkWAZ26NI xGl0gS+lDwAvqjIwyTKfmNbH7k9B62uvXMXd0/dX5G3fXSIvuJQmSp8r8gZ4SBT5BkVD/A/E2HLz sIzGPrzLFX7n2J8PM4JCWERJwT0pU+up+x+SfgNO2QecD6kmkeR7pgz7hwQ/Om7/A3dkNxh98HaT /HJ+Mv6HpDvQf5O1e3rHfvHuB3q0FwKlJwKt5qbyZEpCcHLrb5aRXTcZJBbJRZTVpmlCiCGpqlZY 5Z5joNnr6erq2ND7H+X+Au0xmcGzuNeZdwDaxcsgC82g7nAgjEjnuRxPqcMo2/LBtjyGaVBCNwXk JZKZO9hyRqbq7dbLCaYYlCiKoJYKrpw23TEruQs0Jegs6FzRvQlDoTQZFo6K0i8mwkSMg2jYxJZ0 TGsGnTlOHPlyO1VTCo6KiZRNuNzrIjk8zYOOBH1kK4KUSR2GMaxBYC2aKmAuTgIZ0TADkhiwgSnW lrlBaFUUNGMSwajSqWFJhkEMG2uGGkSpVLz2eDBdBpJiKeXDNF2melVvYKkzk0uOQp6ULBPR0apT iliI6mS2UYaDqt0JRvROxzS6RvC0ezge8ZJG5sDYwosRIoxsg8tiq0YogZWUdksmhrmTkFRDQYGJ jEKFijHIzaNBSCxgaOUGqjQy9jCmDOTMFSb9uOEradlGENbuBwZJho3lSjEaWEQRYNdmFNLS6wOw qKARQOSmDMN8pUQxNMhyMoPkaDmxKYUvYhM6OirExdHch08TQYKvdAxcmjgQl0lMYqt3VOHLjZTR ayxicnLhyOUocdwZwduCUxPEnLg7B5miTc3X28oHJQQDhigkZJOEfRBetiM46cFLOsbLC1xP4hoD iC4YtzY4F8Am0EAfgKEFwyYhZcqF2WHnDSYZpdCibAG2mhkWSGSOtdpeJkjIrrDk47A5oco0qcQ6 LqI2GNCRM1IRDIEoNs7pnfFNrlRC2hp9sKNlUXJspIY2RJFknSSOZvNNhbWK4CwOfCGlmF0dZPI0 Lg9AMYu6iZwGjDg+SZhh0CpZghpgHcZQUgHFGBNo5sbCtoVUdncdsmsVzXumwzqWE5DATCFARG5w 6dBPdu4iWjAnplMcSdFQnOIN5OjHHAl10zUOtYRSKFklCo47jRk4m2myYYsVcc51aDYbZEmKFLVT IJp35sTFRQ4QtpGHeHBQ8qeOR4FEOh3hI1OkyGVZyCpZFFdmmRNTIxtknumeStPCuJa5xWCi7jNa NTlt8D0czZ5ozbm0OwvS8sWIw5zy0ChFEUhErAwRvaiK0DK8q5Fzo7B5m6lTZQ5Iif9EqTpwjnOh tqVmwU7bVjh1yZd4scLMLJjtyd7NlOyusWIOJ1G5JewOA0ryVE5vZwcG5HPFMIlmIo6utqTkvSE5 TiDViOxSy8hxoup0VDFkADsJ4b9OiqpCxHhkOBoUNHgcQFQl371Jcm4aDtlRRGHmUBJjGdhsRis5 sKFE3yOhWlOEncbtqmg2uC1Yb8XsUXjiIKxoPQegORoBVYRVldu7Xbrsd6u5o3c08lY8HHdrsI7k Z4OmJ3JTdLBzZOc3anTHE3HFhak7UyalalYcGQ4zO5XTiMPBgxjExDDmJQaYaR0ulUsK/FIA+IgS UxMgzSIQRykecSxaPFEuWYdxm/LEjoYdEILFERJgMPIiB7pV0qK8iDcFkgKPQxts7CYbKRLBmCa6 oqFU88ODU2KiUCYMTsY0CyqJIwJaXCGJ4u6IsdQxrDiiKA2DBjTGXC2d2eY0TlEOGisfZpQexLqr xwwfkS90SI3VBJIFqSMKopaiBPiRoOklC0EAqeBTueDzfQ8NBuCPQaO8IjppKDSlTm5uXf12iOEH EUqVFhwsdtYo6eTz4wNlQOGIilOzkiB2WFPM7Nbkg3eWI5SwhpUZGRBhH/RDs7zoPP2A2MZ6tuUw jqxrzN64MSg4uotjGMWKmyHosDslpYHqJteZpHUFAOIQcLHSSUrUYUqTdWhjGRXRjnmjkkz03OPo JyZ1bctOzRkxJVNaIxuofyqKczZOTcqt2MYm6nBqLJhyZKaanE4Y3IySGUy2QNtTZ9ijAwYdOFiE UPRCbhK7JYmjA47lJiOrwYxhtmtxMYo22223VdHM1piUpZiJegNg1o74N7NYQGIYJLBFHCaMdEsb nXrRtDsQwZs4NJXGsPcQ0LYRHTTaY02dJeCDsOYs61yG2Z1LFTVlTKrBTlkFh4mjUIZOdYFBgDGm GQJtovUS1clrC2s0LOBogMTCMbBkgOChaA2ZcKmyDE+xII1NOhhwWm0wi7WJczATEg9qB5sSztCJ LYGiEDsu9wmufLU5RxxpO6bGFKsWcVGQpRKSsEEBKXEj0mA5JS8Em4cMUMYNGWhsxbVIjhaXerA7 jAMF4i5R3TOApwZEQaSZmKpVFGREO9FxiXWxZsWD2PdbCYd0IDnPGjYkDFYqrh3a3u/QZE7eUhy6 9z5EG06MIaWRpyDoFExLEjEoOSSaQLaGppNm4FZt7t6PG9e7xsh3B0nQ8R180Kq2/NrW7BgUZNBR 09DORnqMpig0MVJDZIn1rWdxmZTSyRIBfEWRj0plIjNECnLHEsL5kuQiPgMLyAwZkCMkmykgSkUL TlxIBQg4P9oSjo0HBiIKjTMILZ3PAAwVph5NGWJVEDGrBNjaNQYRjiaBQV57cx4aakGzlcWXKlrk RwxG8miTK5kYdJKEzwyTdY2SWG8fzdJ/J8/8OIe2GGSIeFPOl/j/G72iw+PcanrMGREj2wan9gfu sINcCQ+aSDMegONT1DgFwgENE5qiSEiCP5z29/NRFNkdzG54jjPBQbwJeZRrfQyHIQNDm3GaBhCF HKsHxzORnA0M0ocrgZplwZeZBvmfZnC3xwNjBVcOe5lkWN2QyiqrjMuLqauShBQZFCLCsxVQYzCD GG6dyIN6aZm2Ez5kNjM1N8M4aLCFFZA0MNNSQxgoLKd2LQagloezeLCQxNKCdKiINDK70+z4GYG2 CjBtvhGDDSrybbNtSpMUutiYKOvQxOFQ4knEssOqm6o3buxtJT2tit2KSK3ddOTmbwk2RUbpKRsq DdOpiJuTmmyU0HIaRhHOwwqdiMTk0nVSlKsjqsI7ETcwVKbOExBo5OGKrqbnJ0VXIGJXIpwrDEnC Sh0abmibqkmxTCU6EnRiq0cnMk0Tk2Yxkg2KUqRpN5vpsrnxEGQWFmo7jBOabu1OBHQ1N5EOlRVr UMLE6SVOGgjq5DJJtJxFSYthv2Uq5q61LYzhVsbDr1bw0k5mQsge71plFLPWNuWBLZomee+EJqOG W1paGePj3vdtPGt1trh2I5GiTiIw3Siyg0UEyRpojsQ5xwqbwk2Q3axWkpYtqWW+R82b0PWasL24 M4OMCmqCqlTuVH3blRMB3SUYW1bcrJV7DdyJJRtGkaQObMIajUwWGyHMLHRNValbQm+8nUI0pKNK iSkzISBIRchw4Kx8GAYLuiCXnBGqVlVaVpSUTo2VU2iIaWkTURo6DgNkA6BhTY55F2aKTHncnqwG QhAOSkKjh4REcOWQRa+KhJrS22qtv1vAPvXw2ygIOsj6l+KmeiYiJCul/5gyeUE4w2H/lX7nENr/ T2bN9k8CZeFWh55IOsgnr4ZzfZ1plrfsb6q0QQ/nfOew/NzZ5J2IPg0id4n0PV/InebeVnnTcgyR WvSn2G43HzPjiUtITWSzSxom0tkm2pqaWzEWjCBkgOAyKtIKJ2C+CEIYENr2SR8b0HvQ/H4kmix8 BPSgtsi1owmQ9ZrJBqpY/vGxNic+3Dka+t17Ux1k/BFSdjqYjLEZQYsiPLZELLt8eScm28tyz08d g7MLSeLeNPSetp6g9F880vaFN5FhnHMHaBd0bCIMEgxSZRYZZh1TJ7zlgQhBsBuDjEcZbbiN7kDn mI1tt575DRFkVQ2MDVJNI5nt7W03TmIpZH60kQUx2B8tiYDtRju3FJli3hy+EIDTeagNFkQxmMM2 8KQGGhmUhsFyUWwbDNkEomDVBdcNcUw1Nm7icNnTIwiuQ5u02iJOjlIG6fKGf9Pqj6NEk3TtVHVA 5lqrSSpEWBDqLIRTX0JNkFgrhlSPQaSFUud08DPLBU0KqgdjFVvZUi6xWgbaYxV6Y2Ko0lpPqsRt EGzfscnCuN1NFN1k3Ojc0XjGKpY5ysabzTSzkclMRykWKLOUMMeQuAYi9Z1/4BCaWqfYRB8uHsPc N/JBoOJM2sNExr4R8e4f80UfyRtJyUj2H82s/jrbP58jo3X5jYfWpIgf7r+GYepQ72LLA+sZ907O bH6lLaKZqF+tn3233dTWSOc3GcjJHXJtI+EifK8JHZhZJ8Uxg+DDIyUZCtkVPufcT2vS4iPUnCpP 3KZOk6DE757OsM3BjGdSi0Ij9WfQP6s4ae3BjHy5UsRxTm22P9Fjdas7E431elxGg9+IVxIQcl0P gl94LmbIXz4Ee9Cgvn9QwObvCS5hz030mlNkh2IcQwdsGCQioaxNDeIiyTFZtWtN9lY7etHt4ucd be1s8so6blRWEyE5iuEBMOOQY6hyTVEouEZLrHFdbKgblpkZ1bEZaTGcVRKRFP2y1DGsRgQVYpRh oWVJZevd3Z5pxzdtJpCJsiSHqJu3OuVK3bduHHO3LFOyJu1rcku07jrU6Rzm5Mdiay12VsKFbVua 1k6yNNJjI5KhSgm2YBpnGQMI7Uux3cvVjyHnd2jUpyzblkty24tJuc43WajVtkjju2aQ3aek8em5 uLXrWx2JNCTgD3hykUf9EIgp65AIlXW2Cs2OIx+Sxs28tmxvv5Q9RYnrnwx59T2zYxOmze3GfXm1 LNi4kRuOvYHN3TY3N7LRFq00fiX2p8nyGOZxC/FOqaRPGh6/M9NKt+ymMsrIgYbIJ/9XEsfjfkzc X5jkaXxJUD+ZmUf6FSKpFU9nKJOySOeBHEf9L/an4HuTqGyTZhs0mGlG5UpI+P5Kp8GrtCwyxf9G H/Z6fHye4EPM9Ih8uYKeRCipSPWb2NSjtk7OeTJbXvY+Seuz5NmzRrAN56sowLI2OVseGydC/Wx1 kUskczwkT84w8og8Fj7J0ByWKqSqKvZD6rJHesnyvtlJvOFkOqURObjFS8Yu8M6C2XWFEbYeCWwx toDIqw9JOSdHjFV3/g87yneK4rZd9PO4bMsOHsT4WHFQWjNBwIDaSVEuFtgdQm0vkm0h40ebxvBx vCSaNbbzt4LZLPhD00eO6TjKZdlka5bpxNnY+O7drbPDGToe2c9nOVnm8d5EtvHppuTLXrPXZ4jX Lpa9MblvPBzMebRORtzRprbLGJzhN5vNx2OHbGVmETzHbYdqqSSWJrWDjEFQQY2WYaDR6DSO3LQ8 dJEtt6TeEfKesHosY5HpobS2292iIN7F7Zx1h6zpItOceHHHbTl5eXg1JicWEmFlNGwlfiJ0muzw id9698JEnD5EjGYQnrSLSpPcvytNjxLgzg4tjGYxg+GNkkijUAbmFF7HdeiXoKVVWrSySofgn8X+ B50H7knekfgf8noRPZe6pCd34RUSe1IP1ZHjDfI8f3NASEnKiPwDQojyOZ8f0nehLsvkgLLceIWi UbSIttJRLNixbPqLbZIgQp7YVdEakSUly6CyfybJhMKFCjolEIgNVC+XxCjgP4X2I1DuQK99byPl Q7iTR8va0Tt1XEahZYD6DEdJP32RcPKW6aT+Js+d+Q2Dck4Sbw+/fMR8ay346Uw3nVRIEkBKCoUq ndsJuSeh9fZed6QzVwnmFIX4xfFRCT3IdYbfDAUfiRfm/59/Jn5Hsm2kbFmm+qjhbJJnOZjmrNFG shrIxZ8zHY8E8KPuamRukhU+6vVNIkToSqkVU+p8Gjz+DtTUQUhYgsTeGAD3Kp0cU+wc07IidCLE ClAwWajaW1oTRoWRGTaKNCbSyGfaZvP9LwO9DkdhkCPXUR+coQjlD5UB54Yh/YioBwqIZEy/ICfm DFBeAkopUiPr3YJPs9OWLufjY00YYl9T3XJu2YpT00rGSNri8Zj47DhvDYaE5Gj3mnZgmVHiFiOY ssRFyNobpEirBJQ+Iys5Y2dF5rGTIqDStSrw5RMGPxfcNTSuVnDuYhOw6JtNJrr7JO+ntQrmWJY2 6Tw6GukISVVQC7R/gF3ijEH9IxzDRhMqp+MzSxC/G+kk7CdUQ6yIc4Q7Dm2T7yHkCxoTwTw5PPvJ erRdMnESCT77eP8rxAQan4EkhZdyD4HvCkAzQe0SBKYb+Q889H9b1vJfwHYid/kZDLad00ZSw74g w8Gxsk1vLitWZ2ajy9PgH1Fh7BPJCk/BFkfVJpJWGHio0fOkM8yQfeHxih0d4ieR7ggiQ9ki8M+c xxXoBQkEqSJECEf6CE88Ds9jh2wOpAeqVPh7vpMzSKh1BHxBfwH0n2nthFB1BfchTOWD+1f3BwUS C31JfBf2H1pe6f5g/nT0p0geoJ7TxH6FlBQ1A0qIRCKnZ4X3P0C+w9QbsKkyYcjQAB2irqoEk+Op CEHyETqkP+MkhKQXHg+geFQj4vm8DoP4clXkksT+XwMfE9fveYAgm6io/R68VU0hJ5EEsT0Lj5/H PTbNMdZxkGpNEjaKkR9+xDSpNtD2s0m8zEYzFYrW4iB1s2Ee2TOZnNq+xoE0+Yed6fahukQ/7ULJ aBakm6RwMOSSATADAlkMdxkdgM/j2+7TjdeYj8J8EiZICaPO/Gxx4Tz2QVRZJVPWPYSiKbqHl4cJ 4CnsBQ83QQIe2JO5Sbkkjgh7R/6fExDCoJ0aZPrH0H9qbS1mkmaYyJjT5gIcgOTpivslwNBrFPVt qVEvaCZE6qJYWGNVxJxB6oO9UnDlKbyejvT/61Ox2fJHEGR1von/kLFWqPHMUkPBBOoJU8YAYhDy FFf82zKRZYQx6lAPP+/Z+f80teKaevtiSB7dAm6SvJkwfucD9s693g/LgGgE2P7Ow/qZqSNjQYlJ /SwNJZ5JEromHmTQbAJeI/sA/AHrIT3CP2ozMo3J+OXIsOSYX63HH4qSiSOAkHqLmgQhLI+gSS+h 3OUg+2Ob7qCrYV8X7CeqfLqPxeoQ8pIKIOwPtFJTRA0k+8kqehDvERqaE1GHxxCVG0q1hwFIegH7 RHZyFUB4lUflIOlBD+MpkH6Py7dpH31LTrWoqJMfc/UeIa1YKsVFWk76cEP6Rkh8iz5CRbY9z/Bk kR8v5vukZzxNjWYOxSegfperD8OxNO93Oz3v0A/+MP/toMom0GBzOBA9Z1GKHZPtWFR+5j1jweZh LQiNznWE5A4jIpuEo/ml0SwEQLCj/2wNzeyQeEM0mYaIURpkQY96mRPRPKfxfpR7Ej3m/zlliywt 0ep5o6zulWKjqjzREfwVPKD/OTyZ6A2GPcbQF+1j7evuPuEGaRc+B1T0T0ThH3ov+8R/B8Ha2fod Z7E6f3tGpZVRVnw/57pOJ2sNIG6/p5uDi/lP5VPFeX4Q9CAmH8q+J4Dun5EoCwlmCQL+jPNH6ztE PQQe6gd5FPOwg/yHi9SPiPMH6HzYJ0iCHwFGET5iR9wPuUn68fkfE9hWby9Ik1+WcT+rH7+P85qZ JWv4Ngj79bPMeaAfzk4kcwiGKaxSCzHEChk/xYDkpo8jRjBpQJ0SHBYRjBm1IxclQR+RP2J0dhsk xhiSsuf7HROU0PzjqYfKH8cQ+mRGzhvP89l0w9EB75ER7UD1/lR5nIMSWJCcj2GhpJU0aPMeJo2O 85ykOyX/FBWgn01VVYWtYRUWgfoh+BCfzd8Pt+d/BPzu57OHpfSPVSyZIoTPzxkKBGhrAuzW0utk TFhIcIWFTaGQaLEGoYfTCKa9t4HmJ8ZXU9jEaK0bJuRYgrk/5xqJS9VhTsxm97DgfWdD6n1PgNPi SI5ifqJEenb8DIgT4uAAyCR7GmE4WpIyXojYEfnDwXAv2pc0HM8Pos1ZDHmtI7Jyn4U+Q9fcE8j0 qdUk7EiPpgw/8Jal9UkIk9zH+TqcoaiOZxM9uZJP10fZyYfYYb3VtUsKl+62ssx9H+W1bZpghRgx jGMh/wtG06LhWoqigTjKf0DMMzD8n7HmS85xphx/xcYquvz4OEZkg0yH9ZrxdN6GMhq4O8NRfJdC IKjEdh9JWT3lGyjUlSdG7GFVqTTGo7arhSBAxKEGhcNIaQ64JIcZmK1FGwBLJFB+To/QujZZYR0E YQsmjU1NJCn1vs+L+34fxaT6OSPF51Y/QwnY9ovYolk8HL1kzvmxmYS/Qj3h8kEPz+/6H2I7HJGy 8XphkMcEhPylhESd79b+CMnl+uFAgtNqwTGU2fWL+wuZ9vuCPrvk0OQKnJwPnJTIPuMEcKRdFSJs kJ6nmPgrze8ZwnzxFR+l+v/RJ/SWJ1RuH4iSKkg7EfY+yPzt5J2OHgFR4sYn87tHzSfRJNOafvbs VjHhQ00x4Y00/kn1mI+j9U+in43dPmT2JZl7VUqzHEyoMByPmQvSmPjsx2Bi8uB3HdMXHHwdKZxs XJho+GmoqJJCqINRMYju7ZcdpBQ7d1a1GZWUphUxkWmZi5Dq+fl7996WcL0smdsxd3Wg7NEa5F/U chvWo0k59AsPIFoXY2pGGOr+U9j+JSSKYkAjSP7vi9f4CfpoThsbPlrb1pPT1uq5yfRJ7hMj+4gN poQDQCYwmZCQtEkdPDoXWhkFRJHLw/oX83C9Q6CBx6kJ+h+Oebd3H9BzRqO13PRsn5UPM9waldTh 6pHrSzptJ7Xvy04cJsZ5nEk3UkW20lpliPNyyhaHO20kkUiVgqRge45Q5z/Od05yD3p3q+AkP81S Q5T7X9LIhO5fvvp/MeCPkT7nn73OI/MpP76ff8DH2qrmj1oOilWIgRtjiEz8ifA+09i/zc0DlHev Q+Md0rfMtmf5U/vfxO6HLxZunh+6TsiVSzVlqqxNqn6bHtvn593t7XzI4HhRzFgT2xP7Ec3/H6SL 9hozRggfJBi6U3MjRjc08mw3+PaD/l/y23bMo56tjoyI/hWdnVXE2GEArG+jItL84cEMGMxcEi4Z WfOxtvDGWJopWz9ZBbKNkjyxMS5NwoodESwovZNQaVYyjO5eKf2Vsg2HAw5C7LHgdaQWeA7mH+h6 TOY4GLhjuaNw4F4DeJ3ZMTP9Q8AvX/1GcoOxHAMAW46UsHRaUsXtuyjYwWJgrBQVIoEpAjGwbBaw VQVMhiXFlZkxWqYTtdqsE3fa5JxNgaelkfZSI2jPc9iV+F9wHvc2JPRD4iTEdYkHVFiI4cfQTzIc 3UfifkDJ2J4yf50NEj8PPCI8f1n4X7thX1p/4q7ZEeB+n8foivUXJ+GwfE8I/X6EnpKI/IHh2+oc jo/PP3Py/lz/6V9EXLnFJVg3RjJJhuqamz5T900dFke5+/3xEPV8Uh9c3Safz83mfwboTzfFIhvQ /RIj6pEPUHtI96nmNTBPDxHvww081HnP+EPwPWaOQBuBEMwxON9o/Iww9QGym58jHLlX4Us8zqx7 3Rcav2JR28P60/svI7BXzv6/2bd/2uyOxXpf0Y58jkjxh86Y5r/I0zjYj1OBYUGfJPC/LtMkMF0L DoT2xtMc4MvC/au1mzymY06p2o5PQ4bNOrfk9aq2Y5pmRhZ7Zr7NtLHV7WTwSnKbvEnm+BocMvju qoKhoOWxyHI2GZJojLmZjDh8E4bNRilFmmzR8225KXTKs/IVN1NPV8c27Pk4j8X885Sf3tk7HVhW MMFX34KypsaJBNh5lMLBMkMqTiGMCMZWZIuyOEwwtvZtvfO+evPmj3q0UYi4ItI5HkMdj9ckpXVC ZIiVJBF/ap5EkpAyQHpoCE+8ASrpBWIkAf4slBATPauBwJkv/tmGj96eA/jTZ26vrP5WYg6kEfZ+ b0eXrzXmOOkWYwySVVYYZJie0DPimz434HQn1J4PGWWPlD+tYj+pY/nj8pv8ZPl9Djn7cPyla+l+ 3f78+JxXxPbE10l/MU9lPJUO1PE/wT1402lV2Co/sNMV7H43u4d575l+Eexhirsxkr2HNMw5u3fo xup8EvpLqzhjoXXLJOvRdabSWGYsf9j7z7HgPEqqPlEko4TSSNRgUosVOyZiOTowiyNJBU+iaRGE aSpYAUh79BL7zcTXgwfACD/IKiTCEH7h+t3OkflH6HlxCAdqUIfKygp8UpoWgQX9SD7K+QgWpse0 GguPEMyhI/cGEPY7gHeDAkbadh7H5/w9L+xDyRU2FUP/E+KP+LTqvWRPaHtn979X6J9CfyNP2Jw/ JI7Ig5nRCD8iGTj8F/Mv68JRCaRQR96Df35Hqg5MhzQh8yxJKsn2pUT50j64OrUEk8iuyBRGR8zE 6fF+Pvk7j7I6RMkQ9Q3EngxEPkgUCC+SwJWFX2LY4R8vyxgM6qgGlAKrSbhIdpngondNISfcm8Uf RjUhhMK9rWpFiqrrGppNGcKAaIQiKtQ3UsYUNDCfUmkqgZBeQvRMLoBIHi+8chaSQGhQgbL9Qpjz 5n5G7vumwxtfJKOI/g+j92pPN+hxNV52Y9lce5fFZB0QVF25DLYOchvzEh4iYmDsoid3K67JmZrZ 3MdU6mzqnlnD9atXkvN5YWXuTzERCxAgPOYygUO43BkOZmZsbjJeLLupGXNzmZmjY7zgUYkRuguu UYGqMbrMdEkanM1MH+LbseOdYY54Tt2nGj2kHYXGSZca49zGxacnEdGsJhiIouUqu1E2g0vzBhOC fLqd2sA9SIOQ4GeR48k7pmJD1UQgTFSqmr0U45whwmvFsxpxglGN11NRB0pUg2neu/YXlMcuTY3o 36sN1iYQQwi7NQw/oX78O4dobKLwVBaOgUqoiM7XAindARurH4g4XFDogYS0OgYLLcmDEwE2qHu4 5bbbbbySHhmw2HYxK4Vg4bmNUsriPO2nFOVmh2VJpzjs9/9PRz+vns1gsgdJ9kOgahgyjGiCFJk5 a0Q0iDSRoVx6gXDfk960RiNBMD010dF3Htcgs5y5yCZZxZyqDxP3CfmfvGPsUKTSackoks0DCh6w Ihic4OOcOIqQaMBJP6vl+Xzmfki/U49smT4HJ3Ghv6vnFVP0ehhpWTbU00rdfo9OeKT1H0u0p7hu dV1QcuAGM12+o+1fYUD8xn+dAs0CuC/FbgcoHQWniINUhEgIJtjw+Zoep3yCTd3ZxYIDOCsbDe97 J+A/OL7Qq9V27bE8B924ebd8jWXipMfGSJunytJ60nxk2TR9Sthw2SedxDpOHkpI0hkMkyFSTeRs YJBsDIGNUmovUk33nhAQ5foXcAdOfhQOqpoJGS4DQA1PM0BbC2QdD26fj4faOkwpeT7nmfX3JvH4 r4dii6IRXgOwlqjzEyErMfFx+YXkL5C8+q4IBW59F0E87gckCDYELVGgL+QwJizVgstpBINuZsN+ 77Y+6PzjznyQldhEe8dPncnj3Mpyldu0n9aRG7w+4+yJPypQoqQUqSUiyAL4GfYO86kRBmFVI+Bn ha+huAbJhI+wYPoX53tW7ek84bH/LtXqfhFRfhzD4rDIPtg0MwnQx9FU5DtgnQ+J0S6nuJpOfbsH UBjc+Fw9j8HrSb/CegVw+2aQiTzqgdqgTH0RKSxQ9LIzSfZ7z2nX0u049Jt6vte7zfqvaKeEHWPQ KeiD1DkT5knMfVPCQ5CR9oMJBymHgc/cq+aPkLM8ADNwP0W69QrBHa1PNXnn0HhDvbnZ9m7l/Y/s ioqVJ/CedHRCuf1ZoGlFU04oI/0CCn/AxM39/G9rMcB/LsjZvdUsatjKZjUNqU2NNPWxjsF9+Cn9 MI/4UU+mQ/zgzAwxK/DBx2/jzf+5zsi3x/m88Yi20tsyhSihWEkUiGV6TmH4w+o+U+ByT+AQRND/ 7D/8kOIdc7ChDAMeJiuGx6fifwvW909Z/52c9PUpS7HyBCbW3M3KgkIc24LS2pE9OzsTrMLCYiaK G2sGkgUTTvDS1Qh6iZDhI2pPa/2nPZCHNZxKMiBz31tBtLk0WxYFrJALMFQ+qFVxRsskWiqhxKjF iQ5khziHOJ8OB0SQc5UwsIfSak1+VMP4mJXndiHUrq7FVpIVKjE5bJvz/+n7K/3smdVz/htX97dt /xcPz/Vu2zaPH4fxPyPvT5ieQ/jd/lIQ9kfz//DbPccW2Fcd7yeDwaTyUnrQ4sIklGyNo31H/b9X /G3tj//mKCskymsjGt/mwMQzn/AP///////////9+//f////7FEf332qKPgdtKlAEEods97nSkgp APYXu4kO2e7bY903hVEX0YJ7bsAwAAB2DSSqKKSkCroKrTYBmgAAAAAwDvhTVCUoiW33bJu893aX hNLrjZzrjAAAAAAEl4MADd3vsKB8WzNDTezoC+wch0HpZtNAXY67TKBoaDSzAVQVNjIoFVQUoBSq UHQdOh99vHvn1xdfHoNbrvI8vth77XO497057rnNNbK7Nnd3cd1u7UXW0cgayX3d69eFRRpz30bw 4AAPt4JPvPqi7GmyV3wkAX3fbQ+IiJlDNAKbZ4B1WWlPqiQOHlRuvq+Hr72gHB6PQPSAprXtjnbC AO4FAAAAAFAAADFN4742b3fRmAoHreuuB7Z9Ave+rvAAr2++ALwBkAK0ABn33Hn3t31h8k2HuC73 ngDmZR57jvbejrqjo7mHK9zpxru+j1A7DHrfLHJJrTWQqSl8A732gwqSSkSgra+9lzx7t7XTmxHP b16+jfTd3t48DKAABW7miqLfYzshSdMALvt1Ih9vdpKhznOAu3O1KDyeIkA60AkV7xr07XwSSAB9 9989323PTAebPrQHWgF9hoet0wD3dxQWYA2w0ebrqKXmAPiD5UFa0qQFYAd8FAAPXvfOd9u6qH13 MJA933ADuwBtgA29wB0A6ALsAyB9fes6CgkqhKh12tbwAHoAeee3s9e8Gnt99vPQ0edgOjoAPbAe e9cAzYC2AJAXsDvnrnbPpVUAAX1iVcPTe+EgAB7u97ubzgO7PkejeY6C3uOhrQDmwC20B3dwGgNz A99gNVQKU+hqrh9V8AAAdPO99vfe3vgfTJ9AfdgQABd75wD33uAcgEg+984OvQayAenUlKFB60KO +K3gAegFN419ucl5usgej59pD77An3c9BxHqu9gUO73AUdAACKqSAHw9PvoD6ABX3x177w5evdnb Ub3uB19AOgd9zgPbelaNG2FdsHyaAoVEUAr7o14AAAZlqug9dZ5pa5AKAfdgNAdDp1oOmg09OgoB VFElCmfEj61vrdh7za5vSlDTOC6YAKSAAAolADo3YtsKIFE0akdsUUg+BGu2eq2+29GUqXhjAlQK J2a6Zqe899iigooFEQKoUCqCgegRNN1nQB84UoeqrIC33A97s+RJIKAkClFAEir7D6pxBFNgkEPo FABWnJmiQElUUKoApRSUmgvTDqVA97OrzGmB0PAAAAAAAAKU1hrQ2D6e7O3PokUoUqqKFAoFFV8+ xy6BhAXunAY9MdgOgEOerPXVXd7t986+ea+89EJQKqunqTK9tAB6KoKJPuAx1nvcNPGOzvoPR0p9 BcD0pLWNg+94815b7d5oTWxRPb7uPlFIBQVICgBIpQHkA1QCh9BcPQaaAZ33nhPYIgAMCg1klCG6 4dZYFQ0Bu7gA7MMIANDcu4yKFaU0DuwlQpthQA5VF6aHWbABrQoGex3YCigaMQEA173PAp6bKzbA 0DUBUoATb5DRXQDWYYMTICmLyOg6AABoO+d0lDwAvQ642GSzUwhbAFFB7e+fW3e2+++7qS9tipED KitRFtmxjoe20Pvnd73veHqL6g29CTgXduCSRQ2M0NDJrkAOVBQKvYPXRRhrACvNuqFMgBNu2FCl KOvdw886AAc2PppE5QkkAAIhCACQEBBBpqnkJ6anqAaA0AHqGgGgAAGgAQRElNRpEyaZNqaGQBo0 NAA0AAAAAAAADTEBKSQCaTFPQT0Q1T2pkymanqepoNNADQAaAAAAABhJpIgUECBGgTIBpNU/0mjC aU8TGo9J6p7VHqNHqeU0ybU9Q8Kaep6npNkjCJJCATCBkAACAE0AQCmyZGgQMTBNNqE8mU0NMmoE SggAgQgAmQTCTNVPU/Snqep6TTATahkAZHqaMQA00NDQZH62PX9RFLMU+Qz5DAa/t/t/u/43YYCH zMf18KXUgBEvQARdiCoC4QECgDcdSSV8ZUASKzTCCyAMZKhWSSq1AGkifZ9SZj8b/6LH1Fj7//da Z+GM/FaxDFv/u/+vyMOmB8IeMJKIz/hofp33/r/x/6TnxlaWjFLRmP9MWIu/zyf6f/uf/vgGOOUz Wr/8zZTbq0GxNggfxlJwv2fd935mnI/v74MUYIfOlRVBq0KMViqJZbaVtr/gTpNbs3jLjmWsRKZW ZQxWpmWYl4TTmn8+dZvN5L+WkFpdVRD/HixdhLnwgYjeowi4yHZeNWgQj2ESoiRRSLDFSbZKehrI 5SiaFYLUFT+q1Umk3llQhiDkabjAxA01nzZWbb358tZ/Vc54DEOWOcJn3OvOfKfj74nTB+xp/Kuj cP7Z/hB5qYoNrhNK3RkiyKZQFm8Lm6e2xeGh1qBUy6Nmh1KAzxObKtuZ6tlSZ7ud8+oOVW3ZN0sP NbfZc3yu0CcD2UzwobU8Y03XB0DLqXy2s0yHekyQq2hIkTG6LyrFapqwzyvBNbRF4nU1XOjlV1Xp Fy6euswWsDycnAelXlIrL4Xxre6ZUyrlK5abnmglGCsighKHHMzVMspmrkExo/B+eqsOHVxwMpdM qBBX5PBaX7sKYcr9xiaUypaDpDgRdIcDNuNRTEzetaOcuO0pBNawMbTW9YDN04whTl5wOWfodc6O +NbFiMKyoWmnztiQx+BE/9S2aQJgP5jFmyyL+UGDIRg/kbhS7btNOl82/vXrdFa9tTrReGgiQSUk dK0hQQpzFlyaSRi8ZdoNhAiZN0i1KKH2kJkSmR+cyTMhkj+xJy49PUgarYYJmRO6XKICLw7+DeOc 44GxzfIYZFVQ/tMXUEUm0GQGkAUrMIXP1ciSRTf8jcyQGjUyGECPyToyyEk3HXMIvb/k/NYN+9Es LQYRr6Tiep5lOC/sGGY7VDCS0hbmzP3JCNtfCxaFEAmF5Is8f/l9kOHxWio5aRLUMhSyJn7MSY+H 4XuPCSJQ/Vz11ZFCkVBlgMgyhRmUGkQnP1QXjTWJf2fc4276SjTG8hlDplbjFk2iCEN/3ZkZKBBJ STg0lj35fe3NRP0BCf6oD9DX0EF8P18n4bBqB9yivKWvov+R6tQqXzZJcS2CE1+Jia+jpXdpr1tn xaau0mW1e6GJmM5dmjbt5Ybxr8/jmDq0TilRV9u/fWgeHzKcjLpCoYwxmtBVjummdemccR280zGV XTNZ1venU4vGAumXy183Tf5ruI9FgtRdJJ6sWTDGV9ecysf/bzXRpWE+VmjlNoUBASkaxhFAkWfq /+rUiAf0P64iypAjn+M/f888BA04HAX0kulM3UB/VCphEGQTS0TrimaW3fLdm6GJp2e7hvRiP/G/ 8nJAEJV5Nq+lkEdky7UmBSRmkwD+qQIJd/VyDvyps8SLlkwJIZBYqmKpfV/aUZBo+ZROUjSkUhII DakiTW1+mfuvDh+vq6kCsT+UA2ffFlIfCWh+Cu5FxKsVSYPw3FU646ovqgyzCOE6etO2HdbtutYu hGTuo6Ja7uqpDWgUzZYoaEREGCLBDERQYIFSoAgI4Y/mMTNDLoZcvCyDiEWCTmIRdyEmaQogSggA KMYrYH9d5swGHhh6g5EGSi8cUhIek0HJyfOjUKQkh+0CEax8a5dO8QpBbxfeSRPEECsBBh3Jv4/0 P8UDPz/pZg/F+tw5obZnKSuWKA/wbz6ZxwT/g/qf+TNJOfu/461pMf29Wavq+urfTWtb/Dr3y7ot a/xVl5v3sYSdP93/659/d/nn/g//38XY+7VH0vur8REMyUSG0tZUXZaKLrRme9pppbbVoiiqKrF1 ZRFMZvLrKfBVE1S5lMSJhJW7eFXiQTAQIhmFTYw1SFAgkrq1EbrDER3rTod2NsON6x0la45k55z4 6NzOOmmJotbReGhmnI4g4lQyURlNFMgw8TbLltMImCiG2ZMFqEXX6zVAUBhGYhboY0SDLbLaGGIU okXWriYHKXE01U55A6RWlhWqqscsuVtNopWTEqqwFBtKyslSVWysteG4UrDthWKMcYIqQ0K7c0mW mVuNuVcVgLedYa3SspSqThqPDmVQMYaymDTEqMpQ2WiWcpCKO3AfqoOQkdyWFx8WX4BlXxrxev03 WXS5jluQ21y3RWtbaVeaXLW22w2y7dB9VzW3N2GZrC9G6p8m/VYzlMZtfuH1+/+j+j7v5d+P7h8/ rko/2GTF01/Qsq1WyLLyabC0ioGlA/WlzmXRCKLKsYNUjSOkDpXSibIB3nJywQ4yc6uJaeveruY0 3zGDSHc4TgqomdskXK6Ik5NEvOfWRokvFblWnMkAhFiWaurfbrsIhYEdPOG6ndIMVtWVQ2StjCHI rJWIZZ3stncVXNrFeMpkQZbd2LXczwyplAl0pinOX2060yQ7dJvdCrCVXIIk1o3fqI+0QYiI+o1E xwKkkkZ/5oyWaXRD1vgbCPrTxGE1haGhmIf5xLsMtmFYIJttLJNqJDBCiFkRYiT4ND5583RNMXbJ BSAsOEPZOE+ifhZDhNNZIsDhDaFYYhF+TX6k4/V+9hsPl9H7UAqSKsqRYtQGMJKlQA3nN5279Pqw +nqr19h028L6NOO2T0zEZY0N8nu8v8wf4+4/8s0Jn1cfVveMycHkbQQ6g/6xs8wx4jB+4IWwqQbQ /2vlTXf7GMiaJKtfzr5IBv1pyZyhX30DBfZ/G87Ln5L8RNc+/o+YCzXoDmrvYXV2zFaoYXDGa9Xz DzZeJw8alTTC+1MBwthoZmXxzzXmg0KzONa3BE1Op2Pn1jiYCjCvmcCJi2ozYGOLI7EOpRqskgfT UCcNGLSxINRWpzFuK+0gMEnTDgEMnqUOIFZWZQ1aHxThIYlNgubuplrj4ZS0N8T3djN/TjQzrX5T h2R+pwzjMnLNbu8+U61OEDQ/JA7DLETQxfqLSKHpxZ8mE0J8UKg7LKz0D4sUDJCiMiEgaolEkTbj PTkxzX7v7OrRhhlxJov+ZIoR+Y/P9XqMz+0oBj8UrgIforakjCPygy5GTm042FToKFQTVthjvk3y nBs+4sxjMTgZQ61pNaT+7lX7vMwYlbxbO8yZZiNTrSkjYzhQhIlaSXlz+Aef3du3bcsZmR3uVmsU NQ5YFoEIhnd+KZrYuWiuiemjETXhLex7FPsyv46G2JFHKV9JThxfr1M+ruenJs2JS1ahTD6Xs9wG HrrtV3lOcmqnGRifx/DfyxpFN4lpaG3x8OLZ88HPMcZFdVOyrJpuKFojUYG0jGZaGCsFhUfxG8gf D4bziJFlyXDbLDTKkRKk0CTWizhKjOPy/jM0LAVRZEGcUoIvVn5n72aE3xQHgwyJOSuwh8XDsOtN wfp5zz41/Tn4UNjax9x6krC0akWtKnJze8H+EPk/nzQ24qbc329X+P0vv5ZD/NfNvb5QlGP0+ZAr qPq32JSi1v1vVL2xHzcl/8/W/Py6q0z2yuyfHWJJ2ftSh1jcK18+M7xnyUk2GXGl/w/X2b+l5KYh TfooMi1JeOqY8N+78SUxnCNpHn9n6VX+I3pW/QuRMH5jiTMeSJ8lRQ1fITBIiTEyCoxLyQ76r+tY cyR8Nsgnx+ERJFeUD4hkOffMmhINhhW5NqhaQehUCCrbCxwMIDc5I6aLgkTyCMWDNKI/vvWcxBgR 920RNAhShQolTp5JwlD87B+CTvPU/ROplQrz+OjTAdqtI+94XNsHh9itKAFms8SehnrkPTPZxZbd syC2spsToNG78biSFEAEiwGPp5V4rmgviulZIYQFH72gPu8iYySsOGGkiZKIPAoWvucvOQkXbDa0 q9cVqpCzMhNFf2EdOkwS0aDZLC4l0upoNUZpFjYnsnWkeDcESp6O3V3kORo8R36lAbmCl3xnbt2r JSbU5cDJLcMS61hrU0l4dZFHRQxKKRhEuUWCGkTWmfqai9LfAizAkyyoARm7IBugHPSOKDBQgZKj b8sRZaxgxdUJLX5mdURLCKqbBmVKd2KDFfd9sE/eYixeG5swkfwPSMICYUMWQggRtU/WjEd8bdVM Ali0BnpYkxls8WJjRLALsoLGiTImpOHYObyGoqBodXYXLvMCs4dM23e9ReNnNPima5zMiTDClETC VoXWXJ65uRDT7bta41WF6uzXaXKba5bhdzLmIspuo0295rdNIoUcJ3ZnBrehMoUjrDlwKUur8E3r eXdaZxhUyF6ZYHzaucN5VfJr4aYRMBnThGW2UiTA5T4L1Ihjh89IijZtiCUYuy5nJH0YYgf4fyHw xJrmLx9Tz93u+peBxKHlx3lvH+PDM24pR7/5PVr/52K324/myttkbSAsvp+HKfCN159+eHhrg85H 8K2zmZd+/dcY60X/M6sM/DPII/vsJ/EEPIX67IRgTARSlVMfoywXYDkiMRcaj1D0/gLaIAQc9qis FRVQgYyeCQhMRYsi4xRpJSKkVCMIwIqRc2Ai3BYkVQYRRBcVGVQCKBpVdJUgAsHVUIFEWKqyjFkF iikqslkFNQsyS2SqMtKFQJkrlxYYoMkYiLBVilH0SYgaY2BplUwsjGSjKrKxtihVZKsolYslquUr MWMFkEYCHFEKBERED4/rEs9dbxwSfYPsDoXKuT4bt7M9eAl47DneBStt9aW0nssGzua5nNlX09q7 6mgmOmqOXN+RlqwWl1V6p5kjyWXqFDa9jV10ui2Vi1X3GZ3iCz1dVzQxX01WWJy+YOnUefU2L7c1 cw528fblySZBU7YGudue0ogax2dhJLrBlom+cvMsNLaBUZhWCtR45IsoZwdYhOC4sLnldcnJrkpu RNEX0s4XqkG2DlzFJ8MmbvTmYT3RRkTc5QdoSL5CiwSRvqnLd+0X4jE8Cbrm1mY69j3JQZvc6qbx OSjnNDq0PtcZovstCc3pOOXs9Jva51a56crSee3I5Gtt4NyUJVXsg05w6TlObN12cctvKFbhmllO u4IXwad3zvuKxKqm5YxzU1HEzO5Sk5TlZw0Sux3YpBuXNls6fV7M97Oo+W+J47xxN93WnQ5Fmib4 z3C5NUHddXbdVqwTaBoqeHCj3UOxaywuumak6pkbXNVqm373A14jQr4qb5OlXrGifcGn221uvN0c tuakN2BccprERRrrlMvbtKrDyZ3DhyXKvsqprBK7UMvtvaO1bm0KdzzdG6F1D7dNVW6enpzsYnjc 4pkXSLQVIK4ZfOZ6kKecXnKaIxd247my7ON7l/hsQmyAiaWlAAXau1rGsCkIW1rZMQ29qzhD1YVJ NNYB6Pqm0Dlle92HfLZK8snadbsOGbQ8Socu0OWQqSpFBu8AO8sqQ87ppJyyTEnWriYhMZIYk5Tw ZwkDnim18zOud5N9THnUnFpj2hwh4JmqTtxNsDGbTlONOYDyvF5IcQGSDDK5d7HGGSMlR4wzHiEg cM8ZNMcpyznrswqHacKzvDJgbTm0Km3apNvPjQxvVdUkXlDwQ8tapjz4OB73mM8FFlmmtDNTIJwi KTPTAiOIryhTjEeXNeG+9QG4wTs+rzEnr56kavDkPGYPYnDU8ELPO8m74HCHO4aeW6s4TNWHfV2w xvNKjzYCnScu0rCyjA48Y475QSD7SGSMee1+seIQlSYoIdPSb3rA2lekJ0mmTvvHAmkgsHu3aIQF yoGmAtmTMKLVk0qs46MkEzIzIq41zLo3ZOHTpBQrwniYzl5cQzGikwGHLDlx4cHlNJvi7tJeLy60 5nXdO2bQ2k5ZNodocsxhS0N96mQNMUcIJiN7zBMdqEaRtoYkKMD2+cSapTrylQ7Q13YCkPHrXeTt mMh41OWHOr4kxg8Xx6fNd4TtCbZ2mO3x2zE8ZwnJBk68sqHLOUhtO282csNJ2zo80dE5tOANMWUR 6QbmcLSGkCEc5AmJtALb4hyged2YzxO3nrrJ29JsV2u9+eG1Jwh1qnDygdc3lC9AUJvyw8etWCzT J1n2TxizRAJNW+Gc4ZDIw29OK6hUwxD8CcfYp4LjcsOERBMCxBvKqY7ReKRzpOecmteJtIZvnDt8 Q2zR09YGRIcIEiLIGm7QGJDWvRAJFxczWCQ4A0wLAIAG7je44J8RJHjEQOIwi6UEiKe7tAYgoeMO UDlCcsOWeapDEURWBtOHjdpO7Nju0NxxKk3u9dUrjUnLWpw8O8N5275s8ScoHLDRoKvAyeIEsgh3 5e04Z0ycas8Sd+WVC7s33ayQ44sDrukMQ5eWBtm/Ks774OuNyVqFTxnUSVg6ukI80NIeJtDbOGAo GIqkKvnKXjAswiOIBOz1XQYIhHDFEmIYJ4+JphAIYwIQ4vGXjfHPfeeeG+jXns1O+FPb1B1q6WDf Xs4c9k3vSzM+zdkirNUtmWpfFdhWQyJFvLMJQYbWIzJqIEnAfYL5e9W61bdoTuMMbArl6Ql3LtBW bPSiaQrs1Qu6bdXj6T6+WzcpyhlMg+vROvMyr8hiC5oP1v1k25irN7SeuyS8QKs3OXzDFKrE292m NLZnJKF7UkoZ6nw5SVo2emR5zcyejJ8SPGmkVG2PN0jgmQ5tWTQR8kGYsyoLFmMGItMoLGRrPLjB FmBmWPMV0q+MD1WSi/Npklx72Pns8PPyJ8xsdiY7m7DBBjkwMJN5iM5TjRS29niiz0vd9cMaZuHI k9OdLInmfBK5p4gMFrLrJ4wnGynEfHTwJXy275ztzdgiTlKggPET1mVIkyOLOdXb6cG2aCANpYEQ a3hg3kCKOygSsmSUzHpNhwk+nS/LQ4cGECBFAFOMVsQoNlvKg6zDU6tz3+/+FOju8wKLISABcE0E GZkTiQ6H3GCINsgMLBpWAJSMbCwQSNIWIRsIFgUaVhApCyhKBbJbRqIhUZIiCVFRYgjGKrFkVRgi Miwsilo1CxiMEjSgWKjBWxAEFbYye4i+UqxRkFiookMge5BFFYCpgmomTS0sqtVjkUVIKAVjBBhC TIIQgnR0fAd+Dvk/gB9fU1MpMI/elmMoxwlAI59qh/LKRD5x9ETA+4TUi6gv+uRZn8qBQ6B1LnWl vXjR+em/YUakxC/A6rDUJVNocmNzuy8WzYckIg0EbkS+5cblVpzNcmyFYs32SSCKKBXLDKOiax0N qzKs2aIDrHknax5co9PORejL21a58c3VXUsoWIcnH3Gb2ekl7OQy4qRm3zzdHBX03LmUyLPVgyQn lpPBab106quJ12d1NFCYnb2hOHa6pxWdvBW5MzTWbwuOqkrly5CaDq1VAurF5c9t70VnKcmQpbhd SEcK23G9PYlvVOWsVSEDVu1NZJevsYWdV8Yk4ZySHmzYcUhPcGzdUXuSGJFlDUlOMPp26fKWc7lN 1ccMHPIkGIGGx1mrBrDdnduBUzNWczBUhisqCCxaT2yt5fgIrNm+IidSCTjZus4OyUYJOxBIhrSv EwedN5I4SRA7gBkR2A9DM1zhnkxfKukLkhVIxU9VGj2GdmcupeDHslyw7IQzsgkSje2VtQLILNRJ 7ibFMpWxyUpDK4cLQl1IMtnbiIEzYiKhRIoXF2iDUVJOmjBokEmmgyO0DRzC2TUmOxkdp5EVYiZ7 XmVnZWiYkU7bOrYxUGq66TWQF3Wz2R2ttUl2pp4aFa4PLOax7M0ONTrFpydp5R0GAC667FdmbT4x uTsUhRBFwBwFSKkbhkDGpaCAkawLlC8vhsmrBQswLJ01qpKYF2sn0CIiIE091TNuGRo6+F1mT6bx 2OIzQcYS7bDdNGqJid1TvZI3HmcJmeIwZlkVujJyXr40w+kyzCkJjdq77s7KS7NtRZc0XBoZLldN h5JVBW9NHLimOsSJW9VTVphTOOtB7h1ZNlZ0lzEixs6Kt5joToJvsm4pE9HddbrO1KIot6NFQ86j s4OqzJvZyY2p5VoKuNI0dFkgCpDCtTFqrYIlDJGF2YlISrSkdXRc653jkzdsSKruuQqpdaTelVsr FtC6lk7rqxYedO3xurd7OnZHIEbA1qq2UaMAx0uwkRMzXDBODQThc4eY4qicxytIyibnkW6st82Q ldsa618LExOJ5YKTOvsE7YnXpnJU3N5eDZNzlbIy1QfUOq52j2d1DMp8PSfO90+HJWEhw6syxSkZ kkV7Xhd88tNO6U63v2PVntfYPiIJ295MZ5g8nnuqqrAUFBUVAVRVUASKKKoyAgqiqsYqKkirBYAo sGERWBFAUFgjASIsBGAiALJEQRIjBiImg8feSVAWHHh8njrXqKKWaMzDDLiiWtwuee/r7vw+Hv8R xzvoVCqjeG/DRyjwU1uERIlvDDDWt8VNbxDQ4/Hhypc3nebRvMblIxtDCEnG9C5e8hfax0pxfX+P 6+XfjDoTbIaI2N6xvSr7Fb6Zuv49V0uXfgdPd5WRDA9VIOBAHwqlLg16Igd0kGo+Mt2UJRN9olIJ USRXHdTzVRihjXYQUHjggyIoH4QEBB3E7jeOAzuv2WDQ4YFjFScJe3236MK0UXY8GQcESu9DSAB7 IIGfBQEVF1YYwqBYAAUIo0yJ/n/1T9yXf9xih6QRFNUMTDDCn3xQOCH6IMiEiqSAiAEWSSfziVIQ UUJCMZCAohUQcXFQpQaaEFKiArAgKxhBRBIQEiAApIMfokqED/W4gnXEFHWkAekgpQkisiJEjGBB i4AsaNiQogG6Ct4w0wQC6AB/dEKgweEglQYReMAgnviWIhcphEAX+6K44VBBMC9wZIrFCEEYAj6S 0KikpZYBUbSFVUjFGF+ywozGCklFGRtgKxBGmUXTVxmIsf9RiZbPp7PXwC4XnRVF3sRsWJJAVRif FrFiipAVFWCiqW0FBfayVF92KxAVRgqyCgichKYJCIsIwiAwjIJIqrIpSyxYEFICkgLILCErAACi iASDBgADASCKuqVg5QqMIhFEGQkjGRQBIiMiMIsIgQSKDAgpIin/v9xBbO44Db7qnD9VNn8cPyRL sVHlDmgWg+0iQkiECEYkkJKMhhmNBNmw5rcRkrxfMrNR6pIPH+SsJhUBBGI6MCqMP0/rYYDuwrP2 R4dA80v9lJeKsmjLiVCf6+aCB/5bhuf0h7fXho/sXnMhbcO9ekSKUQib8GgwyRM/PyVhRnPoPyP8 dzO+KzMrvhmfuo5G3KHEB6UoKYgRqQJQGSe2Qu6Ht+D7MOHRwFllkpwkLHKf9Tf98aL3RAP+wbkX BDGXifEdfn0p4+0jXnMgfB4g6oKNmAPdxSxn0QTlzhRBcVFEBqFMMMz4m40NAwZ/yZtByanIz96Y bn23o4Z0iri6/kEj03OqfzvpJdyuHKsymrDoDFhKCT0QLD3fpd+w3RM//0qKzRTqOIk2aDlwtGj/ EoLEQ78mG38u9HV1N+WptnMnntno6Ok7PXM1XkUwu/k6h/W7KzWxmUcuMcGfxBf+j7A/UmbG1e8n FvGc4+A4Tqqx8cofcazLhhjmCsIQKqUKTYXm3mq97D1PIK/XasmdjJ3698dGB6qMP2hJYGGGxciR MiZVTOx+7+IyZH3rIED/IF/Vf34N/fLs/cOkR6dEofRIAYiEmFdhRcAwvr0H82f/u7VaBQsexZ0c sCie44ow/Tr4dQdupA/1DIW5PcZAxhHiMdCUmTeJVRNDxXtFiiiQw9seCN0YHw+VEDgh4fTSp1eR pUKTPagVq97tsMz0m8gx9k+MfVCHbRaDs2hNotmOCarNx8Tj6dsR+6XXJHqdylGHOupXqV7mriB3 nYxEOkalbXNy67kQOwSQTsBC+dCx6Z0rfDx9JV6OmcR/OVet3NeZE+dT/riY6pZibvfqAejXn1cj 838HyNe/alauUmImfMOHZzCOT2P0F/BhxEiCCgPvWl4Nw+nqS7HXosoHGqclA80a2gfU8ie91yaO APrA2gyb9AoIMRizcD08E+WTrseIFyemnX4DZsLgqrMNV69Lp21qIvgnQkOd/xysmCOWJy/A03o2 HVIJiBNMw9p4jFwWD7Qwu6zrw7iv6/e3ihTDMTKbUKwjGKUE0hdrbDC542tWdC8s2Ev5WKlivHhc I1Y7lB8V1SJ8fLBKcbMMzPPoPHjK0YnTKBfPf2RFcgM44cMP0enj4DgyDHHHiCp3MH12MsC+laF6 0cCblIdjhY1OMvIq1tR/B8HBgcBRXxFrC7IaD1IUv8IfmvcJJJpPymUM8pMm2BKJbxjgYHkDE3YH 3yv89gz1Q/hBhIRSL97+ymKwCLAFkWezCBUJBYKojBYD60CsPdokEQQGRYiCigMGCxGMU/sUosEk Fkm4kqqINRqSC5uLQWLvENDl4i+JYwDiyHPcFg+PUrpBdBZU/q4a11Lhjeh5wA2waxLFeEuBV8s6 MjnCwfjFtblLl9dMbEBgQBRBDAOZwrKif4XD+C7ENQH1KtyhE+8Pk+U2gnEgWP9CQvoFtA8mYX5V r+ZkynSVRJ4EsF1TDU3TZqCCjERTr/g5IHQeznLvgJUaEZpx9U9nDqjOgnH7JEEeZHSVSJM/7DqU s5/y/2et5+CqikWQS+jHEh1XcDAikD6QgZT1mzTa1v3rrVcF3DTIew/HvBeGZEPtICGqCNEQ9REE PkioLsP02p6OdARPu0sJFgxBFYsVVFEFgqDEUVKhVVVioRRGDEUiqooKQYwUBSLESAiRGJbCgigp GIiAwFgwYoIgMSIKIjIiDFVESEUWLIoKpFFStQVisRjBVIiLIjBEYxiKJEWRFFggIqxUYrGDGIox VikRFBBWKqVCqLaWLBEEVUSREERQUQVWKBZCQigiCxiRQgoRUYCihFAWAsBRYKsiixEURBSKggIg nvSSkZFAUYwYrFkIoAiRSCwiwEGSLEZBZCIKgsFYwVZEQARIpESRZERSLBYgwQQRGIIwRGJEYwYR BYgxIxQZGDEEgkQRiCyCMRBYiKCjBGMRRBUZESIMGRBBEjGMEiCQRIsRBEgoIjEFIsIICRYALGCA jFGICCKIkIjJGMkYyRQFABkQFILBYoKCJBYosFgosiMBBixQUFkirIoCDERGIjGCIooIwBYIRBBg siJIKQUIIgRYMEkUigsjGLCLCKDEBjFIooIoMGCKwRQUBSKSIyCILIjBERAUgIiiIIJBECIwUgjI DEIsUESCMkUEQigioLBEGJGIIgMUiCJAUBGQiCSLGJBBkWEGIoSIJICKkkYyERAGMWQRIoIMJEEI gkiCAjFkWIISMQiySRQhFkIpESRSQRgsEVARJBGEBSRBiIEUAFZlALGRiMZBEBBgCoIEUgpILBEI CyKQYyLILJFFJGDEGSJEgiAsiwFUiwEQiMEYCkRCIMBSRSRiKjIskSCCyEhGKSISAyCycPIcJ3ax Mof9rqXgiloomEAkbgSRHXCooOgg1HFCo+Fm0n4VERUQQFBRFVgrERKgEqERIsRSAjC2seZYTcn7 6iez3UoCA7OT8vLw+Xn+q7psbjJeWuwLpkuyWMV2LJeLOu2MUi7FU8PYaaHNVyGUrHHMbjd0d6AI 9b9QPP2jsLeg4KMpLXbyc911O92zZRPOd070rc7LnuFYM5sdNUgjHDtvd5CjYq12Ok+26WHOyrp0 5sYq3JczZXcKom76KzqzqvXgtokCl1eECB+6BAAgSNFkgQZJCjBFILGMVEjEUZIsgkGCCRgwREBI xgRUiKwSCgggwjCJGEQYRWCMBGIiigKQjGLGUqwYSJIsiKJEFIIgsigDErKiDIDBICgKyMFYwYrB giRBRRkSKEixQIsBBWMRGEiwAiSLGLCMgIKAiEWLAiwYIgrJAQWQYxFFECKJFVBggwWALBgCRjBI yDIRFIkIkEYRjCIMWEWEUQFgCAKBEYDIJIyRhARFVkYQJEgkVCRCEFN3ecRr2/cTg+uz9TeM5zMv 49jQL23116c/0/1HzGfp06TJuPaUYxnCLPm98u4aINu7UzSnutmweO9Xo/H/bHyPAiPu/1D+n/OY V/Ks9PAZh5UVP7fl22pN4EnbxS2L6MDohY8p9Ui4v6MhhjDKD/cDXnAEUEjcdQxG/7K22hIdiItF BvJAkDjGJZdA+0zUAMgnmiIkyal6nq5qbp0RYMA5X9okeIs7awyFTQmh6YJZrVZDvzkwxusft+ID 2FeMJNMASp5TDLL5QzFkFrTw1Y144RcqVLpY8PAwzJcQsGqOp8LhkewK28Gejvb7Rg6Kq0gDh0Uv n0eHi7uu0zUlZ8vP5R8IWeJivov4VDrzkj59ICZH1O1pUqV0zAZ1sdui6PHls1zixpFmMe3c1ARG SgfiHiKI8DAscVsukJB6WA7ifZQCI9WHBMcWtPTYWvJ1OOIpIKNXEXuVKFIcbMgwp7XMKm7p+jkR sne1ubE7PrYvzmxXE0pwzczRwX3hX7I6+dHV9EHV8XKD3T0Z5q+jrgpykRWHXhePNYad11vQoa15 mMRmEM7wOUXtzZKGcvPDs31p6wJaYwXDb2kiLzqlU9mmtWbQhAuWGYrbf4wRmrsQjSxJqprkGiyN XGgJZHZFJlt1kPhq4EC2x2erU0V88e55jxdvchU1w771IKZSzW7BR1vDp40c5weLZB8sOHjfeSpw ccU1vY2WAo3dWATaDvjAy9IZJVOTCICIDngpkSQgQQZHcujesA0q4twJMeA8F0LUszwWNkZV2gWX kqJ4SDwUWyHWJQNbTSIOHtnfbqUB8p/a6FElGz0EAzNzGq5umRlD7J9dXIjYnHYMhIQYXWJ7G4F3 f24UCDEXjGm5VUQNVNjwqaqyD9DgN31sfEfjT2eUkTdKfX8eAtB4nNjsB3TdZXf085FcgoGNIr2v puixFfS1dvPJrDBG0168bNHDww76f0xdRdZbDClA4X9CyiGBNPJLUC8dJ4DlKw6l6kCSDQ9kyBl4 WPQc9S8lu1XUprggPDLMIsuGWIetEOGQH0AyL8MF+8OQ5pgePzDcE9mLGR8cuT0NKUHhJpMTYGNa koLAsIYJJG7mLnWl6mRRsG61iwSQ2hOKiBWW443c5IyQhxwGBrXTwfGpx0YXdOG92cu2ThiJyuMM azA+0+B8d778zPXvxn59IfWozNu5v0GHWvxDOlYvtNOFigWWYZDIz54XRv5OXKekKCa1R4wDZUce vbEjuQYIcgoDDiSKIDBHyAXSG3wKWz4IDryJWLWU6wKRVZQJWlUCKdOBaPnSQm1xEq+mAO1QFdvD AnUSBdsugREkXSCSwgSZJ8NmRnvSHLn1kHhw9gB6qnjRsizAvtTqldcxuhDsURpkyXyCPECZ6YL0 9s2MJ3hddUKxet8U9YfrAoP52xhIySDrjUIIdtuL47DYCu0iApm39W/qaE/fX4SJr8c1TU6c3c/L 81oxOe3b5ggYjxsSRNG6CTAweET7bCW4G/IdPgM3zV3qFWrVSXeTafPDlm46prNoMOsttzXZFCxt LAbVzY2rcTPPtnJzVuORLlnoOcgRSNXtHM1M3N7dGcN9L8AB/AfgPz+7+9H8f3zX5Cx+9B+5/hc9 efHTdPf093nx5ab1BpPoQnEn6p6oEWXo+q6/64DruRazmgf/1/YS99RaRRl107pjY9yMUmP6fN0U ZUWQdXEDLtiyJDksSQSQQ8y1mGbDVNGBSBS064IaGpANUa9/Prj54fB7aQ8o+fKxhreytZiuG3lF IkpIwyBo5RhRAqdwTEwZbcLKmSDG5Nb19qjKFPKGmJumF7ybNaSIneuDW7NyGK7WHV+hz1i7uGCc HUGAOmxM6RFnQCIskIIfeM86BAMEmB4pE+2RYuvT8GT6xUWeIF8eeggIYTymYGY3Wupiu5iS77Nu +IHSGZzOyATBEmWGSRwu5EgxKwnStNTvVUSYD7nhikiDKSlByZYHAhi+0S+12cCsY08Q+QFDIkuF Mxh/r8/qfoeATk+fNP19mBPi9UmdUj1Bd6Qw8Y0yAQJJpwGQSgSNKGX6RqVQIwlgJIaWOlAkM5cx vWHYhBhxzaJJgGAOoh/jwaygegGe8Y4KYnMmADaypmlsleu9VMUQQS902rv14w1xZiqHl4tmnu03 01RaLMuZvniaJsSxbe+HTmiDc9AiPqBIHfFXaBT6hb+RYiQVExdkM05GDDKFGmAS/3/S04HM1aI4 szgk0yuqENKzA2Kz6Csg4KwbQDrGOMWSSRXKBerqlxeqUUQRZo4AYoyrZJS5j0yDdtEYukak13UV Rk41mLO2rL5hWGWmVOsOkCyEl7BquZJFoBCR3XVEE2MPZdCytxBgyiSRwvFaMgOkx73bS13NEI7w rhIuX4LUVXjxHYjC258QPo3ZQNU4YLtsUUcbYFz3nVAQgJBRwSH86lcxzCgWbZVk1pbIiiImtdnA fmR7O3JWNSHey/TfqK9iwFBUd5BkgjUgpuH3ISGtIokw8KG45miymgiQ5ZyWCWbcpijlIR6z0zUR FEuuONcBVocddGtazcyGYb9fVifA5f9p9tiSiyBBa9cOy6Gsu1I1GEWKPm0qNCW9s093dfZh0YMC jFdE6lg1PorJu+fUO4vg+clpSseUBFbXUpywe7nXPKY1bYPAzW3j5jVLRkZc3wp0yJyj7+HvXgCA +vxjI0b3ykS147cZzEJNcRXMwG04U7sLBuN0NF8omLJaYcKAQYXzy9fy4DnI+WqBEmTMiKzWTM5k 6aBiGdaeuTfDG0s6tRQtIgmCmCM0AzaXgMxqtVZyqsBGCdUWGQcwDLfEKw6EFiK8t640Y+Nk2CMR 23N4chqrF4cHl2zfhSqKxdcvnWukizKtBllBQQZgmmL1BN7McCJFqepxoMFxzi7GuwQbVrfnz0zY zKT6p5fAaqxfy6nr996Q09vod0NeY+m97FiZ4cZrTmVii2QxJIJCjNG3QskWH8uVyAN8F0wzJIJV jg8oIEE7Il4a2x9o+2T8G2EN8T5fDEkkZRwVIhsIZXzTEggMim7GlxQBQvnhfBXBQlAb3UGpgEiN 5saMWkRwa0ibbAdUSXfbtVESbIobqTUjjdrpHZ3TMTA7kI2e6QjYlCTE9LnOcRLkOg5yqJh0mruH MIdcZxTh7prypze2lwKC0uQ+tOFmfhBQqnzmUZ4qSezZqlhEUk4NfDSmRFg7GzDINXjROVoUmuOy DiAB5CjxA4ggirbGpEHKUyhRiFhQ0gSsDGEdKuu0qRYxeM54VMkSTeOi0ulAeV59WOyINI5tOPSm KeWqmu8PNVNpROt815dbUeOqjMUY2Ub01uirRCwbmX83dIHd6Z8Y0uxwwiYNgHGJ8hh2pDHBoV3M cD0/Z+aAoEdcCsmKMHayk6j207lDDvk75xxo4kjpgmTGAgMVrkDBeidpWQ6WcFZJKH1rrrtIYobA ox5IS6DlKA8/xj7READvl+sizPenyBNRTsNKBVSyhHSHtoOVGYznJyDXMJen2EWKz3OTqUoY4iFF wpjFUGFtyOwUUzZYu6d3OKHacmuSr0feJgSYIgYUB4Oj9GTWYPYI45QZXZ2TTEHMSCMgrTLBD3rc 61DhNIV4dp7iHD3btV4924F4sEz1nrzvppSvGGdp102VN2+jDhDIqcpSWgoPwxphGKgz8AmbkWZG 46QhFJBLizm4WIEsombUAUQbWwLRgmAUix079OwJggyrPGIn3n7yjjBBiyKBOmaqhtc6IxgkBRAI MNQU5Umxi3EtGVPCdY6Qh0whpZFfQY7sx54qQggKGs+gTskGCQA4HwZOEVrl9SBOEC1tyB8Si4Sc 3hmwSRVYhUwDIbig7G5NGV65Y3MN4KxNZV5znju9ds5pSicCC+nAYYA7eZ4XREUcXD7AmThoMIdf uExRAVBs4oRCReoYaELwdbobm1VecnOu1LdqrNZrdAkNWwERZJARZ67YWqMJBJ08bSnpQcEkXEpg EwCGKXM46EbSyU5KDXCmGnIq5uctwOwUG65PaHFIXmdh5bVNgnSNYQaGy1IDBEkdGwgGVpQhAMFX mzMUGEAnICc2pxSaNVh43VmJ6ZETA+QuO9EyKPFCrFtUQzMXu0dHd81XW9d6/2ZCBmyzHiiZgMYC ECvStQwqR4jBJylGIinSsxzGGuNTOL0zjUh1k3mON2ZAxS7YWV41C0TSYD1d0lXNa1NPAM0M9jng AAZ85mWekiHjcm8s9JJmHfakrZrs4cAh4zUg3zRntEr2Hwwyqk1IxOIgMXIXY2LoEZTUzS3wH9t5 3w/Eo9tem/gTJidy6gfqEJuWCYIf4D75kilGeh5IowlvJge5Q0nFPVEwMy82r6J0dynqqceZvrfN 68ZqHVroZpyJwNFYg2dUvXHm6LgWRujQYExEkFRyZJ3ggG8YylNCidwUJS3eZx2DMA8xMhEykkLn VQ7LFTlqRYlQGriZigYoodSfiLfXeQKneE0AekJ1TxFJtNDO7Kb1eC8B3oDje8hxtB5MRZgxd3Eg SQq51vMDAZcKx0mHRgEompEgX2CxVP7nEbAH1Xw9Ve5QKJglIBEn5mT40AKrbd1Be5dIglEV8TxR RBBGojq50AJQ5xYKOPjNlioiby5iFWC4ESYEOOI42QIqKIiDKRw92uKPcg2LBw1QowLSGGOpRElb rhG1rjBKwwZFa4jSEOBYaOqTkmkgvWF5Hs3XDZmInfZhMEEaZMYS+DFLQmTA7eLwZaY6amZ4vBe7 1rsKO2RSYaRGLIKLVIzlqASKM6FA4i+UZ2EbMgjggEhKc4wN5Z1rDjB777ya0Z10HaQLwiIxggxY BMXMxGZVkaRbosYYR64Qs3aGo0JIqhgzKFVQF0rjARhFyQCQUja0ySQ8bnJnCq0gmJx2p/WPqAIq 85fER4DuGJ+l7uUTSv4ewUGVQrwG4DQ1ZzcnKrveurRF3l1t4Nw6c4uqscVkjn6QBLBgEAIAfYex z2pxxfMw736zRJoiMEDkGp6XWG883MkYYAvvT6psX31d+kmAbQGgyIBIBFjLx7cBnGsrKmMyWp13 gAMhplQiBZskc88aN6KcJzYD5QHQ9sk3NMGDDbCnKKsEYb2xkgT2gipCAq0OMCSJUEkggiCSUBXx wAfzx7iGoHQ/WhH2j6dndxqR8OjnpiAXAoAGDAMOBaOTe2Po9smBaCHYFEvLb8X1xYPuhTVULFkA mjuEkkEmJSAwjmhRFWooGeSI9XdxavrfuLPEUYCJogkkC/JlV6hIdIgup4+7MEkdUsMFB0GyFJkg 9JqAsvJAMtbUcYqwSDHLWECQTiQa5yYzZIqQQJOu8pC5gThnHed9QFhTaCoKCFHjhpXpvRQxaiPQ Abwql211TYm/JW5zjGe4+y8W9Inho0dop+UZvGhZB65SY5sk+H5j5EQJg8YKLAv4zfnr2ec9eUxk 4ScIibEigJJA+IIT9KEZMIjaWZ8cdXu1owro7MRiPm6YaxyKcpy7Xm+PKnKj1oDXADlkKrQZCfmB x2k1zEba7GQ4mXdUKxsVKxTc6erg421uz3A5lTB50HosGSmhhMR4vWaxanKWJ3qgLjxEO48vVuio ZcUSCMpRfKAjpwHcM3O6EHq2nDVTyDkEEi0GeMfcARnBAq69tzZ2+IRqLI8XiF1tYk92eeZGg6Oz eNJVbIQpMhYnbJncQ3MOXQYBlAaZI+76EAZuk1bXb75NyJlG81l6dYwYtfwulmdV7PV1AYRMvnTc +MZwtoJPP7/y+jdnWb8plMw7HNzkUYm02GltpfZpkH8NFTJ+8GJ4hAwJKzr3QLFJYdLUaDJkASdB Araoiuu+pibWEJNitYZEtRJsi8wkkGCBVIFicmHKJCNkIM5ywC9QySDBgnTAV3kiTDFJu9niWZ3M k2Bh0hNyLrrWmRGkQFZ0QSIMQ6EsMgO5WqVES8GAwu1hEitWzxJAY0kDIslsYnBh4p/AegAVuIHG /hhyCUZ+I/HVTT7c3FGYWPnUVR+VXUdU2K2rk7WWJQ0flSHwyGiiZzmtTzdzj066Dni9bcEVigdI VA8u5llBqM8JwoeVEERpCtDbPwPrDyHNUBzD2d5VHEwGRPFSBRBIJJFK9vdQwmM1bxIZjryrJEGk lqoSkVekdkijH2DpnPc9BYbUpVsEmkovLd+wXMYcwqJYvLTEtQwSsxxpe+VfH6ez7tNMOb+38a+c P1h7/mtwq1IXWG05DM+sPA5/EUPPHWfurLY6my1fcY7s36DHYwmBKpUV+iFWJL3RQ/FCRUD/QP9G j8frRhIgjdj9OP6YYiYKg/p03+qwfwIdX+ze56JXj92Iy45LmZj5LqNJ4qiBoldN7ZOd2stUICUO tGoMQDkKIpCQUKj6JtbUElLlLTkn9UeMYKerc4PcPDQWaWjKfO31Lhs86779oc2dpTfFFzRmCn+x Je7iB66wZHQ7nzkIsjjE4q2hyHJxIYYYYibGTiuuE4khvNDszC3flz2e+hUujJMd5qH0MKk+mlOx el/YUXIBzNN1ovPVtJWuodOIs1c44pQqDEGcJmHjjA7F3NfDSHmFQm5TSYPSIwDgVXsM6qqs7YHz 4ZAfozLpaBB/1q2GF+ycaYVVVu0icQHAGzUDQQcH7nAsY56Q6yRLhk9rwof2h6kCicOPMIl2DoUD uoqEkIFHv3yTMSl2NR8MtCDKquYIQLf5okIkSNkw19Q+WrHWiBUgpnL4wUoMltPzPBoOcBzAaYSJ uYaAOYeuh4HqSJL29dDzscR8yMrdhL45HEWN4/eux49nSVjmr98/ej6j9/1a9Lwdxrxdx/90UEbo SD05aLAZTh9zD/OpcnxLxDA2HzeVDC4y0dfCbIQPdvE6saa2AdpkpWMWCwTpcaGlub2xixIklojg X9KmEMYmGH/wT6H44c88/fWa/GfKTPUHPAPlHojZgcN4thbDl6PHIoBmIwgxIGbDH9V/LMEtEuPt SjiQg5yrP770FXjdDCbaOeb+gR/1ZrYy7iwN44pY5C8xhISMkkGJxYxbAW5WmibMe/LXrEPWfp18 ZkK04+POGQcLbjAKeA5Mpy7wmODIGRCoFFb/3H+kQgylZrwNwhRv+omkZOUev/mibP5YDmZgix8t B8LXbBgGgT9MQo1ZTlLJwkS8gDyxA3hYlYfk+8o0gfonTM+OmeH/26Ue1vEPBe4sZER9WwVAYgio xYH+I+PX8P1l+HMPP7jQ8zTbPKhzbBIMkCPxaPGZb65gn4aU+fu2/m/qzPrXf/L4xhwfwONhL+Bx n8JmaEKLA3jy73I3cqQc1XDf0o0GIwbGBHu4QMe1xUYgiKimKI1/LA0PlNNKZTtVBs6miIiRejEf 5mz6BZXsRPXAMjDjrf+pNneLu8h7vZm/1P+178SbDHRuD+p8WuRP9PGWKjXJPfir27aA2JXa/o9/ /Ef4n61+/8Pksau3o7btcD+Iwk7bgiSj/oYT35se6+Siex69maVz/nzBtmWRdgZ47H/C1iPvxe2d N2O1HZoC3EdmfZLJMTuMXzthTWGW/EYX73BRmJwYugwsy0x46wqiqJL+Mt1eyTswTqzZKpjAs4hc +e76qnDNfp2rDhyjZ9PLy7P0RmyGTA16I6DdB4pZf5EMfjKYq6t0Evi/ASNno/h5f2c5mwVK+Vqx 7MmFxfKr7y1mxMebPk6JKylreOt3uTfM4QYY74bgyC638Eo8ci/tJ9azC3sN8T0S/5WU4f8kcHiQ 87cZnD5+GyOcrmuerH3SpR/rrBIazkyckc5Op+5RCDHGfNnQZ6f5oL2P7MEHYSTxgeZGWDV0nqij B1mGu32fJTVB0R7Z8krfglPbQdX2u33D2+s0yanhOldcg1JJpEJGQCSEaQJRBBCCIxWQWCgqMT7R s+JwYLwgV+boox/o4/LN/x1/K2q/DUV2bnseph6PcF3T0nk2JgvfzyHUWGqDGvAqkE5N7PQuDCCR UZjhz8hVTmmPGZrcZ0327CYPBio19G8OAawcMhfcY7q5Dxty9ZDPpU4vE0bxVFECQIQhGBGBCgRj r8d6Gxh6cni+Pt9fBOnCV9Zr8jyfzGYtZjhmtjLQPQ1hYFFw0kDv9XPbyOI8763rgYCx73HB7uvh nDDmTHhlRutOqmk0/5OsH9EoJPXlzmmzZPNoXk/g5nk1nWLVLRqRKIooITjY0IBxqov9n8P63P5h fIg99IdB/jgpKZI+/PX3n0D9j400JwIUA/GUoIhRBKUJ+w7OFyOZvXNi3vuuWN3pND3V4TK6yqMa AE1XYN5P756f5D2OuX0KczLZnvX8p+6OHsX8e/fre+M2rYnPf7WoeQT8CHrgd4OrPT0PAxuYL9v8 OTjgtxv2zWB0Gi4WlpxAZx73DdiVKufR+Rg/vx44ePHjmGCpTOUKJ49iw7XZVaSP5MOri/3p+PkZ uBkSdM6b9OlasJCHfjQqWkhRJRioonwYIG8BBkCRVgkACmKFJBYQSMBT5E7Y11bCQz3XM73Ap9nH nXlIH7px8/Shx7FDXRZyl2WfWchTEz0abiF89ugD2RZGIeF9Nr+y1nCXKVFFhv5evjhx/e74H1wF WXkLFWe2Mj1Djm28pZzN5+hYQZTR+CNpNKJHn+Ff9a+MOh8Os9i32aLX6oUmx8SyxukTXrdkT/TH MVVOuONvXS1Zsh6itj1eWG7cKMB/1i20w97nIWGI/aru+PNwsPh6o/B2f8j69OjFUVg+4NDbiS8R HMzP9OTnaHsxyMb+XMdDjI3zxDgYcUoJr6uC+3nOHiH0+kheT0ujGvxbPSI6LoPhD65F/ZbPmPPu OHBKg1B7GEhfQ+Ska6J6dL4/pLYeeXf8Dc1aAdc/X8sBqVBIyJboqBTBORhFANkhWT6EtCfQSoSZ UFkSlbhbAO+TDJDrmDIwn9CAa/BwlBfLWcW4vi4SiTGlBiBENGM4q1WsLyZ99l0z1mQxlfTOeOMX e3BwrGMZpq2qsOPjN4N/BS9MHKfl/bcXNUYWwIRls/OU7wcfXExywAKjASMIuQvHFYWpuQDyGNJ6 RwgnWO+IT4bcULZkEvGRuwjSgYQNszYBk7x5qGHvlkhtgsAE5k2IkY0Nkx0BV8WoAUXNOkrZx4Y7 kohJ7+Hnz7eY3f0ZPPgownHitzy7dMuPSBaQITSQ38rIw29OW/E4xuGCH69+neIB9W0H5SrtkWyl ACdIoN45Uje3uKUvWmmeeUdpTxhTAhTPWH+1XHz3xVwFirGBBCLBgQYoCgIAosFEYxWSRUmL5Hh3 3b3eX3fM+PBi0GGqxkzN/P3apLrjDuGaedy/33+1Pp/j1NzfqefakZOFHJGRAcadM5IlBbcTyTf7 MZ/TyHxCVidqhN8vFYxGbTv5g07H9rvZQm+OP4H7he5VOJM9Sc5O03HQLOhWtrujVvsrkTpjmjvO 7x9h94jrCQeqWDdaEUiwIkggwYHyRSVkWIiCoaSDEAqRSDIhFgdLXwNv0LTQL7QsY4mNO9u/75/o JVafpxx/+fTgx24niuHZiELsnA0GBrfV8aVeN3BtVuu+uOjyxGlshU3rU+HqtqNVFZLZCWxddrrU 7vVhcnWda/LxcPd+XTpWim7V/bE0/Twr+SS+r6aWzfsehRZU7kp/wELo+WtIl/c3aVKjS05Jw5jJ h0YQY/2Q8qH6fXOmdcTqmdZKbeH4fuF+t+W/gUX+TnRqOY2z3rpzmoGZ+fR/Mnmn0favmTQtKYn1 NuM+gi/bQb/hUt/MpLqukMFU2Pv/i5KSneZV7ihGEoZIubtDDu/w9B8NGwfHVslsjFaqfM0UrHs7 l7+A4xXHyB9UWaMKZPb9o+OpsXfB4nQb220/3JlMOxXt92yJpf9EVBdLG/6HD5GqXMzbwDDh6cfl 8jqMyfe0znxmwqOz1vmm8T5fjPKQsiTjEh6ufW5oFgmStiL1NiIyJsoEhxaajTe3BetdEuHwPWQo TPuuEzoHGdP14LWz/OSh/r/32oT1sen95eEH2j7WxCCdJ/9WTvsxV7ER7vv5dIYapP6s+jgxKqu0 SLtO8MeQkcY22P1d/yR+mUo/p4yY0XnJj+7f7CLvGcHhtfbxMag5zRzRx7ywT7Plavfio14WxQMs laPh13BfvIQ3rGTJdMh1+wrOp2DBKhypiAxvC8ocFwWbgf0sw70VBdpq1GwUkPrfox/t/obUk6Aw /Hfguapdswb9cf34ZML9zLSf4+LxrCtMb0xUqRP+ef/F9ohLLgP+a8POuTRz2udQ57nP7Ev+q/RG iHD4qdrPcyP9rSAYKciaeofmEdEiVb1aIYZDI8fEWwlYaFohM/20T1Ih9LTum5gU8nlw+7f4HMxU Xb44MNuS/3u2VyvvIKMigXyl9kdQCEWHaev8YQeDYJOiXYcQksu7eqcaPssoDwRZWjLGLIkpoZfE RQEsmjl8MyiQwu+nMp+0VSL3jx73jyAOBxQac4kjmE8Rc6cDcQhDJxXGcwHqvM/pdbfnRz+3Fkxe dapPTJvSaTg29xeYzjoktVLMGcDIHGcZ8S69P4MLVMdSshTn3ufZx4h28d7ogH/R2n3EVi5Lqf/g Ps4jOWpu/TS/0t+/60r8cqf/wZuHbrtmxONXHik2/JOH8/7yrErp3frXUF0TXptWKVhjKW+qW2FJ kPVbl0XHQc65VocjLeYDHRCZ4KhcU14wkfgQo/DBj1J+aQv56BPVjbzZ5PDwBrSgmsT1RkKtY0Uq UM6hmHyx3eMo2Op2QptZRKfn9uJL+kb23Gx3/v+kITPXu3+mRHr5nT+AGqiJwFpS0/P95xD4nz4+ TPYVJ3Y+46H/O66fV5I453vFGSxTxEmf+sEyMmBwWEHqFVUZTrL1SjhuwRtchN/Jt22236jgvtfP mBH7s0R3lu3y+ccQG/kD4sw1yhV5X5UzZ2SlrVq0kP4UJpkJMnSwNMxq4EuHna/JD5aGX84Zstj2 NkWwnHZUE4tQ/8So8zHlMUDAfBSQkUw4BXjhVFRAMDxIcBANgI64JC4g2ICYLYUjnJM9OYODaDIr Cpxg+WYTKoQHR7zenh4cBnysRo9loYYHJz/BHY/By6pqBhFAqw+EkWqaJZHaDw2d+hwzVoA6Zlzw T77LZwlG5fpbUxV0jNmcGGNHYSr3nGDe+Rs+vGIqdoPHjWQxlo/M7D1VPeTgY8QRD/UclDmbYi6O Ia0mlCMIP+HQr+Pz0UKHw6j+o8c9Pb/vSTn/wS0888t7U9/PvCh6dM/vBZWpsP0hT/a17t2EE5r6 q2Bg4pHpWuh/QG3r3j5t6MOKxdRQunCcPUatJRgRgOyfKiKwNTKfXcCH2P+Mo4JOC0+SHjEj+0Pv zNWmln5n7lA6ZnFz5//16gWKg4pmabEo9KSeECRJmtkPkh0nr9OjaBKzm/i2xLWoJAuNppktvFp7 yHbsx2zmEJsNfR1v8zfvKHyHucbRKY4UumlwGgOl19WiEhmTL+qp8mZmn6bf/Lp0hjFWi4sH6Xhw V8/yJY4YuQRgPzeBh7sPs+lkE4mVBsOZbv92XSqxdJUE+ggfqMWxnCO17gh3tK21UB/tWDgJYtwo HJmH9S4FkPx3xP7ZsmDZZZqhMeH6tf3/r9rxn/Of4zjN/4P3V+Wfvpv9/8bifC83P2UIIMkFIT3h lj7qfYYHBX6VQ7ywHiTXV8mRvydeadup5Gs0+XNi4fyb7JIkI27+whj5cXnnSjWcn62rhtWuNjRL GpSFKu5YKrBMcflbxBmT4AryRMHuOBFYJENnro2QOJwDEEZh2mRNmHTuyZh0heB/quLasmT7+N7o h5NYyv2fjrDq9Qb2S4JpOTx28XD/4FyQBhBJJAJBeW9sWCISKJ/PEWRD+dkIfrIhcxjIf7vu4/2c GGgzUfj/L+bd/Nx/ylV938xz4ZNGr7MWGjWRMvZvb2+ZrXX7eED8J9XD/i/5cff9vpfXz9Sz+v6R KrJTdYa/WRpx83h4U9DMiu6s2rZFQmuJodUiq3Gsxyz3Zl0qHHmq7UeIkbYu2qFo7QlotY+ZFTI4 PR2rG6JW7lRlLNSNW6fOtxbzmgiw94idsvu5wcQNXOzIWFHdvKK5DuV7lVIy7E1eZKc7FPLIs43O 9wPd22kRrWc9OVUzPVypndhqr5ujixM7wRWAkn+u2Lk+GHAuQ8a3Mua1jXIdYQrYqWVc3UVRTWe6 +N59k9xo1WYL5ebUq0qHBlESmZkGi3XspI510A9zJ3PYMFScLIkq+sJ2aRNapyQnWDLkndubqTRr Lqr3Dgch5akzWEXSvupaNnVQosN5ctPJ3OXbsuqvrsXpCa1HCpyZh6RVzlqxO5PW1gIa0GtynzFO XaYJot6NG0xrzLkK6Imq0Wz2jhSBzrk1o+AQD4CUNrsfqyxyE3eFWzItGSJNyJjwYBnRWG7t240S LHXmAs6H2XJqghbrM0zIXhYWW+21I0jvcN6GCJVqoqNa0pngQbCwMRnFmDkUBb5mNOBLOK0P7j5/ EP4xqpPl7zUbzleJULG8G8aQ1FzsdbuHfTM5nAyDQNH94WTMI6MAixjuKmqFwOG5glFMAts3LlGM aH/KlyjECxZuo2banDRqWMwMRqNk0UEuINNFuhVUuxFsFBqtVLDUipsbP8YXBMgcihgY0LIHJVbt k5YjVDAIlgqgFWAQCMYAMBYgFC2wEsptiq7H2YuCVuXh4dm6w2tJXhKhdVLLqCQqEWEimcBEyBHa IKbAiaG9DECCHWKSJIEiApxfiY2tWtq1lTgFLggbJdOEyiduf87v/Up/7Vo+fp0OfKrq1KUGaTfV 45nMPf9PpW3z+eV+X7/4RHj8NL/T9vvn87A/iXSDKMRlP8S2NbBffnJMm5lIwnbnq/Bg3Pz8J/O7 n9Kv5ZxOySiUgJJkEPGTDzw8vFzKdPxNJbjLluuvXSa7rZSrkqaJZCKSB1gomEHcOdqaKIjjLpsW ccY7C8d+xdM4tolSvrxR9r7eVvl79WB1zTzirFfCKahNuEmnHyZmYSUkSC7+rist+xyR6/hjZ1on VR+jW6zS8SKJSASIUQdTaAJTUBEtZMiMCxgMxm6+F0lREdXynUaxQxlnGe1Neo6duYccVCz48HJv 48HV48HdPBakhIMk553DvGvWh1wEsUh+RVyzhBBdAymqBA+QSBP5NLLy/zms8ZLMkpIUw1ptA2NE /Pnxg7XzXx6okupz4REGcYtYRSpIOhIMEoq2GT8nZidQtGLNdmXK9zV2ku91HCjC5rZu3N9KSU9Z mbtvCBFqmlqaranCFVbU3dkIwig82RoyXM6NnJVZn4wIiIgfxj6xRAH5fqgNoLIjrNoj/TLRZAEk P6YJIp6pf40gc90AbYHCEryk4jCb1SVnaTHe7WSbGAfiznIGlblh9SVJ0gQ31YQ4gGOdBfXShpnR XXpRX+mK443qg6xCsfhGsELxA33oBtN4DlvQcobwWsaxHpADpCTTCZzRTbA9WE5SAs+7qhJ0g4EE vDOGMEwgZw2iN4jrnRbxJrRAswivtf8w+vxmFl9fwex9vH3pknO49QNl6UKaLEorgYT2A7YUMO27 SeplGb+LfDNaqHIGXNvOxDVtX52AhaGy3KXs/PIpPKEdHEnzK3sc7O3EdkxtVDsLGtG5cGILIJek cMIA2KFXtaqDMP5FG2g8MFG9IHAzzsiDCpctPj6G98DEuwwgRmw15m7l63fJKDyJtDsWHhLNU09W wnwLywXH5aJo2nYKlle2Z1nfcFNLZoWLG431sjPMRtvzfS2iaNj6PNcjDGh1gY7q98XLcWJVljvU wW6aOVblCIhUvfAowlXQpUUxIoXVV4cE2+lvxg4uqPQdZ6MFaDiN7lxHe9amPwwnBs5qx4EEiawu RxhRID5I6QiRZlfC2sHsW+xtNO/kxSaQDQ8LzneTccMX2s12hVjY8TvJo+g2U4jnN615JpULwOEL edUm3wdBlyRwPtBQo+su++WHKCth4VdFT0uhZVi6x7DC3ffNBJGeVTVAQobdwONWCpK88LLHS7bl mub4OW3mVjcagNm2bBpRmK6OkagxyV0TLnBYzpwD1sx4nIHhKtXKVoWjoe1q73fJDC3m78zcqB74 D+aX8CYTT/L/r/zswn+Xzei7EXnB7vDw0Tx5DD7TqpxSSXeWO39vdyc/PhhtLt5F5OL1224wvxhG 5K4QtXKZwfxl9InP5/LYJ+Uv+GNHypO/d/VuQOH+X/Vv8IINftVwJIsr9F/pf+mv+dQtpv38WaT5 35ZcYSQvIQ9Pv2Hzx44GPl5TenLOaVv6CEu/09ctP3bHG/1LloEPX1xtlcxKbr67Z9/Lv67fZ/sE f/nvpKlSRLCiftKoFQGQFEqKAFEVFUsWpQBEy4fj5K2/f0b9/73ZjNDeihz/P6+T3/bzYkBfKL6Q N6Cvy+dFRBDgg5NH1fbve3AbodEVOrLlza+n7cRNFf1/H7tPYdY8hBR/yKsJLN/3CFImJGMC/2v9 GGE/dpsiZIZ/+sDJuk/3v82go//i/4GHKXUl2QFncySQUAnnezCEmhJICkBRSAoECEEYEIf4VSg2 IguFilAn5IXf5hRcCRIKr+UgpWi+yKMIgEIilv8YUIEIoJBiIf/Jc0KSWYgpIIUBEHD5z+vga2e7 kCAoRMjLFLaDSlRN2SFQhWFmFhGhYS0oAiRSBmGGEIChJPfKEAwSB/i/2pMASPAkQ9skkkLAjFPk HeCodIRUA/UgpBEAO0H7l7A8QuUYgfTdRJJJIQCwnqRHyXwQEPwWAgl56hPFREknnaiskh+57mK+ II6HSaQUXlV1GmKrFDY7mnTU0OaFUwUTEsSlaSFq1LCXUuqt2IRSMbqlG4jwCiX/cQJGRkJAgQTd EUNPzMhRb/DhhluXBhYYEwmENAYQEIKaC9QA2MiEkIJFgB1YoNFSyNwFCCJktkwBQDFV1Ad1UbGB YyEuAFlyQVqtgC6VFDIAQgAoYqtURsKuKp3H+cYoeYxfJGJ/EBIW/nlhsJcf9WzcmMn/seUi0JRd /akgQf82UgkH+3+Xxlie2gLS1qVogHuO9KHNKwQZ+9//FVcJMFgkg/qKBYiSD6U0A/v834dV133/ o/JcW+Hu9T3Zz+jN+mXw8ZcTet66H83t2UQo/f/5a3tViH8hDt1f9PP+e6qurVh6fvfR+n47v+Of Llx4b+j68nx/2X6f6F0f797m7uj+SGT+SrXZ7GZ44yD1nj/2/5f7v93/r/H+nz/m5M2cTo6ed04X oe0hrkgp3kADdlykgeo/171guwOVWK5IBIqo/gfgUv1sH/TsaGorrhCQjD1lIH9MUNXF4nvvDALR 3qsRtiQhp1FncRhEUc8UXeIL3xRLSLFf6CApYgAH0xR4I47U/jgXMXbIQETlhP2BkA0n+ZUJ0lGS RGRQYgByqiGiClEUkf/iIpgkFLEWMWRSRJEWMhE/KQQM8AN6IXEAPVE/aTG9A0i/1IDZgskGCq94 K0IkWJA0wPa2FpQqBPsVVVURUmkIMiif8Jtij/LpJeVUKtRUqkYIK6YuXbpvJXj6fT+u9/C6eHnc XYWLTHNvZ/jMWHnX14/6v47tfh/B3ZtfrtQ6Z9jrf1Yh4/8Tv+7+e61pZXP/ylCP9/1d3s6P/l6d Bmtd1Xus1GlIc6DnR/EE/Hy3uFm/34/1g4Zj6M6QOmG7vgxqGv+gtKbTk43/maI/7CnqnzJf9/+/ Gli3t48H/4EDoe4MM7LoMeXXNez54a4xNkTZEPVF98OomQVYh9J74Ws87zU2j2+FaE6vJEDuKHD4 nfrwahGrEx9X6I9Pxr/h/5YP/4uOUddvTf3LENJadFh7jLf+3aEDq/5n8iFQHokM26v+U3/v+I4P 3Z0jt5I/5r067d/L394e+DjaKOY9eHPOfHz8vn4mrOmN+ZOPOPFPHJvnL3JfzHRIkvrLv5H87djP /LD+xPjl48JrX5SSoGnnRwha/mfG0/klqVOl3SEe4lPI4uywPP/Hj/C9a2ue92UHGEnvffD1JXNy VMdMvfnm/M9r4wyP3Om1D5unX8/356B/mI5PORvtJegfrXKJmu4OP9QD/X/UYjT9+suHFVjrwv8/ zB1g+AwcA6z97jM59vCHB7xca8QEXXyavl/z8MNAYkY7SwWPEiWho2za8Ps397bxmduDno4WJZYv jncCx74YBdxMe4Ycj/t/pyuov/1Y8s3G+WMOj/st5hGYmdM8+gbWvXCZ1IvFPjrvi8Fwz09LHRdS 2lJMCMopqz/X+Vfj9S6xFxjFfNazJSn+2MWjwh5EfNnrJnOY/7kyhCF4qNNQlLbnRLsFymBmOm99 v8f+79f8SRaCi6bY9HboHsq51reS0vGkMiWC7I0vxfDL9f0tpjzSnPIQbDD/DqTufEINW0e20Nv6 fHWPf3nUbvfL9sf795plmbxX/mffrb7zl4K181jTcT6Ut6bDDm7494nVXnVn2yyGdHDo6Gjrf9vf 7/7TSD93N8YcWKX+C9+eiR+rRD+pDRzd0J9xmQIrpz3nr093+6zL8Pr+J5t48035jLDfO+HHzbx/ ZVDaOKhqYoObZP1nvXtf3TieodwraNNmVKlvk8yYaF+6enV+mNMU+rik8Pi3WXf+Ssuf7W/4V/HH O5Ppn/KBSGpdDUj9D5d+X+Ll3DM38VPnH6yc3tN0vp7L4MzxApSvqVZQiQ8Qn6/efb5+z6M1mZhj /daFhfHek91KQXLs1TAgH4bJ/C/sVSRUFIwagMDGA+oX71JDKECOap/uKhipKB+74g/YeDnU+jEE IxDkfM8NI5ackDq18uP3HpiPVPlHjUiT81/p+XX5/OPk6+/w6bs++/XDUz2/nCFvM05lg9vJD0s6 fodc9EunTnEaUnDN6+IwTdePd55KloWAefh1mPgzQP5XPf8EZwuSwvp9vh73vx1Tv4ud+O/45k+k /LHyKv3aP3/R6+Qx7NHzNzPDid9V68b8eKWaHIcxB5FHiS/9D5jpDU0zj5H84fyZVa1N0XzbqI4h F/6y76ClZ9reQ+ZEDdPP2/l7DvLjPPb+kDnTudfzq6Bj5LZ+vLixdGGOxsOa8tiw3ZqHNrPsP3Hr KAhSUiMUAhEGRUVkZEBg/6f2fNH7S4Ly61rf/P9NGAdEEL7Z6PSKfv74FIt5oCVKKT9RtKf54qof 3xRB+JBBwxFI/8CzSlH/XkmBPoz20UNCqvFhKyHAyUTgQKxSQ0wowk0PDkYiIJIn9HHP/S7A2SQS ERZ/dCgWQG8g/pif3x/dP21Sf3wDf9qwxJ95yUUh/oeuqN4yQYgsJ2JUANo5ROQ+8D5/LpnhL7Hd NcxedqsJ/m4e3MA6BVkfo/Z7Kr2mje3p3/q3vK0MTVZP6StJ93wxFsp8Pp2vBThfCEawr65m1fXj wDS5Cpqy2/yaNF8w2cmi0ME+nJ9XEbLEM6h5tDf/RCWFKmz/wCqdEOwn8f+a0Ue+3R+LevzLkiLw r9boZwgQD6v9VRSupIqhdowUv9L86Bzfpn1HVtpj4Y5TTjSnocbHQnqc5oaTvu/Devq+kgrH2cJH 7NPguKML9P5gOuc3CENGRP7yL/QbDGyEzxs3d/A303Kczt5+D8EKS/ArQMxiU+bme467c8m3XrKk EAmhd3d7MWBlUp4UB+0LwkSP3ghf3gMrh4+ybe8PKm8GHxKemdNIl8M6Uq+XbG8aymUS5O3xo9OM 8PV8PCmMyaeyBImtKGkyW2jRA1P7OuEl1h6140x9tMfM23JDw9/8EnMprcMQOhK8OXvrW39eTD35 WrzQC5F8RMtO1XukwlGW89qtfR0pXBJzVaymwi5nS39d1XtBgqQ/JGq+stVk/RWQtZAgVzt3tmTD +vTEgf2cOw6wJFbbbaaWM49eOPOdhg+gzRTWBahzjfr6PiQN/T7w88tvEfmfcSdxm/K+Ojy3f2sm f8h0F90a1jdSW6U9QMfTsf9vv6X8Xqa7AfhTdKiFEptKT0hU71qVK2pEuhel2b3aBgPqQz3+NX8q 9/vB+P5/+F8nN7B86rx87Jvz8m+cGd77P5XDRDjmDyzPeVIu4yUIt5gdEKHEYPq3HOdJ2GYB3nLI e8xSw0iKcu4rpfMYRMJCpntEfeXlDwGtm9JDWWF9x2j6MJfUNqenFhWGCDjSPpTrTWEPkIZv+w9/ jc4NO/XpWQ+Y6vzhRSik3C5xmZqnDSNliz8n2gezBRj+dZvppwPaQRqz04Qv2KJpgYu7JYrBTzDu e4RvVvzWzzz7d36aPSc6LYPVU/Lq6q+D9AP5I/uUcOdEhgZ/z3W3Fusw053R+v9X8FtI+zWlNjY5 jHix5B9CHHVGzGcpM8AqqQ4HmkHpXe9sO3u9MH+J70ePH/tSKP4oBUH/v86sS6IFaCmkgRK+H4XH 0n4H8mjeHePoCCCoBAj7gdYfYOJ3wuHAMQlBTwhkGIXIpwfHFMC22FEkJXnLTwqUSF1ijmSZf90y 0x/Qptu8v7YUrqf0Ef+UCh/oH4ioH2j9f6P8hko339p2vt9mk4nhp+fDvPG8btOXhWwHDwJhvGlI aQAgSoowTjUeMJ7NVNw8AQTwiAwCAFhNIIcCPMJQagzVBJJIySSeqYnlSohpXM+zK6+k+37vwDT2 nQeHMA+ficHCF5oeEN4XKbn6DcI+QUqhkUOUfgJSA5ACMPmwFp6XGGUdYmMMgiYiIN4LlaUGlKSh LMRRbkVuBChgXULTS0KNRBoIIIUKFKUAFCFDSqNNNAKVVAiU0UDVUgVVCCkYpSpStK0AwRMg0UAS AhEixigRiikSCihiQFQuYAAgWYIgjZDoIrti6REsnSG5aKTnBWLWxLxMQ0jgb/ChxrZImjcsNUO7 gGae9Mx+x2dQi6Dm6tH3lygUCiCqAXAxqPC5iGbwOYVCqBioZAMVo6iUDAclCqFQDNKsGwuQ5BmF 10AzEjUSqlSJZ0CqZiGahkFRMw0cxdAMS63cVMwcRsFAqp/eDMZcLhqhqgKgEQzESOKFB1CqOiBY KhgGYYKpZMUoOIEariFTGF4eR0Lq7Q25pOUnOXQnz3EOe4Oi9wLvmPyAaljE+lwamA7hKe6BIOLk fx4FzYKIUDDX3fA30eDCFDdSqZpmxjxc1d4cQaBDlny6wJwU0YKwMDuAfIp8hDe5CiG1APj9ljOV hTTndv2rK3/lHHkINUhzAkDxqhMsEhApSrt5SVSmgUgbAgElASBGSASEJZGrEfr5fQwRbLgWm9nO cMMM3dyaTm9CZBCfE4lmpH1EPTHSMWcnKvSHUD0dS3BSAqAQO1DSUBYO0INFoXA+QeTMW4d96mNO /Lu6OOABqo5ou4NEwVg2fmK3Yr8MZrPj8DhAMRDIYtAD7AaobAwbC7ID0AwIrADiaIHuQ2QRJNSF DCe8AcViopFRVRQBIJFFURUYrOiJJCigIwOFQKBQ0PQQA05AUsR1zCAwk4Km4uPAXaJmAGq4CVHE OcXgYDADNnvDonhIwNATJ1PA8CgcgIUKTiSTZOwDqEyAgB1onrx1+Ztq1trYqUbRtLaW1IUJYAol VtqthWpbbaNrbKN7JCHMJPTwPxHAQ0GykCgYDFNbCuCVDINVwcBMwyWwFAGq7ABEWwBcgQKD2sBj 8RjQcVMxNANA//SgDt6wohBDJcF2TIGgXQBwW4OTcC40LJcGJmDsG/WDQYq4hqGga6qaDolRwCzq OAZD3gBQcRDRSgZZhcDFR7XAEMFKql1NwDILAOrquiSyKZBTRKDYMBQSw3yHAcUMgzU+h9+aahg5 BmlEEoBqpACgZXQ1GoXSqpWyBuWTYdg54qOUP5ayro6/8d6rdG/xXbuvg/v9NfPXXoydPF3abcnf y8l3bwcu/o5bdvd3Hz/p9PtbHjz9+P79vtjnhuO/O3U9jv7eM+31+P5+fHqTuefVsfL3/Plvf7Yd /TLnR/Xs7XKd/jqfx9OuePs36hOMaf18d/j6ff7fNuvt7cf7tf8X/Hx9f/LmHb/p8fx8ubi/2/f5 /j9e33574r7+IfX9X/XfPnmB7499U+kc/J/61n8+fr7fP8+32/jNr+f38Z9s1/ftjntjziWq3/Xy r7/Htp/56/PL+fl8sfL9y3v4+vn8fTnv6tX7fbx9sfvu3s+Xs+3y/PJzj/H41N+/U6YfyX7+PGft 69/x7/b17Snj36/P39fn7197fK1Mc+X0n9/46+vy9rvw7119vx9admfPs697q55CQkkkJJKqpp7L WjMW7Vv7uXmy83X0TNv6f9Lfav1k6ts/P7Y+evPX1j8/ljzrePpCPz861un8fx9PlCbq8p5c3Pn8 ef3z718u+u/b5uj/H8NX39fufPnD3r8S9m/XvWzHvT91+ecb+0J/PM/f6yd9ttCXxiH3g/29v1qf j9e/0xuf2/Py16qO+fz9bb9eMRj56Pf5v+UPD8P15i35n9bQ+2vzaHvx2nS+I+vk+/Us9W+1fMPE KR84+nz/f8Q+16Hx9v33M+/UvjjyH8V8/fHIX+M+HuaUb3+cOvtPqMf16d9qS+Xb6/L2pCPcv4b4 lJ1fe/3xj8/e/68/GrfOX1d8/q/85+v19b+tzx68+neO684WhX7/Hnrx31isvHzfn+K2zKU/Xh3j 386pjy7XUXu69fuW57vWPX7j+/ef78P98Ybz49vVI/fxWH2jF/j6+PtJ1XWb5V9x1ff6fb4+dr/r f69vaX2+f1xT4565Tvv9fSMrY5HX48fY+nd4Y+UT598apPD/tK3xqMIeHvs5t/Ol6/fzOXecQfin vr7eKU6b9Vd4d5/P0+7pzh7/Tzb9R9v4pPue6U+l/11L6/v+Md/X6a78fT5fFeP61+ujz51h1uW3 6h8vUI3+/j9/J/jFdRs+NYZhv2x93eZ0n7e36fr7k5fn38bZ3rr3+ftD2/j31qP0pCDp7+lPD+ev fXXp1NRvXc4u7/Hq0y2uY98Y8Qpv7b+nzr8Ox1bxn0+j/l5+LWnqe+fv5z+94/KnPrD69bxCH1+0 /f8fP0/978e8Sft7fjX2fKP48w+Xv83efp7Ol/Hx+Pp7/x7Y9vp9Yedc6xv5ee6Y8ntPcsdP/iH6 /WMud9ufvr8/rP2+nk/cfhv1B/7+fvv9/T9/mOLu55+st/X6/fv+Pzd9Pm3v9859/nvHP4+n079/ vKv359XZ+Hzt+a/f9yxHHPn86frXUa107+Pr9ft6l+/dvnP8w0/rUvOfxHx+vp7+Pr3yv0/F8/b6 W+/3bz02/p9/fzDnf8Y51ffj7/r8/fH3xD29/w3j8fv8uGp3+d/G/2+mrV8/qPu+k/Ufp+8a+9b7 mfnz+/r86z/HNfnrz8/tCPh9fi3tD+Pt8vv6G9vp9vP1bGKHuzfOeOW+VL/r5/elvpKzo+9vx9Ne 8v39Pp5+kPX1n+t5/N6ay/X8X79n3hZ7evP2hb8N5x6/FPv88257T37Ny0OR+ffn52/fPO6ePk/5 N9v376x9/p5leXy/PjMvm2+fnn1+Xr5v+fPvjx7/n3/I3Xr7a83+T+fv8T3n884db9zvPt1OMXx9 X8x5rVr+TxinmnOp1+XHU01H/wweK31n435+cItVz7UlX6SpRrWnaE5fbHj7eZeZm9w3uLb3vcWj GMYR59/zL7/b7/S3mfrr5fnx468ePp1mP68+tQ8esb8S8dw9pVPx37+H+rfvkPPXxWmPX5+e9dfG lj5+3zzHj9Wc7y3Jzn9t/Pxj0+fzp568/S/5pTFaUyfHn5/n07z+Txr1n+Jz8y154fuuJMx8vluP 2tL59w958+n0+Uo+/t3it/s3f7j+L/Lv5fxGRYZvHy9/p+q+Lt+vn+vz+f4af1n9fPdX0efx7e34 8Tz7vy6PUIEvpK7Tn8pwjmz3s0XfT6/r2l9ft9P1+Y61+swG9/efvHz72+fx88++fl4xTTfWdIc8 ++913uu+vr9oP9V+2IDTEzk+joJv3D5vhzqHpoR5/Hh5N0qOP318t8cN0V/R+VGD/p/H3Hy1b9We QeatVg4V5q6E13c3Bv8vFo3TadUMXN06rsnBhYPTrS98S+nu/bBVs/xd8KHqP8G4RfCn0jX8t98n 2PbxttzHt9Ot/fH0U/B+vqWx0fLr8xfb42FOvl5xezfbna8a/XmUp/pfYHntQbxR/2kRo0/u6tPc bTvp8ea25rr159rwh8z2n074Pr+fr3v0780pzBfzeH8fOPp+5/b7u+8Gld/jrf77+Pl8j8/e/3z+ r/T7/O2va3y/h/u93z+nj60+fM/L9fP4x7/j6V++7euvt5j33Xx3j7e9PTfvx9b4+JT6+66/NqsQ P139v4N/mhWT1gz7+fv+adfhvM/rfePi3yr+m/LB3f7dP+kGjhuN6+ee/33H3tT+Ppx3sx+mfJnf p8GjArTnn8frmiW/nP41D37f9vzuX3+st5/NKeMEvDY9v1n640d2d+c39u/a1PX8Yf9f3+Yff9/j 5x+2vj7VGO/X659evv4+9vl+PPc/j9y/M/1bx6/Hvbx8T+Vcdd/iVuv19dtaGbfLHn8y/e/ePXcb +2/nb6fOf719d8+/g8/x8vb95i36+kf4m6vw/zx2WvanJfT9tn9e/j6P8+vrLv418tkCK5941/jx vy92Je/Pb23f3/XVW+PfqH5huH76j+e5fmz/jFvj8d39vr5+n568dfFfkZ/Xtn94+Xv9PiHU/fjf Xevpyfw/3719Pl9M/v7T2fP28/aXef359Tl9O4/WH8dzn8O+rp+XUn7dyl39vOtQd95dcxz5Y8fn Nm+3x+b9Gv3+fP4bX19/pDH1o9/XtKF/X3174p+/4/PXvOV3bdz9Q+PaXyz6f8vPtT29r/x/Hyvy su4+Pl93Y+f4z53/Fv4tHpq/fnXLuh84/qf1vzfnvH8UtP6a+vU3cx8W+H/jzH2/X25b3hufl/z/ jFPu9+vEZ/b5118fXGfz9fOvf9V1v+J/u/Vq+vnb5O+v48fjz+I18xv8P1+5/X85w3fvvd/b8vfH H34/18vX8SbNoOrP6WdXzb+P18+44p9vj919+pfehL36/j5/rDfnH1x9tHtP8W+/1p3L5eu/4jJs W+fWW+ePx9KZb+Pp/Hw2ep+vfj4R9vb8X/PefrOninXt8fTPvT8V9+/q/83fmH1d8oz+nWYevr9r 31Tx9/PU/4wfLx6+MfK33hps9e3Ql4A+YaEDwiIXwfdPtqI4hNQouwYncPtuhq4hmo1DyGoGIFUs myiqA4A5BgoYA6OmI/IUBiYBcgoYN1DGgBZoBmLkjoq6IeHHgpgEkiYA4HiJhYB4OAJqI1RwRyEg 4iaIYBFyCpcDFLJoGAQQsuAYWG4UHIG7BqJcKrEMANXjkhJPM/29vBeXy4o7rVdhfcfZ33vYX39M uZuyVbJYQcfAulT/q8DSiBP9v+f375Ff222c3n/V/qr5ufP+IEh/tdn2n7pp0GP5DULk8P8N4PzO MrD/JhG5BFKZ/Jg0q/H92ZNJn5/hrf3fpWn+VVm9/Nlb+AvfyS9ivv97/BJMGm4kVevanl/6k4gM 3h3TNb/dD/PzPOfs8tfrzyHliP/PFJ8i5X1A6g52rIbH+T+5nH8iFozv1dHuB7YU2QTsl7KQiCFR F38b6fggRje2eG/8ChGBhZ7KH/JfUp4bhjbEd2DuJ/gcfuEBm1NUIFSbBUZktj7in86WCV+G/3rl 55zKO/o+j+dev9v49TI3lE3+QIZD/vRjzvzqJUq9v+XGmHtqI/x/00em/TvZpQ+T8FY98hv5R9yn vebP/Mn+85XGTTaLh7dfO9R0P+793JwVD4L6L3gcKJClAcSRhob+FMiZPoFf4dCSGcpMspsiA9wZ HDcdA9pY/z+lj8vy/iMOgTbDZDp5gbwqkT84H0KFf0fn+j/L6C7+YLV8/zL/Z1Td7h1btGJGk6Ch NB0KJUCiCoPxwHt53gbgzCwYQkKZFCMDIGFl9omdhWXeEAxho1TNa+wmrrLLwugQxwydSmt3Z6oM mkSjFQkSTQB6vWv5xYgmEGrH1f3t/cf3ynGJ3kqszzjQ3KBcDtwo7maIRHhU0eBHVSwJczMU5R0Q CwG7sjHotwKoFkgMjDrGKRRRVFFixRQVaE9fF9TsyImGeUVVFJslkJz2qqqo9HPqoIrE75a4AtLm BlaUaKdzPawtoNBVA9kiyB6wiQa88DwZR06zWTSGMqe2cNZKqLK0VCttgpPfaiPfwSHxeKttrGtF Lu2Palcd1Lgt5zUOYfGTs9YbhDgD1noEDMLNtDUEIIbNYmyNRLgOAF2joB6nPN26ACBJEaxCG0RB RR/ln9j+91JOeD+n7flD2VeIKelG0OBmZClpKNiqmhwqIw1RvpZuQyTRGSFMkQLNhI5Zkytwpnrf hyXX1yzg+NBbp7bDnUz+SvFoOnpl4OHPLLElrerKq1cxurCupUQugWaG3AssPOA5ngbPIDCqqMFk l5Qh0CF3NNyHNdvMYYluQ6bmtfBY9Dj5UN7+oP3NUohh6uaLtzWFjNO01uzcuSUidQyHUfexCIQG QgEAoOKd3LL/Z/lJhwZNkpuqh2ZXhAx0dS0tImlDmFBZo3DIxCpZu0TBi4tQqdbkr38N8szxnzeF nM/kq3SFEGGEyCaRC8NFg7LuOCoOSeYEg41P7wYezbFfqrumhXQIQkIQiB5+Tb9q33x1rDWrmN0m aLrMzSZoRE0KUw1o0hpsG2rdWuGJdZpzQGGs06DRrWtNLRGJdLrWapTWrcrNCU06MqOZRyuiSGiG gDRD02SQsJMILbtprCmlbaWDrMxzMEu3MdSYurc1pwzRLhrNa0a1rSW0tGiIiVKJRkSyVDbLRbQL lmU5QlpNkhElsShWxSQteULF6fycwhGPqONOnMdz9hBHA3PPHmT6zpoib1oTQ71ksLmampthfkGG hFHjinAIkdh6k426EHjKcUClgoOAb6P8kBBT++IDZX9cQMIGN/QJRCMn47YjJU/yJC5MxzFyH+p/ OLk0LclY4L/P/wP8uf5OJdf58Jyg6OMgYYeZZBYCYiggmZvArOP81/zvO5eWXJTm08ZpMcwsMsae g4pk7HFmFtR9aYOKNEon/faYgURpZZ3mFiFRZyZrNMUuPGBYIzXreEP/gH+UOuHmDdmAlsxmA7T9 H4/1fp6l6fbSX4sU9PHzy5axquXLixXINrvz5smPJiAP8rOtjEHzp/p/O1RL/TW97ralEby7LB/o +koJFmHM4WoA+/8LuYi22G2wAyINVu5mCMzKqoinTzP9asyl/rfPvCALhiYM0JeVzn9z3kZPmtAg B+bhSlFNfTgP1OPzmw4Vth3f5VQjLlfdlCIyzM/KgAOIQEQlFUFTo5vvKhyJ5WWb8zGABG78xXpo l3CioL3f4eXzwOKV8EZj+8G6EkYySCqCxUVEYoooqoqIrFFEVFVVViqqqKKLFjEYKCKiqKqqKqoK KrBFIsVYLBQVWRFEUSCILIIqLFQYsVVFWLAFhFkgLABIsFVYoKAoLAVQRBYCyKoiMRZBRRVIoRRI sWIipBUYsVjIqiCMBERRRiMWSQSKgjFiKwBVYrGIIqKsgsQRVkiqKqrGKJFixVkIIyIihESKpEUY iCxYsCCMIoIqjIAijYzEWuAXQ188lIGPApLVSRh8xIbBQIga1xky2BbLbSW0LaW5AT9UncmD2N/7 /+EfkzXMkvY+YxXmkvsWoh7JyiZGkaLBJjtYffcYzHkE1wmWj6tWXnwKNcx2xC1jByETgsQ3cS2B cE6XqVMqs9wH92f0T+jWVlrWr/PYtz+P1K/G61MDFy6whD0xZAI/D2nkOxjTG1aNLymfRJjB/QQU AkoYOKRSWzvZnxTC9KkURupkaaDF6ZAYDKybE71nVlbdo5Ye02cdzIF4VBxZJRlHFWcKmTHQg6St DSDYizN4TwdUKyiNWCqw4HVMXeIqMyaTJNIygXMJt2KQZAwx0m6BI3YmhAECCAIIiDECON3Eneyp VK5SlCq5yJsM2lwlVgQKLkcNDajswEslBVc6KshPbBI5iYy9aI0zyk6tPQABAmK9Rj/plRtAxhYR FXUymeehhbGEpe2szytWVzBUcrwejfOtzqDJ4IRTtJfKaSYPSbZJ4yBtJiTEC96MkxIVnDUBM4PH XPbxlSQrywAU4SeIQ2+dea10w0J0JFJrKFQ0wxwMpPOaG0k6ZJpkNMDzQ5vQTQDK+YWSHbJvLICb 2OAeCQ6QO2IMIpDu2SaYYyYw0nHe+N89c6YcjiBiSeIaQJvuwNoaYNoG06TtnLMSSvLDhkOGAdWg dsJyyBtk0zSCl3dOkWKCnjJJYwPGcoGZMRhA8QwREDiIGmIudu1uWB5c8PDKh4/VRogbBEZqiAEQ BxAEIjMG5MRdmyALCZ1xrQGkkTKFRUVgLCLnFknOrM4vW7A6YcpWGMmIW0IReBO0KhFhWE6ZIeJC eZYQvd7Z5IwUUBQzunbDTHCyB26Gc+UPEiwJp4QhjDpJHykO2BwyQ5mDnDoJyebNdN2HKE2gQ2wu UA4c4vCM1CWEUhthUIjJNMk6Zre8l43gXVCBoZFWRSCkmMCcRk4NXlKwJrVMQMYHfVJh5ZDQyKCy C6tA080s2wDlkDzdAqQUnnVki9MmyMFCRdc9gqDU1qJyBD19IBBiABJArFRiAgIKKKQ8SHSErJZE 7E4SXV6ZJeNoJaAuEMILhF0CJCKOERhBv3TgQNRkRgHKcCSsrpARkhyk75CyKSYleGTabiEnKRYd 73O6cbDsQcqMDGVAqTlNMIXqyHCXVkxk7ZMQFA88r1TbJ2gpIVAFIskOWSpCdpA6iQUxI80mmBFA WTGTq2BPBgpBQkO06usIHb1510984c6wc3yTp5kGRInIwmmBN26Ql7sA8QOkIdnlhUIYyHKAdKkg oTndJOmYwJXs4Nc5xqZbm4Q45gFhFPGoSaZCpJ2naB0MFirA7tnQgeJ2yQ61SHKBvKsDO9L05rlm MNMDflOmEFIGmTxNMAUkuN5Sdsk4ZkSYyBtAmIA8F5SEO0P4EKJDNrt3g/myKjXINFqn8lYUg/mC dBkWWp1EIN2Gj7j3C6GEScdbCvRQj7AX1/t/HP1/1fsgN0w6Ip/1ZnyAhZPW8kMkWHHjX2AoYbMy Mh0oud+uf9cv/IeUSZJAY5mVogOYP/XDs/+r2lslC1B54PAnaByypd78cx1OErvdx/702CueW3jM tKfgAodjFkUP/H/q+mof7dh/zf8drk/w/3+e9FiT0FPrvyB+Pz2HCV4uviYzMmcJs4m5pAqFxCet r/9Qflx6eQbIfJoGoK1XUXQWgEALAmoxAo3CylBW9VukSyjSKX0nh+jvw+g6/f6u39OcyWyVWXHa XWwwwxY8hl8/05qxUm3ANNGuxVi81ob2JsWdxeS56h9nvVtG7XadFGKRGBqHAUQ8s2wFZf19e1hv AplHF4KbckCYfo1rj+vThMQSl4esMThLJgpZomkaEyxFyQkaZT/h/r5ditvK/fl9BL4U671gdEzN WHRMhqEh9gCHIGcwP9qFqrQ/PX8B/Iu6bhhENuEbZgZ43S4V2tgKE+H9zCdLlxs1InwNrlDPOmOs yT/pcjlDEd1dUKn7QyOeuoiZFsKmVdWKO1lVKGQ2ulkqRbOLpUUsGGGlMt8G6ZmNQMBCKxpJ1rg4 RnIOQTyWfZgEFgqERyB0VlWkKZL7uc/wz1NFiqB+Sb5bfUeFprKQRQtzepTe+JADMGIAKpgbYlCi YEvhj21uZo3kJmrQKIgCmuWG9s6FOm4ZYraZw1HM78CR/0IMcTRVRnOxzx1yeh0zeK+e6lsw22Nc MuCD9lFSkrOWoMXIMo567/4o/K6U5WLe4o+Y6cEyHDCnzoacTa5ibKRymnTLpG88Ewlb3vTDLXAq eKHRAVALpoGYBRVxSnsVyVdBJmSwtArFUCiwRdaIds9i502xqxVMQvkDBKLLahtrVEyigm4iRBbR AA7eVbAN265U2wplnj3K2GkRrgWknlseXn7rEJecbl+Rp04PGFnrYp82z7ha+MXSpc3BIsiqECMi BGwAy4S1UHFB0ROF660gN5tPhm4mm5A4FJRGdIwaJgdDT6sqwJWDlxBSVN1KsUk+aS4jq6fEx1MN UupCu+gkh6ZDiDVkDBEuMjD5pFQeSwtaoSMDRwQtXfWCmAmYlwedOrQdPp6JRsNcvrYTAPOk5C+U FjQgIELGFbTOfKYJrYHrjqcB+MuPL0zv3+cyEDLUYY0mx8vrhoEGGhYAoJwJNj7HKiauKmpb6on5 9Dvn+9oGoYjByW6ao3K1dU1GwxRuYDQGwWQtmCvBBEcSCLtm5U6VzHMWhbAAi+JNBpBB4k8XgW5k bFtTSXVNjnoLsOMISLFEZSo9IixeKqFkBh98GLj8zruSgxNSVJ0KA4eG9VaAWFodNgk7UKI3pyAm IluBDxFCdIWh6DKe4thiQVdDjwxrhFKmjBpUsQYveSKXrQzuNllAJIAmOcTa1dNJyecgFwVUltnz /4CmQpLmCzxxmDK+v+pJP4IQ0W0b2z8Hcg6esoahiju33OiD3w1UKHHSNetT6gZIYI3gyP/zXIXu KyjMM0gU6n46iTOnEqYzukupdvymG/kkJwH8BxIXK4xx5BwXinQZhhm9WBtnwfnsvHs0x56yLD5a 7iGu3EN97UMzOOuuOszyXEBm5yAHOzUhOZKMIM0SgokQoRQDARdIGXXS53mSbam3Xe4utt29RUUv AiJACARQIEQZCSn2UBFA5K1oixUbREl3PcSaUUJSAxaqICFV16uoi8Aq6vFM89Yma4NS1lF7zW2u 7i5IYaEhR3qWeCNh9r5jqpcYA3pkTuyoIQ0gkngyE4LeO34Fq65eXJ48VKFaSCSSKj6v6hE3ueW0 2AsafTYt5IGe5vUCacD9OQTIlcF1LNaAtpshpz4jazJqkg5fGGbe75jgb0H4HMmGtMY6IwrGLqwG JNezJDLF5xRKqHJUYoXeiGhI6BAJQBh7RjRegGzmQX8x4iBQqk1ARD/Bh5+F3VemcmU5hMi8MyoY sEKDZyDDFaJVXBdhPlkY3DZMFdE3ammy0oA6VBW6Vg5wAmGO2Be+Y4lLAQi3KphmBXphcG6REoDZ iA1EkwG3JIckOdBi/Rm2DBedkjPUpjRDQsTjQe0QwIJEMSWJk8uBsyvv12HXBDAixBMQwKkqZQJn cqFcjBdBUzdzyydbOAcst5ANJkjm3JPW7ha8eA/j1XMrg99YByhoZ2Hijdhddpb8OyVaCmAWtJfm t6XM4duobN/TaBIngYrMCeil+EHYsjSqFs8ynSE8McdIvbWnKFU4j155ETKcLl2yY5pxXUsHY7RA gcf1CRGJRr3DEau8i9g/6AkIRsGZfMO/Mh32XVoJs4haLBylJUNvl3Jg0oxcQkQy6bUcSzOmSXFO tFMUwuAqhIBXEuPKyYC2CobVzuZgIYZCoGDRAWOE3Ko9PMeSWnqrpV7dHUJCSAYSumAZJYGwQRup BUqrFGKuAQR2qu7pBrR4UnxH3ohxC5BkkKhygijAi0wcE2kIiD+cQoi0ERxWagkKkoBBa1MQSY4o QVVfUg2kqFws9wDMoFjCc+RNWepltHRsbBYLAerXSuBAXownHkvwD+O+nMuKEnvhOCHTeDOgqCZw PLwDc/5if7QLRcV1/ziydGJDxO8LOyF/Gmv0tP8Qjm0czy+BmryVEAkgCf5i8rjxnDqmbOjBjq0y m1ZEf2kHBfUNU7tGrn0wW218LvimrazWqUXUgzMsJfXVjdpMLXl3jfOYZwOxZ0C4BZTAg6BZDNaA wwSaS+Iju20qQiadmgg5sAAvAC/n6F1XxJIAcmBD8E3oSDtzxPfsVjdWriL0D3PfVIDhO5TmKEFY PFDoerdFwq7KNEUkQeBthBs0rm9VKppSjq1UiYZHoB4geCywFbFsabORStQhkphYrE2VCDm2BB1t LXe7DjbcLsn4qv3u20CYJ44kOQwTZltRwbuAJ4N0IUXJP5zcFYMDYtizbhr3+AradBsyprEOczxi xJ0n8xxZqGye1qFcrRDimQANofc2H6og4BsgQxHnrmGDmRwbKpqsUgZoBMsZlMRJqMREnT1xd3Vm c6fwOjaj+A+CKKG6AqAXE2TUcmh2DcKhktxqlRwoUUU7blEUiiK6IuDRRSXxzDSQopIFUalyUyAO HDgKnJO3YQKp8pgAJvnS7Tc66lEqhdUL50AA1yaKItGIAlO2BVUTJKh45b4YuRU50DK6A9GooJBp gsmfdUGoBAKIgo2edyfR7ncmz9Skpdgfnq+6pB6ruG0nPRY2jKENC4Y047c45VPrAEB6lShvQFjz 4H4FK+pGHoHTTwu6I7kwg0XonMDjLgzGVx6rK0GFVZeFIWNVuxBMc5TgPGxsDN+D54OtDzhK5OB7 TGyD4iAGyWkrKZKA7aZUAHKFwOedeVoPXjsZEQomCEyC1sQAgNNC2GIgmCriosWGKgIBZFYKiLng gFIjFVgIwAgKxBVsO1VaoKG9pqauGAYKqQEIIoQWKCGNBQMDr1qAXQApTbgd6ohIIJgRUTdgLqQA sFKAySATlE214akIs4Q4SRk2+opBXEozNnCmRjU2zEuqK50AuqCQKi7mFl2ghG5mokHvZ0GCrTc5 IXGBOLqxUkYHCFBsy0M8MuqmCLDkiY8fnc5qw4KRuaLWYtCcZjsEpRPaNlyQ8yMuui8zOpG8Jz4j G2kpXdsclmcqWtyNcHDIzBpMSrN0O+ypDZKGrgy2tiuWxIysA5xaeERYK2i7EHlRc4OHTGC3ITGR JW5gqHX/Bf0DiD3QSRWzYvlh54kMSfwgRLdEEF1hUwFBMQEAsYVTMyekTovvalspStydDqY9bN82 ihRXUCBlQrorNboVAiABBFxgrQRCILAQQzgALIrMxqVEUExNdtNOjlu+QZOYVZtdFyGCheA8DEKo hbC+pC4moBl2UgyVkCRNp97erRzIRasR9XXYaI0HUFZRv4Kk0r04YfjWDD2xq0cG/J66ioRJGnQr IcRHYy14Ry4daRjTGVrO9AVXQw4YuPluEOlitbgEzLDUphLevfglOwIEjj614Xz2FXT1VX8hO4fn XOtdUdIbe8lIPViu106tpyIGrFMBmfOF6U36WD8HUToHdMQV+1dB6iKAGgoD+AHjPdk8RcSAqIqq VCG9640G0gdMkPVm8pdUh9TKJOrrCE2aKBF51jmYgOAB/eP5v+2XkwrD/nDNnnmBw8V1e7Q5yPV8 ofBFDtdMfLBF/y99Fq/KJEs4e7MB18oz2RWZygaktcI6rnkrzgxArG5YHFBnrZsqF4EIWiq9dMYx klsTdBv5pR4EudPYgjANcaln8jw3sJHJzEN8cIOeqq+hq3nfjB+EmOA9n32W2XpH7gnIgGJEaX0Q +ipHYRIgdKAgDD3CvZ5dkhxBSPB3fCXIkdVzqDXvaeecqt4aRHppw3dXhJiJFS5pcoOdA6HwHnQa ZVvue10XKscLQJUl01Dbb5Wt+2IUxrGZSgbFAhKz50PEDcidDNv3p6kRobWx816yWYcvbbD9stoK YgplFe+zzw6OysWpCBqO72uovYszmJzGkSKYHDH3D+QvuB6Uyisd/tHneHHKc20AbrqDFL3onWpW UXp3seqQ1I08FeeLylNfGGBoxoaFXkzveFBhnmBGE9RIL0UORebsOjZQ4V1CeUUtoCEwOOdTnGil Az9vGwlLvGkDgkJar58XgoS7+CBlcJfkzjYCnE/wr90idlCZHq+R4a5YhoOV6kzBW7J3IdVKSpQc WqQBg4Q72QHnROdlCyOTK12XsZ6u8H3ifen2i/e9u3U42N0tYp0WphGzr2pO3cuSCo48En078kQz mE02R2SUbEShkyHhU9G0riKDEMu4gDHjWy6OSH0M0BGhL9fuKGhHI99YeAHB1G4wBQTbcQaLSwL8 LrCSChQjY8jaEqwUIWsiV7FSgVHVFEyNEst19fNAJIAzTVwvcva1wqd7dvqjnOxVyASQBiceoELK mtZQ1CbYhhOHlT/MS/Yv4A+gvGTpaPXfmJBmTd9vfx57Ugw5hN9HemO5lITI9v9evWpqrh8zY/ZY kIPNsZa8/nKzqFM9uJVYed6+0B1vKvz7xAYZ65Fq0K8Ik7U0zpuNsGLfDIfthQdYJYeh9iRyPALP hQaYw9L3u4vep8lkGQgDrrGXNh194g7Lb7ReL5Y6O76mmGIN4ZiUgQOwNTsHRUO0dtjbpUKC09rf 4IYZMxAJ9RJXdu0rvCErb65XnSORlAq0XP6yFnuXbWRLipAPhEDFEjSdGdKPPg8W25nsSXfvAWvm wpZfu7JS1KICSQviM5MoY3WRl2kNaqpRai8HF4mjrixBkSKF2HmosNjWlIWickVfklIjDFnE5BIu nDkTtE2qSpgUa6FnocC90NgwPGfYtvbGdFiHma/YDaEb9onKHOF4ci4B4hAdoYjeDXcPEmMDhVTq WNzyAUGxiEjIEd5ApLgs+S7n1LcPG0BqCwazWm8NBmRfyBeJkV3mg0DzhrCGsI8gAb40coO5HG9Q BmDIBxOMdIbR4F3CHW+gYJgHoI7g/KJ0i5g0hwAEHOhvhqEshwhtAOIHlDtTlHQr3BB4h2jzhr1c wdgZwMzszjxB1ugNjxB4A6U4g6k4kMXqoJOntORIb4BfWRIO1DE/enUcgIGodfMexuHYRPqlwO4c rsBGEH9D6j1+x+xzrVtfzW8c2J0ffrVtA17e0ADwfO8E/mxJg8h0MqmQnOTc5k3XvgiIjjAhTSAI 5wWsUkFVbRF0woCirfvvw66xIbKndUUvk1D1AcQKrfnCi3szrbsGXTXUt2TJz1Xc4MnHNj0jTYm4 bMih4mWStJD9bYzbCYYIvBkk0DLXliyrPimzYJL3UGNpC6yzte9uG/WBZDM0FZFSmj3TE6s9VCdQ UiRky4MBVVSgiiuZPC5531o6e2HWqGdg0DGQFnGqGDNJVtiwcuPW6c87zpKwii8oFYW3YybQKedz nrvjhnRpLBZBK+azRpzx44NE0ZCnYM2hwzfTTHlCu2TlDGL2LUWR1SxPqTi7w5KlQGXMoZIjiAyT dWHGrjbXy4yE2zhCY+gwgEOd9Tjk7vvUNGb75UyefsgCBAAq0AHGJAgmETG5sxCZKo1Swxh1oMwT E+d9SHdaEwAsQnPVgb0UVRUSKTkbu9Y3et8dbL5vjfmjvnsenpijPEoZzeHE7Oh3jGbSo+1gd25P VCBPUoB5lkiK7GcTob555eVvpv2Vftv0AUdLrQ4owSBGEYQxiigQQPL5ku/CiId2g9a80lpBZDyI Z1YIwahYKEqQOu7zmyvDqSdvQyiQ2NYjzChGBnttSOlQTARiB2zgye73XibnfedZDUYdc3jVJLxQ xeAKCxQ8c7oaSXi6SsEZJwhwwQQHvzAU4fOznIFpQBhARhkXIUgxhGGIfHQz5RpusYFAxHrn23rn yJ0RF1UVfn54AyAxqJA4EEiqQPICOxQBOUWc1wPEnzv2ULJWbZPM8ydCiszdMfGE0w4YxhpIedXH XVCsOGTGeERlskPEOGQplIdigdqOerem4iBVqANMAUagwNtQBRAA53KadmqB15ZIsAU7iNbDGVJO UgLKkJjFtpMVkplk43QDb3KWBWhnV5w767eSGhhNPTwQUYC8skOONYQUCKbYHiAUYp0w0yTxIa5z u5qaYXVLxwcw1AOk0h0w6Yb5pHi7RbXpUHr2YFUh1AKCCAPH3sLogEvUGQmAkw1zq+a86NHfWnBi TLLGB1aRQrhjVJG0/V+BQNySQPy3yMnUppxa9aWscbYVtn3OjWLJo1BJnBVAxeO8+7NrkqLGDGhQ 7Klgrm45GoWYgGhAE+6BSAISAdFmwMwR/BlrzxjLpn85xM0NQb3v9v67jJpU/Y55a92dIasv4GxO EgSSEDipar9226zclif5XA1oqpcIUaGwageQ6hwB2Y0W5RLh6HRAVALgYgNgsIqgFA1xW90SwEFs jQAWYI0EClvALkvGlW8ViKEUIYh/zX/L/D/Q/6f8GV/exksbs2K0WxiyQ5rczSv3Zb0qjURpAacd QEu95yJ08o4TLs1d1uxedXwlkk2ESCQ9BSfT7qgfU1nezR4hJ1iNgsGDA+CQqALIfZGfjyw2JVPq Y55BZjyCKIim2AKXTMIh4TPgpTfMMyIynR9KPs2RNYQigfQRX/W5dBEzyQFkAt+5X2IkIFjEorjG lAoCQwD21oCBonGKTx6PULv2KBIAXqK1CLTHiCCcnxUmGcLhdDuFbEAceQKKVxC1gkvOrL95rNTg XIGzCyZWGR7unWyhaAGyJghEXSCiUSvUqpwHdyIzEhAZYB03OTunaV+4/q+NAUSJsJoaDdIPB4Ik g2ZeyBuGFFEuQCQRovNXpDWHv0UTQVOydsk49QZIGoYxIAVIApESB4We/JuYGXeB7nwsDaH2ccmf VONYcGUwQ03n2+rg3DlUWC/MFEzDhw6+EEiNyCrM7Ls60ZmxnGit9V5b/UpmLqZUyaE7IuKARBgL BGKMFiB18BSmFOpuYNVJFLbhaieJY6NCnPFiyGwEO3FHGQ1AIiQibVaGgb160Kb3KSJj0M4TYmX0 bn9hFAJgLr/VKVKZE5x66yNKsMdnnbpElbnm0n+D2WMF10iDO3HixK9thomZyW1W+pk96sxMLQHP hudsGL5dQuqaWydpGuHsZsaqeb5hlAKTpHGHqQ6A59rrA3TDg2cotlo5MHjueQtNJW6GTLQ3QqEg yC1FogDIx2x+QewWRYBJwLAkFSAm1ERcwKuLjWNnVcPrUm5oENB85BMCQUBySwLAlgIfdUURnqSG /frsIsnvacfaB9uVObREIDj3szFJKgFaJLmZhCFZiY+TuQWkuOlESTSAbvYCVbMPZY0qhhy0wTso BK1xJtrYH8+eR4qd36lx512XnKacY6dq1XUppjshGjU6m6L+JHK03K7sZxeVfx0bQsvo++gwZkXG 5AAmerPoMdkmulFouTmQbM9BCT23I2diaQkl1ONFRsjZ5FIKNmjh4DFGsDtFSw8j0O8M/sUTHNth WmkoUYNCHrw8IXiByTk0UUAkhD7mI1AG0UKUhuSkwrudNg6I/x5K3FCZBHhyKCUsAGARAgpaBSuX hpQ4LBa9tulzfE532zCsQJJLlVoaS80I11icdq1cYXabPfCwhZWOGSquepY8adJe0WT1ecCjQ4Ps X5iZVTkJHHMvNR9dWUYo3CF4DzkoVD9xdQtkmfRX7kwxhnh6Ek5sJT8wKTCkhRWbOW0XieocobR9 YnEoicEVXieGEWHtQ+LWVAnxEOI4wE9MDMzYWaNiAD3iI5GwAhjBmw2sstwSfvBLOFZCiwEwULhU Ll4IexgUhdV6eo8zUOBIDAd7XMac0wUd61NLDoIwUMLSxlkfv4pXPEzihjYcqx0MvG1+vqAc1ByY AQsRkPRrTtR6SUVhZJoDNgrYENBppVdIYHE/l0fIlRI+VuWfHhYPRulir0M+fiZcQnpXKUVjPfjT pwqgOMHptRPDnRxgH171WngbHZ2UFDuYJVVnDSUjhaktdqbaepkOzBMEqOeubM7fbvPaNTZPSEIu fQgB3xbKTq6Nda3QBZYP+bbvQxQCXfo5y0w7aPU4rMRBFIHirUg0l6c4f7E3e32/zRfhnJefdcY0 djz4GNj4903zNC94tmOXmpmPlwzGaO6HzTftfEN08Ob43jZ5tvMRU2jUGnzzcUJZwaHQrl8M2vAs zXbeCETbbUH4JG3m1EyX88wMPNuW4M33qmq7amLfTze0o+27lO/NAz1yh3oPmgcDj+a52+UNMDme 5vN49lrQfdt5vwplwZmKGgTqnj6BpUhFXruJCbXUrFnGj7sJZs+48nWVrxfI5sZ4HdHlLXVT034a E4gcRfEZTwdTItJil3DeZ0b6m8ao2NjoHB0wNqfIaBkHN9uecGsiTNOWndTmnvgyeIO94FCVSrBx rzNV2d+bZ9qex5ydQkcu07Pmlm9qmnbzXcrnmcSuDVVu0VXpOd8M352LHeRi8rVbXe0S08Xvnku3 XNeeOeNVadhlCh2lee1VhN1rFGpfEiMELaLbX24hzjevD5tKdleYC9vcrzjZPmZo1Pg8RLrNLS68 p0ah5pkPmqBtrabexrUdltJrypt84HrY1L+BcDH1zTt7W1GXnHinrNc08dzykXi9U0N1WWftarst k7PWvAu9+cWDuM8magaXS+VCc7q/O9nnZod8VqjL6nfFZs1s+VrieQdCEefOsoxUzjec1lU/kX3u 380/e+TzUzdDWptb3G0kVeprfFBpx08nTPBnFv1hMooudLrleLyqV28E3RS/I7x9tBs7awG+6eJn zznWTR94qnSVCeMqcOOa4K6x7zD0OvyFV8NgncgchIHH7Ph055OqiNDUjOR+hgoW1kplQj+Un7uq j9bLQzUYjxzCqebcsmxoyYdqbmsS5iPRfv8YLwdDEgDJ4hBQsOeq4Pbwg0LY83OxDiCYNmktRazs QtCqGJNSBAYFVBEPw72TrZjxC+jkOmFFPk+r3wnDkSLPfGZUQjhbrDlNIkiaCqDwKIhYA0UEBFJN RGDo16iDwYfN1cnq1srgBqOiW1VQLwU5e9+kEDuxRwlNJVk9AI6ndtSZKiQvADaDqoAXHF22pYE1 EE4/JggXdNzFEVmduwlQJsJXQODju45CMsIWQGBbiklp3RBOrYku33sCV8VxEl6KNajQmQQvAagH KnTua2d8dQF4QrXtnBOkkSZdtgYuCdB4fsAugJ4wSNrQ9HnEikIxXPJe3gExMXQoUy40ta2gNWtR SNPUpOJIOFxA4ZJNaVS05PDtCzkjjlCj+9cgTPB4dg2Qk95FUvkK5m6oNotkfcpIKtgqagEJdXqo FYzDUXzA90H9hKIbXA+QiePDlpRE6b3bZzanWpYygeIFYlrUkC0AUDSsOTKhp5dO+N87yGgrjTRo DLQqQUaEGS3fxicHWfzk3JGhDP3RD/HOA0EzdF1blkqMUIGLgrcJdL92tg0G47uQnmHkEOBLDgAI 16UPIRQA15NJyc6HCuVcFr3sgWgHqB2Eogt+l5pvas9bv6U5g/MCkNzgsmQwPbnoOSVUDfAbkGkg IcGtjkKTJQIefOFITbAWCMzuqiCsltCmt2obQ5CuWa6+VC9OhK5ajUIpB9AIOIB0hcboOHZO546b psLghzEyGhYJpVTUq+BsAGDv3zwkajcThhi4NIXnOgHyb0BYLAjmBRAVtJBAHGR3lIeCHBBIYW81 z59WfvFdBQCDJ4lMPC+NFEiafwzTdxXQiiHbVbBlkO12ESSCiRafC1IZQFWpTnk66eGJ0vWqCQgZ 4BgWrp4Lh2iqXv2DIw+CA3Mj6+KY5GKpxu7no8b6IyH/kUkce0wwSL+iRX1qHjyQorUVG9RLqASL jnRYoYFS+SmXEweES+5+jWqN1XH3h86oZ+PPnr17XcL8lQ7wtatSStaWkkhnEtEuggRSkTGCVQVL 2650vFwmcrRJjDKc8dYBURp3JYqID3lLOaLm8bH7or8R8wMhM/2h3C6cAAsIgCTSKSYBuHcsBkL3 xwDgBzfFw8+wWwIwOHsFyUSFtCwMInrIWclyF60egeAVF1WxcgCiDgM5TazQohXYeqBwwC3xTB6i iZNLKQ54PQRYKoSwYcLDAHsZcFj2JSfHNjCEXbsJ5UADE5FsCcdpUywfWCFrSgDkIUbo0VSDh1cX Xbkd2MoVjsuTFcDKDrVu7MfRLQjjyiVW8R4XqkooIDcMedvFh0nqjoEyG41mwhi9yOKlCRIMPV7W rQjafg4UoBHDyv+wH2Aux53Xb+snkxiYpsBJwncJkMQoWneVI87Ehx3OdCQUhrrEIONeXwiFPEO/ RDvOMUMuTO46K6ySGKvMpuQ4xqKpapR5RZW1x6vjEBz99uphlhj12uJ+5+ScbF/DrJGskCR1pQKQ CjCpIzGfHR6oy5dV+Wja7hv2TZ1cvvTqxU3OtzAuAmYCjAsqYhYGUQoLljA+wlMM1Q08eDMa4Hny FQ5QO/pUTFdfh+uJcmiZoSbPeEXE945sUdvVJsHVBVBhG0FiKsAsKuIDARMPQzC++4jtxoOwPHXB BOxJAdN8iIkXeASWTOXwDWTF29gcn9dIq/oEfJyuir4GpwBaSYMgYelUCDR0iiVDzAoqYBFgPbph rbfEaDB6gNVxb9MFbt0QNO3XTIA3CYCGIU1BXMaiEQOxV5FwEORKBQGcWz0NFcIMkFElZCH8znQK dNJQMuc+iFFgkx1LT2JsOTpWgeIw2pKJ2YuYoJD6SZw+F9FzLol4Fm7PFZIVNJOKUxw8eLI8eI9a za78JYZJKHge7oH5idXTjvqnC8pB1zc1Jb1XqEk/PMtdbfttjEg6r43dDAuy4Y2XB3yDee9DiaMD RVRmDeBRpZ2z/L2qsQ+gAfgNgHx1OUOUiVlCkBwcak0wlMcyHthmgRFLn1bwnupxJnsEx40FBh81 NSxLjov3RRZiP0CFvHmaSeGS6KMNTYUMk3GkEtPP1XHIwEcxUw2mse1uD7e5JCtUZve3GxV9XoPu hOEbPk8E8RAQg8oI2QeIj1UylwgWmFUsDkjs7sXAH10sJlZCsA7qQKQMhivAxbCibHQ34hwWDCJA NivYaqYZUgQEu6ALaAeYUUkQRyIjh4H+HDsGQUyj3VKpLfQKBTIx6+I4xqtcrtOuhkNzCQvAoGpa rpPOCCSAE4jinUQIKNUkumCIS8LwjGFQRzuva6ynsbnoGfAKUJ55YweNVNBhI5J2dRePQeDDM5/j Ns0FFLjuFqkPD9ZqQ2pyS2yHp49TOHdE+5jIim4vLp/jXiRN6ZW31nJ06hQlRS3XvusyHOBO4gM2 x+W4Zw64X1Cyx+XFMSLiLhQCF1kzhG2lHauKQ2E2SZ4BMnw+jsj6qfOGCc5cS2wUnyYBTLJocfLg ky0HOLuQ00BGy8LafHXxTTwX6k99c/WY26sDITFdUWgBowcAuOQ+W4B0BpTgCqniUVo1aAUG1bKG 0yO1PAZG2muaGmT6P4k52hQfS9JYR6IpA0QCi3MLO8XlRZ5jTMjpiFROfPrpPEJwU3tF0jaSThKp g4WlsiosM3HQAqUA9MILIjdpQEb5tejro7eSe7aCgLaNhKrnWQWDQqGUQn+V4RoPBhHVQKGjz5ud HXgkhWZU7PHjwBI4eenODXgXZLsDrzcexVnQR3UZSo67iQLnmGnT6o5dGrxOnWGMJYF33mfS8EB3 estlqVU+3W1kyJhKzKgLKE3euvMp0PHd57jUO52ctcepMpAq/g39AmqvvMAbVywodGh871Efz6IV h3ottj8SSgVXXVLlFmpMqTWS/ULHJM2KuXZdqDnMykwVBQow3xxvfjrCcc11kvF1YTE0nveXBFFO VObeDSPJp65rp3sw+R6H1h9Cey9OMnNdANVdg0VSAMAP1CgHIWjGN1rWqNI44AdxTsjpHq6wydoI BuuVxbZW5163Km3ly35VOg4YIK1YGSAMIqnFHCEKc7hq0FTgDG0isqiQDrpWQen6E54oIsQFGF+s IwyZit5CTu3CbBd4sHonhLktqUyjcy7hSdSGoG2qmIQe4aqahzYReQxIVAKQIyf28FAf2FpRhNMy aDyu4LlUjBl0Dbnc6c8TWwnMmYFChCMe1d8UZzK0EX71lC6jVjvqBcgXox4vvRSFDwYyIVtYThp8 4RLdXPC7dAluPWGG047kPmTek7F+p3HldEHEOqmqmrpn6daZDS/xX+4PNErYl3k0o7SjrEbRk71p wo7ZIjCCRh2SoEIiXKqo5xVximgFKERguYQpV96+Py5X5DRV8+T3vP9Fj0Sj8setyPn5G+byJTr3 U/H0c7C+KYipkXJi2YuHvRMkRy94+UD5IePy/f1OfbnUCtDn35iXC6mGKR4xj0HhjfwIzL5o6JUD RXJ+UoiIFgtj6SST/YASAcRIcPpx5shrXzCBzOgnO7E7VwhY42shi30u+z0aseWJumdtFWkDDgwr SCrnBUdAsRCKoDaUbnwK3OGp9Z3AP7JB/mH+IoCDlzzjGw673tvJ3RYc6hwuGTM6RoQGaFERcFWT gdW/kkZI+S1r7UC4XVXniHt0MMULSlc9ZObIYSCC848sQtFhp+ExEMCBcg3nQUD0IfxHqAD5fmF3 3dUJVwnrjHDgSPW7xPoDZRJU+yHdyI2eujJS3FKidrO/5g8pArYVx8C2vGwmQiorjD9hLcmN8rl9 JYsUQ8rGbSAggBxpYWWiYyafKceVhF3iFjRm0zKJZwFHY3jYahw4Zlh9WvMvdS1UnoemxN+SkwsP P8knppJDDMzlFD09DDY5q19UnQGYZhuJtkTdNjxtOMo5UqViSk5+Vh17hFFKHKyxGjHXmC0HFXKu FY7Wen+54kP1y7If2UHRgsu1UnSVCOk8OtRmobsGLRqW/keG3IZF85NT8oMDuNxomR+axN6UqfoH 5BFPt+5fqCGGZvvttx2MI8Yc07NbuZQm0ES9DHpd+SdbasMKMmFSMJ4v7uKhl2pGlHZcB/wy++QN vpc0ojalI3Ltx4F+h4nwkGxwbp8Zjkk5194Faca+6QOMmnUpCkEmqqmug2fLvezJl50TuaK1zClq bxBMMshAaJ0OHrPcs8I1N9Ex1JZjzhHq2MP38kRHk8dLR0Fw45yNi5bR3LUp2Jz7Ys9/dZNgbUVd a64r8utmSuzjWU+YGlfD2RKAY2meXvmNqi73h/xWzqMrttkM2HPfFOdGRCDG9jQAII6Od2Ip9cui dllnCKxrruTayi1Y2CIYsz1XuptF4jjBQdiJlRTp6Mk+sl6tBXJKa0PDVDOFyxSU+2HFGJrqT3VI aqMxm6gry/AokdYJs34QVg3nEL0BDcWBPcDhtEE1qEeyNvKPXt7qrl+qUixnBtGGEOgdC1DU9V3q aHlC6oZE7b513lPH763G+Xs+U8bfBxlV64+ibPR0/d+b5OL7ZLHHwHqml08tCOcdSVymo8xkmEVt D8BlYCsJljGyPRwntkdVKPJ0ehm3IbTYHIDgYSfAsxAQn6VoU7Jea6MwsoRg8uLUiFFiRUzWZnVR 7FHx1FMaHiuHyIan4pD36FBgMWMUQUBgqI/tm1HnUOdVwTcF+8r6I9KepfYLqH1icHQHYprR6w7F ygcgnovaBzLzc0JCMgTWAdT1C6wxChuDgDpAD4BxrmA3hpDfwDYEgyEg0BllVBUMIDpACYXgRoPs G8B4GscQoJwAaU8F5QDoDI84dQut3WAsPtyH5Ccp8hwDECwVH6J6h+Y6ZBmByPRmQ7lC4HclJ2B3 GYTci9qHagah1hsA1B0AcxSxeeIY8vbnqiYXUOmBjhaF2FG/ss4ON5jDl/I6SZumIV813kHNZCLF EUhEKRUbRA2RH3VbwywDWWyLVJqmM0tTb279ZJJww8QDlCLCFZIQSGYAEfVHvqyTOyTcyg7VKEB6 Bit9HmPCxz9PskWHt5r7doClsGgXQnCq81sdL2xrGQaPgEoTsBdBk3msZu7KY7xqx7LgS3K4uDBa nU54QLpXM+4aBwsoJLHRgJi7KGdSnphUII5RUShMVkzkCygyy83NFJWS89wgZJzW8snSc81baFRR YKAvjCpq1mrvVNdWaTTiCA8sCK5CjGiQEQRxA9BoxcZMVNTl+gB4BYmgs0eDAGNQ9TI8nkjpMuGY JSQswg1UDk1eVNYXOcoeeU7agbQPHx76ovaobgybQxr++MRmujrfVOz0uvTjjzrdrfmjFWCNOGX1 jd5NvisbNdOWXUZQHImAKBFtudoIVejhJBs5q7ZyMMLVwsErNnJ2iRrwVTqdLmqdXyq4rJF2OtVP dl2u1DHeNyYm1UaRdCaoWngJih0dgO3Xbhlh2MoUYGzCJW8CWRJDgmKFY+AJUoiXVqT2SODlLc0a SKlRmto7m7gB7NACIuqvOzOEETABLaWVYBEEcsKpZvS1tBkrhVkWYBoBIUL2BPBWAVegSKkdwbVm qeC94HOHHSMmuQyKJpHtjFxQa3RJsM8gr0JsAKZIe3QHZsKjbVWlHZt6YDFrLyrrXKb5GumSNAaQ IDsT2v+f4BkXvYk0ckdPrs/MqRRWVYmq0TszCI2hDFKStPIWJWl/rSGMpOb2gmIFFYYDwgQGiZAD KHoOq2+1rQnBhxb5TkYKGqSl+5Z3+HRgUvIy5Mls0b8WR4dQiIr9BwHCcXuKIWy1R9USklLHc6ga puIVDIKvUGoWC5eitqsGiFhowbARbBYKiiXGrCBRLrBsA4gVAmBP2P9Vy/4tIoigXNOj/V/Srn92 2IP9s3GUh7mIVZ74MMQadIUlErcCobWQosoTgNhgH2k7vt93Rz+Et+5KL6Wgs5ZDlhpJpH3y5ZkQ zb2hOASSALISgMG5p7Q4cdJnxZiM/qfX50RjxYfjL3Fk8ElcIJXR2D0RSDyHKGeUP0UGaMQkmtPY TdJTQav5+PVYeuPwO/63UfM+LkW8zTMrWJRSf2jv6kAFUsjvXWQAFOJPbi49fi2eKMz8hSrmySt/ VNerBSHqyaYhY2qmGhTwebmW3aIhIkAywwHDlKA758FQx2F8QGqGJzVc/JSi+vcGWYCVihCreMxv 78kkaYVQUusBsNCB6WQSXgckrPG4c2axSD/CsE2BcnyKuIQsIikudsV6F9g1OvaASQBElkZklk2M T8sbyeIb4VBE7JCi4pNoTHjiQMwmwwkBQXbxyBvMHQN+LprYNhp+AswhlPOUhEZYjJzH4FQd/qdL d6MRYq2LLmcsqaGjswcZeu/LFc2FOalklVxiKq1S7Jm3Z6lKlY3NmMNRedLhm6t6++ch+wB8NQ+J 0+t+oT5tFFiqFSooAlLOE6t1DVU5ZSZS+6G2IWukbkWkpaNivbtcrbD1vGpkNhDAcgYAGYi8KCsh PwXAGCE/C5Q+J9adS6MiTtIzEuwdkTolXNOL0cykc0ScW6GV29UhCbQhkvKcXPdKDJwL5nwpz5l6 5GKmnXxvTlhjzXL0laqRtPTtIEDCsBSO0l0VnsT0kjvcTp88aW7aBOmDwplVaBVDYxohQDIcNdAH K6kSlngDhAr9dNbAUyqiAEMloPU0sXWgRBwA5DGjsaDRIUZi2BK4QU6kdbz3BlDEtj6FoYAuwiGk tEMQO7x1gJ9VJUyNTfRc72rpji4hD+xYd4u9EzxjpOeZZyuDroE1CiyvGLdR8arVkqzga7NWFxzI xMndlE8d0MP7aJmt8GEkqLOYWmrGaLXhaH2WFX0KcmwdWOE8lzjulbBw6O9Sl/ohL/QML6C/nQKp a86cx4PceDao8ZITEPlr5dGw38LzcPbLOYbYPjacFwq6UHTtJiM3fJfGPFBBYHpLKFYMAVDIkfjh czzx9D2UTRisTjbItwXc7b264boNBGns2fHl9LCSXgbfSqaJjoXlhLW14NpcC/URCptsBmo4n8gc /r2RrAEELamQtZByPTY0GflPymMoO5hJzQM5vkPEPM1GvM0OZAYwhI8w5K2ngSLvHgHPEUqdlNKR Y7G3sJGljkYE28qHh9EDpJCnHeZ0vCHCQUK+NcgaByjl2gXeF4bBh/d308Imm4anq2BFFJTSO0jq XixAE0js6njYrvKD9zIm7nirCunKraY0cstjzxrVB4YxzDobMYyQ8DolZyLPkpNI3Lq8YDKLGdu/ QnCZhxryd7xkr3KMhWASOcMDpcwunbCwaUhnJJgEyQJ+VEMiVTsO++zm3tvhQ2VntVw97Huuyvio XQqDJA5FAHFQX+hENLIKWknFAWgkBEf3DatnhuMT0Ul4vkFmF0lid4dXd5oMdt0SOdYi89tAqdgR KcHaDPtsWhuxuiEbPmMPWBdVS8HVOxA+xcFbZLbsdbjV3EyeMQ3H4gMTM4BDnxx30VSr0vTwDpZ2 BlIoB0ws27eHUbHdERSDEEiaMnNbCJGddIN7Gpcrg2VHGqgOFR5yq1B5YiaKq3mg44O+AOaEYCCM 4mtY9DpvgLVQXVTpQxX0pEnus3cRyufMPAAALlNPo8dCRzn+YLcjwRYFjoZO3hLPRx6J/TLMVA09 zJBZGcXs8utZIjEgrmvk9DNwNKJIus4FqFpptxUAj93UOoeww8mb0y72bR82saQtAKIRla+K1Sr8 PvYBImcQQMlIQEPtIcmjXwXglE78gyv4v6jMDMNhE2E4QN1qLRTNdA9BoIVXIOAckh12A1w0QQuH jFUe5nxcnWpRSXtIS4dPPVrEGq7osZAdnQXc7oeqPM7+XEhx12Hc3Py2RggEopwenoDQ8NzQb7wj QEg4aNVSgGGCzBMOFIGFPFLiM1WxXW+whA8RrIye9kCojAV4LY3U+iBWoILD4U7x3rrlHQVVZCsH ZZzujt8Gqy12UEE/JwMyxk76wcCz63AVBBOVAo4vfqZ783fGaHWLjYM+LzC7od28p1zaMzcqZnju FWMWe5IOu5DhR08kccD3ZxkMF8wg7Wh23b5jxcw8iRXRUyrwQPSfD6j5Jx6/R21YjjDGBgKhR9+d Qyz+BvQKBIy3jEI5NYhOML5TZ+ZW/kPe/a4FY6joBVAgqVDE1FpRFLCW7GhXGcvlOqkwhWrgJFyh Ty81TptCQWnJZEvFsgjdvHlTuJ9L3tvwiDu5qxOwZAUSUL99PAg8STcR2OeExwQiWUR3VgE7vRuj PYTuP0G9DJXKIHuikF2xB5HHAA56pfVr1L0x6PHeUUlikADdxeLcxND9IjkeqHipSshsK4kaSNJE 0EKNBznSUaj1k0TqgJIvmlE+1Kw2YVgJWxpYWdeJrWTx27BVRl0Y2dHciw+McKbrqnO6HqWPFUOC p41iz8VqSq++9zhOa6qnDF3yKjjBPInEZl4k4zcEmnKYU4yfGn+QukgZ7eDnPWoYV7GBgU2zwW5l G0LwKwkkS8S5+8TEBmjspTWEC0pUfgbEkQhd/kwuMC2Z7LdaJDp9+sKPg/OK0/RMbAQGwxIAyIQF AZMCclI3EKeF2EVwXeEVoVw4867LkjSOy1tuuTYrr0TBTGSLpgU8nWEOAgL1LGbRELoVc1Zsp87j MJ9NNDSXcKKyGAMZ2n+NGUeOlEDvSc4a7ziEd849xzgTUfDspVMWgWywAR76sD4yO5X2cR32E3eO Auo9WKDd0TtvIYyQ71+TIdMGCIZuFyGDBEM0Qted+c44PT1IKEuqpFckFYkU0PZ/coKNkQJHZJ8x VTkTyyjbTozJzGGvJdGyt8xPKMBLzsUql8lJrQa7zy5ttZhmRciPXBxH+qUFt5Lhbi5st6Q1APQf LWcxWlHy8dqlqVLNIDU0uUUtLGD+aZCAmYsVFECQhUpU4J/KxVItiS7/aHnx30LAqzRY7CIsCukK ckB9BFc6SF6ugwwnQTwaYiFHlrOJXUU+JywG0vVea9V+B5YnfJanxG9r28KOtCJS4kBQ1kyitlRD +nOskndbtW6isveGmmWWjciMOYQnJ4MhN3Wq2odvUdzMW/KIdEgquimeoaVDaPbACSOiyQZsbmWx E8WhER23eOdhvQjBTNMPMF1dyOKBWIyAegEkAYiDi4Nss2AxJ5RCkXotPcXNVWov0dRTAYySiNmW JmMUgT25EJVA0K1G7EclhbgteQtj6mFwPgCjQGbESMfAVbHVSeqEjenLx1HPJgCXCAWeAG1D+0L8 TxajnEO/azrXPmgtoBvEpIWpQCSYQ87YLv1pmJITVQEADJaiEVMAyvaBNB0JML5zGkzajmOacgFQ KCNQyAMAiNsxZEEbSR3BCR4n0Go09ULPJnZ5gA/YiZbncHQIAJdIPDAvuATXjnDYcKyeChNjsHIg FWj0j7pUSHlaWerUDQGRX1KpvTvLZAbsKxf4FcJ4DEL17Iz8eO/9BbSRuPUwOmFqzltyAuPCiHh7 zmSI2SKRiduNRMMgKusOuEytdwikJ4C/Y63q5YLWL4v4t44TfXTGXV+lkvQpes5luzx4ne6KwcpZ uQGqWxXqDa2VmxAK3sHikUby/VChcfGdXmJM12katw3fD1xuh7RH4JyPYOwwclPojqHC5B1r08vB 3taluUOH1Em0DdoGhM8YervaGbOXRsr3W61w96Oojmu+/wB10aPgmEOQDyBYASyQe7GGBhEsHfjS oHvi4pqC3ONZe0jxzGRHC9LWJlcRmyckhHuK7goPcB7e79xO/GwRm4WFmvKDyCUcdEDwu4d4BVRZ 9hIQ+M0igXgzDLssSMKaRdTYCT71BzibZ5GCmhPoMYKTDvJQ5KkDOeoxwJYqrkwm86dkuXZwRHLN gRU6vrxvvd+w2ZNz6Y0IO1fvGKFlezdpMELADEI9kXGe4712PXLHeb+RCKTq3mZPRRR6T+6JtjGW KEpdliutlWWurWvWLE0XvKLHVXDydlCiL4JRsbVUl6BooD2LCQCwIAUJkEUALtHBywa76StAAZQA gMEsfWqqqp/Sp8gPlJ/VtlsZG6rqk57B6GZU+av0PIm7Tzcp0dBz7sL24ucZfdfuuOeZY4suTCGI +9oQnMnxfUratYjuOLVxUyv7oIODH2mTICZWuWW/aZKRaiHZMyB8f8hWIuSIqhUxGFEYpeM7VRgf vrQ5xDq41v34HYDRcxCFIMP24P2jwdTL3xnPZ/ZCgPnDgGSPFSUmghxgI46O1JcK9nYGnnV+tFUe HRIGI0iLPVysgzq94x3bixHnxS3A5PxhIeMQekyAVZhykOaBQM98oGAk5tebA8S6v2iWgL87tXMu 90zuO08rXffS6Me5foIuuDtk5xz0mdqdLF60Cl5NToK2lU5Q50Su/lLggVzgmQOXxGEKDgYV4sHB ZAHOaUbHRxqZo/LYyzxh8a410nZhTN+sj8ufTmuTIg8ol+ROTf4CYKkLcLkDfetSJMmGC8Du3i9J bDp0DLqckds8hQTuw5dYUVfOk9SUirUHTe5FjO5YlRz73Jda2qhlcw3FywNl+R96DjqTjOw29tjk 09ZZeEjoq1F1pTgrDypsa77rK7pVHoPCz/YgcjgYPrQ15kdgqZE9Pzy2VaCjhcA0u6heOeivdI1r ctA8jBQqOp2VjzyuVim8zH2je65zq2XexYy9yuA4k1NEMYB4Ce9fn8zyMb4Dk4eH4p58s8b4+R7e jw03/IPeOpe5cvn3iHsXneJZI9ynSqIMKW9olzmVhOB3hcEmpY/KovB2fCexJSweUoljJj4xImEp QzLo6sHQqS6pnNErjhmgnk4E98ePYjwe58HK5VpBzJKErJM6Rk6tBZC9aFhkzlHOuQUGDcvMgMp0 QhtqXse7Aw/ffA39ARzsoqG6n1S0g6EL/Oh4l4yrRDwNt/nrgNHk8id2nbjj1v3B3sKP112C8ngW c5u+6MMv8rwQbZohGt6JY9HfBAehJQnPQ2ogPSWwSOCUDlwjBLeCpOb1eJkiXuY15r1KUrfAtdCU OtVh0bMNHfHYT80fLqfUjCuDGbcHRrQvO60VH7oDjV8zMvpNZHpnRy6l8l6OVc6cbnlIPmg/ASFZ AVJb1sfHfRGhzDECY+y5pWCg8hDfi0FeONU6PgqO54J9FNGyLnQaTgvfEgroabLYcIZIDtOqTdJG n13LXG0ccmovclmUVZvCWAltY0QycWpkWevBGjEQd4z0xXpQKIjDUwu5iOY28RxD167Y+flz78wT 8D7NaSfSGtIh9YaFhY9iGYPRbIZmWhTNqF9kCdG3jqspJTWbdEV9A/zQfcGWQibHj9gaA2COsTag BzDlDIGAcK+wPci77yK+CCZVs9gdKl4h4JmChcONR7w0NAZh4Q5xyhoOoeh0ARN5etQxBSdQ8wbF yPt7UbPJggdAlkT3oGoC8QuAzhxBxJpB39geSjxococgDtDSG0eYeMDeUdScCHSA4DoHnHanIIcI c2LgcYcQmkehNo8Lo2CGQdCcSjxhsDyA4QYjyDlDkEoxjrfFXrwZIQhMB0jvKaRMY7Uudym5C4cS PcHYtG0AOsMicoOgOIePaHOo97eIdi09PTXZz3dWS2Gw4L82RW6LjlFrFuffEPOvN0o8658rvZvP M9Nw9BOi3HvT6hFkgkAQyzAgBJeU+1LlctGepjeZwqJyvCYipe5YTvTHrqyOvsv1qdNO0glYxEzs +E0RZHCUkEWfEUOlr3qF9AUzO5E2HvpiqSFPUK2vGMJNIrIB1oWdompuQBt2kgQ7WBIJyRbGyKMP C44TbgkVO3lQN8p5s6wvnXGt7hCB3rRwzTIosiIobKKa9Kp+Tki1TEZKEQwF1Tu+kZVQI5RYMCjF iD1heQ9K2RQsWrGqKE1rM0KXY+E8cIBOpQBRA4EDQYogpZKmVLVGNNGSPaETeGq7hOrxly7GC+zH EA3Tk54UUMU3gup4KnIV5iF6xlLdpyBxdhDdx5izTKuxwyGmyiGzV1RBjbW2K0zQSvpuqupMqwH1 SK4aFex73TNpHO92LLn12jhWlcojiOGWHGnhVmRGHOkT3WaiiMyiyMNmQkKZF3Z3zfFeqoFNgbUw JaGlwDPjDY1w+G76QssbN851dXKrQ5AKZY2sAt3NSJaNY+xjqrE4gbnTV2HysjQHC8aF7Lsk30Zf qkV/deCyTG+zAOAnEYPVTI31Dbd2Aa6TUWtFYcV/LrTAAwXMFogmQ0uG0LZc4ldqq6qqexkU2ueo KQVFzbI7uBDQ9xSsrWjAQqvwtf0ZyMkta3qEEzoF1Gq2JkvZ+tO1irjMYrlAmxrt3tMJkJUfB6NI JDJCYBGWJf0ifwfTL/fT9qkClKN1SjQ6r9OfVvYSpp+jHXSQhwSapSWLZA8QiusSKGbRYAdkNUI4 AXRotwKjQLoXQGwXIhRVqhcALgUG4NAC4B/17vfj/G/7xaCIJBtQTFlrJYLMIEyZlSbrMpwKICBU WgiAMId3UwLeTI8KbSszGpOJMEQAwkWQmFn/SDAadGWpDoDge4qgVJVZovw+WZJNr3yU51eHbxsN uCyYZCURNuP2jMkW8NfmFQffs+Dv9weERgAGQALqMSgG+AXg6w/HyLJy57aUENCI5+ulYIS6C+zd /6QQiWinQj5aoSq7LPR1RwL/FkAeIoGiQYAanYom24l0Pbv40cDUzSu+g80IFqXJ6yJTADznvGuV VhQUxOEkUjqckdSskH9jdcFd+aCLMyg1Dv21ve+aaDJKPYv0loPPO7aPNw3DKxpeTnT/GO0kPh3d dFC+CCqBVZZIZiNZ8yVnwzQH1SWZIgNh7ea6yM3BdaPujCywgtTWcy1OsyTTCi/ye+HjslOxA0lT cTcCHh27MLBbqmGjmOLjU8FXA18kEuRuGyH6g2AnwBgdDEHc2OK+8oUziaOPAK4lhC85u6EQk7vD KHHIGYHjA5uh7huOE9D8X6rqIm5XVd0A2bMQhQYUMmB8qQSghpQ0aHWZKZgXo5LQcCw3MlQwqFhX SIhjFbalBYpFXmACaqxTQL9CXChSwkvMZqvSxjV3vg7IMDIYQgHE8Kjnp8bhJgBhI6kGXIbuVbMx HGc2Z8rEG3ctrnVncnfe9Zjmdr4lCGRrtHdtX207Szfrxys9u7EjQEAqgk5ADkFHJCmPALpgXeDI dElsTk652OATWW1AUdoKJaIHQICp2O1B5ur3xqj2xp1hxXHHYAor2C9+2qK3UXHZ1yTzqiJF0dgU 1cBFTAWh1UBRaMdLMfuAsIUUhQL0seMVcHI0Z5Q8a5eK3i2UIhYTFuImjHR3LnazmJgQUKrbLoNB zGtXrHDhA0JUht0CEjzGCgViu3XKg6JzVvPhmRUJkzGoFChOxZZcS46Jjxv+of4InY34XC4dPGw1 +znBRtSb38EL7IThH0fKw5xN+GF7DMwyZrQbMSsjltLC0+bmY5A0PwacLo1u6iCDJNWx+ywE1daH un76n8P1Yn0jpAPgAxRMyTGndz6YlVUhI1ndAG7KZYB9mcFYfL56AmHSASQAzh1j49175PCrpBUe KwAOWR9+vRi2Co0ZvK6dm2EBFLyYuT85uE4LbrephMYpTvCFZu7BHTgOsv7hzBM632OnkV8uYSoT sk5DoBQcKAFOwOA9QeWTzt2lk0HWkl0BZCU0Bnuxfq+YtMO/jxEKBKqkMPVciXWQPCKym/ISdEGQ +k6KDJEhdWyzb8G67yY3YuQMLLJFEknnI4dyy8Y11bvNTxpBAAh4wnS2HWbjqr2SRyJI7O+a8Bjq LNvdSYOJSuRDY6BQ8seJYp575q4T2oU0jY1Vebh48NFGjOj8tlEzcpXT5O0mpJil2K0gVP6iF7/5 kCw+gfD29OoyZr658E9OC3inq1cunELl5+1D74gxto4gzayoBkUsc4IBWAkFUPZv5eJoMKCTgYCQ A00Bb27noUqRzHwK/i4I0lP3zudnakbA0i+t82Th66d0IHYTJVgFcMMU2EJQMENTsJRtoHYXfZvX tosG2EtgaAw6M8Di3iYasgDtawhYhtySWQyaLBAGJMqZSO09I8GDuuVRVEkxNOaNB/ixaiR1NMIP DMdDT8VHYNwfUSoXOOBQT3PIk9acY43dwDJ2peHuGtRVuuBwz0UycM1JkktlbVOJ9k6nZd2B7i++ 1HcnkNxgrF47yoKlRueJqO7BiHXUrMavfg+FU7euEVUpJxmLVM9WrbXH/la64ttn1GGe5go/Ch6p iGneWYKw3ST6Z+Ry6/GmNBiyARFcYJRDoDrIYmYsZSGkqSonhsRMKgVQlNKUAURDkF0i6hWzIt35 eHfnOBSTsELJB4DrIi3UR1SmUQBtMgd5OiMrBSwih2A2SKikK6mHlyXRsfyY2kNPAZCqW0t6cNm9 5i5hRzrK5jQEsCBiZkDragdUh1Zn0DYCui13ocEX7gPhJq3Nze7VgVQQWbJR3Ib6PM4MRoJUB00c OpE3SMK/ZUictHrAqwZNBJIcMqzH0Yrc6eHUq+HXQXo8NCoAYrGy+J6rRIdaCAMZa61Dc3/hDaYa Jft/d+uo7qeUNs802PzAXqDHBnRhsKygjRO4868j3FpnFR1TsVVxjPbS7Gra4/tvcTqGlrrk2B2Q vLrXwfsUkGhHtjmLhfHp5N0dAhxd4aahcvGc65ZtMiCPLxrWPMcRi6FYgl9iMeKIxnZeff1mwAYi 4gcIgBMkxHFzQPM0DZTICDSKmgDmHLphSayXVqyFm8njq1kzp+JYzHBfCI9FVQKDke2wDUPA8i7H xcC+EgHuNq01iwrLWIzlYMj9+0yuKHbeOCuGwmrMkX2hiq8a6LCwi4dyLCcKAt9njwuyyB3U0Jha u7Bwe3LEi9kqB3RMacIRIg9iUHG5Ew2stIKKJ23VFt9+y4IgnnVlVkBJywkPBkt6BO71jvDo91ui y6JSB1kv5I0AVK0JlkjxGsy6M3l3otDZAwsKb1dPSNmHGX3hKTiBIsiKTiJdueXLlzvqvAuwB+Ae BQOwPcE/2bXscapNM5DM6DijDW7njc4A936PUnHXJNKczUxA+Zx65clR73OaomAsKYWVRB68lF1R /rSd3uGLBuqNNCTq7T0noeCdkUyQ4M+vRreQK6zJ4Y9QFEpqiOhJSjqgBjHeHT4ciXFSaFrxh9Gn jXaw9TugzCmye6ICp4mHjsl4MCIZacxN2ume98ksS6jR2cml1uAVslCC8ddKeXQpyqZQysx7jAxU wQueIiXO2mWe1Tqyu+PUikRPGvzFpnRMi0r7OHgnS89VVr3MdGjoq12cwzG6TvbFqwOR6neECOra Jm0vhJH5D1xkc9PbbdM5mwnEGewBQIMBkFQeK/D5+M5QAZy9FQ63GCMhXhrusnxdZxR7icJCsJyi lALJIYLlwk17Ky7ckFfPCIPFc7xQ0K4LyURfhEWl4vvB5qEwFF9pxK3SmZuq6EtGiuURcBf1I5bO UESqojTzN3ENlwYhWnF3dFrG+krjnhycwko1xldDFXLwKDjUd0w+aGPwGES5cY4P0dcmlkNkzY+o ViSANP4Y7asJrq5CoJ5LzKRbsg9dyl/IJw6cb2qF6Dh9pT3M1bffQreiPMdXVm9WfTI/joaybOD3 RJ6wcmZRThAew4qhxazpoJC+9gt6yxOZ6gxKD32Yy0mFBkPe7TEGfB7+UwKMUoo/pl9OYBkSVst4 AFjCI+TDzsu4GWYZOKA3HFT2CwDBwTMSvl37k3ps6F5seKZ8dLKCnQvPYhnWGt1U9bVRuUuBA/AY d0CxJLHT5Hjt2rooc4wUx3lZ8YUZ+MdEtGkTWVS+jah3atjrZcoYSoEyZzeECLqHPBAW+2Njp6Xr Qj5s8HIBCDrT7HgzuHaokz1347vqOQVV4mdI15PA9+xzXdFwTKgDo4WI+HQ84oBkWJLnCygEEOT9 6wbXIctcf4cMzBVAJIAu8u8uETwZc4hIKHZejnyrEppgw+U7KMeDLeylXoiJmqa6wZJ/UVAX+Yj2 85KYH/ok0o+xivKnNSAvs07bpkkJBxKmYhloCqLkwBIcuwTVfghmCo/RrnQDf3GBAwQIIgmDpAwk wYnYENFeSfU8dsV8yuWO68KkciPXeALJLkzq9QxRHLZhSxTeUKvUjsQd5F2G+l2KOU+1wTmmsc6n YsVqhlRixxZwtOvFyS2EqiNTRuh6eOsEK+Nq8BDZqXlG/Arfx4wUOGkLh22HTXjuIPqeCqiW3Xg2 rHJnjrgG72HSL+I3HVOUqiqju4/cxzHiaXO+Ypihufj/EEuk3xOyw+hukPmgToBY070BWhwIhRfW LXcYHvvmPuDK8Szic7MUiK5dTYwRCwWsYarGU1dyBgacVwOcPTmU7OS4FQ3kYIguQiRQGCIEETUG IxANwgqMQAnw8z04brF1qbjltfPg6c2Y3Aa85wZA5L7qBfJzv6KPV/iI4b3mwrZjO2Fav2PuM317 nMfScH4JRjL6wNKPc951AYiUDjTi6PerSOvwFnbWrwqUN63HBGxrQbwI4ex4BfHeAvBjjNZtwm5n Y8+js2QRCuwo1nwjwso3VBfkTpBk6LeEZ7TQYMSL97O58wGLkSVaj4clK6tEtyspF1nqQ/UGLkFO weV+kvzE2KW5qjzt0unjnlzJlFiyOwjGMxu4FU9VYOwdQoQmGcxvcadcZHvPEXZCNXJxfUxrojA8 Ik/1DGYLQMncIRNZWmoafLEB/RzeJQqCr1tYIHJDeaaOA+g4Ca0HGwNlEaBgGi+cDRQsFzigs1dz zGHIzMmCsa1vyl5FN9LJc01rWtyRNOILiheXV6DSm0UouJ9LqGNNE/gOC/Ql/NLAg3jvnLm9yJ76 VPHESw4VZHSLK4WkPlxRKrzcyRIWjGfghkaUH0dHySUCOOE9SWpdPU3akEliFDhYkHT8GMr3DEFc 09wVewGMXzu28LSgeoDkXRjHAWrdh8T5AYs78HJJQFW0gGEc3sZ3JifL+eDrz4B4QT7ewRwHk7OB +N144PkLfJ2L/yqEg8VfgpynT+vfFK9cy93X5R4yeXTipQhrO2NpiZACPLGZSRQKKlVOsUuJzIE/ jUQv3UBE7HNQFDkiyBBmBzOTz0M/j5zrc0XNG7iaMIXlvbFUbT0+huoTqEbVrvY59PiuU0/ozewc C4I6sg4EdbwPHnuRnFLmt4tq7Dk51Dg+ZE2ipYJmleadTGkLoCAW2ZuPK5s4I20QnOBRm3B74ar6 7kd6XJ7LC6WzjTouc7LyDeXqHESJ40RRO7JuaIkTqSwwQGcwXLYB+yQbliOVclVx0ZmR254Nodoc sRvc6E6+ZVCfirYRS9CjQXm9gOoEBg7sNhIwLd+8h12XTvjCiYwoG9JyX4FEAsDYQvYkYjChmQ85 GtHH8PkauaUurY+aodZt2cUZLgOv2rE54BY5bdFeZo/DC31QE+mUOvF7Lez+eDwciZm2a6vIsLe/ D+KZjDIop7zAeQzSLxiY7g+GNY/oIWE+Q6vcqBqRnk9JmCIsBNFKktq/FWlrtfNyueVXJxkSzG1S G+mgZ4uyK46j7bOmxv2FlLeESO5974+3FUp2jKO2snwv3aE7lcv0SsWNyulMWZbVeuJphc49a9R9 avuT6AfUYJ5Af5yD3D6iF1EUg+gRQGQ+pIKh9hfkAKqaGw8QsL1hnDj8/YvUIO87U2D2K9QangXU vyXu+b7Q89UOADoGwVA7h0Oofs7ofNHAeR0hsCh4kvHK7gx7eMNIXHqQ4k2mQNQNg90HYEwgIP5g H0AOhH8KyWwpo7AoL7TnEMxx6DiQhyaxE4zOInCqU4xxbU5QOFX6tgNA96UDXctQk64fS3lYqlpW tD0p5jMyZqljYiAwFJH7P5CPf1CTyJ5M+KBHmo+fA1bl3EfNW9EAYCIARgQCRANbtScOT/Cqrm7k bsDNyR6bu/SDeToN+zgX1r2wjm1xnIY94PfDFeIUgshHHxsK4NKK5tTomKPao9aw2JKj3tAHmqut BvZjeIuiEA7sl0RNgx3KSQ4niExs0piiYZVQQuTggTtujWA9isYOYZTxOIGGBREgg9bzyA8QL1Bp Py7Opy965FJuIEEwBoqi4udnmbgDQ80BhDeksGDaC4xJGKxTuqOSRTBLMMz0BMeVmFdOImQRjCB2 v5gGJ+ezA/jo+mKdeVEsX83Jq2dr4KlB0g6npy0OzXXlUDliI7OCdsHrKJtT7FfrwdrZ2BEsh3Kl jYRg3R4Va2qNMryibruEnj21EiyoyZgnRYhwcTbyrWaTUZajMvDLPLgtcTF8UbSZk7OYODSnwgUk PV4A5nVdduzUBnL6ry5tK7fvAyg7QAVYB4gcMntpDTRRi6Am+x1dO9Vuw0s97wQ7yjB54BHKcKs7 IwXvsyNiBJ9qD2dZupgWMiuijjkpTFGchxS6xzAoXc+URmwECRV+jq8JHHcHkVU4bFnNwCAuRgtp zgBqWklK0UKTFdnmEeyc71Ot2+kVy8RMQyGXK5KgkW70euxAtC2NHv7bDrr9R1utBivTfw68MYJl y4bLJIODmsjRx4gnsooPuQm5E2xZnEOmLubWYeqq3IH2iYIggfdO17MYr4I4IRI2b7TJ2UJEWl28 lEoWLuTk1pfDv69dGtLTptHBBmZuPEf6QIeRwyJVB0oA1QiGkMHQJUhFsEHARMYmA0JQlBGkC4VI sCwNloKRacBCluFwAcSAXLRSrQCBVQaqFIFlLCxS4oAyT0DlJAJ/ffx86W+f8Zjj7+/iMb4m8va8 oVdKLJekrJiarGznN8/m5mbbZkZkXT6jqGXigm2zvtQrXbMrk7QtfTabaze3Fc8BD3qKoD1V6sSq 9miHlANCfiBfPTbPy0g5kTqVGiFZFi5QmyaO0IX7iGcqAeLJiO1BqKd9Ab1b4mNMpWhXLPI0gYt0 LrkFAqpmqYBZLwwLRMD5H5PVJ+XexJkVuyJzWS6OkaaL+g04GCjz/x6KsK0rpJEidL/M77kDZJ2u kYB4mFMqH43UL2LgvrQ8uJC560J+FXItHQdLgWqmkhMjoGE4mal1eY779cstlDLZT8kbgJgvlAJz IWYg5I728vThjrrLTafKktgYCaCQFwSVINrBkJFui9wJ04LAmBxhDczoWNueuOi442yzFBMB5ook TeChXBooylN5vhutwWqmE5IHHUR1DQQ6zIQkAFcMtAEFX/N/bcjnLLR4V9ZYgrau+LdNfRB14Y+7 BhAPzeqH2Uzbil4+CXGeSGYAejbhdhcqbVxuOlDPHMwr7X6q/mHImqe8D0N4bZ1hx6GMp9V0xTMo F4vfv9OeUmW8xTgys7LcNMmcadOxHA9qm5RxJh1mkpfob4e0DwyIlGoZjmBAKi4DouEEzuWthTtV Ax8w0I+PSo8CBWHm2ahwDQlmljdSADpmxrLAkFqJc9QSXRYSK9EzSeggIS9uiUkTTccWnSdwB9+q HPghkMu0JeBuUr06OZH0bCJw0Ezu3K1Yq7ZLOdVfm9d5tndLbNbIqEekWoIYUEFslwywdHNgd3DD AyyEwldysQSjsL4C4g0MXRJk2zisi48Dpws4n1zU65gSwMyVgchgNmHvTApOBdaGK2vmSq8nhGEG lwsaGo5CHPGkzbKvQrRQwYpvAJQ5ZQ7D3nUVPEkkZVgTGnpGcWjPwMpZhpR3Q7PHRJaDa6L2oYrB 8a2grsHIFKv724kdLMzD3v1g1F9+WXKEH6HOLipDOY6CW88fvrMEWyWuepe4H0MTxh7efIPTf0Od XtkK1FBO8ONSSmmjy3kK2xuujS03unWyYbZOWItJE/gRodbc1ASYVnaFK9jAjp8QAaFloBSqkoAS C4royvCvOc3JLdSMF03auKhQAtxwttOlUh4cCApKBI5VTPHawp9DHcaAvHWrpCwTKTIhBsXWTFCB oKAOY7sDkh6JHZYUmv3q4xKgmmOWaxl3gTh4TmpdBxM4QYGAeFbKo5fkLPCiqh/kwunpFhS5/ZIP WUilFMYHA46LFwOuXTwCLAPyxCZOUSty4FRPQDCPOFd4A4HU8LsJkyiownaWCycEDQGsF6sSvcuE TXMMUMB6YZ1VAhWhGtsmeyJxtuxJ0CutDwt1t2cevXSnlje9vZy5DqKMldD5k8GDoteKkDZDp5GD OiOOjhDVHYydYp1yfP7B5DEGLeW7Z72ZDmeznpwMx3HtMPqpvH3Kcmh50cb3CcCqm4mi8mP3GMXb 24RRKwDIVgkgMXRBX2UACU0rQ8Kd6edGMLIXSyqua1e75aNCj4JCu+A6Ig89BMeNu6fpaXXVTAbB JOJxYHiwkPDxvMOqToPOcdvQWilgCcrImSAhIMLOubUeZRcmZIhe6HskYzbYgc9+evMRTfUfLQaS sgObqngz2WKpyAdzhZwy1VLMwMGEOUuhDkg8bTp6XXLnd0QcGw665WFlC0w6iKxZy2V5d6WjI5Ah wrEvGIhN1w3zGS4F2O8OSVfBEj1SXfDxsEJDzuxJqZ3g7bs6sXh4uDXlMmolsuvRggU06quupA6R NwTi4NY3EyQsdv+YYwagjA2DmIo3vsP5n5SnbHpEuz2TSd3iEdRdiiUEIBKMIj9CJzJsV9ygFRqU bHx1NaSm+N4Q2IHAG3Xec87OUT4nX5h3OCAikFF/vCKUSyCoeixDvzIFZaFuntTlY2F0ZRcyDBjE 5rvK9w2e2svHf8ekQ2LPQHlbGd0dQBqMkXZdvwd2LBM+TYSKlwZAj00w8eCw8K/3FxS59wrgZiI6 gXCQ4LK9zzFLh7KU7pWXUOyKh2nF+wzQj1XzcAdXQkhvM8AolyOpaqAT2TcuG8J5gcOBpaHFEHeb JS4S9n8XiRssLFjmN+NSXWXKZaJDuvD5MA/wRf4G6US5QDHxwL7tyH1PDE2edJnHFsMwHyW4K9nX gcUAr47hICbcAWTZvPPN2w4MEnOiHiCz5jobeSZgbAvlQMJ4mgUJEkTlmELHNq1PFzNqYBNn6mhS gRRBqFMW1QgH8amzt4JqZ1K79emZndIPVXVXKoDohYIGC7IGfMPBNxesMH+AJKuuQ6UEBnawkE5b boiLWL0FkpO6QdBgUVMky8nZqdjvIrFHTxgFisk5R7H8KZ6qBQ5q1nJJe3UQRNCxCIWBkFM9ov6Z eBPenGkXQsuqSy4VlWx3jBoTZ7N7QEVXIiluIfTh3xY5+hd6EiNluTgtzoyHDw2rhVklw6VSw+R4 d1eq7JHBSLazBbClHsqF7UbxnOgyztQ6mh8bNZqhAcLqhrA91LrbjkKHIUu85W7uDbhLUiR/YPyH 4F6W+MHpHl3B8fTRr6dGBJF3Fg/dgsfeRs1ScO5cQBpES7YKEUBUoT+ksgShYhkqDNb98UcFKvzd fAiaAhdHJ0QuKmSJYMRNFTPbEdDv3v7RvBhKm3khDwpQwvnOp7Yykq7b1I0QcY6xQQZL9F093sZ1 4vqQsl0Lt74SqbSdTbSmWCOjBgVFtCpUOaCktB4Y61MIlwLp6rKM0kZ2KE3FBSJ2nEzt/vxVWugz 1og62yN+pcnG5cVYUCgyYPPR0bjAohUxjcdPi/jzFp+EAkgDprD11xiBPVr1qSBimLwMmCUCm2Bx lRHMX8Vdl+aDjWHmH1PBVc3QvWUk0+R+R+xHzA+CnRc8+eKBXRh5DhDWNK0DA5LGMwi2jK1XgEls JOAfvsaLVGBbFg0IqfvzbN6CA+sKWQFkVESCwRCHvdB7lUsVLHXhRqrYDyF0QtSyt5HztoqCujZ6 1IPZc2xyKh30TdFaBzpaeZRLY1C3bwxMK9u6yYRDfRpCr2N3hdUHkcAdzzarq2QupH9BK+28Od1x TXijTucKnMng0FiGFSnC+B2HPuncYYWAWEEyc7XLGRjvRHdkjHY8h1Cao6ZnktA9XGnmNK2JEwz/ AWdIUJd8+Xgmsb653U2cPTjGGHWqdydquCxogD92mjVFWGn8K3UiZUkUhwgWMmq1+YH1EeALJGuN 0gb0XYqxYc8ycUSbMznSeuNj7nN1RMt0fTTwQMDdOg5yJg2gxC1LgZVHlwji3qE7AoAd4QBkRIEZ +voEW/3APXUvB6zbgVzbdMHNI0gOKFurmbSdJhG0X2RSSPJSBdIIElS8hBOEEBEOuoM8xDQrCfBj A62j1YkljbOGXC6RcVkVv3IMlc1qIhWV/CkEgiRY5EzB+ed3ne9wXAyTbfbjI4vuajqozIVpzzrj VKhVnqqV9i3045f2qWLuGhSZlMi3bHY12Wm5AGndeHuI1d4oSL7naw3ZgpunDatkXW4RDgzqw2Re w69tGU+uTX7LKIK/Hv9aG/2BL9g8k2QEfr9I/CZBh0j92YZpWgG7JUmsmUYVhwReNbPp8DnWCeue CGg8EDhUAqFRBaLJZ0hj1AAl571AieX0z+FK7MBHrlPTu586zvIiDCOwDrogE7yNpahuO5C1Ymda o5IfILAR2QmTTtTCVk4CYZyE2IqeStF6DAkeFCt37gi18FymjyK4ha72BF1ZjtCSIdrOINgdhYBz KJffV2rpXPBqBi6NF/Ge6HB8b8CDuDyyQQImSoUlAIdRPaKg8ZqF+/JjTQ5vse+RCIxIEjGSEYRS CQF1zHF2nu6aLpdkjeWphELjo2WkHC/VJVWL7UPBPOHX111QM090DPMI21G8WCs76YH2H2sJkGIj 7z+hG3llAhtJSPpT/KfxIr965sKMWSYYT1Vf39lt/y0oKY3cQ6TPHqOY1YHKcikMMEiHvmx+z9Dp WlBqtqrT9o7YMP++a4oSq0D93JKxGWWmFKkyski0lGlJEsRMfUF8kdCQCsIoAY3+chtWqpuLsBUA NUCoMVfYcJ8Auoq0sTujVWJLrV8E1Ibd/PwVO+3GG9gb9ysK9PXUh2iGLEfex5Rlx0FthPKxgbbt u1rOJ4ljeqqIxk04wviSNLf9xUvLVc41iAYhRQ1/c16AeavQX6MHgsBw3PV4g0Qt1Ut/VZ22NRio nxh3R2usvoi+bbpzJXRaaP7BwM8USZ3PGnjBg+tZLijrEpYsdqtNnT49hyL+YyKpVH8APQ9k9/Gt CnBgn5PYagPrwPQYltIVDzBKlJe6A4GeEyx/ZCNozKh26CGUqki+elrPMDXL05BPHoEBgMQaYfBZ DLoHpcCVUd6OJsNtkHA+ydiB1KAzWu7b523ccEc03j+4GXBHrKojoyaFENhxe3AjPXkhVDLdbWJg EwKCQ/lGK/Q4MGHRdF0EYAftsNcudwyupabWpS5nF9EtXJkMAQSNiCpOv2mHsgEkAVlxrjosORc9 ghEi1buf2tRO21gJinOKf4pRelO9CElFdyupyVIJluF59hnXGnFwxHz5Nl7KeSD6IidX4PLnXV7b sLreoaM1JDnYqydLrY/BUY6RHKDhBhxghA3dT0YmRCpgbMSaxxZoNZpzcSdAVXOW3TK4cyqWlTh1 BTTGsbFOMYm8l+sDyZp9W0dZwMHJjQJPvO5I3IgqEqDn5NAnh/dC2v+UXUTqyQf7QikEI6wceece Aw0LurOrycaj3DDC6meI+Fhw4JmC7q76kSPCvGUx9HGjBDBsjV9yK8XJrJQ88tzBFw5ye9xgcY2Y Olr+gU1us3E4nIdZuTaYOB8npUxTNAk46CQX0RIBUtt9X1Ga7K6i1wp29f4Cffd2TUwRquRsWCVy sQdxZJTCl3XQ2NOmO5pyi8u8u2q0FMkD8QydI+ALiyj0KljZB8Vi9778BLzJbvaWH08VFow4gFl3 myvNfusSKDk7Tg3CgJ2NyPoICAZ6TOPX6B7Hto89O/hX9q12ijS+2YZH8L8zM1ngbUCxr4NnDV2M CWJQNM3e7CgS3iKlfB9yuGvbTtRApGyH6hRR0dkJo2nRSdhbjnMCEDFcZcPyjwaKJoUJUNPveLZ5 m2TBA0ZuTlucWNOm40G+ZrxFB3XLDKtVOa0fUO++nbbA6l7cIZ69BSCHX7Yf6OcvnpbRN7B7ad82 EispWU2XH0MovCDWS3qGQRNEJ6NwadjfwKuFsDlkrEODhNZvrCjar7SeWMmCZnUCJokcOyPTrdQz /lnaz0z90k30UHQKFkmyxfhJcfDAP784dgPvRQsfXNiyuwz7FyJayisWpqdnLOLpXX9QJo/qH9j8 I6kXGW5kJpEORdIHkHUr6zgSwGQaeMbL1Cib4agPWPShZHcNwb49Qmwdqmh3Bt6A7hDGAXjeAHOH e5xE0OwPivrC8Q404S8LlDqChE8ANyG+uQM46QOwDURPU5BwAeBMQ7h62JYQ9fuSx6DwIbQyOA4C 8AbAwd/gDz7R6jfDAetdgdgagyoXWAOEOx7FDcHYQc6nKGxcwHYA3B1iPuL/I2M9rOv+MuP0mcWa P3aZEjKs5t/H8Tg1pEoWDUr3Sn369Nl1zp1fUgsDBgsqd7L3r19Ne289sxuKNnn2DMDwy6io6UHk otXUtngRSOCuzMMoLlCiwMAwy1GdJHkN8qlPXMECr87M1lKZKBDqTSlqy5puYEFRVGSzOLLczND2 +YQ1WMXvdUjxzW4uq2Snfd7Vm2HDLtgQCnTxxTjiztDlNNXyj1rBdPOXhhrxNGa8NmMUDk6MDSQI w0FHsEjQJDfpll4FFyEyivZMRjGBy7FAuclsmQMl8RMAREDEBVyLfswP2AilNstO/ZlHWMvX6phr eFBbPVWzAog08zUkDcoqnTJ3bpgMFHn2QLQqHlSBhvTU908Bb4snckdRR4a5Ggq0MHCMFdHHK0mM F5dEdw7esCb6tjHsWpycZyc4QERs5GgSeYc7Yk7y2GA5VWICIsGeHAbNIEHbI2qa4TOiKgGEEjmo bBWl5F3dwlQNQ7Ol7L6gXOcuEi+qubvJEvgDfPrF9e0KoOriCRmb0qqgdKmOuhAvEZBVkYLrcTCP CBOtZEk9eAbiIpThoiW4ADgkbtT0BT22su9vrbm3V3eXukZyFGAAgzz7ioUo29OGho3usgDSzJGo 7b49ZAcs3N2RBOnJoPhwsCbwbIi5zCLv2f3ZJHxD585nAPemcRpMsIfLlzujJs9eMLdKrpeyLoyK tuOQRwUxImouP5hQJAg6byEZJAks9cz2Px9liuO/DxlR2CVyqTPfTbUur1oE7vwpSJyfTvCSIPSE Z4HzgWRcCQiwOITgECahDIBshZJgVAl3SG1vUCwlKUpcA0KCWS/i25NE3ZaN1tdrmqlGKMWySpdX Mbt7l2M+hXWKxVZ7uyKnV8WjSI9VpAn6rSlJEHUoGULKJCTksgwMT7eSEk+UMVFBFSgp6nwN747r e9GDsZKxACRU3c1rIAQ0u95zhrIbrSKJBiQlJsNUPzUjLwYQA7YEnAFJZFNcMW1zUC4JZAz/O4un 7QoWRTIK5UC6hiUIrh9kcVLg+f4uI7ZPHg0NBzumR+JQVQDmXuXzwzuo76wCzvcaeLNUTs5SRPBQ +Y1ekW0VZaE4MrTgFx5sSB204SXbsTB5lUUdO3VwPEIxhC4AtRR5GsbP7C3RIoEAXabqZ5PHSuQn 5NXJvhJKokgOPi9UTIBPLh8g86WWuW9YS7R4WwLhi9zRQ4SeelHNrKXUHLus9J0cYcaPDgSV2Ypl EKcscsjOOjqHFbFyMlDXjg5xcOuckSpbRwxx4bOEbKk7NS52aPj8PTvoJkT6+s957PLPmYyfNbUu Zky1ZC/IkgQyC0ZhP7wxH2+9TAGCzSgTf2eTtVI9s8jAnewrq+NsoPk2nT1IuAVERD+gagMGJPq+ qdVdvkRkHilwWSfiMeCdtoQ6sk7hTSQH1LFH1Lmhfn2HKUMQes0lHWJcnzrHfPnNZlqPnJ2F8nu6 5jeT3vO5yDRYrkjNloeSn6+kQge+oNaEqiupdE4N9gvK9xLqwMg6gz0iJ3XUwDTCca7ZzWuki0wF C2qtwNBJB0MjwRCoOabovbVJ+OmoZAY2ATQknDCBHRIoIpUTDLR0MKaaAbGBmpmEFS7QDKqJBj1U zfE+PK35ooksiUWyIVU1rmbA98yj+WEZqlDMh+OOodzcMzjVEU8mavCoOmtWNTe6p1PoCxuXUoEC yxLPZGsTMWKGBuU27ZtDQivSDAO+344Sc4TFA6EIfi19kJhpr8cGbJBWha+/rL1onOuAOnWm6NGm 8Q9rqTAKS5w6fbvOi+GbOYcyzvsp2Gw5gMDzZIo9wvZWCoojhLydFSxB6OlJeIKqtgQPCQyuN4dA BxRLZOoEC8cXRYJS42qrllqqKjLC0RIJVleBBI2eC9NlVXfnUTDl42ZYuNA7JsqOdTmLx0C545th s101HNOsRde4bMQNIKE02CzR2VuIeKVUjwYnc4Sdsw8UAsI7dCwX2eDepE7Y7UlG7zAEwCSFLNch hgMc0AXgDi0fEM/6JaU8CiGkAJ4WUDVnWiTDISyu9U5vyP9kBzxbhQ0WG9amok+pjnkSiioEJ9Vf xbIkXLqODEeHbtXJX70SIBXJQm115DtfE19g/cGAhnv6PNDOeDVnDGY0CVDVzCS4JqmG9e5x7cAO njnRtzcm783GVZwFBRcQduG2NP4hXgyGfIHKv0AVABPSSekRFUowVv5gHJqOPCrszgILTsoJ0pB/ n3fULjk8zTV8dGzY7Zu9liWNgWiANYLolu6Ap1AKv5S1l5WzLTuLashLMqOfuuU4r120CEUql7cV vxB56dW+PzA0AxiktrRYjw7uhdr22df5pXB9Ohu2DrQujVEJ6yKvgo1m8w5ajqgh5UIebHXO4vxb gLRMdRd06icKeV2xGyNwJE8VpJwucjfl3bhP+yFbWSVQkjSLTf4cQebc7papTeNPPmI9C96sEbFG 9osWYTDmwJMkT4J/Ump/SRUCiokSgIRrVtmRRBdBwiaoEIvlTzCrou8WJ9sn+PGcBQLCBOCSBMQq FW6hNFTPZ3wzcRMTE7GaIzY4v3hA/x7HRWq7MgD0R9mcNywg8I7T7RLQiQ8auB1R8AeBVcvzwbpL Un3QrA9LGHmwCDJ8pjGSLw301gBq1OLvrg7SWlqi21bpLwgcKKuuXHYy/M8Y3rKR30lLbgi+j0qV 2KL5PeXIYOsIC6OAtZRNc7cVCym6O6wLJGgq/YdEIbNkmX7YHLJ34egHJJcaL+QdrHhdOdZrfMCf 5SKKFiuPBdl0NktAkseit/FV6ZW/uGSx1UWGcIs+l6uyqMrnen8wBbIg9wyfOXxG7p9BhKIoRfdK 4ZeXRN7wtk8M9E428pihwzQCbGQOeS49cJxeB6zjsJ7u5BOVOoXHZCDcamoOGV3oalgfSwXCgd+X hREhdyHT1JBGo6IBfaSZizA42eB+jIk6dRTEDAOQyCZyfSFJAC7+yQcpdGuqQ5W1oR27QXNRwRYJ 4QwgeY2AxOAJ+zniyogOd9SilkJUBVUg5x5AWlq7Yv5wjoWShsBxLjkQwW837j8pLhrQGpwlt2CJ 1cbY+NrJXh5y+9zSz46NtrRKkjKCHjB0nHnkfFnIdLBPY7UpuCRTL/ASwcJqkag3TwnAhpwZV3JP KTkdKsWTgE5+YeTtkivihTsHGSjqGHEhjaocZHC1T7gv5eJzolcvJqSk0Di9KrSmYELuUuqxGauk 1BPg85vAyw0ccE2udFMkEHsnONWeNSLVipbKsdmitMOAIzB+gNxqGw57IVqYI6V8WJupidy7uYAQ IZVZSvkjgR6dHGsrdPFM3hswIlmpK9SopQscxeNxGdom4XDNhVyTdc1O+zCV3CfXNNLK2euvJ0jx oXjxhFjqf+XAnXlkdcoftALqRdFh5u1lbxZVc4eHkwOayPMl49LmfNpXyjzro07DaPK6KBIjZmKW XVxydomJ8Gv22kNQWZGzsGLEOjqahUi9MMiI8hqfrWd5rmMMUhA8D5nCWCc9liaoat8CBlzOI9Ez p5UtKPZ2ZpRDTp5fFc/v/REg/ZfmGERpj7EMwqQscqnMlBmYyYVzeWByFDHQ46jLIp8aZHYgReNU kGQrduTp231G6GpATfNHOuuJCsJs6pQPI5Rg6L49uLdrz3HXIwLhbDjOkiEZeKG8EtE8kpI74v8U BhGPDSOButBYHSWHHnqcgoeX4QuWoeSohHRZqaIrC6ugsTiT0QvZcHIwOLqwT3yJYfEMyPJbGJ5w uDqw1iil4vdpafB5jTbi6hZxxrko0kdUNaRzqSiRXTyZZ4WH5HX6sxi2mf57yRzVXR3IHE5GyacV 6i4qOydQGrycuWUKGCZ1/kERZ515heM/KScyGYG6y8JcdjxNYZqY5XiyyZSuDMGJD5WbdylEBN0X zZKD5MTUqTtMbOjwx5iooDKGAU8AxXuSSV4+XO1B2theKtXBkMNsJuWJQM+YXRy4Yr4dUzCGbSDu xCPbtusVO+QB3FphdbxHFCYDD+u6BAe3ZjI6yr5lGSgYsiFl3GotRJyK2nrQHRhDcxJhV5tlvr2F o8+KTaor91XfQ7xSHbloj11YgEd5g/BqkVnHbtd5osjtMNRiJsHLrL8mc7goSzqhkih481lTMmMa IPNkm54rm2nE4ye6uKvsHyDvljyeW3Nd7SLQkIHlEKFSiDEgwasPG8QIGYLmi3ICaQhtNACnOQDE Ay2RLBTV5efkT9355cdBi4Yj4I/YKgXgxM8SE6aclw7Rh3KHmwc3N9bp2VzR6O9YgelDrnE6pi6K OB2hyFfGKXWlxXXK80k5ONyE7AQSNsg3QKk/C6keDGiKLkGrA4rpHb6uKjgUe9+LhqxHsKhchFQP Byi67tnuNbXnWz6YJEuB0V8PzCYYVu646hrGr0kFkb3caURuqVDBHtvBqHWomYTwYRmfi1IjaCBB x1W9DuBfAKdghdEuAgLncpwPA6jekIWwziW5OL9aGUc2zIEKrGKcHmZo1soqpR6y6Ml1agMfoO8a OhPoMetUPF/RaBGdHl/AZLGPQtQqzyVWBitB5i5SBZr6kTO1tiljZbND0VqiZhcDWMBunFTVo3xY mVkUI0vwqi8SkbR3jE0bwUxm2Istss2IziXNxGDb5jq1gYis1rXMFbJ7gBRLgZq+cibZwqFFAxEK HEMbcnPGTGpTsQJ4NBdDxfC/oEe7bJgE+1J1YdZeazC3K8RDozIkFgmGCNUXIT0mJaDPUdSNupti e4KYwaLUIJ1II1atiUmZoEwEgwNDi15GBB/PEGSCjaWsuOPGlOvBiVGZ71IjGJzPIX3DJEcj93ta HQr8dKsvVzrCyIJ/FOFHl44yPRDBhmNNWbocNXjcjc2WC83OKb/qjAX/kDdkth0s3Awtv8USkwXg 3q2hdBfGEjwDHAoZvQZvmcYjD7Ome7q1iz590RQYMWTg4uGwtEuchtmLXOOhCkMIgQu7aplVj44/ E3ba99R62SvhDVup8wus0dno1pbu81l7nl9aJewjqFxdc0puucChTe52Nd9pnN08Ouixg1WPKjQY ecJ0/oJzgz0YqjCPGtodlZ5GY8xtMEwmFng8OcvSTniil7r/MxilNPhhbqYzHljLaE+Vn7TyOH2v Ybqb1k86jGKtVYtd2QnveF5hdIYCSVAUU9BgJJgVEVWOVuFbIo8V92yOV5rZGOIxMpElCBDaiaPK sHSzknOhogddOqdPhyY9xyK8baQ47GvEmhYVPfQOCwbHjqO9Po1pBgQfePA1HCkOygCkrTWDuatk yYqd2Fcei2S6dseMcRgjEdy/NGXXWNFRXDhu8eH+QddWcLi6QCSAOj0mTfjiXLWM4W0T0ftcOhuj 3Ozevn8/oevzjpHjxmykpv4E3rxo8bbB3x6sYraeQvBP0nTrlSrRdQ7ElI3YnbhDUVyVw2NwmVKa O3yhA1wwciQmZxPEyiUk8nhb30VU1rVacs4thxDSxvMb7TxgfjKo7MjJqT/8UtJU1NVHz5srmBNa UHuG34Mfpp7yQhjViQD53pkzDXuqywwPe+aTT23vw+RSsxqZI1UjbhqKbX0SJhMmTG4xoeDbArMD Fjzfh0zC3YNoOOWFS0YUC6lCV++VX5R33pZ7B7Vxp+IdLukrBAntjpYUqSmzwt0D1OCc2zpw3HAp TXrg+ErmOlZkD+8YDuayXfcHKGYD1i86BlTyRTUGIed9SA8yHGZYaR9QlwK94ePYnUdim/5hoXEG sNoBZ6keZAsG+FKm5dgHNtQOJQzBjArfNIBQHOJ2AUAY1DcFz6PqFDIGMR3KHQ+0PDsOSpkAdnwB +IB8h2AqPROg7D8Q4x2AbX2IZw1qZ04E5VS9eYAOxTebgyfeIlgsNA7jQO4Dgp8QPIPU4BolggYh OIHeDWJwh3AdqnKPCerRfbHp3F+SWqsIqdufmWa/XK2sv+aTMhUtoYLtRWi+qWUETdHNnd3ZsZ4D iLIRwgQvKSPe66JyxPXXTucT7J8hemMQE9oQoHxy8LJ9RnHI2fDiuqGfSp7O97LqzrEhTV7jQ7lb q7YSHoIKEkMvE5NUJdGdJDsTY0gKjQeWBexfgWBa6lOLW68aEkCbupE+CFjjzAzFgI8ENeEDb2pj bthGN1CzJ3vcwsGi9xWSda4jIMZNv0CCYjKY04Ci7kemiMCDh9DCWQ082verTSQxojEAj4g8o4jp vX3XwIPI0nAxyEOWLPXfKxOaNytQrK905JmKCBwimEWfXt9eTXVHARi7Z8J3MEbWmQWuGDcmpWid pHpizLl8NKE0LkbBRUZBBy8Zqg+wKXwxV7Rhy6yemoyquuEyb3aHWYF0gKzXbimfASABow8A3Z9U gMKWsFgoLDbn0F8JaAw4vVbxTx5Cp3KCkZuCBNAN6DIobFEbqCUMapKB6QxR2cIYpZJFmFJnUQJa ycxibWDmgNPADNhA1MTlUbkNgdu+8b9WWJKSPhIFzFZWcRRGu4E5NSgAPeQxhBM5zJsqV3AAK1I9 XuOlv1qNQAsvlXkFXYlkz1TQ6irVufakLjOWyAkRKlDvRmq+bAwHSIDd0ahBicOwIlVY3qwWf2aa ab1ge3YaFFfG8cjuoTjGSQzxvtVaEDd4MvrrRxurCFcYvJbHHQhlsWOzI6PvhgmII/xQIiIgc9NI 93fv+F/Udj6EzhU5CZYZvsRWhoUwOJU3N0SlzJed5PffjRcxMkAkgt4e5zJzIHMJaWwaEwcgiYyA heFAhZLI0pQXgVbgRCrQyQDMAqYqNRBuKloiYUOCcHAGicQAQ3ZklCcAJKGACFCYBehgqRe7T38/ L0dl12F10wLr5VQoq1EUZDiUmQhZloAkEJXN2CZAamb/lYFD9NIUpeQqOyMYWYoUiN/PmSpk0AQ8 AGwRcKoB0GqYg95ISKdUMT8u2WEbTwNoaRtBCfgWf0oOibAtX+2oqgLsmIV1DBLgBJTJhArDeuM0 anrrNGkYVocXCIEPuMKIPUR3o+WSNURCsLjn/JfPV7w3YhlCqdfNwsRze2wp5uHihUQoTcvGa2PH WHrsgZN5H2JdZWawwVV7knhcSrKBAMUeWnYOjJAUILmEbAHi3IqLfXLbQG26I6qVT1eJdZejJBTm hCm8P5atMxSQTCJi7556TCMAAW8ckP8PkHU8eLXKUViuFCqAyIthyTkWmQ/vKdvGZrXQkDkZAikI QgA6XiNtB1yWOO8x5jcb9/m8nyz3Rpe8rs33fIYPu/vM/v8fVeiTdy8/Q4fX6L6lqZhc7kOl9fnL Sl9MbRBm0qWTyEIPNZMuHH9xODLfdN8HZ7HxOgn5Ne/pDj6VRBQ6GVdlNudUoPzdMXJwcHvzvjfr s0arJzM5gkmclMwjTHcilG1NEzZEzEX3Wd2LIekAXxi8RYPMeDuZfZeLdTPBgRoWZUBEqyxHUHS4 xsvFZeaGBuLPwRTIoTZwfl/UNzmm4e6eDQ5yu6v5MHS2n81gZ2Ed91tAcDq9ISVR8IdLq4MVT0oo FUi9DxOJRUBEAODBq4A4CjJDGuRLVLF7lQHgmBJZoU2pJQ6h1s3wmZRG5vJvtwoAJkOOnuTJIOZ3 JcMvhYuxrdkkZZIJ3ihjp0bnBcc5qGgWFakaHCOm2h8349hA27d5U1P1sp3qZsLCv4q61Bm0TyWW ZOy4rEorbwPp40Wwv2AWUltx+gtwY83yK9YECrI2yOr3OEPYBwhyBxr0084kjKxOYpUK0qrfegXM +rTvimuLxs0nGYQxNBh9bG5hpSpV++n+905BH3iefKGfXq8jBQUCrg4A/TbmRJRkLyvY93+OdEwI VjenW5dBLru5GDIJSGcILAgfg0eAjko8tS0PG4GWQGxu20bDx8JBEMYW0SzPdymiT8ry5uqYvhXk tlw8Kz0Ic+AAVumO6GvLhbF5LYuOU8dUhuGjCPOgw8vwxQAydleiCni49cj8A8vckxe0Qd2xX1/M LFFFiyDGRUZBQiqsEZFBUZEZEYjFgsCKAoKIiDBYMViqoIiokWQgiKRVkQQFBFFQFRFFVBiKILFW R2y1qiiEtLFCSKLI+lrBECCwfZPjlYKA/Pbxl0EowIKCyCqqqqqxFVYosUVVVVRUVVVBRFFgIIoI qKKqqoqrEVRFFBVVVkVVVVVVCLIIikVVVURZFWMRFVEYKsVRFERWCCIkBBBVEVFWCiJEZCCoqqiI sVRUGDFRGCCSKKiqIsEEUViCIjEYRBSKqjGIjEQBQRWAqmxxyPGmFPBp25lcQE83MqExuwceHOdD JN91AWx5+3OSJ1ydlPFPhdkeQFeIcogpSDwdCkLvc2hXqADmDWJn48nFc1Ud+BRrIJULRaMWYM/g vzYTmKEfYycEg/nrFAkW5kBOk0I0kI4oACNMLCPvK72K6G644REWI/IOB95Gz4CtIC/+XUmwOO3k U+mHMweZQrnM3WgigDz2GWnpUu5JL0XcuaTadeXFLewBwFiA2HpAYqRM9tXjTAOMkDDBtknjAPYM 4jSBSMx9GbOQPFtS4YJO5SDzx0XJY2rJXt3ST6lS4qAg4MIamddWoTbuB746UOTpBWUsUt0RQjp1 Ukx4XHruupQQgOqTo0yNcHMvDaVL2vCzD10SMckFdItWT8zLQG3s7LaWDBfSIjGSOjO4ndNoeQmU Q/hEz4A28bwwwzMMtOcqIdcGvhoNrtKFcQ62twcD26OXXDZgQpETGsvMLJekN5bU5puJ+mX8EAqo PyCFkMZhWHzuUymcPYNcZt17I7+/rMuD8N4zzgMqKwFRVsXVx5OX6AsIJnrv35oJB8TOj5jfMDCp alQ9/HUBAEWSAYJRxS+tPPngN+YUKnCxmOnD/L+jx3fjO82Gxcn3o3vvSu10IjUSmXxBCWDWxy6M +JQxMqGooL8h1JXDrmZ0KcEG97JYPHKj/FCZ2rmfIueS4N4EcEVGDcHg8IAWTgOmHnaX86TrDrPj +qD2soe2L3VhztHh2TJF1SwyOebuDrVK2rJW4bIXWFSpWJlk9nHmlHJ92LhS2+BqLlhkmbEpmVAl Sr1iRAr9fnaflm4fvTsv0L7fYGPnvmR+NstAov06wMgwprN8zNnLm2mtrq0xeI4hDngpjCMpmWw7 XK3qeapJNlE3YbpeDdKvqoyx5wXy0xKQaSGYPHntdvGK2fXsn3joXawdpZW0q5INat2zBiRejBh5 dASACr5WMQoLNlx086ySBod844UfQFw5FuhBQFnZaRVE8cD+aW8AYBeY3tteDFVUO/kw+KK+O2QG wFjHA3Cb7d1iKpMHpa9HqCjom4JkMpzCjbL6mk9PYMqigUfliD3loGZdkYIwEA1hrZ1OflWVYB4T oPdDJhMn8vY4QIUoQ3/gj+4TUzzR/j0zM9h2WkuWC4rDD1yy/XTeuOJhjRLa3VucHBt3WsDp2nHB nx6E5VpT34sAnOfPV9+PhOnEqPKZY8ZLWudzPUXxzUxd9NVicMK6zdUuzNcq5oEaQw6l0ryN4Jox Vg3bHJNkGfi5QxYkzEx64Lj/NcFeh7QwWaty+I6ZZkEi7MYHWvUzqpEbEmCtMzOA97GkMxYnjupJ luA8M9nLrW9GM1UXU/6avr4qQuqhS+XGXGRjrpZxKwdj3rs6ltzbb7bj7GCWY0UDmHmFsPSEFAf8 OHKmtsSm+YfAwPx9a9ufPrzo9/MMCBDSUkkbSkBI0GcMyZxAEqljsWkCasOJFX+e0ZUTf5ZMkCOp /jKvuoC+lt3M9g/Tb4Cv2XHQ6mMOrFBZn5pNx5i0krQLMVts1vaa2SS9aoHWpMBnJz0VTFujVaz6 icCVS3NdcJFRVUrrofmExrVIG2IjYiU1ZG5V3YHao2jgZRjq2GZb0XIdBgHqSJHXOiq62dw6jOoM imVfru8FiOyLqFC2jNskEOQ57ddwgyZcYjeEBlAiXJPHoP3QRgNucvIxTltmOlpz6sc0N6WVkAZt H0LTle7dPCVsKVLuIH3SkL0J65zho8Ltu5OHOcLtJUcumBvVNa9c0HGtyaFp7Xe5z8NcoowGi97T 1ZQjMpJ9r9cyLCKWYwqMs3XjXjx5uKJlbQ3jlM6Cfc75lcULt8gsj50meQgus1Iykd3S2a4XdqyI mBRKp9BHiGxDnZwcqVCK6HO8FpKAZwNmHk/axWXeHbzILLafrHieWfo5fxnWzxgwRhAvmFt5sWUI VYyWXBk7eu3FFtEEVFBVQGlb0vk32QKEF8D/Lxs0365BhuMyFI5Xd0s8v9QbIxOZq/WZp2x85veY RJ+7R/wR79SpnkJnxgn1DabeUkoasU187m1ub0SYThvwaroeLinOuWFco83KZjCHCcN2e7eunSZz NPiNeYq3lQyVNDzGjUp6tYkqjz1PI7TjwvGp6Lqb0921XpqrfNZeeVXg1VkZ3TrZffZWO7kSl2pH Ub3Cj32cUNovPM4D+7WeMdsjBpPNC5S6TGuajI5p4Upbrd1LuSkNey8Fgj2WXjLst34DoyWCxAqN NsOn25i5O5FSbxd5ONOSjQ8USbfUBUo/u+Ch1YlhSUgdIzifCUH25p1rkfHUpmEWe0WoEWM410MK jNkooPpYh/ZLAVKWy/m8noOIuISACKASQBkOlhFUKQia2/fPz9ISUqST9YAmJ5Gp38jrgX1mPaHU DvVh6h6DnmFpWcTsjDqwIUr7aPVVT3jx1nQFSrFjBO3okxqqnOBlZ1PXtzU48OD4VNUu8xXULmgs IXNa8x6oWCThOy8cpkQHEWFEEPgDrg77faNJ6qEHqTlNsKfMuEyI45C4TquD83pt7tkdCdGMEyMM KEQCKC8zwX75aORfGgaHtSoQe0PAsXA1oOJ7unL3Pm6qMA7l7QBqRfePQzB4LWNXHWtPRO5GFis0 QLyiWJAaiBo1wluN2k0NOlAzDY+89tA6Kl0bUlUYxs6vK508cbnnmeLt/O2Q7tVRA5hxux/KJcJv l3fbkff6JCXiNjq3FYp4Zm0qhSa8XrYp3sMj1HEp2iHHrBSeUrscuNq/8w+YF7/hA51w9ibdW6dk gdbaKLRlELngVS/JHwS3M/YfmsxX6bi2vn4xDYkK22NU8dRfu9VJo8cV1gq4/gHRaO22HMlWHLHU 6M5+OqzPXOykaomd7Vmz1R+8jW3L3Rk50imH4IlrkjWw1CG/Fb6ow1liMyOcRzhsT5dPZWxyBrud y0+VoV06FM/hFBftPF0D6byr4O5lJDpd1o7ru5FgYB7OkCL8rZfNRXYzmmLHlhhNoDbCb2H0BAoi 7qmHTxA6GntbCZV8zWX7hZ/Z5VuGOFDBuKy6KWGnjpbZ7yEzUmiddBRkYJBcydRHX3UtNU3fOxsl jExxV05lYb0LOE0SpCejC0TnnLlSUyGZ8sV1KmUQ4LVruuQgPfgPyC+BHD9oMrdyD+i2oGp+e5le qt4JqjPVTdIvwziZ1Ps8Z8I4aPpzw0jzQuUCbCEmZ/y9gf3xQhSPsFcLE7h/NL07B7EVJT1NTz3y ZmEZR7Wy3enQKwB8vheY+rHyzvNV+WB334LkqKht2Cj28aS+TuyrW1TlzWDYOmnTi0S6OUMSjKzt NhOrMe5f5I7IpslRiwzqVVa3111xcU586PsExBZf6o9yiOJfC35kC4/vrxx3wK6emrpVeq+XHo0p RiPfLz6gOdZ/b6WkQmapW9LU9Spm+OF2Y1jM7+l6DnN33p+H6wcYBvoU4KEHfApaJg8j2TPeoj2q 2yfYzmsFJnzQ7iejPO6QGvokGNz3IJIENRSoLTvqAXOqUe4n25zy8URLaHPyPnRFa3ao4Oppxy2K 3HLcq7LOU+4ES5+F+Ej0HwIchdh4QTbquoUoYKdhD9y+g+DULCgkDzAqJtESAdHmpgJjDpH4LxY1 Yq8r2hxLk7EDmG85FU4HiAOA1CahsNBeA/AMooZlTEnO5VDkDKGrcHcAYnU8oUHIBExG1To+SFxP gBkPyLAB80oYO4dQ945JcDjDUAdIHFqENQaBpQ4QPRF5XnAvAXickj2QugX4DykiBNWCnPr18c/Z J7vQ6E3TMoXaH8dvdKRjDGkAZcCpQSIFuIy24vZFXeY/3kyQiDJIMV1/8CAL9nukZwM2WTUydROe N+HEP0ib8x7kp2+C1cXXirU8NwZTxXcTl7zvDrrs3bs32CRau3vh4Y/dO+GCR4zvpuOvL2qYzVO7 4ETSPPrs5ZCQTJNTbv0kaCCJAXqmq7psCvenNgHhaiRq2K14TECVeqEQSTAg1KucvIptbMnKuIu8 5LPMOwLHbImrEzWehRq42a7S3TonskiTPXlCThiTthKfMXcKdhQc2u5KU+Y8RLwZ6xgnPc67BN6Z nZpJjgcN5fJM7SjAei0lSV486tACMmtnJZ4YpYr3urTHEVHoDqa5e4ObvwkTVEeUMNCcus46IiKR VFO1VmXczT0gtHcUDloF1NXj1Lvhjh4jqF7Xr3yMCgbeDF4BdVZecGN1AxB0tlLQ/VCyeENhdKsB TgwwOzhKmxdjIFZrcIzee3MyfUYxKOBTvfX4hyVKn1z6UMBnGKmw7xXOZDFahri71YMTHLKruuJt jN9HoYzrjr4zIcjIjbdD0YEqkAkL15xYtYo8ZaO3axke8PStxlNQ16Olq5USIEWczgcUBcK9pW+l vM2vHyvuGIEd3c5GIwAeoOZDN34ARl117vZ5u2ckBTVu4Q1xseynEGWgIYZEx3Mo4YmZAtqQxhC3 /i/t+ez1/OmlJNPivSNxhDC9qULtaxXwS00DQnA62cyxembt3axBMjNkVosDgP1A/Chv9FbPIEKv JVhf6Vu8i8wsxf9Nvxf51pgjmF9+DcNRqJTYYNRyGihipdYFUIFEi2soqgFFGiXGwlBqWSzUaDRS 5YuFkugF1S6lBD7+mtfnj9PdLGJhTCYwsZTeVefpZ+4yq41XQv6e3uFV4cPBjPGR0yeqBuHAoboV WicBYKjzSt5+Odt8sCtMS0xDCray4b6q7XerXrVTEthzeNVhFWXJgu6UhmiCkCB+pySmJEAFJn8J /OmZy827I+xKVlaX9z+xUA0L1Hh77IxvdPNDCANbtdnxigPhkDHN8TaDJ1iHXJhsXZ0yUuk3BjEU pcevTd62Ojy27G5Z0FXrnRFEdNaIugjYyx2zanPAXEMzHjTmHMUU2FScDt1aqBPBNi91MRy82zXh frskFdd6WUtlYWVezCzsn3YwMXz409kPIiKeGiYfc5otY1hYYbQMXcaCmtsMG+pq2vXEcIKh0ihD gd7X3X8kDdBRwt/oYvxudSzrg/Q516VvHZA4iIvZc36FOH1CzLglzgLfF8UTLBLDJQD6HfAPKnKt iJoTjBoHRNhQsHcLdl0w9rjJUhzMJdTBgPEEAzUwJUIVZsmSIkPbj6P3SihL4DewBNQp3YN3H2gc tLasogsTaRMd51l3K8BdA51Q4L4Pun8dnR/nv4cZntAeTKcpE+cxJ3rh8U2mmW+9S5SxZj4W9ESi +nHHDDwaRfQ5APkKmIJIuj+qHGBqCji0BItWS0gMkXIC7ADgS3ATkJHfT7WqFD2fbk97G71u/azK duIPHRqMzdyk4ch3i9TzooCUANo6sAAjwXk1upcNmyvi/L4EJYOztXWK+CUFlFXaSNUlp0H7csl9 NiwbIknlo8kJs4Kkk8gjRawQnVoEdIteJHMbHjamOy/2F8C/YdCtslbgzN6iOnYkx2n03rZxsy5c zUG74NHAaFPhyEgegaTpSIxxpqniBao6iInScTn13knEYPBO9m27bvUwKIi61JOxcPbZVBMGAZMA HQ1UTPRSqvnC1IsEhsGAwnjsCn1YFc5RCWypvYjG6hV+8RIqEWCokQGCpGIRIgASIkWLFiISCxIM SLAYpCArlliZTGjoUNoInQWyAjncBVsnabNyxgsJBEUWCvgwdMgoo1SoGS9daIJcCCEvzsGpiXo3 czYyV6xQOXEJlQMorZ0TsluTLC2dTFAEsIxdFKb0TW/KRtFSyw5JCHJJCmOp3mJGoyNJYWZKoZFY 2bnyDq8AmW6CA5nPxks0SyMh37nDgYJWh/UAceCvUszrGvgQvD3xrBEIj5HibEO0Be4UMWlZyffr GckaCmgLUHWHNr9CY00/lSnNTXzBdH4hFkSaJhKiwsnCAv15IGd01ItqOwU4ehgFUSAcEdCjQ/NU KH5JYiVZnoWYuChh1Rt3ZXI1fU0nYA3WCNWTsjxxAHz1YJqPs6wqxlIAsMspDLVOutHOuQtpHU8z pXaga3FUqmDIbAVL4K2qYZGSroLRTGRUhosz1lAdcDLyWcvVLhnlHRSLMGSDkK20x4fclR2ZfzDA PQCmIzclofUgxuCn0RnQqLCho5YZWHECNuYIzdbpaH39dzrz7+IKYDuA1jQXpcwX10kvoHE+iswr a1DUXVUmAUxoV7AlGIMG7I6MqkKnZKVR2uF5IzvQ9vz/iD0+J8fp8Z9T6/HMeErNN1SpWjp1cZrS lzJFKkFMA0FgCJgVAyRQEm/iCHz7Vgg6jOtAZ8T4Cgjn+CSRMHXGd5rB43sPmGPB62yGI2GGcfE0 HStIFUYDYyR316fQtVAeeNMJkb+xQ6KoRWAEQYI9fJz0A4NkaWNBIYKYeYhpk8v2md8XMAkY816t Ag5t+Xz2+qiIqkxuZKpWRyc+Xro1gTr7iImX5Y4qlAKx8TDhYoTy7ZylTkVI5yElJFFDog+adWAW 1hUUDJIyTc86wOB4VqxYN2LoOjd7K9XaWCUi5jMNnfWJ70FPuHshfzX1ALiDzrrovf2Z9liqCozh 2z7G8741maPrdTJyxvCw1eIa4M3GC6rbs+By0U5l0aJPsDoskM7/dzBTEXMpiZjTMUkkn4DyHn3T 6vWnlMxsfyT6HCcqhjUHbT7EHRB7DicL1XqoTjZMnRKbSIL3HfFPG51d8c4QxkuF7lShYdw6TiE/ 4EMFyMbD0gSrpkOT855Bu5rMHbIE9m/klQT8JQSTN+OTFtDrbkxEReRJ8a4UhBCukGBpg9WgupUA mS3dUJsPNPgbmXDl1qKWcE2eOuxBRGfkjTbS9FgHpGLJPKIIwsa2PBhPBiPL4RORYhOxdcsTMclA jiViY/aY1qvj/d7Klw+qmfU9DOsPMtIQkRrElK9qdK0LkyTj6KEppkATEuXmCZDQh1+w/oCVQd5g 2tlXLvxW0nllBQIeKkIhly/wQYtj5AevdrZvQ3KC5WKmWpJvfjtWjPqx1IyxFw9x3vKxJZJZIIlO +e9zODHxsI7x8Edlp/UuD07sp4ubVKVj3Y8TzmodN/NGRHR4gOTbqOz4MeHF1qN57kcCJSJJXHEX HOPwTzXzApFeJdEJ4vtqFsxDTw60R6Yk7F2pyYsdC+wfF8OKTAgzDJj0XYcD8vezGAK/KQx+d8ME kqoBlZAkFgaXhVi5EwNGlIieH1pwpmDh0/PStXIO8IsFNLykL7iZIYTAVlIvI8a0QnJjMHBT1t1S 1h5shuxDL4jVpYr2w1YTLqXd65erILfwKsWDUxkWpXjWezdxkqKMLp1DY7cZ3YueDupQtLCmNYmT M26hkptthmGeGghuiKQUTgalu0OIh85oCvgWIYi0eKcYhYr9gVbHOY+WY9TMIQi0g0J2mSFE+Fvt a8S7zONsmQxpgb2Uub1qbNjRcS7Nu5VpIBJAGRPfYcsycPGlK8oUJud1V8U1BaTxXzk7wN247i1i SlQQs7Cw56KFTAaixQqSzVru3KatdlJX2MQi7OpMoMrKYbu4je1Nqrh8Mkzg0+usH7DN+2W24WoR hzqmm0ohXXT2lJ0u2JQjI6u9NWBlTET1BFrR9fFdBS6bPZccT5HTnYZ9p2YwO0W5hlAcfVH4BBlV nt5KFE8aBrURnX9h2x8D3VQ/IRF8Vt1S3Rf3mhMQ3lOV1nw3QuSXUETf2GulzQrC1CNw8y5xA/pI n0bIFW9WMqDKk+e9d0IQy7X3A9FC1u/KcUGzG3nDLClSsSBWvW5ea36Dc6kg0UQ/Sk+aw9jrJF8A sjnxUgZJKfXDA+FhX80jj9PH693Yk6/EQqd1MfTDc+Sdj74omtFfXTz8HBInFwOHKlOypFwU8FDk yJM5nq9ssyNz0aNE8RnCrehBfF79QdkxsFlISACCQGUkff+jvZ39WLD3ug3vPGb+H+PY8vOy3Z5h W9s19Wm5iF6EU1KyPYcbC7GS6JD9nm7twJn4Rbp7ZYoqHB5qyHGxjimGJRfombUDDzLPNkk3XTTt xxAjYd7SsmOsrkzFCBFGuggcVelxReudFuBC/Bp2LFlOl4UJxM7MBa6zvRmBmBSl+ri6bq1CyrdR OdZnKhs/sqZTFSqpwPmCbR4OsauvD/BjGDxSt1fDW7fO+d3va8LHRQdiq3pxCt2vW5EtYJRsYKPt 3sg+KXimSYQ2540Tresl2JBnWYjqknClihDo3GMMmjqb1I6HXgSxHJhSBpKbUuYrGCdIUIVgMHUI hfrMg3LnDqPCeDXQTmLZ1V/LPKGzWoYOn5fSNjMjFOgw7o5Ha5i/4RW0jreVOHCUrmSMkY5ArCI7 s7nQfJVJ0DkvqmhhlN9i3bh+xyxNE+6z4dG1K1sdFTD6WPGTBYcR0tPyPaWgxaw4iOxZTDKVVRRF BWNQq2BfSpGbUytSFoYzjVSUjhjwxWxvXRA1UEMFrp9il8Yn7CMmh0cnZWAxDuxqBxWKj0SxI+JA 0B7FZwYjihBMUE6jXIDKs4Yfgt96Dn6A65PFXOasy6nh60V1Soz3QZUiEHS3CEeuZGoKW9/CF7A6 pRdOLGBVAVmOz9DSNecJZOD2YrM2ipI3OG9ViQIRxSn9xIEWneI+RDbcXBsoV8Hvgrj36xXfnBI/ Q/Bzc2EG6bFXZCJ9qWyRicH103cuQgMQ4EXrKIELqxFwi7y251nJHU9ctC5vZcqrO2Vxqs4hxpBn UnlvIlfs6Xk8Wvj+kegxN8NVX4OegMXnV9emTj/GUBeNwKM9ztekDJAPoYhC7C0ameKioJPGo9ke VTZwVLUopmdEH1UdzOCaJl6rii3lruM5o+WjZT+wqGZad7gJ5swUZ73ZeOyGmq03wkYsZ62GibsO 6LhgkNU0akSQzsTnHR0Tz5AvxqkeOcqxWh9onjzS4daazzBhbtSPRGo7ssSUdR/woHsAH9xVO/mc cGDGs54eOKfXXo1RQw55aWG9tBUpAwYNRXapmw2ZmKtJyWRn+4TWpcxBZMSoGjkHTy+ONF9IdWiJ hwbTEfZywGoOyDiRi0SM4asTLXwp2RupW2U5x0Nk5om9cN2iPIQWzLZKPJjG5Bk1vbiNva+o3W1s 2FUQlGJxQIUI0ajEZ0xvl2sxcGoEGzmBNWrkdgqvceB8kqeY7h9EOYTYB276KYxPQdGNwQzLgIY0 8A23PcJtGlKDpAsu+BpB8wOBcQZhxl6HNoQNQ4h6FNYdL5B4hANrpHeA9QN4bg5gyzfHFxqdY6eA DWvY8oHcOYLg4k6D5D3X7A+oB4LhjmgUDn0HF3DR7gfUOomYdqnKGZfNeM2cK8iHqDANYljcGcGg 2qY8iaYp3OUNoGUVNwbhN9fFToXPbIMj9f7K/f+X9/Bg3+duLNg1OpxRgE0O2VcE9R4dU7HFtE6n C3BpnWHW3rk/Y5fECoDK72elcPaRuG6HJrc309BomQX15w3G6PUiBRy1ZrhNHJfqY6q4rhfrsJ2s ZNFojvJPPN+x7FTNb0y9mOFXZFOQ7jurAn66oSHblSVAcsDrmJuwuYUBTppKWnXP1xLKOGumKBjx oC62QjY4oURmN29KaE2n4YmElBNVkPTHoqZoT7Z2jDBhgM6Jnx92kGvVwAMdSD5UJaMWN1jdJm6e 2yKiMdHANpNWl2Q0kZ/BoGwF2UHmhjY+sZJRAZSrZVTW2Pml9mzFJza20WSWZzHkwjqsrqmsxC8N GsnLFAIVMuQk13HhNuux8cFFhnqDPAV00CCFK0OTWQaklo1JRMJEmTAk0O3e00YGggcXkLlteN3K OQJQWONuWI0yODMCwy4IouMmET4X1ePcto5KL2RxDeBQMI8I80JPA8bYu0RR1WZp5GvoEyNF2Art 4YuTu5tXeGJHb2pzEkaq6tt3OiBVz3Tl7wGig8iSGcgXBs0zVtjDI4mRNI4BtS7ANUp0ihw2bwi4 EQcQqmVSzWHZYUzuKQnbVAiKM7nbdg021O2eWsYFW3NZNRwMgGiAswb717Fd7lHEEBwRx9Km8FJ7 3Yalx+0fJQv+2So8waBmEKpZ1MI67k1dX2DaKAkbmJVHeRI3evN1va7b6BshB8Lj4I9/OZ3v6a/o DFRU1B0hyo6ahPGfjOR8Zu+A6TjtxVYd/2DgiFUlxAKgHbo1dmiBRHA6JZAoFQqF1srEBul0qLYL DQApULANFKAllLNVuBQe3sv5/d6a9fn4cbykbY0ytQhjTGpSSF0mIiJpWhyV0DsHDPMEEUUoowWg QLgIF3gZgWB4WjcLAwAuEQLI2T7/XbxjXDE979RsXttSUenPTMdE+jY7mvXM5Jp4y6bNqJcVmy31 bITC1ruG9MXwaKx5Ad2cNnI0r6emc6ydDKTR/2HcEZSSdF8rlfsd9OoSbkaISNuKFfBco77X7Ra+ EAjNJxcRAxExbTlR7n5gHis+3C5YfhRcOciruB4kQrN9GL72kMkllWYzJE93ajXkZnELABZkkTTA 8EyT7m00jPVxGuKqIlYCgmkEQQw213x5UDc4c81AEmNyqAC5RUV1Ag6HGmueZFno6sJqWgiBx4CE Z5BIGcc60VbN/8E4iUBXlTq3+cl3EfAGy7EsEktATjcbAigWKJCoQsQ6g/hKkQe90o/AGl9g3ULj Hm2nJOczmYg/U/GzWsdO6aKl3NDnO4G3hF3oOHdtEKd8st8GXmJnvgJZRB7RQVw38TFuY/tBRBPq pGsVcLF/KgKjxICrrksZJv9eHuqaQ2W7Du04JCGEwkFTesmveRQmxfM8tBe0t+zF+hvv7TBpiNM4 e2QaPaW34dvMRD/bGEHPbpbcHPnHkwNROwkSihXRGkVgBBrwqBspwOcyFQsunISeS7ekhUMiguZL Lbzbi5vfP19+upbdUJAHlBa0UcgghVE0eMhl9MEkh5MQ5Uk14QDscgGjR4X0i0GlOUx51jQApAEg zZRiUikgF7FoacbIquVnw6TBOR3kdKoxD9pIzpSqec1erai0sqfcwXONZbKPNiZHz3zKUpXPuDgv h6SBW3gRaepIMmbyV9a7UPEOxL93DW9oo3cFrVVipUSxGQdOfH7DPtNUxeOJs19fF03QGJ9p3bWU NgdTcSpQkPUi3byRO7zuQioUj4M29IulGAbfMflazgfHPqkUpjqT18/S6ICChMQDnALvDUvqdGgC mASw4UEc2d2MT91ItYIoCqQ9KDgah28A7BkjwvEBaHblISrsWyRN1LQ66qZT7WVujos8UjZ8eSgQ Xa3WdTwiwRw/sngwrbPBbwGXWc6Xij4jDBx7QIKpE0VwuFHHzVej8b3mk8/H1XvmJNhY8oOTONMP AufmtYYzNW5BGRWniZJ0DtEFqs8T76yrzplikw1mqel9RflAPRH3/s/FlAkjx1xx+XWyrGhjL2gE YQYTxy6rKTOiECtHjkkuItU8x4YOyvhR9grRbMJJJMyQCnrzl8wMymixqohXJliUwHkfFuS83kDD +6CyVK23NRLXFe2zCXWKj6RMq3XdtCEIiAbIichx3SGbUxRqgNVrEs4uh+vVrvoriclZx4i/EEuU d410waIdI5p4hDCCk73CgqERGsRdMjiXsGH2LujVeDPZs2img8FtpxZ7yYrinCc5io+IyfWZOm86 DhCs9EFeqJDyJmpKso4YhXS7tBhmAaPbIc4LMOazzVzvNufEzb72s6Wb3KZYxVIadsbrqQ6LE1M2 TyXtKKYoFwTsTJ0qIqPEWlaT5G3B00K9HW9IhuP8kGwibPScXuz9OhHe2gCUmA6TL1Q8DNk8jzN/ Ga2KrzHuUjap3WMSx4HoTaOnidanXVCmMBITFNCgx3WzpbHHk27GmJYDsKMpHiw5dxscpe9hyIBA Hzdo5ZZdyx4jgxa0aWwQoQKGcxcPBL0hxHJqRQw28h2DBBRzQWB+hdLHD8N/NSNiC0gbX2A4C+NK bZTUq5zMhlEq3x0rvtv0MW74vWZOTQfzET6u/Spp+f1TPhVBKeZjvu3oSt4kNN1RHbb86am+rjXj Pe2ApubejZzh7+apmvu9SmshUY8l2MDvEdSGk+D8hWfsenh1PB1lWAzOdlg50OOUswqSi5Ucejov BkCGiHAgUZUdXUr6WELbSosJ65XpxO69ALs7K0jgw4Agsv3mNHGpUol2XlX1kzg2WHBnPQ9HY9ax pxEHgZxRI7Gz2PbBu9SPsFL9IZxCpItEvHDTto3lmhsfN9x3jtb1S7O2zxlT9i4UvRUMGV29bsGV RQi/fVal9no5uAnBmmR4X7UQPTN1YC4X7EYHwwMnmPyRpwcFujgoBAk1AybhzW5uT6udfXHq4Zg8 W7pmdMB+rc0fHYECBmL2fqS88o6Bs7rMkRfe2YlxZ85LLx3PvM+jzzstDzgwCqbPZKEGLX0AMNih 8X49/aQGm9P8nsWL2UJmbSgOn0/HI07XRA0G+jLc6jTRV8i6k4aanHF4745DYHEJQ0Wm968CQXS6 H1J3ve2egrzPZyyDkh9Eofm4kM/2OlDQJ/Ol5L0xV0lISZ2y+8azjGyeXSf9QLo79FtYvE7e4d5H Mk9+m1HQ3WSaze9GaKZJUK7Ao8k2YbMlZ2n2ZQZATc5dNGQ+z3E6kDSh+ApPZMdInwd4vCRqQV8U AfDNfYeXnKw4hheeBwnG1Vc0i5J46hqKtcsPXS7GIl3hPBSsM06DrQbMrRNpBiq3SnfOQXYLV1w9 OJCWNZ7xx86gVY96wYWjfIm9NIgKOVAeNiLreyfrRYrhuF9dXmoMiNMUJBORkivqF1fLDbYYqSv4 I6u9ohOSdqZYmNqnvC0zBSSoHc0ue2bOqlGEXm16ew4Z7PdheDjPjzndW8Zc35ex0k0mKRyS7sZN XeUK59INlh+qUS7/g1Gku9koijXgmxLz7uSfKzTGkywhiixKs2HLBSzcIq1iGxUKYOvSnPJwnDTY Wsz1bqOh0rP7P5JjCuodbg9yG8U4eiRrvTy9n99pXWP9y9GDH/2f6tFO/98M89/Bf3d7j8zHdsHx 4a3zR4CROhgJB3T4yeyxMKnxU1KVjLOjH8DzdUH0FaE6XK0nwIEEWrK1jnd7FdFHj8c6qWieqYIt RX3XcfiOYHcm6YdmAWg6GnPYSSewiIIbTUW0U/pMCUhKDxZEmThUQMP5e+nN5oUYCF1fVn+iZGZn oQMvmav5uS/fjccQPG+rDwiwYi+ayahbdZObtiuxUd5M2f8lGEpRRJdHR2sFyx0OjM6T74V3qSVs dmzLsPxR8eig6FQyeq9q3i9SN2tdWvbfVU4TnGkcnpSDof6F2dZCjy0E+6h33K50ynJE6T1ZdFo/ sVKbL+tOtd2iJ5vvdbl++JcH+HJg/1EgRIlbqmn+Y98zw3G8NPrDfXiOLZwmMSwjx/Ak1yGWuWFX S6Sj40HULnDXYzTkhotOC58kBUA4yzypca93Dq3W2mGPWXWfbYONhHZapTRJRI3pcHW+KGR0MqlM T+exPkfOLpZnWInGyzFnQSObTJ+7ROpUeF0THQB8MMQzjJLeGhTwjaM7oeguzCEnwKMeVLTRjUw1 SpLgxeEodWuWZNDGzBh4OcpycjOkxfKNNUtzBgOSc3FOZbBMIlIYDDtuwanoMG1DLntGyyvmkrh9 gpKNjTKT1Q1rpVoNCfUNr/VJKGIbXc6K0Qmrvh1l1YHjy/SKE73QCSAMvs/DEOh1Jea3iTO7beOR 6QPMYdLwjvfZoKSZggT3yIsKWQhoKro5mJVX3Cqzt0DGlDY/RHaxJSsQYLQ1CsB9ipixc73szl1n 8nbjZJbDaCrUIfLBwpFasg+gLQ+HhE9iiprPg1nwbyDtQjrUT+QPD0GZFKcrNvC3ofDWt3YjSIQL LBeeKFOWf3fXgdOmJ+J71qyus2M8ebaGkxzwScdYHbnRb2iKdULp9mkjlRilGeXJDpweXHtSg9m6 6OuiJHnFLRQxyKCI6V6cxiC6MuwTXMo021cL6FCheR69aceDx/jEIGhaRsLCQBcZ8yBp7pyMhKmg +ofdI3WZ1K8bdTlfaOSm5xW3RP2azAyyzyPmEwdMD6IONfifewNIIj8kWD/N6lGhxRN5iIw0C8RO sOC9rrzU+dRfIEeANlFHZroOx5me96NEOmsCmbDTvzy3ph4owMzHAKwIIwbCGJdMWHaGIyrjhGoZ HFSQXw/jyAcpCoQgFrnSYpii7Di1vOh+c1O6EQv2Or0FlXs6UKkmRfIdE0CNTn1BUKDNGshul2s7 GaeCyq0xxQSKU2IbCTPfHYuMOR0esPRHfexUDrbzplxnZdpp6eWaEGc/w6XoPQVmFeu8Mi8YefHP Nk87tCw+b9TpbpPOUtAnk+C6pqBrGCWDxN2tL1qD6el0nBOsnWgTIFhzkRKA4Z80UXKkfcQjBg/o KRXxTMr36f10RxHutJ98iidFIyaz2i7ys3kZPCDYHbI4oeXDXOjCzUn/cL7FVTPOIvB7oVhKms18 GCo6euf3RUJkWHSiml2sT2jel3yUdFcHHSOZNm33ld1txD5qdsq03Ny5kLMvJd5Uqh85+UJHXeWq scT3IyWio92MQDMlIrP4fpXOOrGI8HwZrzDH45a1C8GHgfBQ8yYjQ0Gc1rXbxsyOKO87U8ID+og/ 0EfMPmriF/sRBMkbhZPzTFE/NNU7h8xwHMNUPeAbodbvKYgOr1BkDaGQdSAOs428daHOD6wsPArF Pp7TQKJAIIlUfNgfAdRxTW7CThYGSUDwgDRAoMDcQMTYP1fe+YeQ5ge9X1LcNwD2d0B6vxHuuSvc HJCIogvZBlBxBFB9lQWvQvQTAkjYLIdn0Q8wNlD3hmnInmod06uYH7NfheHbrDv6Gb/Sy1a/KQlu NOpq2JN/0k5V1WavAAmI1pYmde+LHSdpE+Br02B6qHn6faFpdXYQo3Pu6nbS9NBmjVdV5gC4zsya 9h9UsoEzQRdmGTHrLhKLk0VIzeFW7qtk0Ud1vzOiXNceImNbUCOncgizlcZqh4xsj3eq7A8p1WMx TwiIhgmZbsiaSahJdlOBnWM8Jv0HNJyhoy0OHUQavK3yt8DfgkRQJwdM1x0ekTQQHChV1SxPl0sZ uWF4CIPoEd4NYaXvOX6TQhVPlSp08N5fPuVTW5rjK7Rg3ay4VcZd8YVUUya1YTg2VF3T3a1TZyzO xs0VdEcDriBydqqElArUBJklnC5BrgOLwCdWVednPbjbR4hRSJMQzDIW7YQnAaGJ1As4cIZNGZWP apaNXR2Xk2bGzfGNW0KlXTuuN5KkAbt1OlxfV0hEeuvTxRudSj3W/RIOl4ERMTjATN24qZkUzo24 6LE9i26CqXr471FgcQ7HEvCasAzE9dLu69uBovdnTM4tItCLBFwJpEkW+TI5QBqK7T3WrZlC5vSJ 5XdjhVGcvbAAmep1UUgjOVdVNXNnSxYpBkKzd3OXt6Fkml1WlIjjNknRnqjs8hjEnf7XU/7Jz6mv n1zInwQu4VJWJa3DlZMhivq3dYBONbxqRzOSYm8mrYLAPAWITB4ScSdWKKh4C1i34kit4WPmTPVP nV5SaxATm9hpaPrBa5jcH5jdP1ZUviMjLoKKvJf9HIXX2OBikCrZyVihFCwBYQ1KCJBqqlRu2AI2 CoEAKoFgGgiNhqLCikmE4HAQAHhYvn5x+X9Ov69/OdY1Hwo6JEKrxbabJN3dTV7y73hgPecNTObl 5XGpkqQnSBCcq2wjSQbEioG3/4Obs+iaADopmcoohIJ3+W1ZEyrNXJmbZhEwAwyFcP7ISk71F00S /itbdxIJLov5D5Qu6qhiL5DkEGSAHVN5vpAE8vOlVaCnRvS5EE5MMUza70BJSIlkhjeeyCHdb6R9 LQuGKttkaHkhd3Wh+9WiFUTaWL9MWJ3CQkgLskgFzGzVHdG+PAKCFUZIQg1rML5iylUkJ6VoYGto tsRvD+dD/NtWgNJx2ZVajhE9rAur2kWvo3mcryPJgPDT7G7BmxMdEuZxGBFEgcP6JD+gOgVH4+yF NopzSzhC8Gpr66B+5n6EE0l1wnX0jZw7d5TRBVHyUEXMY8Xfxf1DYfzDntfc/WmP0FD9XHiA64hh 4gaxSFiUC4uv0QUfcQ+qIkKztBCtSDSqOf350LOGBnyOViGm7keYGkVIiDk6blBgxSkiWvQOpH6w x7Op+M/7tlTws6KRY+jUfJFh5zI4fLzlrjK10d6lUaklEwQ+cgrz1yvsYGgUtU6Vyfw4gSLCMJJJ nvMeyPQ35oeMe/D1IKHVIJBiCc5hfLg32PM1/jQ7Vw35u/QgsXK9eOgcnJnpDJImE0g28aCa6Y1V 8Xs7Ex8jjLKMUxEFvhRUXtbPac4e7yNXARxVzUIBmQAoKclEatszkpOxQIQAZIVGSXGQhZZIhrhL 13NfKkqbLizQSmX8Ma2QvsgeXev2KcHKktftkQIOzXYEYIkzMzXopdEFG2R1d+CbBBMSWhxEAPM2 zUD9eImgJkGMQI/QMMMSxv6IWPuVGyAJYBJZGl6xYmZUQ53FUkjRQln7BR922NBJDCcE3USHZdfA 15i8d6/zDPg2y84dvp4kBcA8dX1Ph4KrwiK8xtTMs+VjMSUifByE5CJ7qh3E18LSrwhRK4g0QyQQ NQsRIeXvJz0+Np3g4XGwafFk2lImmurpXcmrIvwiFVdk7RLIrjIhnrTxXDrqYHMPjtbjcrMePwK5 bNpE+QIV44ZFy/WwSPSV1woUUym4RppsqvZ69ULE74Jb4MoEC60VSLqC1nUpqPOk3g9CVY16liZ1 ZRdAJwP7BENL+3v2W6Ms9zj3MPcPZOy0qQn6aqPxKNASTAuQsjAbKBvKkmTcD9snqUuDnS148uJF sOMXXt5xhWlksUxIZDp+0xK8U5ifPT081ksJCHRLQC5FxAMTWNOwBKhSgyRcipYuXE8MCIi88tOv GadYHVSD2Ob2e/SxQ5wKdl9HMBrsLdjsPqyETlPcKj5HQXnZ6RkCl5EezC1S76cOrhtEwn3vorkm F69KCqSWzaQkHhTROnDwQNiyDA5dtyWBnBew7OjBi48kq7GChcaJTfMqg6AYptYiOq8O5Zy43ORm g4q5I5TmaPJQyrhfSdIxk/CJwTkN/U9YGDAT3a6ymJS5mtYZYWlM1Ri8RIOHYaMmMAkc/utcp4Ik li+MJfHu8LowO7LcuzafNXQmk9wzycrCc4O4CvyS8s+o6IblSrmgkV0hxGiTx73SDIP9Tzt3R5N1 5tIJGo64TNyXVLeDtVSKWK3752GSJC2BGiCrRjw5YYVzwUmkUS3koa+BcPJVFGluocO+T7Ol7IcH OHgtIq/dtLAMqbGjTptDq+caqpUHEieD3BRtB1NbhCav6PD1dwolZG9Yb25WZc1whum59lIl/gDr iKs6Z0/0Oc4ThhrveSk/zGK4fmnpmocKmuHSGoGqlJvZzkNk+vyZ16+MXu80lJBgE0DrpIR1Hza5 DVcWZr12uXIX/QHN1J4wub9O1Op5TUWTrhmTyFHTrhJIsEQi7IZf2z6i1XJPqSRMoZjjMpa1ktoy bukWUxsKR6wR7lVQ8E9wNZ4iOX2LDy0aKIu+sUmcq5aV1VD65Z/lbUsHdM9keEVkJE6MdFThOMlC DKFp9DMUy5uRw+Aw7wSzDBCQsRoQ1I16S3PRZmvcKq2cxuP/uA4t8v6/SGhp8J69xzIgmioumYlO ftKc3+eupGxFshKBJwYaVkhRFUahyn5LXmflZqWbx48L5ey8/Gw+QzF/PrPa80bz6I1R179BDUts p3ys1v24RhZ5FTLDjM0U11ytO3OdjFw9e3rXZ2pUSGO1/Y9pI9DUJmtjKqLEPQNSO5H8l7/Eyxvg /3D17bOsqVhtUZ3tEv1k0o+/xMxa3hfWLQbni82n6pBq+lthKeFmwRtuc7F2xeB8fItmb1O9JDlq 04sTNF1KeL2T8Hw3wyv7OUzahY6c9dclmlZSUHnsgRa3Vto3X+iSR9QF8s08+l7soWlL9nyyawp8 HnjfzEYh9HcyE7MOKVkQ8j1UnBxITqs+ZXyfoVKFy4zxq+CvlP1KMgSb/UeYi2ElX539Tk+jv66n RBeDqKDPXozIkSXI4UnqBLZA4bwSmNKoxaOqs8qcCTh8HvMK9t5B0uLG8PpQxccYdzelPJM48pW1 7Kzb+BHVS0sK+ObNks7SR5NyYoFJ0pi01Z0QcU3J9tIjbs6N5KzIFbEcBy41sx3N5t58r8TnnC03 ynSViGKx1BpqWTfK3c8HhNL1QakrDFVXyPBiVtVLCsXt2XSCMAkPFDf5YbEUc/Bl1Lc6MKMEpk2I y2xQZWMfCSU3kcHg5kiYT0dvJXxszaRtXHXxYlihIlAlfNr2bYsHVSXhyDkKGf0x6yvQGazPUIW4 EBdlIDD33xec/LJpdRK1HmOjaVTFj0mtsPdF63XeegrSUsuPGe7E6cBthHYp0Xgrrxi/hTIVKakq GW17ByQujcvLyEc9GAxHUkRT1ufSI4rF278HmocHbn0aHSLkUXMUDL7aeJzMwS5EnkHlc3WkQkaL 3/JxAL0j3cs3KPHHs+jyAxAc5z3M2SEpScx4mSaGQ6/NgXKRu5ARAbWxTUoQjn1PESbRHxSQ06Oc DrRvINc8B0byP0bcdovm99/cALWW+WdYgbUID2v2LeJV3/dBAZfHvmkj/aiKSEgrEA185kPTv8Fs aaHn668avYerU8ZlPHOslOVO/cVkQyVmU3C9fjYfBubb7zUI3GvPyI6Qu6DTqGBcOIu71eYn4udR na0Y+N4r4z1rBn5nLYluFYR+F9XAkh22hbDhc+87Rx/BX3lJ0douhNk6yBu9E8jQ2nV5Qka3eFMW TubuHuL3LgJJDzwgK/6F2/4uP8vnFzh6nrHs6E3dO8h587Xj39Zrf49pa1Z0NVeliK2OnVikxiG7 1LVUPfWfwqHMOK1+W6nVDNOwY0Z5RPiOwZ7IlvgL28B3KVHhEp0aoYK6Yc1K3OXKqB4U1NXCluiF 7DulSS2bXViIAni7EDAj43kSri/RwwOTwZBD00/pEhMNOU3GSwhDkcIEcl11StWDh1mVru3SobVC aUqT5CpH5mEiFI/NhmBMzAzcqtTJBBauDcqNLT57OKFTZLp9tuop3KVYwSYzdib55BxQKkupEGpK YxUwMnBgUT15pI60X63vOSrPOTDbW03KopvdsXMgyLQrwzPWq8pOiIVLOs/k4KBIsRUDEyBdYM6U Q1KnKarKNB5fbC0DxrjjHWeutUfMpsnAyV2+jTlDatBiGpsdMVZ/7R/VCuQvh3jxaPXceP8brc4F pQVp0hIfRl26SiRcDT2eCh2CfCwD4gDRsLE0I4HG+RQ+hwgcNbxaMngxYfg2+j22xLUSuKjWKUR/ JNSwYFsYSMZULj+aXXdQo11ta8nLhR6mDpCX9Rvv0aJ8q9rlqw48tblFQ50rnOjqASnnbxg04pbR Hl0+Oa6Z2sa4yVnwVMj6Fby/hB/MQsZXHV4W00ugcOJGnYkV6OFuv2BiubThCfL+ZLEn5pLY689b GqUR5IiiFBdhpAajZ0H40xAvsj+cA4xtgIUu5z+cxoMWaRqKpo4s7bIpwWPPXE++1vfDBMyXka9Z NwvXSyEHhMneBHOOixXeDqOjRwepumBceSyYmTeUdBpLqssUxpf4iuhI/0KZjV7P8Mn3A2n5J1G5 VV9kzAMvp9r4GAb0UELdHCEEIfNxlR2/L+wZziKlIi7NmKiGhSzOhbHPT7cnOrrU+C2MJUqGLau1 CHKEKcMysdVqyJzCvmOCV8MdLmw6GbkSW4wU6n+Ijfjs1V8qXV9eBT8GV8A2Ecx+FhBoxs9UqHvH BqMMBlEuLCXVjCoeBsZCCLSad7Haj4OyNuJB7qaWBIEM346OXJ210XnM1Id2HHEbB1nuK6K5VCya o6xG10hu8WwV157SdrmEPKO2RS28YiZILqPC0mq2ufkRPp6kVh2TO4g7tjg0dT4M+ECO2lbQXwhW 2sPI4YvZsRV80QA01MkZ2pEmxzQ59W4l8KLtNoyRfJXMDV0/sOujnLGHZso5NxxjoMnCEIThC3C9 YVjgiQjnqWH2L3jgoT+CKDwAuqvkiNlPzUYHxH5ByH5vIdFcw3DYfaGLdT4hqD4DL2A8D+QDYchP T1B6J8c0DqeJV6A0DlPWDzJmU7k5wzo6g3gOQTpB7kwXiA9TcF4B3DjXrCKcanQGUOkImcISGCG8 OtXcEA4gNih1BuL03DiDkbh8wfkkTyT8+yL2DsofENgV5VsBZPOy/D5BkqfF9iVbjqp4B9w9uXA+ IdGBoUz3LtHSGDpAO9dQruHnDeH+r4cnLnlYuDTa+7gKO/D+M9t40FJblf2QiH98aGbiAuTZP9xP 8f0y/OJvCfP+LqFE8BgREkRJFCEWKARkIiDGMWEUhESQSILFFBSCAKHrVUCu8UBgqpbwEUAP0UUA LCKAFRFACwoDZAVAPYZthdmtpJaNV87ee+5a4LjXP8JnyZMLjNCeM/+TX7+6dDP0OMy2484erye/ p+7n6/Wjs5D8z8f8STUWRpFH6lf3x9m2lZCwf621UD7oY/K/8ArTH+Z9uzR9ZrzT4Z8T4lUTlatT hP8R+A3gK34nrxX3zJtu4vX5YvZj1cBDWW7JrMVa6KmesI29n0ZbXDzwDWe2a+VP6ZnEPECYFMIa ymdH5xcY8cbaWXfWmJjryk2fS8oGPD+D8GtamOPT1lJ4mrStZ5cw2n2cVfzvp99D2fVPys8zedp+ R8t46vPVPTm9ZmSG2SsD4P4/X6vTvfaHSqn3pPivoN0m0uen4dHwSfPqv4O8+D6MxxPjlrMYL8U+ HV/OzvyRfH/43WtX/vw6aAy/k1Tw4YZYbhl3z6naA6cvUDk+uQjhDmmDSi22CvU5gW0P61+BdER9 1r/xj6uKkdnmPz+IcPc0WCziWn9vsYH80qPuqkwP5985Dh37WHO7tigV014ah2mkwZOvraLx08fY c5xYdT5u8seSOr8qz/4kWgO2TfWYftxHSfFPhqcvpb3uffkvXOeiLNPiVk7dff5kPqTjXMqnaM4p Namlivv+PixxeSgZxe8Q6d6AcQaGPr+tkpE6kJpQzwoNSSuNaxHMwTwnOOUl5aKjTv5tH2VHcc6z KpR1fZxFjR/NwU9PeTo7kXdHToy5TeOYq7EF5A+EQ6Povs8sKiPHAqFQYcd31nqBj+Tlpgg2/aTz WXI+nxt6dty0/b31zWHy/73y/UBXqibM59uvGyfVZlGXzZNX/ZubWZ3lw+aCwnDYsWKLwsn1ls9j ZCxHDo7eg7y6ri+yuU3tdvc06Sww4VD/7j7HkkWJrbInRwHpv4pHv+n0khdVcOHYgQRuEOnNANTj p9HJzHzkMVcTimPu99sljCBdz9NkcCN5NMXCJIBzk54aIm7iKcsqj47Hh/0n8jvcFI+p+H/T5usH x/f6Pg7uDeonDPwz8204+uBqVqSU83+srwWL/5e7h4xoYcJzvxP+7yRLwMPiwWHYq0c0IakxP8br 7ZbBgZI8R8ffkZK/orBmOojg3zkICGVHf39nxm4gR+k2Zy+bCr045FwfxN/bt7ZLeMSh7fO1f6J1 MrUx6Xkm1QakTOtab+sreCGaU3LXi8FAqTQ/9OtfAUYKRd+2CpRkQPr9R5oo4lV9yCcz/NYPgfSE FR0IuZl+waK1l6iN8as9ubC5z80lH+HFiXFja/5GzCxlMZqxV+fxwk1H1p/4ISBCIhxx5P4kVBaF CqRVShQP9p/0qLBGH/BJzmXRommTSaZDUk/CkYhNiRmAKJZK3ZhClCkKgjJWUYLFhFFY4SBUCBaW SZvRhFFCRSG2VkRoyI0UTYVgiKEFkgsKAWBSlD/wJSqLlkCFwRYRVgSIyDFSQULRBCooEgJhFUtJ ELLEQsoSQFLRB/+zYbER0IBURkFSIFUgjKoUgwRiFBFkFZCUIBSDRFQoBkEFgRkArApBGEZAQghL RoUYkGSiCixZERKEEsUiySIxGSkiElAEJEEVEEGSlogqRIixRBJFBgokEAGAsRYxgkVUSIgDFSIi wYgMEFUURgqrIhBWChBBhGMFIgwWRQRgCDAVBkUjAjEYpBYxiiMiiMBjAWAsRgKREFkiMjEUYiMU GAfKEkkLUiDIghFAQSLFAVgwUBREkipIIpEGQhCWFRQpYgrEIKlUSApSgUqNCWUBiCLIkFiMVBJI WESFjIqLFlhELQJIgwjBKG0FWRQkCRaVSoAthiFkKSBFgxiwCLFgRjEoEdhBoJZAREREIiIqEBYR YsIqqqMFIqorAUgsWKsWKKKqrFVVUUEYqKqqxSLIqwVViqCqoqxYoLIoKjFGIKqokURFBVFVVVVW RRVBVIqqKAsUFgCkWCqpESLBZFIsiirFUARBYAqrIoCqqgpFIqqKKCkFUgqrIoooosgoLFFVYKsk VVVVVGEBiqqoqsiqCLERWAiCioqIRVgiigsFFFSJEVIKgqyCxYiKkFYiKxFkYqiqogqkikiiKIjF UFSKogpEVBVYqqxUVFUWQVFRVFVVWAoKiiEUigqyCMiIoiRWKCCgsUBGSLBFVUgizJIRNTUCEyDA gkyMiMgxggxjIhAGMYxGAyILBWKEQIQjEgrGQIkEiQSACRWMVWMREkAFk0wKSJCMYAIMYxjGIIMg IhIkEGQQAS2SsIIMjIxiAkGEECSIRIECIikRJIAf9rw5gyeIaw0GdEA1xBoPvP3/cf4n/Q4zR6yk EGRH+FRJ8IyKQYwQEWDEIxWAsAYoJIIQhIAqyALSoJCoJIoCQIII5gC+Cy31IIiS2/E/Ofm/PPxA qH5lAiMVOo5RVsAifnQU+sU+oALhTzvVUwAbgAsqWB7y9RoRAiBBD87cLSIGBZLkRuAuATAGgApA wEpApQLCRVcFggkWKN6IxRgsTBHGUBQkUEMAYgNwhSrQBSrbrQUBXeHduok/PnsXfneXpRC796gx 2OWrH5H815TCyfNIFAE963gf+8DIWP/IfxCl5D8A/jsGB+lTBKIk0BQCNll4EUSP+6Igknn/bIXS JkgMJEnBoHhw2SpITloqVTCW3oZ0Xg//DddQXDCuM+vafEFFPcLEQIgAMEEgikSlpQaYIkCKCEYI AkFRqCqpAIMQkiDABEhGIQOBlggsaGJKEMTgOgBYsM9sNhj6yf8RmEWJiC1wkKEOhbmkIfr3kOSk uUfe3j9rBjBjCOe5DjN4hY1UcfHUa3aEUHZmX4sQqBynWHWSpkhxCxscKUKYHMf7NOoP+O+XptQz hr9BDVMl1EzMAMCAVSvdvO8ea73DWsusrl4APin0gELJAqEYERAcednLZp8jNjjhIJLiDhAw0/tV 3j/1/deHCw4MMCOiC0OrsJ5BW4r3eCO9gcS4lFMlxK5N+JPuj4K9dSVrW1FMQzKZMC3CH9YiJ4In tzOgP4B99g51gVL93XLmx92QgFCe2gY5TQtfxhgUr8DaS0pSkJHzVAsKcPmXSwEIlEAyVz0UP+ZC 5O+1LgDcYn7At/JEtq9xDkHESNVKPU6eRIdC7RhmguETofJCK4oK9bC6ezVLmWa5bBUQqHgTPLAo eh7oT209c01fyHhDUopm3bBE2sBQlkHXyxgkfrYf9DZ0naKvT6cCXbVPlk8IcCmzKgJghqU7FNbh iD0T1WxE1YccqmnKjjCwRCAQgN22/k4y2sxDxzIiIIsphQiqQKThhYERtFQUj/ymi6QlA3L7GhaA QTxYqjQJFFEdhfj6UDnCHQnWUJRA6kMmpOCV/b/YcyLYRSEAkUP6/+L/899lX/+IViYAZu6VTV3U q8AUjZF4nvCrZh7QbHX0lgyjLWUKDgS8gUfAyglx4GI4ibmQrbf7d49Lb0ZLkF9a+Jv28KIOxOHo E30oMh6FEMQUZlPEHMBuFiBCZhx3RDsd3ZFPoRPOIf5p1PuYnQQrsPSPfXsVa235AhWASFg0OxgD kwZ1V6RDA0iUCaJomia9FVeJnJuElD7Dw6k6ZAwifXeEklTsArkXOh0TyT9AGBAfIQsB1DETzJR6 KQz5IlB5gaHZaJaMYIQIGxdsaBlGEDDojyNE+4JTUcRgG4sZiBgJ+bMKbxESOMEDAgDRAMA2IWBU qF1IkYQCEIHwo5Dc4OBSYGYvVP1yggSCSa1zQxITkE1oQgLsEm+Ghzhk3GIGjaIpyHIBxoGUo4hc sBe7CzshY/iTU1LF1AqguidCB8PB5pm5sLtI0n+cRxU5wTBuEFc6GInBxc0hiHA9JCEIyhme1qn8 g2EDVXImX4acGPTvkPHnzB7RDA4ylAIFT4KINlBMrAT6IMgQiUJzhAc9iBQhlExK4BEFdErsKg1w SrVyAKkUkFUhYW4q6wlC5A8FPOZE67GG55LqNSNhThIdG1E3T06iWWESwEEINzMUwDSMepiaSCNo Ak6SkcgxObj5nUSY7go1VtBpzuJQ8hsVU6hnn9eie/SB5sKYHSHcO5i1/09kOxVP3wkwenYInRLb kHdTqIwdBdD1h6jgoOhyJTACI1MC5ZxLheEyAf94/5zYsUJFIv6KQfJmLZ6mmjdxoRFB1D3oeZD4 AeeQ9AuMgMGylXVPMvotn0L+qODcKHVgyBwR0yKHzjiJz6qILY6AyLSnPvZMKlYt8spoI4gPQgdT 1PLrZUNZOIopEMjmLwxh11LgAw2k32CTKziEcR32f/VcEzH+//cbY1AnJKu9fturqP5bC/mvoP4Z lYBkCQgft7swH+hEDpheans/+P+h/Cnk4dP88u9938Q24DMB+j6aCxP2ft/hzTV5/o/h9djGUfaV v48JWTJ+rDH6XShu6ap61/o81Wv6mf5htzFSIp38bZ7/zXz3V1pkEaqeLaalbbjpN+L7UC0jb72B Ue5B8PUie5lu45Y31da4y8fUN1vNzzlm9pXV854aPS6w7Gj5rPG4hr5yFuOLre0bvp3V7FTO0jj6 8/ki118ieYIdQm33rSv5r5/N3zI967Zt/iNEjxvncmwYzh0q6UP2ptIvfzSNyooT37F9No5x2bzn 2e54Ht08TXr/wcp9H8IZOL+hz496r5RkOVrnKxH5/r4vstcFXXVda1wdEx583n+rC8zaLWq/H5fa Pt7CkL/3btKfMxK7kA+h7W/BT9B3XgFgypkQ+wIhBCD+JxofYerk+8wyzKZmgmQV/mKiVQ3NCVwQ VoVbYLcExwcW2chcpmzVjMQZwpsfwlBYIn2uRE/doDEIkXNf9RBDz9kRxu3KFBJf9hQ/zMCK22IL C/3/jQlyGpwaCEHwH8uJ5sua4JBPJSyD5ZkbABmIqwwImAbxZ/2cpuSL9AB8HqOQ7w+5xAf8H3Pb ZfM/sX+osf7jKzEWAfIXSn92tyhtgT23jXK1rhcrAYHsAfj5UfJWCFVLAhfJB5wgU0FQN4DF9omR f6w2XEDoUD5e8fnSoLIxUh/WkpdBoNMNithExo0bxEyxD+1ypWEpaYyqojjFKn/UY40pEIJSlNhD U8hM1yeA7EiZ8m56yHJSIdTzJ71lICSb0PPxm9XELlpDqHUpmnRhfoLQdumLou5CIVTLmGQKlobo btxgdyREgQJO5roORsZjRDEAPD6FJxNBoUbcpbbeIep7HMPShyBMOgHBAYEQFsbiu8wRMjhw82i2 BhIkVYCMdB0RJSZJMDAPBVFFVWKiiQwtVVWERKP1c5og5EZyB8sOIsEb7USvvMAZAfhCbggIFAIg nYsBqSQkonCF4cpgHdLkYGwyMCRwukZLm4D2NTvJOW9GiRU+OUl+WhUzIdXVdGjDYBCUBIAUXeBu VFeSp3SzQE/xpAkAdDqFATGgZhJVFxAjzraTmyBSAclAyGAVgdwwk/tsmgv2LkqChUuDcrJ6Bo05 BqBjVOSCoGaByxhCQkFOWEWAfYBoAgfA4nuS7IKsnUujKeXXSu5MNtKU7SG0I28RMuw1vb8oG5Ne dJhUhdNwKF0sHcqt0CBAgEEQYkBgqQRgMQWEFYjGCrEUgCJAVgKsYIRGKsYpEWKjFSALBEgDBSKB AYqQSACQUHKiqkBKAIQBIwIxAYISRIAxERGMQJEYxAEYRiEh58i2HrBgJ68hhJe05o2vv3QzKdbT y1QqBAwQDPURM+BTIkIUIdIQuschwkJ6HUeUInkmg0OpbUlGoPIjeBXJeYEmHoTs8FCCKAFEDJG5 1MSEq46mJwQhYukXKToXSrUYFKLkFeqFkAo9nkEyRMRDuI3CyakKOQQK5FlUsxS0GpqtuCRWoWUI RNjmZmRgEJHpGMCk2LFk3xUTCB2QnXVJIIfJhPgbLBYxiIqWhUEREs8D1Na+JfcafDt08XezfHwP gYBitTzBztEIwIJCWChTkKlE6BoVDlmVPaYSHzAYx+CiKtJoOIIiDIwJGJIQiQNg1EOwAaKvK3KI cvbProSEhIwJiY47Bs2Dk6quBst0KERg0Tg6gMUM3qBkGQVcszmbFlLZDHhgdcmy+mTknJzEkFkT E1NzQdDY6Fe+QoWDNIdiBIAdSDHHiaO25wBsL6DqPQDXqODYsJYs7DQLb1l10gZqqwnXEL0eSzg7 AyGGjDCmYCIIAAvQW9J0lKShdLL2cCD4FE6Vc0C7bKxBpAqKtxA1gNYSAEjI+AaIWVe5YuGR5kJy jyIZQm9A3gfrB+5fQKP8vGoczzZd37huoJCwhoj9LTua8AM0Z9CyEO873pRRFOB5ZzGusDi/WfYk 2ZktEkEQilVhDm4T05rLDiOnWoMrRor9IQ9rFMcaLYibQwmJdQzhEggQQqnTujTpJjRjSjqTNKGk XoBCmQdMEyeqGAV7sYQQFYLJIF5vsrmX8EOqaNevuYI6jD0DuFjUMnsaFDEjOqPZ7q1UNQsgl7Ra zt1lg3GBkIQo33EFG2CZgs5VIz9VuBUQByCKKaHInmjQQgJYgKwCzSmJKXDs1gXXN6kksBqHmQKM fbPQ1TD0w+Dp3IpfrTBEbwWY8SwzVOA4Nprja/XIwGeock3oQGCkgoIFUoQkViVCdAj+aJaBfRyt iFNlSMlgYaSxNQQCjRgfFkCsBCBEjTFf18Sg8JzfZ+SubWabrE+sn9+PEVMV27F2djj3Hbwm+SDv kEojIb8OY6mIcAA77xpnr7x+n/qt/1gTbuUk7uhdRZinVKyWnZJv74gCPEVM/6SUP+v1X5R94e3w 9pE3hfIRfoLSy6h2hiROX0/+vZEbRx1S3zCuIqCLropKPNMr1+hAffZnQTal7GeHBra8KmemLJdx IiKgGmbgF+16VLRdoFjFqNnnnSadqgGxnQhX4gOQsT3/jIrFcpq/VVUxevT4mlwjccQ/vmEjslWF co0OYi1hqDzZOyMbOqo5LRXVMxnzZhY3vs0VIABQF/QDReeK/0VMoqafh7yBy2QMcMOgRdLFVDI+ EX9NAY1Gzr7bWttXFDr9jNp1D8FJt4qbpu6g3ls6veTnFY5lcdFJ6zCjZca8Hg2D8aPsISACZXOc uc8XNDqceQ6YU+u+9WSc9jkeTMShdbWzZpp7CzpN1ngYnIYcdypPkznXaSSSE6Xael23+0w99cx8 XnriwSD7X1kA4pvm1HESWCxrBg1SDa07gn1MSIqXVIjVdfGj+awJQ4NrGY0Nucvx331aveujukwn 1w4UKhwdyp3w6Udj6A85MyHMxscmE5q+TZPFeZpaLsnBBVG77Fjk1mpIYcEtxNxKpifk6N0kZeEq 5BtNnodSMKG2BzcCt3rWyFsCyQQ01OF3RWAzQmTCBRrSDaEPhgUfywMDiAFDKKgq7wTg8WFDsMQw 45p5HQPK7U4QfA+QXD9gfwLYoptOG2zuA943bFjZIjN3hPg8fpDONvp3eZyJJujw93U4VpCayVrc 1mRUmY8+dLFI7mcUSeS7aoYrZGvMIa0gYe+i0OfI4858FoDkgu+xYW6YDaxsc5uhEfKGrIyZiUGN WgGqo2acp5J5HZmR/mKw685YXCpowr26LVzbpNQwdnChBzoUqxmRc612bZpB1d4WlIfUKmOClXNU 5iqOIPYD5CZDzwpNMedJm8Xq8eH0Ch3UPDy1jLrBAkdWK0uYKk+mMXwjunRDDrukoaCSdij0OeRG QRqWdV541kYayLT2NNEktrdsz0zy6hp628yhJkP1+ljjjmr6MzFh46GT4LQbELc9GeB666aB1bce p1xD2EFpE6ddv7TUOxau4cx3ort1bY+4s07aM9Gu7q0Y1zUPqKAfzAap3IwoP7OPTDyLSd5ZIzsp xmm/coRom9Vhy6owxJWPGX2G7Pr550sCj0gpRIYLHNG1aJnT0chYc6ByI2A/V5IsfqxiYE6BsuQx kLkrCP1vOPIvhZZqEULRMhgIBIGMNIByTWgJkeCiYb4gqnGvJTKkWeKe3kGuHXWjHENTohcfgN3Y xHEshDQegkkYJQOE7RHp3ZKGsYRUsd7KKcy5wtgLmYVDOLYJlpRI75E1BygVFI3IZa2NGJcwqBaW QdqOK6lQ64ZDmowkbdy+SKG4u8R6GdaeDTFixMI6jA/sqdI3I4iesk3q0tnaYcQ7lDRjrd49kOtR tLPdaPsWXW1I5fUi8iMycYmNGSezHVvytTj+nnzVCA9/BuCqJHgnwrLW6KRW/Pl95Hio0tbNCpPB RX3ExbLr6TrjjFmfUCl7XvsSK2o2SeLQ4OoQ5rgbMhibr3ph0DpjC3xDKLnVITUyafUrovQuYiQJ UWKP3NnVudNQy3XWcpheRCuiZk4TOUeWbfuCp4bQU4dV7Ih1Apgr1Qot8RSIbDF87ssFouHYKWhO GVlZzzJQKLEnoe+EwpL3Awg+SAulEP4bWQ219TowF+LTVrndDBEyPsfXfKcBnE/dyQvXIUdKTSkP I6rity7jsvTWhiCpR4q62q6fLFzb8KxrInktUmxbSf7ZmGauGWFdY1MhAdc3WWKGrolN26jBArJN dRZh13SVpYUkSC9tkRqjphbkk4KacxwqipQ3VQpAyNjL8bWQsSiF7x+iP0zMOOMWns0/XNF6ShCB nWnWB2LysnuDqvC/SnC0E3bZUinM7nkrGyaed8kzVtuWKaLDkY0UQ1r3BXFvhRXIocsaIwqkOibS tWL4CsMNuFqELcRZsFyl7YenMj4u+BaSroK6NORLAQpvbRxdeDu1gz8oSQf0b3sj12pUr83QQYg1 y2Jl+dRjm1pHXDI7oxXBY4WCyjcwQRNC4C8n5GUPEzvvsz0i95o7PHil8bMunwWWQ8jrR4fAr4qD 8FkbCDx+7KfLyQw0yKJGjTjEnx8boqbyFUT22lHF+VfllqDtdBu9MaVGV7DKwrrZVHJxdmWVPeB0 8X6IoUqHVFo6kSbTOusE7eidJv4ZaE9EQJAuQg9JDnepDUex0YUIMvfXTYOgHgcRmEHFdTI5UCGB ipelSRF6hSkqnKbK5YlsybdWXIElRr5uryB8OsnAjYxe94Ze1lIhypge+7ycSuSuotaQeyAvdMHF 0aM0vIjLY8lQc7lBiTkQQ52SewtyyO0/qpPknkrvTjUKbCCzUt1M7magS60P6tiidu8w3AhyWjcs mFbrovnT5/2SEN3o0dkB2H5Q9tYGqfYXlQdkgtUPGNlbeD5jH+KPjCSsPEdzwzh5d3B8P+Z5I/L5 j1U95/R585fLRX6QgXNaY3Ed+wkjeNLWi30NsSBqKLNgfiE0Qzz6ulGLPtXvm0bLmyWihIvUrCKc 7ZDZOyGeaiULk5DF5T2bkVEIjK9i9XI3ioMsVU52Rnvvct65wyWI2lJKMqRwVMlFwhoMFas+mk1p 5x1/ZJEmPqzmEzeWc8kU0xiRvJyn/2Z63VrlSB6fb1lea8mL/tZJeBvmf2R30M4DsghwxEKgkiB7 CB8IrwAefAAGJVyvUpppsNy5vBIAaSiEIEkiEIwjCPMXG29PL0IRkJhihzbuN5Nek40+io2z7cfx xaSiVPxR7iP4d7p5Sf3B4230Rvb6LDje7xPvJPiZf0NcOHRdFCxR+N6GhwqM8zSdpb2ygJoD1rEe sU0TJaMphxgm/Q6+c14IU3ZTpkgDthMg6OYMmsTIuqe4fCgZOLIMYDq6L9EyPDD1qME6Q2gMr/zU toeRt58GyRTaO4RROggAKDr2bA0XCJlgiC8Bv9/BUM+fT0VMkUFIiJ3VRqegca6asCxhuAiuMIyL Hfo/X/pR1C8e+Eyar9OzTsMMZD4K+j52PoP9/b1ZttHCwS37FazJHIOoS1jYr0vt8QYebNXzbLQ4 oFmdkpqNzeiLubNEJUJbJEcD+FiCANOBJdFNbCRrQLweH5kbpaiuA4rhVxdErqWFCIZHSvFSLk0+ f+f2XSpM4nGg3GpyWTtVW95SpEaWzGxNm39kkZqdeHn+Iv8ROwdefHqFqnkPS9dEPCXfGM6vGj5V WBxNVr5HznR9qqGcbmPpApXQ9Jl6CJmZJZfFAJIAxXcEasrxotPUo+TmSRchYzZodeqLscnQliG8 ETOaawQpBx3uaH2x/9ogl40dsTrdYYhOEAc6sDbGduHFbvjYG3Z9JjOhX2SCZWvA8f7ANg/i7Xmh Ugov4ndx7R00VEIhvt+nEed7JmJ7rjoomNEKt3i6HxCiLGw0T2B9BZ/SX9kj6GBfsDyI/YgWAUYn 57KYY5BMoJBJQYwQlgySoGFhkBhUEhIAFMIGAQUsexFpuMQwDYvtDIONDxHpDW+I+CpgvrckWKSM IetGP4EEtFCoB9djQIBASCwNJ7Ir+98l9mlD0TeHcHWGXMZ1CqH6+NcY4ibUDZFoO0PW2ewchbLb mvqt9sCTUYARU7QpbJSEEZBQjInIlFoIYi6GNK4F3cofAMSZxRNIaQDOtlzr1e9PbQPx+VLgJlyI Gl6DpYYG/pZQPXAGJhM2AsWMiMGIbpLFEQIxCBEqRuoLYESrI4dxzVIn8fTixG0m2BoqqqZbcm8H HmJoP1rvkLri5OhQsaAm+e5XaiLa8OcLxXHGoopCQYqCLAhBViuIOADkQxaSa4HhAsMAhKloVh4o YBE7ovZHGDrK8GSUIpIjCPnBCjWEL8Q4rCIFKK2fDKHX7TOZV/+t/SRV02ojriS6pQRdzIH+Tt1j QiSlAISvQ1A+lheEPJd4OAVOgIou8UDRUFQrAqjAED7vaFgeHuAG6YKv5AcL2eIOcRI8g76p73nR i7g1eHGHbtmsRhCSSWS9vqfx7DDN6dZE/EzHBuxScD+BDcZmwlCZSUBAGbDDDGKSS+EIEDXbUQ4A OE2ixHJFxgIKvicz/Xc3mlUHwbOlDseUkB0BvN5lsHtHQgBRlTFBC0FCRnGnIt6cAfFMugIGzvoc C0oIRZTJS0XIJ8AYtIR3iPrpAv4bNekuCxQSnDwgQc5GqUDtnGt/0gealyNy78O1IA5noq6NOUzF 4cY2qBUFqD+KqLSB7hWAAD1KLDEUHIY7SOSXFesKM+vr0cfPVnHJhroRB4oQhhJkmyMsKQCjg0o0 KmNasHIxKw10dA4RXUFAqOe3VzIgVb1AIEMzHwRCAcP8f8Y6CBsdQB0hiDUOhE4BCjBzIn0IcHcg GdNR5fEXINwcSgNJyxeJzkPxh2Cl13cPCluJDiQO0947gsqDYDMGJAs4wnoimWpuEM6cwtHeMAI7 6pTk3GO1lDutWkQ4wG1lQ80yhlDFQe0M6j0BtEPanErlWABz58IHKi7xQnwQAMfzMRn04idXnd3d Zw12UXmM+fv/WBA/5qUsYnKk96Gvrbypgu8zcrn9nnsABO3CkLBITefl+n2/m/k+sKqzbdWorw1Y 4ymSSrdKbq7w1+FBCCWQzigICKpjLDIzjD+znNWMoOhWrpNmI6L0guhC+zdR9lHPXiShJZ8HtT1F 7QhyHsU9/hxZNehqy0+JOlGrTNTXVSxoIOF3nS2XQvnclVYsA2Ugb88mKy8xiVaiXqe72UeQKQIo GqjwL0rRNkgzxTi6AwtkYCp23YuUpkcp7/2uwcrHQ+8RuHMaVeb1UkS5PQNv/hbonE0itYZDCiUL qQT3vqqdYrOW3Ot0SM5xeyG65n1+xBLwKKMlLdZDW0Q734xFiviBN0JdyJEAgBgrPj8n61kklzvS MtImvyAfJ1rVrN68bRrfE5c1J7PWu8pz052leBy5MdXekV8BL0MLKJIHl7rErJMSWZFDVrEWGMRz UsPFORiF2mdGHFa/gQ3SwxCXWFuucD6ts5Sf1Ed9BtWqfcySWB4hDOxPScJZy3RjYYkhoBm0oes0 6yLA+/jihopFCQ5I3DzOATwSGmLivgMsHdq5RFaMxrtVoPjgrC7+Fwgu5GR6npapu9F+Ug/hFCB8 CEISVea3VeE/xrcKQm62nt4zAkE5l5mKXVnnmIPLhR/SLZMSHGAh3IxTfjdpRuPupPLTMhvGUZXC +ZUw622agXsQKJjW7kJWdkoX3i3nexlCTu0kAoV0zt6Hweh5BmzPanZ6oXwOB3cmc2dOIwfJnrqv CQcGrDeBvgDDvPJqRs6n3qlKVuZo5lGOYZKLtbXsl+1FCPkHQqFrakiAzVOgmdvWdnrpeqwLXDsf ixKZRsA0nnrMchvWWQCSAKuj5tpGRygP1tm2NkdC8iwYnYZElKEluklZVPIi84yupdGVLMt49d85 THHpxYp3GQ6fZ0h65Po6XWokCHMYDDLoy62TVr8z1CkcUgD8KBqO2OBKezdSA6lYS1IyZOizuIfU rk0yH2JPTD4D6XNa3QpSJvsLARHoqW990ODKFhGbjTx18xLMMnT+potXf36JFtwMBH0bBkvMhhpm 0jt8veMonP68RXej62jIxeqnAzrOoCuXH9HZSFVrDyHdmKzLKUnpzu1InPRDRAu75dEy4SdLrNok Vfo3vc0R66OarsHE2f2bCUBSUBqgYEyCheU4ES95UKxKk2TilmDEHY1Is+nb7A96fc4+dS6PYcKZ jmisOZHZ1h5AMHfed3njOqka470jAPR7ov2nqaiY+5EPYQMRNS4DjrbShEgiTR9yT76bPd+n+w4X OBUVpMO7XAFz+qH6Qj7oZAG6DjTaGiF7HkPyQV2qdkUGFWMBsLcpGyEbIdSoPLmSen2HBWgYJT82 49bixzdArCI8hBEyxFaraHoxLJLPnz1hYEBBrw/lhEwo9gfHTehGlTbUKB7j4QyqPr5SHh33qR8w QblEkaTwqDOyaDXeBbz32ZZVusaffSGRnoiePAXY6hIuUVYjy2sSJcts49dRorcuUVLEGbWIBQkU LXJkrPC5TTDxvNcCqdCBdiBaNXznkR4NbkSAEGq3Hns+ldx1EYqGZ9ZUui/uBCD8vKjdOVoqjdxR qNDnYd4lvsTN7hbBfeqYtLTsVlDLo7abgsR/5BwOX9An/NJ5i7iHUOtwaJiJ5PVOuSh15RaPc5nS Lj5FfGDAVCDkA7DDXziy1I2Uc77OfTcSixI2ILrXXWn251lWVH4e6ZPOfd3euCkP4YteznBNVtbu qzZbZIvzkFa48JDFY56eUZw0yuS9jUTqcbYMLdYG9nHNsMOQ6hnmLzsWJOjbocagdZvHWE/L6K0d HNGj9LoJFk0uXqFVaMZjoEqQoxMcM0Onjh7EIVWCeJqBuakd8JPFq1kUNSMcCqB84KYP6AYUmFkP oTKO7elz0WRIG3BIXE0yCl0gpnqPS0q2mCbykH+L/IA5voHL9Rt+DaLuYnvJQvzvqNc4qjucHyNq Q6xrfZhG9ceiRdOqt4voKVLNzQfQKJYhm2I1lFSHjZjwjsk0lkho0PLpyjM2bBye5+C0KBmGtD/X bjW4lmcUtF5SciV+mVLuW+c0o0Md78A3WxGCPQIOt00IkclqPtaseDrxBja6tPFFAGDdmB074NP0 sAReWxY6j44vReDalGSoFKHFSXQipUJrQ303draGJORt5B0A+8Pr9PiKAA9/h4+bKUji2epeIDGI e3tGTefg+D3x7ypP1LTaiEVP4+ClJkRqrQz2RL4LsXHbJwx0GVhx1bEXzLPsRalFEzYtsUp45auD d3zsYRJsDRVJRVh+wuxbQZy4uOmONVYpHiHQRUL1qsy6kcIbuYHzNGkMZqJtEe9IpGEYRDVCUgnq sG8FNepv/l/5HSsqKxk9tdpvHfYPDwU/sFXfHnNvf4+FdRg6Yxt24i/XsM2sNgZTZ3h58PJAnGxh U8GwpYjB5/3Mkg/wQo60e554Hv8zteevPn5UgHp4OrkznLOb3crBclB94QNFidVWJm+Lxx8RsfJy 3wiQpFzGLO+HrjVHrkMCDAUatxsc8/f4+uSfjYXMRDYeR1nmR4jkolicQXz0xTaA2N/MSosvUGhx pga+DArqJahq6I1kCAEQud4I1G0Hn9D2YGiQXfSVPma4p7DRImxSNtjxLyqf5CP6yl5bmpqtuZ6K K2rWY5Whf7B6h7++acyZnLSrElnVnZpwuiBuS8+8KmJGMFieSkYG8Q13LUk2Uiz5UBsR1gwP4OdB axd8DBKM+UI7DJCaNcvgILLPCT1fPJUxsaGSm+TpKVMF1vjEl1AmYZWYmEy+OIg7bhYfDc6FObRB eSXR0bBMB1X4GtVEuUgrZClNewzdrmUel854LUNfEkYmh6UeCfh2hBPji9ZayOcgdgbTbBg3lkZ3 4/z3sAbOGBehAwULT8jVv1bheonnIXrJMPJj4Nodsvh8DQYua1euCiO1J2GpGvQOBEHaZBlr4w13 SoHYCR9BAmUcI83rQ7mA9lG/QxW/nEvhX6mUHLQzjWtaDC6pk0Z00VvGweAe5X2BiA9QonMnyisi J9PkJAs2+WTh7e556L3Ww8+oVfR8qDvYXq7okClPbHyLEE1bszrVWlQr8RTRtpy7pGQQN2/pGLEt jl3XEjereCdTM9HR1o5syGAc8dSPdd8nh+ZBK3e44YuVXlJHCfLNPMa3m17m0pdulVbykI4dUd13 hsxKdG5RjixrooznQBx1Gr5dzun6mwcLsyzLlTHZuWYawcQnKFAhXAIHYQCv9dUv98nKKeiR4SBc t0Z5fVZMqPJwTi1VrzqHgB3709/kdQXtjx82Wa/V29lhz4/T6PoRHfR05QYImzJJ4w09wn9TRAuU iaw2ulHHMtKrQhyoMKW2eWWyBgoipHmHvlohUvNrtDq2r7yhlS+h78VrImbMlJlzKN13CBvFqQL3 Q9mnLBKkCRfrp9q3NwXAetpzmsWkdEKsW0bHzNlMUzybt3l11EjNQuwOHjeY4A9iAN30n0wleglQ CxUJxC+QbgfgGkO0fBBQFcymYh7QepNA3+8EKdRiJcgoCtlTe/GaqwbiAENhUKortIJZtb9triH7 pefiDnCx/LEAwTAjjiUZcO5aq3oLCRP93+rA2a7h3GAoKNzBsvvE+IP1T9MTjH3PwHvDiAPmvmng OfglwHOCvuDEkDeRjUWQhCRJCSoVAhBoRIrRQIBXF3lj4Y0e5BOFHnMSUtiIcIS6ENpDAsOdM/sf YBHYjD4HwD7hPiGIQ9A0j9yHT+9jH3GpDBAOxGsI6xPOqeKBQHNClTwaCXFXWp5nq9RiELiFx6zR PUemVkwSsUU/5/0+Dk3OTrvWYWt9gWLWBvOmXXSSZrJeJ/pSdK3M+R3CGvrITtfJAvQHuHJzrDT/ 46A8w6h+h7FMS8xcL2CuYDiGy3IGlO1eR7lPUi0/W/a96aN7ptzPIVdd1GFqLrri8JhcCAdIwWzS RCgBoSojMsaRgxU7hXvtQPohs2P1Jflgc6J7QN5F6R5/pD0AzD4o9A7QOQQoPqekDqzCNwQd5Dob hPsTqEN4ORX3rf5Di7ReIA7QDlA6AyAtynktIvUO1+AYgD4KuB2dhwIHM9CmPBUN+Cc8QVN46mem wbhCLVJ6IoifjgIISKiiSIoiSKgJIKgC3jh4+6dRa6DEkYjIIRD9z49whqlEIoBBYRiiCl5QKA1F EQ6yAgfYqDpNMej5H9/g/oQ/kDfU9/l/Nz1CZ/P+arEwnf3P1jMqq5iBnEMM1b9OjUibFgAh8ng6 ZHo28huoK+OF7gUaL8MtuUuze5xIcyBiCIKONvFDy+z6ObR7Oa/P6snD0YlcZjRoYIzIMiaTWITa MgimymkLMxJ61rWEBh3egpDWtHqta0Gr+We72s7VU2jY06oP0fsCL4LB3/1fI3+/wsWtLHIoNWli yuOCyTIZb8JgZlUDRz6akMjcRTl2zw6e2sRNwYcXe2QFQDDs/hSoxP+l7fj9heqHjo/0tmriTrLS wTiFsuDX/mS/Obk6yfUjqYOX9WxZ94m1Ohc1stQKKZLYbZXg/wciWwVGlG5Bg+GOhRro6G1DH54E 1rplxVSjv8MlptHhVjkmffZY1vdNDpGVfNXkSX+QEpqZ0XVhWsDgiKd3aKNSQwanSw8YOqcrEkf5 h8C+4uI1MOIBJAG6WCKsm66J8GJTKQr5H58+6/SCQeuimHPwxabrnncZ6EFal+kC+t7Fr6jPyhxd prXLF9fleHe7zr9CL2c/mQ08wMRmvFYuUxz2th7UOg6alYWjNz0dOpKD/jvFZrTHFSx4JnL+J9N3 12tDdFKqDJQ7UiiIgw/dL0dA6haY0IB1VxmDTruRUHzvxjrkVlWxzMdkqou3IjnkShymCjnbcr1C 1yOtKMPgOOg4upcft8kzkXDLnpcNlHL+iX+4D+SmqRiWubUC/B2CFNuCDRzsOhzdyqDrTm/VZ5HP tVEAyM4gZBiCaNyfglkvAxUL4lXtVNIZPHFcERSNEf68yTap77OKxeAp5sVkUB5wapFH7XXxAnu1 44X5imPGbyrT0DwDtIU1stKi2Brxgnp7zYHYB8qbdw8oNf25J5ShihHa/oHsEOiHjvdPsBnsHqcj C81kpKEdHmdSi8QF5Tx0a78eJ6UGTh1lqryygXVsGNuXsugGiBnHyRkmlDYrdk+ei9FVOABRVm37 hVnxOPTEB9cmThqg0eNlQLxkuD60mEFKBdP+vNfC2B57mvko6jR8oN6hV1Gsi6L+CcgOkocs5jrb ninlPHPIZLJr0ILWzVHj7lp/5h9RJDyYHy+4hDrRF3+R7rX4bUKEL8NG0PtIm5q8cyYLkbOv7E3k T2f4eYGr6Ys41tZb2JmlkxzLyxmgOZRUuCgsYA5cngcp4UNal+2/Nj5rQVmZzx+cUdm071RAusTc a7POH04suOjssTdDTRumWaGyNjXWVj0K/Y8Nmt9i2amqbJzjpeJ0gFl1oMFbF59FaVjkzFZk7WVx o/2D7ABxKrKbICV9xjg4bwbaNmYnE8WL+0CvjtUqh6uM8B+Jn0Wf54w37r3LJYGt6coSZEhfxWT0 ekRt4Fir5GjR8kRLFg4O6qjRL+grqS2iTy/iEKO30vpMXjH1s586X5p0L6yVCARz4MFZIj3aXOoH M3MTXNPrV/GtDw5gciOuokS5MSdXhvhZyrB8JGTMx8i/EBeLtByham4ztuGuSNRzpr5ORGe/XAyN 0c8JKBtujS33vojG8B/QaKwP7pJLnOFpErlKhwmEarDSpuHUi03urFt2UeKwM5d78bspdxB7aGrR i2ipE4irGEQmXUpJqvja0Or3msJ2epYWVjG8cfc4O1zQcyQN5r1O9bIw+5G8B7qxpzPTT54E3XdL muYvDeDByi7dBlPhQk9GdZeZuXbUibNmiIl02SDHWQ0HyAKoy9mFqgFMd5hvxwvfN+JEO03OlGG8 nc7TGqPFwY02LIh5nHzQcJIzPhRyjfnijrgeCAKKbNAnzUTRk1jXVozsjYQlR9honMEzOCR+RRuE +Equ060+Zcz2DpSVczsPDdkP21esOGKDdHcHwwwr3Xha16DYpcckwKL7rXilwLfI3zrQ+u0xqRDG sW0xHQV3IoPKmSVjElULI8qxZn8ejJxFmUZaGTpb0OKF0RIJsqNClAnGfHjovtzidrPCsmiEhhW1 IqQMbnlR2Qdml9NTNlaQGIQOIY0HYSMuF2FkUAenjY4bDB0MHXrwTYdbLZIFltiCJ5zCRo3EtjRU lM7q/GAmW5bG2wpIxG+S7D1uNhYWeXKVT0OzFNq74QeTMRXtkrygCF3O8vV2FHQwbiIQy+MwEdRi XoRyThEDwBGcMvECW5O+uDYVuoha7gH17oeu0+pQMj8egfvG+uazWQwdTrvJQsi6EiTyQCP82+I5 EHIP4yTuXEZB62Y2PfS32AIOQ3hjUFtlHngjRZoFHYm8aeBkDgc3LiqA5dh1LrdyNxhi5uIdzqVR V34S1AhOmVhs/7kJHfhYnuj7jDJyMEOuzKf4KfiNfOJvKR+yS/2pFQNIvfM8kxx+fR4j2SDEOlQ0 aTGcjajiLuDScjwQ95+5UrUdMt4LumPc6oR+vv8ohYK/QWzFlEnkqXmbvDSHqo0KkdZn7/bl5xvJ 5fF339Bs2SlkleSvKQyvx6yqnZSQ4m+pAr20u+d6JBG1ok2VDB1sKplBYJklTmYmh9h1430cNYj/ uF8DAMzBZHIGNnRhM6LyLrmeIkz8SBxV7ozK9dd+eEDiFX8rCMANm++v4++8S+8QkYQj68C3vMLk apQDNYn+GOkcxlj+AbxWsSGKBM8kJRUfDIWWj14yEgEkIWPIB0mw5jgOexgncnHzdV500cnKc2GL Fneopx1h1HSYsCxY6cd7RTefOfP0O/RanObjAmOfMkUk/Q+87X1gfqhPx1vlzJSc7BSx6FB4dK4W RmmQtBGTk8Ro5OIMRz3CtLQHmO+4dUgQVkuYGrhiscSpndWVw1duzokcu0UQXB9V1bfSysu0DLoP 7aus9z1y3JOmRntJPo9bCx++C6UtPMtEfXyw/ep9nnwR/RBf2YFttsjPCqi+iBGBowNX+wqh4OrP rYnfxa/dDMfsHCwWR7Wjih+dwXzo/c3heg+wmISZW1Ho0XIPn17njjAgFAPND1VFCLGQWDnfny5N wg5waEcA41u7PnqV5FSFyGKo2XgXKO5mpWG8FkcQuScsmL1s+ALF2EIYxS6j06GSBRjRelQ/oEIl Qlqoy0nVTupf6B7HyF9SldjhFaXxgmQ78yDT1OzmseO+3YieVF0xWdEfZWb29YnZWdLBohwxlGzg e2qlDBvph2VCUY43q5oOOmdRkwUxmKZwpGdjzgOMNeeKT3hNaBA6CsnRw9aDWbFgo/PXUTgVmyKF g31SwSeSczIpKfSKTsaSnulLRfrqZLgbfl6G6hwlWYtjunUJ2MhQ3i3wOLfhvXtz/FOPIfuCCJFU FPzI2FERDx27NjCXkMGkoUISEJPlSjzzwVMx4Kc+QYiMbZ3QSt6FxQ9eu9WNBUTtlseRwxLQ/7qR q3X/OBacGMyf9hl2S0V3FGTHblv4kafqKfefcvP5ElonB2OFnH24GxYW4DRGZ8hsoRftedHAoNLJ I9HsDw71Sd+c1qCfHosp1HNRa51W5CZmn39jufqDVasnH4UeLXCaV6JJ2lkcB78k2GPwcLzXNduV HT4KDIAdeMO4vHsDbt5t9NKB0EDoTrDlQvjxcu3Fbh46xMwxU1gcXLfec3JaF23knNgQY00iH1T4 n14nOlytrEMauBqESKgFiZGeq2nlVfqAS5bL1VbqjkB6N9SKYgfM71dEeE5rIMZTVKmgLqQqLoXF hRlySYwl3CEdoe9NMr46C9+/QzyNp8+BByQ/DK31sUYR/XNg7EwMt4ALKDQ6HIwr1eFNR4Sxrpxs g9/FSpS6cOzfBFSZ9QocMzVfALyH2/zAP4E5JVPkFgX1CvWcpXK2pLQCjqBzcIG0LggdR1AsD0Yp 64AEi/EioyqZKli1AehAvU9R7LFlgL1jVEocvEqnMoYjD1xxCS52RxHoD5CWLxwWkL+ocoeQlwYe wyrxo4zGh0hxwUqbWOQMsTXofBL3L8BMoblOkMw5VHFiWgCggxghIiaO2EJJjs09g+Yn5q2Fxi/m EUP3FRMnBaW7pmpXqnmRffzW6ugqo2liV1HUWBxO0e8LcsigKeKbRJQBvJivDOSiMUsUUBQQOsOg APcRD1ob4+RzFAesfQfWFns16ncJ7KBuXX2MSQX5sShuKcinJzWpZAnvPq8gSiqotltpbLbS2Epb S2W22llsIDY0kpaDRpIygNLaW0aNGxtLSNGyNBpS0tttGjSFtkKS0GwaCWDRoNCy0EoNltlLRo0p aNGhS0aNKWjY0aNiUGwbBttBKDRo22ltGjSlo2NC2yJQaA0aUtI0aNGjRoNjRo2DKDRo0aNjRo0a CWNBKRsEpGgMpGwZQGlLbaCWRsttttsLLRsaW0pbbZEsbGxttjY2DRpS2NGjRo0aNGlLRo0aNGjQ ELBsSxo0bBsGltksLS2lLYlgNgJLINBlBsGwaQGFCNkYUBpELGjY0aNktttktpLaBbZLLQEoDYlj SloNBpS2AJCkjaWwQpGkBkLAGlLRo0BKDYDLBo0aW0tsKFsjLBsjKDRo0aNiWNjY2DLEEEGCMZGA o2QYFkGMVo0VESJEEGRAVEUYxWDBgyNkEhSDGIRCICQaUtKWgUtlLZQtjYNlLQlthbQoWxo0aNGw aSlpS0AbBpbS2lLRo0tpbSy22kgUtpbS0aNKWltKWxsaUtKW0tpbS2ltLaWjRo2NpbS22xKDQstt spaNjaW0tpbS2ltLbbS2NjaW0tpaUttpS2NjRoNpbCJYRpZaRlI2lo2NtpS2ltLaWlltLaW0tto0 G0tGg2lo2NkbBtLaW0tpbbY2NKW0tpbS2ltLaW0tpbS0stg2NLaESUg0GUGgykbS2JY0aNpbS2lt LaW0tpbS22jRoJYNpbKS0aDaW0tjQaAykbS22ltKW0tKFo2NGg2lsELAaULZIwLCDZJbYlg2lo0G 0tjY2loMsjSy2DKA0bEkgwINpbbaW0tpaNBo2IijaWwZYDZGWRtLRoNghYDCMI0bGjQbbaWjQaNi I0toWFo2MY2lo0GxKDRoNiWDAYDQjLJGlLaWllsSkaNBsSwYRhGjRo2K0aDRo0g0GwZQaUtpaNBt LYRJSQbIywjYMoDRoNCMhYQQAYSNpaAyWSNpbEpGxLBIMI2lsiSwjRoNtIkbS0aDaW2xBtLYIWRs GUBoMoDYCBSRhEgiKiyRG0tAGEoA0iFI2lo0GjY0tsgwLASERttJRKqqn/F2vJFEwjIdUApjAkGB EPAlmITtCoVJWaF20LQUFjGSCyQtpKxikVGSJWf5sgErJ6QIgK0lH5aMtj8aoBZoe47rXIKbwqXZ Yn8G5zAwlYJNibQ9hhVkJSo9Ls0OZSNgcs3B5IisJGQr9AD/2JCJ6gNQVVsp01qDsh7lxVwNoJ/7 8UyrSh/D/zn+zXOcmcIiPNr/4f6T/fqTQICpN5R/2f+OBfL4NMUxkNJy3WKhxDA4kpiUJxn5tVhx kXEgHVS40/HCBGVZ+ZyD+b0G5MQnMxMsPn7j3Y2vmBvCGToHOAb2UjKIEWJQetVT6IDnPyKXewEP qPyBpADMMRsB8Q8wCirfchAWLIyKgQgyCTpBoIkYMkYochGyAQAhFBgLrJ1DD5cUtpWsKArEWSWk KAk3GKRPrapV/GFN79Ij+CBviHzDVtDGHCWOAeoTrKTmkI8wWuLc5zJSEYawjBR1BwrwqPqdarsD YF4LwjvmTfAD8YxR5EZgheH4BiDaOP7A/MvWDBj07wlkMF6+rL4++sjzZMJciQuAnw/ZIDLbD5lU syFk3+g5etDHSapPSbM3db2R0S4ZCKwAwPw/3wpyfVweykYmfkwqfBvZTuhQ6Qv7dJ6ziaDBQu5Y eutYLNt6pY8TzJwmnVEde1w1omXiiwKOm8bMljMkssob3htpxLtmJwwxIcCaYpoXLt3EFAEgwAjB OxjuZj6UkRKSIGA4dkaNGJ6mbhFkNUs5bd4b0GOHNpq0xuCqcsKVsVEYmVhOkDg5LDQyCh1Kf+N5 /T/j4P/DBf19fy9vl9HO+74zVyl1ecv+q/q41YuHvaqzXPkZZm2xjd6HXl7neV8F28IBAQvSkCkQ LFE+zlTDSTQjVQsLq4aHMttmkRCZSqxgs95Aws3+L4X3zj8+Orq7rrXG6tUcg0Rd3cWDWVlzmXdi I8RA7PjEEtlEgkjrA0UJmpaFzAHn3+X2VpTxTt3PPbzvlq8n8fFWJSrJy/73yhj396VcxdbhtoKD FCWtxGoRfupZb3BGLKuTzkasRSQ6L9SYrclO1bjGVoxbCXuhUEUFl9DCQaJelEdTwD/C4EKOFY8q BTvOibratOdZkjP7Au+FXdTbYdR300uSwSsohYkx//yQhCS7EgFwxwVOtXltEo8rBaUDlJ3FTeDX gSpI/gBdBKanErsfzU4b8taS3O1pv3a3jnmNRir+EkjU6i9Ym+jNa8DBX6E83sl4fN23DS315fZ3 Vr2dbNepTJqreer1b5UHPE7Tn1ZAdaqTRKcHZ+SvvxtdQWjKyOsc2WfWDcC1uFJj9l34GmpXKXfw fcwSJki9jKOkSOkZlYmXvIsLbAzTDNcnHuLj/8Bq5hMk6Un8K1sdW61NSJnyiDb7hCCTg4PiPtcu fE8HykDl0JHEHo1SHwH7zytzhnOqE/6ML/wVA/uB55HTqt4zA4FXlCnbjW7eCjJ92hdXguqVFS1O jBqpbQSfeg+idRsVgUan81KEhdVT6pw+Od6rzSXZhwsqWuLPNNNk8eeEFcuWadHyW2IEicx8Ebpg lhXlSdQKsMQDLYZ3VsQKZxRPV7lpVDJg5SoVMlQe6ayY5BpMXOiuQxkpPCc8cS+bYzOkiBNLCq9X J9MI/uE/Ei5TGr7IuDU+bUTbP1IbvGrTKAXL0sl9/OoSc2qa3W57vSccqAkErXC+cPijdngxadt5 Iom/dVTSM/3BSjOAarY0TUsniRIy1KyG5wMQ2i+5KodQHbwpxysZxO15UH1lX/wgHvNhIxvCbOxv ktKciK50e7LkvcfRPrsnwTqfyl9KEnWFA23VenU0bIkocSexxQpTHCwRLSKEbqTLMlExgUy5I4Vn cTOe6MC0Mb4GwK/DqPTRqw9ddXrRzMw6+DZ1BWf0mUqA92naE3Tgjz0jCj2r6TRRJbrUkpMvJ+Fk DZJvoyx3oro3+QNEMdPMdHMd6KKbp1fjqmbQWyv5EE41uiKISKlsa8LFLdNsVh9uH8B7C+wfwHft K4eBPPeMPCuh+1DrqFpFCNppex1OHRErAKvJt6qPCMrdrQsr5oxgkHxREUZdM+SAqBj2GroEpqO5 OTRHGEQ0izTJDi8cGdQt4J1iUmGVPLFrEWe0iyMuDZHDU3Cg8dWOA3EJhFQVR+HrBZG379a5blTY zs8JQde3DFjJWOnV2PLQmHqpeRScjddMSOlaVBp05ksWWj+EE4lZ6y/THAyPeA4nnxjqi9BInLnL NkI0khaDv3585sToZ9KPJG0+Ni2gub0s8fbJikzqA3DZiIOLc65WOktaiXHK06Y23WL1xjhzRqqq rbMBLlordvgQkAD86dhyK5wFJaHWNx5sdGKIEjBpnRmWarvDKeTvXZelxtjwnHcigUctNeVyeZa4 Xt7CX7BwkCP6CP2KIOJBoI9jxzuw72PWdeZ365UKeKOlClUe9KeRU3bb04k6uSUM1pqZDyqc3yY2 vd6AW3UZyhnmgeEF1UDYc85BBl2Azn4EbepCgjFN6vVUvmEp1Utmv9iQkAFdjYwROaNjzAQLZOs0 6MWZtwoXyHMqdVHOYQpUUqq9U7pvic9F75HsshYjzou9m6u+J/sQwGJuOsWT8RyLqb+oGti0YmW1 KjTbjnD2MdPMRtgaMgjfPe1Tu75wk+mivL4lY6kYmXWsNhzr5Nc1rrZmJoxRztFqcOQLyKZ3rok9 z71GVzoq6QrJGB4NkRitofJLG6haEtwPx4hegRzvAENIeAEuhXOn41fMZUlcuFKz2dFdTq8pipyb rcDlIA/h7C/CmKW7r+iYKPBiKCPiC34dBjGzwQs6HRW9yezDis4hRQxJy7bNDtg07GfEp5VypYMv t4g75orCifelA0G+FuXIbokDDsQx2MKCF7uw4cQVMzKugvUilbqpDZS3BRhV1wqTztQ6VYij3ywa hG9Ql6fX2d9HS6PYcwo4KcqPOAd+I3RgLwLdVKaycT4jcmNnYM2IlrQJStg0DdFY6l0Ka1DfByni AdXp0yvEvG10sWkIqKIEvMvE4xuTEa0aaNyFisqXK2LI0iNBkoQMNQ0ZITsN7RdQNFGAHoZ9vbBv ZE6Bpx8OH+27R9fK5I+I5Ie8QcNAcIHMj5RkHy+RLL59buSNQJxeOtlzzC6C135HWuOWVN4XGYrG c+g2NuBsyxiC9hbLRNE0QRq9xZYhmOoseQQOyMb7AHY3dJXBA19A9oIWgjeFzGfMA32EBwwnyEG6 52yGx5FYyDBCgcdYoUIQhRGIbkESNS6oZ0VfdjbjJ7L4/AJ6Xv/m/iQ60wUtSSDGSMYvQIN4vDs3 9IWeBtQhvnqhLxJMcfIme6hORW57Jvf3pYeE4yHj4zv/NaLqJgYZTcVJnz+Qbhc4oFh1gfIo4TA8 tA+kzvJBESey3eodUkORWWzBQ72XCCiYtkfc5fo6Cpk3wMvmZCBaLI6JroYNqjjhibyTGbmzavXN WwMUHjNA4ygalUvolakJjaRFpPmSZ9wsJfzP5IBWFsQtCn4d1De7LUtCmcgAREAA6D7D98pEXisG QvnBEfSpx11S+NnDrQHPo7dDl90nQPCEuIsKhO3NFCEpdKOHGmMA2AXY7YdUctcLzVSBehMpkmNM DJ3K5Ho644Ww8zELc80YwaVyUuh7AQnC9p4Ck8ETI5w2LbHDglBFQcYL6sczENyMbzom3EPDZe0Q lIM8DQPOEIpVKDys0+E8BXxihscXWyhmg10aC5VZSGeI/7mTJhie5ETLsdsZ62imTIztywqkiQ2L GCkxuuJ2HwnrBKNZCOoPfbo3SWWmbXCg9R00lyks74yxC8C5gdHh3XhOnLzSi7UpaHyTjMFFz8EV Z3GL34WNcULhokRll6G1bpjcVPajC/W7FMliaHGn6cQ3GZlffRYzqDwj9CZXCPNGjDYhCzQnsBu7 2e1hlewYuWGxDfXG5vDpYpkP9gKKbB8bCKJFQ8xQgSECI9kjAhYqoUoKDrdTxzdugomKIoUUkAkB KIKpQIop47FMEBUArzXlN/Pslg5N6faB57TfBqQf5Vzb5+bz2MnHsmKUf0iUw3gv1Osyc5lCZaA7 Tr0OuhCKSmPYjeksZZbfQBAUk4QAi9ZxDDqOcXuzDW1d+DBGlDlNZ0WNx44wRDOeZmfZBPkFJrmm a9jMMj4+Q8sDMAAZsLRiYreHYMZo+cDRWvx24sV8TCxSOLyOMeSsyFvwodtz38PE+Aw4GPs4LEXJ XDh663v0OO7nXUoqzLtDjCEgSH1073sPF69SyGNQ47UfScZE6QiljJx2/cJHccTzrAAfy3ZCHGkN nKByRURHkEtjfz7s8uEpqBFUIhGlUKQmOJUsqjel2UEn0ndQV7AoUo2Bq7hqlBZkakoTED+IwD+T Uv8T/Gz33AetMobwDmDeBHu6iNwEeDvA7e4OK/mo7eMxvIdMOztvbk7wx9pke97suzOX2zYBdKNL 31jHJSVzQdT0/KHEooqbYMxzBjLuulwgE7avCdJ36MIoUNSN8jke6hnGKvHGMQxWztGqMiBTZcyU 6wHC8JQKxKERa1be3RyTDaodbno3XlCuWeOGxjtgTk4Zpdu/uDIWjsA6p9Bf0AuP9kRyBmHJp074 eO4cweYZA5BfggQfkGIxGqJcsPeIoAdfVlH3ZSS4PoCDjXOjuITeo64dsDQEL4wicAd6n1wHLAPS B7BW1Q8/00KWYB7Apgxg0vusPYObcr0/J3A2AL1daN36PqSw/SYIlggmQ4A9Ee8CB5C7QHGHBsNB 0B3B8hLvzkQPamuk/Z+H6/nc3qPZQPKgSHzJ2Utam7FIQhC8oKCEBBKJQSlClP6D+PAiGBQ/3CBQ /wtFxBsWKC4gWILJmVGDB331j1h1hvgbncgnop9K74b4Zwizfm+S7ZV6AHgedGFwbJkQzroHYCaI AoegMe5OcM++Aesbk6gyJ60AXEHWD94fU41NwGH2J7xDOb+tSLwQLwQ3x5g+lFNhQHtXzDqCB6z5 LZLzEa3QBkF9in1v1ghjTcPQI3huE0rqfNTUe4d6XhwbhRNC8wYhc/B49RfXKavpu6LCKJ9JeAQM RQuu1LtxJvlFFuuqsQNm5r9AGdesmgOOJ4ep3koZBM7EVxRXWewlPYVXejiYbN6/OUeA3NB7s9AM k69PHVNQ2ZTkM8k8PUwuw2GHKpxv0mTgJ2cL2CjBLs1sNJzOTrxdYbk5nkOIVYBoJY/8fgfcIyEg xuwWTOHm6IcQSvyFOTYnCY+A+btQUqWIKw9zUOFigRZf0ImBkvSaXaIECygklHgUnICDhTBhx0xg 6UjzmMppnCTpjPFEIuDsSg5GDmVMmUGXdHPx2S2uu9H2+lpCmaMIFQhCoAxgAzsIk5ahwZkRxzM0 Mz2oC3qwxz3oLB7s2kPTpKHoHVPGd+a/zfmNccQz07wJvZPbs14bp4oqziAqjtUTO8aAnEBlypOe 1Klxow1K0AvrvIVTwvIwg8+3OlB9TnKziEk752dxMwjcZPL5U5xa7VNkaFKFCT7QLyCg3wmskHXp ZOG89fAzQcpFielzPTPkk0k7E2M4Bs6ZMFcD7VGvoo5hm2MNeBKAKUWHj1Vd0xCLA04nMyUheO8J w/HdIg565mrReHX7vKSKXchmAa45KFHIHMUGWMuCd6UYp8pTP4retzEHMIOspTqMdD2VAlZVAGBA Pk2zmO9je+RU10hCEcrSF4O0dYIQNsHC2rFlLOW0oCF+g1lCsxlIiA8vZz7Ptvdf293Th++WimhY /E62IEf5Pn+R7k9z7QGT7Gs/P2+R6Zr1h832PKw1vW2NkFEtERQu1j6vPL140vM884Svo/fVW26Q BAUn5+4ToOscxpERnhiFFiUE0XZiBwzUzVq4JKFr+W00+MuHZxfPY0b0hjPQ5ZopcG+poxD0mqCM PSgKWC6ja+E+BJyZms94n5KjxDTTi73PHBEyYce8OZ7GQ85eR9fQ+Hf3e9TFUuYGZlyopgKaIneA YZoYQcCGdBCTNsE9c+NA4/htYtYhJOnsGcK0XrRpq/4trP8jgrTK2rmtg2UzUbJWLeZ3d6QDdLDn gesWsA2gSBtbGlku3QCNapQvGyAXoBW9XDBV+0wuxgcxsGJYwqpOlSICRApHgnEgFiwNBcgVEqio JBRNSCh7O3mcG0hyffbkvn05MRteg5JmvN/ElYOWkBUA5CVlstY+6+EhQUCwzDlGjz736GhDbEgc 7MlwVEacZI/9PZMkWzhGjs7O4OioV5Gy63VafXgU5rOJV2KCdFHHnhALAThnO9sOYNIZfB7HEhTQ VPxzcjq2S99lljegKKzTUyrjifRMSq7krGnrIVVMY4URmMpc6xxZt/NI+wQRutiuqVvC7zfi0Kdl exRUS8MVJqXgEhHW+7P8UqM0W06IxWtnvtJVNHqW1i1LywXTJJv5jRKJryvEkjG0DVBwj7F+N5oC SGLQdzD+JvM17TAareCtDQnRhBY0G9qscHgPgX1AoYCo5yu07ejgGcC634O0agSC4+193skHB8D/ C1554k/MJ4GaeKyeQduMHdXN0GhxUIlh2clh+sHUBTMF5l3HVYrJGXKQVDraNIeL9CTs8wo1zSxG lDuC61Mu7Nim70nBmvggvRRV5Xi+fShh4MKwUb1ufZoSEtsvTbjHGs7KuUi81EJEX8Vboqw7RE2Z bIODGUxpR7nzXMcRl1isRnzxQ2sDF49aJOIGbk6ctQgFjG4XHuqs8tmrtYVh79UDN1tRMPlzMuuE 99DpnV+YyObkpceNIs3W6yiMrYNzkOsUVWoXt8kKtEWhOBpxeF+4Uydyzuu4tyUTRqEDhAyUs01I hlF1baNTJ0L992ohiivenW8bOuuESMqMMDoPUMWciPbAWBPOoPPaNMzo9HV29gxqZ4nnBk/j5IlO pZ8GytREHMEKv6vE0Zc5Yu7HRPwNgFCZ7lrv569uJUhlLpcNg5RJUhBiDwp/AtH3SYPdHgOdge4X 90jrow6GnQXlztpzHuGE0K3K/IEyxZ49F+4X+7RTquDStaaPrwNKpVL1f0s61uOjB7bmQCQ69eHg Qd2OR4g3qBl5UrdAVAKdjEODP7w066JsSFPvU5DiWsZS8xgQVn40QIFyOiwCO2OOq+mB1hQ7UtU+ cAMQ48Ucuox8cu9BJh2nAn1cuMUm5L+8+9ViljNL/JSebsj3fRnDU6Q+xCbV+9h4h7K1bUegz/Jx K7vTRZf40dpv21tOs02MdYepNWbkMzJpN70YHombpPdBfn37a1PGfY/+j3qWz0dp6+lKwla4wO09 VfTKX7bPVnHPWFT6JOO3B38nJ35uZrERYhn1CDLEcPe3b3JK7LbB+vm4AoyCvrLybCXUsTgBBrdu RNqMmYnD3fU9OXUSsNe/pVLRnNOIOk4gU2zMrJvAZDMmVb1pHEmvXrhrc5njSgZa01iuMO8UvlKF svFTxEPOnWZHmjn6cTYLMD2+Kw3uKPDVavfh576cjN+lQepT61Le/tVOkNp1jSB7b0rGkS+NOnj0 rtz4ljEQDHB5apdZDhgdfFWqI6cVHBGiLVqXHPk/6sPg4F/DJWZE2zz4eGGDqLhFcuF6Yj8oVE1v 6VCT2wM4J4vnUpA6EywpI+cd8+cbJt7Oy0GrRxdpzcI8si83BVzhOZVYcy36ej87BvlgqZ/ER5ZE kPHRj53MsNmJ+ayLfIqP+M+zBom8HY8qzBsLWNE9zcK7k9w9GpjRzXdXuGJRhW5/kkaR/H8QvoNd wGLpsAGx1gpPnTch2+mLjqwXRJTsdU7VJ2q4e8vhOQ6/LuttFTacRc57ncOn1aZPT6YfxvQmNX6O jvGz6dETucmrbU5re/qkoD6c2EBzjudmRaHjUodSkE/NlFiCV9nkfkrREen4GNNsi5P3nSmZcSuH UHP27woy4ikwgtxWjMrMn0c1L7N46dOv5SqqHF3nDiG5Aan0yBAPzhanzreChyOZzdSalBYkYo1h 7hACMGTRW9etEnFVlbyTxqRYgPcWMqVIJqMXqo1ijN0vv0z9oN478Dj2wEkDy210IIbooZ/LFRcf ZHczCiusW0mfFaLOHd72X7qxSRNsHc9b4S21x7bH6/mHRhgu6fOCy6GJ5pkZPcRpv8Iop8Uhmdur f1WS6QZkumyNRwWH9D5ufuFyvhQOaa2EgJIFbjBqfgrVXwUPh6t1KeYAp9hvyiUckKtSUKeiWd96 nozotPTnHXOUBl1HVbtdGO/HRYFWDiwp30DYNugUGfCEF0QIseB3UkUTBBa3J+Scb51PTzEnaibY oPyiSMGudPOT3TOjRKQZoZHJng+AvslAUjpH1SJAyVplMXqR66J1XWMEe28Xu7o1CcjA4uurkXOn bW1PBmtt0KS0iRfZnR4gRqAuVruNIRMnAzCxMUS1Gxjx1PTi+sVHK66MmeD1UjzAYCk2Lo4ygWOO WHuRmiMg4Up+FvSGBsO0B62DtFHwVPsQkFavLvzQIJttAm+5jO8bLUtk+iA4gwJL8IDZP+aQaWtI 649Ds+eudmE6w1NoqXK1KFS2fJ3HwVwPtfHkmbT1hRmclm8KcJvKubNlOO7dPJyW/BuvRfAxyEOu cIZ3XhS8DbeNbpXeh+EG6bATzYwUD2EwTedtk84nAKctKiuI4BzqxvBfowFi0eJ5LA4462V0nBIL zbnXU3VvCtSOiwWJaLzHLBidjOApA/IfzQaF6+33+x+2+QOgfsBH9lzWEMgaYzaVjRYaEwGQHeNi go2StadSt/fYvhSoVC0DG+BgYKqoxRQXAewigBHERW1sNVdEMkwTEfWBYWgiQWqF0SFWNTEMHEKC N1cRpW6VT8DDGjDFhkh3SoqguaYIKQ2WpgIoAQLDZAMwqNAELFALomTYFqhlg2ZAIXIAF1wEJpow yNRYXZJCQ1MR1dyjRQyuGFwuOgh6ZfMXXzIFRvY96h7r3T/R8iVZ5AD6W/d+93r9N/U6SXqCq+Y5 D1Mfccd77dXGShPPcA7IZYgQHfairJMEVXJI7MWzfY+lqtjpUIPYve2A6+6B+i10y+D4Kr6ckFeY jz6/M+nRCOmUaRiyTYIGE+71fkkRzqNO++J5T9n/wIZl+PdOSezDDOeW6DnJXfnIU5L9TmyqNfWr RjIwPSuep410vrYx83ycM3Dt3JDg8jztrHlf8XmdvgdxKI+bkIlAOVj29YVeerMoG5ufzGnTq597 k4buDba7FG4zZOTm3ck6bUfvwhfZScYz9oCGD0kWxQiRgG1IkVFuy8mE4n11DUo2IcCMydlQccB5 u5bj8f1Djg31Y2VJSHwolVdddGyhOVHqXA4YP5BmtgaM8763hy5z7ynetytCnOV0vGSaYNoz1yDS spD8H7JKtcHjViz57DJCpVSIojt/VLPL2NMUIkWKw2ZMpbHRp0NsWvDB3rZj1A2UTlHcgETveQEA fgSSoLOPuasd7d5U+inr4TeAn8pzZmKUIWCkDNWC6IjpSrWC90xSnqbQuk5zEyZMvV2FwMN/wjHP HQl6Y2nCucPsDiAUx0MLo6YI++EwneikV0hsSPClB7sbFaNSXwc9obpW1EokKWqS2sMIE1fqgkGT nu9NXVe/5pB/hc8ACzLqMdaNSjZ4npROzjE2gdA+ABgp5xQjEnLRTSQGFAkRypEBkwQf2sd64LwQ 9Yo9u3x8LynbdsKsOdhfVYA3Yxs3xjLz+0SAxIAINZIKmB9EdodVz7E6/qn/GPgXQbOzEoiEDU/4 x0kDhj/aN0+kyT0LoGJ2ZB36pfxyjCQaSQlyQjNzG8XbJwinnBJmojJFZnWElQbDgcw0iT06dqBA lQJSifRfr5/adRjuhtPMD0hMyYKIglGm/ShHDdvw373D4z7bsJjOG/nJ9z1aLyJG5G7ysHNObQje RQgJ34/p+j9Hj6THfwuQP5+1ZRZ/86FXOP6V/pJQM/0In0x9R5QlfY58XaGdkdJ5lDtGFurcgxxi G63opxHsyI/15GtDJeBcIq2xtxIRM9W3W9o2cdQNjytBxKUTE6HH1uF3Pyng67y4UOoQezy0NT37 n1+wzl9Bom1pXjBSIcgjcJSjvHMIUrs4Ti4eE8nkYl7+BoI8v9j2ZVPccPdhia9jkQ9zBeFz5HyU x6irpjL1g6NqM5Gyf5E86Q9tUhQeoXR8TSr5QhVnCXhxldvivFXjvETkUhCKVfTdfLbwYsSdEjel UqjoVMw3H1NF4M7oT5gAyL8YZyAYkOVIFZoSBI+SI3OYshsmrlcaUJ6LpVURaNSMkyZTZU9RHn8k gly+pd56hCZdOWSdBpEFC+1VBnr8Ij+9YDPLQu/Hnq/IwPKl48Bp60/SZzGGjwLEFc+pGf5SEIZa qYprvscFSa2ODGjq6fjGPjsiB8IX48gg/y4mHAgPQe5/pgqe4cnzA8jDvNO2j357PcKaGHty7Ftd ZLeYQCMrex7MXMUKwhaR7zmr8hfDmeU+dYU49YMofEo1+gV5hclJ5Ah1y6/qgNpI6GxXTB2TdbZL M1fR3N6wbp8nwO8bJq3QZk40q3tpJ0KnPqDyaOrGrUKh/cYYZJEMnZyZCsjdjvGIXHjzI0TEQleD jffkULWGiEyas8o6d93NlqeJY5qc9+iC46mFC2bn06bn4/zg+agn9Q/BQ0B2B45CaQ8xDKF4HO4G BQ/2xQOuAcUgEIhA6FWynMd4BZCydw8BgvinIoaDUr6K4gvzBd1h7V5Q4xwHAQ1PMjmC4QzoepPG KDCCQgr8ZUGRBCf2FKFQQkE6x24wQnKSvivmD1ngORHBcS+AHc9AHMXBcjwip4DHl3vWZagWoaQk QKSxxIYlMAymYjESGBCihT9eWololEVh1EKBko6Gih4AGe8kIgBsAuO5LCCFoPziDyj/WHI5MxD1 TyHUGk8IH8wT/V/TD/o1CGlRVYqqCEctkgZVDkDeN4oIJnJ7l6mwNgBOEXg6k6xvEEPUHfFaB5hM MBDE+cQg5F0jqkPyslNnZND2I0LCYWSgwKJKRFBBHIFZ+8hcsCp8Lbbp/Lm+LKMmHm0iFkYQgwCI GKU5fsiQ/F0ifin4T+kxANl+Ik/houmeTnYvKVNPfatpQlNK76Cqcc4z984VH+30FDG5PnArwDM8 SYK/kbw51y8wrDD4fB/SkhRKAhKaCkwiLGCzDJxkuvv2Zg1BhlC6DQVsYihApEEiSTG0oGKCTmGo SQJKDK0UYlj7IBf/ESRMC5kBgHubOaiqnmOZhAm2Jiglnv5bVaqoRrmplFGEP8pcRLqKQqBFXHqk TQwdRVGdRQA1FyqAGL88oX7ciNg0ioL9IfIKUBD8gaoX7TlA7gwFBzKh5jYNcQS4SJqANqnOAF3g Plfnua9FiVzibB40uU9qmjz9IaYH/HMf64Gr+tBjEMUCc/Ys/Kx/ZiHpUD+g5gH+g3igvN3FB0En yYxhJ0hiTEk+49PD4UxEYOjWRM9tZJtJwPsXzA94+8m64W7HdswpacuWX3/vXnnng5NnntgocsN8 eMYliyAWIEwlkwsLnK2to1pEYMoYAHGSFnNMgsoUuZY3KlHB1L5oVKRJoXs2W2RUBzWrdMwpCwAG QHFclMXHVRaAMFZOTK44ewPCpQotWEzABYmgMuKK0kgSCY6mdNFADkIKI0iK+xIDYEUgBFWRikUe UU0Ch2HSn7OQaBTOKOYoFS0ESB7oJS2ym9gjM+lu4QbQiqMfIxAegL/KJ+0e6WzPT2+dhPC7DxvT Hr9U+ZCtP/DIX0hFhoMRaBccypM41/yqVo/kgl6ezYowlr84nXEiISEYGfvgJTIzLJOF2q4LDIhi oZqHzHDYVghAickwQLAOqy9cHKjc0pnimeSqgkYwgwkRkhzJCJQQ2H2P8Q/dhmW2lhSZEhCUMCjB hD5fQVBRCho4k9AmqqfyMEC9VT5p38AMSMJIBJIMQR/VBhX+QiFBzGiBQTGXEhaWZMKWGJIH3KJA /CCYLAZIKiqsiwUFGBGISCRhIiSRIJIjGBGESKCSJGQgMYCIIQBgudA+IZ0h4Xa8IefkNg9ah8ND NIl9yqd3yuhsIr3gSCKkRhCRKuI6Q+8wmNWkAecAN7EOcVO5eLWhznBp6y/UtgC3BUBPeKnrQzeV 6mQDqB/lKEZEEgjKWjRGSEk/JsWKLIpUQeRYNyxgwEIRAYwFOE31oA0Iu+wXOEGkI6fIdBXWmxpD 8q96Vwv6ojR/BEtZPRAsFIfwUXaEKNkb5CGUbKoyIP67Ev25RFgsisRBJIxWQkGADGAogt6e4i+8 s3QB/R+V40TgewOKwdQM5w61iF4oJy9TBUMypESiIKlQSQUhBSUUhUZBa8yNT9qF/y4+o2Do1kiw yyrUKLEWyIpoMlBVhMQlEKrGlUww+ACEUeY/67/y5r/spL/wf80S33P9ssQlM/5bNCCjAuSkpf7i WSraN50TJx1qBET+f/xwHEPHEjESSdaUIkf7H+f7fqPsw4NTTamQhMqZFNmv3y5AND91t5/j/M33 1wcmqtvfod/Sfr/xjJj/2mFAojKWT6SHr2Zfb6jgN/Q+x9d+axl9PIdUje93OHVuKHuZtBE7x+uJ aDFpvGinPDUlM0VVP8C4EawuRaA1by++xDnOQcCbF5LUQKk//RqUdBarv2gqbVi6Mw87M3grl2PD AmtcT5lfPtlXQYj73uk0xWOeXIWWoR3gHSXs6QldeCQteca4MjFDTjXSB7Itxu8787HZYqO1U6+Q Vfpt/6o8i/2i2L7CiGJ9939h+o+l+6IQCCqp+0oF0SVWyQfbwaDfFCFTNVF+Coy33pxKNRK0FrnA y7e2/bt9Emead3fGLwbautrFvJrdQkA0jhWmCkJIVREAcgUnOADAN61ihNTfAeRaqoZLldpxoiyj UY3RvVM13y51PAl0TTsa6E8wbly51Be3C7ORpBYMgvOiCHU8MbFk3QYobE3a0Awsq2ze9VGF9sWL SP25B5OV68DGhk4MLC5cjdVJKj+EZ9QguPfCvlfxt8v+Arc07POQj151uju2z3guM1pSYrKlrqLP 7k/hlsBoplRGcMYdOZkrV6oMEKyrDUI5ioo4jxnDrDnvZYxYuylelQ3OHDNHz/3IoXOuFYaOERzz qH9A+gpxKe/nJSvh/cKBzvxjb6Qj5nqdMNORWSR00R2XdudeTFKQYLq44lV5Uy14mr+Yg5BpXotj WiZj6VUTF/AnCvvMdWdzoHzpsMvNx5471ENX6RldqlObjwq/GFaIOOFYzCo97wYp4BIL5YWAF7c1 WigZ+bgCPOXPo+MNDXyxI8eYeqlE+AoA0autRr2NziVMUwdb2t22T6NuXJaClDUEAkgCI0OLJXaO Y/QJ+oYfeU12d8OrZ3zp6ORdOxTL+pZCVDcLFEnhAhJrPcz9ECNHSU4SjB5CIZi81e3BX4/GLDoU 40/2H/IgP7IMpbRG8y/kBVF33PaO+ipYGgT778IrKuQtmxorRRJ5Rfa0R8X8s9IuAK7VPA7t8D0X OiLig/UDRIfSxJs5N5gej0TrrWQtd9mDf8gKKHjJ+FzoqDQlIbPwiDZ8Gvd5htMI12X3gSR8X6Qf xNKg+kMwisBTEnH3h38JZ1JTHJ18oOO5Za3UvLwuewqB6TPr56KrjOL9v8c21ZeIxL05XC8nmJhF Sm1Z8I11lo6BQnDSaF3+Ch5kuZ1IhbRrKxfIukOKQ0t2iFIwpLKOqQuSdibsGMO4bMcva0ttRFTH XNnHyH6VpFs8NzdziiGos1YD+ioX3czVkdRRaWhPtrRimCOe1EgE9LDlIfmy7tG+jaeqgIinhxPJ SxfZ0+95GHiHvhWvX6CWjPM7yQYMXoRg4iOOQmn6hmYb8DMziBSNcJogejqCEFcWoJaQHZbE++GQ culeOw3YfYOfkc87vqA2ag50JvfbRfQPTqc5EhHY40G+SyjWDadmOx3J1k6IOqXOOn3MsYRJt3Hz cPyGR96YNprOHw2FIPa1nEN6WH20tm026ml/NbAsxSLWXFCxji2tzwER1tWjYWyrld3BCoUn6F48 RzHlVlPB2aTlObk7FBpmSXi0SAMSOnqZF8S91NrrolIcXLxZ3F1RPNY0u63Tmma5WmYjDZq7M3BE idBM1fBTlmIdTcdELohpowZRmy5sXVHLnU3wVO1HRZcOIkWQ/hZ1Wka7OaxavXCmrnE7OnM8m0Zk yD8FkSG0UkhIqIPuL9gYScs4GUeuiQYld989buWUdOmsOtOVRxZBMCv5ipuUMPWb9HbCCBubYDg7 T04YdH4KCcwOy9UbKS6JHJgJ54Z5FkOz0WUt5WxLIlmCXAeFYEVPKMXc6Go8H04UIpam0iLlt1yh sk0sin3fQ2TqrgrO/VJF4lUcTzAQpPNk2hxqC+yFs+wvB+wS6wec9az0Sk/fnfe5Tw0UJPyv1oOQ yH2Bcv+EKJBg2UQGLYHBD1ky4kqVvMqljFyh5veSluSqr0JqDjM64C+gfmGZF2WKWD/egntDbUS1 KIps2PyA+NYWHlsJSndXCgcGyAEBUJrEuRiELY8FfEvc+2nnIdXrmk6AQmRLJ+Lpkne/ZB85msbT RVzcw/f3P5DnMH6cAOYE4YBJWAuMearzU8y8+NnkdxuQtCc6THuD9BmzypG3s9reNUvs1g82GMWX EQRrA/EC5h9ZoqVleCpjWXhYhMzCg1wyUWp39Q6a/HYOR2myViSgOLjUdFGttqlKtUInH1ZFJ8q6 Ie4G7sz5K1Y3HhggnuL4YlrpEHXucr/yA3vZUr2/shmzGBjhB7nYuZhxOvKmGecR/CW/8SAyDyEE 9aEEIAQ+MLNgp84lghD/X9z+jwC/jQDh5uPisoVx88L7BcbMG3HyYrGJ5DDmR85fRzrWd9JyPmYe PlYmS+hjj2Nb9tPlnqj2ILXU76jlYnuFW62dQT8hgnQ6N4I3L7fKFVAN8oF5vqOCWPwphc3zKgcw qMVZmI4W3nU7gw3P6pdZwOXhSv3oLTMCxUXjIwxtoFuZx4IOJ/3Ep3LGDwXe9GFDk9qHDhnxCONz p2TZy5Uq19XfjWyQbpOSKmh27/zWgLCEMEhyza+9SgHdH06etvFHUJKbi6v0UkPHq3SjUmboOH9P iATiZDVR24T/xOSp3gvvoOW2QLGCm4SlTc4zuYkuCrAzEkU/IBoHF8SC1OWOJwDVHv4WMNfJ4N8A mUMGHJxJQM3xbzrcAvuWGGwsU0+jEVuJ2PfBm/PNK5MpQxFHCl2BfWS9QWiOVuerFEI7hIdbWcZF EA/KE2NjiE3hVnwhl9ySfwvGcWcxs2ZayKXqP6OOaoVisuDWshjMkN0MSviFwhUiTTBSWXhKJtxh SkPGjZGCp5BiGHNG8lApo9wHlswpk3cH8dPrGq65grG2eiphx/gIIIziT0VVnsOgPrF2dQ0xGedB 0OpytD/IS56zXRra7vHh10wVG90jB2WlStxx2h0ivWI0wZL+UiMSTt+PC1iO3DDSVtaCMExIYYGd Xcx/BwqWC232B5aeGqOzjQ9wQUzOKMZxc5arHChMEyJ2EwlBng7djhLy1Fw/VUKG0P6Y4fFyRlNj lrddShMjpjjDLRl0J7KRo7BcI5l7CsQpFWnoLYwo9LXKiEgAcrFKFHzXaHPKn5PrStuwyE2hh9r9 ufQKwaMCDdE3EitveBBauqs2TrP9gImOt7sbdGlSBIMkj3D3FoX+bCEnmwAYKMRp6xU+AOl89sdL Et7PBTnyqVW+RvV7oe8e1HyQ80HHvexonWP+KRi2+snTylfmdmn53p/L5hdNmdWISbLclGJeAztY 75g0pHe7FMajk3pyuQNmy9GcqPRZyOPu/deQ5l9QNP34CC4jnBz8hK7lBz3nBhkXU3Ds5130UIsZ GPAUKdYmXOx2nzl4GVC3UaHg7CBr695MpilTBvm+YigBp1DnevqABvAV8t+/Xeyc5H4qGNOBQvMT cAHn5h+R8IE6fJKg2CoEuDEHeKGYAyvEaVwAPaPAgYxfaHEgDxKtKn63GPQBvfyqqo7AaiB9odjA jlUPcioJcqoLwlzw4vYf7KErBxg4gGhSwD7AAwhhun7Jv7xRH90NJJ2UFGSHQegbk8A9avUF6Fg9 FOtAxukI6BDmcpyLdhmB1IJ8APMXsA6TvCbA4VDIdQrpCxSgvgDwhQpvhvGkN9kkc1UQgccqoU79 fng3wUuisgvSA0dGl9dzeZIhE5pitQRakSWp//v7rktAvHPE/o6cR/YGM/oDgM0zhqQ11SiSJILC B/Vh/zEbQTrSmSFaUClPxhuabnIune1a7jLEta1hta2DpqoRhCBmyJmgXIINx5Sw2QrJP9hPK5r8 9W+vWY//v/fdaCqFYosCRCdyeoQYBChyRJF/kgLaGeKNTrAnPGdMoNmUaUAG9vS7bhegeCfID8g9 4B8VfJPENBjIw21836BD7QzKpvIYnSw4Yr+zKFrT/fRU4m61mxGi6kLgg5wAk6KqB6IEX+yKu0Pf x/eH3/IfRX6lXbSBAD7zG5AE+4P+BBPzN5cfjPqFxCPWH5h3sZi10cBQO/P0EqImUbw/AD8ydQ9I HgH5gOVX7wvGkS5EELxIgAbPxRkJCQ/EFh9ShT4IucWG5T1hxqfkGSfsLAX7DeAB9kCqivGhRAdI ChIrSFhUOUwCqzGq/2zC4wiwgsMA8ovRAgjygBREPifpx9da/jn2/fx99Ti90HDVzU8xombvOzeU YYoxdKO5WjuByAM/hne963vzza89azjnYT6kSf3yw2qRVH2+RYTAgoLFVVUUVVFaZJD65+wH3pcH Gm+HMOAZjkHKp3hxhjRewwD1iYgNIawbhU/MA8iG0MxlOsFdBvW7xgEDrQLgD8wDzKmBp5BvQ5VO NG4PcHkQncPOOJOYT3pep4KbhU5Q0IFwQOZAHkge0/AHvCw8DUEO/ZnNoU/JFEYqoiKsWKKoMWkE oi2AfrmpaYWISVFfqZySMkRgERgGp5p4F7DonKGZFgnMp0NngDIGsALzGc6bg58wZAdwIyKAYLel +wLhHYArBBEDaVQJS9Qd54x+HokQj9gv0CWTGb280owmaBiUbljEjANsDJTQCRgpXtuRPyJBW0GE lqAShq4C1Wo9D6abojgxQjBVvxRE4hDcoUoFFuxW44ZoaBYbFH9gp7QDceEOVD5j9wZ7hIquhxRA ihEDmpASwpxYLlUQo0GMoRYFB3JgHt4ERuFb4wwAoiBCuQetPAT/Pz7Q2PS4u4gQPPFY9iCbhUrE ARUAMwif1oKAr7QsDcG5ApDwDhc3Y6Q8EOkDQp0pzj7jecS+g8DqDqD0o/eHUHwE9A5kdzYC7pUG CfSBIfP6rINxR6iI2RtAkCn7/wsXQe9+IYm6XNUEqvbYtD87QBAIjSER+S7w/Sm0LB2r1gcyvzFs KnwA7BpP1xLLrT2rBO1H6k041TnVfEOLqFTAMwinmr6l0Bzn/v5fiPxaewtCf6rkl+GIwuv2bh8Q 4HWH1Fub6+KSipKxCeg8KcC+1DiDaHuUelRVAekNwZe0cSdjdY+yEPEhYsHxB6lV4kxwXsTtBVCC QhBIB+oF+si0UDTYREVoUBmRPZJF/Qv8/7GaRNNJ+g1SjIaYiyIH57AuyBoNrktuCMSAGAjM1aOF jVFpdDDJS6c0NWUZMVmMhWskKkiw/nSG0xAoyT55/ebgYlyrBQFXRLmBWEMZgwmZeERlAERgghUx kKIhytCiVlSsNDIyMh+chQ1GnwpKfvg2i3zCePlWjHSBgZStH6L7TIVZvhWyezoNG8C5TIHAyUTj +f469k1uNbaNe3EIoHXP/u/5ev/l1zy9h2GUkwwawhl16cv+LRwiz0K76w0EpQ/6zuafr95uLwMN Ds+dCmrStkSIbGSiBnyGn/b9l6eATYzEf/ncy1izQlMwDD+UScRDEIRg2S9EMlhUgZxLkVtFWihI MSRYoG2AIzSNphbS0oqLPu/7WFugXEIRTeZgRUsE25CshVG/sr9vTJVouBDGQxWzSWtEP/7Hu/5S H/vleS/mxia85mmeS6XMWhiVCVIsJ7NTRoaaEkn4GbJu1IIMijqXLC4NmMpMSf3EMNNEgVcHTd/h 9gfV9xJIfaT8wfUh9Q/SFIfMHAfcH7wj+xOkfchBhIE+iqYJGkqIK0stRsLYyMsKRgSIIH1VZDAs /wuJdL92RMoIZQ8kU+kMarelhMAPuA+1oHKJsSw/eB+IDgH9qD9yH4gHclgLCh+hP1J+V/UKGQNA 8SBoBzKWEOdDSgWUP0HNvub8ydOOgALjdjrFKD9A0BSkCQiKOwsCiREDqySm2aZJiBjJwZWEGSKQ FODdmhmqDGpw4CZStSK0KCCVY4FiwyzJogE2MJAEOg4HrnjUFRWH7UEGLGFSMjIoRGIBnFoRHJAc mKxqq9jn+5+H7SiwiJQopNzTRFKTKYX+7diyOi4MTg0RKC6U4DPQhJNBewB9RonVP7rmkdK8IcLj 5kXoRouOgeVQ/aq51OgOUNYcGUOIOADaGVOXcB1BiTEHOAdIeAfpETEHIIZzEIQ2r1rzu1O0AsBQ dztG53np/iE2jxjxB1AZw5w59BzDuHNkO1OCkgSioyi2jEYLBYKDBJ+ckBKKBBgESHgbQpbIOhBQ VhYLHBe+nrt/UgrgYafJVqCCWBiC1iBEP2gZaDiie+AS6eQYqp+PrPwG/5dB8D5i4h0DJdBshp28 YeK6XgCB+wNgn88hE3xilREkFWSCyEUVZBSAoAsJBYiKKCwkiqRASQQGAMZIghBRGErIFSSIjGkP b9EKfRGaPtwVFZA/CT6oQQRH+ql/VQKP9Fn9TDFeqWRHvWZsSmTWDFiYZbGOWBSsKipBRcGaw1HF LWTQ0UzBM3TTcWtUbi4P4aE4QGBgdXqUpVQ2Ef76ohERVGK2yT+uqYw+loc0v1jD5CZoNCE3SMPq 408n1rkB9gchvIJ+9yvxEcBOkeEMzmA2B2p6OCVtYD2J2gHiPGrBznCOjtLI3iBupCM3xU5LSDCQ kJCEknuV0OC8xAoNwQMYkA8A3h9gonsV24Hwh8g7hoJyGaB+oegOYB+qegH7kP746wOFMwZgntA3 cRCxPgBfAGG+Htbv+HvmAHWmkOkN8O1XeA6heIPoD5h2gcId4mvgWNyqd7nEbHDvI9ocghzCiOwc 4UAO/MW9JISSSG5U5LC9AoJmDsDYnYHWdAYjQPTmXrF7EHjXiDGG0cQ8g6AVxh0Ca3Oq5xg40MnW HyFBEeCI44gih6i5Y/dFpYzMmJYtK+vCTnHk6dnHt0c5fgpa0StQVio20EZulxClSorMli7d3QRB MEiaYoSAiDLcWUZIuVZk2Icimygm4wyD5DmB8QugbIvcA/gHT3LuHpAzA9o3oWxCnIncnkI9aaR7 FTl/jVETyE+2gAoAooUoSqqrWVUsKllPevOOcAMQch5qnhrjIQkNvqRNgd6GzEP2I8AifAfUAG5A uDTmTuD1OhO9Apg41TI8pmfgp0q409jmDgAKBgOcdY3GMOoMqhiS8OcH/mr4gibWKgGwDsH2g8yn IRygEWoSIbxzI3jUu1i6Q7Q5UDzQUBXk8kFAV0gFOcgkJziGC5kTWhegVAbEEahAiKeeFA2ICkVk EJiGKGoYcUTB1GOFe3aFtoY1ekfNceZeATuXlPbm+320XXwKPdVLmt/jLV3J/GBnCFCfpl1IDMRj in73mcBDL6j1Hz+Z5iJ33oMYIGRuFYEsWUkhO+5RLkEC8RoRKaz8fxalzK6oogZ5N6a+Z5ii/CMJ QJ/4ggCPrF7gqlQD6CAKdfSvAPSgZkOJOoA9yIc4ivOGn5R4HAc4EyDMlSEhRVJoUOY1CoJsCCIE CJGCOrKB0QJGRQkOmqSUUSqDFUCjYJEGVkCpFWC1SlEQn+ISUSRDD/HhgqJMEZQUqSLaCWSUQbVp VtX4WUFQYYlFYOGZ/TokuFAd3iZYaEgtvOKnee8OwfodfTiUUAPYeRGojcMD/kS4PUhcK29btgEh tpEhjGxT7k94Zx3P+BHNhFgsVUiQ/toqQAAhDTQOVCgHxRYSFk+gOwUTzTuvA0g7EXIG+B9e+5Rg 8D1Ia7AbQfFTAdLyBoTKHiHGv+C5jKFx7jXCSChBio8L8/mHsW8APqF+kMo8gMFDgFAFjAFFORiq guCsFPWDsHQT1p7oJihMEQygpqD5BlRbBxiPQfAPIfw+dFpIQA+R1vMKJsFMcFV7T/jAoFOcDkDw HwDFf+QdHcGv8VnZAx5jEDYTIxE4IB9MVDojaJeKldQWoQDUMUFAV9EfmQIyQIyRYQQ7LOtDQe0U OhEUMoHazpTxEUAIb/PdAGDFhAIPWqO9fvFCUpNEYxLVW/EIsVS7WCXWC7GBjifoiNJAeSEBCCsY rRAKh9lhoCIX+vm8uvhqxBQWR+0KRGpCyJJRk3oS6u6pcmzUzU/6rTASgoTU2YkfYAUKDFyAdn6y 4JYy4/Kh/jcCQyFfWprLlr/BCTM/r+zqF2LH3FyV9mPE4mDob70MeEDTDDL6JwnAl4sLJa1pA1Ej CwwgWdmoVRMZlAQ+4/UXiXji8ACcgD4oREMEQ4vzfZTh2wtLffVEIECGV9xwgWbjadFjeCFwMCMU yEEYjBbQT/aak1/bdvQR+ugqsV1rfZT+iCYEZ/MnfpIXk5vSBimShWTbRAf8f/qH+r+r+r/Hv+ro 9H0SfMT0Y4v/VmJFAwrYT2ZPp9L80uiYGFZIpfJj9lfyf9ODBDFFqBe8fxEIEVNCO8BvDRgNIHg0 GCNm8VsJ3Ic4IfAe0uP2oqpoFVSsPqA8AO5V98+1Fz/pJIch+kZAUikIoCwVkUYQVSQGQWCqC+LQ lIqpAqDTFhAbn8aoT8xD4Cp8kD8Ybhp4n5rg8aJ9w0B8tTeD+xAeFfyBA+kPxoZqUDOEfrCKvFp4 UCHUAXcAbeSEiwj++2G5MocxtYsBZGCQSMBiEFBGAoLCQSRiB+s7Dal3T3Xl5effRcmBKcLGQ2Jc H8iCwOgPv4EuxFQE5I+llEyAXJHGFluCD9cBC97AOmqel06coact9iIQwKhAybWikLigbwuME64X wPGFoeqLTkHrrIhwRNDXVoBK6kJWlmipjFUgERCAY0FAVihte0aTOsEDIGCUGgKE5zjXvTeN2+fj PJ2hsic4VSkjfCxTMssrgtKP9j/uzUdNFvRxN7DRI/wf3fQdd4dZkp4kfEDWK+ZHgUMmQ5VsQkse pAO7mRf3RVR/Sq5h2cyy8hzWMDpuzgZTO6CPeFn1JkQxhiD9gdp0qGzHwh/FSn+EANAQMr5DmB9j wofEM9wEDQhoA9gntGwQ46RfJH+MIAuJSx+xTUmCL8UOnhA/Ut16LynDS0VSgItAwCabxxP9L+rp 4eTly/xWLUEKBpU5IYlIhtCaqyrkRRFuv8omhkrLYytsMcKF7xtJMcMa3z+on8ivtGge71IZjufC oBxHQMPAZjU5Q7RsOQPiAGwNSPx3BvA6BDafUPC6A5HixhiPBTEF4XocwK7q806w0AaA6Xsbw4B5 R1DrQMQoJSmoOF1BbcjycyneNl5gvFfWoDnEOYS9fJNgfF8wbgrknCGIFgHzT4ip9RgnyQOgeYmu sISah4TkNTc+wEw8K+Pkh6B6AUTz2B2oJwuscqZxDpTnU7F5CCUEHmH6p5h+A5ntB9gGynYXwFV9 FXkPQefcFwOq56E8RyhlAO9DqTU7QpA4gdAqdSGtsGtQ8hD5I3gcC9iRXRtAiaQ0PKnkhsdjwq7Q 5wMYonemgDmW/fxqcgOh5BwehepdoeClPKJoCwvBvBwPiO1TiWJ4PGFgPWnUM0DjcegngG6mAfgO acKfJRL4gAdqhugEgDCGDDPBohUUKkqFFwAiXgVLlERXzbKGLXWPi39eXso2aYYndzd0jSDuZm5g yt2j/A5fddfYaEhP/CZK8J9oQhORQHIYJZN3wJ7Q9YYppHK7h4U1gZ16gvHEGtTSlBcm0OdXpO0L LQcwbEBx9QGoPIDNzhqTeA3lPEC4MyHkODrE4wHcq7ALK7lMCpJsRoHlgxO5HQHCHOB2uXABuNK9 T56R2F5DpAMg9B8JcB7BF+K91yH0fwg908HmuChpYuzOHkCKePzgSBCCSDPM/XYLXC3LbFqADjXj E3Jen0e8K6Q5F70fUPQvMPsVznGHmWDt7RU8AvULkKX1LwLkCg6R4UXoXGdgcAigBv/wGSCxzBxh 0CYkPETY5ROkA6gdAu5OsKHzDtwHE5hzgd4QDqAOMdw5geMQ8NoBjUed6ReUVNQcYdIDqXB0gHku sTWDuEOlLYiYx6g0mM9W+MX00BxgBwAHQ4k9BHEGkDfDkUdqJsB7QzByPqDiF3PAdS8wcoB1iJ1g HEMBaAmZ5FLcSZUivKdY6eo6q236rx9vdSXSyGDy4TkclKPDiMmCQQSMRBBjjCiokbEoxgw1bjTT aD+E4EIl96sispGhGiBfFpAIgpZZMdpbqlYYriSYZYzLMZnBrDQgMJEvAO1gECAgYhpsXwcR0btf b1cd11QlVk0rda3ohtk1oq6d63m2Xnrr1XCzJRyMVVqKisRICQwSMBQLZLJDJaIiDlotEgZGYYT6 2SxtWgGjDmo5w7AjqcNAco8Y5nADSG1ToUg8DaLhNJcD9iJoCosj0QDglpL7ooGgTlUUOZD1iiXP Caw5U7gDEAALy8oIXrg5Q0hnDh6ncnEPCGTnmW+uGVC0SrWYwwhQwFgUChCkRBCxn1AFFgGJYGRo PH6IHpD0YWY+gs+uSUzKj2h3tC9Prg6h5ei/Yskkgc2U2LSAUFg/552t970yIFFwC4IcaPo+sONF TYB1BuMg9A6oBAxCeIUGIFdOJCAbCSEm+1Ki+9sL+Lil9QH8HFfvHw6mMLD98XyYIQGjynrLr7QC 9wKRzS9VVGFSkmirtKG6T0OHRmqVYpyCdpVi9jNZe7XEYsURWaZ2Rk5hEEYgMgUiKgl/2K1yxLkG OA0ETBisaoqC2uLBQXEQLiFg6UfrOQIf7OhGDJGz4ZAQDfVAyBlN4p5STRdaDGxTUwhSvKgNOQ0B 4EQo/gfy/1f/Vwt50q8q6g4oEE4XAIdCOL0bkqQoqxM91kLUxL4/7bnSAbLj74cYHCBe9g9HtNS6 giAh2pDHzDubL2gcoe8IAdodJ6Bvly/J8FXiD3jvD6kydIN4GgPoHh+JCSWDaD7EDlv9aupdZuKW /1UC6AOA8r+IFQFebsEtScgWYWKn29tEEh3yQ9DAQ3xtUO0DeDfqkhLAfAAOZ+v4omLEomG8kA10 mj6KbhghxoqVvGiRA7w2hlXgE6B7V3x2D8160eoXP8dDIyhP9BSmGGBipiJb0DrKTSLahOsNYXFy MGBcAwKUE5xIWi0xCFFE0XILC5EQ/aFAoYEDDMKI5Ed16RzkfELtKmkOQbBYSb74hMQHS7k3DEII zmQgHQtC0A9DglN7HMHxMiDcc/eq6D6butgTAK2qKhiKsOc5SxYq80LaxkBOSH0HMnIgDfzBrE+p xKGYbxvCx1iUNbMIFDf9o7BkJ6hDBEM4ABHUMlfSvSD7BNIAb60IUCd4hv9AHsLnIgcagKd9EYQY QgJIgwiKQgyK5w4EGyawfapANSMDWoesQzhk8VwdwQDkDWEXoZkd43jlqzRKWpNM3WryoMlzjtRi x247BofJUv8RpYe4PaONdQin3wZJJBFixRTamlTnGbNtSJybSixquaUQTC2rTGoQcZCbGSSH9tyQ m9khAJIyb/e+Hn4/wev39303x31Te93VbbTTmFb0iqd1fV3K6QzpZzMmOrMkUdk52duejwCDthhk S5eERxY16w7ArhQz5gH1c48vOt6Bvi0HrS83noXobBkHYdaPKu0dgnAWH4Gl40yj3gb4nGAcYBuA 6wOMHoAdwcqnpQPMMkLJ4DzckEzyU5feT2vzolog2LCFhQLIUSIDAEChKWQ1SUGx0BZLSIMGCQNY 6eYDiTw9Sy4IciITzCPuUT2KmUWxQ3uZEF0i5Eal8AkxODSl2cxxVAr07BWESJGQGIQUJBBLxDna RbEUjYRoUKIkFeQMpBhmxAoDRHfGIe/GR+EL5Yha1QygEP7J6l1iicaL2OcNLeEW49YbE7BCDEbx CCHgGpBMNeZeUDHUAqyRCMiDIwwcgYFU1hcliJSCkJI0gQaE8DxV41C5vCQIRIiCLeIyAJQCEUCt RFVyW42wYWHIDxLiV4pRzqOVcA4sVFEKoaBx2wDLIdQg1tjPviWhYWEkUVh98CNKI8ojSIwCKkv5 LIURIqkA90BTCyPwMBuVAtaw/fBshfeNk9hpUTOTYaQYvYgZBDInz1SZWzpCQJCS8DaQLbhscqZw PePEB80AbB2h60ekLD3oeA+pMEDGHeCp0BtA9eg41DbnDgROdOMJAjScV4dio11A3sUwUiMGrUEJ E6huPpA0tZFps+QdE1BVWgdVf4kqpQb4eQ+14xDYB155JIxxvIZxwXEHcmYLLhs4LgHrEsqIfJQz VAiAhy3p7g+CBnDqMXtA31M2oHzROhA5YLJAJwnPZ9ibhdn92h+yCH7WyTEREREmIywpEZKjDCbD 9t0TaaZs/kEmt2bwZS2EtEpWCy/d4GyYMIDDZ0cDEc/IETaKJ8B0h3KgEyIaxD5JipHSQdGUA9FE zbIPCLQ0/4CKAHOvoh1pydyE/uiwmIUErrDeR/zu9j7A0oWR9YcIdw/IMjtACAeUoGG6laYrlAo9 gQ5XpwOAHhAPAPci6RN44EMA4jkB2B5DmDGrggDwAHkHtfRG5eIODE8O0edLBeMGx8iyYgYndMze WT2BkKDfF5w9gauYDr92nb5RS6N7wL8Nffrc2U1/qw1wbUYn1GvYzUQZg1pZEEhu39aaJJDR1vf3 2FWRSpDjFA4yTSTIJYziOXUhxEuWzrcrluzcpimGRHKS68m8SZKKXLRMS7w2Mf5RmnRusJbhsDNa eJNlNhs3vA2gQMQmmu90rrRmOO7IpmDbDBlMHeENG2psZLpLvbsNLvMMhHcplFnOOrkLaRQRhql0 2M/YmskXY8ZbyaEwtZsVrKUhs1FSirzxOZJSM3wTGAEFmtb4hCBqH8LxD9d9ED14KssSz4tzKC8e zA8AcjD3gHj/hd/mM/1ev8dUg692iMJma7o+FFTnd753z4tbcbMuFV7W2EHvpR7yJTzTWuPyFAcA Tym8coU3oNRAPQbKVBQIA+NDwUSTFV9Q9UI7qxuET3B7UMYRfqETeADYHaq9gcI6UOVOkDMHChsD WpwD9CG0Dcq4KKoDwi4t84ZMw5HaH0YQkkk7lO14RE3w1AaRMRmjJeBgLctIUeCqeaPMFk4VN8ed 5w0L1BgOkPYms5nEXDvLnB5ZIG2NGekKJKiyUURaqFFFMsRFQWHCgoCtdgXUkVihYgFC70GogAxs 8JVEoQIyF5SnQEaYOp9X+CXAOJFzJlCKkgMGAkTFcdwFoHv+JUj8YezCqGLaBQs911XAzeBW73hq EZmmg6kODfENmk2nFyAIt1j5WKXzzLrCXMQzq9wAbhO4cQnIHEPxA8gNpeT2C0dI21hxg6N60shY gVRqoCm4BH8walI4piKGAyVJCMJU+9k6ByCcJsYGKhgMmSYxWLGn5wNEJAAwTC6hLBJKnsXSADFX YihqNSiQyDNHJaqNlR6k7IHBuSAFkiNNApBGEQQEWRhAhCQ8VG/w8csq0KgTvSwOLFGKj0bQeEnl arolMYEhufvvPo6uYMFHKojsii/tTUHuEA8KhByNh1YfABgBvEf1mTD92d/n/Qc1t4gwVeY3Myw5 Na9pIABtHhR8gsqbygvMQQZJH5BFtFFSJAAOUjAg0EFOcIIWUHpDrFSwgHGIr7UOR+IBubm+Hn3h 67i8YCGtr0gWMQeIPiHCI0GxfAA0g4hcgc49xA8QLhO7sN5sm97mlATlkIJISOQCwe4DIG8BByfI IAavRN/nQMzqQFQD8RP2KtVyCyd4PI6idkuFjDrA+YmompPzzjHhKChxu4A0BcE+AHMG8ryvT2hr Ab0MEOwXwA6B43VoM7wHP3AFwdQaAHMA8SJmQDwBnroCoxBdI6RfH1l4Wilgi4R1QXTxD9YC3wAH 6P3f+SwiXKnyxn3GcoNoiRUtDOB7z734Gq8LNxcQpouuOUIdgPkdqXJzcC8J8ELcoahDE4xPYJyA fx8h+KE+jPQTHLi5mFC3VAsQEgX5trIxG28ZS11CmIuEtcLBQfRuVKgMR0flgGTCIBHJYWwjEIFQ QjDgWYSktbG1kGRiyjMg422ypCWDIUYKsksSIFSyEErCja0ULIW0AtgKMpJUEpRoWAxkrBKtqCDJ LEy5kstGCBWQrADjAJgrIMiKAjMlsWIwUjGDNSlGAqyJCMAEjBikYiwEIhC6NMhCJUVpiqRJP4AE A3JBZIfnJrFIvFbCtpSaWkhIFIrAIqIUICLBBhFIBQ00MRSJIxYpRFpRilDUAQqjAykqwsQhiSTA /YgCBogXIQbhIoqpqgvjc0irIEYEZIkjDJQVAVACAo4NGMViAcCRIsEIJFEX6wICi43IhjEyPkB5 D38j8IdYT74MoD2xzsBey+gg+cIRoqqhEIsk7Ch0I4b6MR3hPrXUiHDCSELrBzKbgLI3chHIIuP6 wCyiqmRD6gMQfHvSQkAkdAYcymM5kd57TsTqU5B+gOtbw0ifSBvmiB9pAM+NIRSRnaJp0iXHaB8E TIB3ByCG0X6vP5bKsOXIAUUECMKVqP/xbmIhAiobiKXMS6ikD9LC4D1lmNnOGbDUNsOZqJOBqYQ5 Cc6MATmwu6Q6SsWagwFiMIvaYhEMbGPrxU5WSImqm0oqgF9iEj4Oo3i5XDh8+yrsXR88M/03Xacf DyZ26ZCF19XyphKq+0GyIEUxpRvaY6A7V5uIqnvH1u9NuUEmo21nDE7QaASEuFaru4cPj5mtbc/5 ibjUomthc5HFNdUQiBsGBJBjGIxA31pGkCkKVpRaGCkAkoEhqoR0qXPEEPa7gLwe4HrE5gDaHGps TgGh2DsA9o9J1oahHQGoO4NgDmE3B7R1K3DkB1B3j7wDgDUO491wX0A+g+a5COqTzDyDMOINCrzm kO1UwDcFKu8+AhpcYXBqA6DdBZAQhMW+qoWSIhyEQEgUMChaXUPgBlT9chCBJAQYBEYQNPC9yo/k HH4yLCHzRfoAXRsEFsfQ8B0+PiGGN4DlAsq+Cd0B0VTCcyG9lXnBuHkkSEZAT8qCCqCS2KSJUlSq NUEYUlMABjFCEUBjBXfDjAKOEdcDnDKpzL0L0Nh3xOQVNz0BAWQAYYxnKaFD1Ke8hgHweb3FkhgH YH6RdgZjsAV0reaQ5xUzIXJ0odiq7EKFDxUOBPQMgUNJA6RQTwezsAUPEe8XpUDE90EzhiAxi9gY w7BRLw3PKdqmAHWG92uJRyAMQE3lxAFH6kOE3jZMA/O4kFAV41eUpRUPWbBuExg9AEChwERcBRAV uHmLRst/kQPHuvtFQQ5RRIIFQVA50faAdOILqYRgVULGRg0/blJgwxGHzBChiRYBUExggyp/fQLJ plQPP+sQSXUVBgBIxJDEJmNUQ6KgH2NqxYoCLACMYkSIqpESJASbq5tQ1CBo1HT8ijULiglxVALC RfyAuP0DyDgsEx1TGMjILGBEKQBHqz1Ch9scYQKgjIEg0EaigrBiiyIIJYR0wVoBX4BhaQhDILqX mHSHwAzJyhqFDlDA5zmBRhjzLcmMIqPH0Usjv4xOEOmtqj0h0LYB5PAYmcIxF8BUuKPa+pAZ7cKQ DlUOUXgbuaFSjGBBMBCxAqRDsSBUk1ZYEGFbGGap+SM1hvX49ya4NZ+XVTKHCuGT4WTGvUzbIbSK V1okJFkGR3TkMkAsYqlAAgGv168ZxQ4ylDgUeFcNuRYBoCoaqagSk3IBYt9qa1gnCaCDeG+cuYP6 XNTUUFgiA6MU6gbJ3E92cBgyedCQAyYdENxWMRVSBJBVUsIlWBDQAEQD1tBSxx+jelXCdoQKtieA gH0MqAQgVCg7gIIPYsM4bXBtUMhXcKDyXbjKEhJJDFSLYHGBoBeccSd6lxAPA6RFTHhxU4A0cbBS rjdGIRXkFhlEDATqgmkORdyZdiuKLCXxtEb3oG75LcO5H/SAXC5wxhaOAhq1qnEXcpISSN12khYg L6kE9o1gl3KKEfgoZXZss3h/NLMHJsfm+AH1LABPqBFA9T3AbhUyFyuIM6o9wocgUifACGUHaAew OzkcBE7w1JO9xC099jpJLm4mVQBYkSUk0ZfwsTDWYmg+aU/Cw4R1pyYywEG3nU0GGJBkYByw/SH8 oH9pFimMQ3IUJjgxOUvneCzqa8LDWSjHm4pOQf5oMifw/yH85+2mrhvgmhzpVv4AIP6H9P9f9/+b 939nz9tOrWXMtXadAKksqcrMvLYm7nf1BgVgNbkLdeSbynuCZMhhy8eDpona2rAgQIDnokmA0gFG 4MFH8E7U7AoaTATqzB3jmEu0iYh71AsJ0hvpqG3ch9gbwj2jqDpXSB2gcY94GMUN8A8x6B1/cP7x E0Vt2DUU9oVDuEA5XADZU1BsEN5E9SGJR+1aAziOh5RznESEWQ4+erCppIjyJAApLBQgFIEDB0Aj 9pD3rvkDm9WeiWq1OuHUBECKwYyMYkVPwFoKFI1vAHOvRpspnVXDtGfqS1KqC/rUUAI5VCEIRT8d AcJP4ofyhf0IcSfwfppiefuXFZ2yjLbKCtMwjWDcXcpivYSJJYKo5w4jtEn4BN8dIKAcfkKHkySl UD9B9PM7gAvR8kxKPoFPcH6iEiCcAigB5Ih3vbwh3xkQJHfGBZwXAdxtiHT6P4lXUht/VOCLjDz9 qh1rc3MkBbx97uHvU+sMgcHnxrxHvV3KKoDzAPUpzqG4FHX9dAD5jBDNjGlvIABZUr1f01zzUD9o YkdIbAA3lT6H3B2InIKnF7zmNAJEIfOkoIIaSvslQ70PpAOgQ4jkDmS9O4DUGxTuDiA5U83x6E/Q DxD37CQ9XOAuQQ0omIKxfUH3CEC/5rwBwpqAPiE6QgvQPwVfQE4wDmOUMYcNpwkIH5nqqQE1r7g4 UOMOAUEqsNeUGQhC+kyxeLYATqDQO/ZukRLFA1KOwmXSBvweABoH4m5PkE7zz9oD9gcQBY4hncA+ C9CAO7zHGAegZR5FyrxD3HAPEjDiDkCqYnEXI0WDGkN1jGEOAuVcq2D7D2+VhvzMor9NgzhdBkSU DQ/XKLKQGCSb06jnCh5AQ0rp7y0K9GpJLRtyXFIDc/mIVLyxYUowMxy+oe9P1UbgVT2AbBRZd3UZ vnLDBOx2GfIeD8miiNmBxliYhTyM+pX16V+sTvDEody8SZI8HKPwHJ7jQDhr2QT6Wa/oHmecLsLk 3w94ZREvMgeK9QZg1vxD4h1ewR9Ni4g7cpGRISTu9g+4B7kD3B0i5TMDtohDVNW75fLX7+vzhjyX xkMZiurHdLrEyUU6Dlzdd3cRaHIgKDgmjRzpuuuslGaNRq+MbfpJTFANBwRYWEAuwFNBcQxUPcBb ci4eQ/KCS9BRLgdCD5rVg7D+lV9l/MOy4eXKlxxA9aA3sAHd1U69xQ6i9x4F5xMacIWQB7wM3IHk BoXKAGRpO95h8gOyZB5Bkqdh+8XyVMk0+IWDEOlkU9QB61U1Cw6XD2D5p4Hdt7FPKSyH1AOFQ4w+ kLORbh8BzKnRmTwDSAZXqQ5hTRs60JCRkJsRiEXqDQ96A84XBiDY5LuB8H2h7Q6j81XRyD5rYOo+ QBmgmSHKBpDoCl3hMocqHaOtoeEOQdDzjmTam+D0hsFBNjtCh1OZTjDmHoHrDl6wJ4LTwUnaHUly nOLvqcAcgNLq7EOQbInYG4dAXhx6Q6OozhoThE1CG3aBg7L++stFSS1fifeGp7CGpuWBCsgoFYMg VlnElKjJDEkoSSW2MQu9mqIFmGkM4jDNezvUUnF0ZIcIb3k06PsDfBy6gxgoCSy0ZQpVKNRWW1ay IwoKW0ECyhQURAYUQqIMQKtoRkpba0lgiAMWpKA1KMUQBEK20TYZMD5zvZkDrZHX9O9jYmw31mzB cbqmGMmAFtytjlAr+2KXR26MzNSYpaU3HCpuVlmJYWpkxBCUwOMigEsrgqaZ+o3Y3QL7F5YpDY5n +nRmWQKHGY509nZyeW6X33VRdLdGZmkJhP+cBgM2qlzTF2rRl6PuBIMGRhGDJCDIpkiJGALGK535 fL7uG8BD333YYYXYSAd+6A0QnePgB0DOngC9OlDqoPMe8cA7VXhR9QBmDrDoH1KcyjzqOA+tecAu TgyhpUIGCGpNSPrA1j2C2T7wPUINkMDuGKcKVHwH6D6hMQxD0bnAurrIeBRvQnTaxtIWl15IX1dc bry8wbiiGj89NFNxIbCywiSagUlIkWEoqxUpMBkoqEmUGBYJEDkkKyCSsIKWVigtKkQJMAYKEIB2 EfxDpiFwXwPtUVQHLKKqAEPEO9+liIGK/HiDhh+2Ic+cNmcSnI34xudYNwG+B+gx00VU8v6PH43o /UBABP925+lXsOsQvQ6hXtHfXHzC61V7g4OE4VuCkB6gxHxDmvMYkMaj4oUXKNAPoBQgeCj5IbA9 ETAEQGA0kRnLRGwcrcqNlYIuZYLZg4WJcoChT9c7fIedfb0T+P2/il9XVd76bYFpbzVRgfI+Jo8Q uPJ/SwjFTn4EA6H7EwdFIpT39KrZtCs3fYT9oT5GuR8LUQ4EpzTBMIBkAZJ/WADsrIkT3EeDlSQY QYBGERCEAd2gM95sUdOgi7J++MLBxVphjPSo2dRVBxm/Y8Fn1hoaExCQIMDEITIcpQNCyB51HyTG CfJREWMIxRQArk6CjGSzntZbECEeraQr6xDgS/8Lhpi5glx/MnGtQKgI0N63R0yZra5PbAlVA5WH xeYyaMhKKtP9356aDRATKFUL9yZmozN61DVtJWRhsLTGGMm0Ec0DbmYXVhUmImm1pMgf6TNE1oLD bqREDGosDktxlKMI6ZsLPq0TGbANO8UIoCcQegdgcYBzJcbQieQHSJ0g8xBIGxFjgDEEfAIPYgcY H2BmDQHoOA0NyazBE3lSRA6FKWiI5+wXfTyLOp/ERfcmlrGimSLGIkAhIkWMVLLCxYCsUVBYRISf aepIFY8tn7wPFz+B/Qx/LQzyAp4dg/mHZLRhAMycihXIJxj7BLYZjVnzJqvbK+9COoN4D8Y4alMQ UkjIorIEiIPrSmkBYqCyAiDnDKglWVH2KgAcTY+gLkDgRRkRkRFkUhFICA/ewAOELChUILE7IpSj OEekFSgH6RbhTiQA4hOFh1CdirlCAcKdb7MagZ1UIP0e8E7Swci6BUOEDSKGkzo7nMhSoY1XUDgh uAiA4OOk3yIDESgo30IqAfzMIRgwIRJAPwQyJSBjgUUAJCUNyUHNSgoGyS4ugfMDcrTxoF55gchl GzAjExyRpISmqE5kCUSDOZwpQLR4h4IflPIl6mQIzCFU6wCs6GhS68RslJ5jtU5BUAAOoZii1hiJ 4AMBoO549/7an7ckBUAuZ1+Y/iHgfxpcGAbk928n3HCHLxBjTYl6jjHfS5Ih6D1iZ1DcQTMU1EQk RVSDIJIBCEiISDBVUvGCJSsgDqeMEM27pZCST1BrEM4daZBzBryEty11wu4dm67Fhs7cenJ9312L ho/Nz4C5xkiwMkPJxeR9ZgFtD6g0JBDbQiKQ4ba+YggE/9YRBhGUL4CTvcndppOMEhH7DLLWTLs7 /isoajjCD85H8PvA0cLQZAVQmGFZZohstOvw+6vv9+Yaj+krBj0WEKsBs/GQPx9qX7uIekZwnQDF GGRAYcdg0QHxnEg+jcoikWIjRDLWjGiEkxkwQ4Bg+50YeiZkvSFsbS2dZOke05zgRa2sBktUsGQQ yISYkx1kUGAg78XrgbOmAShpgGGDCBX/WL+V89x1yLQcIf81fjM2I+y3yHjSfXvlRJVgkoFGQFBv 5S3IkYjGMcNvXkXBDAEwQGhACCrZAyClnnqzf/aODI9pmyWQ+UJK08wSNSTTGYfuY016Ow+GHAb1 s1hhszYHf8f8h7/u9TTrijzhqZtZ6bt2ImsG83HmlOheOVBLOJbQD2kC9KRuQgGELGOy2Eblufd3 93Vk8fMthKOChWaIZmAiEiIEHEQ5uY7sa8TQ/mfFKP69B5+8cP3Oe4e4TtwoBYP7HAVih8cwCLHf re/p8QAoxIjMXBx/fJAhrC2nk4Lg1KwNCWItx3+FbJ4hwC+g+9+K+oA9iOMONfoHWGYZeJyfaHce 9uolXYJ7RX9DEANUwD4JyD+aa0PYlg0N6coWTYpzh+NDmA5OUHnB9FfcBuHXn9QkxYqc5y9c12Oz s7503Y5SQHAqnEQlesztWjsfqZp1NEX7UKGaEGg8FFIFlD3DRCgBJJshsHQtRwAzalQjk4F3EFFB ablSyhLlRsnIGwKDT4yCT/bFWokQVWCHzDyFJ/cD/P/2U4NFE/ahgo8KEBCiIPhGo7oHrHcGEQYD FhAYBPIaAPqyM+aLitXN86A3kPpvsCYnw4v+AgkNwevuEGCKIoqsFFGKKIqsixR/ZCWftk/SQ+PM CddCf9loxxKmWiZQzKW0wn68kZ/hPkIlDeXkM4hgq/aBQeCnUgZnOCHJBDS1Bsm42ZCSP58NGCW6 lNgxAzSOsLw9BDlz48BU0B2jSUmKfuimvjKdpYoPR3hyiQU75Jlvr2KeKWDI/VQbvTOliELy00Uk /CGILBYsE1/TZP3wyfmbVpATL+sz540o2wEr/3X9Ka/wh7lMGcJ/LDRowyGGGCEYXTf57Zwqb3xn 7b6w+2BPxn6Eu7SAbQ3IRRon4EeWGBKLuNPcX5LJ13toDYsQDcjIxDW3cZYWFLcDtuRtw3/yS4MM KDGLoOZ5jLeB2exAH2oEGDiDqDY74XB5NA2c4BxJ8UfuyD6cv5gdWZMQH8YigBrAAFuQOACUnEUf Czvicv3AHOgfEeHU31QSM1ZTsxBgIWg30sdiQNcp6qNGHlehpITGwwhKoqCyIqpEyQKAZCWEunCJ iQYBD2++gFWKCCzqYG8uT5DkA+4D8o/iD8Y2HiDI7db4JkV4lFADQNkT6kT+B3KIH4OwdfJHg6Bu P0qKfeNgfkGb5OzIB9yHGpkA81HQB6g8hzCaTlh9MUzcq/WKCddJpUvd2zjXmby16VHjDSnWGcQ1 qQMEyPUMoxkccuLFFFI1h7hE0QNg44BycgGB+R9ofABapqO+uddq8Q3B+IMY7EeROUdZsXzoOs2q OnpQSKRERhGRk/SDVGARAGRWMDMDuC2xG4OpONHsAv5BDAOwtkC06jONXPxo/tSnpfISQ43OeNoO SU2ROQpxhklOXWibOOMin77QV4K0lD2/aYREbjBJIpABh++E9gAzBEQUOyLQRqKUxcoBTBN+dHM/ V7rJxx9UL5IGLAsNgHwgXFgogAl5D1A2IKrVFlkD+WFmxlDOAeptoA9pcFQ8T1r2JgZEBP1EJAA+ hzJiCLNB8G5cXl+OFaf838dcLy7Wq0DEpjYqwIMFX/Dc3sWUDcgIUhIRxlBSJPZxLFIJGMpsrw0b JIGAFn0O95AVGntQMBFhiFVMyyJSwL/epoTFiMK03lMP7dDXSUdmv0Q0NT8t8f0i3IqQJ8lX9xmK SY2bhIwMx3CZ29dooDFFUBxh+YPQD4PMmZH1nkAaDaw0CdAHeukowH4A3hcGtAxH0HxTATouPk+p zvGnr9mfPsBhA/Fy02DVN2O/bppCbiAxRioKMiJwcchT8H0yfXxfTn2hDkSTOucQw9EOiyzSGHha 2l3OyTZOZQHeyk0Z1qybYVgd3MErS9CCjIAIbBjIkfQQ2ogDhkALREnOHUNlYl1C8knRrsZ0Twod WGhA7SaJr6U0YGs55oeyWCw8yzJ89dY+5YeJM4h7rE1o9HFEXTme1Y5hD2N4ZUsh2wwomEPQtGal /ss9uvbN8C0o9Wg9hxp0aAGMt+s4EOnof3T/09DwbMS+5APDeHJjVCR0W7McPgwcMQgVcESPnq3s DEP8EAiIfL4ZJFTXBbCSD0UMyHSQ2MIJopNmjFRkDkYMtvCudQULrAhFYyiUSEJCAwtMD1LIW3Sq dm7h9/JrXtm8AQWHLCB7TzeuZv0nJvN5yTCyWALCWNpRS2FJaVMJQCiAOBz4dYQ5QNsEVinOraWU G+t/ws3s4wRPhvM9h9kwRnoA+r1CG9BaIidHXxspWKREZlEcDmNsgqSHbMihghjG1MrBZ4rUCsbZ G5W0Hnm7Wa0gUvUxm3LTII3TJOSrnAs2DW1rLam8A0BrZ9BgQ1JTiAMZ7MEhRvds5OclCsWCUgGY kUnDsHIKwNehXotqQ5pZMOd5BGAZQfIfRLUx2RPKgvdo0IDTkfcH9gCas2bqMHKlJNhqsGAkOinp IchijgvNyRSZhXHe9RA/vnfmTg2YZYIOJWlt6klYEhK44qwMuISAXpGDeFeDgBlBkYD9RCPDdV1a hwizf0zpkXmVoPoBYgcUi6A1KyBjxhe7RijGR3TWFTlCsnTpjhycuhMsYsXxu2a1dQw+FN6vu5ms tcy6so3z11pEF9GLIaEA2HG4t1wbhA9HsC0Ln7ynMoDQJC0xJi/Ia6ufi3+MAQIQjksJJubEgmyk EgJCG2YSyhTJ9pv95/1vk/v+qmWWaJLlQXJUyHKTl2Lp3SVkxMCzATJQpirQKuv53RxV9vqvhP7P gcxn7ShRH4bLDSJNoSDFBefA/cUbJnXoaEuSTR5reFOokZEjCKwFgwMthA8ECkAijRc3LcgFwhRS WbIKAs6k1CxANlAsKkaBSB1zshhSSGcb35D0J9QfSnvDGj2i2SsaxX6Rn0gHoBtXaPbewiWELg3A 2VLp9YHwDWOQN8NSGrge8C9F8V8dm4XEgaRN5DhAsFwPNkE4wyuZ5QdwoJAAxAdi77zBoF6xxAQK HnXmNQcHAHM9IrvZO0kmXTRuhUbS0H8izJq1dVKhGQUUWPx+RVChB/VsODjSLEwpbiHI+QkkghoN hbcmgryfrfihmmYFFipm1+QWQvdQ0FcAaMCABoEM6FEAneQOVBNDoDrUmHBOYcHBIAakmpEbAMMY yAXTTbiwxCJQBhJAkwuzEYiSwDR2RwJgWL8xoggPXcmAbIROyySkpRnYUo25ZLoOGlGBBtBclVUc sQKKqoyNFKo4W2hIsIClIlpVYBBxplkKXUOZpHgwmpPQCUIQ0M1NgUhydWSb2UtLX1Qo8EPCBYIJ sBi6BR64mQfH47KKn8H4XWu1mTQI3E3w2IdwREwd+jIofDGBSZWNkhAgtiIEihcJ/LBBkERcuVgF KnIIdAQV0BmdiL0qUO8AFwcjbhGLxhdAnFUopPJ5lMFOXMHdjOQIQIEgEiGMliWiwgtECgYAJ3hv tBZCCxYhEgHoMCFJoAPmHwD3spYhsygpdvO7mvlx+YYsi4m8f9QIYM1aaCYMSWx6MuChMgpkNx+A h/aGhxmRZABPNYgdXFHUQ3vv8ugsCpbBpbD3BJMWZa+vYqRpvcS4LcpdaDuTKH3oKwJFZFAifFKB C0eZ5wZ7/rlBCFy3kUq+MCFmzBjCz2Q67x/bGH9tH70UxIxMz8bUWT7wJAMdco/vf67P91rWDkdR BDgR5EhJHpTm507LEB5UbtZMqa2iDRSqksf6izbjdklB9JOQv83qGdgcDP8F4Ca+DPsw/p58HB9M W0MJSHVC6LNFpN2VBCGiCSSSQkfyVYgC5BX6t8d9DseEO9X6we43w9FD6k+x4jxAONHEHtxBzKYx XIEFKJUQkAWMZFJCwW2/f6Y4BoMYqIgwWRRBQiyJ8LJKhEZ+6kqQ3LNB7Q+0QtekISIEvofXLSDj EpDjMsAf/2KL/RFHoIhaIJaKkjaCi2iKBo0dzY6EILvz6CflE7Nt5VxDNRUOoqS+5q46ETnkBAEC /q64etl50janSZbmLx2eE99Xm8OcGleA3xfXYT+VtPAvvLrxewLB8by64cgvFAHAOFPrHFlIIcpz FkCgROyIL341DLiuSvFJaTEulFn1IsNCqnMuqAsE3zlPCiBQUXIiXRGPHzUk4KLk/KJQOvjrvyBx 28Fa3udzAtGVpUu+LIaY4E+olA8wbTtK6pZiUVmWKLQchYWIkiEWDHK2U0SlTQCTJjKEQ9SfjPix adDSZksfY8nPUnjQUYhKPAFfvTUcb+D7g2AXJYPrAPsAPcP4uEXOoVBfeeoK063X+C3IqtzvrvJw cY5ADBELp60u6RIECMJBDspASMAiMAZAD8Io2ghUkGwc4jkE415nGmwYCjcHDjzFirFJZAhrA1W/ AiIIBGCUK7yKqSCqp6jGeAGk0I+viMj8B+IhrHpV+SGU2va/IA5g15guZIyEGSAsEUixUgIjGB8f eNCAfWM9AONGovNjF8cR7XBETawBDcBhQhGCocJBQDzxfmQFQDoDBVLSLEQvYAZLFAO+l/VZIugr hgnJV1mqS4tUHgKgUQAy0bSBcXtdw8Yn0BfxjwmxIRIQCgBXPJRQA1NHQD6vyDzH/ovRE7BzX2J8 k1BRwBOyFHwho8gZAdFdW3MM29ARMZSJiPATIpqV5w50PcOMVzK84uLM25Sh4Q2Ke5Mg6wLw8kKO GB3gGYT5p8QlVoe0z8ZQyYxHSgMbQwh9YjxrwLxq7DNGj5EJ7G2+R6x9QbQA/JAQfCAIA/xf0/s/ 5C/o/2/8szNBq0HLmbm5p3c+/Iksg2boa6eW7qXmKK2bEjhAgQP4Ekf3CP5AfyA/uD2faSSBIE8O 7lQ9omQMoF+pdAYl303AZgelTOI9ivCHiIwDkHxeAQ7hxBnDfcqnuAPWI8Y8gBlAsml3g8Ag9Fhx PFrHOHgqcg0o7BgWWg2ruEQskEBOh9g9KB4oGMcwPCgCnYEVBEDG5xPQOUuFAAb+cFU/mN9sntec DAMdwvviTnDfs+oMBRfYHAB2ChsSIihLqCiO+BPHtUoE8IJhFEOJOMQthvreN5CEEIJAwA3C5AIq IXPOB4qcIXAqGtO8AoAKVdAQ5A3hOQeVzpFzgdFdk78/RAVzFKL6Nk4RPRBMxu+p+3IcRD7Q0eQf qFF17ob3UcSf4NzKCMOiAPA96MAICRuHwJ0EWoKuKKZi8uDu2PUBt7lzTqf5SSbgBA4DyiIdABM4 fDjfZ7vdcWMiAqAQqIXXvOkD78QN5AgZESq3NI9gevZCSQmgeYTcdodqjvpxveEA1bwk9B5LaB9Q cyOMMQXvvJP8viXDAdxQ3XySG5RVAdg+KZBD/feh2+uK9J7PNAeIOhOZS9dyJyidIRGwxeUGy/AC oQ15n3UKoSDGwdwfrdLIohdICF6/7YLIvtU6AuMsYHPQhw+ifFR0ghVpEG9GLziEIQHIewPYNlPB 4iTQJk9aHqDSGOMgSKboRIh4wSzDYNwcAUSC0hFC6t8tS9q69OPME2DrFrrVPuFDbkdw0g1EJIBk M4aVgGwEyDqJx+cJJDyWy8wby6XhF5Q5FcYd6mR4Fzg6j5B4FTFFNwfoGInkGVQqvIAZB8hsCG8G NcaKfAaB0C2Cn6EWb4GMfcJyuYGQX4kzVYn27Xn67/f47YGExrhW2N8a4XiUQ1MN8UNLvTS9fwRB jt2MNMxdSYGiIfofC/eHSB1rZDexOhQ1pqA3IA8goJxjcJtDSGoOIQ6zaoZADtU43IHEsOEDHlUz igPzvL13JtFzB7RC4OdTGlB3iciLqHWHWpvAdYeQ5A53M4AeQnEPObVOQPMHaPWFg6TSjpUB4A5A 6Bsj3nu86xDP5PvuPfqE/hf5noRFIrulZjMyyEYTI5aL7Ahb8t9h3jcGlU7guQ3hF8yc57FLBv+5 VeiARjyLuZtAshYCKQCi0aMYxUiMY6AbmrgOhHzDjHkESs6vrGj1cweivqAxvE7NJlDnse4opqFH GUVG1abUELEIkbMA9As3BAIIbQDtAvUxFVFVIlwLwfIC43Qpe/mD5roofoDrBwAe58HeF5hQ8njH vTOLnA9B5XqfcO+BqAypuETlc4aw4TqnbAqJuYCahVQ+siBrQIiMBasnYAA/QQQG4mySSwA1OE0g siw6ej+i0lYsKiCCMEGRf2miCfuJYLEG/8yl3qB/dExSU/owNooo63mXMxKKDaW2WWlo0c7oLMKU RhpHJL/VEKbmt6yJc/uUaBIYT/hywvaD15FgpBcxcoWnmGUMSpbQoqjCNbJINZ/s78/0JTe4EmHa sFyBFjagIB0IcZzBY/qveE+OMovOPGIoCYDzh5DYVPmJ0g9YpcnaHanh9y9afc+a+i8YP2jxinsA wR+AWD2OMUB96EUVQH1vxD7QOJDgBvC5Dk9sFiQEkHynnQlH+EP2T2w/xnlgBXPByMLILs3O+oUB xx/EGB5F/1HF9cn2dUZJJC8LvsUn2jtDvC5zBk2IeY2TmE8w+0Q6h+wwcHjQi5F/EG8J4/iDkEPY P3hsH0H1virxudDgPUNwO4auDqCw7jOH1BkDZAekMQG8nrWhxDuFcruCwLlTfyTbrKkIyASSRJzU EW0LKT8UYjJhilBEbEsILIxCUQoPXRhYRLon0KX0pzYUJIYm562FhAEQPv/yfh+M/v/T+rBlm8iS 2HUuQcpMGRUzOYsc1lYJbn5MBiXM3aEJIOxYLGsbIom1OhRRAAYisYiB8qWIxIkQgx0bkOIb0xD7 gc74GYV0hDtCC6g1Bugng+1+ie5PkNh8xx1Dyfkh4C6nyCyXETsDtQ3LgucNQvODmQuS2bQGAHgP v3x9h5IpUHRDup6I1D1KtkMAoFnN5zjzG/BkaNAwRixElzEpgEIghBGimkHmA6F+v8gaQdqPULlG dGR8TMBroNjyvxTiBzjgGoDGHSPiBjC4ecbg7QNprQxC+CmGx+SXzjqYI74CbYwUJOAv3hcw/ANx D6jgOar6iJ1EMzNxCgBlNSIPxkiEkhH9kp3kjP6qeFA3DmXkHUm8GAc59MZ2P1BnAOaCUhN6v4p/ FBukMnwp5bWa6SzNYZsaICpk/Vhv2ShsQWLEQQpecTg1A0DDUxMCtUiRpTGBVVCSUWD91wnmoQf1 QZHAEj/HFM3/znta1DZidZteB6QDSnMtLgCZhIX9nKnKhOAF1gUOVRzqHrD4gfh1h00Adj9QIeoM BaMg+4eEPkO8i6EC0D1JqUpD5jDMJ5nzBoMXCQHQqRThAYpgsE1hxv8ZPcDwAcukA2Im0A1PMAYK NgdYXh8g0pkQyBtU+gDgsJvPC2DkHgD3h7+cff+ntdS9/S5ADEJvBwj9TQHYG+8IGB9ghNo5BE7g OsELz3qmMEPpXmHcrZOd7hPkHiHEGwOkOhfFT29z3V5YXAXRghcHpIQ/V4JgH8M17nBo51bh/Nrk 0GrDiZo93e0QYaFAVS2yfmPX559CM95x+jAzK2rUfaxE0Jn/MV1C+NTZqpldZQLF8t41DB0Z/Wif z16PNd2fbGQkJCEccEoiuQU5eXg3ct3t6O215fBbUkYcSJlK6kXefuysrZowQSScKgXKgarVramG BjlhhMTKWK1rj56Eip5AesAP5/2h7gNYbwNweAB9+wcY9g3+8DWnmG+GkDfDgQ3GM4k81aMoZg9N Q4DgGdxpcr1D6wMqahT3rtEyDwPrXU97lMhkTlDaFgCyO8HqD4t24bBgF5/MKdrB/fVPwEpXHBHt DTGyQRLAP0AYg/QD5j8RPA+BOgdvkemu0oYtrf7/v8g0CCPtvcEoQoGlHxa4BzpxrZChDQHxRTmD AEL/MhCE+IeA9J3o3v9boDsPoDxAc4ZgzhrdAcyexNYd+8O9FU8RE9EiPsU2pZDjDyofQW/AO82p 9VMxeEsIn5r3Xoh0Q5E7AQqRMXUKdyuMM4OMNoGc4QNa+wOfOI+KGJNxyYxU1ZRyiHrRNXQmtOIT 0ENoC7ziUBD6jDIdigmoB+I2zHgR1edoyEPsA3w7A1rQHSHEHK4weQTWG4Nw4TGM93y+r1KfJ/TW +OIPcusNCm8BzCHSHMm+PekR3dooV+DZU9Vg3RTIJIQCEiLDf4DJIWR6BfIHQBYAVF8xgu8grB83 vCgHQPcpmUhqUyD5iYdABldip5IpxBjaHrDE+ap3lwOdTSgep7g7hPItx6y0tmkPdBk/AQR0fiN2 fjN02JRmwu7QwQkWYj3B1v0xsFgMcgkEJVPrMhlxh9GMoS4nAVsbmoJBsykNhQNnwMICCFQYLMg5 W9D22rOCBS+Ngyah/kvh7lzuK4hGl2iqsN2aw9tGzKNpT38LnIUB3mmcxu6uof/XWJ7FugntxTe7 nce2GkaNX3Af8fIb+RQ1jDD5PyYa2fy/1pu+U65OqYZ03LrWJlm30cnDaGyNH0mk+Sb3tmWHJrNB olCgD+jT35fh/D+H+n+3/BeXqYITvZ2qtFJFNNq6453bP+bWOnGKEwSoo0KHsmRRW4uXXVDMXl1t OchxU+eumpagusKqmYPN335BYc606w5ADOJv7HYPc5FDxA5RQ1IGYfUcCLrH9bh3c3ZTjpuPo/oF hPtUPYH5Ceh1CiHdPkFBclBc+1U9YYnBfQdgGCpmN20Pk7UOgQoOQOQROhM2U5wMQDnU3kXlVM2c 7IZoVXVDtbFxML6v7Qy9vUJoL3pLKFiwNjGGCFlDKyCdg9ohtCL5D6+oHE3pqHiC5OD2h0I3LQHG IZx5VMSe0eQHrDv4xdg8QPABsBDWuNTYmsG/hkRfqHle5bJjOIDapxCpFIFg4QV1p4odQ8145A4w 5xzDxGUOwO5A4E4UDvE3h6hMoDvjSAcpz3o0HcnABvqOZPAPFDGunYJqDMHMFJiDSgby2E7RzBwn EGAeIG1caiQQANwGxV+XOKHX5ugTWsBgga1SBcGcXoE8AdN6dKnQ8DsROgHuE5hDzCwdCYRkk3Be i8gZgcgGkzh3B39Qax5xI0Gh5Q4V2CHcvaPIJsEKFMA2DQHCHIR5/X9vf7H76YVk26y7U1mje/z6 TTwi6YQ0hUJyomDAw4KQsOOC3TqE43d1peuFpjfGXhjTHClMMMMkLodFD6Ds/ehyvzdLwdC9JpDA OQNYVtAzBu7l0IHI60DUHSHAs3Yy56RDuDjzAcYUHUG4NY9IOpQuDJ1BiHfANwkCIaR6w7xeAbGc Os4wDSIfcD9OCgUD9LYEguHuFEkL6iBlwDaaRBF7S6ESEGEKOJOE4B70naB1Ac6HGHAnKGpR2jjD dYNGfEmxN9NAHGG5PFT4h7lxLJYPAlFeQfaBwIfUO4iUTnVdiKZFzKb3M2A6gDEroUO14eRTWB2j nDIA7VHlU4w4TvQ1ABoTSvGLmTrVfQPmFxXzT1sQJce4wcVOqWT6puKCeQVDgO4aj0GwlRIvd9ge 72piHYDw0GweY4AOSHdzEMQNB9a+sbqfap5LkTeAygbcYAWD7z3zu/hQB+Ko/1gH9GBeRCRAWC3/ 8JQf4IFH8FIlorYKNJA/mkP1F/394ZEtJG0C+zPX2lXtiwjaEtohQkpI2tKlRE1ajjRFBSqZQVVS VClFoFuF0YN6LvQahg/Vzn+ngmocDBgif+ZigrJMprIuMfEqB9lvvwDIYPf///7////V/////MJp /cA+7Xwcbco9DA3uZc20oAASN3h322++8D19O7Uq+2PbLT3wAAA9x77mu2aofJufUcOvqC5TaDsA 99UOXdxdVIgUUfQBuAAAe+MAAAd4LPNANfHlmS3ou7jfXPu3eMG9g7zFVQJ7BkC9gyEQFt9Ped7C lKHu+gPsUjkqD3z73g9BBB6AVewN2ATsDEF1hZ7ANAd4Dw9cqug7tQaHiBbDd25UkbaiE9jLc4Uq VLAHg68k85gbMClSCztxdBprbGbV57dPQA8B76fe+PtvQbY0oCipaHuyZm67trQWt996uD0Gg4Df A8iei1iQdcu6ys7OKchaFNIAA8A8LPN2vedIVrPgBPcxfbK+1BIS0O7FUHszgbg87aj1a3rbBdup yve70eKtHuygPQacBweEqOgXe5yl7AaDQA3sA6KMdHAx2bUqEoKA8kdG2xSVKUA8A174NwDO+POA DoKNsAFaUWLJK2sSAAtc98BQrQNMtGtbve9u7qXB1PsNWsO+r4p7YAbsBMsoe2b2x9ADztPp0FKA A+2vWFPbScA+AAAAAAAHgZohd8+1K0Gg+uintr29BNm87sAHvFy+96u3301gV7ah6Gnvl3fd3Sz4 3Hs9zYH3tsz7uuc4Z0u099CWbNDbaUq6MFLZ9gAPQGlBX0F1gSANAAA6ONmjQOgAO3cAB12wE7Ak BroDnbQAGHe94KSAB4bDN3vA9AXsGtA5AADQaAA53bh00yWwa0a4OruNYtYg1TVwDuHVWsKWy2NA 6AAAEg0OQN2B0AkAAc73AAHewAoaIAACBAAoE1Ewo9TTIMJoBoAaZNGg0CGECJERATamJ6ioNDQA 0AA0AAAGmgCQIgEEyaEwRppT0nqaA0NPU0AAAAJNFJCE1MTRNPITTCmU3op6mQAZANAaAAAEUiAE AAABNBBNJpAqfmgEp5qMoxAbU8oIogEBBCQQm0ZI0NTNTRJ6nsqPU8R5KPUeUaAGjTqEgGNr/t/v /y3mEVyGqDD/578AXnVHfp1jJLDtiJVSb7LvGgzGUCzjKicx1mMmQow3DxCzhx7UsZzIqbFgs83B jKi6bKoGZaLOS1rjVCzGTcvj3kzbZBMPEBzDQ7CFiFiAs0Gt3aHd7ZQ4WARCzUXcKVi6UFTLLNmi pdcWS7yZlZZXfAwaqc2ZCyr1bkxLRjU7CsLB1FsS5YQr47KJx6rMyTK3bTAlqLVIyncF4hXphc0G GCpabq1pYDROUs4tsDFmw70tZcRWK2SLu7p4UGYbMLGTLuZssYlYmFmneKetKGom1MxOwn8EFAp/ 3iuKSf6f9f+//5/7nP/1Ptuf9v+/GMBOKdMmP+4/tH9gkP/f/pn9i/7v78wGSIgQBWygh/eHoA7r 7YY9iPFz4x8zQVYZlEF/nDWJa2ebEU0i6H5/w/+fev+AT4+/2P7evPj+49/wP06L5q89qY/+HSpr Ev/0Y/yO877LgdAiREb4eDE4xGK9fTjEIfUyQ8MCH75CAEPrA/ev22sgbMCutBEi/rNZgSLljLxA JRAqpVVhViFFFmk05wnEERSfcw4kySnGfdyHIqooMeNnCxSVVL2t36+WZ4Ira5dtLKwwxEADAiAj uCiMAqCQaYIZFQ1AoNScUECaX/LX5b2mm8Tq81j907CoMWxnU3ttmuMRJWJtUyu4RCHEDDCmYBmA KeUA99PXNPXhgS8iBCh3F9EXQpZi54MzEDpCHGKZnwezDt2LztSZOnj4fh46z1QQaryl0SDplrVo zURUuHVZcqsWymaWXhhRVVeVyZaWCoMFqg1S5azVu62zQLUXKpopO7kJfF8PZh2eMnaM80L3vn5c MTc7TZJBCkYQNLjIDcQaeVjVCIWKjC+EVK1Zy4dWsuWl3iFl1EEYIWXWH09utmFpg0zLKH0tth0M UWYIqxavF1BCxNQNaZAlECmETkmVMRKGm2U4iG6f9XWgRRf9spqjSeJcDrGPDJDGXt27vBmWEDwb wFh28Vx7YyuNDWQrkAkIVAUFHIDMonINSHIwSsi4EGpqEJgwIhDcmmkwxBpUt4JM2ILLJogwTTCi sSyMYJUmVlYme6IiBsYRbaFWkxMqMIiFQFrDKyJXtqbrzvdH184dKyCsFUnOB5gn4+38T9H1fH07 Pw/+HXv9qqqsBQUFRUBVFVQBIooqjICCqKqxiorICIsgixgsAUWDCIrAigKCwRgJEWAjARAFkFkY wVQESIqInzB7U9pArEEiyehVbEWapEY5S8cquyHevPz4FIhvQlBCncYiAlAEQCQlopCj/w1BzWnZ tFf/SHtD7gUR/hI+lP/VQge/QtlsRTqvNfQI+hI8D8T+yK2e2/czMqQvuVG/cqifwbXh/ENIwlQO jA33kfnTCXg4P1d/b/mP/6So/05CHONsMR+MNJ/A/6U21RiqpooKgarT/fyR/yCK77P9Zy9ICq4A ApLq5odX5NBR/cgC/sfvT+v3p+/9YeZH8KeaFfxiQXgVLyBFAPFW8RH8QwY5Xft1479lC9eW77o4 e4EJKrIjC1AYKLFGSLFAIyCLCCkiAigqEERAEQIQwhi78u//GW/FGjIX/RGfPIyEywn4FX8NGV/T f08s2zhtbQ27K0gKIO5FmHeLO8h1fh47d+/knRynMUqWTxULHsu8cgy50G3IDATQVBgWFCyHDLbI opgyWpUPSgjHLB7mxCvmRlzNtCsXcLL3kMQ62GUi4hXjdTjxrRXy1NvI3e7eXVfDd5a4o3XrHd3E WVtl/DcBEp7FpjFsyGjWxcm5CilcOSwi4nZqeFsK7V1+nBRsN7U6Fyq4dir7iViQ9RDxVFGl6Vk2 hQZDu9LUeQ+PLUmVZYFVa1w7TD1Uu60yksWNh1FzTiAWMVtjyFhGdmDwRcPQMChAlg0VLIOOkAGC jK6m9ogSZUxOaBGhjyUFQGUKjFirldlenaTplXyGg20CbclgQcLli9rq9Vdo00rPinA2ZYgtL44J mGcPBi7bBC1YWrWLVMGQ1GSTdNIOKxhwRfmVtYgKMCkiHO/AA31JUVm+OdUiB1eGD0Y/vKx2EYKe xhnh6IbgK00Gh1XFRmC4+yqpXRejWlZpt6Ip6ijJEnFcs0hsLKMEZcpQdHWYgQCCRSrZCyzQ9ur4 Lt0cSfBXAcIShlmSJIL4wx8rirugZd62tVltOHMaaFAdwVphFFXIh4eSkKQVuFN2JSVacyw13FLA UKkKpItVDy6oFV4iGNMotXhmcEkGTSgMGICoylVerMuuHHeqKiZV8aLYCd+0YkrKPHv447rHV26L XyebQwV71ll+lPBMFROeZg7bhwc8jEd5wuWXpm08Oj5CimdmWSjaulfGUQhw41vLSYyaLKHouRDO zm5oMMoSKFqivdBKR0KgqxUTCh8g48ZDFFN4AroNphtRqgrhQQilAfLliooLIwii9iUEs3sZy4k6 fv/Lz7kFXTdZBySGHdcf2j/0BRH+PH93P7dgnUH87+QUR37Oq5x5/rte9/Q0AxJx+fYlqPvJElqT cdv2tx+mU/m85jBEgMPBLMiNyFkBYAfUL07gQEHHp0S1T0uMCGqGGTOEHrnAcYYIA5qCS6g0GBAS iVOSQlUzCj120haU5oCayBFAftDnNNH1ywWcR/xBKGkGihjnjks3PGnXEL/k4KrNN0y2hf059jTy X1uPP6QwstpfYUN22uxyN4iDW28OX7svkYGGEk4Ppj/nVOZfNvu41j03yeX64qy8v6aGT0gG3Pkq uR+6DCAwfoK/jChA6iAQgaSgPCIsCLgvgDJMC9DxgPB/lw7iRx7Vme7zRgUcemztz+DXNKDX2k6Q g1obP4AuCBmp90nzX8/4H7pWWVMJgBkMF6n4+bvf2fL7ns89xR3Y/7n90696fVjU30xp4P5X5cMX TMYTjRtoMh+x+D1NyhZ386qW8y7SyhywDbBSwzJoQlP06o2giRO2uiJhdUIBz6Y/+rjocQ66UCKf TZLWkIGD4a+G7rrIFJQh7AuM7TKjNAW80SINBJahFlKUgGFauetHhCP4F8uodd4JbYJNKBcwr+Tq FisPpcAnkCIECdYfwH2eexkKabf1zXPl6zFlzKilSeKmXJfcGHWIBBocO0b+tfsDYbLpKG0QgJqd y8Pcjiqu8YfQ+QkR7IwKQo3VSI4mUiusPFOA8JUBqDYp0ksSv71do6ML7y2uYGzkABXDCfp7G13Y WyI6Kq69K+hyoAYJCLiD5BSIhCvy0uD3iHJtaqQ8wyl+KrIH/EgNL7O51cxS3zaooibQavf8eR4/ TuMmf7zinqADrinZ9qZIDsXQ16QufAm/+I+qyZ2QagiqLDsVgloUJ/8kYEBTqgF52uKoqFcnJYEr KcUBfoIf5clgUHczcsXSIoexEyzl+btZbjK7rKvzZhPDYCiNiqdSiimJ5iebGEP6H6EOA6rzg7J1 t8/vWq4u1EQlR89L8128wwmM+2UnqRTxOnaAv1QOQJiBZs0ofMgEEoUW01qFzDzd6zoyRAsY+MGJ IxB8ewoG+wNl+hoEa5278b1bKtheM5LcbDA0dWaLPMN7iiGH2rztPU6tmaNoAOWxzQiINzqO/3K0 Xs4KYf/mCIFAd/2u3/Au/n1oqwXtqy6qg9ltpCt7KPe3O/vhLf/koUQ+Eb/GZJyGU0doPTD4gICD T3cHEnwhD7IF0atJ93OfZoPHNIYYwttxFmqsdyfsARAgTJgfovL1QOD2LsNvhpIBx//DdWsgX9+m X8/EH3cMosY/0wFVV3O+hzGnO7mviXWamGYjTlizB/zsLoKb8Sx7/d+VdW66NB0ndGxqkgBBgw5A ofTz8AG1pKYi4H7qbzWFmRs6Hs7BK8GGGTBhhoaCPrb1mj+yQMBfiJBq2HmNZ4dbDSeI94YMOASV NkQZOwX2FMNu2TDY/GccDYZgmEFAqrfEBDtCEIBRGBVGEVUgRS1an+G+amokC81wV9AdEkEeDGJW 0a8WMuAYDBxqHiS/ucmmfl+Xj5XwKth5ADPgOB7gGEfpSixDMDs+1BdlDgkj5HeFsD4KHdfvBUrR X0PxcPelWgn1QCob3p+o5C5LFxcxNSoJLiw0M1rMjbV8xERHA7B4PoKLUN/aIiVprbFDs9/p5gsM GEjMW+a5jg5j5etXOoYP8/+WzP2V5q4DlQGzt2m79KLM2mGC4So+Q9Z0rU4GMu/RQR9oRCQg7jCk vQJJA/UM3WqLadsKtRokAFUDK/Zovaok++O24oy4NN+OCjldbsi7oiInQIgiIgVRRRVUVVVVVVFV VVVVVBRVVRVVVVRVUVVVVVYqqqqqqqqqqqgqqCqoKqqCqqqKqqqqqqqqqqqqoqgKqiqoqqqqqiqq iqKooqqqqqqqqqqiiiiijFRRFRRRRRRRRRRRRioiKIiiCiiqKKKqiqsVRVVVVVFUUUVVVViiiiii iiqKKKqiqKsUUUUUVRRRRViqoooooooqiiiiiiiiiqKKKKsUUUUVVUUUUUUUUVRVVVFFVRRRRRRR RVVYoooooooqqKsUUUUUUVViiiiiqKoqMVRRRRRUUYoooooqKKiqKKKiKiKKjFFFFFRVYooooqKi orFVVirFFFUUVGKoooqMUUUVGKKKKjFUUUVFFFFGKKsUUVRURVVm9npX/So2Dov2hCNyPUwTwNVK /WZaVBQdvT03GS81APcLzDHxje0HGGjJw3oFUY3rM3GbzDf9KA6ywhc0ex3jig2biEmtuoOCItQw NgjmmjI9uJCIwkGiEF5/K0xZxssUWYFHG2Sgk7DjRA/hBxgxeLwrVf83VC37zA/X8v4jFCxT44tT 8eSTrb4zSv/N/IRETf8a7wzF3768lh5jxgnNJGvUzX63BtcHaAjKucKejpeu1zusftuPFxONTw3x 4ew+/G4jQVsZ3kbGRHxJu/A3C8fT+K4nj48NWyzsRtABKO68yFbfjlUk/Fd89oBxRIil/K8+9bdb anMdX+rTpx9gFEZl/oj58TN/gocRT93kOXuOxcbG2aXdwyPShk+Y/wJTICaCmB7vAKwutcECUnp0 azS7qbSh2/lZKNcarGIiTqm+Y+wTEGKSItFSUkqT91VRfJAI5deWjc/hExWUKhQAhCPfr7JcTCD5 pjdohPRl5F6kMSUFEWFcT+YYdhE+4F/If2DNjXiMQVtg/jeyD8V+mwZg/df5DZIwcR9rIAe6mVKt 9UwNqLj9Oz1mCQYCP5Hoo5D0BshvHgpKUPK/DIT5HZdoGE/TSiQ6ZsRl6vkjx8l+T6sdoocEfQ0u /dDdIXR0xcNL7EgR/f/X9vX9COnX+n+j+lrFvCkOUsU6vEBv2w9rkvElKx7i6YlnZxmAnKpwzSJu 5OJgwY0y9ZJYFi5mMDGniXnJmcKmczHi7k3TPZtXq5l7pZrFuFmhEK0U5m2V1yDFUxfDF4GwlVW4 l1D4Ga0tSXq5sRhmcmSmRZRQSiyjMhto/r/+tdf8dLbVVfOv5n0/59a/7+GOtVT+W2q/Fbn72Kps nJRK9XyVZ6Lv96wAw1e2WrHn+bARO3w18W+PPwVlJ+rzUXRdrFVUy/Z8VstjazEwC9uRa3d1NY7w f9NXmNS6MaLO16qI02JTTU4uNNDTQtcQREATliGf3tD7r08a99Y7CkeWZcqcac+fhXeOHj/Zn/3f 6wUR8gojc8I9puUeiPw9o2t5vFvsmFlPuW60oYMDQAowELCBCZRCy9QPEYBbss61kYYYWdSLJg60 kG2LhVIiIFgISylkuh1UT+KR/Vxv55unE5rxFpaW3xAgegQncJOhJIB5zt9NKkUfha9fhTq/i7J0 yOsrFLc4qFVgKa1/yXtw5hQKxnZ8dr0fDv5duvs7/N9YHZmXvq2iaLuF3fY5BmCFUKubxE5VKYls 2aUMqmoZy6sqstlA9qHsKJhQoKYZKgOoaSrsouVkMz1UPkONrEkXCgUqh1IFQ73GsV9TDXSDCxch SjqohzRqlsmlYvAhWY8nrc2H5OPzGy+yfg4NsKn8bCBvnz1NaZuWyDWUNDP3UXflofIuzE4zxlxy 8RxujlyYWdl3u9Xw66gcVgRrZid8sNXtHJ0NTx0i0zSIvBeM5rDa2EUIlbwZKQXKkDXC0bOHR3PR 5PR2O5J1ipJUkoN3PZw9RrLttki1PO3Nomm1fa6N2jOtwedSzZQXTDJZJRdYB3lM8xvOgl6l5RHT PJPOaZxRtrLKIvyG4tntw78tKLYc3ze7DKufKrYM2MZZUxOqziD2Nxq2jo7tMTW8Kc4xEPvCIh3d WYxdmd8XVsbRkdchm5bkvzLGc5vudcvjV7PZH5tg+z2OP0Sej0er62HSmpdRbD5F9NSfcUA/CVAJ Rj2ZnpKJLaHZlYLPrR7WRVh1yh2VqBx5q1vTx7dWGekKXjjJxlQFf3KpAIpRVKEYu6oBJiWVkFFB NO0EJusnPLerC6vKsmdy8TMOPZrIcZ5avaleMPLvZyM7sprnp3KVDxaZ417c9E7c39W+fVD66k7X 5dUgYS92wrLabxc5mq+K2sVjPzV7E7HdnYm5IMrx5WtNVqdGdjMc7N0+9a66l4C4bc1XIW202vNn tUGISmi3Ns+Zmmzu0Kg1ByztfLOkJQSa5nUXVVZLotLZKfW65Y7NsWd9TT5VctN8zw3RAlrpnW14 LPZbTdUq70LzRupkelyqZN1nLPg2xa+Y43JmqG97By2pDYGsPw86rO5GqmmZecxZpkNmsbRdRZbJ CG1sbIEREQ5gfy3+vyHI5oXT68/rvL6isaeNJudy69ersL7/VHT614f98zvXsDMGhB+Te/Q3Dn4m W70VX5mae4ZZWVhSbcKtxIaMyVlRCvlucMsr4Fu1elZzmTLqtOVxrq4uZOZkrZWheO9VLmrd5i2V YyJBuSuCrkO+LFXSsrLDMs2MnHZWxpzKqzWLczZMLMVivWUsQ1TUkPcrFWwciqfLC2We7kOmB4tR NhXhaXMl2vC93hubmVdUc2SrzVNjxOWqxOPIhYYO7M0xgJgvBelZWdsWKXBgFrdSsjLjA6zQq4qF upFuFOZAmHFWymZdiHWsrK2i5qs2rS966y/u/3qoKH9kCKIn4/thH198phvxZoz7KhJQuIFEam1C BBOyKqQqInCio8wkEIqIhECICRCiMB/tDUaBU2kCFaMAKHLvIiE7Lgqh0cCgLYv+zWCGp3NKzNq0 pSK1KNUtEVZsNDZEPVyIN1UPW7BpooGGLOwtICJWEoiEJ6FSzpdxCblFuI0blygaEIQHAVCyXQ/1 eCAOURRhJEgRAq7T8yUFf1BfsfZYb/sbzPn/DEVOW8fvPb9U24aT6iDGBqZoWFSqJBAqEOE2BgSp Nj5BCh6/MgyR8q11KwLn7f/Cofn391uIsHnyeqCB/pH/aGYD/pATEQh/rPxA87WPZElEFEAJ6dEl /YOoYj+XqrfX7NDBXG9vaF8CNpAXwi+xyM2BZeT1QM4nD/ZAyKOk72JV/TZjzYjbG4BIIUbLFfAY gAhEgPxoWCyP+JG78D8fzywZb/xjbChkAO/1/8OPsbAfZyDioJQEb8frX9wwv5h9ezxFA5A3D9Po /0qv9Im5H7ZRFkGgnvCjfhLAoPCOrJ9JRQb9xx0nRAPyRHRDmf/QyTbr3ov80+VgBBYWE/kjyv+Q n+xD5GqXXCysr5X/akJK0CQUP5/tNKWcBkJ3D+oD9htf7Q8YY6AmDQn5gqdr+i4XlMpIZTx/vymj w9rc5a800plOoCmYgAID5JJogQU/cFShJJCVJSZJEGIEFkGVkUlZZEVZQJGUkGEH+aQgyMJAQIMI QKDDOQsgIBE+D3Z0UAJKBBBSIFBA3hpP7AFEhgETEM13rrWRJdwiQDlApWtSSVGzUOjXctacQuSw SEtWr70KoUSVlRBarcopwv4LylglNJK4EhJU2ZWyYQKCUHKUCEqDhcrVNLlISiUFqmksuVyBIuV0 mU0tRqllyLdarK0F/IarVdl2FAWE2SEukpstFNBVaLcSyUW6Sl1hKLccLZP8aAYHKXMrVZFAWE3T 9SGa4LCSSQUrahUNC7xPCXBUkwrSMjddkZS6hCW4UCxCfp94BuAVSyQBK9pRdJC1XShyn+pIQwQk IPKWThOQXCkoQlklapylEJQiIgiIiCGIi5IW5KExiv3QOQBQl6XLcF6ZAqlkoKyGjdDdLpROAanS 2SUuuVuJRMLfZIBhZKpsmF0kJUSiaXS6XCQsrK3SyaDKUTZJQ0WT7+4Hyk85KtWrba21o08wgHeQ nsPQn7bFV5SFJW6blVulUyu6XS6QBoTKVAJFKgcgQlQCwEJAytF+MH7wfpmqZF2Tdd1/OQfn5lJA MgXT7HSmkovpMIA+Vwm6XW6SFUsJCcJ4X9gKI+lkIDC6HczsIQp8oqpslVulk3XCZT4E/Eke9kkW ybIHAErucLZdlA+rCBdKJZOwTNR6TpdkgquUJNkqugKJY0lkwmluml0tUumElZHQEDI3LC6Sg2Si /2fZVuNU3S9acNtC3r7P/Bc0F6ZOH9+SU/W7fRsw1f4ctG+XDFb8beuSfDjp0Vxp0zPp9lfjyOf1 6doSzp3snG3aVcnZHmqHbDHbM9uvH7dM6sRbTWEuW/nQ9+0kfeaEL9bIpZ2PF216crZ7H6Y1a3fu zjx079uZ37bWTucfEfHHX8JFRQVFh1Cdx5DewHcJHA5jqO48BIiFDYdRyFAjHeny7XKT390+Z8e6 +ZP89Vabx3xbzNQ5y3o70ufhPOs/enrbn427eJwjp44ntN/raVtpaSZR8ffJ+/G1E+b+bR05cpcv bK1466eOlt9YP7ds9pe8Q2SzZMOXmzWr+eKNTXVrpJsz3xmfbXfxv212Y2W9/LR36Dbz3jxKw5lO FVc6iQ6v7/M2HZw57/BVdkbeBse/Z/Qbi1t/exaSQyu5+914x4x3j45DrrPvlWFFtDPzp0cinWEX MpV3ejFefbcdO3LqusM8YHjpLx1nBx7+MXxp3zz3+e+fNTr+uPffh1duOtZdkttdLWcd2P5IRKj9 eXxbW8KRrimNflfBzRv6Q3sOPGE9n8uXyJ0xhHV6EL37/OUaeuePbc83pkdeOe+dPSaU510T59jh Hjbty+Jmp+/SHGY9/njVdkJx1hHrxied9saeOamdd/fdK/De/nha+ub7IT58P945eXIR5P5o5hyt x4M+Vmosvyv14t0v17K68RpdXNW18u2tGZxrf5WceleiD9eNX7R+RYtz69mbJ1zXk6XePrCV+/iv Z68d8wXxe7OPMsM0QbHyj48Nfq+vtnPnph3dvKUxWqld+1b2anvFca7zP2jXxR3LVq+fibketnby l4j5yrhNWc+iOijZBPFPnbj03r7by67dI5fv80Vvxfk7e09fO20tvXbq7W/TOcYvnEst9dXP3XT3 Ty1Pr4I+Fsumkc26eHVF2Tz56u3jZ0bw7o1n60bxLn16/OuT7Sl83ZLlyL53mkz6H0V1rcw27d2q c1ah1bDkjH53XPX4PQ8qZq42aCSJJ3YNpmHNCEWNb7+VdrIf0/4tG4tny8NWgggyg2NG5Dafr3s0 oPPNVb+tYEGXuAnD02p++36YBnh+4VhXjSlYtft0N+8O9VxXfaywU28ytjeqxawhk1eh+MGvi/s/ 3/rn/XxJHyMp771T3049fF8vPSevZXvzf0jp289e1M7eMIx3jbB3R7khu4vzxfTtxxfX1oo2rvHX lzye3aKPckIX61zW77t8V69raejzTsvo1a/msfHTbvz7Y7cZTqcvEvHLv8TalbW76r6dh4Ry5c+/ hMKr6cS558WSu3r3jvDu7kjRunyfj3r5219dE6RSvxKTukkc35bjm/qyN1e+PXPr46O8dHZdT1m8 8x4lzbiEvfEN6+Ztx132ft7b45b06W1599uqPdeW23bfhd807xfBUzz6y1qfni3xIlq12E8rU4xy 8cQ7aDZrrb+e/OWnnvDaPW0usqy6ztT3zjKfjnv8bpbxlHCWx5nx3xtj3DRnnqpY4144hzhSu+eY 5LR012lPvxo1XbnjVDbyGtUnaOc0o2+X989W2xyd5bxKgrVKttK3q1PiK402mY5hGo5CgcOg1avp 0m5HbZ28peY+sq5Jqzn0R0UbIJ4p87cfG9fjeXXbpHL9/eit+L8nb2nr522lt67dXa36ZzjF84ll vrq5+66e6eWp9fBHwtl00jm3Tw6pXZPPnq4bxs6IuIdwjWfrRo4lz69fg6jJ9pIlr17O8Z7Wtp03 +derRx19vjLt5W7Kr8eqn81j1RL1rr47X87b8M8r2dtz+IvzHdnKPOc8Mr2X8zovtXQ38bvt8Z77 s5M9uWnjTupLMwXpmXyXvt4ti0xI+UY9oK5barq/qvAXt376H6HTp3717zd7b0rtm/nQR32j8r8Y rzfR3WmI9a+qae/LRPvxTv36Y5dEWTnVSOnuz5cumjuftvnuz3s61tHMtDvxa53g/5aOMclfGVbX K2iTOo5T6jzCqKTlwsc83R5O9axHnv2T86+ta470Z4nLn8Gue9r9+I36t7+1W686M6T0roeW+6sQ wK8sp8tyWbk19+0o31VOsl+/HCj0p61eqMM8o4ca044jCed38+aa/DU+G9DjtHpxTGvtXqvw5ESi LuuRJrenPMmRZqm5AsWRnSWUIXgloZ1snCYXS0H6Si3WiVXvoBFQMLlcKYANk2MiWXNkJVOVMJdc koFhlNl0m5utFlbpZLpK0W6brKFFoiXQslEumEhbrshdYAytELC4SqmkukLVS63KpZZTKVbJKFRa LNISpLu/20ks0cqZf3b49onOdZ20/GyqnjItvp/kfyx+9zQmP8Kj6/wz/OqeEDIeef0OS1tn7VAJ o3ZuiIO4YP7VUno2Rwq/malxEAY8a+ebv48bJETCULpZaiyabtqrCRCaHmH9zBnJP2/V4xHLT1H+ p33iKro3zv2ETY0FTdQsR/c2C98n9xtL10Oha9a+bXh3GF0b49rHvdI63i8+sUDgWa0SKv6pn/eq 8oMlWe9DEBiopGqs/s9+fOXqOvx7x+P5NU2T6YaDuziGmoDTbqptqQUtOpWwruxmMzMyLuLZoJR1 g1dWKpsW5xiYyZKyJxZWrMOtyZEyJVcgGxVUclsqspnMTU5j2WcUXfFoy1WJx5wLRVjkZULSnJy6 gsrYKUxcEVbS7qcYUJyDNsXtzlq9NIVmFMWEAmltoDNZZWU5gd4bKiRFveCllrNLOOzKaR8VlWGi rcu1OHLupJeXWJiMY5IUy1tTNAumWxBuomKm4Cys02ZbkFrbLfMNKxhYJtBrUhYa9oQtrgrFdeuU 66mwwlDBofzrAcm9f09whAfXawXJBYwN+T8TPw+VXg7/1M9cs35/TbvXLU5rhudTv39/D4+Z9Xui +58Luz7NT9vltuJ2PSBjNmIwYYO9p0wFhnEvjn1a8PCT6k8OYKHIPt8g6e/DzTCHYPFDv45juk9q Sd3wj1/L5qJ/uPd9Rv8z6kpngpwXytx9OhMrTDytnP83QX36Y/m2aBUZwEREGTUG8RBqbvC6zCPs nUfD2dbTD68h6vsic89262G3r14oPQ7M3oC39BaHJVlcuXd3Eq8RBhnWIch32guJcUwoUakOWZma agkQxeQsmVqHHPbhoTi0NJXO6kLsJC0BqOAkaMO4G15txOb6tfHPil8gojshCgAA4mZiXNbpRLhC 6AP9vaVUUq0Dswmrjq9a1exh1YuypBxjenp6GncMLzWIkpgR9tsVD5lASCUSdiDx59evSH0J6RwB 0B+4DpGBZQqUhiCStakFOc2VHmecvLxqVuW7XjbtzlGvKbFEiiNJiT3/y/aQgqv7v6Q/utEEMkRE RERAqiqqqqqqqoqqqhJAUBVkVZFFikUBYpIpFgsFIqqqwFgvpGep8fifTzoaP/IJCE7IiAjjgFEe B+/L5po2YR+BdZ9vqXz+X8zpPzXKuXIUtMspIMMsFiyhW/e7uiwnFCH8Nak5VlYsbTLWa5i8gl1i 5G1H8EU3ha5kAbQJxFIXqh5JPD5MFIeEih0nSBxMzoSHkh0hx7sDwk8+WHkhxyKpOMN5+ei9D5sA OmB2QzFhDzSeQ9IFZRCAYXsIqBVVB+v8xmqWtmvU700UAzgmt+MuBcPdb+r9tf6sn9Z/3fb3XUXS Yzhllvxyn1zXxL2WnU88KGvtMYIXOGd9yL4pmYyrntCqpaJxqqsyD23BRGSL0D+txWnvhdJC8CJK 5B3SRYUqDhISUstUlZWqQlFSVqIIc/z+R/kHJ35Gvnxt+aOS1spSi9kYxdKTmiLnShB4iYIzM6yq 5zkZznOcxOUFVQqqqqmsvjFSIqalSLtYBgGFqvb2tE91Ctp+fta9K1JuUxM0pAJZ4p4qFJWKCI/r DihcCfKWuobGEkCAQkFGMjBhBYskUgRBASAyBGQiIgAkSQWEUhFWCMFjEUikigByDDvJ5kZOB35u 2JO3x8udgY/HZL34T8DccRzcuV1sNbpmUIhSbfhS6V2hc78W54Te+UunCaTP46KU5QjF9kotUENk oVvUakJaKQLFBrm/6q/rsmFxcSVM9JKHELzrMaqiDOUkhL24NWWELFUmyRW1t4vvrkCqX0Z5ubLU YBQUCs6iB7PWAIqAxlgABAALEONt7nOsRPCc3i0Yf0kHRDAuFzuM1XCSq5ymIMVUqFGzwpC5rNmD HsFqRHlPhPHv0cbXLbRRrS/FrEE9RKHQoCymE0ASGEk+8NjKEXvFy6fC3gASUhUTbai+cGt7jleF wmybIF4RA2GFRKbyIgfHxT6OMDmSNXvGefe2Mr1ymAETZAXlD5zTcjHzsvjxqnASpDUCHwG8aUN7 vmhfcgtZOPRF8cOtrcSbtz5u58w9/Z4IYz1aqybUgrnYgCAUyLrjh7EHfCoRYIk9q83533ZEq+5Q Qlsh8cRRUDUnOLO8JuMCNZsdORfzQpQ39bHVDXNZteEosrCUWqWSJ80x6KLOgdJqV0sJRDHhUcQq BtAqcXjvi6ZTVAJwoWshlN0pRbFU9ndponHHkoiEoigiDazadAtkGRCGIY42LYzV9xYEL383CpVB rbfnJqEpdbc+qCHSWlDemCu/J50l8OAHdauoxwQQcJi12HgIgARasMrUZllBCEjSUhTbBI6t1/FL 2B2890fVA9Vjb/cknaBtSfJc5ru4SW1Q16g8014ZPZIg7BtKL837swu/fWe/E7fgMr+tO1A68w+e gFSkHFOSpTvzzTrVTyN0olgKxnVLLso6SFVLynJADlHELqnqMLtxqeM2TVqIA7kLADAwsIkLAkIB fCjdKyJxt/nx9bZ2XQ8pv1ulVT1Pxjq2s9jrelb704Nc7yjlLQsapz+P0ne3KSkJeInGXeE2S6Tc KLCUTf3xrtetmxLWypC90uKaJTlg9ZId9vWE+LA1tr1YhLiyAssOMLblToJIhcJxzUNzQm+Mylus 98Mbfh8jlE73YZS4II5Lb8QZohBsbl55jsHRJBQOgyujoGV7BulOKmKZuu6UwmE54HMDYSFRqswl K6icpa41gZXKwiZGEAum8CBRYSTqvPfW+sa0D456qt0sUTiE4RIWF6xKUSK7THddYx3snZClqXWb Qcxm9aWWIXeqcLzscbybZS/MpwXJTniUspuQCYtqgOZ4M9nugHg+83PYIn3tcN3uUjlgM65z9ekC x+wadDQSMTKDme3nG6W+IsJnthYerfPNr1Q/xX6T+1eR5XJkjMkPgKxH6+PnjxF6XxfWisSnlZXd RwuBLJ4LxELEERdbRqM2jCytWhGlggVS6IUSyhWdvrjEUK7wZEUgXELCQt0gWywtESBIBTUpvv75 jO2U2QSmRdcyoG2ySsWTEWSt5lN1pYg3vUXFE91wI7Wn31fXPV9bzwobcrMAkvCw6IMj6DEXL5e9 iArORNXxZesvcwtFNrIQS4wpJFZnsg2S+GKm5XPLBljqyzhzGZkyV26TmHhQF146z676wW7xrXk/ avlfxW3DDz88G0NTbz31voJQbg0WguySAQh0k0paYtTalIRDrjMUA98yAbQiOYQd/e/1UQ1AJTuR QL8gU9cpdCLIxTrJSLGTWO+N+6IVBMyuPBIvG3PHvO+ANkJCUCRC+215895nie7OLSjPD51vNz09 6yD0FWslvTI1xi0rjGaZ4PYaIm/whgWhudwM+5ryqxkhnnHXJFpjAp6QKE5514mM1LH3pKVA8CgL kG6aTKSH4jpaLkCy2vxNbe4AxWRTz7AlYQBOE2lUYzfsVqCJviuqi6KAEigtImfHjZaLZVLe5FMw oAQkKIZ9SImfjmtyIBIEEaqRXtWuc5XYxVw6b6uiCemhFYR3zzSBBzfPHFGh8dZbxPTBdUWM988X K30laGFv6L2RtJi0dr3F87xN9HuBnvNAy4DG0lcoGRbi5kDCVISy5KnIkDHeNXr/mGrAhRE0CEAw BkERCiBACrzCiCyCwIMKMKBArCipVOaCURQeq8WtzdBCQEgURhBgRXnNERO4EaqrNltuWBQiERDd CBBldSkAk9Xx6trCcIECUxIni2jx1m4eYzdZVFLyLINE7hO7Rx1csB3tx2VH3CPfgOZzBmbCXEtO wbXI7K6r+RqM+pDUYmGt+mgAV8tr51zEhLJCzAxGMmcgtLqKrEHhCwbYvv9/2EQkQ5AiyRMjtHn0 Fcerdzfr3nCStgbDCWIJnFPrYSQYWBAIVRgVYVEhAULoVVIGtKKqDfWO9/oS6Z0JEK4wkiBwkCSo berayTF0tCZQfc0QLEZngC037i1NaFthlAVLK1pywgeNrRAJpEIi1wFBOl247DPaH1fnZwJGtR9+ V3pAY0PNx3L31pqpFyp1bnbJvo6suMW8N+om8aXPfAp7pGifMpm6w5zlW2gzim3HQtyXiZ1qETwm VOjmVSW+3lZ7dvbx69T0+2+SKSMJBbcGkzNS+iNnp5IC0Ho4I59XL6SEWRZFa+EmMK5Yy2wrv/Qi H8uW1S8BvuE7/PaNxd68VVZs78WGu2hem1SKNWlmuaYDiuXHBe6EL3dH4FnaYlr8xudDxp6ne5lG vtAfRW4nV930Jnt96UZjeCYHqpnEZbjWz0ZE6vbXLHLiuqjdPioMZ1y/BnVRDTCZIah8Q5Dm/CLJ F6ItCDKR06gGnRSxIHnQ8Vxwm+vHGCexB/lVnMfV8kKIvvmlPg3b73VdyDtuGvZeXt1mEa9Be++B xw+5OfdcRUuemtz0XxgNkNTEKkt1SHUi5gD6gF1IWntsDO6Iil7/L6A99XaJUZuv1937YtouLbs5 zy0djKsq1m8GmEUZ+014yG72hzaoe94nG7+fwBEACKe61nFt8vYEQAItL4loiGtek0Bo6EXYi+Au YFAcrZ00ssaXT502Y9HUJG2gflfttTt7czdr81XPubPFrUc6jH5O2x+bytIFtbWdmtcFtVaKvZMM yOeETtazVdfTZPG7Jl2DdCPnWSFqP/JmZmZmD7HcOhDmt8Mu58zCYSb/kg1/X2lWxR3jPg9n2pO/ TEmYsDTNsxrjn4bx7fLSExNDW+5kqZjMcetVrvJzBx5p52vitvpegPsspk+y/ivJKU2gVAfCwDuW tDEMxNqVppTqsQ5A+UlgfQowFVWHqRvqAw6JofhDuDNNQyXIk1yoZUxpJb0/S0rtTJJcScQ3BnWU uC6UmbE3JYvRbxsXYliZFo2JpTcnZPgK1rD0KT3L/enBDomJcq6kGExJpXKkwdY7g2JxTupxXGoe FhNibk5rmMpyXwuA7lwQloMSbl7JjHQm0T0OUNidk2JWUSXEG3Mg0L3TYlSelrAypYsJcuU1Kdhz JyWhc4l6nm7a2eYlRBHSJyl3LGqbvEMrsyS5VQwP3K4LlmZiG9tWRVr+EgEnfnnl7D28/TQo+GXU 8/Gx2Z0yOq1kCtTp9LeltnmmVAPPWBJ5vk+UVnZndUCsnSHF7UHlO7zz7c5WdkDdXwmYVk2XKCBa oNEkWAyhHdUR7UI5RBqaI3kediMyeXbtiTv5tnEPNDw+ScQ490BYTyZ0zwwLEPPrnbhwThXrdM4z vywXEBP5pj1mzK50C63tWt13l6pFy6uU6RAgQWPqj740tmD8+Tuzj5itaZ7W/qaNPOo9XnmOpdth 37ysdoad1eHdZKzMNBcwsdCypaa+wgDEDoLRJBCwUEwh0KAtUsJVKgCLK7GEshYSqwlElCiQKSsK SlgCq2RQIAABQQghAyIw++fr10Pe/x+Nz0sVCiKqsyLqqdwAJiXdpm8nKzHYZmPmKzxJww2kFB0Y XhCV4QghPv9V8z43mtcUtOT1qbNKmK3rTFwJaTUrqzFC40Bi6lF1dROpt0Sgn5L+NL/AMgWBExCF QYBIWEQc0oBJfSTTknYgA3KimtIC/hnZKC1k21xsmhekw5U+/jJCblsSfhkudoikOkC6QCDCwlUw aqJtAnR51fz34ttvwmw0WEvApvAIUTz+G6PfddvwXfb2V8brzvIivMKvNs+q7UzybtfCi3jnoURZ vmZIjww0qMfMKPgQAg3qAUY2c3AnxcALVQIKlwQoRfgEmiNFWx0rDFtFHpBuyUJcluHUg1kkLeJx x+axfKrY0IfCHwiuAAgh1IWBeydV1JepisgOAThythPZQ6aomlAm9JJNHsgxA47qSSSCD3CJA2iR GvhfqlkectuiCrcSol/nhKIidIa+uk6EM6Ipxjbxr7q67DxjCVx0nmTZMcpxHgSoIHiv42c9XQMK THgOE5268evwv0vlIWAYThDZWQXuAO7X6LHKpNwA85wiBWqSpCwqUhZRCBGBgRhAiCMa3Mjq3VI1 JHrvFQLXQEANpF6atzAA8boo0vHgzFNejigdmC9i7+DG1c04nxVfzS6/KfolvMXde1p6pSKfXfqK z8JZMgWA9rslVme/qh2JssAEKHMqBRIQC968gQls44XgX4UCAhFT5mQUtQ1bQYW4q9AkKJsQCWhD 4wVwY5+PG2gfrMgnqAU7MeF85v+KGeT3IHncdQvsMi9MgCTiEOmp/BZV175+UazpWMrA8+lFjUD0 2Tnz0cvi+8BCIAlGnspq+sEW/rAekGqkboj4RHKZzfVxCV7dsL6fWXC+LaFVsX3mESrax220cZVp eEOQCIECdBj0PlEj6Io5yo4mkzLPL5e5s9rY3+xBAlGnfNAQLGefSA2Lno+YKX9vNVZAOk0XdLpp LCbJa2+OMpKVNs+9eDKT83TScgbAIkBqBEkuoW4KKo7/HEbgW35S+ENBJRDNT2bcmvW6ud9lwlPU Uhac8UiFmhQnsMrZVMWD5ys9wWXvn352Ez1hbeqrc92S0DlNFP2JsU52wfFqhCnpOwfPjvCDPNaP AF6UjatWkVFghKdFrIaVhjME20oaLMeQbtzJetPRvael+RP6VsHaHC/ZMHnxra/BQn69A+E4SxhC qUBskZNOvozXKZ5qtVquU+No0Lytrp8Kp9e6xnpKJzgTYDxK8mqUWwhAlISQDjP0IFPFhsBBQRYX dCEQ7SAWa4Q2TgHi6ceMFX60hNq+kyEJIwkB8rAtwTm/NEN0wrnz75x2lgbpRdaKJzRSgFk4va1F LKXpKEzcSnrspSL/itNk2yBcdG0UhekgKRJLCygMhXOl80kRVcQUCkd1bqIWSEsWDmwinSWYTrQQ PGxaaQG/vxt13s7WWEHqEbn4KG/7fE8WQ3i83n1IKIaBrlsygXwNJDJzY42IQEhKkuhBWplVXteR JCkMutxK4XSkVa8JZp21UTnAQlZ6HKm0EqukCy+ii7iXU98JwUGy/dQB55g6/GSoFbZFwA5U8c3C ipay0S6YHeMG98YlbUSCOelK0hdWTZBosiGlrtK9Qt4WlPfFimUyGTKQ9JFT6kv3SmvFh2BbbJ1u oHfCSd1wB4snVfI8vJjJldJPKc/XZW3ZS6VrX1VQri1jzCnUHi5QgwccdY3pthQpj8OYtoaj8AlE VDzJ0yD2IDLTtpcAb4bKb4Iwm9nvpfeCQud8Ub1o8WNlB6vc0ZaMh+5D+pCi/IqvYbeJJ7+bGMc2 49+qbzfzjNyZhZWUldlhfKEXz1TH11JcUuWTiy0TAQlV0f1lkCiZsuxRKrCVB9wKNlsIm0IQowAN eeueCc7LGVqsDeR0mZWOHOeTYlMJeQ2PiAeFgdl2otharNSASidrINFhYFtGSqSQnINF1ayVQqrj 588bpZbrqhsImlqkJXxWY9LOF45FiqxRYCFgCYnalaAYWwwmga8ccrwBE6971bcdmAg8R3LQAtj3 TOn6AAgCxbQ8pyYNzXfl79dfAvV5Xde4bdK9eQN1NHPo+Ng7C9qryoHimM547MdOFRZRIut9G5IT sB4ShRzXEQZjWZL6oJSvMxM5tbJagtFutBgLAZVOlIuazc+W4/OFStbYWEKoRqwHzWW8gQgQqvCT hI+s3GqQXSlELQvJ82UrwmISZosBAB8pCuUrKhskAVBAtxHU5sgbJAJchhYBbgaUd0qgEpKfX1FN /N6XFOdAeYAvcCLlfPZW9xLjykoA1gWgQTdZffmxuAm8/ibQGrYyeQWscwnYnvEyEJKsQ55OED3u 7drmBLE0Kje+ZGvIZ+vCsvi6uQp7Yg7XQ0F+vaxiBECegYN3o9GDJU0YYvLNzNUiuh3AZWqQllum k2rbNjcPVajcDdNigEiFJQIDvmt9tJt6vkSLJQzyo0TlkDC4nbbrdZwcwckikyMbLCbCjKY8+jSe OThNGUICE0u1NrFnjjnF+59chlNuLknRtum68pZab/qXyptwHe/OiPV5SNuOACvh6ISS4Gucz7gu Z1ayN5XJQl/SF9ogggwL2cKvpN0ARlpDNVpGmVZEipSqiCmQWuzWrQtgpByrrT4ZIPg+QEf5CCaz cQAJ1dPgKPNA8C8eTF2IWXKVXCQDmR/rGiWO5vT1n4k1Tqlk9ErFYwcNhMe/D0nvN9a152WyWsAA dIAwhCUgE1AgE74r65Ws3ETo2TKSkJIHFEpnjjqonEJvnff3jOFOEjEgUol5iIt4rZvikE8Fxr3W a3oitv1BkJ5HNti1eV4PIHm7evGOuwIutB17wQJoymNwd1thDMweZRFEIswJl9iA/JE1ymVnCCcy WjH3ImaI16Z+/vaf6Gz8f1UIAAAFggsAaEqICniigZx5+PhQJyXis9zr5+lvom9Oyrqvd7x59SVw oeP06kHsJzK7jp5V+1q4vUwnDrWOzh+2wD2YN9VB5cNYLbqrbnLrqhK/5Ib33zEaIvyRfkEFBAL7 780F9qj9jQT4fGZkwDHB8U6vQkt6ta0616ohTs7JnM2wz5Vth7wx/KG44l+73irjVMfG7OT8BeOx rG/L61Bf2IrZxtR3PiCZzHhLZ4x6ykTDXk+XNKR3xdMNtcamJzWo6MQjnqWvUNmkH7gzMgRmERe5 w194Th6mS7jvTwFZk4bdwjJrYtqKFcO/2B5nI3cLk9E9k51m1cO39iE6hR6Q5rqcGuPNfBF+CIwB 3HgAfoROhBGRsqeqhkarQtoUygstO619qcv/BtS+owtYlvmnvf82v+Si1LNVuyXF/yQAVrSmQyPm NmmKfxdNjbo9dXWIdefoRYnXnBkZIFoD0NLb4n5e+bY55NC078C+O4OzES8Xm3Ae9WAAR+0HtL1V 7Lf0+7WY5ojEzZsQwXsClJN9d1WBlBs7YvCW3CDtng0fRFOOrzGotfOMMcVTa3fbHjUOy25xBkc0 2uda+Req5aXOLam8hNIbOtltrHDHalOgTLow5Gptw7duGffMzg+Z0uoQ9aq57lOdY1o3vwUvbivA XDK/clk/EHfsgiI/NCZbE4g8QqTaJWY09k+E91+Vyp3dJyTsmZOq9huXevyBPuvFePFiIgiCIzIP NOa5lrVNyaV7oeV2JcuRJLoKkzrUuJKlxjiIS1C1cEzoAwmhMa8lxrlXSmNPdd68hrDivRMqbSa0 JvSxeiYkpWpZh0DumxJdUuLBtXImt5GCeQKUoSSdk8IYJsHuncMizzJnHKvJYbMC7fTwqqKCrvOZ RROMTkNMMsQ/wqGE0/4AIhUKjurQXVS49oRiSDioS4KBJhQmij6pkDbTjgM4QAXptabGL4cqoSJR XtWZdVCLS4HxgVkPYOChlxTm1DYzMLwH9QiuWjVUpjP8fGRgWlqsroIgHrtXB21rKbXKYfbss8xZ Z7BBibRbNQe33I7LYcYITIG5NINPeg9s67wpa1iMpsiFuVp2wdgiABE9vztE2RN03XhNxaLVbBCR RJWiykJZIWq1WgIFkokAEDKlkIWq0AslUryfgPqHyuY8xupNzd/heUtu75ISlVA2F2ycisNY1i9i LRa18xnN9Uzndbr/z5XKcpINlovu9sfwDMFhnqKbxmnWIeF8cKZbFVgwIj4IGC4+j5p7+6vPBoRO V4XZOxotlhLrslMU5Pu+iYCiTzZUwsB+YTbEsslz4qKkLouSg3qgqD2P4X/JLnwdGnCwI/G+80ni +f7fXa45SU+t68QjygU+JALoQBufbuEoDhAzm1/pfjq20cZ9010m5yvgPXmoO6owDjvqJ3Ip86TO cBx/L3VUDdLeiFD4h8p+ter84FAX2dJm3nrnj1eh1n5FafBeYoJfMoBhN4QKfM6FqHIGqNbjE4gA l1gwaGj7EOa7PZfTVVYZpR4VG/kJzTt45PEY7xMcccZt3QfYiKicD0QcSBySVKg17pz8Ozov5vOM JCUSgsIVFKKZSqGqNS+csRqQACgU2VF9dp7+HCCjkIBRRA8DnjjIF+er7e6XymOKKGAt0krqBM9e sd+ZQ3Rr5SVomQvKSD5Ev3yOLJlaFaIMg7eedsfSvPORG4EDtDyAbkJIQnBIhzO260OevG5fIpeF K3nVc68rwF13gE80kDEDmO418Qki3IGhCHHMg8mD3R3jffavWoSFsqDkXNcQyi4BVTleL26AKXVL l5JmW/kh+SJgH4p/Iuvt68PyefscSUj317rrXK2WyUFwuw/C1LZvstsoetCgWGAYT51Yw7ccfaBS oxGUQ3i9W2sild77UrqeOanlKLx0I6NJ9G2RsgfNvHkutPtfZ2Xqb8ZLT1pZ8c87ykKCTQhjBEHj fonCaa3zREALxKexuBp713zljayJ3O7wQCbjzox89F3hTLkc0fM8gPbMi/vmV0fuvKiNwmMh/T6E e+Uy2nlVByNcX9QRMQwRaL4QvLHqJiYtbJ+roZT0hCBKVX0n9YWX4TlbEbYKbynA4AiiXUvS9+67 JClIN8K84v5od/O6/GyhysbzNbnHaVBPnlJHCQtox420R2tlqvaY/WMrV2WpsnHyRTfGgOMLMJzC YAosp4oIVzEnNK5jHepS9uTnNab/R9l6sNl4734WIYIvxhArqKU2k+5JVFdrappW2M/f/BCvL8mQ Yw6XrxTxToi7kEHsHrTZDZXQ5BTEiBFEEPAFGkMEBRUxSCvIYT1nCldQm76OWB7BsFQKLZOV9hKW U7/Ik142kWGNq+rJ3TgBmAbht6+dkE7KT6uoefj9OMYCN037Hi6xO1/uOB+/wuY8b0XS5slFkYXd PrdaLdfXS0XrEr9Xa36KdaXpNVTSQhUjJl4yAoMfwkCQ5ENEKuQPoLfTcWRerXXAG+2Huxg4EIkw I5yPKd8gDr6KED88w8jjhEeFzfzyrJgvl9OVGsENQesnI1wbXxQylbJbbVIagRnCBVaEx9DTd4na xiVDaUigQVfRd6DGeLbuxEMATkFSECqF+s0psmaGKrNKLTHZTPM2y524SNgTV8p5rn7wFE9UT1bH HXnecne5jx380TFFkM/CB+8O0NYwRS2FnUriR64W7EKo3+ZuABohunnNI2vW3JgfPPVlJulfZS2P A7JpDcpFCu0Bd4L35tYgg9amI7ey63xes0W5/T4JW/MT887oNsOqanVFjUGt0N+xcZ44/3IdABkO dFvSJ/hhprivva9tvOEqBRKjQwnkCVsu/vvjRNk8YTbK6Nk1jFffVTsruZnawmYE1Ank8a5WqPfg wtGAXDMiu+0UYjH02/ABdJexEYLqusd7XnnmCKTqoIGNZ1MVIcAHn2jcN11bwZek1vzaJrWj15Zf f08XxE9IshlB953LWtv0aRr8NWGG31xPFcpqpVW1fR1UD7EUINlWTfoCJwG5BWwMbFwJ1qD5KTj5 47tjHWN0laHpKoeFsm64UDBcfvEmZ5ti6fmSIURQQnKusAvwsrv85gZvkiKfxUgGMzMY3rxbS9xb r6Oq096miwkc0yfbvcfIQii2CGYIWe1iLZkPljxm/He6SWKmO9nrzcn9yCIAEUaTcZqZIYbblnx1 T54UsM38+ZzIx5fQS7zF9dw4U/hpl8/Ky1qlgt15aw0Y/3wxHHoLP3M2TCec2xS+/djPlbJdXCyq UXSXWEtW0c943xCBNcp8VAd+DiueBtdMJADRSEzC5yMe8ZMaPNF3ipm35D39Qd7XTK9r0nVTx14t PzTwmVppdV1x3z/YnwFefXAsbb0gCmqLaq8b0bQGI5QexBbmN3NPoAgQTjMO+hqif5Ybnynp3Fef mcNS+wNX92eBO38Y9/LouYWQjYozywrFVn+KpzXOm1MiQJSnpLFvAsWVBXLYmKIMZ34wTSmotbPm tr1kTAVSUAcLinNqXonxD4ysh7ynrKWte9/feuTvf68Z38SnQiVD3K8wua9dG5Q362XKdSdlAJ68 RqJyYuCB38+dlyQwPeRfHVXkbGEZiI860vM+R2yv56B7Wxq6xXmeDKDfNulupb32x2Tt5PdSPX/I LGJxe4x82OXpbkXv5t1q18mL+bc9+tq74jJxTabJ8LBsnymwqqGZRRdXb27fGct09tVHwB+NQGVD /mIgCf+NR+w/C5dufRXTspSeOr4MEHMBqUHcweFqfD8kEw2YGOxqlqA9af1kJGQc9KFv8BsLVMxK 88Gw5YgYmFeSKYjf6kDjRE1L00xy3KIo97u8uiCM+F08C+sbze+rW3lvLPKK68GJ39HiM6FxfZ4F 9KEocxPEbL7uiqVwxys5NGFqd5yu9BsRLQNUM5Ft4bGc2fL5SBiORB4nL91zsmtPtGfHEenzq5EZ AYIv1GF7dugDHtOLII1ImZpJxptVKGQjlYQ0xlolOsoCLJpGVwsfKz73d6UILneeWv9kSX/Yi+xZ fvXPW6jcUd7tE4LRm3aTiYfzkWuI939KZyub5favTrZiL+5F/Mi/5B+0D4QEMVjb2AmxjOmWqGUa rgxKIYZq5AZHMTWl7PrGfwNYJoF7tiTmkit72RBg3bzOFnS4OlSdr1mmuzUMmF1WcoDaV13uIqSb 4TRd1zh+hCi2h/MiQQkCIfkYsluMWRmzs87rW5GLOELrSGZMTu1UHocLUfjWExN3a0xxYWyaW/SG Je0Plc/XG/BDwhureZWchFXWVO0XG2DHWoGtbM5Wi1YbOYo25FwQ7kTCEAO2rvIGTxzXm8Y+eavn MmPK4Nent4aBQjqUwTSPdL8u2b53sfgNz0glvMaZW5i+vcrkQMWlbRq2K7hcmINSExZbE7rYqVAo 1Vc9ZzxRk3BHIi/JdSLoBAinlNh9LoS5Uxi7UB4retq1LoH4/Kbk0KHlbgZqdU6AUh5S9ZOwe64k kt6al4JapiDqnJMFxL2WtZD2TkuZJ2p3SZugiKk5pJPgMi0rQt6aV1gZAc5mX2XWm9dw7EyJsTgm oca5VlpTmJUmJOKbE3LqWldTiXkmxNCXGVAwC9Y0rqTMvsmdIE3Jcu5ZIWp2TrTERERSpjSc8QGN KxNYlS7ElsShLU8idk2IdErXcvJcaa02G1eKgeQpSW7lyln65qYqifeKZSmW1ypnXRIlTdXKrDrL 0cxYIFKppfjFn8kAFVjPFhiYIVlEq7KtqyMTtpnBdValEZTKLpkVEQIgpBbsJ2xbAEgEjSM+AxBG kmlIMhXvIYitNqKJiSCIWcNqCI0IVqlA84ckQsi2l7nGyry7rLbLV3M3VzULZmmbbzRB4vtqvs+g 1wNo+7XXwftOb3u+ut/jOr23s+b4/HZ55E+Ux3B4OgZweW3YLCS1cnnINPE3jyLH9Pr5SpCfeQia CAFABYCoQLheUhNhsDK2WgkpZLKVBhJSoFVlLJIJYWn595/L1+u/6tihOc3viM2ila3MTMzU1UzM RUVdqtXVh0CAoN0GkBROS25jjsp/b4jy8plzT0yw1ja0p41i4+YqSbIW9khtV9+7WmE2U0DusJKx nY3ulEuWgE337xVOPaxtwBUS32JAZhFaLCQLaKlq9QnHKjFChB0AQtXkiQY8AXbaKPw4hIiAa6EM /cLIMBArOAQYmZC0CFKkXcDNiLWMlSXpiIjDEcKnSKyKt7tz5jye5ylgBC4Sj/mRI99jEwLeYTGD ynluN1pp00YOdi4v1V+86HNW2qzYPao+WIQE92ZgZMcHVGNYNsd0tiK320LRNISlklLIVS+3zRc9 3EZIBDUA7pCswiNUgSNLS2W9UxekmEhYSERaDABDWI81pc1cR6wvrnis+NorSN943Ct02DhMTErm iyDCgQA92M+td9GBAyQrQYBElQymcXKHne+oQpb1pAKoBcISM2rQ64qbnk7X+SqriCAAnCIAAUEW OnBECtJs2As6Suo5KnnMgO6jySBbBCU1ekx8O+/a3sTrX0MrOXy0oTfE4mHW1P4m9i9OqihC65X9 yL9wXvnfRWHnu+3Vl8IfyISnrUbfA7ge9j+4jusblKZnNscrdKAgXUg2T936+SZmZkmZ8ppcE4jo NhE2+bj9H2FAXB80+POyfdKbIfR8Znuoa6OeuOuarvpD3xytjHxa1stbjTUrxOPOwnBvz0cY8ruB IFQ5Sgue1laEmUNRjjZ2TCWB9a62LdG3gvbicbs5TpMXkkDxi2E8Lvvx+E35zzjjY4wC16U8dhXH nI8awrrAGzaHfr7TFoyI+dGhnGI+nh+eeePc8YwYrxqOL83r15pfbGNFz81TyfuWV+Vwd3Pk2B7I 3gjHVMfHdvFgJSVlIXYEpFNbXtuRYv2ffI1+Rkgm4nZF9hNtv7WhihDEMEWOovgzbXnBnafnke/S woTxRccHNvt43TC+ZW5RL05lr7x4LgkInuhfN+GQ6yAuqfmfebwQXiEBobj3AZs4Nx82pNfdH6mB 5tvBl7KtdCTietEDpi6mbxDvfVet/6E5yG0PlJu9QRBWdq8TC+AbJ0PldgMlQbJKbhitc4I97pe5 7ovvGUrO++F8RsQtNkibxc5re4UAoR1MsxEHCgQMkHPFPdAI98eTfZbpjleTk5ry8ZSnHF/fnz5O PHg6TiMlztfOfIxPPmKYXQ7pC5Wu1HJ3rAYi5rGh8YULJgGRJYhoLuil3JLGQPvibnySKhCDCJvC 8RXpClmtemZmp903smS8aLMW0NE11XWsGV7kJwCsyQw9yFrUWFyCpcAeiDQVSJkT4AbEwhBbFDAN 3upuvOPPs92+BEUAYANIIWNo9sQQRSQpyKVIMZCiIFRF7bQfIqYBkL4U6adXiLJWySfPCc59cmya 32W2wfU1K95O9LuulzCZ4W099aPBtwuF5xsHhPHvrFddmyQOmPv1TxxhunNkjUpSadNttYG9/Ud8 zpsUSOsAGggDIHy2SE4htmmH6uneAf9iLJEB6MR8DZS0tT4stQUVSrGShJ7wlZrkkTaMSkQ7kTCJ pFQhsQZczI2+EHU8pg9rzdauGtg7kSkTEJImBRTHbxejIPxtALmrTrUJcgbgglv+Sw/UTqdhoIfF INemX8d8InAIT3iOEDGQq0z6HYPIL75vjty6bDD1eWdrBvhx8EWDX23vLL74PHPcMqCG1j1msIhF iYitRVB8TbK+zfWREoRfqAQ/0IsAV0bMyBdMKTrNO98zWVOUomUut0hbeCdsa2TxKUiDxiKSGexQ kXIrKQful15giUAmX5d9RGG0AJ0ZFh2TnzHfowUQQ0dLa+scItdJNs/V9IkzmPQ7fkiyyNrKEjC0 wRYWZO87kdZrRlrrhf0IsXMQdVUHCccyjWtccX6x23Bqaec09nIrkP6ByFW8ISQxhDeLe8E5rcwO 4VUO0yIfgELdLrjObbs3sshe8rweHkFbdbEEKQHPlXbyRMpoQewiFHpF22kYID289rfuOX7Vs00X 035+1xA+t6nmAakSgtbCKQNtP/BzHhgAEpkCBDVuQfxEIK7d96HbI+RyWarDgu92iU7b016M+MM6 br2Ho/Gu848IMegiALrbivwWwY388ccTSx1aDz6p+tap/Ynk+H5TO+aExHq/clPFO7I+kokLRSAY Gb1Llutsd75c251eihalF4AeQeQyoADtRdRHQVpMmUUJ4IXV93SwAbrr7dG7wMQTWCtjkZIICiCG s/H0Kr4PkXEYYlKyAQDxjAcxqhbk9QlBLs3OMKBN8oncZlhrShfMz7CKDm4tA4zRs6x3bnT/qRK9 WwFnSf4IY5aFxp8HJNNmXx39UHrnZ+bxUpYUUMaQqwgEI62CFN5CkIxKjfRvlA+g3SMtWizdqrr2 +ELLszNPu4f39bNtPYv23z60HNZl47OM60DuxzluiK4sxyjN6FjwsXrFoch+xBM5PzgSRyUvkxmt Eiqm0qp8vJrbkh7Ih4F6nUC9jsLyJSUYsllrrT1ay/uXmvvF91MA0KhbKUce4nBru7hBqSUQFHE4 VihcXHObRbpxE4N3HzVCtdvmOi40+d9aQoxXxPHH5p4U/av8E7Tb3HEx1O8e+r4m/NTrNZ4rmwyn a7n0L63q+7GjFTh9Nld2/AIXze2Gu+amOC4F44l5EPxbjfMqqMavqWj6l4ThrCXn6z+hFOeGQH+B cgxC8uEVvWcL6nNe/gd6P5EQ9uW0Ocha+ooidgzNiyXdPVeh2q27GiXrg8Ol+r6etc5Ays23s45W OYq9ezFnyYNr211qzbXN465hEGevJDwESkSxjHjQqZ5uKHN4FJjEY6fFpqFg84a96fwPej8WMBux u722KhuMc6tgNS6z3TKudnk5tVlxbScYv2D5/Uhbz2Pc3IKRJWcRbOyhHX3FJnEcDWq+Iz5pzhoR 9Kpp57nf+gIgy3r3i8YIJsu9jmnibzoeKi6ql1A81raBT0kax9kIBajl/c7hte+eJFVTmstKYuty zv2plTanBew9AYFzr9JUutDgqYylKl3rSGRaVsXivRCxKk9wksdUuTufScUeya0yp2UOK4wzjjTq BmNy6C5MQcFvWa6AyjmXqlCbQwTIMk0rSliGtbDWaRxCUIeU0JqQtTIty6V2JWtCB4TqBmXqly5B sMYSzrYo71+wQt5ghqFgNxlTWYJpSS1rWbE3riDwlC3LzWSngA/jDHx5WCzsVh/NyXgLCKflTP7Q iyJth5sP2AO8+x3s6Upuct4Uq0lTz8dc7dSR7FHLkKYWK05WimvuEo6HJdy4lYDS406tIw5d3guw 9YburwSXAMrGKobJDlFZmWKcLdPNqX7yU5zHiK4rafwAMbdtZdYsz9Ut4ZV6W1deqTBDVbisvk1i glWi2/dJPi4ten6qWCCIw6owVjbNc5M2viaUx1ac4rqb4IP7PZZdlquV2WTpapDQdlukgykrCSFR gCFopRJWVkukgVW4mhCyFSBIWi0VgotBKAaUoWBJpJKlCeGXZusu3d8VOHc559ttleK++HjaHt9z vb7kiKNTE63vWrarW9qe9Y1MzNZqd762zxTEWT9QCKgeQfKwtFPSSkvV6cfPJ5mVmR8LWLyoZL0W FKdFnsaqlty+BlBsulCHYs3vWkY8lvu4xjGKG2LUThaLK3TgUtVLAUpNqEVqkyn8LbUS0aSYdsX4 D+otXpLHEk3L5WiQtdL+OE7runfdlNyZtkdL+rv7juqQvhYSezugUr9/eL9B54E0uyhECHnrjrXf fPGgwLB3wqM5MXbJdYLrHr1xv4vlzZ7WIMQogCHrax45FAne6IiIZ8OvNbu/LDghYZX4VfBTOhVS uDw2cClVeHjmmf5IPvRNIJ9kQ+Ubew2iAl38efbEkeM3AwkpK4TcYFoLlLWmx5qnqlRxTxf2PPWN JXhUoPR7ok9FwPZt4WgFsrfHW1Vxe3FEuQceCy5yu8LeskUJnIzggDIJ0ihwBr6MDw3AMhnqkWYn lQ/RXK2OgMLQXeElUxKUHO+1a+dzmi0NJZOvnrrg2Cl1TzmU661redF7dyuUYSAHuobwGk66y0F1 77x/JpnOzbgP5d4y821q823D1xfqDCdBHke1AqmIjNq11jxXCyGqrRKi1W65LZ/jt5TWfWx3Qlgh QgOuuOX1G5vkA1AJq+AZosbEeK8mvdPHlb9ZRCtpD3XdDtcrbxhaAUsveEvUnM+dvZ164Sy63SuM 3KLym0Hkoe/dMn3Ia4MRukXNSlgPWPH7wNsJchek2XvjNB8wvFDmtUyMJnEjKTX149bHxpdCaBeo XzHt31rvbZMD2Qm69lMc7+W6dtdHkwX1UTmuGjCMZZT1I1k6m2zwvm6E61+8STxFJkJt6O4fEpMT MlLXvt5252yIaTtYBouUZtCauBWydd3pF/fjvdbrskGZ55sYhNi3rq433timHm3921cL0Cnmgkrk dqcU6q+l39cIqImD0CpSQc15zlURaeSAm+yFtzYFFk5yppYQ32M2KrSA2SBXnafUbccno8d0IugD uRFNU0pCqCEOQRCCAMgDIUmns1HbGCBhVUEDVKfAIgF+s16JrHpYVbnEe4x0nLj2rTv133mafsXf ip3anjyv70P3rIezpjzMnPwuncIWpIdeO3frWn2VpsAMgKBkDoP0CTDabHseicpddvrPGfrANwss fNu/rn8fTyBsscnHEaNj+3jRReU2nKyTaUzH11X4tWNHK4Advc4X3C0z+acJh5/Yuwbni+y7AcSu k0nx8UIqliOa92+OHjGy+JxsKUinrFBNsQ7dwbXzVMXSPicdtJqhC1UvIcpIIaIw3iwSpFz4qoNz mdBNWK2IBz7bPzNL2+YMU53vN0m+rIHDHF9dD25WK+yFiLJBj3MhGSCYk6xWO+rbxxBlcAWRqngo OkqMLcXxfcvW3NLwVTM+f4CJ462e88WytaJmWIIeBsichRBtnw7QX30hUkLx+rosKWBh00IfUCB9 IT6FiGJza4BPoFPs9ZZG3AyZDPWQPls4EANFSqQUQFixSFPRA5Kgk73sh9a1mwYzi0w7NaKik3rG JPciyAw4iQnXN6JY0RjSaVx+pF5Iu5BQZjs5fR61LMFKVnivvqtc3TC4SqVSy6So+hIptWnzdPXx ZT1tS0pxn3+Jt3YC2GKnOL8dfWp2wgJ+FyF6+UMiDZBq482QbefXoi9tqB5nnvE2eBi4NAIM6RBF p0KTJ6DD0seAyFEKZDv2yshLbleDlpMX4guFx78IiABFV7eRyoVgoO3joB+WHajoMGDrJQwtZV4H shyIoiGoaEOOMQqBmB7XlKrVbrcnm0aqviljOKfC/O/O+wHO7PzJCvjEXEYfX3/pJAQ75P0LF03C EWKP3zuaDeuQ1F5EutkVa/HwDeVsIaaCcFsk8QtRk+DaDkkKks5ND68zzDHTDxY9HgpsV9/6kOJb cTJ8Vva5vFr/WNu289/0L+pfC3EK26+fcG/l748U15t3sY3XKBsWQQuQYhcHFL9fq/zc3ELwGM8S m1I6fCKCHUy3SGrSrTYi+oYDmVNNQMfV+ACNwSe6Xt/Mghksb3eK80Pw0PvUe1NOAWsec93+nuh3 AkvcbqOiF956riQXgK0X9pUEcwlsN7bSZP32/xMGHvnFHlNA29IRO0rRtGTiv2IDH1GP9yHR6Op4 lMSLdrMu/b30fxxxC+l0Gy0Sy3TK0jHAcHjbu3rdB29YzU2u8AoTKp6SYRTogEVSKqKwRsIxdTOQ 0gM3WboH4qk3XxC39DvbjfPylur118dSUSNW6oB5qcCqn4eKsayY4qAx6iC1Ip9dF+bavh9sGlOf FIgWzx6by+1VUVE9j7x839z8RPar7H7XsJ7n9kdo5x4IMI+0ERkjAgTxGiMUeYyRwjfB8EHrtT8Y F5AuQ2uOslOWm/U1qqxxjhPSXdqx4MBpyitoSkOOlDCrDkm5NoVliqbMLuHH1VkyZt+3pZs0aENh I1EMggrRP4xrVZqxG64CVnPVlaJrfM4oD+VEzyAOSRVmlb5zOXSdj/JAH6RHFOkFcEeK0r3VhHq6 FvQA3k5VbN7vzeOvLPtv7kT29awwEjXm96u6JGqghcgP0BIQeKnPH9RpxHmICy3t3F4FgevshkFp fTU6fs25WD2t2xa9hhMKrPs3C8ZsXHL8HuPTSe87/t/kist+jWnhcbar407xdgSNPVO7AvO574+l 0LDHU6vJGRoL2v7wPoUBdc8xHWdQfS01bvh8fUi3vnz37zVWb6W8YDfXni9HaEaaQl+PI5p3nnri +bGjDiOOLogqKPryHaw7wRe7dTe9z1FvLd4EXr4xvNW8XNskSgv4kNkUDn/ALuc+Q7PpK7qRA8FR pfc+LewrFvHXZ3tnWww9n9iJB0xt9IPPFLus4ay++X4nF1jUDPqf0AXcCTJMXi131XvEW41G7w5x uRcEFEJEQZmVXxhZgfpT3vd7guDbvlRknoYiq4YIWIkzHHYBfgmLXzfwGzxt9q66T8MsYjVbzwNM LrnLpbaKQStrnNTnPCPNspis8c+Tus6flW7kL/EimNcS10rzJCxET11x4PLI+5OMpaO2xroVBZnY oty9+TS2zbN02Y3bIN5IjSRbL0NHrMWbnjWLY7e6UmRZO37NpGhuYtWpnVwjdeBZiBjpi72ZKjJP Elyd0rTuvUOS81zhPchHlDMu4DMvgTmLSGcJrakh1LMDkCBpXKvlOSTDalC6AnzTOpuTFuXacV7q FoBSlK8U8JiTBc6fZfZaU2JqApWheqyHwu5NC02jguRfCXptS1cYJpBr0LuCEoXccU2LkXalqUhS saU0LpNAHcDMlydVypHZcaWITJjoHV1OqSW0ITsm5cqXp1GhPBF1IZrxPqxKVINJoWYCzQFoCEU7 qQ1vnySvRsQJ/hdrIl0SDhDQuxINlKqmA2dkZBQAFhLeQZwC8EUHkJCNAaLcQzxbC03MPIdni7WA sigVfBOBg1DAz0ol0NCymVhBCWLXMNFniMmCJa2cwYaNhO83iWTjvpmuvuARAgSE32XVv8/nyNn8 MFssweMnlemz39kCbIakfFmwVzElttnaOONdzpr6UYGbe+oSndp7RV0YDmOpisllrrRd204crcNL shVkTChZYUao0SySjRZIEksSlgLA0UkCUqNFt8+t6Pu0ij2bQ8meTEz071qX1p1VtVWWASLu70bk KMa8MZmXd3WU96xrwYc0pW0G6IOEDIigAcIhQFArdHerl2ljS8utBYCuXtbqXp0Ck3YrLOdAl8Qx BSvxOjIuwNEuUdpxO31Vd13+smQNA3P6oAmKLbAGsXRoAbWokL+di7W1Whn8Rrt3+8GfCI88IYUM MaW5FBBaZhO7YRWYQDjP2upTud8UHhRnVgNs/mvrC3AOvHibaBntEON5AcVT7L738Rn4+M36WcHE +aXDri5iGI1CncYgbVrOdrW92ESMe/ZrFMGX264f3qeccR9XtGz3zUMO862DQGZHG/T8Lpw3cnMh ovojSBsZRpJjbqjW/YAD8oQfcEvlEGw5DkfFl238jpDfGb3QA3BF6zc97etfUkPCFiO9a/WnV+PE C9UA8YN7APuFKb/Mei8+HAle8xyNROyx1ZORMbTx5trn48aDSZBSUIVXMChIsxadXjNTp9ZXK33o tEhEeTnNT1NXzciA0QYHAIh8OLCiB+TYhsWssKQ98n97VVrVNQHFzebdvwi7ZkF9sthys7E1vUQG k6wPh4t5LXzXiui112WBKHK1T7hvXOI9wudwFEm4wh65vulVMwSm68bT8WWlePM828+ElJzK5gQ2 MW17441O6aXbbePCCaspVPXHvPJc3380T1C79T0lzen27layvBxIFIvJue/BZc90vv41t3u4S6cW jvhe4F99LxRZ1791h+gAviZBZChAAFAiip6yJr8Cs07kNls0lplWDqJF7dYpQ3mrm3Phb9b4x+Cf ovK1x8zr68fBHXJSxELU1DHyWI9jEq0oGRBaCkDojP7YPXavFeabehS7CuPOunQT/PffETsgugC/ TF/GGDIlAkpXlua57HrA1rPC7dZoVNfWP2pv5vhLcTHpN/j7Sdwf8EW6xV0N5C14B5hiEerhEEKE DZffLAhBF9V8v1hrOWoAi1L0zU+gjc22qTWsnNzKVvNlk2+5BAqrIrwxjR+6B6zP8y/BDzb/YLBi ZQIjb4atekInIeIyt1sNBou0wKerff6tU1P20C+ftdeO/d7wlY+11+d/PGaU7g47X3Plduzit08F k10gFuFT2b/N+n2YsOoSmxpohqiCkGPzJoPleCe5L3rwsAcStfVaA49+Z90n372Xymedk88aj7Yr jJitUaCxB60IRP3oM6rCAPYARtdDNdTb2BL9gig/RmhMo/RQ/BE2TxM0AiQxm9VBKYQjOBFMgY6u TvuQBjiyoUHnJeB6ZJdltYltV7CeyBkTALCIUC7ic/eNMbWTvNQCq/d5/DQ2T33xlKRiyV4UNzmd vdlqkJ6IxCYolUAfyX4aW4tfm2r9dDYgBoi56pBfO/UDf3y2+lfkEBVENarBLHJDMzqQt83kdaML D/DkGbj6M2f+KO312C3VvnEDVtffj3+asgwUb8QcHxI9HmHWUIazRYMAvpsejt9244NuKbWvXtJT 9BNekMTM3pFDvaI24mTj3ai1LIo6QcgoIXTETgh5AaxCwHdg8ulSfpgaMQY1ny+XbkX+oKtJuPqi DB/J8Xn3fXpBqIh6doPKH+YPfgiSuU0QIYDnBhBX6qIGRP6kQCtY6b6R10kccqzsp97HnK3LDYbN QBiZzcMUSq5B9hWVqhZsYDVNuJvrs3+w1fqQzfFI+lG69C+5bN92ceTUIGIWIXIAwRG0VFjICgzk LgAKao0u98/E9kFPxJUYjrkO/8EM5+WBDuKIapVHu762pDYZtELd8Rj+oQcQ8F2e87H6KMs+E2lW bXmg+92gY7b6qG+sz5fb2weWTneq1pDavJ55s6C21Y1osnDJRiho/URIIVPJXi/U8RBaQNQWix6p 59eorjW2E3SRgU0eVwGmef2OAStaEUVCj3mywuIQ0YCjdiEBt1rvbPFYVJeTxg1QiCarDCF9cDGE J2rHR9WOezSSm3DVpQdq1BiGlFXTDghrmLXMRdFMKRNGrdXPPAjRV45RjSYsVXNlBTbvBjIiw6Un ohjsm7Qgsh1IaCmKmWAqaUBJ0mnmm1fNac9QhZITGkupsnpbfJxna5GALqfdQAvpcqtApSy4MhTV pE8iMyDdW4s4VQQtR4ICRgo6rVnNZIWR1aqjwRYjYwThPKABVdiEAdax35jflVXw7V8KG52rE08n u9Az1od55c9OcvBFzVbuot9VzQHRQxZYatJ5AomYNzESW3KIU/WQgQkr15CvWMW7mS3ACd20Xg0o W/R17iLTw+V1oesPmbdHBdtX01P9PlXGstAxYLZF3aI1jE1Mm3FEtnCTzOxmH/UgHAERvVcvvgTX Ztoi/gRD9yJACGuvKxXi5bJXsu38TBisA1jacmgwm86x6bPtR4H/cil51mt1awUbNN5XCLI3viXo IMwL6lFyMn+t20Ny6K862i5Doef9yGXZ3/wCSKi/sWOvL0jC6qycHLQPlvXo6F6QIOJ4t1C7Sow3 qRZOp0XybbbO9VbOEzFN9lfnrcBnSeedRLDOR3frK0f7Ak64MUG+fK1evmUEDZvtlfhCxD8EEWz+ 8xHmDS+OZw9/mL4Eib8HcFb2Rnr5cFg3ts2tnjFIQzO6arj5lxG8NbZxzng4Zo3YbDoNjW3eI3hC MArEN9cPnLfHUGBWBZ+3zlBmKu4OR4OPX/BBunO5BEACK6Y993h83i0W37mkxacH1JxFekWBHgr1 bhztN2HvjPtF1friKwMLN8rLBK3jOB/Ihgi8wN61jgk922ueCLDF/Jyox3WHv2uKo249Z7htHhe7 GLHlen2+Bxn3QzuTjlraQ4R2ymv5geeN1DxZ7dtrS9k8rhitMuWL53WxXmxUZKMxsXctqfZOCVpz UzLWnAfpQ4JrHBPpJiJ6XqdQOiHUXSfK4AVrlXWk06JxSa51ku1Ni7zaOtAvGxZJoDIsk5J2WQ2L uWhPpPCpatipuA6pwXSmCWJYmcdIfIR4TBJJlTKuCdF2JnHan3TBMyYJpTgCUrxA7pjChbE5DQtC SXQkl0A1JwA6JrXcla3pQkLYmxMgmcdax4TwnFKryqnZQaqJxlic90UUV1UTlFEodTt7WjXGAfAT E2SdMF1mfipGzlmBghWQMDCw7q6QYYwxAa7prC3BMorQz1WFZvZZMYsBiJMyr6xWw6UZchXUIhxZ ZoWsYFHMVK6YQs6fQW8jA0wzYXuVZfA0maZlVaVN6HrEttczedafTjhpimBYgPWGLxhErZ1WwBOE zwtEbIhwyBmRAzzKj09bsmWnQzvGzW/c2s9o51S4jj1BT3iECqFOzXSeqIhWdHfDpLgAFBsRXJom k1C7BKlAKJKyllollhKDcA0smBWiBVakJCXS6XS63AIWxMwJJUpCSWYgSQqWkWpYThh57nPl0yUz DzH7K9KyGeqicbJm3t3V6i1x5q8e9ggHSJug8jRPCUTxFqNYr58z7vi0WgzQzW9590pcxNUqqGzA 3vYtqZw+uz5sJUH8dDf8eEHwpNEBB75Bb9HhJC0miohQ5RFebERKBC+IdIyILVbLyosgQDHPmLDm VEQLC2vdDEjUyJHwmIqItDSkJEt25j5IE5BKRW+YAG1oChcN2seZ5ghkC1bemIA3/M886vbg42Dd NkR+PU7fF75Md/E+9CPPtN4S4TPmn01fICGBNvOS/i7zsrGbOufn+xCcBu7AFiHKFJ9uGTwdtC3P SCoz3RFMAgLWYgkbOYl++tl9sgVBM11tXi88e+Izqdjj4wvehUiTHjQcpUHiBPFJWY23DxxdLInA DC8wu8KEk4IuXSy5EgRPHdZ+N+K7Bo1oTyfFEoowk80EN6+dvXGqeOOOd0fUIFgL+PM286fg4CFw hqY31lj+JAD4mq3jHyvOXm7A/h2vi22b+gA3oeD9yx17zmS+JOY78h2h+5bocr6+z1sYSHBaUNzN S1mhWEuXYP3wQe8LvpFQ2D9wkisRQIPEp8aly9DOOZjxHXzct1bLzVbmczRNL44aWDkE8cZzALJn 6/IItEIvxT7vD37YFsYyQRSLGvzvElJDJDXVFYypx0xBe8xcFcyHI8C65+SKh7/b59wPn+wWKLFF ILBSIiigoLFFBSAioiojBFVihBYjFiqqqisWKopCKjBECKIgiJEgoEUFkVVVVVUVVYoqqqqqKqqq xVVVVVRVRFVVFVVVVVVBVVVVVUirFVVVVWKqqqqiCqqqqqiqqqqIwVFVVUQVVVVRIiqoxGKiKiKq IKqqqIIxVir7jemdnG9qMT7n7dVsdgnz7mbNjSHz1K4q2vawNrK2r0RAfuRf1IuE1/wPDIHCAp7d rZ7s07dLVi92RXDeSCkEIloILBOiBwRrf9vdzoetT5RdBG9tUcGbKVjA9wvniRE2jjz8znqxweQS QO9pB74j16PGli6B1UldQtOJRMlJn6xmPXoDTznztZK4wkDbuRcv76mANQAWCKTAIYjJ4OYSjxvC nbbiWIFc0wQ4twpAb76pEWzvDltOB6F7Qu7rwcuKGsCfOQJsuk19ELGAyPlFsNcP4u+wP+QEEK/s DGN5v8Drf55Tzyn9ak32i3jRmyWXZdjVyXBdOmmWF4X1Ll1Rrr2FOOCwy6s1AiZSFxwEPba7mQJX furzxfFC7Wvp5wmB+Y5bCZ3Yh2gwwuY2oo+vOinWPFAJOcX9nJixfdfNNHwm62+KrKuYAvC0WApA kQvkPyO804+0pimrnCYavpr5ubfGs3PbC6zDr81rNawKacVYa+0xH8SDjhP6krv7r9yeSJhercY4 7rXVMydfZrNFdQkRnexjhwHEBLR5BxkNKkANEMpZQ1NdNMUoQkRYU1mJ9F/Qc9AgimRAvzuhV55r qU5x6L/4IuiMeeEAHkHxrNoifog4hou95RlZEwqWuHhkE0PONSCgRA907fb6+bsRDvpEZAGQpmZq TSYOLXDvnE1sPwLG/VdKCaw9LjP+xD+5E5Cx+aFa4Ny2MOuyIDb3NWt+Kk49x8F6tf121h3LI8FJ Ij5EWyYPOkw3Z39ajQQYvBZCfSfdb7Sn75kQuAPMzjquH0ua+cCF8tfOg/m+Qp4efMfN8LvOeR4p 4WITJ5aTV4XKjODgcRXsQH1HBE65ke1jB6A0Ecl3XKaErUHSulCdiAGyEx212DSAFQ9dBSWtTcRO oHvhtS1xDa0iBS8DqQkKSn4emxzABWwtP+BaiXPsPXx+LkOfi7qSLfHUEPI1nS6+YL2t8o0fkTXt /PbIyYD4P1chw2MC3F7V4Q7bmPWiosl220YP1JfX9AAoA/ABMQ3HzwgCALqd9OyeLql98wEQY+iK BOPtNV9zsmo9dJAFIFK5jVkIiesLRKKonyInaRQ+6bziJyB4yhs6NBNvUhCzrGIjDpyEuxCdm3w2 LjsJYNaLaoDoj5zVW91wH9B5BpXxh37DZbbkS+t3QfhXt7eO5RONot61t+KwSblrbUNuKeDi38Es WI5g+mYO4Wgg91mNR7cMgZb/Q1jFs1h7v98gR91h2gRy2vvXsdGfvWiyXl291T2fDeo63T3lCVrz S+A8nX1y/d6Ua5jnTniZEriWB2X4HDJc46uhPlWw1hcc5f58DTqyMtZVHzhe706nPI1u3EygX+5C hjMc79kWyKCJSgUBdfXn448/OK42iEbdWIxbctNMVWUZjMs9lNLhlyHcpbyIQTs9fK0FSEJ8p3oE UbB8ppaxtI0aDeclsfbdxVmWutHZ1Tix9UZizmlHGOzCKMFrha6sPinnb6nGHu3Za+hfOMahDZXh ZUi1sNvNnPpyOYRcDT5uekrd5z0amunZQwn4QkKc90+u+f4IaXd0YrCEvqFYh+pgU0OY99zmpkA9 nIi6EVtY8AXnIvwOCk1CA+zzM1dPpk+DX4sZiXG9Ox3r2gaHssrmELUquQgOZFVTLSD6XatN4sOl 2xpuQzmsEOoK0mje+aOEp1d+PnnxvWtedx/UiuQ/YBSGyKsb7jve+TOMWcX8Ph+RXXXze4Xl3iRr GIUNepZ9HTGJji7T77oa1B9Lrd0XbYpTv3oaRgJm15xi+WmpO133UH07VhGSrc5ib1LCwfPDkURM AP5kPyQ/YBh7rsa/fg5z6u4VjtMNvvjiJT4N/3AFMtY+xa2LVpLaqJoh+b57d5jy5rvtbPqb4NGR PVNZ1A+tBzvrVTe2b3Wuw6gmELEP0BZAcQoRbkEKApOIrNO5BttKIRLXCj2gu7FIQFiTJshpBq2S 2g+0jjSTdCDJyidKB6rPNIyvAtuAi8txxrLH77u/LfqQ1oL3X4wI7xvOdBXnGz/kAQyPb4U8zUpf 5d3nl2EAatN39YgP6qcgNa7UkmVcotSUhcspIVLkF+lNibC8XoGpZpvSF5oe4FqWr0D7LGosSE2p 4HitpLuPMCkDempNgZFyJJJJQD9luVLwTWvJOC2plN67EGpMqHBZJvSFrQxhpShOS1p1QoA7LVgG ReSWLWhqXIPZdJkXIuJJAaF+V3pwWlRmkk1Jch4ItCCiAgRcnCdr806cLapa2sUY9+WMetL1tY5h gy8iXSAyzDx+TiFk0MVSKIkUsMBAy5UJpzCJmAhQavUmLsgyuGqERi4FFBiWvIUXiJJWrwYMMMxV 6FBwIUNk1FUbNnCJY0Ja7h3V3xWMCo9LfKz1832lozmHdoG227aG8zljYhfkOI5vV0shuTEQu8CG eFdzQqmdQr0wzGU4sl0wpCVXSSBdbLC0SFlYWpUQRZGUslUkAoFUqlElJBshSs0KBEoSkClJge1f WfQvIt7bcpza6pVW2vk5l6tcjU2oIxLvWng5mY5jM1dyLjWZY0aa1m1i97i9LyqcoUAlTparRaeK FLRjmtdkyqiIuzkMHp5EUxu2h1wOoQDzurh8gVt86zrb+qEuQNgJ9PzPu/Jf+JyhKB9QsfwPB16x 6WnGVdSnUT93vbvsLVTIJ4hFA1CaQa3zx5WqW44yqFIQPZK2PMGtnblN0624K8NfBUlBDRANjx2I CBbiuQ98ogXnw33gDAz57Uvc8wvXJKJa2222xcET3MR735p1z+wTrzhnXEF/XVM5MOpJjPW9smKr kfTmmVVdDRExADujSoZjy50VJmvQI0vvVeOu/l5CUG46bfsuIKogJb7P0Sg3Zxp9kPCJN+jtnMfX axFFn01ISte1uXXgO5Q1+iW1tm4GbNuwqQOYGRcEIIXkEEAWqISEYjSoAXou7pCWYCGAVItnZRDM 1eu72zxbNjg6uoVTx6FBc1jrkxtb0NDjHOJjWE5ijTIke5VSa/ojAXl9fu+KE65uOr7iwTX5A/Qh 5IrkWSLgzDdZrqaWaGxKU7GwhRQKebrzdbACNczb6z8Gd/tpcLWQB3jSHRXbfxbNMJReu0ogQJbP 2VFcWwXjnmRwtkE80TGnDiuMAmaDchOKWMFcVAquE64JUC4EJA85L52QuloBLrvqV+oBqlr928zT cxnKiEgwc66OfhMmKbe81TQiQqpGvPnJGPdmVheq21ImoBm+5xy9NfqRTvNlGXZO4IhkE9GAIbw6 5zs6CEG4HY7EAeY4jFfKYPe9TOGq15SAwkdSs1z1Po6SqF0DW0rEN579VtF67RzzRGTu5kUHg9U8 xYEC15nvSzHfuABr7zhdTAj0Adrso657gzaPWnT0bpg43Sk+fHHHG1siOoAr+3hQnqf6kNKRAYIf Q+r6TaZ+IM57XHxf6NndZgkVPoOLxgWXzlZxdfpdKVKMU9W5HbseEsN1yhkikPA6kUgwy1zTJoOr 62fwA7LKObBDtx+CFCGT0YvZSYzQCIRto4KWAVdkLOmJAiAlYNhvIgqFJgDAnCrwYCVIrZDLgDhq IzfuVIYIvRa/Lc1rW9gCAfYb0aAFhpzcWAu6Ks0TTN1zarKnnCK0YdepTNF+GWuqd1uKOa6k7rwB L1vB0bdFt5LIwxS1U8Mi+H4szKwZlYlVaYhAiCavx8K7+3o09P7vdEBBts0BYy0ykfoNglM7+ar8 1wTBCIQ7p/gER11CK1dig83i899Tbdr6+PNkKWlIPOOc5OaJgObH3vZGv8cyH0DLokFgZ+twPlPf P3f3rxqO8W1xdlcPfhj2fWZNWv1bwxdt3TGG85WZtj/cegELEX9yGBbH0BzSH6SXFrhEajC+vxj7 AvB9QWWP3IC6v+K5AjPfU6NaJOTKx4YNWLaGngXRKON3JimdjYZTOClPhPfSEprYiSwunUL0AO9n VaKn9SKAloqsH0fdTJaMx9GzFgswb9Jp1xRz4tADqTugNdK7HwsRdyKBFZwP6GRnqotr25uTXVmw GhFM4TeBVPsF5dPdT07Ojh6MZTLtveTisZvxiSQqmiVI+APFXBKq2sdGtRQNGQwzq1h7Azemxa7L nbLNsCw9dBoYOQiW1Y60fNP3L3xupZCkeg43mDUnE9Vv4p5ze6oC9AcZ4t8zfdYhXGfHbmt+/Wxj dvnXeSGVuD8GhfN7eeXGI7QRkyhzgXFx+Ny+nxq6TF/B39iK2e/LUw1sZu+DbnrRjm7bmvEcSabu MI+4XKIi4zQ1uT/knRcKKL6r42BiHqsUJmYw2k4MYX0TiU5EpmwYk2RxtomYFExlDe1br0seqHzb VHciWpUUMko08orCxCV4r+9W3NBf0Rae4M+sFaK0lYrLXbSrWPE7befbx8UNZuz0W9nmN/Xb9M/K 3v5g+kAIm4nGSG9AgRAiZ3V0n40THxNAJhNyrRaVGjReEtzrU7KhkGzu/I0AIPAjor8N/UhHen0x hQ+OBkGbIHO2Rm2ujorV/wvd8hd/gXoxLpdqq2GjUda9+LzsKL7RNvHMf5BPI5/EhFazGt7lbGuL hhat9GL4tiR7bG7QyQLkF8U68Mxr26OGg9mJiUXPOrLbtkaTu+dbp53rKXa7pCCOWfqjc1mL73vV uc5ccFo5WUte34BRs13uQr2Sl6uO4/mQNYOy46nRF77fxfZwftWxSD3GSLhdGQuL7YHZXgtYWwoL m67bcYoRWJXxbip1zvuupXHI7u+zkmsVe09TyKz1CRGbqp056Kq2Tq58Rc6kMk85xGvNjUsGO7Tw 3XQD8SrGu843jUNqb1t6vbWYrW78YQ0ZLkbGtZTaTcFbzGugxhdzjk7NMekJnP6EWdexld4tw1U+ vvfhyzjrxbKCG9Vzty7Xxdg12XHdvnShJ3eyis/4IZz+ACsNBhS1HrbbwZ63loQJ9eLlZRWHoj6I qs7A6SnpHNINVZIQj8BRF+AB9yJi5tRzEcggy1q2qb0Nycg6sM8NZCfZFbWvpV019oj/j63OUxtO vVXXMqttXjCaqz5xPOtVoVnk1FtW401uDoxgxgMZF+pD/YhrX4TimCXLWvwlSUJvGlal9JrKE7A5 0ksk4rMDQuJOS7AK1vSwKQ3GJMgThKwOAG1ePuviF2JkTGvylK6Nq7y+IjSlhsAnzUympNCnRDgv ZL0oXKuoHQvNey0LSVjJcZsSq8bUyL2XImtdq8RvWPgdacDUnBPlK1zLuTBSlY2iFhamQgQ8XJtF uHcu5NAHsnAwh8xF0+dE6IltolEdaKuMq6Y0m1iYkD8kyWCrK0yo0holFqMR7ACAI1M8u+LkNkgn JgK2MCGimV2qbhnd9jeQlMoZaWhTaaYo6tdBowXBy1GnAFzZddQjCURSvoE0K2m9QHyDtMZN3sMy VyBi5C/MaM6dR7fVvOeiybdTud9TvxPB1uzRNsyvi7BmGjpjvFS7rJzZjOtardLigLoolAhIALLk EwtFoJYSqhChYbJRKrVJWSglRSRZBqIVSi2QlPtX1+fvb7v2c5xWtc5zm983zjGMYza1rWvfNM2n ZOFTk4W61HlJSy1EhIRCAjojonP7ArpxvKns+nXA2hrHiHKzRqDVK0rIiHgOUDwhJWy5XAufXrU5 NO7uKsBAhAUHOyc/Eg1I4ninz/C38SqdBe9NsvPUnc9b/xsAJzA7eqj23nfQQARO6B76Kr4d+UGq GLQmmLndeuDKwiW4NsXzxTbS6XUIspAPjfz4qAiBxCKob8b+h89X8QCIZhEFcwqKcrCXOdbYOOrY x6lUR624gEmOfOTmuKbPabL0Oj8aRdgfIlttbA+yLJD9SLJUZAT/DWSb0kkKxfrGO+Jrb46ztfWb pW4iixzPr4W+0fPabGPjYSURMFde7dX9LAC0SEAjRvxct0Tvv8Z6wJsedJnbOl0kJ152EdgKwyoQ AQCedGeeDhLg4SFFhgFgDNd75n50XyIOgd5RNlhKA++NudWAKXE3pt6Nr+LLhQLZleN9sxfF6n5g dnCWGyc/262xufJTgEJPWo630Pn9QCEZK1cet6beUbffjXSLC0HxKItnZlrLiLfZPlNq+F8vZL9N kGOXEgIg0UTJZxPZOzjuhDDYZBREyGNc6UWoF06Ca1GIgAwikuuwKLdC6D4IGlBPUUicffCUSkJV eob7/fjAHNgopSL4gDuFU8HZ7okvFpn3nuh5/rihFjlaV0vWLxZE3WF5pAFd2CBvE6M3lMplrZ02 d1j6jGIjChiG58Ce3nfOxa+r10YcF/Qh/Yh4NNFIwzExNTxPnqtIxwYpzaIt79dAvrPvqb7oXEAQ qrEMDMqPRh8ELwasRXFvZ7fQnQX8CCKg7LNrgBfqrqZtHk986/SKAC4+Mzh3In40i+s1wvO5hN04 OQ3onfRmx3YcqFimMN6u1Ip65zc511OxVEEic4I7XHBm6drhFxB2QaPrAJCqDmTzzaKH+axJBMJc YxBBASixgk4md5jf+pC6tCyxYEsREoyhF76Mdvfcnu1D3PHOAC2ZCwdxZBpyCkNZEdkhJiFc+HoL 8oi5247mxggZEyo2N6jttu7LxZ2BBYrwpU+1Z2BhOHBhLQBWSLduuxEKOodN5TxbHFyobDEP9yD+ 9+tFczbCBtMk2xgz8eojX5GYBxP0OKVspke4Fvff0bdwe3ImUP4NWIrH4LsxFdWWx8C4VuTv8AyH T7b1yiMiAHgtHRZaa2pbNl6r152KAYxjus6lYAziwvPJurYrDt9pq3Ysf7EWtVri8nStb4etRnnS CEHT58+7A+oif8COqd8KPmY8VGsZAgAL2Zf1fL+zzj+GWfu2/w7VEqqXz98Ss+W8QqW8WVx0VuPq uDlW1bXUE7QsDmLWHOW1ESuuoalRyaKFj4CAxM4mkssolbzEbVLt7zlZd9JY0lPaEnrN87Zf6EUk VPuPv1UPdmUojMN5dVsdpDccfRAHmPPwuH3aGXzWIQ7NTBvPjK/zM2QZ/DaWFgr0Ta79kSYwRj6x 9D5wurKVnPAdcjThN27uc4NzHqYP2Bryrt0xNWYhjN2t8TPbD32ea0rdfOlH8yKWXTx9HqrPgXSs fIx6MfYHSElcN5pqt2PjKAQIM/udVRxFz3qe9ut7FQS+ZaHtc/NQTNGlx9x5ZakeSS0h19xnqeH0 WxO051+wLaMJ4uZX3t3RLc7uwNHF7bWBO+YeloKuqgNhN+Tyw1hfgwRGxoLA+KqGSEV8Nl9a1V9D Of3MGZmZz9C+eCVc5Sy19Ytv5tahmpX5uDyfvIceDQniN8bmBbcW49kF9PGdZ8WkYDOPL9x3Ld8j duhTtkHSjd+5Hr+buqJLT5fmcXe+dv/QiF68E5PGYKed+ONFu/fXBnnu/naddAf0qQvvoyCiMpZ6 0Tc/b3z6OtQBrSZiLDVpMmquJeRQFp0XWROqX36Do1+fik/LtfFh4HREQIi2zTiTfiR07LIS3c/k Aam3M2VGrmog37u6TimwEiJPXdrBy4flge12ms80Y3P5IgHIv0Ij8dLajN7GK/cMPPEdxxF8v54J SKBEACLx00fuZYfO40f0Q9bx9UBOxyXS2bh4nlU02nzOLp5fjeK9hnRrYYyNIuXa7VmX8wqdb+pF si+iLMaz4y3PRprXEJk4yKPbGvJt5Gc1Rv3z1BsKNX5RoNjDuG3jn9o6GhFgd6kHmVXVtyfN3Ppo NWrbJhtWu9l6l7eZWyM9FFxH9iJ7c3D4m3PEvqKjerfdx0NRHYjfrWpCznOPQNPkbHY52/Mbxjc4 fZmespnxbtpgxCtEXdi3RepsDZeV2DZ8SMc/cimQb8vgNXZ4vM+AFSBg9t6F4x0Xi4Y5x3GMOgUb Tko32C+yGat3k2R+1jmMfoQ8k5A5pe/ds136q5XKaQSsdQ/qg9yJPUc3t2b08Jjpq4rmKG72VJZo +6IDYAkg4smf4gpXydhldvXr/BC3LNLx6vBbZ/Q14Dw2Ex7+hB6YzmLyna+EWuHgELiNsiBWT55W 8Q4/IzbCX+kZB22RGCymPnnlKtbzK+++m4PCdE3LuTYqeloSxKVoX3StPdb00r6SpLb02gGJOyYw K07jYka1sTIgDlQ1hUmVOI+6zExLCdy1YWBhJJpT7ASuyl12tBERERyn0hIFNJVfaAMgkkLiATBf oN2odK2L0TYlIl4BG44KHRNaHJdQFqaUsSpKU2rjTWlIvJLEyGtNanIsWtcyYx0hGVNiBiXatyZU 9UTyQeCDSJ8uH947d86eKmVZTAguKFFWmvwmH8xKXJ84VlKlxc3FzRtbESolEsDSzqqQXoTJKGnV LD085KrcwGaHy2nQhXKuDLE3jHGSS0hcD1bKGsuEYvLMFAmAMBENmmzIyYp2ELMZRZLvRd4ImC5j 6r1Z7n1jN1fW5Vff7q2sQ95E7HnkeQ36wyeY01aXRK6LGt+FdZ3LKsyb1rcrJmt9ETKErRYWUumA aBKyDUaLCWSiUSyVBiqUWAoIVBkUGqUSkqWBhKJI0Gi5Nc8n1f4/Kv7vHzqNtsTg1xIm0omLTDQJ lZmVmZlivdL3vd5ELZ3u95vdE5ROgExAWEdu7wpeJnu/daqpKjLm3aKDVIyafFK+f4ohYyQSAQUT L61tuFkGLdVbf8aQ2hKTDEfZ+L4LoKJ+kIIFIQRNTKpEQ7ZPkSYsDGDzNv0XQWumQc6IbSu+zois RYWaB3Xbxnmy6uAiZ8ERvzbrMIPOraVFdFazTDHDwdDBBABn9LaeTIbpeo/OPY7yCyCkhy0Pde4E ncZyuoCBmgQdks29M+LX887aq1DhM+OZvx1tbEWxudD+9eBPyE2+OsmIpp9WiZi8YCgw2CFlHAgK jU1aykQvf7ohfvXchm3JdfvIH96IiIY+No2Me/q+JaboO6QkJCaSFhIQ+qdeePX9aEY8bes+jYAx 68xcnHGrrVdl6ppAqkJqAdqb6qlBUZhAAxbbM85+84LImya+6RJBgWAL80Te/xfn5thc5xhW0Jms hDZggSGQ2ZBPfpvx8oZostj0I7cHzcXWy+aHIxYY+76vQaOicwjQca15y6kB2WxJ8D3Wnza17HFb 0nM1rfFVssJKVwuKRCZ/imvPjAKXQUHJoilZ04dYxGd2v9C5BCAHrHoHV6IWIXupCl1sXvLdnUkO cOxg9wADEKbqFEHLoh5khQMANSJgyIyK90YhTabkEPrPcXqu7G0UALSVjK77xLYtMUPRWGqGpsj0 gmgr+jUX/1IcItEOlbP6jNdZg2suujDYshUnnyVx4A2iDrquqp/HAIDT1g6rXK2vlJ3tTdPeSa7c pdaJmyT58cW2O32OW59q+9X6RffhFnqIPe16fY0FDEQGSKzR4zV3ET5gFRCxDl41NxD5GzcaIAms dD0Gm88GE0PM7auXGq1oLCxWSzVpV/4kMEKIVP14RmzPfbeduy2IrnZGulz9e9vX1aMDbPqjBeSc m9Y8wQ94311Ax9e4PBBn10yNKsNDHyp0+SDgAwW94jY2+M6uQkFjL7p1ghdFTx9VcEViKbcT8EU2 O3r3s2/ctpQefOBkoYz0zmMnj1z/31f+5FmPY7v6jR20D0WGG8EMCO1g2qULTMnPaxVHpYAxjSJB A5ZIp2jrdghMLL6kW2zFOEgh9qBFzQdtI8rzU9LjiCcRJBTNvmEwa+F6hC1uwVu1chzG8LrQe8z8 pM38b4ya6tzIDZC1ZmblxO3Owud20EsqC3W80MhzXM0iqCeqUxqRYkbWhz0w+xCXzp5E4meAis2N iDQ4C9GwxhznPZPNF0XEYrrB2WQdtBC5O0W8XRmFEFsya5LZOjchcM5yIKIR00pMMZlSGmlPogq2 qnGljVCsWtCeor2mdQMfvnDCKCj01J389uZ5l5S6Y7cBu22F8ZIbJ6cZW3aUU3BoTVjFJyRYXj6k PuAUIdSsEoMGAcdVIPWIipNQz2CEHhXKgRHbaeN4SrzYG6z8PwuscUUyp0CLzCwkclhg52YpgviL 3tOjo0w17/uAF3ayNMP4+ufB9PZInzX3ksNI8vweYFSIXuWWrtHo7iwWtZ5eHD89deGjVS5BDzsx qt+LO6JIAgb+hHWO1Cz+gDy0WydoRnd6ZpeHLU3abDoLX0iQ0uqYZarmtfvkLignBrdZ+vG9viuD UaH6kV8nPk4XMzdvQm21uYt5N7fTj1TRPe66okTV7awsDlepnLn1dUMavzGe15Z+bIgPSHOiziN4 UWfG2frXxvWIbjjltah3cgH6PJ5usQoqvALTC7pIAnYYQX2Iru01oxWaOnlvrWPH+xT15SrdBzmP ude+dHZmWuUjozoLj6w5683ir93mL6ROiLm41wI/J0Ledq/mtDIjXJO3GrMn0e4iyQaCABJ6vnIb /b6fbXVsQRZrqvNZ666aS2fNuVKXQUZGu1uxFOjZRdcTgJO5EUmzkkWZFcIIdLvBDUkWkdgSyH7T ILX2t+kd81fvzMYbafuQVA6eYBJS+TxNhosLQ0vJFasJN6BnMHQP8mYMyNckVtaapz1mxFNG2Wh2 ORe0iO6zbFoviZxd4BQMve15woq2qjzdnJD+Z8zfm+tXOZ46eW5NCfLb1fVoNV1dZsui2iAr0Rci CWxEdH5SL5m16arwLhUnBCVhbUVdq1jLDrU3ZgnqqZYVl+RfZN80MfuQ3siFGz3Hdwuc2JJiOWfF +nlxfc+V5MYTdbtzTLnwLjitngakpUjKpgB6XICHPb1BF8BEIOK7qTCTfWomGeSLF2R7bsGFnv88 y1QuWRxtdr8S+f8kWOCEnb/REomeQNQLR9dyuc7qw4Yft9LhOczXjWTRZdcugvdqfmv6EIImHBqN HPM9PePA8NFhjB0ES2N8teudEcFJ5k6O1t6xf8ADGtRzIhmZe6yLrWjm3U5b/Yi8zdPKrwi1e3t+ 4X3Og7rYYx0NeRAtHa7kEB9kGAAq39B9Xl/pqTG/mGIxyvD4/nzqPulwxCAfNvc/b/1IoQ16egYl h5NSNWTgtBp0A7pbkNozEpiupLZPNtoHyeMatqt3tLRrbfyZmR7p5IRT7bPB75fcbAmmhRzpqRoX qsLzToONfhMSzxpauYcEygS4LSnNcE3LYb0yJ7qNCZE2Glda8y1OibDmBiT4DgtwHhJ6lL0yj2Qx rwTsPhK12LP0sJSj8pFqd1gHanVbg6LC4LEEVLlXKG4SANY6EDsu5KV3JWuVKU7p1WE1J6M650zo HVMBEgDIlC0LrKU5odlsXohvSaUpeukA5JnMg1IdEyhGJMChcwbUyrWmVOa5l3LyXIhP3VsC555v /l3qDR2SHqxo2A2B7hzgafCKQDzL0Y9HtIDxATIVOwqqHgQGQEwUR7KpYRRbqp3hRRaigL9kfo9x 8efH/PXs3j9QySEhP88+SsWICLERWDFiCgokjIsF+NqKsEGMZ9F2KX27IwVUP99oqqirERYs4koq qxET20KwUBRZIpCKQirAUDSWtIWSsUFhBYFSpUrBJRIhIhGAFEc+nXj8xz5yzV7O/vvSJ9/e+ynj 6ql8uOF/inYAT8/VX0ppNtX5mAHpshdG92o1n09/f6Z51/Ujp16xTc22+/Xb79E4pptL59hzR225 ffwlLR+O3HTW/btajO+yMRbv1d6FX89/OKsslyY7AvD/fpScTR6v987b9/HWHf5TRnjTx6CfPqPV XuHnhXP512b7i2muIqTwvx37WS2O49RMR7M266cB1vDme1bq7bSHT0jdgRnjkLw5+zNl3yfiSry4 755e9fWvJ2Lv3TLxJWQtSWpVTrmVuGrr8bbv63T62bmeNmKnw4Xa6Le+8/jumypw4alSr784ZThv Q/dNW+BZjFXb5vs2NbQl0kz2i/hzs64+etI+e/K8lcm+prz8x005ojrJQGD/3kB5vg9DM/YnuAaC dQTp+edqrFGHgA6sb21tSlZIwVxVvn8vJ+966jFEIKKEUgjk9n64mr+TudJUmWeSH8IM5nOZzmcy STmS7W7u3u1F2tVTVQqnqqand3cu7s5FVTVVNShFUVVPVU1KKqoqpaiDVU9VTVVU9UKrLu7u6oVM zMyIEREQSqrMxEQ4gxEQQTEJEewIoAfzQhgVhhRghIhEFIRAVP2T+yDAVEcHMqktqEIQjKUSAClQ lkiX9UAhCpJIxhIlSOGgiQKAstCxUYJC0soowlYwClgoLFVQLBjQCkFEiiosUSIxEFFiKkREQBFg xiiLIKjFVjJBBioqqixGKosEGIsYQ9AkIShYxQSLAUGCMVVQUUVRVkLJIWEqIrFIoixUEWKMRhBY xWKKhBghpISRojSQLKqSkaDFUgWESFFQiRVFisCNlAqotGS2BKy0CMJ0EhBqSlFVmUJFSEqwQwRS QURkogRAIQ9wMWJGMYhGLIxikWIxAYkYyDFjGMYxixIxIMjEEAZEBJIQiEkQIjFJBkjFkBGSMZAY DJBJEBZIDIAkBIIAyIAxIDCMRixGQIQowCwpEFBa1RQJSlJWRVEgwZEIgKIgJEiRIMIyIMjIgICR IgMQIMVCLICigosIqgSBGRYyRCKqSQZCEhIQ/7tmbLB+lE/6KikBCqi7QURoCiMqI0BRHAKI0BRG ooBE4xRRYpBYLBVWKCxYsUFIDGMYqgxFiyAsEViiIqorFFFWEFUWERFGMBQIoKAiqqqqqIjFFEVV VVFVURYqqqqiqqiKqoqqoqKqoKqqqiIsFWKqqqiIIqqqqiiiKqqqqoqqqKsRRVVWIqqqoKiIiiqI iKqCKqqxYiCIiqiqIoqoiqqIqqiIqqRFRFVFGHoEhBqFmoKIyoyhCKqQKwkICkUJIjCBEYKEIKEg jCIhA1ip2GGH3xpNBDkj9AcAKAKEaVmz9sDfGHRSQihhgiEoMgYxSHDqwAdLJ1IwGJ+YgTCQ0sso eskRFHqh/J/5/5ER/25EgoYh/hkn/Q3P9p/8kqf8f/B5OL50kKW0oKvoH9JP4DPXezb7DtCEgyRB SAIkAkUioyRkJIRkQOiY70E8P3hBP3v8yB98cnme8PBTxA79EBRkxZ/3/7Kf/BDruagNCPhG1mRE RAEgURnyQiiP/vP+j/1KT7CX8OjRSP/OwRCRCkdFyc//1J5DP4n/7k2iGDqJGYIv+gLB7GMh+yPN kZCifYPhqm0waoKqDsQiJCtKSZBNBPzAqEydBMQR2aQxZ1NwQOzWQPKebMMx+nmILKdFMd6VY/p9 sJ7hBwT2f8b/Q+5V8SgfWQLTSiUgdJ+n7h/ROe4wbKzoq7c6TbiMxxJFKQVpemlJzBEYgYYcxfcZ w3F2uxsthJQaJB/xM59UMxTpN2LkfWfR2+KejEvvMfrH2fCXpP+vfAr7kOQfgeaKSYlEP/DFD2h5 H6eBTh+juSeJ5RORUiapAUbka7jnLRXstC1ySkQXkEkYKLTcMzsPl2vkgen6PH6uezu1jEFpbBFE Eoz5TtBcTyQfsD0jcguefjVgIeZkmUmGIghYYvgksF+bdMONMiowNWz+unKdD2MpL7CGkt//1zeV +4t9BH6f+fv/AXg/y/rB/xof5h/7SojoP95X/K5kzNSnX8mCef8vkYBfLxJmARgIQYIskEJEgMCA yAgEUEIhFjCMkYMgJIiCRkYMSAgHJISQCGQVIBVwmyH+VP/KGNXoootlZYAJUdJlD/xiU1dIgsDy QY3NxkGlcgsCHRJsE/n7xIoiDBEFFWMEURRRBFGCxFGDFiCDEVYqqRgiCsVUUGMUGKIqKsRYKqCo KgiKCKIqiiqiiisFEYqqKqCDFWKoxVRBQWKCiwRAViKKKIiwRiqpGKLFVRUGDBUYiiIiIiosVRYI jFVIqKiIiCKIiQRVgqAiKjBFEFRURVGCKsVBUViCCkUiKIRBQVUVGMQUURQYjFFVRUWKIKqogiqq oijBBixVWKCr5eRkREylx/407S7Inn/Eof+G5Jp/4MMEgGUAu1IP/GOJxrPeVEY6McfyoJV+Zk5A nqLkSBxkP/RCArDIEDtC9wWYRtMr8f8Pjj/L3/zmv/H/hT+urepr+tRNfm2n1tnw01n+wf5o5WF8 ftjbR3HX9no3+eVkiXhpdmmVERDS7u4cqQ0y3qAnHXj38pdojZEV4kSoTRy/hsSj0CJt2jRAg697 CD0avCo7E9hEQAIp3jFq4eTwj1fR51/5gBUZ2/cuI9tphaZufKCMJGsPbro2gjvGe2CkWyH6kURT 3Xmn0zyCVgKWx+4G6t03R/9yIiF/Ky/ztNisDGahMopp7jFeDF4PrcIAAAElso4rOOePxw2YyLyN 43echrZFQnkX7wNP+SGCDz2eRnFj93zawqDzegeCK+kGfImwvD22JsICkXdDbYcTyNcv4Fte2gsI d9vR3xI6D00cC5xxqS2sDGnxk842F5zarutdXrv3GlH4IpkX4IvZDBBZEZjAzi8rsWKzNNFYg0XX k8LS1UYMv4k/L6hny+3fGTvWM2u3K5eT2OSE6yYm2Gtt0/wBg7bzt+0Opjc6NPN1HnW88h787ptW caYQYohwh/uRf5IGQa/MPqDyPa/gC8xMYaLenUZ4nxUHvOK2hWcu9qIXxq5oIq7ZNXqnyMwjbT4c jDfM4zo4mmS26kTWRnZNTqK1DERUGNk/sQfhbq3u98WhxF0IuEP9yFprmo8sLofw9XQ8cOy7ln90 qTnmZB5FnRDkMNQZMYH8G15WL65jUG6qJ8H6YWJ6nnctq45wZ3w+mQiKpC5vZ5U2s+WXYL6IrEG6 c8O4GpoXtXdBoe+84D9l+eMKgbGqFQp6CvWvMxrlofYdoPs/uQzzTPpMH1cvrGu488ufm+xWN6Op o7LbLWmcZsHVnzZ+ecICwD2x0X4LsHhsSOXXWdcQbtQ0uMpSzDChuH7Nx3aVSHVjta0rxRzm5+EL hw97VP4Ie+wIHvN29GnxbE1AxY5HhMlVsxQfZyZAT2ISIcEMEQYRegh7arm6hSm9ydGhTqxuowrs NrxbiKtrZBNZ0LxN8/fzT30mM22tsw79pdtfcNCZsd6GEgGysFumzuu+wOYo7MQE7pY1Qe9iQi+2 vrHwBJBKEdbXS8dZvDHul1Mt36Y98wL4dZfG8KH4kYpzBc99W92RzWu91WzB5OLerrh5N39xxO29 9rWbRGeEaoC35njTD8OYzJx4PMy3nM4qdYwi5VRBrHkTiEQQTR00DXt5xC2tHznm+cPg7GJH5bGM CPROrhSFQaPMV/zpi5ny+enTKsXnclnSS6o+k5z6xqaINgd0H4O3xgcRaHjVzT2zPQ5ueroGWxyf hCABoi4QxZtyq0LW3ds1vepkHGgdrarEY1W8b5MC6d+d/YDM78xkVv3EuVFU6q+r27pSOjvXO0v+ pavt51NbMY3Ea/9IAI4gtQh8/b+P90j+wNCAoIIKQkyGD5EMED0imqb10WN8aL10dDceCJsMishR mx/eVqsbylme7fn9f0jWMsI65m7wwrAjWM8hG1qBvxqIilbjdVrZ/JIbo5Ynrns/7QU9wJCqYPFN 6zD354idscerX23dfv1EmlD9IED0ta9IagdFyQdppQBeAdsWOjNo1V9vJBEREESN2q7Xo2YIjnSa A5HKD0w0TvCMuaMTQ2oREiSqYOIiZqlOdQ1nQ7W5Oxngn1unb31ObPlwwCjlloXHvNdCdM12VOi/ PT6gNsGwAEf7QhBBQy15JrrhUR9eYPGOft9xhAEfJIIQIb6z7PoW1yIKvUizpuNkZBJCrcr1s0Tq DfoWQpZwNA4gzUzgNKbxzkdaQeaVN8Lu3gRxLdNmS2T2qMthFNFtcxLmTdNTFhEjS6s3fUUfVq6O hMnkV0eiJnwh7IhQqmy2vLZ+uH36C+3tEs0Xjh2P31gR+kVNpFBEACKEtd4bX1Mxz60CM1Z8zbK4 5V28j/1EV/evA5q/P8ZGnRK9rqocVi8qNMwnYibgTGn2IkJoL5VU71vSwU+bcWPLfPNTmutvuJ3p uT/hd7anjJAdUYPUIkwFEeqii0e6EURRJLFjGnpbmkX4TomUT0HlKkstQ+DGGT/CllUVKCSWDJRH owT2XjgpuX3tulIKZCTmaUlWlI7QOPvFG19QaIlQEoo0oRMnbK8UIYIAhXYmdNZtWlK1T48LsOU/ Fsb9/8qAprAFqP3n3GaP+k0QSlJDEGWI3UhO+2KtdBpSa1eVDUkty7NWaUCCCEByOQUR9o78IaAk mZgIJCH9c0oSJdfABguA5RRHArUgAiIhQ/NFoyKgfHo/yjNIHkUJDwL5Sf1Dz6ctP4hoFMSpgfjJ WSlKUpRBLwhKU/AB4JrvXoBiXMNOEkAxqwkQAbVpAxBnCjsvZLEhNKZV9JzSFOAH1pSnmZi6UiJw SiGGcIxIcTwCWSQhl87tOZCyncNBYhYqAI7Gx+AVDla2+Ukw7rezuQXDP+npflP7F7odYtugxyZM GJlKYp9k0ggDotzwTZJ+V0TT1VBggNS/+m60j3MgRBEJKR/FZBUZ9/Y+iDmsgfZOPrfmpT1FT4Mv U603Vtk6rPI4H62cVaHiAhIiEiYZbyhP8IzY1cKGRtSEtQrfuGcjuPhbDqdULfskFKf+EDXM2PRM 6Z0z9A+RNaSWtakpK18L1Tgu1eymZbDsUMmTAYkDUoy7pYtizqgZp7LcvNdKeyaQZ9CDOJIWyBA4 +K5Y+sfin4z+J/sa/57fn5BbHzXJzUhzuHLm5VJsilsjcibTbixERUMIg4z416/V7x+vgKf8bu72 1gOlcBG1d3qbsLbMrTLHwa+CHLBb2tvstrgv6/uSNd+Mv3SoJi2U+KA2q5NfBaxnXdn4HPpvvMVV 2zVLVHVCN4zKM7rqDVZUr10c8vpTuKV9GEucrMWSNcnebb0mam7+fB/sQWbQ+LIu48YzwvmGLIY9 1MqoT2/hxPrk4n3I0iPrdW/mQ+CDtOqqsbvb+JDzYxzBtKy3T6vfHTLwmL7Croy9vLvGisRJ0O2P fYjsdsj5AD6IF+oIgARM3uRuRN9rzpn24sl1+7DodPj+tWmvgLrLxfFjz85t3itRcJx8Z0z1nV/C ltXB6k0k8Wwm5aDbFstSZm23d9U628bXvexrqYptPlLKfKftT0n3J5X49Ebwia8dOPKYl2nmURAA iZ38a7kqMoUodpFPPSJIavoUstnf1u6l9aNqSrfUXfh7x3gVqQHcUMI20rgo+UQ8NP18C6QHM7Po t5r0icivbzyfGze34AGXr5j4nohWMta0mlde4tP9SAz5vrpiBVTsRbjVqwtzWGYz+nseVjP63u1D I42mznLfed876DuRNIerpnKRyUnzYNuJmPyBwgM2fwHNO3EpW8un6EH2t6/kQH2RX+tfW2Sesh1q /bjq2OPij4LOq/RyaML2HTbBuYs4Sdi0KxItIyXe1L85TntMBqBoT74J9PJnZUNnxhFmAdvSFyKJ o0/gCzm/T1rnszd9jx/T8t6MNa/abmWDLrDPnGKj1Q0WC1GE1WopRfGHGo3vHYyYZ2dvOeY2vOdt zH2Rbary3NpMTFr1673rt4+VoZM70xktT3XmOKf2IZGU/Na69fl+8KRSseHJnvou0qkbA5wC2h04 LXlKB0BqfFkF6kWNO4z1TEDeD2LWkz1i35fOqk8e8EZ89VDzO9jx9a50dUIh4PQvqnhPEw2IuK8H 7EB4Cti0qiHvYsiax55QxFhgYCbYPq5hujI6kjC4wcKl43a7XpPIR2i8Y/9/8SKp+HFZ3pB3vvd4 uKmPXb1zrde6yu8o73F8Jz+JFcgy0iO0qFnUEGkHzuF05PEyLtSZxmm+cZBhO+Z0SraLNLdqDx3C Pm9uo+dDuZCDj3amBxJjHXfOGdB3safghcz3OZCcH0RGRf4Iv0DmYq2X0X7d6BERSHfX0aEINCEB CEGb9C0B1XTLGPYrXhAWvgGDs7US2cjfZJshNtRHhz2m+UhA1MWuznW57naeefPqm1vXmmE3J643 4Psp/SEMbSoyH85p8fG+3Zt+gxP1y9/GcV14tfx+4/FPQef9pEkgxwiqgwBkdSHwSniQLppbiWrN UNXtubdYpg1ap7KiiY6Ndnk0t78tGKEuwrOJU2G8XMNeb1KC+0tMtza205zKS6bTNrG+AQematf3 G98wYXZ7WyEGLwFkfuReyFBW2BOdVrzKNT6EWmi3sBtn1i04LZrWgk06BS/UHNlwjmDp01lz+mNN 28a6Vtl3pZfl7jtULV3nbhQoZ7C7UQGyEEVDd9SMO3RburzZRnSvo825xb2TnOGa8N8Z5vM7OAgb cMGHd5dGdGS4PONrqd9tQujYg67l9px5YeEDZYxjizxtWg97fqW0V1WVXYUF9+MyGWjQnwnytY+g QOC/qExbUApllriGGezLbTZ2V66saw2R1GjdlmFLmaTD0bcryizE6oHqRxBBjKYt+mBvUc7Oeryg nwWnjTl//YQGJke9begI5wfZ26NZxHRm9/fixc2ofg/Xi/UB86BwWAWzOAwDIDaeyxMJobMKUDsL ky5s428y5GdAtA8G7kQfTzVrjydyPYdmnz2EbHN+qfMyqrdjELzE5t+dJzGGxB6JrXioCjD0me4e 68iyYGWyqurCVVU6Mdi5kwX3QByJsE6LpT5XQvFOaqIo+l3r54xFDy+JKoijN/2Ff5m897IkLT9/ SfX+EGtcSfZeK4x+ydV6JIXSIn8R1++VIFsWSiIAIentPfEmk/VA6wcAhQzLFRansHoYjuIssifC Hwv6F+UzgZ07rkXemSxfUjjB/vFQBDvINnecERM6B6CCPyklmZEgd6dU2KHBKMYKI6D4dK9k1qTH Ykhz7FlcmgGSY9oGgMN4vRJp9k2gBnAPuQuyFCIGkKJkz1BBwiUdklJoJUw0EB2TGH2HAoL8aey8 14hwPpe6707BwSNa7FmP2TivMvShIDGnBKFn905JjXknutSV+UjqmxKoA2oPBZj1KCS812J8LUnw f9j0aU4JyFrz5TjUWPQRACUrPxKcQfEgJBEpV12RSCAFSpbt7S735Lf1w4cftVEtckL+cLZQMpJl MCEmwWKNSxPhcIUWoMdFWUYIiH21GpGZ/kBAIAEoiAX+z9dfuOvGjIfIV2TJTmMlKUouiaEvys5v h83qmqqvVZzmIEREQ7vaXsINnd81l60V3FjxJByzEYcm67Ny3bzfTGos45BQFr38L9X3W7H/LWuY rPKGF/01hP6X7m7300vTXq3ZblamL+DCdvURlx9gAvBU8xwxJc0LLvBtjG9nysTWR5Nv7EXmd0mx G9TuBpitOev3D+1PuThagcczjxuKAltT+lGfAvzmO+H8QzgzFvmJ+4i+o3CboSu2b8jus4Td+cPu ti10sUZ8siXe/NeZo3ObUvU5vExjWIwIrQ5Dzjej4bkVYVRZZ1khYoK9yH5BdSDCE8rACC8EPbqW +dIl+YVJubjpIMDg8JZWwc80/nzGYx7z+Y6M6mlkdFZGDmOy2dD7PHh5r3WQt9+eh1EDpsRLnyNT iVZS52p2GtjuuVdMa/0Ivsh890lqx/EiqcBvN9qucHlrefLW6wzCZeQ3cmJEY+RqXqRhbwssAQuJ 0l1wazvlHvlY6d+jHb77XBGA7bFWVTFoSm2rESZA6KsucmR6guZE4hwOpBmFgXomaZMloGHTcP9N 7u/y5+e/OHr60ohMWwkzrFs93Oh22l3ON+1fVJ74ma54PN+Z+ELo/vxrjLcq9kty416r3aQ6aeSL oRakQEqoLWSVCcMTOj7MyMG164LUlzaqYizFSYaWDiZFr/kh6Gb9yFZUz30+W3kcrlkY2taPp+t1 41Ucyk3XK+sqZsXoMLo+NiJFrg4yARwmdzzkox1fOPSIDOzv3A0/L/uCAz7cJfF5WbjqbboXRtjy +z0K93tcDE1RtuGiB7dgd0yEu2dhtXj29oaRi783vevSHfHLedTblvEbOALJTeY1mb1nt1yRaIv2 BLemMwue6fJYSlHvr31u9rJ54NDGBwmrAPgNWflhmdBbb8XUf1AztbMudxjGii1Tu78gH24vx6ib dwOxebIqmr615MAg+0fFwB882bjoQzIWzbu2nd7L29k7uVE9i97kQuKEjQzm2jlbwGE2ZEfKtMGm ma0wF12sZzcb7PFvy2o5jWk3uuPdgsWNxldOs4e/JewfMTGBB3mv4EAxFp7DVED2KVmzngeNomue 40ffsizvetY98t3HgeCK2+VLANq3TpI5o6yoA3fzWtxT7W6w985unm8CISmqt1+aJrKpvzROBUQu LxtkfIdq8ZVvNB+SCkTZBgL6Aehj6Llp5+d9/U5/QgVAVx269Z34IxyahuELDeOzOyFH8K7qLUv8 jZ7T5tXdp/Nv7AoAZsKgzqzEggaRric40hd5yVb98BEKb+kMPCAhYNsrTOkDpltr5+EX23JT7kAp oRoYFmCQSogK5+yjqL9F8+wSEgZ20Tw62dj0VtCGu5ocxLWSru+UhcAZmVTg+RqaM6n1PNLvzxYV eYtD3lhr3sZc+tsLji7o/5DOH33XwRfq6bFXym2lW9fHctP9iH9CLHT5CX0dntNv2IZzgYW02xbs v3l5Hz7tviPpI95d7BAlb+byMXDDISbzSdvzbVZL9sktyHk7YeyZ4g/16YOrb1rlY/sRakBuQ6Pr phIAjCBq0yhOLDSDmEGoRbB660Y96GRTv6zT4vXXrkc2bDmL5ZAjbUaF9Jt+iXp+BzEdekyms6sm +oHlNbt/AgX/SIEQ0QjcBXzvQxvZeW0ZxjXjGP5Jzj8j72D+mhKz/RLQiAihYx1NixCMsJa9uzMs 040JOT8DXUSn+8iY+66pw1BTlzejSQSvhFBEv5aHbb5TGXny2gt8YNY5WBm+PsfPySeXtbzjas9K 01Ulaa9LUDXWEWNn3IVIEPJFbmaTJFiJ3c0EZdSGgLBCu6LpDEWMYWEX1yN7bSWa9UnNjXJQJxXN 8o3cQuPzvjBfz4H8wkkUCSLSLNiLzloUXY7Zs/RHnbYo5XmG0xoGBqetkSq8avqK1dtiI8aVdr5x 0LwPhN4SWITWhyXSvBdp7hQwsEYyFIg4BAxEAoj5STsHetBRtQmvYHIlkiwt7gHROlJVVG1LFwSf 99wNKbDdNksyBpyRd7DyWv6D7JwHQBvW5blL2ySygqZgojPNjiCIYpITindfZJ00iPssJjQuStZ5 wK0utzrAB/5kQe4SB0J0HYCL2TQEEllc7A4r5Fxp2Q1ISXynhPZZpxME0r3O00oA0CciA9o/gFEf g+j/rJkb5zZk9jbaY2xttMbaY20xtjbY22mNsbbG2xtsbbG2xtsbbG20xtjbY22NtjbY22NtjbY2 2NrLNS7aY2xtsbbG20xtjbY22NtjbY22NtpjbG2xttMbY22NtjbY22NtjbY2t1lNsbbG2xtsbbG2 xtsbbG2xtsbbG2xtsbbG2xtsbUprKbY22NqU1lNsbbG1lmpdsbbG2xtSmsptjbY22NtjbaY2xtsb bG2xtsbbG2xtsbbG2xtsbbG2xtsbbG2xtsbbG2xttMbY2pKTWU2xtsbbTG2NtjbaY2xtsbbG2xts bbG2xttMbY22Ntja3Uu2NtpjbG1updtMbY22NtjbY22NtjbY22NtjbY22NtjbY22NtpMbGDGxoGN jExsaSY2MGNbrLNjExsYMbaabGDGxoY2NIY2NAxsYkxsYMbGJjYxMbGJjYwY2NAxsaExrdZQ2MTG xghg2NMa0xZCmxpjUprKbaY20xtjbaY20xtpjbG2xttMbY22Ntg02xttMbY22NtjbY22NtjbY22m NsbbTG2mNtMbY22NtjbY22NrdZTbTG2mNtMbaY20xtpjbTG2NtpjbTG2mNsbbG20xtjbaY2xtbrK baY20xtpjbTG2mNsbbTG2mNtMbaY2xtbrKbY22NtpjbTG2mNtMbaY20xtpjbG1updtMbaY20xtpj bTG2mNtMbaY2xttMbaY20xtpjbG1usptpjbTG2mNtMbY22NtjbaY20xtpjbTG2mNtMbaY20xtja3 Uu2NtjbY22NtpjbTG2NtjbaY20xtpjbTG2mNtMbaY20xtjbY22NrdZTbTG2mNtMbaY20xtpjbTG2 NtjbaY2xtbrKbaY20xtpjbTG2mNtMbY22NrdZTbTG2mNtMbaY2xttMbY22mmxpJJjW6ym2NtpjbT G2mNtMbaabGhjYwY1usptpjbTG2mNtMbaabGIGNjBjbG20xtjbaY20xtppsaGNtNNjTG2mNtNNjE xrdZTbTG2mNtMbaabGCY2xtsbW6ym2mNtMbaY2002NAMbY22mmxgxtja3WU2xtsbbG1usptja3WU tlLZS0tspbLKUkCi2ykyTMskyyTLLJKMkRMskyyTLJMsskiSREyyTLJMskyyySMkRMskyTMskyyT LLJIBJJKSSSEkkpJJKJJETLJMskyTETLJMskyyTJMyyySqyREyTMkzJMySSS/33Q+j+QCooyp/OA /2CEIgLCN0ZFOBaCCG1Ca/KWo/lCAaA7AGcm3Rhjl7IVpuStPJ5G5ImYKVINgXQnUWqEsDWLsWw9 k/J/JGS9F/kksOeoHogkFiKye2HeTntkOdbRYEvcJlDOCH9ll/vHsKfkM4vhPAGlDlrduCGJcwGY eSXpgk8EpBzJmAT9JBqShcqfkal0DjPhf4T8JCwu8yJNKgOVZvICCCKPzNAUtqwyQpIyIrH2JQ4n GTPQJL9aPOtwFGMtpJ0lRGVJUNVKSD0WVGMWJGf2EoJxKdEWNAERRRt+3FeNndC97IcZnslQKIkk AQQkQUyJRCX4/t9sm3Xy68bDbXOXS6/C+l5tHR/ynqnfLLEtOA9OO7s0C45ij5vrkY+eqQLy0sAo rD13bu3l9VNAp2iqqgsRNJMrFNTVU1ImZmaeKqnpqhFtUUp6lgXIVQPUeb+fcHt5+GzerBrqxjD/ iHHGuwjF9JKkhlBRa6QpCshN42aw1Mmc3r0MPnNTNVh7atGl5wf2QWsjO2uT/IhfeLdWetzlgj/A EQAIm2hR7U0wy68XEAu2SFxBmTd2BAp5D6u57xdoHuNLbIyw8V7PSL8T+RAbf5zY+d4M9gj02F4L va56bg98IhFtEox5biUnvlbgXFPXHft3xrCmroh6KLqt4lNy0ohKT5WiF+AZD9omRewTdJMpedn2 3AMYtpvPbdvNPcXa+l9czQUvoRsXwaRmFm1HDxcda4qw00xNdRv5LL2iXxuJJ7ThTfnrXYEVlknI TlpANTYcxLYbcPXDIfsCWktXIpR5i0RUY0MPOPN8TPVibbmEq2zWbWre23nMvfM/sQ1SjLtnzWb4 3rE5bkenxUiZvh/Eb/lIua1To2m7VqOrY7G2v7bfO3e+kTITYkW8Ectp10sWqW2+6xbfYyaaThn2 cY1ZE7PCQONq6tjNCtYe7Oguja0LZ/oCQoG29g6CkpOd4I7kGvdar7uYIkV/JDUi5+iDJAtdrro5 vdrGPm5+5vOL1+LMMi9Lb6a6fD2ptjNQxi2GGNvLnLUjarWwts/MzwNk32zyk7tu5rrWsCwZ+YsN bEj7vT3zZb8Z/2IBX4cjfltuc2uy+GqWF68S8jrRgJHlNZhfzXk45zzcX5pxnV40o2lQ/e65iu/k iIhgN1EPELfHnDVX4S75z0V77uw4+qdF61TenGflf2r+5P2pVJQ+l5XxXbv1E+/J6v1oze4mLml1 9X1PauKsaYOy30Juw9RERMywRFzMkQe7lxU3udVkbfkECIESx115kbrJ1YqCc5rtnHGO5yru9Hw/ zkO+chfMuuUYfuQMigZ88ml87l4SD1xHuO5C+aoJK5t0LtLzC+bueYlxs64ub+Yd+x1MD9ACIECx TC+jnZ7aFxyF0Ra3R7wGaItFeXE895q4HMrnOxDaHyQQgyb+4DrvJjuCdQ2jKIyLxMak3puME/gA fq+t7erb4i2icSye3r6xi+hQW8cjuG89gbOPUvk/B3eO90obt7cHiXpp3ZN4cTZitwsldgcgMSBo ALNRhzjlXTjnRrv8IAgtQ+IFAfaz4eHUr4+XqpiBfgGAHpm3pvfKrG7XdedUXwLZ/EH+AGO3TNeV lT5Jr1ldzPLfL7hKSm5iuO8YRQ00JpVm62ju/BriFC7hu24T1CfEAD4+8feUIPDsVwctFzpd9dDz LC5mzSavREHJG9KhIT+20VMkxbCeGgt+fMYC33d4wdtN0/G99v5jA5Ym3N8s704rNLVyu4i/kobB 5SiXyTzXbJtbnze4oCVua8wiaRR2PKRtClithHUb1GNWmUq9oS8zSLcRtz3EtJPgWm+0Qwk5U+KM 5tdUoZptcnXmttWUjFuKx65q+zvmPw4Ik/cDVg+NbHh1vnvd7Yd9RxlyC1qklsVFYzoN7vdu97q1 kZFyt3xXE0sRw9Vat8bQcZCr2bSvc1jOjp0ks1p9R05VPCAFhCRBEGLG/N+LOH/BYJTdZABH8f0g iESYAghiEhRBCOJRUd4QBGqqCgALJuCIAESIJzDR81/Qhprh0tV5fcHqZ1ZVL25xlK7wig3t5NQE MbtgiIECm1WOMRmIvzW/O7x10H4IecWuHMim1Zqt218xEu+BaPMXtP8cucKQogrAeoP2BB8/0SJS Gtvnnx11zN0VUv3fuoIZrqNObDVIvzjotkf0ukcE1EjMuk1QsAImhJZmAhQNlUxmIbqiyRJkRJfp JlT2S9LQh9lbiygXOBFumrBsznxshi06cNUnpuo+fNBRpJEEtVwN+RaE3wbSMrzj1m+D1niavlcn cRwMwiv42HN4FeUwqrnROy6eK0vwn6WlbQbE0G9XwNK/wg5FvS00GMzLuQ5JevRbV3B6GPlKysJ+ lU5dbU+kKdtcapRiMTKIQmQjKiO2de2BMgeKZE9th7pmShBpTElB8JJaBJLCYl6pwGF6JiE+Vxh9 LxX3E/ZKB9LAYxgdMC/g/TlBZ0xCXIck1LqW5MiZF4p8Ld+oJJSSKk47D3xiFuBYz5LMyjqWQ9Um mwDimJTrWNCfhfpLBLR1DnsQ+yekpU/rpaFzJuX6XMhJfIHdeSwu/cs1ypuGxN6fdPutQHJEoXak sAMifCegwIaF2qAXJHBcq2mXfiABGmIMOU5WUHamUvornPmy5Q/VsiJyEEX0u1/ZZEG/apBA+yg9 ulUjhhqN0E8RO2tJdCud7Vpg+d6b1zQ004JBJ1BCNUloUDRa9oO5aR+Ocmq2joipQt3moXTE8JCI iRHgwbnKONxxjo4kzsTcMwWI8Q8QF6ySSYrUEo+0QVxQuyo7KL4fZkvJ5XosTBwaTBF9tKMGhgkB jiIfnFEmE0oUXiyHOtSuFLAQPViYZCN3uAGNuTIRrAJ1FGcJojAQxyNYK2Q05cKaYQKUPyBE7qNq C8kNYckkyqpOiJdj2Oe3Hpz2ngshCHPZzQh69Ce5nWi8HyUQrnKLpWgIFMKALEVH346tRVLlt+Z4 /OWKq6cOuGKIqMX3Im+2Kmrza2BVU1CgviIk8cTrzkVbJxKvVKhpqph2WxTs+46zASgNsgWtJivC YRVSU/Znxz4JrWpSta0rUmClK1m2J7P1VnSoFBCv6sOwhV7KxQeHdRb+C5qxdVRJXuAQICYSYCc/ mgZYpJBCQQlNWPZn2XTdv4lt4RZiD9og8AEARbjeT+uSIAIZ1cEPnKJ8withCj+YrdLeOqDYbPk9 3G83O804zCjN3Q96O+rZ3jr2zRC05ym2jqIU963KtOVfJF1IrEEyxJNHYYuNcXXgAgUmH3SQtx55 cuIK073qzt49Up5Tv630pp9p0faH3v+s+j3esEQ2QiE4NkCEoQFNkIo44FJ5+N8cuVVVPJTNg0VH JME17rb6gti2pcsTDEpW6YnH1naiybFsaoR8E9t3aC7tcX7IS2PDGw2WW2RFR3g/iRcDtmXV5B+r utC7r1cRKx4dQ9W8umGlMr2Ewj6sHp6Kz0vk2uwlj3DzrE9CZBznY1Gutw8Q/KXLZE7CrBxvnW5k TjdyVl0duhL2ug/kQ8cs2qIt5GKXSRwLq2cbvL4VcajsrMihejwjiBip0M+M9/HR2bscZsGMEN5l O7YQHTMHJuRLvWo6t6F1fCvDmpa9SGwAmQ9EVyKosRdiJAtsBQR1pTDStSd5RG2ZovhvlWi8oqaN r/Hz9N9znVP6Q80utVNmBEAF6/Rb+DRM/rEODXN6TB4PXutl9lOfBHr8oPxhB6MNMezIdD9mO5gg 8xg+mFkU7LBcjGeVNGsTvskwT2OjH5VfyExmUpr/5ISQzrP6JhwAN+1kXjG0VVVUgIYgNNIT1lCK OiGmxVx6IPrWn+OtE5a+da26kEXD+j28H1Z7Z/kZFnAHyb74oMbVduwlvKsGup5trPFVLzN4znjv /AhNdZRxeoXY61Y10HaKi6CYMiIECjfKe2LOOaGUUnfDvSy+7a7feL+/6gBdLzGGykcW2HHNc5bv ZG1GTf/BFyTt56ba/kQSMJkL4Ej8EGADvxXcyoU9E+GzVrGlqYcQrvXQXI8fGEwa8WvmYb2F72u3 xWjzvNhhZh5CGj5c8HnkbcW6lZjObawBTS0vVyH9ABBDJDpD+IAKY3tYnijknjvB3RRbrQz8D3nQ YAjq2/FaUjQcXMTVpR3l9jHKzqz7NQ7d2Md3gRWeM172FW9a+7ajbkiz2PWzmBUhci8AE1f0BWqJ zoiU1pkGUgFtalZsr9CsU7vZw+Lahpvi9vJk2tU18tsLB4O1FaVcaScsIxfGb1bmUtlJyi7aYwtv Bv4lef9TOJTA0Ep/PZ+y9l0pLhSbtmslp13T2cCtBBayhERIRAIHmBIQnvnoiIKooSMFABZAAUAg KSEFiwFCWSRPy+4lUREprgpUUWEQmlEDHSV/XZxtgMmrLt29ZkXTqNt4BPALn0HGXIrKrbVsYeaV Ye4PjA6OOcR2IZkhmejT2TIa2urrs3t4d5TzBniPHVM7dsp4I/i/1B+7/T6QmINuz4njqw15kUm3 u/dcVpbnuPcW/QC7/cApQ4HLIslc9icA/4o1FwG5DJuzbePDVGsK6I2hog0IXlO85KC0choRMUlU X8qRa1E1OpQfcipJXVNPO1VDI6H0P3BSAj5l/OVd7Zrs88938IEREQOd7BipeiAc3NGIOX2sJJXj Lrvq5uQENCrWVhcxX8kDA+hFoAByJBkCKjiLSIpeV7sxPazXrhGSYJNtXwsskZV8GnntYqsmRJFw e8ln5esa5mcW4I2h4nOyTfKgrusLLsleSJd14uLBc1N9kXfKvNKPZYDknwg7j7bpMoCSQyPshpM9 PCjqXAfJSe/coKzCUtJsiVTSGg2FsMqOP2KA1YJSFHtM2RoaXbTfN3IXZdESqqRRYHB+a8Mu6qpv QdaQHeA+67RuwBDXE2MYXhTAN9G7kRpcmUxUPBpZtdUaxjUpl8iXV0+iPC0MY+nFxviFHfsKKugB QMWwZHNUIT9uWpAHT5yHStvYX5C0bwD0qR2NfhBtR8Wv36R7c4UWmaGRDhNikKlSIcIfLIeanm5U r8FqA8p0pVV0A8SWDxWzq5gjJiUkRC6YQRrY9LiDWER9HXx33HMe892lQZTqAFUteM0+ObHVcbee OOLesBrRh8XAIA/4ES71c489asDlJawTN+827CMuqZskDnXy7Uuqbjt8/u3SMaOean+BNf+pEAR9 4/iv6IqkVXY6Vs+I1pG+cpkodK7R3J1SgFQTCnbvU7DWShbkjdWzoN5bRVoo1m+cDS5tSJyohT/o QoAHLhZiWuXvQWWkWE97zEVPwQlQYmHSSr6EVRS0yb+n0ZiQTC3cd4Y2g9371WwbYZ/L4zPdgguQ rjupNKgeRKgsG09qk4G/GRAkQEbhmuk8hNJjRTGNCAMy+U6LaO9d7rXQndaUvTYmlaEvS49nmlKL 9l6pQ/FXJO6cE3p2XmnBdwFC6V7pCZKQhvkRJC2GIWQ9El0MgnJ/ugzWf8p1QbFrM+S7/PyUvhKz vE4GPKb1khvOCkkFqB5AxCEh2JnqMyHaIWGG90ifYeIkfqT8s2VBZE+RS9eLpeg594dT5knR/gf3 ycBoD7KYKkLtUSCTofuH/yhLo54YRaZSBghNq4hpE/QKI0mlc13SZi048z9pRhtyn5zFQ6hCEO3Y OSqRCxGMVufSCAG1gICBfg6AJ/u0rxAQQkREQQBkQUE/5SAf8oFFS6bqif1L7rIAzhpXeu0CgADC 0OilI0Ji2ASkm/qvRcaXJSH7CHTZaUm3fR5Grw8uVcUW1aayQBE/WWwbZOmZgKPmNAONs3x4EFd5 gOvobn+BkOg5Ih6sFFbVCWJax8SesPUDy6UwCiMcJaPyrQ45vERHSHF4lkDZf1C9iBCCwIxi+UDo 7RFFkFkDx7pCsLAQ8BAJECHBJCJIgD98BZhYB3OglGfFKNGMQnZRiRcQCCofYXwlOWx16VJ8vZdi PUsvjPwF/bp5uNJ4DYqJ2Hptk3GfQohFvKzyGGOHd82oN4SJEj4pHDHsWc3xoU89lpBQPYG6YWE5 LgKI/9ulkD8lyF9C8p7keR9Mp5YQ5hiIhAqIojLMMNAe4ZIAWoKI08MH5NtB/nij8p66YYY/6wTH 9pASQQn3JKyJrEpHk6AhbLMVQ6BRHhKdTAxjgoaktXSfshYliAO8Cs6D1XOX5EMkdDbmzNAlTBAA qI7V1C3JkX5w/tB8E80VKl+PSqPIQPyku6hyEh++WrkPhLk7JM+8exD8BqJE9YACkmAURh/g/dOD eEcl2k+ABpGnivMFEZpvNULIp/SHezJFkRngJIEPd1uNa/D6oEC/6OvbTfkR/QfB6n8OhKt+9dGA r/rtr3rH0vII168vvHAbC7MiqmVBDyB8uv8fbNsMhdOqmrTX302W1xXBOq4jHkSpdg0XeTVDKzNb 8jv4hNcfD280X082n0Fnx9c8dgg1K93kVFojCW4as4RE9oChxGzIEj+XY0+fsLfDpNNNrVbA5N94 y268EQ09NrHYTD4v4axwSU5Rij3LW996yNbJQY+AkJ7EI9SGSH0IoEORC5D7r6+b+/LL9J9JbHjr mQmG79L80KR0XSvGpwFYQ8TOd5P6+7Dp3CDetYtPA0mD7WglDp9Fs1R1a9jXGI3AzxMW6jdQ0r4Q /sH6YiJkbbO824oiy2mbuYsi98XgzGG8vlM7dYXKx4Q9ydIh12Mzrlu8vf6gQODE+SHIEKuEBe96 qUxJzpWc0sWVm4g10jg0PbkzmwRk5OUsiKitJhOI1s0pfsIXIeCJTYxky6wt+8Pem957XYxLET2M xjr0p6VvPdKRS1ZjsDMOe2iG64jJ3yCpREACJEis1z8kDc6XmNup1se55jFnRYESTnDPDDrbe7st HY9/kgH5gfag4QdkEaPlTIIPAzdlpqEEBF74asTktegyIZfIxNK3HA0oQltTi7IXW1rKYlxo3ltt X+hFVrt933WKSj0Gz5Qy3Eh/Pgnz1jlLXEmYTaeZPCdDrXddq235C9IcHmglE8kFdHv4cc7yY4o1 1zI8RHM1b4XRKjx8FV2Up58u4iC5viX0h5nWgyMav8F950+r6ruj3eaXe9bDa7rib2MdskeENTpK 147i4BIC2Q4QXceeRFpUiXv+gHuc4fL2Y435p+J0qZujAeZzy2F0h0H9fImERbo9n3AWpc3PPi6O bK9Rl1atqbuwvnRRaK/xz9kMETIYTcPiu68XtBLmSaRWEXXBELs1IPWMNvyNo1ErxuyxeHPEcxzr qtVbLFR2gnKXG8W6RYqbZTlkkBqbJ2bYbXOxs7ZGO23c+lWsxfdpFTNMjnGEgxZE0i7kPZDJBasX UpwsuYauLkycoSTECzxzyGc59GWKa1n32x8G3caeM33iLbqf3AHCL0V8sJnekr2yOvrtvnfaHt7w /chBYS+yFLbe44CKK7kKkB3Ih8AK0FCkaYxGrUPXNlg4LqGKzC+Eq1gvwiy1xVChiKVq+XVsOlHb B3s17fZCJOkF70eBlsdC5GjkgZ3cOu95Ppxy9xjyTMuSbeKh05UVKbCKvXsCp29z7tYCIRsKgprv FZYqLte1p+CLwMHZ3/DHHHtrS/bDcLjLRer/iA2cV+NDGk33JyNmRhSh0i4G9pkGJszcg5lISeVz CrprSzfyADmQtsYsuy2Ey7AyURhmqsoIq7p7rnD/KTBHzDMR7pXBYxSFZgwS9914box226UqNK9X zSl8DdFT16Ri5ztawqlq4DZ7BVolEWTyIMbQTm1U7LpCfwhGi6Yc4TAEGjCVCcqvvFfYg3NJneNZ ww1l0C4E6wjFK5zYthrwfsQyRcoFgGKid4tzHjPwXmw7628YwGAIT5WcXqexvYPyk0M1Aa/Wviha RnZrM2y1u9zr/JE+YzDZmLi9sDNX1PEt1VBWi6kPFTVWk3WcWxbwRqVIv4kN62lUwdEwqsr1bHph OjW889iQEd/FW922M23Vt5EVI+EDC2T3/C3r3kj8kW08fvzOb13wZtkR8ESXXDHIEqRazLhn7kU7 OxpIQE9wRLTJAoheBvsgzHyOff00J1Rb3rX6Dlb/vQSMOe/LZNj+8wlcezbW6+cvgWUZQHo7Ib7+ yCbWNhCIiB3yxBauxALi2mEoY4TD0qDSJKL0eWs2uOd6eyKk6RObKTNSakwXlAughEIA2DyAPi/D KVX5DHtyao8iU/KHI/X8fmR6G1pbXD3R+LD/phRB6XqPXN73mmzNaGJhzwh9ULPayvcrWB6ReX2+ kTzhbrT8gf5JpfOfJ5LGPG8HJ+Jn3X9FU89LifvRKwCHj9esuvFn0uxbU2LQE08i1r2VKhpSxKR+ EyhWvwuxQMzgwsw6/2Jcm5Jp/+kREgH/AI/psiLxJoiJefKyJhBA5xSS9kIA/pFBsD0upey/ChvW lJr7J9BaiW6kmWJgv3T3XknReBlTSNqEcAHCURBBIeo51oyr/hmVPvAu82SOCLEAEUEcIplIKAIS RwJQwIJrDeslQVka191/IOkeqbU0L5U8B8rFicAOCYuCQiH6hLfpfo7L0DylMoT6Q8Hun3T7hNU1 r0Sg8GMPuCiMAGWB9hKV+E/CbE6jzX8JtT4WlZJQigFKwqG8c31ERBHFaF8IEkoowTWv0uM7rYp2 JrPrSCmiFgIBQxQK2HOQU1FQjKU/mEao0oA777+uLt12croLd9lFddU7qi66u6gg1U6qtXeiKmYc XdayFY1pkQf5SiQhQkExoxQvpdyTXOPhY2ial4pau1N61L2DevlK1yLoWgfuoxvTWt6FwdRExEsY eQksL0SgPyDwDIbwZUJxA2JSvo9yEiCI7JySU6x4p8LQB5Q3DwUxgNCwvFAHcuJNw4LJLgoWC0Sn d4x6KfEYeNVVAIYrGGGGpCjWlS6V4qGCaVrXMvoKELUOScl5Fy+l4EZoRkIZIlKQSIYEAYGCEIvf IH71rYBRHCrCii/ihJQIiCk08L9Yx+j9P4ShP84C0LRIiIiCAgK1rMiRIhqsJUDeEBT6B90sW1Mi 9QfZaz8wKf2vaAMrAnUlRQeqglv3pZLEN/K3WUFZAbF5p6Tp5OqZk4lDWn2XWNKzbU/0VRFHX91o KRU+u6wc0xJ3TkOC7090L0qA9JmTB5LH8l4Hynsu5NgTSOFL7rNTah90xgUJt1jnT7p8oTodiwHB PSfdKATQcU+591pWxRD5SOyafu4L9s6cBMaXrI+LdRMxMRMzEzcH9S1pXhOE/anS/InkPyWNgCKg TXP+0NQ7k8rrBdCUnyqhCfME/ODj8xJAJPMxJ/jf4drZ/C86sMrxEWElClHBeCcX4k+67VvAdqbV mv/lEBd4bUs2r9lT8pqEHNApEAHzCp4Sut6hdatCBah9LyWwpSa1D1XzJbgc6TTyvlNKfCvdPI8F ms1T6A4p6PsqWriNQEGtMYOCUUAcxcofBznp/eD6iMcjffDIokSInBJuuBlUE5L1goTv3O0kgW7u xYA6AIQEQIE70v5deirER+swYiJiCXhZeZIoPo2ddlVVUe8nvk/KFh7ZP4Q9YMD0A+iOhLDgnJJJ QhyTev6BwTku5cqay5dQ7V2Lcm2jaPRa1mvEeYnlfwNa7xqQMA2p1Wjkm1O4JQsl7LtSgMadD902 psXWvVcF5DwTalppc/HhZfShrvAFB9TWegBmn+IIUAS5BJlE5LSAx+IzLSnpPK+in76AeCVDgsbk uWhNaaU5JmWB/S5l/vhTNCyskiqSIyLBGKBGIoqz9fr5B7voO6l/c956kP0GmPrPykoHsQCIh80F SEggh/6SZJERllfTGUDqnNJgHlc6G9dJ7qlKdhMq3JcuJeAHwlSSNSQm9eA9R0jGzFGJDikykh3Z xg2GwSIPSVONdqwtgMLzQxp5BA8JjS80pyXQlyULYHldiZ1o+E2J6X+aZk0pfWHpNUt1EhNpDoX2 H++iIOgY05DnXsmIWnmDqT6X7Idk0r4FyM08Jgk84GOI7juTg50vXKV4iIiIhjaJuQkly9sq9l6h vW9bQOi9kdS6VqHkkdE3JgIli8kvS9ISxbPoQFzwqNc2/Onp7+e/hz6iHLNLTLlYYRExMyIZ3cPM y4mJ3AbxApXgli7lxDvTMH2Xoupdy3JzTiJMrE2qdF8qnJcibQTv/Ai/sBKQEgIAgCRakE0Zo/z4 JShUu9DynPKQREbJS9JmXsmYrT9k0D9k9IbUoXId09JgvgZIQlaWDvLvsvNLE+E0ppAJJsAkOJM6 Ulq9FvQLFpWqzHs9c9RP/qe4oOIdS91+QDmDxgyjASgLUgoK3SuhfCYlyKoijWbPdVEUcgyznJKz AeqWJOJxHxVJukSpgKS1M0oSK43koMpuWkeie61N1ugVEfQVez+oSfNTpf4qhD9kAQXJxskiiele KyJbUNPJNQbE2LBrT4HSimJoNlNyZ6LIJQUTJBACiOAEjECJkA2gcUPwnhJ5wBxu+UnJDzSBx4JD SnZe63L/qZ7UsLurIPS6wQJdkgMVQ+F2JkQzLSlqQmtMSEk1JwWlMSalvX7LxXSBclqYw+oAYQhc yej0vUaT5X2NiXEOgJEIAp3gQVPJEo8JnC0IfAlCWudbFqTUKcA8eQhfxL1MkhB/MNwIG1AVHcmv umTuYNSj+zoq7oFgURgO6QSg/4Q/7YUmGACgcBnJAKaxlRCKVqoijF3GAiEfPJLAP/a7kqhBLFKE 6JI7qKLC44DljMUQJDyiRzic5RCr1kE3MMSiCs1guvtozkEEy09nfZ/CuOp2DodNMZTo/Lhznux4 Mc09e/PHUDrnJxF6YfeHVOWGOsnOx1/GUDdHVq+y57fsp+59BPEGenlO+hXmPQvbY8dFV+fhN6zP GUKwFQhEgd4yQCeP+P9q/mv4j/IbBXAW/57bSjURbCFF0gJwgX0WcE/oqnyKlQKI+heIp6TQuvSk BDDAKIwhAiMgKjIoRYwkIRghCAEGRABz5HAD6XwmhOi1ipoc4sBglAfyUMgy+VkvNflLil3L0/tg anuPDQxM7bWwdymshN8glDEEDECRAwv3/3swX6AcWzGqiiPslr9sJJvUAP1fvSq1qQkTKSx4CBoW EgZwMclURRg5LFtOC+6cygoQzvBagTcUv904wEzZTomn/dzKj+4YJLGGkHFAKI5xC66Qa16KYk+V yJ/NdqGpf7S5xEVI7AzJ7r+ChYXtdBBA9mElDEBDBAf2L8f+kVJQH9S6x2J8p0J6Bf4U31DEA0LK CIRUSSEmRBNKegQ/vz07fBv/sL4o31yqqpsorZreHkgEoTFTMTNF3WpeXm2dyZq4WY0g/RQ3pIeB rTElqHImukPcIj0krANyndJpavuhnHQkfY2jjXEgbT8LpDEvgd87B9kqSlKU2iJwPdOq4lwXmlAm gN6ZEyDeBlXSmQaSNqWcteO7nGbZTyX2W5OK4l986cUpT3TWvVNa0iJYmpK1oB3L0XukJmDKmxL7 4giCIvSUtyZFv1hQdk0nZOS8UkuVe66EyKWgaVOieyS8JuSEmsJwXqutfdbUN67lngmZNC0AaxEx prMkMRwWle5MeSeyXJcCeydExptWSa0xD0TNNcy+7/JpH2A1Ad1IT3XIb0hcyZE5IeyaU0psTenR bAQMaYx5JpLAOCYlOC0p0TavunoPbkmIaE1GNdXum9dinX3TctKcU0JcmUxpnTWlK1LHFLVyJ4KL hDdAeRZRJO7D9iVDAXr8Xv7yBAQK9gkITsSACIRnguvd5+Ovuf5zWVFZGGWZ8gRF1V3d3cxEzi0W znOsHURuAxAqOBMpKypdD+kPgDUnJd650ypgm9NiZVxj3WlK11E0wE6K9gPZJpIeS51CVZ3TImge SxkTcGJI3ge61LghzUrXOu1R3mcZpId/KdWjZjozV5JiPkMy61lQvcMmQlzAakNAGVPBqWwOgxas zImtLRTKsAdANiPLtFiRnSg3QpjSLk9KB/R9H4hm/DUYwKE4JpTimd903hqB+VDenNaPdChfZfZa UmEgPhJZUtWY5U2rWhiX91FFrkWr3HuzR9JjTeAcEvXUvFJJ7JuKkyJeuAdlg8gGVNad18GoArUD imxcYGteKjjXgmNPZcqZU3I+knnslJLU5plAtPk2rAGJda6RpT3FKVxjnT0PfamdO63pmA3p8rrX cnUDinBOydkHWkCSWC9N6zQ8JakJxDun3HwPf+ufP9KG1ZFgW0KGoXJFhRISkygYSQUyUIpiCOgT Ufp8WAwTOm7NZ9a4dYhYBh4iIJeIh4O9ca3ZUA3h2MEkMCQVixUZGRCdWMNi5FW5lin1k/BIHmlw b01JWlK0YLrA5JSTXclw2CGC9xZVhcmCFA0rmTKpyWxcSb1B4C/QIFAZV4p5BqVBGOBvWkdqXLkX BNR0TcmtdS2aNteHHj7IehfnMUjC8RwSZuNlJ0B2XHzoSaLYPENB2S9KC9ggtJSTWHsh8LLqCnkX omHMMhAkLWm9ahEpM8QxoDensNiTvNAnsk08ppSV+iJJABEL8GP2CHr1CEIX5qfre6pxY+aHcbvU Q6vc5jc4HQWQDv15Jxy9L1DF4diKKIlUsfwSpcLIiJJCEf3n4gFQA7HwyxTeSnBMjWOpN+gCrGDb vSalPhbcbRmiWEWzTalFxQtnQnuCZmTKk9y2L6SB3LpDqpjQoA+U4mpfSYwewFpuSlMSfKc/cgiI iIia7U7pOjz9vKZjPHDCRiHSG//t12qKIrGqIKPqcs4Se10QHoiIoghhQKK+ouit+T+qoZfUSYAI 0GiCIVLy+IThD4GkbkypqTqmcfKf2jOyfin8DnmSGSA+pYhlKJNylCaB+tfC2ES5CXtKUl0lD+lf 9CQuCiOVtmBiTgmBCeQKEyC5FNyzWaeQqXiktq7v8CUgf2gWSWm6UbHskwzULLaDASfmRJoxLBsU 1oAydy3p+y0gXLSlK8UiZDER9J+RkiaUtXi/svFPsmNfZJJ/kKKNvhOWkFEa0B5L9wkUKHsop0IQ ZJUvFLQ/CQuZI+kvWv0BSHBITguRJSTonvxxykSIjrIlwgiglKcrj3Wk9JJK1/SVJeH0Q7w+sPpv 0T7xAqQtKeGUSZowFLwmsQoTRFHTJKImoAAMmj4xW789+u2V0NmTmZglYp8i7vJzMbMiIiKvHmqt 832TYBC5ZJ3FMC5ey90kWJabBNadTclCZVknwtJiXeEl5ponzTauxMyaAmp+UMYa0vTwmdNa6wTa vJdacAdq7wNZJOa2Je0ppHYlqyuLVy8OGPZdl3cdVUHBdie+v34Af7EAMuKFL+cAft+wn3EmKlf9 eKRBBjVH1cJJewgeQQ+zAp4Sp/yqEBWW82TT2W9+V1AgdD7WdUuTEFYwlKEvsvMsEhJpLquJdt4q dQkzSiUpKkUn6H2tKVVAEJZUYE7ontIKpylQ+RphqemgDSkkjMksOp3jIIRBZHztBGpSCs+m0JIf 0AOckkpNlEDw4LwWakpMkEa2iihoFslGgViYbfqun9/lcj/P10wQVj9BtwCiP9wKIypBRGoJBl2J QCiO1IT9k1p/NAGfZfSclmm1PSfhKgsXughx5L+TEakC94GvT2AKDmvNYSEocq0YAKjJJKNyaFxp +rhBCY5RJqTnNdDnW89gP2ShHgNibUL0oApXwpgBetCQJzTkIH8LCmaFBF30p91PwN69AKz9kzgX 5E/oPIyakkwxC+pxObBB9nkSfeN6QppBA/db16KNCYj9kkSQiFcdi5V5AojcH+qqQeyZ1NJTEAwv 7wFKBEt43p7p7j8I1p6XMBPkB/C+3BYukWronP3A2pnTQHRfpci4gM61LuF/IjJOiaEoK0oQB0p2 X5TylC6gzJXqSexPZSgGSH7IUJWmB+e+KtCSfS3hJTQnJflfrH679PGaZsmhRMmBCSEJdMaceTHH b/hgKTShIQi0vA2rpjPXOSTl+1L1YpxSiLYbAIJ/bxScBtpwQYZ2r9XDhuXYosti3XSxqd+d05OM 8/3ez2Z7AHgJznNJDt9ifgSTWAFDpwhPb+Wm7zr5619m9DbbaLq72NbbVNXqpmpmZmanGMYxh6lJ tiXero4KjM+mhgCCBGTCJ8EigLPI/IbDpJ8LSfvX7k5XhCV/hNYGRfyHYdKZ01pxXDuO5cqS1g/s htXcFACKga00670sTaPDCIIgiPAsS7pqHQuUcizWgGQEkkHsnynJZpqTQnJbk5LSmNT5TglQE11o Yl6aJdduGfHVlt43aaUUkKADCqIo0yAAEOcAqCWpctCekJqQgXGf0QQELRD/cS2bQlkxLtXgndNS 7U/Cdl3pjHIEYDJggRkkIojCyQE+8EDDAhCXrCbEgqTQg4BcEKBBCpDA/qGyiiyVSoTmagQJlJCQ +EssjTwlFCfJCj8qBXTz6y3LCVCtYKIwmwN0jbEryOtJuWGoCtAo8pYGdMoMjbCWNQKIwvZLFBDM JjToswrFfssIAmiCIU1DAhIdi7hmpRAIaUQrCF8ppT4XOKlFUf2dRPJQWwUwVSkge6GZbKYgGCBa KV6J2XSklotTmAZBmtAKI/+z1XfzeXwlYp3gZJ6WscFhbD7rAJeeVym9MBS+AREO6+CQzsTytwus ZrR3S1Mf/WGI1ptJLJN6yfpOa3icE6nlcYlKlS+E/Y5A6k1ZMAURlwPYEyJ1XEJeJpT3wgIgPzkS ye0jeH8Ih/DCfhKP7SDSkKGggJ6FmtifZLzKtiPVfLkT9qgNsEmAI/KSlPCZnGAgPhFaVn5/UHuN FRCCCIkRFEFIxUjEQCP8lLEh/VggfWQ1gMIQgh5+KTEhWjSHkmN90H0TkIwIAHvGE7GpAFOwhGI9 9s4ZVYSrCooJIlwnKwAK/yWABDKXWf3J3Xsm9KVbWoal/S4TIwIiIIia5lnOtUqP0FCCAFAP6Sx+ 3yREQRBF65k5p5DgmwD8p+E3J0QxJ+ycbqiIiCI4JgaFmJRwT4TULsOIbl2/OX9vEFkFsAcINvGS TYCiA8iHdnuVhw/09twYHDysk7MWs2LKCdCkHjPM8Yny4dPZh3YH9FKKod2E8eL0QJTmMqRMihte CEzKBbz+78pr/P9tT+6+/99q+Y+/5TDLlMinPNH/dM5h9ZFXRcK2cJOEfT2e+Ztq2b74WfLtnmp2 xRpiZu73433qo4r10ncAoQAPz3LMdwd04pLcuMHIkJqXOv0ncXeqXrjX20DpTYn0uVKLUyL6DcAY lpvXQmcfcCLE3L5S1ANawRrXUNqa1xhwQyr5BKk3JIxJkTGli0JkXln2XYYuct+7PdRztx4X0dXa wQjyLk91/1tUTObtAG5Cg+XvgkGRBo8AO0ZFVPBfcaGtOKcFmnBJRyQuL03AHpOp7xn88KUrCiKC IqJFRkUUTMvsGscw0Kc9WEdVkIb15L0Wamkd67g/ECJECUIqpYssSwkL2W8egc1W1ea8lwXgDoBc Ekqey40+ltWSyWE9k6rrmnIgGxdyeycEsTgCBSawoSNyTaQY4EAXqxu/yjPhSvMFEeaqIo6kgHGt oJNP+OwcViaBigRrAVFGsdKxQTpP8Ymd6AAANwIGEhTinunM0QMDJxowkIRtJUgsFH57nQSeabE/ sP+RIWi2QkE6xJIjCKI0hFVFqhCqgl6WHQFEdSBSqIekhPZbk6rqZpbWXVwASkp5EP4gCIQBkJCh +FkDqrDiuJZfhYwTguNU4LXss3qSgEvoEZGZDSP3Has/ZNZ/WGRFBUPSwGUClPqpkkLqXHsnkg2D /XI0TAkQEEEoXadvgcOQ9UPHagY7dYFkN9EDvKonIyERbgpLdA+P9jpWQSglgFgBILMpK0g3v+x+ KkyqMACrgcr0dRB3+xRN1U5IFS1IRRGs6fSfkakrMiyLrXPBCSiQPYJyImAdQKMP4aLeIAG41tFS 53FPwlEL3VGnGbNRqoTuGLWU4iJ/iZIgnkn1oQ/dJqbFeUEXxKUAUpwiEmhajWkGSIy66dxQwZgP hfysrKDcLBxXFRF8fAU6BXYse6EGYXYNSZeipuX9hnaprX5TYlKdl7r57Rygz5CoZkbAogKArSqo AB4+vrtIgb+7rJqqe6rC2PEhKINTePFXmRCvEZOUXrMuqhEQAjYEE7hHCH9wOK6hkklloL03pamR K12iucc641lsEP0uCp5TKOtcaOwdKbhlYqZ05JkXKeE9kuSgzhaIcFmuhYXItQuAJlEzpjTqlage UkmApiTemA4cMVWPTt5crZAojYSIFygfzgoy90f8IOcXpfIKxCERE/yBRH/MFEf8hFFu/VK/mFH7 RQaFuDSkfoCNaZv2FTwLJO8oiGCJAsaAJp1Wa91kn+O8giGIIxqp1Tmm1D+bD8PlP5DgmYclLL5A 2LIFBULwO6fup+F8rtMq5EPlNACKgax2pefQfYpWVy/kaS1cELEp/CG4911C6F0lCfhdKByXQlCm 8bVwTeOVdCc1npT+1NycRyga0xbxggIYuhQJCkq1rp5/kf0kJ+k0pXyU0gZ32Xesv8z2f6O0E4vA bEiWvIpvD2XYgbDXk2EIFsKHMj/p/+MMy5l3D8rxfBjkL/NZChMyL2HeBwQBzHlLAT2Xuti6kzB+ T/MkH5YWiP4I/W8n/aEGWsrLGZBkD/YCiP+wFEZYEFBgZCCgxHIk8yENYYAaWX3EqWodan7KBSu8 LFygVECH+iQQcCXJKLU+xI/mnFal4Jm8kfoTIn6P4T+SfZTWslxr91rSpeybl2J+l/Ow9J3NP7By uIiIiGJe6fKjyT5TbzW9NeBEEREGWMuz8/t/Bw/fn+ILW22yVNJXF1l2oiTqjer1mazRGRREvBgX jOYtXnWvmghA6OVM4NaVqHoa0tSAyLvHKSW9di/ySpNi2JkTKnJMZcuhdZanNPC5xq1eUMqFSWJw UJrpTADOaVTOmldQHVLE1zQB8rlOKe6YluQtWSXaNe7VXGbLy5W8I9BNN6S2rmXGuCXqb03ramcD OdlpWxdhQvFNSYLQl5ShyTMm5MaUGs3QoUL7IPBdqySxM6+gvSNxenpDICXBxXkDiM/aIgiCM6Sl CSU6jgh6UJckoArTOhYuJOz1TivFewXJYtS6FzcSIiCIIjWly2pxTMPNJKZAvSOS+EzpJcQGteCZ E5jgO5JaR6LnHeNyZUJXptXkp2Tz3DlI0HgeoUiHJZaEzrtSSZTum5Jp3XauC0rrMicjqGC410i5 F1mxak1lPo0wxAQXwSAlKUQMMZFYvpQqOrbG2oIwzKIhrStiiIgqa41KkpWFKyNkqwhhJmSu96Qo UiqFqwzNkI5E+/9f6/uPr8rl7RES7OEh3Z4loiJiJiG1Y0ilSilQiBSCRFUVRYAkZD8iH2ye+CfO epDqTr54fAmmwDsnBLB2JjTwg4k2rxTwlq6F1rWnlNoUDvIvXKBAFSZktTymZOiM1jwPMShNC7mt cgFq6hPZKVrWtdqUoaVy8DTn0cuPPbYpzYRRG0YTSnJeqFDuSsBFQMKKLUMdawHwiiNjAH/WCIPz yV5MqiJrFdwXPuJwQ3rTQm1eSYlKBDmvQuIJnUDykilIQxRuSuBNqyXmlC21UEYsHOYtTVuziX8v l9gCfuT9/xJ/KQEN6/uiqlwB6Syl0OJCmIikJEBq4WiWAqCa1tbIqYgYIhHafQ0Ex/eGVzpRESCB BQSj4ITT8D/YUhTcZGD/OyTAJBMYP/9YPFWQ/Jk/mCiNOgURgURP3BRGFRUCYKgmQDota6x4rQvI fwudclAIjEDAbuSyD0mYfysXLgnZLpKnssOxEL96SbkEQNyEk/eEppLnKZRDtbIIm7UDCiSsKQnh n6g7fwKamXMwG5PC/dKrEwXSgaXOv3SoyhcmNT0mRcEw/SUyjbBlSLggQIhB7JDJEEC5ZAH0oIa0 oPlKE0BCgfsEDpWUiaREAYOgHcfYN1OrqR5eLIFpT3Toomt2JSgIqF4kP290kpO00jiFvCxMqzC4 UQYwHA/YcpcD0nlJB1/clind4JZkAkEEGILAK0nRIgA6JqTmtgeR2p4ndPCFZRKMrAX5Ak+UOxd8 Cw7QO0KKIyDGmMJoooNA+EjULrURQyJUtQuYa0knzQAKhwNpcnlP2TIp+lrXSt6foDMuLQaxlQoF SZQMSwL7JwTW6n0qkReYJgkEkVLpCAoz2n0v+tGznEREQxEcBlLOuJOSXLePLFo36U0z3WUUQRKu YhwpiW9wgSInbwV0JFAyOfmyPaBdAKnmQwe0U7Q3HCqR+VDdkULeKAjOp+ssGVUixO37I1ZSx+LK R0ob1C2cm04N7duWN0QbC2GhluCGYrrdXcIvfSjoOzKU3UUf75b1GKLqCPAokMCRJQdF+579teEj HLHxdSClInPDha0sS9590jueiclrVVZqSkWMPoD6PYc87y+ri069Q6fd8ff+Pt8/okxDyGaXkTMz MyIiIiBMy7z1znTcQX2/DqZ4l1qp8r3cfHt7vIoz8/l479J2e/ip7grHMb2Q4+FxEbSTAk9FgwQE EJ1+dF8C0LyXUvhPQfC+Al6SxdafSc1vSClMoRzNibp5UmmJY2r7IVgXpUvMcqeFzIeyTTEFKRvW amdOI804LwXinhPddq0+aiXv/D9X5fl8/3Hy+r0+jzPr5R5zcnOc22yisRVisOgqI0gKIwCiMhcW acG1ZL3pEURqv4L+9a4A/NbvSSuQIWQEZXCf+Ju7CxAn5pKOx/tj+YsR0SpCGghE9jP5L5S34BAt RZT+wZT+kCcjdPP++IYLzIwwEEBERER5y9UVUxLfRYvdMPCxXsuVSgk9qfXJ95ND6ej3Ggh2PDOe KIxOpMUBSaVpD9FATTcgDvCEhKVwXNwS8pX9oyvCfwT67f7i6VX/FVOkAAey/klrHhP6x9j+tJ65 0+aZHeEJfbxMkEyTFKAYBRGArDIgCqRfotZYQwQMIiJBYFZHRLE8B4T2SXpIBzL2SpOAii1pfef1 f1S+ko0XLIKMEvT2QQ+kmn0vdN7rH6XUlgz6qBsXyP5W5ye8RCfzJXgO9MSUue7Usw0LgpyXIlhR FISg2obV95lEIeyHdcSTspXKupNCzX8pYnRc6bV1JzA0qBz2CsEiwUP4pLALIQkIignlI2CDIRLi vNdqU80Kq1roehviYygZETyUTnFCW0oqqn49Tez8FVRW9uxRIIA/theBICqqQLYEAojA7UgSybZD 3JdO6a1q9KKLWFobn9eJxRIj0kh7qzMYwalyWhgfzh8pKFmKlUTUOOF8JZFFQKl/S8R8GZJcz6G8 bl3juWEoTylA4lxh+9Kpnx/aO3pNZn+IKI/tp76ifc0akyYKEec/JEib91lRZeIdu+o+shIcTPdx MTDLZA2Dlks+8K9AiSm6vIAGodxkPKqQqhZnSFrlJ32WX0dPUYXxXU/zNg/oZymhaSNWqbcpF7hU 3wKuzXCSl0GiBsKUVgqnmg5WluFwEKJIleQKEvqAUdyyurv1RdmFsg0qgaKUCOAUXNApQYboIBm0 vnhZdmkVuUJEjpg1OqiC6BwiIzHzP19P5clZn2YQ1U9F6MQ8TEREPSsJNWgAVu4Zts7xEeFKwgSN rkPZWJSI73T00i3CE6CFNoaIBmySEJCYVTwAe2U9V8ruT0vpPuvRZJUBWnukAe4d0vTWnNkE12pO fwPpc62LwTKuU1p1WlfcD4NyVDrAyBrWayoTihYtSWBbvRqX7plDmvNOKQu4TkBlXOZwN6HMDUbo QpskgqNERRjrsD+iM4ne31TsCFHdRRam8Qd9kh3wgom9aRERKZCSyV9Suw9swbpX3ELL3jkK/sWR UR6YC4QVQIflPwWAbUxLeLYBvTSZ0niMykEARZJSQ60jWl37jdLtj4SZiSPZC/ks4BRH7i1osvpT eqnr43w6p7e3o8OR6ulNbpUV7tDsfAJc+4piLAfcn812cQEZZIJwb/1HEcEzO6GKwCiPqtDMn4EY VN5BA+hh/805YC3DM6jM5VthIIYIIIVSPwf4SH8Yi+cfZJIoidcYKI/BrTgZU1puUPCaB5IHup8p vc73KU2CbIErlIbcS91+kCjSj94VGIQT/WQyQIEQgffH2SGnQD/j/pulgdHLP+UNDUsdQ61iTaU2 BUlCcWAStca/ZPa0DrBaSSDiSkc1pUUR+yXKBiauyMmIBUR/qUdOYTWJTbaV9Ql6lybwExDMIYEs 0M4URTFJO5qCqiIe0kh5aIfilp93oIn4TSGdPzsGkCM6zH7D+E/YfkNCRqSZ7DunH6SQi5g0Jlal KEImu5dViMYCiIsikCP32FQBYQU+2SH6j6W5js9lDEDDiCACD7jqCIMCqLLENyCAEUb1s9lPdAvE 3J8pUGZOie6a1xHNDEERryrKL1p0JspJgex/EE5h/jYsECMMmR9w7BIaVX+YoCwCgb1qED54Uv8S Hy91CXwWZD5mpWfQyFPpqwrGIDwupPutAqiOJ0fSnUvpEUW0FEbV8Y1pB6sdapAojnTGSCdLJCIl DKN63CTTOtLMLWqYWwYXWITCuTV5TSmNOKcV+UsWkNiasAwZk2SaByB8ralazhKV9LINJC/1JfeQ CKDUQmZiIEFBmmbSKahzOhMzjj8h2DoJiNSgEJAgvt7aP4X37ix/L90sJpapZqrNssCSSSIi4W5m rlntqqlTVVZZXVUVxVFqi810J8Jn+/8iIiIh5nFJT+n7JVcuRcEtXQu1bk4g3inuoZ1+hSFY/qA8 ppT2WtcF0JcL+F+lTYm0AuWaZFMS+VhOBNa02GZcF8i70kudIGaSXam67JumPPkVc4w41IIH2SpP YMaZekO5FECtM6/CzFXqqOnWnr9w6DUlZQ5B5jYTPoqH6WofKimZYUfCU6GZTIbIT0ZEpzgQaQ3h esAtCdF9JoShBb2D2GBSSRgkkPSZBaNjtSWCSXBcqYJmQyewgtyn/5oS5GxKjaHcrSpPdbU9BnJB A5QpUuP86oIZHGQKI5UAfRqgOL/oQRARAITK70JpgG1cPlT/7XgZtJjVMyXJ+KQBUIjeBGwJvNff rEEQxtSJdR6jV7QSzz2RR61QxtCigRksXL8LNnFFUE0ygIqBiXslBcUwfyiBiCIiCCIQM57nZQ2j qHSlKaEhNgcsOUXwuVdZQsw2p/St/5EfCblqLyDuv2W9dYfxCtEEQnCCIiF+8JcHwsgLtR2NkiIy 5FvPZPA2JXHvEMokMoknZCWkoSA+5WuZLRMidgT9w3nuRZEQQELDEEOi7dwCRcuMTd7xEQR6WaSn zXGuRNCck3hWvpZXJp2JgprDUNiyxD7LWupCwms1yLUsfpJ41sSxfykgDEE1kn6WcjQtimxMiJiC UEaBTB+DPwF/Xj8vPvHrONXFXetVl1MZNMtVd3JpRVVN6Z8idaWWtAB5IAeyD3InyRPrQMgwNiZk yLuQB1pNdi5F0rmXka16htEuTwIVIXBsWNS2fpCcwNibFtX7rQvJM6SX2TcuRMq900r3T6S1eIXh Uv0utOIbl8r9k2p2Se/hPbmO913jQgbR5LHVJvsh1P/vBTrWtZm2BxIMkPSXren1Un80A+g/gJmN lVccn94J1DqdSgW+pJ2Ox9sP0h/HD64S2IY0+knwOC8AflbVNiaS1N8t7EolGI9DMAyQbg5L8gSQ QAnXMkppSiIgCJsIUT2Ox+hzJWJ0TwlGJOap7KbE7rhg4PunBO6HJc6Yhb13DwxLgOdNUhDGiOMP 9UhIUf5AEftD9xKT/umS6XTFwQyBcqKVyLRYT7plH6UiR+E/Zye3mRUUR8rQkl+EzrqRoTYuxNx+ QNC/lOKck0p+AzCdFgqTysl2J5W0BFQOaeyfhNYulKVoQyDYtuKGPyst4UF/wQx8aiIiCIoWic6J +4hL7LiXgs6EIhenFM4PympKk/K3JwPyupOyfZcac1OqcBNCYJkDohQmxJUJwWaagwX6W0TOQO8a 1xp1WSVpqW4f3SaQPOTx7Q+EGRURFf234ph4eU+z8JL1v9rcv69/lsHqqa5ubaxMxdvd3YFM1VN3 RkoEDWGhIypUnkArSwMSxzWMSYDjXMH3Tom1eKUCaUrS9dBxXOtK8VoSlOadE2LUpguUTcl6SLzE FK+E9E9C7gNS0D4QuTSPlKB3JOgWtZpnAqDBM3LZLXjz5ON9HJfOUAyfwTHuQ9MSewbFrJLqTUnu mUcEqHEli+yVrNOKdl0LkCdS+yfu7gJpTmB1EKMsiy7jlPgJ2X70+F0feQva3S47of2wpEAZk1JU BrS9S1fuJXzCOoEF0AXZzOSyDsh/iGoArg/EazMmZNoGUHGtAF6gY15p8D9zcuskOwPKx0WpJloe EjWvumNcQeyZU+knev0sIWamHAdQy+Z9QJmcdp5U0rxMiZ02rlDnUs0zJSv0uVbUtXan0ukvaFxs 13pnTJ7LxXEm9KUmmm5M6bEkvAcqZ1rD7rGpLkkc0sQ3rUeFtX5A3LzSYHBOanpew61wXkvBewGw 4UREQJIoSH/wP3p9yp3z1tzX93ryfffETjGYznN4FrbOc1znOSuYtapbOcxSOFT/V+1T949LsJ/J f1oP3MimhNSeENC9BMq5F0LoTkBmI1JkDol64J1MyVJStazTknhbcx9gOTYuoe4GVOqXAeljcvgM EHBMg+F9iXBJrWkw9H6Q+6HhaC5YTyDxXsnNNK6VxrREsV3C3rbZ17pWlqWp/ltBmmCbF3LXT5Ii IIj4WJZU4IdkxLyQ+V7qN965kMF2L8AZVxodwTyu0Qsmx9JQLqXsST2WsrXmag4ARauJKE9JmTIv suVzrMJVmUHqkyxC9LE1poFzD7rwOfZKk5pvLBylq+6ZU5pmA2J7pucSVooBWMLuXyk6xMSWpjuI iIiDsuceyUUZFoXomoTghUG5I37hpK0nuMSS8gXrampNq60xJ0SE0HJUmbVKBM5QuC2JCYbSCIiQ 7U7JiWmmkVETukKojjFdDoJwRDHNMa8UtSAzCF6d0rNgN4aF3h2Xqlsk4jYndJgGC5E8pzXQsvZ9 VvzS/jy337Px7FZjnIyfbw49c3VLwbJIPe1RHHCBIE6T7eePb11wveVvhF+fdCjKUVgiI/8htfUK 1YgADay2/t4eH5fX85rgfcHfY5dudSa0sO1URnija1RFVV8VRnKxGMNgYDvVK9lkX3atFsaM2PLE qPqgVMg9k0+6TAxLK9dSDkTUal0pvW1A5ruVM6Xp4DWmZPRSmotTBMZlMS7g9hoXkBxXwuxDMMkN Ce6SWhJLQnpO61pUB0TOtSXobjavuG1OqBLeu9Oa3nJalHBMa8FuIO23JTz4cs9dtfSm/nD2EFBz gojZF6VrsWF9B5OiVJSAZ01LQGc9klyShJi7QMiYk3pWnpOQB1Xwa00JvAOg6FzpYuhc6U8u6wmp dguoYSFtXQImRN6a0oSwdKbklcpltHksdgzJnTumJOSXqMZ0hR2hvJUpNTuuhaHuN6nhfCWrnS4T euVKhxpck07JcmtDWtSd0ltSxGA3LmDyFyY0hIQljSScx4p4D3jCjnKpYTuvJNJmDkndJcA1ey8A qE5FjAkMb0iteC41uFxLB4DmuheSQshOAaljOvheycEyrJKVyLI0rWGpb4/D1+P6H8T9XO3bvzdu +vZz3JJ2SCgsFCPbve14viMULRaKlbYxF71xeZTwv3pyn6C+FP2plHSdAOqGNal2hiWRtW9dx4XE HPMGVei7Eg3k05L0XwJyvTasl6rwHOnNJrYWpUuhdyQEJiUl2Tymdb17KbEx9Ke2/tTy3SXstgJJ MFtTQtK415LWLzGHSaQJE4QBSINqczYnlIMy5g5puGWdOKZF3JYslwKUyqZlvTSu5PZNi8VrKEoX QkkxJtHEnhc6STichLUvAxnBJp1StMS+QUR3JlXml62DsUDcmtdIWpjW9NLjXUuC9E1r0WldQVpC QUpvSErTMtC908DJcQmhLloypSLQsJoDevE4LYuZdCSlR+guDGU9JpMLsn3BUX809rpeV0ms3rMT 6T+Pgkn//F3JFOFCQJwPT3A=