From 320ad6e2aa9b107901a76ff7184d03bf3ef20dfa Mon Sep 17 00:00:00 2001 From: Stefan Frederik Date: Fri, 21 Jan 2022 19:17:43 +0100 Subject: [PATCH] embedded raw file storage --- src/callback.c | 2 +- src/draw.c | 245 +--- src/save.c | 277 +++- src/scheduler.c | 33 +- src/xschem.h | 10 +- xschem_library/examples/0_examples_top.sch | 1439 +++++++++++++++++++- xschem_library/ngspice/solar_panel.sch | 13 +- 7 files changed, 1732 insertions(+), 287 deletions(-) diff --git a/src/callback.c b/src/callback.c index 51450ac4..0e7f99a7 100644 --- a/src/callback.c +++ b/src/callback.c @@ -40,7 +40,7 @@ static int waves_selected(int event, int key, int state, int button) r = &xctx->rect[GRIDLAYER][i]; if(!(r->flags & 1) ) continue; if( (xctx->ui_state & GRAPHPAN) || - POINTINSIDE(xctx->mousex, xctx->mousey, r->x1 + 40, r->y1 + 20, r->x2 - 30, r->y2 - 10) ) { + POINTINSIDE(xctx->mousex, xctx->mousey, r->x1 + 20, r->y1 + 20, r->x2 - 30, r->y2 - 10) ) { is_inside = 1; tclvareval(xctx->top_path, ".drw configure -cursor tcross" , NULL); } diff --git a/src/draw.c b/src/draw.c index 1a03c50c..8b150430 100644 --- a/src/draw.c +++ b/src/draw.c @@ -1478,216 +1478,6 @@ void drawtemprect(GC gc, int what, double rectx1,double recty1,double rectx2,dou } } -/* read the binary portion of a ngspice raw simulation file - * data layout in memory arranged to maximize cache locality - * when looking up data - */ -void read_binary_block(FILE *fd) -{ - int p, v; - double *tmp; - size_t size = 0; - int offset = 0; - - - for(p = 0 ; p < xctx->graph_datasets; p++) { - size += xctx->graph_nvars * xctx->graph_npoints[p]; - offset += xctx->graph_npoints[p]; - } - - /* read buffer */ - tmp = my_calloc(1405, xctx->graph_nvars, sizeof(double *)); - /* allocate storage for binary block */ - if(!xctx->graph_values) xctx->graph_values = my_calloc(118, xctx->graph_nvars, sizeof(SPICE_DATA *)); - for(p = 0 ; p < xctx->graph_nvars; p++) { - my_realloc(372, &xctx->graph_values[p], (size + xctx->graph_npoints[xctx->graph_datasets]) * sizeof(double)); - } - /* read binary block */ - for(p = 0; p < xctx->graph_npoints[xctx->graph_datasets]; p++) { - if(fread(tmp, sizeof(double), xctx->graph_nvars, fd) != xctx->graph_nvars) { - dbg(0, "Warning: binary block is not of correct size\n"); - } - /* assign to xschem struct, memory aligned per variable, for cache locality */ - for(v = 0; v < xctx->graph_nvars; v++) { - xctx->graph_values[v][offset + p] = tmp[v]; - } - } - my_free(1406, &tmp); -} - -/* parse ascii raw header section: - * returns: 1 if dataset and variables were read. - * 0 if transient sim dataset not found - * -1 on EOF - * Typical ascii header of raw file looks like: - * - * Title: **.subckt poweramp - * Date: Thu Nov 21 18:36:25 2019 - * Plotname: Transient Analysis - * Flags: real - * No. Variables: 158 - * No. Points: 90267 - * Variables: - * 0 time time - * 1 v(net1) voltage - * 2 v(vss) voltage - * ... - * ... - * 155 i(v.x1.vd) current - * 156 i(v0) current - * 157 i(v1) current - * Binary: - */ -int read_dataset(FILE *fd) -{ - int variables = 0, i, done_points = 0; - char line[PATH_MAX], varname[PATH_MAX]; - char *ptr; - int sim_type = 0; /* 1: transient, 2: dc, 4: ... */ - int done_header = 0; - int exit_status = 0; - while((ptr = fgets(line, sizeof(line), fd)) ) { - /* after this line comes the binary blob made of nvars * npoints * sizeof(double) bytes */ - if(!strcmp(line, "Binary:\n")) { - int npoints = xctx->graph_npoints[xctx->graph_datasets]; - if(sim_type) { - done_header = 1; - read_binary_block(fd); - dbg(1, "read_dataset(): read binary block, nvars=%d npoints=%d\n", xctx->graph_nvars, npoints); - xctx->graph_datasets++; - exit_status = 1; - } else { - dbg(1, "read_dataset(): skip binary block, nvars=%d npoints=%d\n", xctx->graph_nvars, npoints); - fseek(fd, xctx->graph_nvars * npoints * sizeof(double), SEEK_CUR); /* skip binary block */ - } - done_points = 0; - } - else if(!strncmp(line, "Plotname: Transient Analysis", 28)) { - if(sim_type && sim_type != 1) sim_type = 0; - else sim_type = 1; - } - else if(!strncmp(line, "Plotname: DC transfer characteristic", 36)) { - if(sim_type && sim_type != 2) sim_type = 0; - else sim_type = 2; - } - else if(!strncmp(line, "Plotname:", 9)) { - sim_type = 0; - } - /* points and vars are needed for all sections (also ones we are not interested in) - * to skip binary blobs */ - else if(!strncmp(line, "No. of Data Rows :", 18)) { - /* array of number of points of datasets (they are of varialbe length) */ - my_realloc(1414, &xctx->graph_npoints, (xctx->graph_datasets+1) * sizeof(int)); - sscanf(line, "No. of Data Rows : %d", &xctx->graph_npoints[xctx->graph_datasets]); - done_points = 1; - } - else if(!strncmp(line, "No. Variables:", 14)) { - sscanf(line, "No. Variables: %d", &xctx->graph_nvars); - } - else if(!done_points && !strncmp(line, "No. Points:", 11)) { - my_realloc(1415, &xctx->graph_npoints, (xctx->graph_datasets+1) * sizeof(int)); - sscanf(line, "No. Points: %d", &xctx->graph_npoints[xctx->graph_datasets]); - } - if(!done_header && variables) { - /* get the list of lines with index and node name */ - if(!xctx->graph_names) xctx->graph_names = my_calloc(426, xctx->graph_nvars, sizeof(char *)); - sscanf(line, "%d %s", &i, varname); /* read index and name of saved waveform */ - xctx->graph_names[i] = my_malloc(415, strlen(varname) + 1); - strcpy(xctx->graph_names[i], varname); - /* use hash table to store index number of variables */ - int_hash_lookup(xctx->raw_table, xctx->graph_names[i], i, XINSERT_NOREPLACE); - dbg(1, "read_dataset(): get node list -> names[%d] = %s\n", i, xctx->graph_names[i]); - } - /* after this line comes the list of indexes and associated nodes */ - if(sim_type && !strncmp(line, "Variables:", 10)) { - variables = 1 ; - } - } - dbg(1, "read_dataset(): datasets=%d, last npoints=%d, nvars=%d\n", - xctx->graph_datasets, xctx->graph_npoints[xctx->graph_datasets-1], xctx->graph_nvars); - return exit_status; -} - -void free_rawfile(int dr) -{ - int i; - - int deleted = 0; - if(xctx->graph_names) { - deleted = 1; - for(i = 0 ; i < xctx->graph_nvars; i++) { - my_free(510, &xctx->graph_names[i]); - } - my_free(968, &xctx->graph_names); - } - if(xctx->graph_values) { - deleted = 1; - for(i = 0 ; i < xctx->graph_nvars; i++) { - my_free(512, &xctx->graph_values[i]); - } - my_free(528, &xctx->graph_values); - } - if(xctx->graph_npoints) my_free(1413, &xctx->graph_npoints); - if(xctx->raw_schname) my_free(1393, &xctx->raw_schname); - xctx->graph_datasets = 0; - xctx->graph_nvars = 0; - int_hash_free(xctx->raw_table); - if(deleted && dr) draw(); -} - -/* read a ngspice raw file (with data portion in binary format) */ -int read_rawfile(const char *f) -{ - int res = 0; - FILE *fd; - if(xctx->graph_values || xctx->graph_npoints || xctx->graph_nvars || xctx->graph_datasets) { - dbg(0, "read_rawfile(): must clear current raw file before loading new\n"); - return 0; - } - fd = fopen(f, fopen_read_mode); - if(fd) { - if((res = read_dataset(fd)) == 1) { - dbg(0, "Raw file data read\n"); - my_strdup2(1394, &xctx->raw_schname, xctx->sch[xctx->currsch]); - draw(); - } else { - dbg(0, "read_rawfile(): no useful data found\n"); - } - fclose(fd); - return res; - } - dbg(0, "read_rawfile(): failed to open file %s for reading\n", f); - return 0; -} - -int get_raw_index(const char *node) -{ - char vnode[300]; - Int_hashentry *entry; - if(xctx->graph_values) { - entry = int_hash_lookup(xctx->raw_table, node, 0, XLOOKUP); - if(!entry) { - my_snprintf(vnode, S(vnode), "v(%s)", node); - entry = int_hash_lookup(xctx->raw_table, vnode, 0, XLOOKUP); - } - if(entry) return entry->value; - } - return -1; -} - -double get_raw_value(int dataset, int idx, int point) -{ - int i, ofs; - ofs = 0; - if(xctx->graph_values) { - for(i = 0; i < dataset; i++) { - ofs += xctx->graph_npoints[i]; - } - return xctx->graph_values[idx][ofs + point]; - } - return 0.0; -} - /* round to closest 1e-ee. 2e-ee, 5e-ee * example: delta = 0.234 --> 0.2 * 3.23 --> 5 @@ -2321,6 +2111,37 @@ static void show_node_measures(int measure_p, double measure_x, double measure_p } /* if(measure_p >= 0) */ } +int embed_rawfile(const char *rawfile) +{ + int res = 0; + size_t len; + char *ptr; + + if(xctx->lastsel==1 && xctx->sel_array[0].type==ELEMENT) { + xInstance *i = &xctx->inst[xctx->sel_array[0].n]; + xctx->push_undo(); + set_modify(1); + ptr = base64_from_file(rawfile, &len); + my_strdup2(1466, &i->prop_ptr, subst_token(i->prop_ptr, "spice_data", ptr)); + my_free(1481, &ptr); + } + return res; +} + +int read_embedded_rawfile(void) +{ + int res = 0; + + if(xctx->lastsel==1 && xctx->sel_array[0].type==ELEMENT) { + xInstance *i = &xctx->inst[xctx->sel_array[0].n]; + const char *b64_spice_data; + if(i->prop_ptr && (b64_spice_data = get_tok_value(i->prop_ptr, "spice_data", 0))[0]) { + res = read_rawfile_from_attr(b64_spice_data, strlen(b64_spice_data)); + } + } + return res; +} + /* flags: * 1: do final XCopyArea (copy 2nd buffer areas to screen) * If draw_graph_all() is called from draw() no need to do XCopyArea, as draw() does it already. @@ -2660,10 +2481,8 @@ int draw_images_all(void) cairo_surface_write_to_png_stream(emb_ptr->image, png_writer, &closure); dbg(1, "draw_images_all(): length3 = %d\n", closure.pos); /* put base64 encoded data to rect image_data attrinute */ - image_data = base64_encode(closure.buffer, closure.pos, &olength); + image_data = base64_encode(closure.buffer, closure.pos, &olength, 0); my_free(1468, &closure.buffer); - my_realloc(1466, &image_data, olength + 1); - image_data[olength] = '\0'; my_strdup2(1473, &r->prop_ptr, subst_token(r->prop_ptr, "image_data", image_data)); my_free(1474, &image_data); } else { diff --git a/src/save.c b/src/save.c index 9e4661fe..b5c100d5 100644 --- a/src/save.c +++ b/src/save.c @@ -29,7 +29,7 @@ #undef BASE64_BREAK_LINES /* Caller should free returned buffer */ -char *base64_encode(const unsigned char *data, size_t input_length, size_t *output_length) { +char *base64_encode(const unsigned char *data, size_t input_length, size_t *output_length, int brk) { static const char b64_enc[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', @@ -45,8 +45,10 @@ char *base64_encode(const unsigned char *data, size_t input_length, size_t *outp size_t alloc_length; char *encoded_data; int octet_a, octet_b, octet_c, triple; - *output_length = (1 + ((4 * ((input_length + 2) / 3)) / 4096)) * 4096; - alloc_length = *output_length; + + + *output_length = 4 * ((input_length + 2) / 3); + alloc_length = (1 + (*output_length / 4096)) * 4096; encoded_data = my_malloc(1469, alloc_length); if (encoded_data == NULL) return NULL; cnt = 0; @@ -61,12 +63,10 @@ char *base64_encode(const unsigned char *data, size_t input_length, size_t *outp alloc_length += 4096; my_realloc(1471, &encoded_data, alloc_length); } - #ifdef BASE64_BREAK_LINES - if((cnt & 31) == 0) { + if(brk && ( (cnt & 31) == 0) ) { *output_length += 1; encoded_data[j++] = '\n'; } - #endif encoded_data[j++] = b64_enc[(triple >> 18) & 0x3F]; encoded_data[j++] = b64_enc[(triple >> 12) & 0x3F]; encoded_data[j++] = b64_enc[(triple >> 6) & 0x3F]; @@ -75,6 +75,7 @@ char *base64_encode(const unsigned char *data, size_t input_length, size_t *outp } for (i = 0; i < mod_table[input_length % 3]; i++) encoded_data[*output_length - 1 - i] = '='; + encoded_data[*output_length] = '\0'; /* add \0 at end so it can be used as a regular char string */ return encoded_data; } @@ -130,6 +131,270 @@ unsigned char *base64_decode(const char *data, size_t input_length, size_t *outp return decoded_data; } +/* SPICE RAWFILE ROUTINES */ +/* read the binary portion of a ngspice raw simulation file + * data layout in memory arranged to maximize cache locality + * when looking up data + */ +static void read_binary_block(FILE *fd) +{ + int p, v; + double *tmp; + size_t size = 0; + int offset = 0; + + + for(p = 0 ; p < xctx->graph_datasets; p++) { + size += xctx->graph_nvars * xctx->graph_npoints[p]; + offset += xctx->graph_npoints[p]; + } + + /* read buffer */ + tmp = my_calloc(1405, xctx->graph_nvars, sizeof(double *)); + /* allocate storage for binary block */ + if(!xctx->graph_values) xctx->graph_values = my_calloc(118, xctx->graph_nvars, sizeof(SPICE_DATA *)); + for(p = 0 ; p < xctx->graph_nvars; p++) { + my_realloc(372, &xctx->graph_values[p], (size + xctx->graph_npoints[xctx->graph_datasets]) * sizeof(double)); + } + /* read binary block */ + for(p = 0; p < xctx->graph_npoints[xctx->graph_datasets]; p++) { + if(fread(tmp, sizeof(double), xctx->graph_nvars, fd) != xctx->graph_nvars) { + dbg(0, "Warning: binary block is not of correct size\n"); + } + /* assign to xschem struct, memory aligned per variable, for cache locality */ + for(v = 0; v < xctx->graph_nvars; v++) { + xctx->graph_values[v][offset + p] = tmp[v]; + } + } + my_free(1406, &tmp); +} + +/* parse ascii raw header section: + * returns: 1 if dataset and variables were read. + * 0 if transient sim dataset not found + * -1 on EOF + * Typical ascii header of raw file looks like: + * + * Title: **.subckt poweramp + * Date: Thu Nov 21 18:36:25 2019 + * Plotname: Transient Analysis + * Flags: real + * No. Variables: 158 + * No. Points: 90267 + * Variables: + * 0 time time + * 1 v(net1) voltage + * 2 v(vss) voltage + * ... + * ... + * 155 i(v.x1.vd) current + * 156 i(v0) current + * 157 i(v1) current + * Binary: + */ +static int read_dataset(FILE *fd) +{ + int variables = 0, i, done_points = 0; + char line[PATH_MAX], varname[PATH_MAX]; + char *ptr; + int sim_type = 0; /* 1: transient, 2: dc, 4: ... */ + int done_header = 0; + int exit_status = 0; + while((ptr = fgets(line, sizeof(line), fd)) ) { + /* after this line comes the binary blob made of nvars * npoints * sizeof(double) bytes */ + if(!strcmp(line, "Binary:\n")) { + int npoints = xctx->graph_npoints[xctx->graph_datasets]; + if(sim_type) { + done_header = 1; + read_binary_block(fd); + dbg(1, "read_dataset(): read binary block, nvars=%d npoints=%d\n", xctx->graph_nvars, npoints); + xctx->graph_datasets++; + exit_status = 1; + } else { + dbg(1, "read_dataset(): skip binary block, nvars=%d npoints=%d\n", xctx->graph_nvars, npoints); + fseek(fd, xctx->graph_nvars * npoints * sizeof(double), SEEK_CUR); /* skip binary block */ + } + done_points = 0; + } + else if(!strncmp(line, "Plotname: Transient Analysis", 28)) { + if(sim_type && sim_type != 1) sim_type = 0; + else sim_type = 1; + } + else if(!strncmp(line, "Plotname: DC transfer characteristic", 36)) { + if(sim_type && sim_type != 2) sim_type = 0; + else sim_type = 2; + } + else if(!strncmp(line, "Plotname:", 9)) { + sim_type = 0; + } + /* points and vars are needed for all sections (also ones we are not interested in) + * to skip binary blobs */ + else if(!strncmp(line, "No. of Data Rows :", 18)) { + /* array of number of points of datasets (they are of varialbe length) */ + my_realloc(1414, &xctx->graph_npoints, (xctx->graph_datasets+1) * sizeof(int)); + sscanf(line, "No. of Data Rows : %d", &xctx->graph_npoints[xctx->graph_datasets]); + done_points = 1; + } + else if(!strncmp(line, "No. Variables:", 14)) { + sscanf(line, "No. Variables: %d", &xctx->graph_nvars); + } + else if(!done_points && !strncmp(line, "No. Points:", 11)) { + my_realloc(1415, &xctx->graph_npoints, (xctx->graph_datasets+1) * sizeof(int)); + sscanf(line, "No. Points: %d", &xctx->graph_npoints[xctx->graph_datasets]); + } + if(!done_header && variables) { + /* get the list of lines with index and node name */ + if(!xctx->graph_names) xctx->graph_names = my_calloc(426, xctx->graph_nvars, sizeof(char *)); + sscanf(line, "%d %s", &i, varname); /* read index and name of saved waveform */ + xctx->graph_names[i] = my_malloc(415, strlen(varname) + 1); + strcpy(xctx->graph_names[i], varname); + /* use hash table to store index number of variables */ + int_hash_lookup(xctx->raw_table, xctx->graph_names[i], i, XINSERT_NOREPLACE); + dbg(1, "read_dataset(): get node list -> names[%d] = %s\n", i, xctx->graph_names[i]); + } + /* after this line comes the list of indexes and associated nodes */ + if(sim_type && !strncmp(line, "Variables:", 10)) { + variables = 1 ; + } + } + dbg(1, "read_dataset(): datasets=%d, last npoints=%d, nvars=%d\n", + xctx->graph_datasets, xctx->graph_npoints[xctx->graph_datasets-1], xctx->graph_nvars); + return exit_status; +} + +void free_rawfile(int dr) +{ + int i; + + int deleted = 0; + if(xctx->graph_names) { + deleted = 1; + for(i = 0 ; i < xctx->graph_nvars; i++) { + my_free(510, &xctx->graph_names[i]); + } + my_free(968, &xctx->graph_names); + } + if(xctx->graph_values) { + deleted = 1; + for(i = 0 ; i < xctx->graph_nvars; i++) { + my_free(512, &xctx->graph_values[i]); + } + my_free(528, &xctx->graph_values); + } + if(xctx->graph_npoints) my_free(1413, &xctx->graph_npoints); + if(xctx->raw_schname) my_free(1393, &xctx->raw_schname); + xctx->graph_datasets = 0; + xctx->graph_nvars = 0; + int_hash_free(xctx->raw_table); + if(deleted && dr) draw(); +} + +/* caller must free returned pointer */ +char *base64_from_file(const char *f, size_t *length) +{ + FILE *fd; + struct stat st; + unsigned char *s = NULL; + char *b64s = NULL; + size_t len; + + if (stat(f, &st) == 0 && ( (st.st_mode & S_IFMT) == S_IFREG) ) { + len = st.st_size; + fd = fopen(f, fopen_read_mode); + if(fd) { + s = my_malloc(1475, len); + fread(s, len, 1, fd); + fclose(fd); + b64s = base64_encode(s, len, length, 1); + my_free(1477, &s); + } + else { + dbg(0, "base64_from_file(): failed to open file %s for reading\n", f); + } + } + return b64s; +} + +int read_rawfile_from_attr(const char *b64s, size_t length) +{ + int res = 0; + unsigned char *s; + size_t decoded_length; + FILE *fd; + char *tmp_filename; + + if(xctx->graph_values || xctx->graph_npoints || xctx->graph_nvars || xctx->graph_datasets) { + dbg(0, "read_rawfile(_from_attr(): must clear current raw file before loading new\n"); + return res; + } + if( (fd = open_tmpfile("rawfile_", &tmp_filename)) ) { + s = base64_decode(b64s, length, &decoded_length); + fwrite(s, decoded_length, 1, fd); + fclose(fd); + my_free(1479, &s); + res = read_rawfile(tmp_filename); + unlink(tmp_filename); + + } else { + dbg(0, "read_rawfile_from_attr(): failed to open file %s for reading\n", tmp_filename); + } + return res; +} + +/* read a ngspice raw file (with data portion in binary format) */ +int read_rawfile(const char *f) +{ + int res = 0; + FILE *fd; + if(xctx->graph_values || xctx->graph_npoints || xctx->graph_nvars || xctx->graph_datasets) { + dbg(0, "read_rawfile(): must clear current raw file before loading new\n"); + return res; + } + fd = fopen(f, fopen_read_mode); + if(fd) { + if((res = read_dataset(fd)) == 1) { + dbg(0, "Raw file data read\n"); + my_strdup2(1394, &xctx->raw_schname, xctx->sch[xctx->currsch]); + draw(); + } else { + dbg(0, "read_rawfile(): no useful data found\n"); + } + fclose(fd); + return res; + } + dbg(0, "read_rawfile(): failed to open file %s for reading\n", f); + return 0; +} + +int get_raw_index(const char *node) +{ + char vnode[300]; + Int_hashentry *entry; + if(xctx->graph_values) { + entry = int_hash_lookup(xctx->raw_table, node, 0, XLOOKUP); + if(!entry) { + my_snprintf(vnode, S(vnode), "v(%s)", node); + entry = int_hash_lookup(xctx->raw_table, vnode, 0, XLOOKUP); + } + if(entry) return entry->value; + } + return -1; +} + +double get_raw_value(int dataset, int idx, int point) +{ + int i, ofs; + ofs = 0; + if(xctx->graph_values) { + for(i = 0; i < dataset; i++) { + ofs += xctx->graph_npoints[i]; + } + return xctx->graph_values[idx][ofs + point]; + } + return 0.0; +} +/* END SPICE RAWFILE ROUTINES */ + /* read an unknown xschem record usually like: text {string} text {string}.... diff --git a/src/scheduler.c b/src/scheduler.c index d5092a84..441cf76a 100644 --- a/src/scheduler.c +++ b/src/scheduler.c @@ -635,6 +635,14 @@ int xschem(ClientData clientdata, Tcl_Interp *interp, int argc, const char * arg Tcl_ResetResult(interp); } + else if(!strcmp(argv[1],"embed_rawfile")) + { + cmd_found = 1; + if(argc > 2) { + embed_rawfile(argv[2]); + } + Tcl_ResetResult(interp); + } else if(!strcmp(argv[1],"enable_layers")) { cmd_found = 1; @@ -1778,7 +1786,7 @@ int xschem(ClientData clientdata, Tcl_Interp *interp, int argc, const char * arg int i, p, no_of_pins; cmd_found = 1; if( (i = get_instance(argv[2])) < 0 ) { - Tcl_SetResult(interp, "xschem getprop: instance not found", TCL_STATIC); + Tcl_SetResult(interp, "xschem pinlist: instance not found", TCL_STATIC); return TCL_ERROR; } no_of_pins= (xctx->inst[i].ptr+ xctx->sym)->rects[PINLAYER]; @@ -2047,7 +2055,6 @@ int xschem(ClientData clientdata, Tcl_Interp *interp, int argc, const char * arg } } } - if(!strcmp(argv[1], "raw_read")) { cmd_found = 1; @@ -2061,7 +2068,19 @@ int xschem(ClientData clientdata, Tcl_Interp *interp, int argc, const char * arg } Tcl_ResetResult(interp); } - + if(!strcmp(argv[1], "raw_read_from_attr")) + { + cmd_found = 1; + if(schematic_waves_loaded()) { + free_rawfile(1); + } else { + free_rawfile(0); + read_embedded_rawfile(); + if(schematic_waves_loaded()) tclsetvar("rawfile_loaded", "1"); + else tclsetvar("rawfile_loaded", "0"); + } + Tcl_ResetResult(interp); + } if(!strcmp(argv[1], "rebuild_connectivity")) { cmd_found = 1; @@ -2633,8 +2652,14 @@ int xschem(ClientData clientdata, Tcl_Interp *interp, int argc, const char * arg else if(argv[1][0] == 't') { if(!strcmp(argv[1],"test")) { + size_t len; + char *s; cmd_found = 1; - Tcl_ResetResult(interp); + if(argc > 2) { + Tcl_AppendResult(interp, (s = base64_from_file(argv[2], &len)), NULL); + my_free(1480, &s); + } + /* Tcl_ResetResult(interp); */ } else if(!strcmp(argv[1],"toggle_colorscheme")) diff --git a/src/xschem.h b/src/xschem.h index 3661b6a5..7d8cc4a1 100644 --- a/src/xschem.h +++ b/src/xschem.h @@ -1000,19 +1000,23 @@ extern int cli_opt_load_initfile; extern Xschem_ctx *xctx; /* FUNCTIONS */ +extern int embed_rawfile(const char *rawfile); +extern int read_rawfile_from_attr(const char *b64s, size_t length); +extern int read_embedded_rawfile(void); +extern char *base64_from_file(const char *f, size_t *length); extern int set_rect_flags(xRect *r); extern int set_rect_extraptr(int what, xRect *drptr, xRect *srptr); extern unsigned char *base64_decode(const char *data, size_t input_length, size_t *output_length); -extern char *base64_encode(const unsigned char *data, size_t input_length, size_t *output_length); +extern char *base64_encode(const unsigned char *data, size_t input_length, size_t *output_length, int brk); extern int get_raw_index(const char *node); +extern void free_rawfile(int dr); +extern int read_rawfile(const char *f); extern double get_raw_value(int dataset, int idx, int point); extern int schematic_waves_loaded(void); extern void draw_graph(int i, int flags, Graph_ctx *gr); extern void draw_graph_all(int flags); extern int draw_images_all(void); extern void setup_graph_data(int i, const int flags, int skip, Graph_ctx *gr); -extern void free_rawfile(int dr); -extern int read_rawfile(const char *f); extern double timer(int start); extern void enable_layers(void); extern void set_snap(double); diff --git a/xschem_library/examples/0_examples_top.sch b/xschem_library/examples/0_examples_top.sch index 50dec3dc..d9b80825 100644 --- a/xschem_library/examples/0_examples_top.sch +++ b/xschem_library/examples/0_examples_top.sch @@ -4,39 +4,42 @@ K {} V {} S {} E {} -L 3 830 -560 880 -540 {} -L 3 800 -680 1120 -680 {} -L 3 1160 -680 1480 -680 {} -L 8 820 -540 870 -560 {} -L 11 820 -550 870 -530 {dash=4} -L 16 830 -530 880 -550 {} -B 2 1170 -430 1460 -190 {flags=graph -y1=0 -y2=5 -ypos1=0 -ypos2=5 -divy=4 -subdivy=1 -x1=8.70075e-06 -x2=1.87008e-05 -divx=8 -subdivx=1 -node="ENABLE CLOCK DATA RESET" -color="7 8 10 11 12 13 14 15 16 17" -dataset=0 -unitx=u -} -B 2 1170 -640 1420 -472 {flags=image_unscaled +L 3 860 -680 910 -660 {} +L 3 830 -800 1150 -800 {} +L 3 1190 -800 1510 -800 {} +L 8 850 -660 900 -680 {} +L 11 850 -670 900 -650 {dash=4} +L 16 860 -650 910 -670 {} +B 2 1220 -760 1470 -592 {flags=image_unscaled image_data=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} -B 4 860 -510 880 -450 {} -B 7 820 -490 890 -470 {dash=4} -B 8 830 -510 850 -450 {} -A 4 845 -95 35.35533905932738 8.13010235415598 360 {} -A 6 910 -150 70.71067811865476 188.130102354156 89.99999999999997 {} -A 7 854.1666666666666 -90 39.58991173406564 210.3432488842396 198.9246444160511 {} -P 1 10 850 -370 840 -430 920 -410 880 -390 910 -360 890 -360 880 -340 860 -380 850 -360 850 -370 {dash=3} -P 4 6 800 -350 800 -440 790 -390 790 -430 780 -400 780 -370 {} -P 15 11 840 -400 850 -440 870 -410 880 -430 890 -400 910 -410 890 -370 860 -380 830 -360 810 -410 840 -400 {fill=true} +B 2 1200 -560 1490 -410 {flags=graph +y1 = -0.038 +y2 = 20 +divy = 5 +subdivy=1 +x1=0 +x2=0.0002 +divx=9 +node="led panel sw" +color="11 18 6" unitx=m subdivx=4} +B 2 1200 -400 1490 -270 {flags=graph +y1 = 0.360479 +y2 = 3.04484 +divy = 6 +subdivy=1 +x1=0 +x2=0.0002 +divx=8 +node="i(vpanel)" unitx=m} +B 4 890 -630 910 -570 {} +B 7 850 -610 920 -590 {dash=4} +B 8 860 -630 880 -570 {} +A 4 875 -215 35.35533905932738 8.13010235415598 360 {} +A 6 940 -270 70.71067811865476 188.130102354156 89.99999999999997 {} +A 7 884.1666666666666 -210 39.58991173406564 210.3432488842396 198.9246444160511 {} +P 1 10 880 -490 870 -550 950 -530 910 -510 940 -480 920 -480 910 -460 890 -500 880 -480 880 -490 {dash=3} +P 4 6 830 -470 830 -560 820 -510 820 -550 810 -520 810 -490 {} +P 15 11 870 -520 880 -560 900 -530 910 -550 920 -520 940 -530 920 -490 890 -500 860 -480 840 -530 870 -520 {fill=true} T {Welcome to XSCHEM!} 110 -990 0 0 1 1 {layer=5} T {This is a test schematic window @@ -46,37 +49,37 @@ pressing the 'e' key, or by menu 'Edit -> Push Schematic'. You can return here after descending into a schematic by hitting '-e' or by menu 'Edit -> Pop'. } 60 -920 0 0 0.4 0.4 {} -T {Lines} 930 -560 0 0 0.6 0.6 {layer=4} -T {Rectangles} 930 -500 0 0 0.6 0.6 {layer=4} -T {Polygons} 930 -410 0 0 0.6 0.6 {layer=4} +T {Lines} 960 -680 0 0 0.6 0.6 {layer=4} +T {Rectangles} 960 -620 0 0 0.6 0.6 {layer=4} +T {Polygons} 960 -530 0 0 0.6 0.6 {layer=4} T {Electrical -wires} 930 -330 0 0 0.6 0.6 {layer=4} -T {XSCHEM OBJECTS} 830 -720 0 0 0.6 0.6 {layer=7} -T {Components} 930 -210 0 0 0.6 0.6 {layer=4} -T {TEXT} 810 -620 0 0 0.5 0.5 {layer=8} -T {TEXT} 810 -670 1 0 0.7 0.7 {layer=6 font=Monospace} -T {Text} 820 -660 0 0 0.5 0.5 {layer=7 font="serif"} -T {TEXT} 910 -660 1 0 0.5 0.5 {weight=bold} -T {Text} 930 -650 0 0 0.6 0.6 {layer=4} -T {Arcs/Circles} 930 -120 0 0 0.6 0.6 {layer=4} +wires} 960 -450 0 0 0.6 0.6 {layer=4} +T {XSCHEM OBJECTS} 860 -840 0 0 0.6 0.6 {layer=7} +T {Components} 960 -330 0 0 0.6 0.6 {layer=4} +T {TEXT} 840 -740 0 0 0.5 0.5 {layer=8} +T {TEXT} 840 -790 1 0 0.7 0.7 {layer=6 font=Monospace} +T {Text} 850 -780 0 0 0.5 0.5 {layer=7 font="serif"} +T {TEXT} 940 -780 1 0 0.5 0.5 {weight=bold} +T {Text} 960 -770 0 0 0.6 0.6 {layer=4} +T {Arcs/Circles} 960 -240 0 0 0.6 0.6 {layer=4} T {Select the components here under and press'-h' or -click them to visit xschem websites or local docs} 400 -360 0 0 0.3 0.3 {slant=oblique } -T {SPECIAL OBJECTS} 1190 -720 0 0 0.6 0.6 {layer=7} +T {SPECIAL OBJECTS} 1220 -840 0 0 0.6 0.6 {layer=7} T {Embedded PNG Images (yes, that's me...) -} 1480 -650 0 0 0.6 0.6 {layer=4} +} 1540 -770 0 0 0.6 0.6 {layer=4} T {Simulation Graphs -} 1480 -410 0 0 0.6 0.6 {layer=4} -N 790 -300 910 -300 {lab=#net1} -N 830 -340 830 -250 {lab=#net2} -N 830 -270 890 -270 {lab=#net2} -N 850 -310 880 -300 {lab=#net1} +} 1540 -560 0 0 0.6 0.6 {layer=4} +N 820 -420 940 -420 {lab=#net1} +N 860 -460 860 -370 {lab=#net2} +N 860 -390 920 -390 {lab=#net2} +N 880 -430 910 -420 {lab=#net1} N 380 -530 640 -530 {lab=BUS[4:0]} N 510 -640 510 -540 {lab=BUS[1]} N 410 -600 410 -540 {lab=BUS[2]} @@ -90,7 +93,7 @@ C {title.sym} 160 -30 0 0 {name=l1 author="Stefan Schippers"} C {cmos_example.sym} 160 -570 0 0 {name=x6} C {greycnt.sym} 160 -610 0 0 {name=x8} C {loading.sym} 160 -650 0 0 {name=x9} -C {inv_bsource.sym} 850 -200 0 0 {name=B1 TABLE="1.4 3.0 1.6 0.0"} +C {inv_bsource.sym} 880 -320 0 0 {name=B1 TABLE="1.4 3.0 1.6 0.0"} C {launcher.sym} 460 -210 0 0 {name=h1 descr="XSCHEM ON REPO.HU" url="http://repo.hu/projects/xschem" @@ -117,3 +120,1335 @@ C {plot_manipulation.sym} 160 -250 0 0 {name=x11} C {logic_test.sym} 160 -210 0 0 {name=x12} C {simulate_ff.sym} 160 -170 0 0 {name=x13} C {test_mos_verilog.sym} 160 -130 0 0 {name=x14} +C {launcher.sym} 1265 -225 0 0 {name=h5 +descr=" Ctrl-Left-Click to load/ +unload waveforms" +tclcommand="xschem raw_read_from_attr" +spice_data=" +VGl0bGU6ICoqIHNjaF9wYXRoOiAvaG9tZS9zY2hpcHBlcy94c2NoZW0tcmVwby90cnVuay94c2NoZW1fbGlicmFyeS9uZ3NwaWNlL3NvbGFyX3BhbmVsLnNjaApEYXRl +OiBGcmkgSmFuIDIxIDE4OjMwOjQxICAyMDIyClBsb3RuYW1lOiBUcmFuc2llbnQgQW5hbHlzaXMKRmxhZ3M6IHJlYWwKTm8uIFZhcmlhYmxlczogMTAKTm8uIFBvaW50 +czogMTU4NQpWYXJpYWJsZXM6CgkwCXRpbWUJdGltZQoJMQl2KGxlZCkJdm9sdGFnZQoJMgl2KHBhbmVsKQl2b2x0YWdlCgkzCXYoc3JjKQl2b2x0YWdlCgk0CXYoc3cp +CXZvbHRhZ2UKCTUJaSh2ZGlvZGUpCWN1cnJlbnQKCTYJaSh2aW5kKQljdXJyZW50Cgk3CWkodmxlZCkJY3VycmVudAoJOAlpKHZwYW5lbCkJY3VycmVudAoJOQlpKHZz +dykJY3VycmVudApCaW5hcnk6CpZkeeF//aU9GzRD4I55Fb4HQvPuF63EPqJx9KWejDFAXcebHV6Ipz4yzD2RnUTJvAAAAABGuEg9P/PjReF6VD+vdh0n47cDQAAAAAAA +0Eg9lmR54X/9tT2wqkrfjnklvlfaqe4XrdQ+r/EMpp6MMUAAv2w2OkauPvLoXSTfQNC8AAAAAMBGXD0C0hlE4XpUP2J2kSbjtwNAAAAAAABgXD2WZHnhf/3FPTVT1d2O +eTW+vr477het5D7L8T2mnowxQEgWv7MUDLE+IJYmauVN0rwAAAAA+BNvPYWPhUDhelQ/wXV5JeO3A0AAAAAAABBvPZZkeeF//dU9p+Qu2o55Rb6XeSjtF630Pgbyn6ae +jDFAPBqDKKr9rz63RWjxyizRvAAAAIBVf4A9mApdOeF6VD9udEkj47cDQAAAAAAAgIA9lmR54X/95T076IPSjnlVvixo5uoXrQQ/ivJjp56MMUBWylLHd4ewPj3GGwmB +v9G8AAAAQCLokD2+AAwr4XpUP3tx6R7jtwNAAAAAAADqkD2WZHnhf/31Pc7x/sKOeWW+Z4FU5hetFD/H8+uonowxQMDs+czDL68+5+AGSUC+0LwAAACgUiOhPTvtaQ7h +elQ/Z2opFuO3A0AAAAAAACShPfgj67QSh/s9On/SE+jhar7a2Eaz9OEZP2dgsamejDFAYM+MtX7irz4nIMTDNB7RvAAAAMA5gKU9hFT+/+B6VD/WRsER47cDQAAAAAAA +gKU9/mu4KF7b/j3ofmO2OSJuvmVCH8FRAx0/IBMoqp6MMUDQoi8O7+GuPiJg40R3lNC8AAAAACgiqD060FL34HpUP2sAGw/jtwNAAAAAAAAgqD0Ql/7mimUAPtEF7IIp +A3C+TbY162nVHj/fHG2qnowxQGDyi10gSK8+KNT0g1TL0LwAAAAAeKipPRviR/LgelQ/mn+QDeO3A0AAAAAAAKipPfAe2NjxDQE+6alECJ6ncL4DInOwCwkgP+kEnKqe +jDFAQPjjESPxrj7VrUjHoJzQvAAAAAC0sqo9Bcra7uB6VD82doQM47cDQAAAAAAAuKo98pYRF/KUAT61E5lCdCtxvioFPLD6hyA/Q5/Bqp6MMUAenm2v+ocgP1r/dJgN +wEG9AAAAgFAWxD3UqBvs4HpUP4WWrQvjtwNAAAAAAAAoxD397fBIfCUCPkHNVDSbuHG+9kmttuEPIT/K4emqnowxQIlatrThDyE/+itkK/pRQr0AAAAAiIXYPSXZKung +elQ/DIjHCuO3A0AAAAAAAIzYPVgIjxFDhwI+mCX4URcYcr7tf3O20GshP9MdBauejDFA3qeus9BrIT/nP9OtsLRCvQAAAECZSeE9jpgt5+B6VD/Z5ysK47cDQAAAAAAA +TuE9zqxiwjYQAz4znxZJ1Z1yvnPHOlCV7CE/TkMrq56MMUACUU5MlewhP8kyByX0PkO9AAAAgBSB6D0YTmTk4HpUPyDtUQnjtwNAAAAAAACG6D269QkkHiIEPmsr+jVR +qXO+rYO4gx7uIj9CjnernowxQBKTY30e7iI/Qu5BE3tTRL0AAAB45cbzPTi50d7gelQ/q/edB+O3A0AAAAAAgMnzPZOHWOfsRQY+mywLCknAdb7LpnDqMPEkPzMkEKye +jDFAMszl3jDxJD8vsQLviHxGvQAAAMaNBwI+ko+s0+B6VD+PDDYE47cDQAAAAADgCAI+Rav1bYqNCj4f+NCYOO55vhtH07ZV9yg/NlBBrZ6MMUDzwUifVfcoP4cQsaOk +zkq9AAAAkmFjEj7ZPGK94HpUP6Y1Zv3itwNAAAAAADxkEj6V1iboCy4RPq3SYOH2xoC+B1mqnDonMD+Q/W2vnowxQJ4LPoM6JzA/MX8D+SpYUb0AAAC4EdwjPt8huZTg +elQ/fjL58OK3A0AAAAAAntwjPvQm0KibmxE+YtLtMfUxgb7fNVlKPo4wP90Gq6+ejDFAPtQxLz6OMD+/Fu5Wx8ZRvQAAAA82NiU+qt5DkOB6VD8Wa5zv4rcDQAAAAADQ +NiU+scciKrt2Ej7JKQrR8QeCvoN5qKVFXDE/uhglsJ6MMUCzZfWGRVwxP3menBIApFK9AAAAWlL7Jz4yWFmH4HpUP2jg4uzitwNAAAAAAOj7Jz4rCcgs+iwUPiUMzQLr +s4O+9ivwW1T4Mj+MPBmxnowxQFt5pDVU+DI/668RiXFeVL0AAACVgOotPslLhHXgelQ/mspv5+K3A0AAAAAAJOstPiCMEjJ4mRc+0QNVL90Lh76OmCPHcTA2P3+EAbOe +jDFAsr6hj3EwNj+nKVtyVNNXvQAAwMxZrjU+VDXaUeB6VD8mnYnc4rcDQAAAAAC4rjU+CpKnPHRyHj5/5TiDwLuNvldoFZisoDw/sRXStp6MMUBUmRM2rKA8PwfvZTYa +vV69AABg9BwkQz6TE4YK4HpUP+c6vcbitwNAAAAAgFokQz7vzugoNhImPlbXVObAjZW+ttD9EZHARD83PXO+nowxQP6mVaaQwEQ/HTsXwlJIZr0AABiVqwZVPmgK3nvf +elQ/E1kkm+K3A0AAAAAg2AZVPmFtCR8X4jE+wHM+Jrl2ob69HKI4g9BQP8+gtc2ejDFAdizYp4LQUD9bR0rN7g1yvQAAEtJMR2w+XU+PXt56VD/zH/JD4rcDQAAAAPBw +R2w+NHkzNA+UPz6aUWwrNtauvrfXFDz4sF0/LLo67J6MMUAk0yR09rBdPx+CbLh44X+9AABhSChDhj6apfoj3HpUPyTYi5XhtwNAAAAAODhDhj5uyEOv/3tNPk+FX+/c +yby+/ZeFX/C4az94NUYpn4wxQFPl8kHtuGs/joaPYUTEjb0AIJxrzXijPrj7D6/XelQ/EfO3OOC3A0AAAADc1HijPgrwy+z3b1w+og2sVPDAy755GQ7E6rx6P/ZMYqOf +jDFAeVzB9uS8ej8AJ0Q+prWcvQA46TeMIcI+9hERx856VD+I2vJ+3bcDQAAAgM6PIcI+2AOQC/Tpaz6eIZ980zHbviQF8PbjPoo/LPWul6CMMUCVPffH2D6KP0yeuYtO +Lqy9AGbp9GJ54T7m9koFvXpUP4yr8wrYtwNAAADAt2R54T7ADfIa8qZ7PgVEyORdwOq+afqV/dX/mT8g15mAoowxQL4TNQrA/5k/QkEFrI7qu70AIuHUIiYBPwR3jfGZ +elQ/sDIjIc23A0AAADS0IyYBP7QSoyJxhYs+iNZuM27h+b5EZGSLL+CpP95Ds1OmjDFAHmDuDgTgqT+fB/qce8jLvaASfaqd/CA/qUi/QFd6VD9TxUhGt7cDQAAAnxme +/CA/OJgv6IiomD7oyz7+DkIFv3Qu0WfHLrc/LZkibqyMMUAtsGGXgS63P4q4vqUg5Ni9YP3CKWtFOz8ztSGJ/nlUP1G5FWaUtwNAAIBTjWtFOz+4fB4zoASiPkNVjw9q +kQq/FycCAUHwwD8pn//UsowxQPNdQ3X278A/07jiW7Qv4r3Y+dI9lh5NPwz37+bFeVQ/qbsm0W+3A0AAwJGGlh5NP5yHKwuQfag+tbZRXqFpCr+zxrVRNgXHP7rcSCS6 +jDFAfJ+pnawExz9A1Pv4NbfovZQ8Oi4q5Vo/HGBoj8d5VD9pgBYMRrcDQACAqF8q5Vo/QEgtpXhTrj5WjFXgvtkCv43l5NZ4gMw/Hzm4w8CMMUA7NmK5pX/MP8tTr0ak +me69+GuFpOGdZD93gq02GHpUP91L4zMgtwNAACAfw+GdZD+N7bWg98awPrKzy8E0E/a+JkdauIqIzz8cskpyxIwxQIFqUEmIh88/1NUv9l7t8L30K7HU1zxpP5F2Poxr +elQ/qOHCKQu3A0AAQIz21zxpP6YvaKyo4rA+XJUxe2rP9L7ZXJBwirzPP8G9ZrLEjDFA6iZUp4S7zz9e3EDWRwnxvbixMb+mkGk/71NhS3J6VD+ww2u7CbcDQAAAROGm +kGk/2bPMwwoasT6GNxSf6jnyvuXHFrVEEtA/HY+RMMWMMUCjnclwvhHQP7eztVAZQfG90J2+71Y5aj8QyzsTgHpUP1oXd+oGtwNAAABEElc5aj8/vJXyzoixPv+ltAav +dOm+JJ8HRkJ60D/2NfMsxowxQPKscCG1edA/FyMBn7qw8b0oVexXJZFrP54YCWadelQ/zBRJSAG3A0AAAE57JZFrPwrNJ1BXZrI+ABT0OzKSl77T+7uaN0rRP78iACbI +jDFAdgLpMZxJ0T9Vwodz9o/yvbcLlA95Wm4/55CfUN96VD8CXkgC9rYDQAAAtDR5Wm4/oe5LC2ghtD48tAc4RiL+PmU/X7sJ6tI/9Ud2GsyMMUBaUaa7T+nSP3rxZ49R +TvS9VMvw+vgpcj/66Xn+gXtUP4zSyWjftgNAACA/D/kpcj/c9viKPkO3Pq8n5SzVwBo/if4Fdjba1T/gVI5D04wxQL8wIiM+2dU/NBxX2rJ1973bBaMnGEB4P2mUoAsc +fVQ/kD/3fba2A0AAwBg/GEB4P0f7RciAars+w3F5gkUhMD8Fc0nlz77ZP+Up/87cjDFA9AJfG3e92T9aQT9rYqP7vcYZp+Tb1YA/OamR70GAVD9MfnLzf7YDQADQePLb +1YA/3Bm6mrvkvz5ireX9gNo+P8OhsSL/790//VFMKOeMMUCvXau8LO7dP9i4jEeZEQC+kmFBPvvFhj9HVpscK4VUP+4GldBEtgNAAABTTvvFhj87gTmOKeW/Pq73b9co +3D4/+8dCBGbw3T9+2pgx54wxQGbVsZGT7t0/+6SwfNARAL4AgMYDmMaGP1P0TPUrhVQ/6Ppxm0S2A0AAAMATmMaGP/lPOHUF5r8+hXgxpHjfPj/PbF7HM/HdP5ailjPn +jDFATMe3O2Hv3T+HvPTmPhIAvgCQApPRx4Y/74MtEC2FVD808RCQRLYDQAAAAKPRx4Y/de01Q73nvz5cqFKkGOY+P9RDZjzQ8t0/VoWUN+eMMUCNJKUrQyodv44EGXoE +yYY/AMhTwgrJhj8y/BBGL4VUP16YQXlEtgNAAAAAAAAhaT6SI7QdB+m/Pk3SxcoQ6z4/rANSRwb03T/xq5Q654wxQLncDWtCKh2/cdSi4wPJhj8AoB4sCsmGPw9ziO4w +hVQ/fCkcaES2A0AAAAAAACJpPnipsxNf6b8+tqYvCGTsPj+x/+X0WPTdPxuEYTvnjDFAQTWtN0IqHb+aUX+7A8mGPwCQDAQKyYY/EGi5XzGFVD9pn4ljRLYDQAAAAAAA +I2k+Q7Wy/w7qvz4HNPyCCu8+P1/RDVD+9N0/SDP7POeMMUDMV+jQQSodv5eENWsDyYY/AFDlswnJhj+ZQRtCMoVUP9ORZFpEtgNAAAAAAAAjaT7ZzLDXbuu/PninanhX +9D4/lI5cBkn23T+Eki5A54wxQN1FSQNBKh2/lT6RygLJhj8AcIYTCcmGP2fx3gY0hVQ/nHEaSES2A0AAAAAAACRpPgb8rIcu7r8+zNucYvH+Pj9ocPZy3vjdP4dUlUbn +jDFA5cW1Zz8qHb+bAgaJAcmGPwDghdIHyYY/8kNmkDeFVD/4HIYjRLYDQAAAAAAAJmk+YFql563zvz5Uy1U0JRQ/P5nRG0wJ/t0/teZiU+eMMUC9VTkvPCodv/zK5AT/ +yIY/ABZ6TwXJhj+ctHSjPoVUP9EiXdpDtgNAAAAAAGAqaT4TF5anrP6/PqVPFM2MPj8/vgkt/l4I3j+rQ/5s54wxQMi16rg1Kh2/BF53+PnIhj8AgTdFAMmGP1DCkMlM +hVQ/BusJSEO2A0AAAAAA4DJpPj3IuxNVCsA+YDqY01uTPz+8TWlhCh3ePw3gNaDnjDFAZIH2tigqHb8WlfDO78iGP4BnBiD2yIY/qIDFFWmFVD9qbV4jQrYDQAAAAABQ +RGk+o0Gdk1IgwD6QAK+ZfB5AP+kJSSRhRt4/wqKoBuiMMUA+mLJdDiodv/CGMznbyIY/ALf0kuHIhj8ZFCGuoYVUP2c589k/tgNAAAAAAAhnaT5wNGCTTUzAPqBZepkY +yEA/In+kmw6Z3j/yUJzT6IwxQK9Yv1XYKR2/SX39ArHIhj8AZRVut8iGPx7unN4ShlQ/SujLRju2A0AAAAAAYqxpPgoa5pJDpMA+NpF17UobQj9xu8RQaT7fP6VYvG3q +jDFA80pA8GYpHb+OOrJrWMiGP2CFd/leyIY/eC+KPvWGVD8lczkfMrYDQAAAAAAVN2o+PeXxkS9UwT7FSnyJl8FEP5KwOuqOROA/vVbfou2MMUBdZZHPbigdvzGXKZKW +x4Y/gHdJZZ3Hhj+s6lD5uYhUPznHA8sftgNAAAAAAIBMaz6jewmQB7TCProUkKbFDUo/P9j2n0GP4T9UGrMQ9IwxQJ/Sfz0pJh2/jNwLONDFhj8AJeCV18WGP/pBP1ND +jFQ/tLJJDvu1A0AAAAAAUXdtPnCoOIy3c8U+9un+FA9SUj8Wf+/MnyTkP8E3ovoAjTFAn/9ED0kgHb+05+0TOcGGPyDyJ4dBwYY/MdweXlWTVD9DeDxDsbUDQAAAAEB0 +5nA+CgKXhBfzyj5jwWeUA+NcP+G1BPc+T+k/I8gjCBuNMUBAXrvTNg8dv6JhatXis4Y/NKBjc+2zhj+kzgL8dKFUP3zRxWMctQNAAAAAcPI7dT5o/HiqSavRPh/J7P54 +d2Y/cfqkAY6Y8D/COdSIQ40xQM+Q9P+L5xy/IhH3X+WUhj9IO0pM85SGP/i7h8TwtlQ/+bUe8jS0A0AAAABgpth7PvBo44i1+NQ+b95n3sq9bD9+8JVq0bLzP7AtO4Zk +jTFAVIJWccu8HL/SlYvwfnOGP0jwJHePc4Y/QjJxWcrHVD9Y1q1ueLMDQAAAAGCZhoA+yELDBdH41D6phRXq/r1sP2VWJz3rsvM/3Yly12SNMUA6xmfjybwcv9wSqbl9 +c4Y/AIBYQI5zhj+45StQzsdUP8QQlp52swNAAAAAAACHgD539oL/B/nUPvMaagFnvmw/ERJK4h6z8z/8BJrZZI0xQDrahMfGvBy/fcrfS3tzhj8AALrSi3OGP/vbxmfP +x1Q/8L5GknazA0AAAAAAAIeAPtZdAvN1+dQ+aEjXQDe/bD9LEazxhbPzP/2z5d1kjTFAN4rN7RKz8z88eQec9SYVvgBAFEzBdoY/wfApl9HHVD/s1rp5drMDQAAAQHbB +doY/Xeuhacj51D7gKwGQ079sP8hsARHTs/M/GBoe4WSNMUCcI2v0X7PzP3dDu1BIJxW+AMD7L5V7hj9QJgk708dUPy79U2d2swNAAACAWpV7hj/WzCFn3vnUPoXLeUb9 +v2w/TQzhoeez8z91uPnhZI0xQHJIs350s/M/HsPEXl4nFb4AAPLF3nyGP1VNFavTx1Q/iAZtYnazA0AAAADw3nyGP8mPIWIK+tQ+uTfRuFDAbD/ajZ3DELTzP87zsONk +jTFA4MZAk52z8z9uwtR6iicVvgAAjvRxf4Y/gQ48i9THVD8hIZ9YdrMDQAAAAB9yf4Y/rhUhWGL61D7sYOW998BsP+sfBgdjtPM/zWof52SNMUBVAEu877PzPzDB4rLi +JxW+AEDbYZiEhj+toOBL1sdUP5hUA0V2swNAAACAjJiEhj95ISBEEvvUPnWXpUlGwmw/oH6VjQe18z8AWvztZI0xQFNkHA6UtPM/3r22IpMoFb4AANJ85Y6GP44Lhs7Z +x1Q/l7TLHXazA0AAAECn5Y6GPw85Hhxy/NQ+hZ2aZ+XEbD++G62ZULbzPz89tvtkjTFAAeaysNy18z94qD4B9CkVvgDgKrSAo4Y/AjVC2eDHVD/fWFzPdbMDQAAAYN6A +o4Y/O2gazDH/1D71Tf+9K8psP2SAv63iuPM/IBcqF2WNMUAJfK7xbbjzP0Xozbm1LBW+AEiAKLvMhj+ZooEE78dUP7gyfTJ1swNAAADQUrvMhj+SxhIssQTVPjUp9dnY +1Gw/RFBuxQa+8z9IGBJOZY0xQGJR3WKQvfM/Sj/nGDkyFb4AlGMnQB+HP8pIK7ILyFQ/Gyy9+HOzA0AAAMhRQB+HP0CDA+yvD9U+UHGg+LTqbD/98t6yTsjzP0hP47tl +jTFAwpcEAtXH8z9WtO6OPz0VvgAUV3uKxIc/l8ScakbIVD8AOzaFcbMDQAAA0KWKxIc/nPzka60l1T7kaUghdhhtPzCWY4Xd3PM/m4iKl2aNMUAnVNEyXdzzP0UTnFlL +UxW+ADU/ZiAQiT/XsJBTwchUP2DzDJ5sswNAAADmkCAQiT9U76drqFHVPo5u06AmfG0/TbG1A/cF9D+M7etOaI0xQOdlIllpBfQ/W03MY15/Fb4A7bqZUKuLP77XfyLN +yVQ/TiBOz2KzA0AAALvEUKuLP8XULWueqdU+KzUQRpRkbj+rNWU7GVj0P1Cn+L1rjTFAPw2njnBX9D/6QG4ectcVvoAUG3zeeJA/5320mj3MVD/A+ikwT7MDQACA8pHe +eJA/pp85aopZ1j6sNYHyH15wP/2bBUcZ/PQ/xwkrnXKNMUCBqTNOOfv0P1zL/MROhxa+EMsmakzflT+t8DIoidJUP2panOsnswNAAACugEzflT9pNVFoYrnXPo4Xc0zV +zXM/pl6fXf1C9j8ymXxfgI0xQGVPFbWpQfY/UBFiqNHlF75YvsuxupWgP+P7fngE5VQ//W8TTNmyA0AAqL69upWgP+5ggGQSedo+B+w6EcRffz/juYnjAsz4P6k0FfCb +jTFAJWVvvLPJ+D/uhkhPpZ0aviB71Lto3aw/Kcl0qlwjVT9dZavIO7IDQABQI8lo3aw/Zu+Rb+Tx3D5r8Ac2NMSHP9Yg8PrXDfs/oayoC7WNMUDZ8x8VkAr7P2uKTJQL +CR2+yOfWTVyBtD8bLzhMGXtVP2bcqU+ssQNAACoZVVyBtD8+yXHs//HcPtFEufadxIc/Xxsh9PAN+z/xYn86tY0xQI1LDQOpCvs/QE/XWCYJHb4AgJC0ooG0P6rV5Hh4 +e1U/eoEDRKuxA0AAAMC7ooG0P+18MeY28tw+4Gj9enHFhz+qO33mIg77PwwJrjy1jTFA8hHi3toK+z9VgObhWwkdvgBAgoIvgrQ/B2aff4F7VT8JOos3q7EDQAAAoIkv +grQ/TOSw2aTy3D7CPf+OGMeHP3+0QXmIDvs/7CMeQbWNMUDYuC8U7EBKv2lIxW+4grQ/AABqRruCtD+VAJmNk3tVP7wyLx6rsQNAAAAAAIC1hj7TcVBQ9/LcPqmbO+JV +yIc/ddLm6dUO+z/eUIBEtY0xQOWMWhTqQEq/E77m37aCtD8AoJO2uYK0PxE0Rhihe1U/lp/ZCquxA0AAAAAAgLWGPkxT0E0N89w+ZavwgKrIhz9NMXmQ6g77PxJNZ0W1 +jTFAg1bYi+lASr+WA0F1toK0PwAA8Eu5grQ/RW+7tKR7VT9RtbEFq7EDQAAAAAAAtoY+PxbQSDnz3D4Y01a+U8mHPy/knd0TD/s/F0Q1R7WNMUCDXdB66EBKvw7J8p+1 +grQ/AECmdriCtD/0N6Ltq3tVP6LoYfuqsQNAAAAAAAC2hj4knM8+kfPcPllTCzmmyoc/FQnnd2YP+z8xM9FKtY0xQBAiq1jmQEq/nLJF9bOCtD8AwAHMtoK0P3iAcV+6 +e1U/NEnC5qqxA0AAAAAAALaGPu+nzipB9Nw+yhEVLkvNhz9WT3isCxD7P58VCVK1jTFAZYULFOJASr83AKmfsIK0PwBgdnazgrQ/7u0WQ9d7VT8s8oK9qrEDQAAAAADA +toY+hb/MAqH13D7EWqsWldKHP73NlhVWEfs/aet4YLWNMUBttXeJ2UBKv72FZfOpgrQ/AJhVyqyCtD92OH0KEXxVP2HjA2uqsQNAAAAAAIC3hj6x7siyYPjcPuu/4eEo +3Yc/FZLD5+oT+z+y2lh9tY0xQJi9/W7IQEq/Hzy2lpyCtD8AkOttn4K0P3B8t5mEfFU/4EIExqmxA0AAAAAAsLmGPghNwRLg/dw+bexqYFDyhz/WN9yLFBn7PyTIGbe1 +jTFAh4PAJKZASr/BZrbMgYK0PwBSdqSEgrQ/ukLiuWt9VT8S9v57qLEDQAAAAAAAvoY+tgmy0t4I3T6oepf9nhyIP6HvCdNnI/s/pd6fKraNMUB/jyE7YUBKvxs4MvZL +grQ/AE0Hz06CtD+C3gwBOn9VP1Is3OelsQNAAAAAAKjGhj4Sg5NS3B7dPjXanrU6cYg/CNFWXQ44+z9x+7wRt40xQLn9VhPWP0q/OfYbP9+BtD+AXxsa4oG0P3z/lqrW +glU/5NA1v6CxA0AAAAAA+teGPsp1VlLXSt0+ZMmSBmwaiT91X7RhW2H7P5H+OuC4jTFAGma6cbo+Sr/Dn9moAYG0P4CuLYgEgbQ/NSmEaRCKVT8Gv2VslrEDQAAAAACg ++oY+O1vcUc2i3T6u13t9tWyKPybJbin1s/s//31GfryNMUCZN8XnbTxKv3ATEt01f7Q/IGYPxTh/tD/hB+qOhZhVP5BUtsCBsQNAAAAAAOs/hz4cJuhQuVLePtyCckve +EI0//HxhtCdZ/D/O+52+w40xQBESfcR/N0q/HLaB0Vt7tD8wdNHKXnu0P19WATl2tVU/rYULUVixA0AAAAAAfsqHPt+7/06Rst8+ZunN6q0rkT8RZz+0iKP9PxzfY1DS +jTFA2K4/pU8sSr+ZwBk5nnK0P7DjDVWhcrQ/zck0EW/vVT/Ucg4QBbEDQAAAAECh34g+snOXpSA54T7Q1sh71W2WP/4Tzx0dHABAvUj0uO+NMUBFZZKtoxBKvx5fmt// +XLQ/YIDVQANdtD9oPoXormNWP3ypsANdsANAAAAAANkJiz5kMa6Z/1HjPgLLZVjyZZ4/YC40VBkUAkDmPZ9+HY4xQEG7mYjh2Em/Sxq4MnAxtD9gAKT9czG0P3iwqfEM +Flc/UZ6WdVevA0AAAAAwX1eOPvBo44i1+OQ+1GU1veVOoj+kmCX716ADQOOn2tpCjjFAes5OJo2hSb9Pke1FNga0P9DPDGQ6BrQ/y8tDbUmkVz88ZdX4ga4DQAAAAAB9 +eJA+3FVTR8P45D4wM0iA/06iP3dnLeHkoANARYd9PEOOMUBhlhMwi6FJv3xNj700BrQ/AICx2zgGtD9CJjrZJKVXP06N6cp/rgNAAAAAAAB5kD60LzPE3vjkPveYaQYz +T6I/+vs8rf6gA0AnQO4+Q44xQMDAl0OHoUm/lo7OrDEGtD8AAPbKNQa0P10UWxMupVc/+rX3vH+uA0AAAAAAAHmQPmTj8r0V+eQ+C7quFJpPoj8TtltzMaEDQDDQt0ND +jjFAb3CYSpefA0DwJKosChIlvgBAXX79BrQ/WbMAiEClVz/pfpyhf64DQAAA4Ij9BrQ/J6pC+T755D4WM0Bj50+iPzIQaepWoQNA0ilHR0OOMUBXuVCpvJ8DQI8T2kwy +EiW+AAC1pS0ItD87KzBgTqVXP+XHRI1/rgNAAABgsC0ItD/kmgL4SfnkPk2qsAH8T6I/E18C6GChA0CLHTlIQ44xQEXpbKDGnwNAAOIVAD0SJb4AALjBfgi0PznCfBFS +pVc/mTLeh3+uA0AAAIDMfgi0P118gvVf+eQ+YZM7PyVQoj/FTjLjdKEDQEwDHUpDjjFAlJSijtqfA0BEl4pmUhIlvgAADvogCbQ/BAwxdFmlVz+3ERF9f64DQAAAwAQh +CbQ/UD+C8Iv55D5WSU2+d1CiP7cZgtmcoQNAas7kTUOOMUDsr/1qAqADQBuUYjN9EiW+AIChbGUKtD/d3VI6aKVXPzjSdmd/rgNAAAAgd2UKtD82xYHm4/nkPgBsYMwc +UaI/PF3hxeyhA0AQY3RVQ44xQO34ciNSoANAY9bMzNISJb4AQFxZ7gy0P6SDe8mFpVc/NlxCPH+uA0AAAOBj7gy0PwLRgNKT+uQ+e8hGKGdSoj/FlZ6djKIDQA6Gk2RD +jjFAOc9Zk/GgA0ADeIr+fRMlvgAgKFEAErQ/1h9h88ClVz88lNnlfq4DQAAAuFsAErQ/meh+qvP75D4ovx3f/FSiPwKlE0nMowNAzrLRgkOOMUBlZRhvMKIDQA0Fql3U +FCW+AMAQuiQctD+Z3H91N6ZXP4mUCDl+rgNAAACYxCQctD/HF3tas/7kPgipQ0ksWqI/df7mj0umA0Axp02/Q44xQPT7VxaupANA1vJ4CoEXJb4AkBNxbzC0P8t3HTMl +p1c/7NZo33yuA0AAAJ57bzC0PyN2c7oyBOU+02nnEZtkoj+NryjdSasDQEv6QzhEjjFAyvHWI6mpA0Cvgkse2hwlvgCcNXMMWbQ/JMdplAOpVz+7aTIseq4DQAAAxH0M +WbQ/2zJkejEP5T6sTkuIuHmiP/OpyHVFtQNAPUAqKkWOMUDvC4U6nrMDQI6sbi6LJyW+AHqjwmSqtD+oZ8zzy6xXP6H+6cV0rgNAAIA3zWSqtD9MrEX6LiXlPgyDN6fz +pKI/EMQAnTjJA0D8/dwNR44xQLwhK1SExwNAmssH7ug8Jb4Aoc5jjk21P7p990mLtFc/zp3s+WmuA0AAAG1ujk21Py2fCPopUeU+jI8LmG//oj9RSoyvDvEDQH7Y2NRK +jjFAVMf0JEDvA0CX8mfVkmclvoCQMVvElbY//UbjdsXEVz8VdE1kVK4DQABg5WXElbY/8ISO+R+p5T4tm7plpcSjPzWzsUd5QARAksYWYVKOMUB4oPqfdT4EQHDm0Zyf +vCW+AN6LZbAtuT+oqEP8MOhXP1CR60IprgNAAEBqcLAtuT91UJr4C1nmPsdAm3E+kaU/9nQkZkPeBEDmfBFyYY4xQJjbuCTT2wRAcD3V25dlJr7gScq1MXu+P7tWAhsv +O1g/k8gJK9OtA0AAGP3AMXu+P3/nsfbjuOc+XG/as548qj/4J7o/hRUGQES+M3F/jjFArzSphjISBkDfGhdt2rInvhDXA6QExcQ/KUxgoy0UWT/iCUbCJ60DQACK8KkE +xcQ/LKw6/Ez16D4biMJ1mrOvP96rBilTKAdAlVw6jZqOMUD862qFKiQHQKr+omAG2Si+oAA5h/79yT8EwO99IBhaP8ql+9iMrANAAEZvjf79yT8Ymaq6WvXoPrEmjRDe +s68/4zQ4/V4oB0Desm7Amo4xQLzZHFA2JAdARJHvCRPZKL4AAMPkOf7JP/InYNrEGlo/Ut1itIusA0AAAADrOf7JP/Byijd29eg+7R1ZR2W0rz8lYZaldigHQEtox8Ka +jjFAcMZ75U0kB0CMaoNcLNkovgCAEKCw/sk/vPC4S94aWj9WPvqmi6wDQAAAQKaw/sk/oCZKMa316D462ry5c7WvP4GNbxeoKAdA2Omux5qOMUB4suIdSaNgv9w2sj4i +/8k/AADMrCT/yT9QMIAvERtaP1Ps84qLrANAAAAAAABxkz5j7Zls1vXoPoJrPZE+tq8/xFCvxc4oB0DkGYXLmo4xQH7QhopGo2C/xKVyOB7/yT8AgJCmIP/JP8yKwFo3 +G1o/CmwHdYusA0AAAAAAAHGTPiDeWWvh9eg+YfSLqHS2rz9d0UgW2SgHQB4Gi8yajjFA/lGv2kWjYL8d8LElHf/JPwAA0ZMf/8k/FsZ9iEEbWj99uC5vi6wDQAAAAAAA +cJM+mb/ZaPf16D5UMCTX4LavP2vMe7ftKAdA5tyWzpqOMUCrEP56RKNgvwv6LAAb/8k/AABObh3/yT9xYuDjVRtaP9xafWOLrANAAAAAAABxkz6MgtljI/boPh+lNzS5 +t68/vJ3h+RYpB0C/i67Smo4xQPvzjbtBo2C/OM0NtRb/yT8AADMjGf/JPzIBspp+G1o/U5gaTIusA0AAAAAAgHGTPnII2Vl79ug+2n7q7Wm5rz88rax+aSkHQInu3dqa +jjFAnlJ3PDyjYL8XcXoeDv/JPwCAqIwQ/8k//tWGCNAbWj8U9lQdi6wDQAAAAADAcZM+PhTYRSv36D7E1n9fy7yvP69/QIgOKgdAiMg865qOMUA0cHA9MaNgv1Gv/+/8 +/sk/ACA/Xv/+yT9w1vbkchxaP/M8yb+KrANAAAAAAOBxkz7VK9Ydi/joPpo4aDuOw68/QvJem1grB0AyzvoLm44xQN8v/Dsbo2C/zAq6jdr+yT8ACBz83P7JPzn/76C4 +HVo/CPivBIqsA0AAAAAAEHOTPgNb0s1K++g+e8Uo1hPRrz+ADXfB7C0HQDEgeE2bjjFAMdp5K++iYL/tZO6zlf7JPwCglSKY/sk/s1RFJUQgWj99I3aOiKwDQAAAAAA4 +dZM+X7nKLcoA6T4nDjGXHuyvP6MXFA0VMwdAGN930JuOMUDZow7UlqJgvwLgVqsL/sk/AIiIGg7+yT+lMW9fWyVaP09O5aGFrANAAAAAAIx5kz4XdrvtyAvpPpJczyIZ +EbA/UVQBomU9B0A4yovWnI4xQM1YpEvloWC/wMowRvb8yT8AUXe2+PzJP5G2WJmKL1o/KepOyH+sA0AAAAAANIKTPojvnG3GIek+pBf5IilHsD8oPafCBlIHQAtjBeOe +jjFAWgqz1H6gYL8twFcsxvrJP4ACyJ7I+sk/GhxKIOxDWj+h7k4TdKwDQAAAAACCk5M+aeJfbcFN6T4HGFIyOrOwP8A4F99IewdAnAlA/aKOMUBh2vhPpJ1gvzfV9LxQ +9sk/gIi4M1P2yT8yM9Fgu2xaPxzJ/6FcrANAAAAAgB22kz4syOVst6XpPqAjLc4ei7E/3go7hMzNB0DdgdY2q44xQMLpVPi4l2C/Pq0EBBHtyT+AMm+DE+3JPxYC39yJ +vlo/OawRoi2sA0AAAAAAVPuTPrGT8WujVeo+ydLxCeQ5sz9V4Ch90XIIQNH9or67jjFA/LcGfwmLYL96f3rWPtnJP0BkMmdB2ck/6sQQNuBiWz/Gnlwsz6sDQAAAAEC/ +hZQ+uyoJanu16z41i3yD75K2PyDIJRbSvAlA1luTId2OMUDfBNwtS25gv5zHp3dVrMk/QFr5KlisyT/MUGI1Pa5cPznztWQQqwNAAAAAoIyalT5t6B9eWs7tPpYVK8pT +obs/EUKio0S0C0CyyoXfEY8xQKFRQ87WOWC/jC9Jol9ayT/osmOKYlrJP7JTcBC8uV4/KFW6AuOpA0AAAAAw1ECXPmgdVU0Qde8+3Ds9B3uPvz91ByJTlEANQJlCDbo7 +jzFA8P11jk0JYL/GXJguiQ7JP8AAQECMDsk/SQ8JFkQqYD+YzNjY86gDQAAAACA9jZg+VArFCx517z7+QRiKm4+/PxJ7hTWhQA1Ab0r1MDyPMUCIlSDgSwlgv6TpMo6G +Dsk/AADdn4kOyT9knrBv+SxgP2XEYTHxqANAAAAAAACNmD4s5KSIOXXvPjAkx4/cj78/4ldM+rpADUAoUr0zPI8xQGhdcoNICWC/8rFiTYEOyT8AAA9fhA7JP/Suhw4H +LWA//AV9IfGoA0AAAAAAAI2YPtyXZIJwde8+yvqLnF6Qvz8+NFR27EANQNvACTk8jzFAbZLYDOo8DUCTLaaQ3WQvvgAA2jwTD8k/0maZTCItYD8g+zUD8agDQAAAsEQT +D8k/n160vZl17z5T2+sowJC/P8UGKAkQQQ1A1a3rPDyPMUCU2B98DT0NQKkz3JwDZS++AABIa/EPyT86LsO7Ni1gP85nBu3wqANAAAAgc/EPyT9cT3S8pHXvPkX76iza +kL8/pimfhRlBDUDOz/E9PI8xQAkjHO8WPQ1AReA5wg1lL74AAA+rLBDJPySD7C48LWA/IIEs5/CoA0AAAACzLBDJP9Uw9Lm6de8+wk5lNQ6Rvz85h4l+LEENQL0R/j88 +jzFA9skQ1Sk9DUBMAfEMImUvvgAAxyqjEMk/Ro5OFUctYD86v3jb8KgDQAAAwDKjEMk/yPPztOZ17z76bEJJdpG/P0HRRnBSQQ1ATpQWRDyPMUDog+KgTz0NQFvyRaJK +ZS++AIAKK5ARyT9x27biXC1gP9BCEcTwqANAAADgMpARyT+uefOqPnbvPuKXnnxGkr8/XKBjU55BDUBJlEdMPI8xQMWnJzibPQ1ABZCKzJtlL74AAPguahPJP6pYGICI +LWA/hGdClfCoA0AAAMg2ahPJP3qF8pbudu8+jDTfEeeTvz8hJiYYNkINQJJ/qVw8jzFAvKo4ZTI+DUCNtH4fPmYvvgDAaUQeF8k/7xgfxd8tYD8IJ6U38KgDQAAAPEwe +F8k/EZ3wbk547z4B74X2KJe/P2yszptlQw1AbgNtfTyPMUB8enW5YD8NQKx8Er+CZy++AECepYYeyT+egj14ji5gP6l+bHzvqANAAAB2rYYeyT8/zOweDnvvPgaUjKiv +nb8/44esi8RFDUAowPK+PI8xQIsnWUq9QQ1Aqdrm5AtqL74AoD9BWC3JP86KzILsL2A/Z5ECBu6oA0AAABtJWC3JP5sq5X6NgO8+IdeXsMiqvz+JmpINgkoNQBAM+UE9 +jzFA0Ou/DXZGDUCFWznLHW8vvgBQ6Nz+Ssk/LASoKasyYD9WTUwZ66gDQAAAxOT+Ssk/U+fVPoyL7z5kuW1ZKcW/PxhCwZn7Uw1AuOHwRz6PMUChzcQa5k8NQBXyOQJA +eS++AJr5oVmGyT/uifrBMjhgP+hjVkDlqANAAMDXqVmGyT/EYLe+iaHvPtzULVSl+r8/kVhy0ehmDUATJI1TQI8xQIShekvAYg1A+rhOF36NL74ArlRERf3JP/BxUTpr +Q2A/3jFHkNmoA0AAIDhMRf3JP6VTer6Eze8+YNUzDkU0wD/m3IOsq4wNQJkDdWlEjzFAK0Qe9lyIDUCGnATL4LUvvgASDfPz68o/nfAlNYJaYD+5faw3wqgDQACQ+vrz +68o/tBwAX70S8D782vIiDKjAP63li4XS1w1AxC7qj0yPMUDZuarlNtMNQOo35+EfAzC+AFZQN6fMzD+bCbXCT4tgP8j0DqWTqANAAOBRP6fMzD93AoZes2rwPoabPotn +p8E/hxf3dqBsDkA4CKvGXI8xQN9ZputoZw5AOs8htK9SML4gBTxYk03QP1+ViAGm92A/A9F3/jaoA0AAsFBck03QP/zNkV2fGvE+rHiWpWAHxD/TGX8jHJAPQA1Xm9V8 +jzFA7KMysaSJD0C+bf4Wge4wvrDStCpFNdQ/OCBUWzr9YT8B6qzNf6cDQABu8C5FNdQ/UjBW4NO48T4nPxYfYpvGP6nGI0GNRxBAuFhPi5mPMUAvaSdOvUMQQLxq2v3H +djG+kInqpK7T1z803Zty3SRjP5opX7/bpgNAADpIqa7T1z/IJo6/2rjxPlXaCSiBm8Y/tuXMt5JHEEAcsQzBmY8xQHn7Sb7CQxBAjZWl1M12Mb4AANtt19PXPx/dqEKJ +KWM/0cJJjNqmA0AAAEBy19PXP7QT/n3ouPE+6LBbOr+bxj/axxulnUcQQK7ghcOZjzFAV8CLns1DEEDLSziC2XYxvgAA0v8o1Nc/PhdxkKUpYz9mjid+2qYDQAAAMAQp +1Nc/jO3d+gO58T5LYJ9gO5zGPwM+bHO1RxBA4WHpyJmPMUBFelHclYBuv4anHxR11Nc/AACKyXbU1z/26Q0t3iljPyKsXF/apgNAAAAAAABXmz7t0IWYGLnxPmhm3n2Y +nMY/s5nzxMhHEEB32kjNmY8xQGXHDJmOgG6/x/uRZ2/U1z8AgP4ccdTXP+PO7KIIKmM/6bFfRtqmA0AAAAAAAFebPkvJ5RceufE+YOlyUrGcxj/LV8LrzUcQQORic86Z +jzFAqr44qYyAbr/1VDTkbdTXPwAAoplv1Nc/0Mut9RMqYz/dyrU/2qYDQAAAAAAAV5s+CLqlFim58T5xk5j74pzGP33QXznYRxBAvXHI0JmPMUALhIzJiIBuvynHdd1q +1Nc/AADjkmzU1z9QkAebKipjP1MIYjLapgNAAAAAAABWmz6BmyUUP7nxPjTAz01GncY/7Kya1OxHEED8kHLVmY8xQOEXGwqBgG6/pyrlz2TU1z8AgFWFZtTXP2QD0OVX +KmM/ZHq6F9qmA0AAAAAAgFabPnReJQ9rufE+t3rt8Qyexj/vERALFkgQQKrVxt6ZjzFA9GPUinGAbr8X7nW0WNTXPwCA6mla1Nc/0JC0e7IqYz8PO2vi2aYDQAAAAACA +V5s+WeQkBcO58T61ZuY4mp/GP4mM+XdoSBBA13dv8ZmPMUDyjreKUoBuv6xnX3xA1Nc/AKDcMULU1z/GP8yoZytjP6MuzHfZpgNAAAAAAOBXmz4j8CPxcrrxPnqzzcG0 +osY/DUTHUQ1JEEBsH8EWmo8xQNg4QIQUgG6/aSxSBxDU1z8AsOC8EdTXP3CnNQjSLGM/vd6LotimA0AAAAAA4FibPrcHIsnSu/E+Suduv+moxj/0u00FV0oQQJD7ZWGa +jzFAaSFbXph/br8aMrcJr9PXPwBAaL+w09c/SWfu26YvYz98YgL41qYDQAAAAAAQW5s+4DYeeZK+8T708eFpU7XGP0bMBmzqTBBACui19pqPMUBIbrmun35uvyjegMDs +0tc/AAx3du7S1z9+9OXWUDVjP5/2y6LTpgNAAAAAAGRfmz4ylRbZEcTxPmRrvHolzsY/u1cpOBFSEEDkk24hnI8xQLhFKcCsfG6/eD4g9mbR1z8AsKCsaNHXPw2IXxqm +QGM/NUXR98ymA0AAAAAABmibPtZRB5kQz/E+QjjShcT/xj/lXy/LXlwQQHJIQ3eejzFAhf1gpsB4br8QxvuBVs7XPwC8kDlYztc/3ScN01VXYz/jGKSfv6YDQAAAAABQ +eZs+HsvoGA7l8T7RQAQO7mLHPyljOdz5cBBATK96JKOPMUCJ1pKEz3Buv5u3kh8iyNc/ALNQ2SPI1z/mub7nyYRjPweEZ+akpgNAAAAAgN+bmz6tvasYCRHyPqsUKEvt +KMg/AYgWqi+aEEB3ySWFrI8xQLV0rauJYG6/LYMfjmu71z8Agi9MbbvXPwTGXYAD4GM/WaVMUG+mA0AAAADA/+CbPsyiMRj/aPI+UP3Apo+zyT8fCX7zmewQQCwNkF+/ +jzFA6HbTy3A+br/lND0fyKDXPyAS8eXJoNc/XHDZZbOXZD9N2ciUA6YDQAAAAAA+a5w+CW09F+sY8z5IgF4W/cLMPzmCfyhpkRFAVeFg1uWPMUDQxn4nFPRtv1IL276v +Ztc/sADWlrFm1z9oavnOPBJmP/gcRMknpQNAAAAAgK9/nT7iy0iRWiX0PqWborXfrtA/LmqvxNWMEkBl/xXPIZAxQEu9c3/wcm2/42uS48sB1z9AzujVzQHXPx8A2w7R +YWg/lEyCF9GjA0AAAABAZiWfPvBo44i1+PQ+XKjuYxh30j/IeLSwv1ITQNmOSEZSkDFAcofqsxwAbb/ROY9sFqjWP8DPpHMYqNY/JFb0qfU/aj+6zzwlvKIDQAAAALis +OKA+Zl8baLz49D4tI6saJ3fSP3d33R/GUhNACqfgR1KQMUBrsWTIGABtv5yqjlwTqNY/AACkYxWo1j9GioVeBUBqP8fXIBy8ogNAAAAAAAA5oD5STIsmyvj0PgTsH4hE +d9I/3G4v/tJSE0Ae2BBLUpAxQMbcUvEQAG2/eryIPA2o1j8AAKBDD6jWP+05r8ckQGo/4uPoCbyiA0AAAAAAADmgPioma6Pl+PQ+yjt1Y3930j86Cajf6lITQAEO5FBS +kDFAzf71zkpPE0BCbKjR0bs0vgCAklNoqNY/vHnFmmNAaj/4r5/ou6IDQAAAuFhoqNY/iwkTQfr49D75SNiIq3fSPxw1WWT7UhNA2DkTVVKQMUBK0c48W08TQCrVpnXj +uzS+AADBG/eo1j/orh26kkBqP3e1ttC7ogNAAAAAIfeo1j/pAXPA//j0PvOKxU63d9I/cVD8y/9SE0DtnSpWUpAxQM9ZWp5fTxNAAcrmKei7NL4AABYvHanWP9CIX0uf +QGo/azB6yruiA0AAAGA0HanWP6byMr8K+fQ+ZuHH2s530j8JBUCbCFMTQMxjWVhSkDFAUeZuYWhPE0Cf/2OS8bs0vgAA0FVpqdY/qPjqbbhAaj9yMwG+u6IDQAAAAFtp +qdY/H9SyvCD59D6gfbvz/XfSP8JhuDkaUxNAHu22XFKQMUAw5IjneU8TQIsyTmMEvDS+AAChowGq1j8L+Bu06kBqP01HD6W7ogNAAADQqAGq1j8Sl7K3TPn0PiZ3Xilc +eNI/G+lsdj1TE0Ac9nFlUpAxQCRzgPOcTxNA5bbhBCq8NL4AALJAMqvWPwOC5kRPQWo/OaYrc7uiA0AAAOBFMqvWP/ccsq2k+fQ+wIuToxh50j+gLeXug1MTQHLh53ZS +kDFADdx9CuNPE0CwNwVHdbw0vgDAjoCTrdY/xCQeeBhCaj/mQGUPu6IDQAAAuIWTrdY/wSixmVT69D6mJbvTkXrSPwZ/EtwQVBNAfx3TmVKQMUBEy7E0b1ATQOYJPscL +vTS+AEA0F1ay1j9Ftholq0NqP7bp20e6ogNAAABkHFay1j9VQK9xtPv0PmNwByOFfdI/mstfpypVE0DzKqffUpAxQBSp/XmHURNA6nF2tzi+NL4AQCig27vWP6WSYZnR +Rmo/lQrXuLiiA0AAAFel27vWP35vqyF0/vQ+8/bOfW+D0j/1T8EBXlcTQGGZRWtTkDFA9rIhyLdTE0B8W/5WksA0vgAQZSDoztY//5rq6yJNaj+IkwSbtaIDQACAlSXo +ztY/0M2jgfMD9T5Btu0lU4/SP44xgsXDWxNA8LVbglSQMUC+kH1yF1gTQCP6SpJExTS+AMC71wb11j+4Qg8/11lqP+kUPWCvogNAAEDt3Ab11j90ipRB8g71Pk6Q/U5W +p9I/vnMNiItkE0BHeuyvVpAxQIu3mf7SYBNAQFnb+KTONL4AlCQOW0HXP+ER7s6Gc2o/32km7qKiA0AAQFgTW0HXP7wDdsHvJPU+5D5FeEzY0j+igebxC3YTQECVnAhb +kDFAf4gZ7TpyE0D41wR+VeE0vgDD3Ptd2tc/9qJhIQOoaj9H9O4XiqIDQAAgFQFe2tc/S/Y4wepQ9T5PW366+z3TP0TrQh7QmBNAb10asGOQMUAcVKLpzZQTQHDupip1 +BjW+gB5v5sgN2T+X16cUfRVrP+ug+6NYogNAAMCw68gN2T9q277A4Kj1PrXSA9aBGNQ/PD50EmTdE0BBY6jWdJAxQEMTCqD+2BNAEXlAK61PNb7AqTgSC3rbP9rVh1zc +Amw/jTYZo/ahA0AAmIwXC3rbP6elyr/MWPY+8VSTWP4K1j8xBsznrGIUQI9zDcCWkDFAWrf3tH1dFEBT9XKB8d01vqCgutR+M+A/3qgBSCI1bj9d2SDbNKEDQABhdtd+ +M+A/jQqPQgH39j5y2ehYOBLYP7JVXsQQ1hRAbpCJfbSQMUCBBFCsKNAUQJI0HSkRWTa+AJryKUt14j/SXMiTi0lwP2s0gOmKoANAAL29LEt14j8DAcchCPf2PukX4V9Q +Etg/s9i0rxXWFED2adB+tJAxQFZFjY8t0BRAtDyfaBZZNr4AAOF4ZHXiP8bPq9yZSXA/+X004oqgA0AAAKh7ZHXiP+/tNuAV9/Y+HqITboAS2D9qtF2GH9YUQGkcXoG0 +kDFA4pkDVjfQFEAB0Z7nIFk2vgAAxxaXdeI/gaKpbrZJcD98FJ3TiqADQAAAmBmXdeI/x8cWXTH39j5s1nWL4BLYPxZy5Dk21hRAwnVCh7SQMUC/CFuo+6B3v9Ueh5vE +deI/AACBs8V14j/GEJqT70lwP2jx8bGKoANAAAAAAMB/oT4oq776Rff2PpHJzaEoE9g/ZXY3hUnWFECAcESMtJAxQGGe5vfzoHe/vCusmb514j8AgKaxv3XiP6Z+rm8a +SnA/mlhUlYqgA0AAAAAAAIChPoajHnpL9/Y+dTXx2jsT2D//pF6qTtYUQEJPmo20kDFAaiX26vGgd787TZD/vHXiPwAAjBe+deI/lsC23SVKcD9kzbKNiqADQAAAAAAA +f6E+Q5TeeFb39j47gTRNYhPYPzL+rPRY1hRATQpGkLSQMUA4+xHR7aB3v0QMVsu5deI/AABR47p14j/Yy5a5PEpwPxzFb36KoANAAAAAAAB/oT68dV52bPf2PpnQpTGv +E9g/lphJiW3WFEBNgp2VtJAxQFZVNp3loHe/q3LSYrN14j8AAM96tHXiP0RRbnFqSnA/u6npX4qgA0AAAAAAAIChPq84XnGY9/Y+Z00z+kgU2D9YbYKyltYUQN55TKC0 +kDFAucMxNdWgd7/p4I6RpnXiPwDAjamndeI/exZ74cVKcD+UR90iiqADQAAAAAAAgKE+lL5dZ/D39j5PtfmJfBXYP8KW8gTp1hRAYIeqtbSQMUAhivNjtKB3v+lDFu6M +deI/AIAZBo514j+BfwvDfEtwP9bVw6iJoANAAAAAAECAoT5eylxToPj2PivuM6TjF9g/I+nMqY3XFEDSG2fgtJAxQKbGorxyoHe/Mitfo1l14j8AEGu7WnXiP3p1B4zq +THA/cDyOtIigA0AAAAAAwIChPvLhWisA+vY+coNbw7Ec2D+bi2nz1tgUQHoq4jW1kDFA90awWu+fd79xt9n+8nTiPwDQ9hb0dOI/NT1pNcZPcD/YMRjMhqADQAAAAADY +gaE+GxFX27/89j6wN2OsTSbYP8nDQoZp2xRANd/f4LWQMUAQqYlJ6J53vxSMc3kldOI/ACyzkSZ04j8lm77lfVVwP2O7APuCoANAAAAAAPyDoT5tb087PwL3PuurtCiE +Odg/wOR0qo7gFEAqqfk2t5AxQPQcSPLYnHe/n1ZIfYly4j8AAM2VinLiP/pvA7zuYHA/UzkkWHugA0AAAAAASoihPhEsQPs9Dfc+gn5fxetf2D9hBdfs2OoUQLTVpuO5 +kDFASYuFcLWYd7/RVOi/TW/iPwAM99hOb+I/LMCKOdZ3cD9qX7QPbKADQAAAAADskKE+WaUhezsj9z505NtmpazYP9ihi1lt/xRAP0boPr+QMUDSSJgkW5B3v+T4ljTH +aOI/AM25Tsho4j87zB5NvKVwPwFK9XNNoANAAAAAgC2ioT7ol+R6Nk/3PkMVPgvBRdk/0iR90pUoFUDLMQ39yZAxQKjIQ5BZf3e/w/S0+H1b4j8A+v8Uf1viP+vTIXnj +AXE/mCzZEBCgA0AAAACAsMShPgd9anosp/c+lyar6Y922j9O1LVA5XoVQHfcDJjfkDFAtMJkpiNcd78duP7Z+z/iP0AHmvr8P+I/dTIJ4JK7cT/OOCSblJ8DQAAAAOC0 +CaI+REd2eRhX+D5QSvcZPNLcP/4iV/V9HxZAyUH7uwuRMUArbrHL9hB3vxGeIs9ABeI/UB5e+EEF4j841wuh1DtzP2AaG2CYngNAAAAAELiToj4dpoHzh2P5PgTMSGNp +LeA/ZkzQUJUaF0BQPB+pUJExQJObaQU3kna/i4E6/Dqi4T9gb54yPKLhP1llttnhkXU/ozm7gg6dA0AAAADgPmajPixDHOviNvo+DUbFDO2J4T/XWLJbOuAXQEYTwcWH +kTFAS1QjRlokdr/bmcuGZkzhPxDVisdnTOE/ZV1cZpFidz8A2/mV05sDQAAAAMDzC6Q+ojlUyuk2+j7gt09E+InhP+1/lshA4BdAYdY2eYiRMUDfATyPViR2v3Xh5p9j +TOE/AACm4GRM4T8p9RRboGJ3PySAfZTPmwNAAAAAAAANpD6OJsSI9zb6PpemYLMOiuE/OMdeok3gF0BNZeN8iJExQLWraCFPJHa/JcYZ0l1M4T8AANsSX0zhPx3egES+ +Ync/suF+f8+bA0AAAAAAAA2kPmYApAUTN/o+S9C8kTuK4T88rluAZOAXQGe+QIOIkTFA5SfbW9vaF0AHFNcIMJ05vgCAbw6STOE/DWumF/pidz9IUiBbz5sDQAAAoBGS +TOE/x+NLoyc3+j5P/AY5XYrhPwkkoIZz4BdAtNS4h4iRMUBOo91G6toXQE54eA1AnTm+AACfPOdM4T8T+7P2JmN3P0aulkHPmwNAAADYP+dM4T8l3KsiLTf6PiUykjJm +iuE/fLJHiHfgF0AeFt6IiJExQLVjQEHu2hdAgTb0UkSdOb4AAKTz/UzhP9tCGO4yY3c/Ue8KO8+bA0AAAOD2/UzhP+LMayE4N/o+OFbAJXiK4T/C0ZOLf+AXQGaWKIuI +kTFA8eQCNvbaF0C6eujdTJ05vgAAsGErTeE/9HIA3Upjdz8JgPMtz5sDQAAA4GQrTeE/W67rHk43+j7q8KoMnIrhP5MeGpKP4BdAKJO9j4iRMUAx6nUfBtsXQFyyvfNd +nTm+AADvPYZN4T+Mlo67emN3PxS3xBPPmwNAAAAgQYZN4T9OcesZejf6PuxxudzjiuE/HPHenq/gF0CPfeeYiJExQJz/E/Il2xdAI94aH4CdOb4AAP/2O07hPzntoXva +Y3c/qXtn386bA0AAADT6O07hPzP36g/SN/o+ua27hXOL4T9CeEm37+AXQNAVO6uIkTFAi1QwlmXbF0APJqB0xJ05vgDAW2unT+E/oOekB5pkdz/FXq52zpsDQAAAjm6n +T+E//QLq+4E4+j65ZlX7kozhPz8DouNv4RdAIFThz4iRMUCHm+nZ5NsXQEFr1hpNnjm+AGAQXX5S4T/1iBxPGWZ3PwCNQaXNmwNAAABEYH5S4T+RGujT4Tn6Ph6w4HTS +juE/w65gKnDiF0CvByoZiZExQIFCXk/j3BdA22jxU16fOb4AcF5kLFjhPydA1psYaXc/7op9AsybA0AAgJJnLFjhP7pJ5IOhPPo+pCdtoVOT4T8XcxFwcOQXQHxIrKuJ +kTFAuxpN8t/eF0BZId54gKE5vgDwXwKJY+E/L4qRLBpvdz+mGEy9yJsDQABAlAWJY+E/DKjc4yBC+j4odBHhXpzhP5B3Kdxv6BdAEyB00IqRMUDxMioY2OIXQIgYeo3D +pTm+ALiBekR64T+JRRcsKXt3PwHbQzTCmwNAAIC2fUR64T+wZM2jH036PtHiHgCZruE/54J6NmrwF0DJoRAZjZExQCDXLOPD6hdAXJj54ESuOb4ABINPxKfhPxXZ06p2 +k3c/xPWgJ7WbA0AA4LhSxKfhP/jdriMdY/o+nqiY6ZvT4T+kJuftTAAYQFDHeKaRkTFAcYa4cIn6F0BZnBErNL85vgC6fC7nAuI/0eAg4s/Edz/tQykkm5sDQACotDHn +AuI/h9BxIxiP+j6IRWrF3R/iP27P/TrKHxhAApDksZqRMUDm1e09zBkYQJ67axzF4Dm+gKyvzra54j+0XDgHfSp4PzkSL3VnmwNAAMjr0ba54j+mtfciDuf6PjpYjQtc +weI/vde49KJdGEDHMCWKrJExQOOd+U4vVxhALQ8ICa8iOr5AdVDyZSnkP0wgZw/QAXk//lbifAGbA0AAzJT1ZSnkP+N/AyL6lvs+mjMnHY8o5D8KYaj8wtQYQFiAXDjP +kTFAdEnXnmHNGEAbwn6mmKE6vqB7FSpFEOc/IZqJ0b7gej9MkDhQO5oDQACvaS1FEOc/yeTHpC41/D42X+y6KZXlP9TpgLikOhlAAlKVi+2RMUC4IKklazIZQDPeUYwV +Dju+wLby3uqz6T/xfpBO4sZ8P0Di8waOmQNAAHpU4uqz6T8/2/+DNTX8PsCgfm06leU/Iz+eCak6GUDfUM2/7ZExQCuiVm1vMhlA83nLJBoOO74AAGhcCLTpP6kr/pH4 +xnw/d1aP3IyZA0AAANBfCLTpPyvIb0JDNfw+t5DJ0luV5T8GENSrsToZQNoRYsLtkTFAg8ms/HcyGUAverlVIw47vgAAWldDtOk/8sAMGSXHfD8Dms/NjJkDQAAAsFpD +tOk/A6JPv141/D78Te+dnpXlP87rUSbHOhlAY+bNyO2RMUBYRx+efnOAv3rfENd1tOk/AAAfKne06T9Oveknfsd8PzpJHqmMmQNAAAAAAAAxpT5khfdcczX8Po3NcrbQ +leU/jzLFato6GUBag5DO7ZExQJXRLb93c4C/eJe3Gmu06T8AAMhtbLTpP7q8Q/PAx3w/2uwziIyZA0AAAAAAADGlPsJ9V9x4Nfw+0hNNEt6V5T+tHBeO3zoZQBvBGdDt +kTFAGWod6nVzgL/H9c09aLTpPwAA3pBptOk/wW8Rw9LHfD8c1Wx/jJkDQAAAAAAAMaU+f24X24M1/D59ev7J+JXlP1DsutTpOhlAkDks0+2RMUCdXvo/cnOAv9Uz94Ni +tOk/AAAI12O06T9Qo6hi9sd8PxC33m2MmQNAAAAAAAAxpT74T5fYmTX8Pn5kTjkuluU/+m8CYv46GUDSLFHZ7ZExQH7cputqc4C/hbg0EFe06T8AAEZjWLTpP1HbvaE9 +yHw/m23CSoyZA0AAAAAAADGlPusSl9PFNfw+UaqiF5mW5T/aCJF8JzsZQK0cm+XtkTFA1CvKQlxzgL975FsoQLTpPwCAb3tBtOk/wI2DH8zIfD9HpYkEjJkDQAAAAACA +MaU+0JiWyR02/D5x9hzTbpflP8SArLF5OxlAxyEv/u2RMUDCGTrwPnOAvz/IWlcStOk/AABzqhO06T9A83sZ6cl8P/0+F3iLmQNAAAAAAKAxpT6apJW1zTb8PixaWEUa +meU/RYncGx48GUCKwVcv7pExQK46v0cEc4C/sMsasLaz6T8AgDsDuLPpPzl4IAcjzHw/yBsvX4qZA0AAAAAAEDKlPi68k40tOPw+AZzoFnGc5T9n/CDwZj0ZQFpXq5Hu +kTFA8dBe6Y5ygL95JqRM/7LpPwAQ1p8As+k/VSU2yZbQfD+UelEtiJkDQAAAAAAYM6U+V+uPPe06/D6VbWFuHqPlP7dmO5j4PxlAl9xbVu+RMUBRUPX2o3GAv35N3zGQ +sek/AJgzhZGx6T9w54Hofdl8P1jKYMmDmQNAAAAAAEQ1pT6pSYidbED8PvlyR+53sOU/Yyi25htFGUBEUeLf8JExQMmpjzvNb4C/SXkQrbCu6T8AsKkAsq7pP6DuCZNK +63w/VJ2pAHuZA0AAAAAAkDmlPk0GeV1rS/w+idd+LibL5T+aR8J8Yk8ZQEABhfPzkTFAspP6ahxsgL/Ghidn7KjpPwCSSrvtqOk/CspTk90OfT+KZuNraZkDQAAAAAAw +QqU+lX9a3Whh/D79VnGVbwDmPwkvLI3vYxlAyWoiHfqRMUBywbRmrWSAv0JuevBOnek/AByxRVCd6T+lHpcc6lV9PxAw8jRGmQNAAAAAgGpTpT4kch3dY438PjpTlSS1 +auY/fzwAPwmNGUB44sR5BpIxQMEhaPKZVYC/vrTCisCF6T8AoCDiwYXpP6EZxzCc430/T81Rkf+YA0AAAADA3nWlPkNXo9xZ5fw+ywZYiQQ+5z8b+HLkOt8ZQMO55Fgf +kjFAyN5MZZ42gL8XHEh+V1XpP4Bn9NlYVek/t7PKYVv9fj/PbMBxcZgDQAAAAKDEuqU+gCGv20WV/T5zUO/8ft/oP0i5nCSXgxpAMvB4sFGSMUCBR1+7uup/v91vYuJh +7+g/YAerRmPv6D+hNUpT/5SAP+R+ccZRlwNAAAAAgIlEpj5ZgLpVtaH+PnjzRDpzTus/e5kP9E9+G0AdFKODoJIxQAE68378En+/UQUuQ9VG6D/g6pi01kboP/pMg9FM +NII/e2juWI+VA0AAAABgrhanPmgdVU0Qdf8+qfJt4DMs7T/sfnpSqEMcQJ/KWJDhkjFAQnterEpbfr9M0KlWUrfnP2AGa9JTt+c/b0xJQM1ygz/i55aiG5QDQAAAAGAT +vKc+3hONLBd1/z6lxVY4QyztP6bX1ryuQxxARKbgbeKSMUBaQG2BRFt+v0VaHYVNt+c/AADeAE+35z/Cg+R613KDP1wls7AWlANAAAAAAAC7pz7KAP3qJHX/PiblIehh +LO0/H4GPkbtDHECjGSJy4pIxQDNghCs4W36/KGv/4UO35z8AAMBdRbfnP8OYFvDrcoM/orZhmBaUA0AAAAAAALynPqLa3GdAdf8+OxvyR58s7T/vXEBY0UMcQEB5DXni +kjFAPuUveDo8HEBseeJKQFE+vgAArC98t+c/e2eh2hRzgz9WlNdwFpQDQAAAeDN8t+c/A76EBVV1/z73GWJQzSztP5LFKMPeQxxANXfOfeKSMUA6yCfERzwcQGwo3pFO +UT6+AABN39y35z9OEeyKM3ODP8pWrVUWlANAAAAY49y35z9htuSEWnX/PpYJDZfZLO0/GpodV+JDHECDSP5+4pIxQDF33E9LPBxASG2CYFJRPr4AAMKn9rfnPw2xCLo7 +c4M/Dj3lThaUA0AAAICr9rfnPx6npINldf8+l899JPIs7T953gN/6UMcQFHoXYHikjFADm9CZ1I8HEDGUMf9WVE+vgAAsjgquOc/ud9TGExzgz+cGVVBFpQDQAAAkDwq +uOc/l4gkgXt1/z5GxABAIy3tPxQLvM73QxxAhCIdhuKSMUCN+vmVYDwcQJQyOzhpUT6+AACpWpG45z8t2FXVbHODP6XxNCYWlANAAABoXpG45z+KSyR8p3X/Pl9RjHmF +Le0/fvPabRREHEBCgZuP4pIxQF6AF/N8PBxAMmHLrIdRPr4AgP2eX7nnPz42CFGuc4M/YB317xWUA0AAAMiiX7nnP2/RI3L/df8+GgK69kku7T8mANOqTUQcQCzol6Li +kjFATkYMrLU8HEBmaY2UxFE+vgAAOyn8uuc/EKwmTzF0gz+XY3eDFZQDQAAAAi38uuc/Od0iXq92/z6Q+28Z0y/tP8EArB/ARBxApFuPyOKSMUC0s9wYJz0cQGkdmF4+ +Uj6+AKAGRDW+5z+0p0pmN3WDPy+rg6oUlANAAADSRzW+5z/N9CA2D3j/Pv88SADmMu0/G14B9aRFHEDd2HgU45IxQKHVGN4JPhxAQtDH3DFTPr4AEOCSp8TnP6koMABE +d4M/xii7+BKUA0AAgKqWp8TnP/YjHebOev8+Oma5Uw457T/fgjdObkccQB4qNqzjkjFAkUD8Fs8/HEDWRo6BGFU+vgCQZJWM0ec/e5l74l57gz/F6qWVD5QDQABAL5mM +0ec/SIIVRk6A/z4MNhkSaUXtPwlPwbr/ShxAPRVa2+SSMUBCFWBCWEMcQDSzpmzkWD6+AHAJLFjr5z8HJGZhm4ODP1z0atEIlANAAIDUL1jr5z/sPgYGTYv/PqQLnvBG +Xu0/C8LKex1SHEB7eUY455IxQN3LH39lShxAOneAyHZgPr4AQHWS9R7oP8EHFEsvlIM/ZW62UPuTA0AAQEGW9R7oPzS454VKof8+sJi4UqSQ7T/oVsOZRGAcQIHbrOzr +kjFAacWvjGtYHEBtEcCShW8+vgC7WNlIhug/yWXQ4cK1gz/aYm1u4JMDQACwJt1Ihug/w6qqhUXN/z7kry+T5vftP37YuSZBfBxAfmiLP/WSMUDfeZHaJXQcQFQwwlFL +jT6+gAdW+k1V6T/sH3W3mfqDP1mGLCerkwNAALAn/k1V6T/xR5jCnRIAPyYhucaP0O4/jp8BoPKyHEBMOnCMB5MxQI8ZLmVSqhxA8MRnjXbHPr5A0CnRt/TqP21re4QK +i4Q/mCBalEKTA0AAvgLVt/TqPxAtHsKTagA/CwDVi1FV8D+qayLoMBsdQJfPN7oqkzFAX3+gUoURHUA0WuioRTY/vkCjGzIzOO4/DQAcZRfHhT+eFMGOeZIDQABrAjYz +OO4/g1+AA665AD8SK/MpyEHxP2w+tNQNcx1A1zWmAUmTMUBNEd52cGgdQLrDIKSZkz++AEitnOKV8D8X5O43YAKHPzSD3IjMkQNAgIKmnuKV8D++WhxzsbkAPxuSaurS +QfE/5UGohhFzHUDZxhwySZMxQEepSx50aB1AZ0iJkJ2TP74AALQO85XwP3ht441uAoc/2tjtc8uRA0AAALAQ85XwPzRRVFK4uQA/xshua+hB8T+B4IrqGHMdQOA8qzRJ +kzFAFnAhbXtoHUB7glRppZM/vgAAxvITlvA/sQvpOYsChz/ZEVJly5EDQAAAuPQTlvA/ID7EEMa5AD+NEcVtE0LxP8XHnyEtcx1AXHypO0mTMUAWiNSdHDuFv1EKTlsu +lvA/AAA4IS+W8D9lF1ySxAKHP8wUXD3LkQNAAAAAAAC9qD7RL5hf0LkAP/dPl68zQvE/hz5zXkBzHUBiK1FCSZMxQAXidacRO4W/lBjUyiWW8D8AAL6QJpbwP/O/yZTv +Aoc/875UF8uRA0AAAAAAgL2oPgAsSB/TuQA/nqqpSTxC8T/jq7x/RXMdQLN/F0RJkzFADz0Uuw47hb+0zyeCI5bwPwAAEkgklvA/0TjiDPsChz/+kzANy5EDQAAAAAAA +vKg+XiSonti5AD/L4st9TULxP0uBT8JPcx1AjSSkR0mTMUA2Ek7iCDuFvzr+zPAelvA/AAC4th+W8D8N2Q/9EQOHP7RT6PjKkQNAAAAAAAC+qD4bFWid47kAP1FkAeZv +QvE/MAx1R2RzHUAlcb1OSZMxQPR2sDD9OoW/79wJzhWW8D8AAPaTFpbwP2swV90/A4c/lsJX0MqRA0AAAAAAAL6oPpX255r5uQA/d6swtrRC8T9bor9RjXMdQO4V8FxJ +kzFAbiowzeU6hb8moU2IA5bwPwCAOk4ElvA/8zmWnZsDhz8mXjZ/ypEDQAAAAADAvag+iLnnlSW6AD/HRaBVPkPxP0PQUmbfcx1A041VeUmTMUDbOhsFtzqFv/tF/fve +lfA/AMDrwd+V8D9dstUcUwSHP2mM8tzJkQNAAAAAAOC9qD5uP+eLfboAP5SHw5BRRPE/NjJxj4N0HUAENyGySZMxQFEOoHBZOoW/Lwv935WV8D8A4O+llpXwPxkKWhbC +BYc/nsVmmMiRA0AAAAAAUL6oPjtL5nctuwA/PCgZ+HdG8T/sDY7hy3UdQARvuyNKkzFAvORkNp45hb+z0n6aA5XwPwAwemAElfA/T+B29Z8Ihz8sqj4PxpEDQAAAAABw +v6g+1WLkT428AD/JIPiKxErxPwIfSIVceB1AJHb7BkuTMUBoed58JziFv9nOjdnek/A/AGCan9+T8D8LgfVjWw6HP1k4rPzAkQNAAAAAAJjBqD4IkuD/TL8AP8gMP8Fc +U/E/hHy9yn19HUDM5anNTJMxQJeWqvU4NYW/pkXtf5SR8D8AOBxGlZHwP19mqQHRGYc/lkx+1raRA0AAAAAA3sWoPm7w2F/MxAA/KyHCbYlk8T9MyatNwIcdQIVywFtQ +kzFA161xl1cvhb/Qz1Bu/IzwPwCIxDT9jPA/49YCPbcwhz+ccf2FopEDQAAAAAB4zqg+O63JH8vPAD+t1i2104bxP7XIizNFnB1A83/VeleTMUDjSxqigyOFv0mLpNa+ +g/A/AM+hnb+D8D87Hj2cb16HP5qSYNR5kQNAAAAAgKjfqD7VJqufyOUAP55XgnIry/E/0hICf07FHUByZqnEZZMxQLvlNQeXC4W/ehui/Q1x8D+AcrLFDnHwP9F0WEOP +uYc/SSSBLiiRA0AAAAAACwKpPggabp/DEQE/G7qNVONS8j/INwkSXxceQBTNSIeCkzFAmooesqzahL9I3Cfr1krwPwBJXrXXSvA/Ivi8cIRuiD9l/l/Wg5ADQAAAAKDN +Rqk+bgD0nrlpAT/q39GHUl7zP/dHSBJ4ux5AN0/yyryTMUBe8P/9oHSEv5Pn34w79u8/wI/kKT327z821Re1GNOJP8UWBeY2jwNAAAAAgErQqT7ar/lb8e8BP2Ya1eWQ +6/Q/IGuNVse1H0BzVHMyGJQxQJ5eRHNRzoO/19MaRF/y7j9guTruYPLuP4Z4cTLB5Is/KIuRliyNA0AAAABg/qGqPtL7xteeWQI/IXfhvqMa9j80HSv/ZD0gQMp64eRj +lDFAN71HV5RCg7+mF2DIBxjuPwCO0HwJGO4/f0nXU9p4jT/wZq4IfIsDQAAAAGAHR6s+DfdiR6JZAj8HSrN0rRr2P9Rh7zJoPSBAJqDb+WSUMUAWj32sj0KDv5IvhH0A +GO4/AAD0MQIY7j+yYkRG53iNP91s9Nl1iwNAAAAAAABGqz6D7ZomqVkCP2oGUuDAGvY/b+Z3mm49IEDiD9D+ZJQxQB4k5VaGQoO/bwjG5/EX7j8AADic8xfuP4sIGCsB +eY0/ijekvXWLA0AAAAAAAEirPm/aCuW2WQI/ldOpt+ca9j+h0mjyeD0gQFWjTwZllDFA/tmXR6g4IECUxS/C4WpBvgAAuJUrGO4/b2/i9DR5jT8WNsuSdYsDQAAAEJor +GO4/IMzeM8FZAj81hHrZBBv2PyHt/tp+PSBAEA5jC2WUMUAoxD4frjggQEh3IQjoakG+AACmbJUY7j/vWqPMW3mNP8r4yXV1iwNAAAAAcZUY7j9PyI7zw1kCP4rZT54M +G/Y/5XtXboA9IEAyIZsMZZQxQHlFE66vOCBAcAxftOlqQb4AAPilsRjuP2F3aihmeY0/BrDSbnWLA0AAAGCqsRjuP63A7nLJWQI/pToJKBwb9j8WvgaVgz0gQGxECw9l +lDFAXWy6y7I4IEDrN9gM7WpBvgAApBjqGO4/L04M4Hp5jT/eL+RgdYsDQAAAAB3qGO4/arGucdRZAj94Q9Q7Oxv2P2UeWuKJPSBAkoPrE2WUMUC1k/0GuTggQPGVvr3z +akG+AAAI/loZ7j9Jr8VPpHmNP01ZB0V1iwNAAABQAlsZ7j/kki5v6lkCP91vy2R5G/Y/rU7UfJY9IECi5KsdZZQxQJtIV33FOCBAPm5bHwFrQb4AAAzJPBruP88/DzH3 +eY0/O1NODXWLA0AAAGzNPBruP9dVLmoWWgI/tDU+vPUb9j+PbRaxrz0gQNIxLDFllDFA9kpYad44IECBj9XhG2tBvgCA/V8AHO4/7pz9+px6jT9R496ddIsDQAAAVmQA +HO4/vdstYG5aAj9/hjWB7hz2P2mi0RbiPSBAZfgqWGWUMUDNr5A+EDkgQGuSy2NRa0G+AICRkYcf7j/9XUes6HuNP6J0Cr9ziwNAAADrlYcf7j+K5yxMHlsCP6/Da2Pg +HvY/6NUj10Y+IEACNiGmZZQxQKno2t1zOSBAMoe+W7xrQb4A4G8DlibuP5Kvj4SAfo0/p12LAXKLA0AAAMsHlibuPyT/KiR+XAI/jOD6iMUi9j8f0TYrED8gQKlw8EFm +lDFAbY3U7zo6IEC/mL8bkmxBvgAAzCGzNO4/Yyv5C7KDjT+hVzSHbosDQAAAJyazNO4/Vy4n1D1fAj8KAMVYlSr2P5OJEiGiQCBAk88ZeWeUMUC1XlhhyDsgQNTGKdw8 +bkG+AFgwR+5Q7j8LAFx2HI6NP9VdI5VniwNAAOCLS+5Q7j+9jB80vWQCP0ppDwxLOvY/fhR9Q8NDIEDpk5flaZQxQOyFgHrgPiBAKTp6Xo9xQb4AqB4maInuPws3v7oO +o40/H0V5u1mLA0AAEHsqaInuP4pJEPS7bwI/V8BsyQ5a9j8fvwdi+kkgQBg/OrdulDFA67JOhAVFIEBwGfRnKHhBvgA6LsBp+u4/cgCRDGnNjT+f4CAyPosDQABIjMRp ++u4/JMPxc7mFAj/18Xva95r2P+Gvxv07ViBAeOT0PHiUMUD430ruIlEgQBa/JIYqhUG+ACFywaDc7z9F7U8j9SOOP794P8gHiwNAAHDTxaDc7z9XtrRztLECP1wiq+pR +Ivc/hmUldwxuIEBnsw3RipQxQDuspueqaCBANhiGt26eQb4AO89p4NDwP84t5Dht2I4/aSONnp2KA0AACgNs4NDwP72cOnOqCQM/X5HXGi5H+D96iWU14ZogQFa4xBKu +lDFALQxHWe6UIEC7xhfD9c1BvkDPDd3vlvI/lAvlEXQvkD95mQkn1IkDQICNR9/vlvI/ocyctMRYAz/KViGsy2f5P2URHr4BwCBA/JgV2cuUMUDIW84PjLkgQIkFtLVG +9UG+oODYtsAv9D8wj2sd3e+QP6lM8gIqiQNAAIgXucAv9D/cxzgkyFgDP9S6g7rYZ/k/MNkoSgPAIEDelqAEzJQxQHdQKpaNuSBAYSTZWEj1Qb4AACx50i/0PzcnrdHl +75A/LzQhCimJA0AAAGh70i/0P1K+cAPPWAM/PJxf1/Jn+T+SfTtiBsAgQCvUHQfMlDFAuU7fopC5IEDfPyCfS/VBvgAA0v31L/Q/fL0/OvfvkD/j1ef7KIkDQAAAGAD2 +L/Q/PqvgwdxYAz9aaWgRJ2j5P8i6EuEPwCBAiIXBDsyUMUDxbIkGH9eJvxxdGz0QMPQ/AABDHhEw9D/m8JoLGvCQP6tyQNAoiQNAAAAAAIAlrD7vnLQQ51gDP45e/DxO +aPk/+vU9exnAIEDzNXsWzJQxQO+l6ekO14m/o4m+pgMw9D8AAOiHBDD0Pwg/qCg08JA/Cl4bpCiJA0AAAAAAACWsPh6ZZNDpWAM/xnf8rlho+T9C8MAKHMAgQJOcihjM +lDFAE0n+nQrXib8XqW5LADD0PwAAliwBMPQ/g/pSHzvwkD/dpVWYKIkDQAAAAAAAJqw+fJHET+9YAz/uB/mSbWj5P7zhxikhwCBAG2WpHMyUMUABESQGAteJv0ktzJT5 +L/Q/AAD0dfov9D9IBaYMSfCQP49QyoAoiQNAAAAAAAAlrD45goRO+lgDP51a3FqXaPk/LLLSZyvAIEDI+eYkzJQxQLuqWtbw1om/YtV2J+wv9D8AAKEI7S/0P72RPedk +8JA/QZGzUSiJA0AAAAAAgCWsPrNjBEwQWQM/rchL6upo+T/9COrjP8AgQJcxYjXMlDFA8wV0ds7Wib+mpIpM0S/0PwCAtS3SL/Q/yIUynJzwkD8QwIXzJ4kDQAAAAABA +Jaw+piYERzxZAz8+ws0Hkmn5P1uOF9xowCBAD9tYVsyUMUDJXVe1idaJv0VBrJWbL/Q/AADZdpwv9D/T1jMFDPGQPyDTKDcniQNAAAAAAMAlrD6MrAM9lFkDP9wAXj3g +avk/7vdtzLrAIEBhFUeYzJQxQF2l4C0A1om/MYHXIzAv9D8AYAgFMS/0P5IAlNPq8ZA/Bc9pviWJA0AAAAAAECasPlm4AilEWgM/blmuknxt+T8URgitXsEgQKsnJxzN +lDFAoCf+Ce3Uib/1js4vWS70PwAwCBFaLvQ/85DJYajzkD9THdfMIokDQAAAAAA4J6w+888AAaRbAz+64wPmtHL5P/XK8m2mwiBAu8P1I86UMUDglGluxtKJv098Qgar +LPQ/AEiN56ss9D/QlwJEI/eQP0IPX+kciQNAAAAAAFgprD4m//ywY14DPynDLS8kffk/91uf7jXFIEBm4Mwz0JQxQLr8Juh3zom/cXVerU0p9D8AjMuOTin0P3DXcx8Y +/pA/RSIkIRGJA0AAAAAAoi2sPoxd9RDjYwM/52zYSP2R+T/3wVXrVMogQFjhYlTUlDFAt9RjoNXFib8v/k3ljiL0PwC0/8aPIvQ/mUiQMP4LkT/B04GL+YgDQAAAAAA4 +Nqw+WRrm0OFuAz+/NXCEmbv5P2XTMNKS1CBAoq0vmdyUMUDSLCwtfLSJvwSDSgMBFfQ/AHWF5QEV9D/UI6CtuyeRP7DWgUvKiANAAAAAAF5HrD7zk8dQ34QDPzSjbXR5 +Dvo/34ppVQ7pIECg3Fkx7ZQxQJxTqgJ2kYm/UhEVMqT58z+Ad2IVpfnzPyLC86L7XpE/laVHeGuIA0AAAACArGmsPiaHilDasAM/5pm2/tGy+j/0aS4wBBIhQDfIXJwO +lTFADTfQ+h5Kib8Cq/Iz6MHzP4DkZBnpwfM/mGYk/4vMkT8zGoCCrIcDQAAAAEBHrqw+jG0QUNAIBD9Qt/GHvPX7P6ukICnrYyFAhX+LYFKVMUC2IoyHWbaIvx575fF1 +TvM/gAqh23ZO8z+Kz0sF06OSP2xwB0YphgNAAAAAAHI3rT74HBYNCI8EP6SNeOf40v0/9DhnxdfgIUAkux7qvJUxQKTQiUwdyIe/AKvL41aU8j+gzxDUV5TyPxcJ+0T7 +4ZM/VUAHfciDA0AAAACgpAiuPvBo44i1+AQ/QUXj3PY8/z9J3xgNKUMiQBUhhn0VljFANX9KEQICh79hM4KdkfnxP6BX7JKS+fE/1djsPU/TlD+lsEpXzoEDQAAAAJBE +ra4+K2R/+Lj4BD944PdtAj3/P0bsRj8sQyJAYCeH2haWMUDZqot6+wGHv3odvXeM+fE/AAAobY358T+klfrzVtOUP0ax+4zGgQNAAAAAAACurj6hWrfXv/gEPz0vGpAZ +Pf8/0gCjozJDIkBPRlTgFpYxQLItCU3uAYe/sisvLIL58T8AAJghg/nxP9J0EWBm05Q/pUnVa8aBA0AAAAAAAK2uPo1HJ5bN+AQ/qR501Ec9/z/tVW16PEMiQPUIc+gW +ljFAi6vP9Xs9IkBiYHwM0pVDvgAAQWqe+fE/xWlNOIXTlD8/qG49xoEDQAAAuGye+fE/Pjn75Nf4BD/G+QiIaj3/P/vJC6ZBQyJA/Mfz7RaWMUADamQPgT0iQPrBV4bX +lUO+AACZyNb58T+DprBanNOUP9Ct/B3GgQNAAAAIy9b58T9tNauk2vgEP5v7E8lzPf8/0v//BkNDIkAeJDTvFpYxQAk8iWuCPSJAEs4o/NiVQ74AALDQ5fnxP2ZSDYai +05Q/CA3WFsaBA0AAACDT5fnxP8stCyTg+AQ/a6g5S4Y9/z8+cebIRUMiQBfZtPEWljFAsOXQI4U9IkCDxsjn25VDvgAA4OAD+vE/8RrR3K7TlD9S3ogIxoEDQAAAUOMD ++vE/iB7LIuv4BD/p+OJPqz3/P5V2p0xLQyJAjTm29haWMUCpWlSUij0iQAP5+77hlUO+AABEAUD68T+aUJeKx9OUPya37uvFgQNAAADAA0D68T8CAEsgAfkEP211rVr1 +Pf8/NAv6U1ZDIkB81LgAF5YxQEvLK3WVPSJAfmQvbe2VQ74AgBVCuPrxP0dOHuf405Q/x0G7ssWBA0AAAIhEuPrxP/XCShst+QQ/C90hdok+/z8dXOFhbEMiQHVyvRQX +ljFAKMccNqs9IkA0VcrIBJZDvgAA38Oo+/E/W5MWpFvUlD8Wu1dAxYEDQAAAUMao+/E/20hKEYX5BD+qaojEsT//P+ybuHqYQyJAwE7EPBeWMUDSKAe11j0iQCyd0Hwz +lkO+AOAUyIn98T8bR7AtIdWUPwA+nlvEgQNAAACHyon98T+oVEn9NPoEPxqgTL8CQv8/342JoPBDIkBhiMiMF5YxQHWP/aYtPiJAgsIe2JCWQ74AQAjTSwHyP7tqiH+s +1pQ/9IZhksKBA0AAAHvVSwHyP0JsR9WU+wQ/j3OyLKZG/z+GD7W8oEQiQDX9qiwYljFAUMhwW9s+IkCcPsFbS5dDvgCo6/LPCPI/CU3MHcTZlD+QNMEAv4EDQACAXvXP +CPI/dZtDhVT+BD86cfvm8k//P1I2MTcARiJA6tfXaxmWMUAN5G8GNkAiQA3lHZe/mEO+AACuWdgX8j/QoKdE99+UP1p35eC3gQNAAEAhXNgX8j/b+Tvl0wMFP1Dbu9mj +Yv8/kQe0NLxIIkAbqdDnG5YxQEkzyWToQiJAwcst3qSbQ74A7mO76TXyPzSS0jtt7JQ/Q17FrqmBA0AAcNe96TXyP6i2LKXSDgU/CPt1uWOI/z/rj5xRKE4iQKqBOdYg +ljFAwde0QkFIIkAY3nCtYqFDvgBTq5EOcvI/BFL50JcFlT/CiACBjYEDQACAH5QOcvI/QjAOJdAkBT8BHztpW9X/P56PUhHRWCJAFfm+jCqWMUBMEWiCw1IiQGp0aE+r +rEO+AC5Vml7q8j9Vv3yb5ziVP/sCTwBWgQNAAMTKnF7q8j91I9Eky1AFP7SSLj6VOgBAVqRGpGRtIkBW1FtfPZYxQHKmJhIKZyJA/+kWonDCQ75AGoGhCNvzP+8YPqhx +o5U/hflgceqAA0AAaPmjCNvzP9sJVyTBqAU/v7EROiHmAEBGumyKlJMiQM+irZFgljFAQoO7DKCMIkDL9n0nzOpDvsCQTscIvPU//exsTSyIlj/YptZRIYADQADry8kI +vPU/vzm5Zdv3BT+hx28Avo0BQM05j7CMsiJAeHu6on2WMUDgZIoYDqsiQPHmEKd4C0S+gPWXDJtr9z8rCpUAqGeXP3o+jTl7fwNAAGQZD5tr9z/6NFXV3vcFP3JVbI7F +jQFAI30y942yIkAXzDDJfZYxQFJhMFkPqyJAAA9c/3kLRL4AABjErWv3P5ccOxOyZ5c/WJbEXXp/A0AAAJDGrWv3P3ArjbTl9wU/0ppxqtSNAUCH8HWEkLIiQHF9l8t9 +ljFAd0d52hGrIkBWEu+vfAtEvgAAEDPTa/c/F3mXOMZnlz+cDgxQen8DQAAAkDXTa/c/XBj9cvP3BT+3AKXi8o0BQOiYUXWZsiJAzTwB1H2WMUCLmT3Gx/qNv/Uf4BHs +a/c/AAA5De1r9z+dq4aD7meXP7Dt+B96fwNAAAAAAABrrz4NCtHB/fcFP40tz4wJjgFApXi6CqOyIkDY1QXdfZYxQF69e4ix+o2/8Kugstpr9z8AAPqt22v3P2XnvrsM +aJc/7fBw7Hl/A0AAAAAAAGyvPjwGgYEA+AU/0AkKmA+OAUAAjfiYpbIiQKR7bd99ljFAyXt3mqv6jb+1WK0Q1mv3PwAACAzXa/c/FA24yhRolz9U9LLeeX8DQAAAAAAA +aq8+mv7gAAb4BT+nQ32uG44BQBqydLWqsiJASsE85H2WMUBL7mq+n/qNvyuKw8zMa/c/AAAcyM1r9z/dBKfoJGiXPzodN8N5fwNAAAAAAABsrz5X76D/EPgFPzK/VNsz +jgFAruZs7rSyIkAgUdvtfZYxQD+VOQaI+o2/mPzcRLpr9z8AADhAu2v3P+z+cCRFaJc/BVU/jHl/A0AAAAAAAGyvPtHQIP0m+AU/ZNXHNGSOAUBl+VxgybIiQP2CGAF+ +ljFAaOt1lVj6jb/pH8Q0lWv3PwAAITCWa/c/hBy1m4Volz+aXE8eeX8DQAAAAACAa68+xJMg+FL4BT8Ye77mxI4BQPzEO0TysiJAhS+TJ36WMUDxu2qy+fmNv9RiYxNL +a/c/AADBDkxr9z90+f2IBmmXP+rLbUJ4fwNAAAAAAIBrrz6qGSDuqvgFP0iT7UaGjwFAt/TzC0SzIkC5q4l0fpYxQAUHReY7+Y2/fO3ly7Zq9z8AwEfHt2r3P7QZkl4I +apc/wSqkinZ/A0AAAAAAYGyvPnclH9pa+QU/kTNS+AiRAUDStU6b57MiQOUwew5/ljFAZA+9NcD3jb8GtPspjmn3PwCAZiWPafc/a+/C9Qtslz+d6PYac38DQAAAAABg +ba8+ET0dsrr6BT/oGS8fDpQBQG+6rbkutSJAcm9wQoCWMUCqO8FzyPSNv532bpo8Z/c/ANDqlT1n9z80zT7UEnCXP51eNDtsfwNAAAAAAIBvrz5EbBliev0FP660Bn0X +mgFAE6sR9by3IkBsxqOqgpYxQDmgTGzX7o2/Ld2bTJhi9z8A8DlImWL3PzxGXlEfeJc/4f8Oel5/A0AAAAAAxHOvPqrKEcL5AgY/CzundyamAUABGXBm2bwiQHQkLnyH +ljFA7BoFUe/ijb8H/Uv3Sln3PwCALvNLWfc/uE40SjOIlz/ZeEHxQn8DQAAAAABSfK8+d4cCgvgNBj8jT4RcNb4BQF6bfjMSxyJAlubTI5GWMUDSCLL1BsuNv+QW82+d +Rvc/AHhebJ5G9z/YvgUmR6iXPxZIjsULfwNAAAAAAGyNrz4RAeQB9iMGPzVAxYMW7gFAwJuddoPbIkAlxHWFpJYxQN0iNxLWmo2/PRM7Pvcg9z8ANLg7+CD3P0UABwUe +6Jc/4wxfBZ1+A0AAAAAApK+vPkT0pgHxTwY/7sEvR+NMAkCbubqeZAQjQHobppLLljFAqGTU0vY4jb+j7rXUgNT2PwB0VtSB1PY/5lfqXoRmmD9L9ZPevX0DQAAAAIAQ +9K8+qtosAeenBj9oeXz7jgYDQDjx62QhViNA7zVm2RqXMUDHXgXYXG+MvwsyxIgAN/Y/QCKrjAE39j+JTPv5E16ZPx5ek9z4ewNAAAAAEG8+sD4WijK+Hi4HP2vXklVm +FwRAjQa5esvSI0CI+FTHl5cxQBuYquUiLYu/1UZtQ0M79T+ANdlNRDv1P410bsfdyZo/+bys+i55A0AAAADwvqawPg7W/znMlwc/TEfLjfzkBEANV8d15jQkQLugIRoA +mDFAw/syim4jir+w1Pdbrmv0P4AHhWuva/Q/ZbS5Z/vbmz+UaWTY2nYDQAAAADDT+LA+SdGbqc+XBz81+EYaA+UEQAm2KabpNCRAE1vo1QGYMUA7ZLK7ZSOKv05eo3qn +a/Q/AAAwiqhr9D/xSgkjBNybPx4ch/DQdgNAAAAAAAD5sD6/x9OI1pcHP9XAOTMQ5QRAnG3uBvA0JEC8r77cAZgxQDe+qx5UI4q/myz2t5lr9D8AAITHmmv0P3FWopkV +3Js/XDh1ydB2A0AAAAAAAPmwPqu0Q0fklwc/63EmZSrlBED9HvZv+TQkQKibj+UBmDFAE9RxknAuJECEuv0jbKtFvgAAtDq0a/Q/Oe3dhjjcmz+IhhSX0HYDQAAAcD20 +a/Q/XKYXlu6XBz+j6cAKPuUEQHlcU/z9NCRAZq+16wGYMUDQ4vwLdS4kQHQ+AvJwq0W+AACGC+9r9D+ENwG5UtybP5fM8XPQdgNAAABADu9r9D+LosdV8ZcHP7XoBkhD +5QRAR6jPMv80JEBFjwLtAZgxQHhVdD12LiRAAkMAOnKrRb4AAKy6/mv0P5uLXrVZ3Js/vKiDbNB2A0AAAFC9/mv0P+maJ9X2lwc/SxGbwk3lBECpL8afATUkQGlLnO8B +mDFAoCphoHguJEAFFfrJdKtFvgAA+BgebPQ/EBckrmfcmz+idadd0HYDQAAAsBsebPQ/povn0wGYBz8iYfS3YuUEQBndpnkGNSRAsLfP9AGYMUAUdC5mfS4kQH9u4Ol5 +q0W+AACU1Vxs9D+CgfCfg9ybPw5U7z/QdgNAAABI2Fxs9D8gbWfRF5gHP2/7aqOM5QRArLI2LRA1JEA5YDb/AZgxQJSDl/GGLiRAWvd3KYSrRb4AAL9O2mz0P5OkjoS7 +3Js/SSOABNB2A0AAAHRR2mz0PxMwZ8xDmAc/CBpofeDlBECuSJCTIzUkQDTxAhQCmDFA+JSjB5ouJECbYNKnmKtFvgAA/EDVbfQ/tSLgUSvdmz9vC6aNz3YDQAAAskPV +bfQ/+bVmwpuYBz/r+6E9iOYEQN0gK11KNSRAvhKZPQKYMUBMgqMwwC4kQG+SNKHBq0W+AAAaJctv9D+O+tf8Ct6bP54CA6DOdgNAAADQJ8tv9D/GwWWuS5kHPxU4FO/X +5wRAJ4f/45c1JEDUU7mQApgxQJaNQnYMLyRANXquhhOsRb4AgNbrtnP0P3H1GpTK35s/to4Bxcx2A0AAAIzutnP0P2DZY4armgc/oLzxFXjqBECmViPAMjYkQDbLyTYD +mDFARpz9z6QvJEDSk3gct6xFvgDgMHOOe/Q/f/vsx0rjmz+jLREQyXYDQABA5nWOe/Q/kwhgNmudBz9BJYpzu+8EQGhkWLJnNyRAiXgqggSYMUDTT2m91DAkQErFZ3P9 +rUW+AJhqaD2L9D+rMbhET+qbPxQGe6rBdgNAAEAgaz2L9D/5ZliW6qIHP+2J921O+gRAUuyDfs45JEDHG+oVB5gxQPtVJYAxMyRADHXBzoawRb4AwN/kmqr0P5Fin5Jo ++Js/Hhh98LJ2A0AA0JXnmqr0P8YjSVbprQc/oj7XXaUPBUCCxke2jz4kQBoHXTEMmDFAiJ6rpd43JED55+Y7jLVFvgA6RuVT6fQ/Lv4efdwUnD+UIFrBlXYDQADw/OdT +6fQ/YJ0q1ubDBz9Nxd4XFzsFQJ42VKfgRyRAy3jmNxaYMUCg32d1B0EkQC4fxfRhv0W+AOvX/7tm9T8SByl1yU6cP8RNbXdcdgNAANiPArxm9T+TkO3V4e8HPyPZskAJ +lQVAfy2Xt7xZJECXaD+CKZgxQPWk3lSTUiRAsYZkETnSRb6AaPB9VGH2P9l27gC3xpw/wIVMPO51A0AAsKqAVGH2P/l2c9XXRwg/yMwdZCBVBkANhctpX3okQL5fwAJN +mDFA9Lr2FZZyJECznUsemPRFvoD9OPYlVfg/YGbS2tXGnT/l3P1dI3UDQACR9/glVfg/3abVFvKWCD/wzKLOtQ8HQGkaUu84lCRAIuajnGmYMUDXJkp64IskQDjJlvG/ +D0a+wDAXtm0U+j/qu4MTnb+eP9KToO5/dANAACfZuG0U+j8YonGG9ZYIP9UHFzK+DwdAf9Vi/DmUJEB9Ywe/aZgxQOnHJ4HhiyRAJ8XWC8EPRr4AAMgVgRT6P8ZfyUKo +v54/C+weKn90A0AAAIAYgRT6P46YqWX8lgg/rxIM+c4PB0DjHIEWPJQkQGf1W8FpmDFAKtzfjuOLJEAiU1NAww9GvgAAKNWnFPo/Pm5lob6/nj9x880cf3QDQAAA6Nen +FPo/eoUZJAqXCD/sSx6H8A8HQDhLnpBElCRAB9TBymmYMUASF8mhHbGQvww0yky+FPo/AABwYb8U+j/mD9Ne67+eP9kfGud+dANAAAAAAIBKsT4rd+1yFJcIPxi7q7EJ +EAdA6VyhIE6UJEALzVvVaZgxQFsKUAoPsZC/LhAdgKcU+j8AAMKUqBT6P3T55OwMwJ4/dbWFqn50A0AAAAAAAEqxPlpznTIXlwg/MKCqZxAQB0Ak9W6tUJQkQPONL9hp +mDFAx4ksJguxkL9Hl6VroRT6PwAATICiFPo/6iqO3xXAnj9r+V2afnQDQAAAAAAASrE+uGv9sRyXCD+SJ6XTHRAHQFwhCsdVlCRALAjX3WmYMUDISuNdA7GQv9gks0KV +FPo/AABcV5YU+j/CNNzEJ8CeP72sDnp+dANAAAAAAABKsT51XL2wJ5cIP3elhqs4EAdAZGBA+l+UJEBlAibpaZgxQLFZQ83zsJC/JTy58HwU+j8AAGAFfhT6P/MxXo9L +wJ4/UvJvOX50A0AAAAAAAEqxPu89Pa49lwg/V137Wm4QB0DSeKxgdJQkQPkNxP9pmDFAeKvNq9SwkL/rW3FMTBT6PwAAGmFNFPo/yNH5I5PAnj9O+TG4fXQDQAAAAACA +SrE+4gA9qWmXCD8Suqu42RAHQBsTgy2dlCRAqoEALWqYMUDtIAtolrCQv3FjkQLrE/o/AIA7F+wT+j/Coo9LIsGeP4X2s7V8dANAAAAAAKBKsT7IhjyfwZcIP2AMKG+w +EQdATe0px+6UJEAu23qHapgxQOZjKd0ZsJC/F6yQaSgT+j8AAD9+KRP6P9RlNZRAwp4/0q2vsHp0A0AAAAAA4EqxPpWSO4txmAg/aDyOyF0TB0B4N176kZUkQP9WdTxr +mDFAFs7zuSCvkL8C8owioxH6PwAARDekEfo/ilBoC33Enj/bDoamdnQDQAAAAABwS7E+L6o5Y9GZCD9nCgotuBYHQIIdYWDYliRATHOBpmyYMUAJVMQ9Lq2Qv07DgkCY +Dvo/AMBKVZkO+j+IuGKR9cieP7uRrpFudANAAAAAAIRMsT5i2TUTkZwIPw5oibxrHQdABgXQKmWZJEALS/Z6b5gxQNMwdW5IqZC/ShyXLIEI+j8AQIFBggj6PxLgYfvk +0Z4/LFPuZV50A0AAAAAAoE6xPsg3LnMQogg/lfb3880qB0Cb5lC5fp4kQCjbUiV1mDFAt9MedXmhkL/OKgDHTfz5PwCMLtxO/Pk/G55KRb3jnj9hiSYGPnQDQAAAAADm +UrE+lfQeMw+tCD9pkiK3fkUHQGMV1LyxqCRAyp/af4CYMUCs+dsfzpGQvx22xxHS4/k/AJB+J9Pj+T84w9ieUwefP6DcZyX9cwNAAAAAgG1bsT4vbgCzDMMIP/y3nCOR +egdAu9iIXRe9JEBR5j1Ml5gxQD4ZoC1CcpC/cSdKZ4ey+T8A8BF+iLL5P6RKJtoWTp8/nUme3npzA0AAAACAfGyxPmJhw7IH7wg/goeDRHbjB0AeWOwC4eUkQDaNHkPF +mDFABp5eRFcykL/p1tNaqE75P4BkvXOpTvk/q7QEBvPZnz9Ya1E3dHIDQAAAAOCYjrE+yEdJsv1GCT8mIpuhJ7AIQKVVR8dtNyVAwme+ryKZMUBt3QT7jF6Pv/3MGyTe +gfg/QHZIQd+B+D/EFhLBb3WgP5CK5FxecANAAAAAoMrSsT40905vNc0JPwDnYe/72glAH4Cj+suzJUDo371OtpkxQPJJAuGKvo2/xcnJf9w89z9gPHaj3Tz3P1Xv6/Sn +PKE/pElV0BJtA0AAAAAwxzqyPixDHOviNgo/yvbTpGu6CkDslb7VqBUmQB3XdzEymjFAb/vP9OhpjL9vfEL/vTL2P8D1Cyi/MvY/MU+NGJ3RoT/PMlPlTmoDQAAAAJCX +jLI+Zz64WuY2Cj/IYTq8croKQAk9EgSsFSZAsUo4bDSaMUAHnPay3WmMv+Wp0DO1MvY/AACYXLYy9j+FltHSodGhP3nn4idCagNAAAAAAACMsj7dNPA57TYKP3VbAeuA +ugpAp4O5YLIVJkD2b1h0NJoxQMfzPS/HaYy/c2bonKMy9j8AALDFpDL2P/k8Vker0aE/plt0+UFqA0AAAAAAAI2yPskhYPj6Ngo//xWSSJ26CkCRDfl2uxUmQDwI+n00 +mjFA5IWI/aAOJkD9TVKGBa9HvgAAtHy7MvY//2NhML7RoT+hPmvCQWoDQAAAqH+7MvY/ehM0RwU3Cj8pAeeOsroKQAQGVo2/FSZAOnMshTSaMUDG5IwApQ4mQKWbEtUJ +r0e+AACS8fcy9j9xq0RfzNGhP2wkS5lBagNAAACI9Pcy9j+pD+QGCDcKPzn6TTu4ugpAX7JapMAVJkBl3JCGNJoxQP7faBKmDiZA0Xog+wqvR74AALgQCDP2P3tRiSfQ +0aE/ToJWkUFqA0AAAMATCDP2PwcIRIYNNwo/UFAklMO6CkAM7GHSwhUmQLiqWYk0mjFAm7ceNqgOJkBK8jlHDa9HvgAADE8oM/Y/izUYuNfRoT8FVW2BQWoDQAAA8FEo +M/Y/xPgDhRg3Cj87VANG2roKQCqlYy7HFSZAcTjrjjSaMUACrn19rA4mQEQ4X98Rr0e+AACuy2gz9j99jVfZ5tGhP8JPm2FBagNAAACgzmgz9j8+2oOCLjcKP+K6iqoH +uwpAdC405s8VJkAuGA6aNJoxQH+3CAy1DiZAOiBzDxuvR74AAN/E6TP2P5d8XBwF0qE/Ypr4IUFqA0AAANTH6TP2PzGdg31aNwo/ggK/dmK7CkB1nQlV4RUmQNToUrA0 +mjFAYD1TKMYOJkByYMBuLa9HvgCA9rbrNPY/AVd/pEHSoT9lhLiiQGoDQAAA7LnrNPY/FyODc7I3Cj/qc70bGLwKQOfuhS8EFiZAwc7Y3DSaMUC+Frpd6A4mQCek8ClS +r0e+AIANmu829j/x9yi9utKhP7erTaQ/agNAAAAEne829j/kLoJfYjgKPxmmEZiDvQpA22zE10kWJkC4rNU1NZoxQHIOz7ssDyZARkiokpuvR74AINFb9zr2PxHECxCt +06E/n0nNpz1qA0AAAMde9zr2P35GgDfCOQo/R3sVWlvACkAsQFn11BYmQBOuk+c1mjFAkYcWRbUPJkDmgXQtLrBHvgDgis0GQ/Y/L1IOPJLVoT8r1CGwOWoDQAAAgdAG +Q/Y/sXV854E8Cj/AW3wDDsYKQLSn5WTqFyZA/a0gSjeaMUDHWB+MxRAmQPu4hIhSsUe+AHjAaCVT9j+Akv2sXtmhPw2wIMYxagNAAKC2ayVT9j8X1HRHAUIKPwwbUOt/ +0QpAJzGlFRIaJkAM4H0LOpoxQBzVNuziEiZAvtGk1JezR74ALOl1YXP2P11nNfL/4KE/Ltt5ByJqA0AAoN94YXP2P+SQZQcATQo/XrExC5boCkCstaa+VB4mQBoMP38/ +mjFAbfV59RAXJkAbEfPFFLhHvgDI4ajUs/Y/P3Z2B2TwoT8gTbzfAmoDQADI2KvUs/Y/fgpHh/1iCj8skH1qixcLQCfAjDanJiZAFr6tKkqaMUC5tdM0Oh8mQOhU6xXY +wEe+AHtIX6U09z8dYP5Gsg+iP1/mjOfFaQNAAJRAYqU09z+x/QmH+I4KP0P2PnWZeAtAIbd6BoE2JkAtltqPXpoxQIZ3trTBLiZAHGnqvoTRR76AmkyC3zX4P4L5KU5m +UKI/QIFDXFFpA0AAykaF3zX4Pxfkj4bu5go/b3wIvjZHDEB/ScIHC1MmQLmGqomDmjFA5aFUxKdKJkAxU7J5ee9HvsDPrbMyNvo/9FKwfiTaoj/ka+gRfmgDQAC+q7Yy +Nvo/+xPyxwg2Cz9feI70Lw8NQOLiPNEfaSZAjhfmnaCaMUC6lwobKmAmQESljtyRBki+AAwqWtn/+z8/ULRNdV+jP2R5b+fXZwNAANwqXdn/+z82D443DDYLP/C7ju44 +Dw1AUuj4syBpJkD/Noi+oJoxQO0acPcqYCZAhsg0yZIGSL4AAIAo7f/7P0p9tEl7X6M/MqH1LNdnA0AAAIAr7f/7P6wFxhYTNgs/mB6c4koPDUBLsm15ImkmQJRH3sCg +mjFAmOE3sCxgJkD8kX2ilAZIvgAALMUUAPw/uWm9QYdfoz/YHZwf12cDQAAAIMgUAPw/mPI11SA2Cz+biN3Kbg8NQJicu5oqaSZABluXy6CaMUCQZY/DnuuRv7EOkBEo +APw/AADSPikA/D+8Bekxn1+jP+b3VeLWZwNAAAAAAADUsj5J5AkkKzYLP8/nCbmJDw1AxByGJDRpJkBc5yvYoJoxQAySfWSM65G/MzQEXQsA/D8AAEiKDAD8P4qaBiax +X6M/79VymtZnA0AAAAAAgNSyPnjgueMtNgs/kUF255APDUCDBKuvNmkmQIjAhtugmjFA8TxTfofrkb85D2K1AwD8PwAApOIEAPw/tiuk77Vfoz+TIUeH1mcDQAAAAAAA +1bI+1tgZYzM2Cz+X3UpEnw8NQPzO9MU7aSZAEGk84qCaMUAmLfyxfeuRv4oGGmb0//s/AABck/X/+z+6k9yCv1+jP83w72DWZwNAAAAAAADVsj6TydlhPjYLP56I2/27 +Dw1AyUWI8kVpJkCVwafvoJoxQBmsPxlq65G/53xzx9X/+z8AALj01v/7P74FPanSX6M/rGRBFNZnA0AAAAAAANSyPg2rWV9UNgs/JaqacPUPDUDMuq5LWmkmQG6Qfgqh +mjFAeSSN50Lrkb/9iMyJmP/7PwAAE7eZ//s/bXG89fhfoz8RouN61WcDQAAAAABA1LI+AG5ZWoA2Cz9vF5BUaBANQF3C+f2CaSZAZKUsQKGaMUDBAUKD9OqRv74iFw0e +//s/AABfOh//+z/0ZLWNRWCjP3pzJUjUZwNAAAAAAGDUsj7m81hQ2DYLPzd+VxZOEQ1Ah0eIYtRpJkBTrIqroZoxQBeDE7dX6pG/03wODin++z8AgFo7Kv77P3qpj7ne +YKM/dXCe4tFnA0AAAAAAwNSyPrP/VzyINws/b5ZXgRkTDUAUKYcrd2omQIsuToKimjFAW0ZWEB7pkb/uzYb5Pvz7PwCA2yZA/Ps/9A7lABFioz940WUXzWcDQAAAAABA +1bI+TRdWFOg4Cz+qwBX1rxYNQCRCDL28ayZAoAbzL6SaMUAf/F+JquaRv/D5pXZq+Ps/AIALpGv4+z9xgA5OdWSjP0QjSoDDZwNAAAAAAFjWsj6ARlLEpzsLP25/UFPb +HQ1AP5Qz3kduJkDhFrSLp5oxQOCPrZXC4ZG/zjDfCcDw+z8AyGY3wfD7P0mqNeI8aaM/16FoT7BnA0AAAAAAeNiyPuakSiQnQQs/ilr06CssDUDw+PQYXnMmQChEFEWu +mjFAdgl9GO/Xkb/IXkOWZeH7PwD8DsRm4fs/Buei8Mdyoz856PniiWcDQAAAAAC73LI+s2E75CVMCz9M6KRqtEgNQCLBNHCKfSZAAjhRv7uaMUDhLlDROcSRv0BJDVea +wvs/AOxghZvC+z8y8G2czYWjP8t2VN88ZwNAAAAAgDnlsj5N2xxkI2ILP/7swFVigQ1A4bw3peKRJkDD4eDR1poxQAcgNGOWnJG/CnIB+6qE+z8AGWUqrIT7P1Tz1eOW +q6M/QIgfLKJmA0AAAACAOvayPoDO32Mejgs/+fV6RS7xDUDnXr8lkbomQOLidHANmzFAhlakqG5Mkb8xx4DnbAf7P4BZBBluB/s/+6P82B72oz+oOK0PamUDQAAAAAA5 +GLM+5rRlYxTmCz+nJX3/asoOQJLF+mPmCydAEZGJnHybMUD2lpcSsaiQv+DbDK2UB/o/gMXP4pUH+j/Ew6j/8YakPwzDpMruYgNAAAAAsC5csz5SZGsgTGwMP+CDU/GQ +AhBAOR0Mj+yHJ0B8RL3RLJwxQJN4cxbFTI+/MzaK+flz+D8A+sY1+3P4P9SvxEHBWKU/q3jG4/9eA0AAAABAzMOzPkqwOJz51Qw/sEJvMiV3EED5y9AYgeknQF8DsorB +nDFA1AOBH0yojb/+ypx4eyv3P4C/8bl8K/c/6ViUmDH0pT8qyAYMrlsDQAAAAFBPFbQ+havUC/3VDD/0kHfhKHcQQIE/vkSE6SdAKTnMc8ScMUAOvCFDPqiNv+pacqRw +K/c/AADA5XEr9z9FwfSBNvSlPzVwTGqdWwNAAAAAAAAVtD77oQzrA9YMPzqUhD8wdxBAbR2ZnIrpJ0CGo499xJwxQPkJXYoiqI2/y68Y/For9z8AAHA9XCv3P6LFsFRA +9KU/eBCCMp1bA0AAAAAAABW0PueOfKkR1gw/lI2d+z53EEBmcoCAk+knQNwAL4jEnDFAzkVDcSniJ0DO64IFCKVJvgAA+JtvK/c/b2cn+lP0pT9/1s71nFsDQAAAMJ9v +K/c/mIBQ+BvWDD9j58MISncQQD6Wi1KX6SdAGMQgkcScMUBCBp0vLeInQIBTiAoMpUm+AABMJq0r9z/YiVq2YvSlP+F6ssKcWwNAAACAKa0r9z/HfAC4HtYMPyerOvtM +dxBAcD9YV5jpJ0BUP7KSxJwxQCdRKS8u4idAmNTsHA2lSb4AAHSPvSv3P4k5TqRm9KU/+0y8uZxbA0AAALCSvSv3PyV1YDck1gw/vncs4FJ3EEDSaO9gmuknQD8x1ZXE +nDFAOb4/LjDiJ0BMhbNBD6VJvgAAwGHeK/c/UUo7gG70pT8uC9CnnFsDQAAAEGXeK/c/4mUgNi/WDD9PrymqXncQQJnFEHSe6SdAqgIbnMScMUBRpF8sNOInQB/+MosT +pUm+AABSBiAs9z9olDc4fvSlP8vw94OcWwNAAACICSAs9z9cR6AzRdYMP+yXij52dxBAL6cfmqbpJ0DYW6aoxJwxQCugayg84idATU36HRylSb4AAGJPoyz3P5DKuKid +9KU/6GBJPJxbA0AAAJhSoyz3P08KoC5x1gw/bk7maKV3EECbCm7ltuknQJTnu8HEnDFAzVa0H0ziJ0ARYqpCLaVJvgCAHOGpLfc/6L3di9z0pT+31PKsm1sDQAAAUOSp +Lfc/NZCfJMnWDD/ySwXEA3gQQLxUzXjX6SdAe2Ti88ScMUArwggLbOInQMVnkIhPpUm+AIAVA7cv9z+XurFaWvWlPwQLYI6aWwNAAABKBrcv9z8CnJ4QedcMP9dj4ZPA +eBBA9weWkhjqJ0CJ8xxYxZwxQHikvdSr4idAdvhzBpSlSb4AQAJB0TP3P3PagRpW9qU/77SjUZhbA0AAgDdE0TP3P5yznOjY2Aw/Ad0Qmjp6EEBVelCSmuonQAhjSCDG +nDFALTJYNCvjJ0A21ZnKHKZJvgCwrKQFPPc/qybBIk74pT8+E9DZk1sDQACA4acFPPc/z+KYmJjbDD9KkENAMH0QQAMYbsKd6ydAJGp4r8ecMUDAUVUkKeQnQPy3ZXQt +p0m+AKg2Cm5M9z8Na69VQPylP32hvfCKWwNAAMBrDW5M9z81QZH4F+EMPxGYq/MhgxBA9iBx5aDtJ0BmLzzJypwxQLc+l8ch5idAkqsoTkupSb4A3K1FPW33P8DK5EQt +BKY/TTrxOHlbA0AAEONIPW33PwL+gbgW7Aw/bTcP9B6PEECKuMc3mvEnQJtkS+rQnDFAE7iAHAbqJ0BhTrobea1JvgDEqzrVrvc/O59pRSkUpj/5d+MyVlsDQAB44T3V +rvc/nHdjOBQCDT8nTy9Gf6cQQMZW4RdZ+SdAS49Q4tycMUCeJ8EKm/EnQNkjsCqdtUm+AKhcAekx+D/dvumyqTSmP5WoM84RWwNAAFyTBOkx+D/PaiY4Dy4NP5tgVHTY +2RBA3nISIQgIKECo0lCo85wxQOgap1n2/ydAg2C2fwfFSb6AOTosjzf5PyTWxUXLd6Y/IQPpq49aA0AA3HIvjzf5PzVRrDcFhg0/nvJL4OVEEUDvSrvQLiIoQET4qYAc +nTFA0spDZXYZKEBuRCjvaOBJvgBMNNJPQPs/0Zi61YcGpz/BUFlFplkDQABZcNVPQPs/GYEOeR/VDT/MkyFpXawRQEi/x/EONihAJbHhDzydMUCpu2bOwSwoQFt1B5Yg +9Um+gK3siw4R/T8QxSyMfJCnP8ELZO7xWANAAFArjw4R/T9UfKroItUNP5N7Zg1irBFAf0Wxuw82KED/r9oyPJ0xQMpV4ZHCLChAEEvsZyH1Sb4AAIymIhH9P8SkiLyC +kKc/WRKMJvFYA0AAAMCpIhH9P8py4scp1Q0/WdH2VWusEUBYBIFPETYoQEqtXDU8nTFAxT3TGMQsKED2a7ILI/VJvgAAzNtKEf0/IBdJHY+Qpz90jzcY8VgDQAAAEN9K +Ef0/tl9ShjfVDT8Z1innfawRQHYHSDoZNihAv/HyQTydMUDmOdVhd5qSv3cq3YhaEf0/AABQzlsR/T/LcuLep5CnP52aStDwWANAAAAAAIBXtD5nUSbVQdUNP4tbC9SL +rBFA/My/vCI2KEDhZhFRPJ0xQIbOQg1hmpK/sWK4pDcR/T8AACjqOBH9P7gkD3C6kKc/GbTlefBYA0AAAAAAgFe0PpZN1pRE1Q0/BVWqio+sEUDHxfBFJTYoQA2SGVU8 +nTFAX+/TGFuakr8EJstWLhH9PwAAQJwvEf0/sMaNY7+Qpz/YmNti8FgDQAAAAAAAWLQ+9EU2FErVDT8wzeX3lqwRQFKxUlgqNihAgNspXTydMUAct/MvT5qSvxzO7Lob +Ef0/AABgAB0R/T9AvIdKyZCnPwGsxzTwWANAAAAAAABXtD6xNvYSVdUNP7/cTdKlrBFALWQWfTQ2KEAueEptPJ0xQOpqJF43mpK/DucYg/YQ/T8AAJDI9xD9P/7QZxjd +kKc/bZqf2O9YA0AAAAAAgFe0PisYdhBr1Q0/gnjihsOsEUDxOJ3GSDYoQKvYi408nTFARGRKugeakr+pPBQTrBD9PwAAilitEP0/raDYswSRpz+hl04g71gDQAAAAAAA +V7Q+Htt1C5fVDT/AoB3v/qwRQJ6eqFlxNihALzYPzjydMUDxoKhxqJmSv3l7lzEXEP0/AAAOdxgQ/T9V1nzpU5GnP34Tqa/tWANAAAAAAIBXtD4EYXUB79UNP1+l27t1 +rRFAfVq2f8I2KEBxYxhPPZ0xQFJbrtzpmJK/r27QaO0O/T8AgEuu7g79PyiHz0/ykac/5RBQzupYA0AAAAAAsFe0PtFsdO2e1g0/ugh2RmOuEUA7k63LZDcoQDaHNFE+ +nTFAjJzfo2yXkr+bZA3AmQz9PwBAkQWbDP0/92CdCC+Tpz/qH2YL5VgDQAAAAABAWLQ+a4Ryxf7XDT/ThCAgPrARQI7/CmOpOChA8vaTVUCdMUBmld/2cZSSv29ZvRHy +B/0/AABSV/MH/T9tBtYqqJWnP9t8soTZWANAAAAAAFBZtD6es251vtoNPzLALuXysxFAM3qBjzI7KEBukO9eRJ0xQIuJh697jpK/6cZDQqH+/D8AMPqHov78P+2qkzGZ +mqc/IqLLc8JYA0AAAAAAZlu0PgQSZ9U94A0/rw5EtVi7EUDUq1rfREAoQKd1GnRMnTFAYhsJbYuCkr/JOl7a+ev8PwB4WCD76/w/6WgFR3akpz+KFvtDlFgDQAAAAACi +X7Q+0c5XlTzrDT99RPZlFcoRQJSZq1ppSihAWF9FqFydMUAsaWUlnGqSv1V0bvqTxvw/ACjwQJXG/D/8BfOHHLinP3pxKqw3WANAAAAAABtotD5rSDkVOgEOP9NL+c5S +5xFAv7wzv7FeKEA2piI4fZ0xQP6XbvCCOpK/fc2sl2x7/D8AeD3fbXv8P8MP9xMZ36c/6renmn1XA0AAAACACnm0Pp47/BQ1LQ4/1FJr8dsgEkDtODM7QIcoQFwXl/e+ +nTFAgF+OHGnZkb84dZ48tOP7PwDrTIa14/s/GhmP7M8rqD+jw+nmBVYDQAAAAIDnmrQ+BCKCFCuFDj+G9qVnGZASQALK7thT2ChA6t6PAkWeMUBKLfOHsRORv8T2a2TF +rvo/AHBVssau+j9c84ffIcCoP8sqXPEHUwNAAAAAkJfetD5w0YfRYgsPP1x5KyusLxNAicBgLvFTKUB97TQWIJ8xQEKiRBPMuo+/w54Nb+/J+D8AFmrD8Mn4P+BoTKEp +m6o/dNdjEyROA0AAAAB4x0W1PmgdVU0QdQ8//vE624GjE0B6EKANL7UpQOY9LkPTnzFAW12p6mbEjb/vUFRncEH3P0Baw8BxQfc/ULlITbfRsz/iwvc2JEoDQAAAAJDw +lrU+oxjxvBN1Dz8EWq12haMTQNWYsDYytSlA94ciSdOfMUAc98hkVsSNvw4BvX5jQfc/AAAw2GRB9z+wOW8E8dGzP1yJ8RQkSgNAAAAAAACXtT4ZDymcGnUPP6DAjK2M +oxNAZp7RiDi1KUCWIQtV058xQDUrAlk1xI2/wbGJrUlB9z8AAPwGS0H3P3CjZXJk0rM/7Pbk0CNKA0AAAAAAAJa1PgX8mFoodQ8/aypBG5ujE0CC6q1dQbUpQLxU5GDT +nzFA9y/dStCtKUDJE3gilJJLvgAA1shaQfc/IECsTUvTsz/yZDCNI0oDQAAASMxaQfc/tu1sqTJ1Dz/5d5XtpaMTQKAqvyFFtSlAGCHHbNOfMUAtxPn6060pQAGCMxiY +kku+AABsJZlB9z8AGfFy+NOzP8T5REkjSgNAAADoKJlB9z/l6RxpNXUPP5jLW9CooxNAUa3RIka1KUDQeqtu058xQFf3ufbUrSlASzyEJpmSS74AAKjGqUH3P/BSVp8m +1LM/N0J1PiNKA0AAADDKqUH3P0PifOg6dQ8/LA3sla6jE0DegfQkSLUpQAspdHLTnzFAIy047tatKUD9ViNDm5JLvgAAGAnLQfc/MGxa+ILUsz/w8NUoI0oDQAAAkAzL +Qfc/ANM850V1Dz9QLiIhuqMTQPkFLSlMtSlAwG4FetOfMUCVdSfd2q0pQD5xU3yfkku+AADwjQ1C9z9wfryrO9WzP0jQl/0iSgNAAABgkQ1C9z96tLzkW3UPP0ro5DfR +oxNALXppMVS1KUA1nyeJ058xQN950brirSlAIDl77qeSS74AAI6XkkL3PxAe6Bet1rM/0pYdpyJKA0AAAASbkkL3P213vN+HdQ8/yDjEZv+jE0DHEhBBZLUpQD6UaqfT +nzFASlBTdfKtKUCoFunRuJJLvgAAbaqcQ/c/8CXdBZDZsz8tQzH6IUoDQAAA3q2cQ/c/U/271d91Dz8FOurJW6QTQPcGFF2EtSlAvc7q49OfMUDUNg7nEa4pQGELPpXa +kku+AAC4zrBF9z/AOT04Vt+zP3cZeaAgSgNAAAAr0rBF9z8gCbvBj3YPP8Yt06UUpRNAMQ33h8S1KUDJhNRc1J8xQNz9YL1QrilA6u/MDR6TS74AgH0R2Un3P9B1zPbj +6rM/GMCK7R1KA0AAAPAU2Un3P7oguZnvdw8/IlsUtIamE0DFICqpRLYpQPvvTE7VnzFAkA17Nc6uKUCWSn/GpJNLvgCgqX8pUvc/kEvf2gQCtD9rEraJGEoDQABAHIMp +Uvc/7U+1Sa96Dz8TxC8qbKkTQFvrSBlEtylAQprRL9efMUC5CoZTyK8pQOV4O1axlEu+AGCL/cli9z+g2pU8XDC0PxCzLcoNSgNAAOD9AMpi9z9Trq2pLoAPP+eHqXs8 +rxNAotqNsD+5KUAI/Cjt2p8xQL3KHke5sSlAC+4778aWS74A2J53CYT3P+AXMlRhjbQ/shaoa/hJA0AAsBF7CYT3PyBrnmktiw8/rdKOqvK6E0C60mS8Kb0pQFwBBlHi +nzFARCCfDY61KUDl2LgI5JpLvgBUWiaCxvc/QMSGQsRItT9mQQIxzkkDQAC4zSmCxvc/uuR/6SqhDz8ziFTutNITQKdXWVPJxClAPnsrvfCfMUDLdY0iA70pQCjzHuXl +oku+AHCteVhL+D+gHOJ+6MS2P+aIB8d7SQNAANAhfVhL+D/t10LpJc0PP4420q+OAxRAtZIv2DbTKUBRq9ckDKAxQJ0r8MobyylApmtpqQiyS74A7atiiVT5P1ACvZaE +0rk/Ub94Ld9IA0AALiJmiVT5PypfZPSNEhA/zyNqNYNqFEDKgAyfzuwpQKm9WyE9oDFA/c/cngrkKUDdF8QrzsxLvoDqjpGAZPs/MOsdeOYgwD8ge2FBx0cDQACECJWA +ZPs/HHcVFRs6ED/uSEAT0swUQLqGpYMgACpAW6FT8mKgMUBnGUinxfYpQIylXszq4Eu+gId5oPA7/T8wE8Dnkd/DP6rTjynvRgNAAKj1o/A7/T+6dOPMHDoQPxfUO3XW +zBRAXmUYRyEAKkAQ9tDzYqAxQA/PM2TG9ilA0cg4l+vgS74AANgGBTz9P0AQ3M/Z38M/IMsMIe9GA0AAAFAKBTz9P/VvfzwgOhA/mKc2Od/MFEA7yPrNIgAqQDeZy/Zi +oDFAMOEH3sf2KUD0duks7eBLvgAAlNMtPP0/kIh1pGngwz+l3QYQ70YDQAAAENctPP0/a2a3Gyc6ED+vZSzB8MwUQPu77aUqACpAU0IZBmOgMUCpdfWd57WSv9iHz+Y5 +PP0/AABGRDs8/T/gMpeHieHDP+Y7lLjuRgNAAAAAAIDXtT5DXyFDLDoQP81wDuf9zBRA+4KLHzQAKkBd2pUYY6AxQNl1DlrNtZK/I5i23BA8/T8AADA6Ejz9P5AsD5Jh +4sM/EdfwTu5GA0AAAAAAgNe1Pltd+aItOhA/gzaZaAHNFED4NWCmNgAqQODwgx1joDFAYrQAWca1kr/ZGRHrBTz9PwAAgEgHPP0/YMnHRpviwz+36MQy7kYDQAAAAAAA +17U+ilmpYjA6ED/p/6lrCM0UQIyUCbQ7ACpAfAxgJ2OgMUDW2+JWuLWSv353wgfwO/0/AABAZfE7/T8wfsSSDuPDP39vbfrtRgNAAAAAAADYtT7oUQniNToQP9gFr3EW +zRRAYiVcz0UAKkDiUBg7Y6AxQA8pmVKctZK/J1APQcQ7/T8AAISexTv9PzA9mD/148M/zjG+ie1GA0AAAAAAANi1PqVCyeBAOhA/M9dGfTLNFEDZlQAGWgAqQFoOiWJj +oDFAmb3NSWS1kr8/eFGzbDv9PwAAyhBuO/0/YNal7MLlwz9liV6o7EYDQAAAAADA17U+HyRJ3lY6ED9uV62Sas0UQM2xRnOCACpABlxrsWOgMUAE1VY39LSSv9asd5a9 +Ov0/AAD08746/T+wST+UX+nDP2yEmuXqRgNAAAAAAMDXtT4S50jZgjoQP64KVLbazRRAjNXHTdMAKkBfQjNPZKAxQD/t6A4UtJK/svJLV185/T8AAMy0YDn9P2Bsmhie +8MM/UKn/X+dGA0AAAAAAANi1PvhsSM/aOhA/SSb64LrOFEDdyp0CdQEqQKg70IploDFAa0QOsFOykr/nShbDojb9PwDAniCkNv0/oNBo7y//wz8gq35U4EYDQAAAAACA +2LU+xXhHu4o7ED82wDjDetAUQI9gmGu4AipASuU+AmigMUCRoWm60q6Sv3MMRUMpMf0/AEDeoCox/T9QaP2gphzEPw50TzzSRgNAAAAAAJjZtT5fkEWT6jwQPw7e/7f4 +0xRAadXHOj8FKkB5Ou/xbKAxQL9fxO/Pp5K/mdWi5jQm/T8AwF1ENib9PxBXrG7eWMQ/JkQ7B7ZGA0AAAAAArtu1PpK/QUOqPxA/jxr4Ru3aFEDbzQzOTAoqQP0ZndR2 +oDFAsqoe4MaZkr+26i++RhD9PwBQLhxIEP0/YNaTaGrWxD9lIjWKfUYDQAAAAADn37U++B06oylFED+LA4F9t+gUQDMMBMhnFCpAB+dTs4qgMUDttx7xpn2Sv2L/v9hU +5Pw/AEhFN1bk/D9w2eLt+vjFP/4gRf8LRgNAAAAAgFTotT7F2ipjKFAQP7/aOLvIAxVAhZ6WCJ0oKkAEzpCysqAxQKCMNa4wRZK/uqszEByM/D8AtMZvHYz8P6BZEUzO +hsg/etRWcSdFA0AAAACAMPm1Pl9UDOMlZhA/JnwmdNU3FUAxOZa4BFEqQFRywg0DoTFAIQF4kHHTkb/EgbtxYdr7PwDeadNi2vs/YPx8aaORzT9k4KhDXEMDQAAAAMDl +GrY+kkfP4iCSED/A5WqUxJcVQEc5wqHIoSpAta6jmKehMUAsUScS4OyQv9RuXRwecvo/gMJBgh9y+j9ANXXeZm7TP0A+fQWwPwNAAAAAQEVetj5IH1LBPNUQPyJo44cH +FhZAprebd+YcK0BaFUZ2tqIxQMRPwuYJDI+/Uc5HvGdB+D9AK5coaUH4PwCGS3YLjNk/UBiUN6Q5A0AAAADQ9cS2PkPFOH8TChE/u0WeFeNoFkCcjt2aun0rQMCbM+2U +ozFAiPd41YfMjL9igcYeyn/2P4DvIZDLf/Y/wOYY2ajt3T8ChrT9rDQDQAAAAPC2Fbc+4MIGNxUKET9uDWuL5WgWQEG9acC9fStAYMmc9JSjMUATWe/8dMyMv5f9mmW7 +f/Y/AAD41rx/9j9gJl3Y+e7dP0yBW9OsNANAAAAAAAAWtz4bvqKmGAoRP6ad+3bqaBZAqQyCC8R9K0Cj+24DlaMxQGIL2EtPzIy/5chA851/9j8AAKBkn3/2PwCgG7Vf +790/CmKqfqw0A0AAAAAAABa3PpG02oUfChE/hV3+TfRoFkAadQjyzH0rQGnOvhCVozFAsPSG2Zl2K0BY7nThDH1NvgAABJGsf/Y/MPBPkSvw3T9mG5kyrDQDQAAAuJSs +f/Y/aq1ErSQKET+AdD2v+2gWQLq8JdvQfStAAeGaIZWjMUBMEi+unXYrQOvKbf4QfU2+AAAof+x/9j+AcBCAxPDdP7TVQdKrNANAAADQgux/9j+CqxwNJgoRP7iXDKf9 +aBZABzwZ5tF9K0AGlg8klaMxQNP9rbOeditAqjQ1FxJ9Tb4AAHCL/X/2P+CMj1ft8N0/BTk5xKs0A0AAADCP/X/2P7GnzMwoChE/iqmslgFpFkDs+v37030rQEL6+CiV +ozFAJ5WpvqB2K0D4ncFIFH1NvgAACKQfgPY/ANmE9j7x3T/PICioqzQDQAAAwKcfgPY/D6AsTC4KET+kkPd1CWkWQG36uSfYfStAAabLMpWjMUBaRZPUpHYrQGDzy6sY +fU2+AABE1WOA9j8wE+dB4vHdP4iUBnCrNANAAAAA2WOA9j/MkOxKOQoRP9xjuDQZaRZANgD8fuB9K0CXinBGlaMxQPSrMACtditAc6mmcSF9Tb4AALg37ID2PzBSig4p +890/rgzG/6o0A0AAAGg77ID2P0ZybEhPChE/y9flsjhpFkAKJ6gs8X0rQBOIuG2VozFAApKTVr12K0CnQnT8Mn1NvgAAovz8gfY/EJtOf7f13T+TP08fqjQDQAAAUgD9 +gfY/OTVsQ3sKET/ywO2xd2kWQO/hoIQSfitAOlRBvJWjMUDzwfn/3XYrQMApcA5WfU2+AICUhh6E9j+AGeO+1/rdP/uwil6oNANAAABEih6E9j8fu2s50woRP3Pyn7r1 +aRZA2w4UJ1V+K0AbMDZZlqMxQEW0R0UfdytAAM7qI5x9Tb4AAOuaYYj2P8Dd37YlBd4/gsil3aQ0A0AAgJqeYYj2P+zGaiWDCxE/XZYA9vFqFkAaVwE22n4rQEjtrJKX +ozFAaPzpmaF3K0BriusUKH5NvgCgS8XnkPY/oIMSj/cZ3j9A/WzenTQDQADA+8jnkPY/ht5o/eIMET+mSEgQ62wWQOg3+HvjfytAKDbOA5qjMUDh70hrpXgrQN23Gw8/ +f02+ADARIPSh9j8AhGEEc0TeP6sTQeqPNANAACDBI/Sh9j+5DWWtog8RP1XEkq/fcBZA6GNcqPKBK0B+y93enqMxQDh6d66peitAiYE+ZGmBTb4AGKrnDMT2P/AkAe7J +nN4/wJkMK3Q0A0AAMFrrDMT2Px9sXQ0iFRE/X0a5v9B4FkAewSqDA4YrQLbAtXqoozFAzDjStqR+K0BNSM2Rr4VNvgBI+ZA+CPc/4H/3RE9m3z9W18xCPTQDQAAIqpQ+ +CPc/7ChOzSAgET/lChTcyogWQLn3vELvjStAHJR9QLujMUAPpcvRZIYrQE1fiPwBjk2+AJhw7qCQ9z9QQliSDozgP39oMv3RMwNAAFgi8qCQ9z+Goi9NHjYRP8VEsh4U +qRZAIS7+/+6cK0BGWmvf3qMxQGBee0oNlStAy44GLL+dTb4AhxU1V6H4P8C7WRwmQ+I/SkUIcQYzA0AAOsk4V6H4P7mV8kwZYhE/m8k+YuLqFkCm2n6AkLcrQLMeujIf +pDFA0EQmbwCvK0DAPFUxnLlNvoAFHTE2wvo/MJedTBvC5T+5mSHeljEDQAA71DQ2wvo/q62jbaaJET/MlcRvWicXQDT/38mvyytA5Aw6CVCkMUBxETlBg8IrQOc0KleP +zk2+gCztBSur/D+wCYYEfPjoP8GRRst/MANAAAGnCSur/D9Iq3ElqIkRPyxchBZdJxdAEqaBlbDLK0C4EY9NUKQxQOcWEQaEwitAQTqGKpDOTb4AAAA8QKv8P9C6ZXf9 ++Og/LnbORH4wA0AAAMA/QKv8P4OmDZWriRE/d+oEZGInF0B8dsEssssrQJgAdlFQpDFA/KS9j4XCK0BFhjrRkc5NvgAAOKhqq/w/wGwMCEb56D+9RYIufjADQAAA4Ktq +q/w/+ZxFdLKJET/xL/T+bCcXQOIttw26yytAb3rJZFCkMUBQiQTBQFmSv40Wly11q/w/AAAko3ar/D/QciYp1/noPz37EsB9MANAAAAAAIBYtz7Sla+bt4kRP5gnAPN0 +JxdA1iNNfMPLK0ATWux7UKQxQLlKe4cjWZK/waSwg0er/D8AADz5SKv8P8An5gBE+ug/R/3dO30wA0AAAAAAAFm3PuqTh/u4iRE/0jjoEXcnF0CYzzAAxssrQGTfF4JQ +pDFAVL5lvBtZkr9j+V5WO6v8PwAA8Ms8q/w/gL8OB2H66D8XKJwYfTADQAAAAAAAWrc+GZA3u7uJET9CXLFPeycXQN8d+AfLyytAr9FujlCkMUBwPjkmDFmSv49xufsi +q/w/AABIcSSr/D/wKH4Sm/roP6kIGdJ8MANAAAAAAABatz53iJc6wYkRP0OpGcuDJxdA/YKGF9XLK0CdyBynUKQxQCrU1/nsWJK/gjthRvKq/D8AAPS786r8P5C0gycP +++g/FWESRXwwA0AAAAAAgFi3PjR5VznMiRE/GF5CwZQnF0Bsb6I26csrQNL/eNhQpDFAzFbzoK5Ykr+eN3zbkKr8PwAADFGSqvw/8K8pSvf76D+2bgMrezADQAAAAAAA +Wbc+rlrXNuKJET9iRfSqticXQPLQ1nQRzCtAqZMyO1GkMUB6waPuMViSv0/e3wTOqfw/AABxes+p/D9QPuFxx/3oP1z93vZ4MANAAAAAAEBZtz6hHdcxDooRPwCd2nP6 +JxdAe7Yx8WHMK0AgUaoAUqQxQB1z6oc4V5K/3FNeVEio/D8AgPPJSaj8P8D1/kpnAek/Tud7jnQwA0AAAAAAUFm3Poej1idmihE/RgS224EoF0BYCbDpAs0rQBokrItT +pDFA23oRskVVkr/2TzvmPKX8PwBA2Vs+pfw/QLX2I6UI6T+N6Ey9azADQAAAAADYWbc+VK/VExaLET8YUswDkCkXQAS9ztlEzitApjH5oVakMUAvtNfkX1GSv4kJkdUl +n/w/AMA/Syef/D8AmOdwGRfpP5J2SxlaMANAAAAAAPBatz7uxtPrdYwRP4bvm7apKxdAq9KTtsjQK0DpJbnPXKQxQLFW0cSTSZK/dReH4/aS/D8AUFdZ+JL8PzAgX3fk +M+k/f3C5yjYwA0AAAAAABF23PiH2z5s1jxE/evTvr9IvF0BkaThi0NUrQG5K0i9ppDFAWyjacvk5kr8N33TDlXr8PwBAiDmXevw/kPsXPARt6T+rVk4T8C8DQAAAAAA2 +Ybc+h1TI+7SUET8b+5wz+zcXQP1er4Hf3ytAVnlnE4KkMUC2uxWqvBqSv0z1wcnGSfw/AIRbQMhJ/D+w8Tocod3pP3gBQ9phLwNAAAAAgJhptz5UEbm7s58RP4cAbeao +RxdAXlek4PzzK0ADhvTxs6QxQFEiPpgj3JG/nxXhnffn+z8A/IYV+ef7PyDx4CHWtuo/CLmK4kQuA0AAAACAXnq3Pu6KmjuxtRE/PS1bZolkF0A4LkcWNBwsQI/SCv4Y +pTFAQ/+d03tekb/Y3qZ6oSP7PwA+ZfSiI/s/sM33705M7D9+uuZ4AywDQAAAAADmm7c+IX5dO6zhET+k6e5AAZUXQNhg+haUbCxAWm+I6OelMUA4aGT8lGGQv9jiXMp4 +mPk/AGdLSHqY+T/Qk91Z3vLuP/oVYhhlJwNAAAAAUOjetz7XVeAZyCQSP8Wwa/SUyRdAk8qVDhLnLECGR5JJNKcxQKkUNRAQuY2/I3ipjJQ49z+A2PkQljj3P9A7WBV5 +6fA/RmdOyfkfA0AAAAAQBkW4PtL7xteeWRI/DxjF7ePiF0BPx/EyYUctQAmhg99TqDFAiG4qJ6FQi79aJpnm/Vb1P4AW7m//VvU/2A7K5qGa8T9kjH1wjhkDQAAAAPBO +lbg+cPmUj6BZEj9VsXKK5OIXQCJ8BVRkRy1A7IAhYVuoMUBHHioSjVCLv6fnMDbuVvU/AACIv+9W9T/AP4kvpprxPxrW0otjGQNAAAAAAACVuD6r9DD/o1kSP21Yx8Pl +4hdAC9QslmpHLUDCXRV0W6gxQMiHKOhkUIu/FKpf1c5W9T8AALhe0Fb1P2jR2cCumvE/POiFH2MZA0AAAAAAAJa4PiHraN6qWRI/k4hiNujiF0B+M3Kbc0ctQKEcxYJb +qDFA92c+fZ9ALUBgEngE2WhPvgAA8F3eVvU/cCIY47+a8T+IpZnLYhkDQAAA2GHeVvU/+ePSBbBZEj/suGMM6uIXQPbYFsB3Ry1AmgL3m1uoMUDcVxuMo0AtQI2R8F/d +aE++AAAIbiJX9T/gdCC9zJrxP68VoTtiGQNAAAAAciJX9T8R4qplsVkSP7Trvonq4hdAFfTp2nhHLUBl4E+fW6gxQBiXH6GkQC1AGk9iid5oT74AAHCUNFf1P1jYnirQ +mvE/oLSAKGIZA0AAAGCYNFf1P0DeWiW0WRI/Qy15hOviF0BMxI0Qe0ctQPyWAaZbqDFA964ly6ZALUBFNkPc4GhPvgAAUOFYV/U/QKO2Bdea8T/iDkACYhkDQAAAQOVY +V/U/nta6pLlZEj8u2AR67eIXQIcAx3t/Ry1AlN1ks1uoMUAfdyMfq0AtQBuN9YHlaE++AAAge6FX9T+wT4i85JrxPxegv7VhGQNAAAAYf6FX9T9bx3qjxFkSP6nLeGXx +4hdAKuj/UYhHLUBX0CrOW6gxQCRp5cazQC1Aw1wcze5oT74AAOCuMlj1Pwj4sywAm/E/5zTCHGEZA0AAANCyMlj1P9Wo+qDaWRI/yhzTPfniF0DPc4v9mUctQCFMtANc +qDFApNOCFcVALUCmg3JiAWlPvgAACBdVWfU/8C8sFzeb8T9hKNXqXxkDQAAA9BpVWfU/yGv6mwZaEj9eBFH0COMXQJR5CVG9Ry1Ah5y9blyoMUC0vyOv50AtQMXsQIkm +aU++AID36Zlb9T8AhZ0UpZvxP2o4ModdGQNAAADk7Zlb9T+u8fmRXloSP7zObngo4xdABSih6QNILUB4nqlEXagxQFfe/dMsQS1A/xRmx3BpT74AwFiaI2D1P5ANbrGB +nPE/tAjJwFgZA0AAAEaeI2D1P3v9+H0OWxI/woUZ3WfjF0APWT7hkEgtQAgW5+9eqDFAHokS5LZBLUAjBNEFBWpPvgCA/CQ3afU/uA4Zcj2e8T9Iy2k3TxkDQADA6Sg3 +afU/FRX3VW5cEj9YeWUX6OMXQMhZKuqpSS1Aa0z3Q2KoMUDCObgdykItQC+dI4ssa0++ALC24F579T/QtywKv6HxP5/dejI8GQNAACCk5F579T9IRPMFLl8SPy14rEnu +5BdAlembYthLLUDTnmjiaKgxQHfSyvbsRC1AnmiOt3dtT74AkHrpsJ/1P6ivHWrqqPE/0k/zXxYZA0AAMGjtsJ/1P66i62WtZBI/RDHwcxHnF0BpFYjsJlAtQFlVbfh1 +qDFA1VzFPiRJLUA7uRqW/nFPvgCMkvxe6PU/SL/3keC38T/G8/yYyxgDQADQgABf6PU/e1/cJaxvEj9x0BxcsesXQM58PVqKWC1A+ln2h4+oMUAH43QcWVEtQFb7vV/O +ek++ADTxDuF59j+AGTDrP9jxP6e0W4k5GANAAJDgEuF59j8V2b2lqYUSP1qDEp9L9hdAjsjoVGpoLUDefPkswKgxQL9C2svbYC1Ap9lc3XWLT74As3BJbJ33PxjSmOmH +IvI/vMhJkSMXA0AAIGJNbJ33P0jMgKWksRI/+vmbdmsQGEBEUTgYjYQtQBA5NQwYqTFAJwrOdEN8LUAigErf4qhPvoAcKage5vk/SOhWEwDs8j8OAxlxLRUDQAA8Hqwe +5vk/OuQxxjHZEj+VHavG2iwYQMQlWKa7mS1Aci+QlVqpMUCeuKBcyZAtQAmu2jXsvk++ADc9WSb1+z/ICPmjg9vzPzKDozuxEwNAABU1XSb1+z/Y4f99M9kSP0/u0Rnc +LBhAlnQqfLyZLUBqQqMEW6kxQLVYHivKkC1A+WqSE+2+T74AAOBBPfX7P2Br49g43/M/51/twK4TA0AAAMBFPfX7PxPdm+022RI/82sjwN4sGEBhTMsnvpktQDin8wlb +qTFA7NIVyMuQLUCl1/3O7r5PvgAAKBNr9fs/WCTDGk/f8z8yso+irhMDQAAAEBdr9fs/idPTzD3ZEj8eI8QM5CwYQPPhsBPGmS1AJiQnI1upMUD05vFlx+SRv934SY93 +9fs/AAAMHXn1+z9QjW+ee9/zP9sMjhKuEwNAAAAAAADcuD5hzD30QtkSP+JDIQboLBhAfH0ddM+ZLUAl2PtAW6kxQG/v/eOo5JG/HcY85Ef1+z8AAABySfX7P5igSgCd +3/M/Kr8XaK0TA0AAAAAAgNy4PnnKFVRE2RI/oSdlFeksGECgYjr00ZktQDJt8EhbqTFAXXxVwaDkkb9RkhUuO/X7PwAA4Ls89fs/2Ezr5qXf8z9cIqI6rRMDQAAAAAAA +3bg+qMbFE0fZEj/CROcz6ywYQP8gdPTWmS1AwHPZWFupMUCn5QN8kOSRv9UWxsEh9fs/AACQTyP1+z9QDv2zt9/zP7azt9+sEwNAAAAAAADduD4GvyWTTNkSPyGByXDv +LBhAQFbn9OCZLUCGm6t4W6kxQN2UXPFv5JG/magg6e70+z8AAOR28PT7P3gJA03b3/M/ID7iKawTA0AAAAAAANy4PsOv5ZFX2RI/NQUG6vcsGEDCosz19JktQLNVULhb +qTFAtmb92y7kkb988Ls3ifT7PwAAgMWK9Ps/ePiYeiLg8z+68TS+qhMDQAAAAABA3Lg+PZFlj23ZEj+HUV/aCC0YQLHDkvccmi1AkXSbN1ypMUA+3/ywrOORv9Eci9S9 +8/s/AABTYr/z+z+Qee3DsODzP57T0OanEwNAAAAAAKDcuD4wVGWKmdkSP6exk7IqLRhA3SQN+2yaLUCUXDg2XakxQKBc81mo4pG/ukCMDCfy+z8AAFiaKPL7P2gHPw/N +4fM/RIHiN6ITA0AAAAAA0Ny4PhbaZIDx2RI/YkUJQW4tGEBWYboBDZstQDvXjDNfqTFArlDAp5/gkb8Qfhx2+e77PwAA8QP77vs/yEa0iATk8z85e23ZlhMDQAAAAAA4 +3bg+4+VjbKHaEj/YWVXW9C0YQNqp9g1NnC1ASoOgLmOpMUAsWegyjtyRv1ULiy+e6Ps/AABwvZ/o+z9AjGYIb+jzPxakIRqAEwNAAAAAAEzeuD59/WFEAdwSPxVb3eP/ +LhhAJrH1Ic2eLUA2GHMma6kxQN2A4gdr1JG/WelRPOfb+z8AMFjK6Nv7PxD93EYy8fM/OpoAklITA0AAAAAAZOC4PrAsXvTA3hI/rqgAlg0xGECJVgc4zaMtQJ5FyBx7 +qTFARIsHsCPEkb+ayQvDd8L7PwDIVFF5wvs/GLw4H3IC9D/Blodb9xIDQAAAAACP5Lg+FotWVEDkEj8S+GGwBzUYQPvARhzNrS1AtUpLJJupMUCPmhMVkaORv3+h7rCS +j/s/APi8P5SP+z9YvQMw2iP0P4cwLVVAEgNAAAAAAOXsuD7jR0cUP+8SP5P1F395PBhAw5uhw8vBLUCneHqf26kxQJJO/w1dYpG/xOreZbEp+z8A6rf1sin7P5jbYvhi +YvQ/RLxo3s8QA0AAAADAj/24Pn3BKJQ8BRM/0dM3yWhJGECzNvmAxOktQDxgy0xeqjFAVmbwWMDfkL/mn/eKnF36PwCv5RyeXfo/2IxuzQnP9D9ebJok5Q0DQAAAAADh +Hrk+sLTrkzcxEz9/uXaPFFwYQFMOq/W2OS5A/NAiwsapMUAONJf2yrOPv6ogppB2xPg/gFq+JnjE+D/Ar0vo32v1P/meXRhHEQNAAAAAkINhuT5mjG5yU3QTPzkkm8Nh +aBhAU1HgN62zLkB5KlRXwaoxQHHNzLjbkoy/gABgqLtS9j+ArNJEvVL2PwD94zc10/U/IMSMMa8LA0AAAADQKse5PmEyVTAqqRM/3Z53IThmGEAZ6qL+kxMvQFM5iIUG +rDFAOl88T90bir9lKuflxGX0PwC8WIfGZfQ/0Jy5sgrB9T/kk/UEbQQDQAAAABAZF7o+/i8j6CupEz+65Y/oN2YYQHaZKByXEy9AZDL7YCesMUCSmJPMyBuKvzJP09+0 +ZfQ/AABAgbZl9D/gvLjUCMH1Py4piUOxAwNAAAAAAAAWuj45K79XL6kTP/LPu3Y3ZhhAKOMzV50TL0BJsnJ3J6wxQPN7QsefG4q/1vCr05Rl9D8AABh1lmX0P+gFkBgF +wfU/8nInw7ADA0AAAAAAABe6Pq8h9zY2qRM/MYESkzZmGECIs8Z1phMvQE2vsVUnrDFAQvG+hx8NL0C1PTgrp6tQvgAAFNSnZfQ/+Ak1oP3A9T+QqAiEsQMDQAAAQNin +ZfQ/iBphXjupEz/9OG3oNWYYQImNCMuqEy9AF04UqCesMUChP0jFIw0vQKM4A3Kpq1C+AADI9PFl9D94q8gG+MD1Pw3UQq2vAwNAAAD4+PFl9D+gGDm+PKkTP1nT87o1 +ZhhAR/3R8qsTL0DIjkGsJ6wxQMNVvuYkDS9A2XlqDaqrUL4AAEC5BWb0P0jvzIj2wPU/FtBkla8DA0AAAHC9BWb0P88U6X0/qRM/wpoGYDVmGEA7P2JCrhMvQFs0nLQn +rDFAreOnKScNL0BilDdEq6tQvgAAOEItZvQ/IEcEjfPA9T9k+adlrwMDQAAAYEYtZvQ/LQ1J/USpEz9rmU2qNGYYQN4Rc+GyEy9Ag2BRxSesMUBSSWuvKw0vQA5aybGt +q1C+AAAoVHxm9D9w1YuW7cD1PyT9LgavAwNAAABQWHxm9D/q/Qj8T6kTP1RTYT8zZhhA/PFVH7wTL0DKPLvmJ6wxQNE7s7o0DS9AzCfLjLKrUL4AAEx4Gmf0P4BV/q3h +wPU/Ock/R64DA0AAAHx8Gmf0P2TfiPllqRM/xqOfazBmGEAUnSCazhMvQB8FjSkorDFAJb1H0EYNL0CXzEdCvKtQvgAAkcFWaPQ/cCxw7snA9T//dGzJrAMDQAAAvMVW +aPQ/V6KI9JGpEz9PCXfMKmYYQBiayYvzEy9ApdMoryisMUDILIP3ag0vQBs5JavPq1C+AIDqV89q9D9ggYG1msD1Pwgi8s2pAwNAAAAVXM9q9D89KIjq6akTP0F4i68f +ZhhA/wpqXz0UL0AiXkG6KawxQCidQzazDS9AIItwdParUL4AgOyTwG/0P1AlLVw9wPU/owqv16MDA0AAgBeYwG/0Pwo0h9aZqhM/nXsf+wlmGEAfpePH0BQvQEzZ9c8r +rDFAxazpdEMOL0AhfkjlQ6xQvgAA/UijefQ/6Kc7Coe/9T8q3fDtlwMDQABAKE2jefQ/pEuFrvmrEz+2hZmm4GUYQFavsJ32FS9A3etp+S+sMUCv6MH2Yg8vQDj/+D/e +rFC+AJABpmmN9D8gY9bdK771Py+8oiWAAwNAAOAsqmmN9D/XeoFeua4TP+/hDESWZRhA9phqXD4YL0DypGpEOKwxQFOzXgyeES9Awto32RCuUL4AIAIh+rT0P5g2bAi7 +u/U/s+MwwlADA0AAkC0l+rT0Pz3Zeb44tBM/3M5lQyJlGEBUJS8kvhwvQAnuL7pIrDFA8+41fQQWL0Coig+abbBQvgDUncYpBPU/KGOKnOy39T+qZoCz8gIDQADoycop +BPU/CpZqfje/Ez+5hwqzumQYQHcgXMx+JS9A/ErdH2msMUC9zpFlkh4vQLM0rUwFtVC+ACQSNMGi9T9o2r6shrT1PxZ4D5M5AgNAAGQ/OMGi9T+kD0z+NNUTP8xgaAHZ +ZRhA3850BwQ2L0AuGtqsp6wxQGRyv9+xLi9ABt/UOK29UL4Ak5ESvOD2P6jGbKXrvfU/1kVGJNQAA0AAAMEWvOD2P9cCD/4vARQ/iyjfHDNvGEAt0Qk2G1MvQLuuyp4a +rTFAV44luvxKL0DBDPyy3cxQvoChHSVDX/k/GO64JXoM9j+JGQxQQ/4CQADbUClDX/k/yRrAHr0oFD/ZHTrcAH8YQFgxHPjBaC9AJHW4wnitMUAqZvYK618vQJfwSGwa +2FC+gOvkEaWf+z8YYRttOpH2P4AZK14p/AJAAPIaFqWf+z9mGI7WvigUP53ZULABfxhA9u8S0cJoL0AQHeLoeq0xQOVv59vrXy9AAKZ13BrYUL4AALgjvp/7P/Ajp2JB +kfY/HKNhFh38AkAAAPAnvp/7P6ETKkbCKBQ/V0CEWAN/GEDCSvyCxGgvQFAQTPB6rTFAl2DFfe1fL0Bk2My8G9hQvgAAYEfwn/s/0ILwTU+R9j8LNQTsHPwCQAAAkEvw +n/s/FwpiJckoFD/ZrfOoBn8YQJDQcG3MaC9AHZLtEnutMUAjEoTYFK6Rv1dcTpIAoPs/AABYOAKg+z9AtMska5H2P8gqICYc/AJAAAAAAIBguj7wAsxMzigUPzHRMyUJ +fxhAaotHwtVoL0CuzMA7e60xQBpFfO/1rZG/+SsyRtCf+z8AADzs0Z/7PzDdTAWAkfY/ENzWPBv8AkAAAAAAAGG6PggBpKzPKBQ/zZHXzgl/GECqg00/2GgvQGhtpEZ7 +rTFAt3JXse2tkb89oxhlw5/7PwAAIAvFn/s/4PtFloWR9j/Njp3+GvwCQAAAAAAAYbo+N/1TbNIoFD8tPRoiC38YQNZjWTndaC9AOQBrXHutMUCfYQ013a2Rv4jo5KKp +n/s/AAD4SKuf+z9wmw+4kJH2Px7aLoIa/AJAAAAAAABhuj6V9bPr1ygUPx6RgsgNfxhAWMJwLedoL0Dqq/iHe60xQLK1djy8rZG/5nt5Hnaf+z8AAIjEd5/7P1Apr/qm +kfY/y3JOiRn8AkAAAAAAgGC6PlLmc+riKBQ/OzDfFBN/GEDk950V+2gvQIgbFt97rTFAnjc/S3qtkb/nxpIVD5/7PwAAnLsQn/s/EJUffNOR9j/Zq4GXF/wCQAAAAADA +YLo+zMfz5/goFD/tXsirHX8YQNBE8uUiaS9A6ltZjXytMUB4qKdo9qyRvzz3hQNBnvs/AACTqUKe+z+QUMZvLJL2P+g7uLMT/AJAAAAAAOBguj6/ivPiJCkUP1kbW9Iy +fxhAIWSChnJpL0DwYgHqfa0xQPlu1qLuq5G/ZA1v3qSc+z8AAICEppz7P0B/MBrekvY/rspl6wv8AkAAAAAAEGG6PqUQ89h8KRQ/4feGAl1/GEDmqEDHEWovQNKW16OA +rTFASRStFN+pkb+yb06QbJn7PwAAaDZumfs/+O6ge0CU9j8PWcJX/PsCQAAAAACQYbo+chzyxCwqFD9scB/vsH8YQEjNNEdQay9A2PycGYatMUA55Uruv6WRvykGVeT7 +kvs/AOB+iv2S+z/gSTtyAZf2P3ztfiTd+wJAAAAAAKBiuj4MNPCcjCsUP/QujPpWgBhAqZL3QM1tL0B0+o4Nka0xQLSMqXmBnZG/2esYThqG+z8AAGT0G4b7P1iKmTh0 +nPY/dY3zjZ77AkAAAAAAtGS6Pj9j7ExMLhQ/NAAQ5JuBGECUhMcbx3IvQICSKRenrTFAI6f28wONkb8nZTEtVmz7PwDovtNXbPs/SJu5ex2n9j8IBDegIPsCQAAAAADY +aLo+pcHkrMszFD9bn+VOCYQYQN9Lk226fC9ALhcJstOtMUA1VLOOBmyRv5Mz+D7KOPs/AGAK5ss4+z8g1Ihjgbv2Pz3pgr0h+gJAAAAAACNxuj5yftVsyj4UP4h82uF0 +iBhAkYDWeZ+QL0BJfQMNL64xQIPHOhgDKpG/vdfb1aTR+j8AUvd9ptH6P3B8Xpyi4PY//OqitRf4AkAAAABAt4G6Pgz4tuzHVBQ/stciQqGPGEC6poLzYrgvQGmrrY3u +rjFAhoAsIN+lkL/RiEWiLAP6PwA+c0wuA/o/0BOLK+Qc9z9d47Fo0fMCQAAAAEDboro+P+t57MKAFD/m4YYR15cYQB6VxqPmAzBArlaRfJKwMUAYldbVmTqPv3ukDy/I +Zfg/AE9g3cll+D+wnAZg22H3P8hZeMpx6gJAAAAAoArluj71wvzK3sMUP1d6rDaVlhhASgNNz1JAMEAegN90mLMxQCd1V4HqEoy/hlMMNcfu9T8AXKjpyO71PwBqQstL +V/c/vNoCGyvZAkAAAACQwEm7PvBo44i1+BQ/7vuDeISLGECwQH2wuG8wQHjxKLPXtjFAjsxWf72Xib/Pz3sLjP7zPwDZB8WN/vM/WHchwVj69j9M5cwkncYCQAAAALDA +mLs+jmaxQLf4FD8vOF77g4sYQOidITq6bzBAGpm72ha3MUA08JvdqJeJv6nTIe17/vM/AACopn3+8z9IPuSlVPr2P5Jwq0I0xQJAAAAAAACZuz7JYU2wuvgUPw/BDgGD +ixhA0D1qTb1vMECn82oTF7cxQMsaJ5p/l4m/74xusFv+8z8AAPhpXf7zPwi8SG9M+vY/KWvB/jLFAkAAAAAAAJi7Pj9YhY/B+BQ/3HF0DIGLGED3A67QwW8wQBTE18sW +tzFAL4j63I5sMECCrnUenKJRvgAAYB1z/vM/KIk4Ajz69j9iVsGXNMUCQAAAyCFz/vM/F1Hvtsb4FD88/iCVf4sYQLNjofjDbzBAML3Ejhe3MUD99fv3kGwwQGZoNmGe +olG+AACIBcT+8z/AinuxL/r2P4Hr5D0wxQJAAAAACsT+8z8vT8cWyPgUP2IbFDF/ixhAJwjPi8RvMEAZnGaZF7cxQNXhtYeRbDBAd5SJ+56iUb4AANCY2f7zP2BMD2ks ++vY/ZV8jATDFAkAAACCd2f7zP15Ld9bK+BQ/19kAaX6LGEAd3yiyxW8wQF5Nq64XtzFAH0cop5JsMEDiXi4woKJRvgAAUL8E//M/OIxt2CX69j8i2JqHL8UCQAAAsMME +//M/vEPXVdD4FD99bwHZfIsYQGjh0/7HbzBAxUQ02Re3MUBrYwTmlGwwQJGhbpmiolG+AABwDFv/8z9IdXK4GPr2P+wtjJQuxQJAAADQEFv/8z95NJdU2/gUP376nrl5 +ixhAdTcHmMxvMEDwhkQuGLcxQNvimWOZbDBARN7Ja6eiUb4AAOimBwD0P7DRnX3++fY/mmp4rizFAkAAAFCrBwD0P/MVF1Lx+BQ/wHVLfXOLGEArKePJ1W8wQGpYXtgY +tzFA6fw5XqJsMEDTNOsPsaJRvgAA69xgAfQ/CN15HMr59j9dK3fiKMUCQAAAVOFgAfQ/5tgWTR35FD8XNWkOZ4sYQBEhcCvobzBAFC13LBq3MUDfm05RtGwwQJFU2VXE +olG+AIAXTRME9D+wikCsYfn2P9vZDUshxQJAAACBURME9D/MXhZDdfkUP+91sVdOixhAZlPe5QxwMEC9hj3UHLcxQMZ2yS7YbDBAA09j2OqiUb4AQPo9eAn0P2Cr0hOS ++PY/vGugHhLFAkAAAGNCeAn0P5lqFS8l+hQ/YQRChh2LGEB1Rws4VnAwQO5GHCIitzFAhy0Fxx9tMEBUtC24N6NRvgBAuWFCFPQ/WL5dAfj29j+4al7P88QCQAAAImZC +FPQ/M4ITB4X7FD8RVcxRvooYQGWfo1HocDBAhFgctyy3MUDTDpFsrm0wQGZtmOLQo1G+AKCer9cp9D8gZLRI2PP2PywGXle3xAJAAKAHtNcp9D9msQ+3RP4UPwe425UJ +ihhALyWwWQpyMEDEwPnFQbcxQE6k3ovJbjBAwoyn4gClUb4AQPxYBlX0PzBwAh7q7fY/BtdsAj/EAkAAcGVdBlX0P8wPCBfEAxU/cuNxbcaIGEBaflG8RXQwQMTQwnVr +tzFAQmd5GvdwMEC95MSOV6dRvgCEJoJzq/Q/UENWl0/j9j8GV8vMUMMCQABYkIZzq/Q/mcz41sIOFT+b7W9E1oYYQJUHAMWZeDBA/o9qEr23MUAggHFxL3UwQGd/SpDf +q1G+AJxjNopY9T8Q/3jYB9P2P4BbMXJ+wQJAAJzOOopY9T8zRtpWwCQVP6azMLM2hRhAL8dttraAMEBQ8T/oWLgxQItNiNwUfTBAkeaGC1q0Ub4AK8vVkbP2PwjlZRRl +xfY/wApu9QO+AkAAQjjakbP2P2Y5nVa7UBU/4vlt5UeKGEBxgCQpw44wQE903l5wuTFAikO207GKMEAPz4//98JRvgDii+xVbPk/KGY1h/Xv9j/+i3YGx7cCQACi/PBV +bPk/WFFOd0h4FT9MT90peZcYQHJfyPDpmDBAJiaX7Uq6MUCajy3/c5QwQOObPmNyzVG+gKgfAybh+z8QmtySxl73P2ABDiDmsgJAAASTBybh+z/2ThwvSngVP5+tAud5 +lxhAaoeTVOqYMEDjL8TdTroxQKOXmF50lDBAJu+yyXLNUb4AAOhbQeH7P8AYsMfMXvc/OaUMn8+yAkAAAGBgQeH7PzFKuJ5NeBU/nVdUYXuXGED4kScc65gwQPvvmO5O +ujFAKGJsHXWUMEA8JZmWc81RvgAAcA144fs/UEaRMdle9z/pNt8+z7ICQAAA8BF44fs/p0DwfVR4FT8CuARWfpcYQBw9/vPumDBApYGWQU+6MUDCLXMdCNiRv3/3A66M +4fs/AAAIbI7h+z/QPMEF8l73P6D2o2TNsgJAAAAAAIDguz5/OVqlWXgVP6Lnd42AlxhAY1BljPOYMEBwGdOkT7oxQOo8bRXp15G/Lq96MVzh+z8AAHzvXeH7P6iZVaQE +X/c/XtySLcuyAkAAAAAAAOC7Ppc3MgVbeBU/7BPDJIGXGEAaShrG9JgwQGn1Sr9PujFA+LYEz+DXkb/jXXdDT+H7PwAAgAFR4fs/IHQzmwlf9z9TqlOWyrICQAAAAAAA +37s+xjPixF14FT+qu1RTgpcYQLUphDn3mDBA3EM59E+6MUAaSzNC0NeRv1glcGc14fs/AAB4JTfh+z/wwceIE1/3P5pX3WfJsgJAAAAAAADfuz4kLEJEY3gVP2rmW7CE +lxhA+3FXIPyYMEDX7hZeULoxQJwzjiiv15G/ozBerwHh+z8AAGBtA+H7P9j1A2MnX/c/IqvqCseyAkAAAAAAAOC7PuEcAkNueBU/V6v5aYmXGEDAJvztBZkwQBl91jFR +ujFAVgY79WzXkb/mOSw/muD7PwAAMP2b4Ps/cNLKE09f9z8gNe1QwrICQAAAAAAA4Ls+W/6BQIR4FT/vBXPbkpcYQPAgPokZmTBASHtm2VK6MUCAuHCO6NaRv0ggkF7L +3/s/AACVHM3f+z+Y/pJmnl/3P+PRkdy4sgJAAAAAAIDguz5OwYE7sHgVP5aWXbellxhA7VWkv0CZMEASAsooVroxQOx+TMDf1ZG/UYZ3nC3e+z8AAIBaL977PxAkEtE8 +YPc/0xhZ8qWyAkAAAAAAgOC7PjRHgTEIeRU/s+kWU8uXGECbsvkrj5kwQJFXn8hcujFAnQ3HIc7Tkb9FBccU8tr7PwAA2NLz2vs/AKvzuXhh9z8qMN8XgLICQAAAAAAI +4bs+AVOAHbh5FT/LaUAaFpgYQA24xwIsmjBAHBSEDGq6MUA6+tPbqs+Rv/s2e/d61Ps/AGCctXzU+z+YeIPc7GP3P1wfxEo0sgJAAAAAABjiuz6ban71F3sVP421nuip +mBhAzfzsqGWbMEAGZj2lhLoxQBwWqyxkx5G/i1LLhYzH+z8AMA1Ejsf7P8DBzm7GaPc/CLnFT5yxAkAAAAAAHuS7Ps6ZeqXXfRU/1ZL8jsqZGEBAoDzX2J0wQIc/rBq6 +ujFAIvI6RNa2kb9VGpzKrq37PwBQH4mwrfs/WNF8Fz9y9z/sS0zVarACQAAAAAA16Ls+NPhyBVeDFT9f+C5N8JsYQFhG8Lq+ojBA8TZlFya7MUBAVA1iuJWRv6TTNBnw +efs/AKg62PF5+z/gv73uSIT3P9V8dMMBrgJAAAAAgF3wuz4BtWPFVY4VP731N9zPnxhAhZiOloisMECPk9ZnArwxQL+cYQ51U5G/6oR45mYS+z8AYIOmaBL7P/DcogbS +pPc/Wdk10xapAkAAAACArQC8PpsuRUVTpBU/pXKwBPGlGEDbeSNcFMAwQEPiYuXMvTFAxL4Mo9XOkL8S6sPOLUP6PwD515AvQ/o/yI8w9E7Y9z/6qTjh2p4CQAAAAABB +Ibw+ziEIRU7QFT9F5GXCP6wYQHnZyO8J5zBAFMDgn63BMUCMWXbAuIqPv/V1XFZgpPg/gFx/HGKk+D/Y41fHSg34PwXbRCWyiAJAAAAAgC5ivD6E+YojahMWPzikzuuB +qBhAySxg0RgiMUC/Co9jscgxQKZL/VCQYIy/GuNFv3Ar9j8AgI+Lciv2P/j8+u/c7fc/enmFopxgAkAAAADQmcS8Pn+fceFASBY/+qHtksubGEAIPTfdMFAxQIKQW34e +0DFAVuzSOabjib+jyCzd2Tn0PwBfQ67bOfQ/YB3MaxSD9z8qxvQtLTYCQAAAAHBpEb0+HJ0/mUJIFj89VRgJy5sYQAUg6loyUDFAyAmmUprQMUD+plCKkeOJv3YCD7TJ +OfQ/AAAghcs59D/ImP/lD4P3PwbIb5VpMwJAAAAAAAASvT5XmNsIRkgWP4XrafXJmxhAyKlPVjVQMUA5TEvTmtAxQOgUTSto44m/VTjUYak59D8AAOgyqzn0PxiHRtoG +g/c/ILpRtmYzAkAAAAAAABG9Ps2OE+hMSBY/FPUTzsebGEAKjfGkOVAxQManeOiZ0DFAGbZyM/1MMUDvNJI+l5NSvgAAHFTFOfQ/oAoOw/SC9z8O+Cn0azMCQAAAwFjF +OfQ/pod9D1JIFj/QO7cwxpsYQIGlxaE7UDFAj/v/5JvQMUAvlT8i/0wxQDDf21GZk1K+AAA8AR069D9g9s8y54L3P+M9SZpgMwJAAADwBR069D++hVVvU0gWPxuMhsLF +mxhAUBBzKTxQMUA3Hgf8m9AxQH5WL6b/TDFAD1CG35mTUr4AALBiNDr0P0D/NpXjgvc/D8GyFmAzAkAAAGBnNDr0P+2BBS9WSBY/VEAs5sSbGEBpTMw4PVAxQM6eHSqc +0DFALD8NrgBNMUCiedn6mpNSvgAAeCVjOvQ/uIJAWtyC9z+kvVYPXzMCQAAAICpjOvQ/S3plrltIFj9KHqItw5sYQH8rdVc/UDFA8m9JhpzQMUDodL+9Ak0xQMd7dTGd +k1K+AAAUq8A69D+YMbjlzYL3PyWApQBdMwJAAACwr8A69D8IayWtZkgWP8esN72/mxhAP4WglENQMUAbUpw+ndAxQO5x/dwGTTFAHzyEnqGTUr4AAJC2ezv0P7AROgKx +gvc/yipe41gzAkAAAEC7ezv0P4JMpap8SBY/HvgJ37ibGEDrpl0OTFAxQBEVL6+e0DFACrLfGg9NMUDVrPx3qpNSvgAAlc7xPPQ/+PCGUXeC9z/dGTypUDMCQAAAPNPx +PPQ/dQ+lpahIFj/6aEotq5sYQJiicf9cUDFA0o4IkKHQMUBOSj2UH00xQCtOWSi8k1K+AICCAt4/9D8o2D1JBIL3P6iGqjZAMwJAAAAoB94/9D9blaSbAEkWP2K5M/SP +mxhAt3gA2H5QMUAiHItQp9AxQH3ZXH1ATTFA0o7Bft+TUr4AAP55tkX0P8Cu5Zwfgfc/18xSWB8zAkAAAKN+tkX0Pyiho4ewSRY/sVRwK1qbGEAwi7liwlAxQGXxzMyy +0DFAK2YtKYJNMUDb+k0CJpRSvgBAQqdnUfQ/yC1J01t/9z+JnNq23TICQACA56tnUfQ/wrihXxBLFj9maNQ98ZoYQEKtmN5IUTFAoiQ2ssnQMUCd4BPnBE4xQCAfVmSy +lFK+ANBZ+cpo9D+IBsVt6nv3P8bAE+FaMgJAAMD+/cpo9D/1550P0E0WP2zVbuQpmhhAZ7IGcFNSMUBtzjMw99AxQKVC9PsHTzFA4VkhlMiVUr4AGJVulZf0P0iaPOVf +dfc/J9KO7FYxAkAAYDpzlZf0P1tGlm9PUxY/MbIUy8SYGECtsYr5XlQxQAEqiPVQ0TFAfHn8iQRRMUBH4Jyi6pdSvgA4OTQ59fQ/kKV6Q6hp9z+7xqzyVS8CQAAw3zg5 +9fQ/KAOHL05eFj+D/zienZYYQNN0IadPWDFAhJomi//RMUA6xp4311QxQOrTpHsFnFK+AEAc7Liw9T8QL0Vkklf3PzMfkVJwKwJAAEDD8Liw9T/CfGivS3QWP9jl/UHB +lBhABpxKdpdfMUC/DC0SSNMxQNiVAOfiWzFA1DzTLJajUr4Auf2Jfyj3P6iKIffwR/c/RQDaBRskAkAApKaOfyj3P/VvK69GoBY/pLr5Gw2aGECGy2rRwWsxQE/QyU6A +1TFAYJSSopRnMUB2fc2rJLBSvgCirMJkGvo/WLkxHm509z+TWaP0axcCQACsWMdkGvo/54fcz9PHFj/1ADt4LKgYQMNLd+v5czFAyLtwIR/XMUDmPzv8X28xQMZdfymD +uFK+gAacMhfC/D/Q1CIlD+v3PwcYDoopDgJAACZKNxfC/D+EhaqH1ccWP71/P0MtqBhARcyLOPpzMUCDzVFpJdcxQEGOlURgbzFAgIovd4O4Ur4AAFC+NML8P5DKe84V +6/c/E44spgUOAkAAAPDCNML8P7+ARvfYxxY/7/xP2S6oGEB4U7LS+nMxQFIwpYcl1zFAF7FH1WBvMUBVO40ShLhSvgAAwNVvwvw/+LJsISPr9z+rWeL4BA4CQAAAcNpv +wvw/NXd+1t/HFj8H+X8FMqgYQCUeG2L+czFAWpAHOybXMUArfXeOBWiSv5Ozmq6Iwvw/AACYg4rC/D8okszHPev3PynH1PcADgJAAAAAAABQvT4OcOj95McWP7wbk2Y0 +qBhAGJ0B0gJ0MUCezpoaJ9cxQMQ3uHDmZ5K/ItcfEFjC/D8AABzlWcL8P/DoBsRR6/c/sT5C+vsNAkAAAAAAAFC9PiZuwF3mxxY/o7f3CDWoGEDAfukABHQxQLe1PFYn +1zFAqKGEJN5nkr+WPA8ZS8L8PwAAEO5Mwvw/UNMgGFfr9z/3g4Cl+g0CQAAAAAAAUL0+VWpwHenHFj/KI7xNNqgYQGUVuV4GdDFA4AZ9zSfXMUAFDh2MzWeSv+hl7Sox +wvw/AADw/zLC/D/QXyzAYev3P0v9EPz3DQJAAAAAAABQvT6zYtCc7scWP3w2KNc4qBhAuzZXGgt0MUDSJAC8KNcxQGZ6S1usZ5K/P++lTv3B/D8AAKQj/8H8P6DJUQ93 +6/c/3L8jqfINAkAAAAAAAFG9PnBTkJv5xxY/1keN6T2oGECFSY+RFHQxQEdPEJkq1zFAhKKe+Wlnkr/u3QeWlcH8PwAABmuXwfw/+PTVqaHr9z8xhBAD6A0CQAAAAACA +T70+6jQQmQ/IFj/lLYsMSKgYQOmu7n8ndDFAV2BYUy7XMUAWNh425WaSv4I0jyTGwPw/AACQ+cfA/D9ITsTP9uv3PxH+BrbSDQJAAAAAAABQvT7d9w+UO8gWP0CjVktc +qBhAK3RqXE10MUBOgofINdcxQOaagq7bZZK/BxKsQCe//D8AALAVKb/8PxAoPt+g7Pc/emBnGKgNAkAAAAAAYFC9PsN9D4qTyBY/6xAxrISoGEBqw1UUmXQxQJE/YrVE +1zFABd3hnMhjkr9Y6SB16bv8PwCALUrru/w/4FrPDPTt9z8QJ/POUg0CQAAAAADAUL0+kIkOdkPJFj9C3Br71KgYQJ1K+n8wdTFArnENmWLXMUCqTgZwol+Sv+raCc9t +tfw/ACAmpG+1/D9Yba6jlvD3Pz3kIAOoDAJAAAAAAMhRvT4qoQxOo8oWP3Kf+M5zqRhAzqJxRl92MUDWb1mIntcxQC4HR/BVV5K/N/tuR3ao/D8AoKoceKj8P+jUjsrM +9fc/+YAlh1ELAkAAAAAAuFO9Pl3QCP5izRY/CvaEWKqqGEDKSs6PvHgxQFtKwAcX2DFAtCKlW7xGkr85BjJPho78PwDQrCSIjvw/GHn2Tf3/9z+Fe0f4oAgCQAAAAACs +V70+wy4BXuLSFj8t7G4/+6wYQOpR3xF2fTFAvgO4kQrZMUDbxIT1hiWSv5Zzn9+iWvw/ACyYtaRa/D+gjHCucRP4P2FYm1ExAwJAAAAAAItfvT6Q6/Ed4d0WP68O+rUu +sRhAVdPvv+SGMUB0i5oU/NoxQK2lyO8T45G/3oKpJs/y+z8Asp390PL7P0h7NJK7Nvg/WnWxZRb4AUAAAACAQm+9Pipl053e8xY/s2F1Z+63GEDyLbIgsJkxQDqNzxsL +3zFAHl8PlxJekb+fBAgM/SL7PwA28eT+Ivs/aAHaMWxv+D+2RvAX5eABQAAAAACTjr0+XViWndkfFz+M10/3V78YQDxpXUj5vjFALdTAjO/nMUBNh08+zFOQv2hDXCHv +gvk/gFsn/vCC+T+QEgW3r634PxYfstsUrgFAAAAAgLHMvT4TMBl89WIXP/SiBtL7vBhA3BpGjtn2MUDzFtl5iPsxQEIQ35PVeo2/tESG2/YH9z8AnyK++Af3P3BXJawF +mvg/TKBwtRg+AUAAAADAxSm+Pg7W/znMlxc/h1XIBCOxGEAE4QkHOCEyQGt1pEq+ITJA3FnC3cH7ir801j91rxT1PwAmRVyxFPU/MJtfW1k2+D84eJ2ewGMAQAAAAABV +cL4+rNPN8c2XFz/Ue26BIrEYQJF6wF45ITJAvkAcor8hMkAEhuMbrfuKv7PAyT2fFPU/AADQJKEU9T+IdgYMVTb4P1ju8PO4YwBAAAAAAABxvj7nzmlh0ZcXP6Xhtnoh +sRhAG2wsDjwhMkAQlgpRwiEyQB7MJpiD+4q/d0/ezn4U9T8AAOC1gBT1P2BnM21MNvg/0AafnqljAEAAAAAAAHG+Pl3FoUDYlxc/GWpPbR+xGEA3NOeyPyEyQO7uGvXF +ITJAlQ1RPeAdMkADvz2h4XNTvgAAmOWeFPU/+EfOLzs2+D/cwYrQlGMAQAAAcOqeFPU/Nb4LaN2XFz/xumfjHbEYQNyQ2CJBITJA8A/JZMchMkC/EDue4R0yQMoJLhzj +c1O+AACE0/wU9T8Q7wBDLjb4P8wpg5uMYwBAAABw2PwU9T9NvOPH3pcXP5/iZ3odsRhADQb0hEEhMkDel9LGxyEyQMKPVPzhHTJAEfA3geNzU74AAMjfFRX1P2A8AtEq +Nvg/WLNMa4pjAEAAAMDkFRX1P3y4k4fhlxc/GqpvqByxGEDGAilJQiEyQGu644rIITJAz5+FuOIdMkA6qklL5HNTvgAAWPhHFfU/yJRD7SM2+D9cyeoKhmMAQAAAQP1H +FfU/2rDzBueXFz9jCawEG7EYQExqh9FDITJAtW/6EsohMkAULNww5B0yQCWwYN/lc1O+AABsKawV9T84tT4nFjb4P4wGaUp9YwBAAABALqwV9T+XobMF8pcXP3YF2L0X +sRhA9PEV4kYhMkBam/kizSEyQKz1WiHnHTJA2QJdB+lzU74AAMqLdBb1PziUFqH6Nfg/AMRtymtjAEAAAKiQdBb1PxGDMwMImBc/xdX8MhGxGEAm5nkCTSEyQFv5PkLT +ITJAfU+fAe0dMkA6xo5W73NTvgAAUFEFGPU/cNBLrMM1+D8kPZjOSGMAQAAAMFYFGPU/BEYz/jOYFz9H6HgoBLEYQL11XUBZITJA1+Plfd8hMkBzMUO/+B0yQDTa1vH7 +c1O+AIBN3yYb9T/oa8QgVjX4PxS4cOcCYwBAAAAq5CYb9T/qyzL0i5gXPz9fM0DqsBhAc8+TsHEhMkBcEKXp9yEyQKZN+C4QHjJAteH5GxV0U74AgA4HaiH1P3CGr4F8 +NPg/9EssW3diAEAAAOwLaiH1P7fXMeA7mRc/m/d1IrewGEB5WsJioiEyQCG07ZIoIjJAIN4c4D4eMkCYw5A+R3RTvgAAbIXwLfU/QIZ4Ic8y+D+4yLFKYWEAQACASYrw +LfU/Ue8vuJuaFz8w61WwU7AYQP47Tg4DIjJAiYzPLIkiMkC7GHeJmx4yQCt6LL2qdFO+ADC/O/5G9T/wHTjJiy/4Pxj0FEk5XwBAAECcQP5G9T+EHixoW50XP27SseKX +rxhAxJtcg8EiMkD4tRB/RyMyQCTDrflRHzJAofBwoW51U74AkOx/HHn1P4jnCD1iKfg/yOIyvPlaAEAAwMmEHHn1P+p8JMjaohc/zblhLEyuGECKrC/vMiQyQHX8Yqe4 +JDJA4qsSWrMgMkCdQ9gQ6nZTvgBgZvBj3fU/eOU0238e+D8AUIFDvFIAQAAQRPVj3fU/tzkViNmtFz9Zh6a3YKwYQL7bkhzoJjJAUbYcVm0nMkCnxjNqSCMyQAHCdeCv +eVO+AGJlzRqm9j8YpEOgXw74P4RO7hNGQwBAANBD0hqm9j9Rs/YH18MXPwOC/cEdqxhAB7yGRZ4rMkB20aqiIiwyQLtKmUO+JzJATF+U7Xl+U74AfSQHDDj4P9gQ68PG +A/g/dLOdp14oAEAAHAQMDDj4P4SmuQfS7xc/lYkplBayGECoob6FTTIyQMPLMarQMjJAnKY8s+wtMkCmg0wOHYVTvoDDf6cjXfs/qIP2Qlc++D/oiuMOMwIAQAAOYawj +Xfs/dr5qKF8XGD8xpwh7MsIYQGMyCjhLNTJAmZmT0M01MkBQtbd/djAyQOO1nsXWh1O+AMar/n8x/j/A4nsJqMX4P7h3sos94v8/ALyNA4Ax/j8UvDjgYBcYPxD5UF4z +whhAz3zCSUs1MkAep0jizTUyQJiLZ4x2MDJAiQw+09aHU74AAIBznzH+P7itzYtmxvg/WCZUwTzi/z8AAGB4nzH+P0+31E9kFxg/I2/pJDXCGEBkbTBtSzUyQGEesAXO +NTJADJTEpXYwMkDd43nu1odTvgAAKF3eMf4/CFE1uHXG+D/ArrUsO+L/PwAAEGLeMf4/xa0ML2sXGD84ASqyOMIYQMNjPy1ONTJASm4+xdA1MkAGCqnhL1OTv6kfmND6 +Mf4/AADgufwx/j+oNwwRlMb4P4AdEsQb4v8/AAAAAACUvj6dpnZWcBcYP73XCFw7whhAGCMyGFI1MkCz6Xmv1DUyQCAiAqIQU5O/UlUj/ckx/j8AAGzmyzH+PxAAWdSq +xvg/IJv8Be/h/z8AAAAAAJS+PrWkTrZxFxg/KazWETzCGEAZ8qQjUzUyQP7Zu7rVNTJAlefDTAhTk7/ZGfL3vDH+PwAAOOG+Mf4/+D3z5bDG+D+gTp0X4+H/PwAAAAAA +lr4+5KD+dXQXGD//U219PcIYQPDHiTpVNTJAj/I+0dc1MkAX/kai91KTvwTtju2iMf4/AADg1qQx/j+wFucIvcb4P5ij5zrL4f8/AAAAAACUvj5CmV71eRcYP9adfFRA +whhAncJOaFk1MkCLc0D+2zUyQL1wSk3WUpO/J1DE2G4x/j8AAAjCcDH+P4A/303Vxvg/eOGxgZvh/z8AAAAAAJS+Pv+JHvSEFxg/mxwjAkbCGEAV9MXDYTUyQA61MFjk +NTJAXm1Go5NSk7/jCh6vBjH+PwAAaJgIMf4/8HYR1AXH+D+gqxwQPOH/PwAAAACAlL4+eWue8ZoXGD/f2Y9bUcIYQIpIaXpyNTJAUTfGC/U1MkAuyhJPDlKTv+hbjVs2 +MP4/AADZRDgw/j8IzX3RZsf4PzhtSzB94P8/AAAAAICUvj5sLp7sxhcYP1rt6AZowhhAUcCD5pM1MkCPQcVxFjYyQHNE/aUDUZO/9Lpbs5Uu/j8AgKqcly7+Pzh/eJAo +yPg/SEENfv/e/z8AAAAA4JS+PlK0neIeGBg/BUmeP5XCGECKMQi61jUyQA+zEzlZNjJAO84aUe5Ok7884rleVCv+PwCAD0hWK/4/cFkJH6vJ+D+QCx9PBNz/PwAAAABg +lb4+H8Cczs4YGD+LVTw578IYQA5MUU5cNjJAMjv0tN42MkB5yIScw0qTvz15j6TRJP4/AGDzjdMk/j+QPDR/rMz4P1AcYscO1v8/AAAAAEiWvj6515qmLhoYP+GFeU6h +wxhAsuj1K2c3MkAPZNVh6TcyQOCreAhuQpO/jow87csX/j8AELzWzRf+P0hzkFCg0vg/MACeDyfK/z8AAAAA+Je+PuwGl1buHBg/qj+RCv7EGEAYvxS8ezkyQEb9o5D9 +OTJAbS7/N8Ixk7+KuH53v/39PwCgNWHB/f0/WAfeXkze+D+YBK74ZLL/PwAAAABum74+UmWPtm0iGD8YfKoVmscYQJgpBTSgPTJA68rNRiE+MkBjUEUOaBCTv5tNTJai +yf0/AJBxgKTJ/T94rVRst/T4P0iNYvsVg/8/AAAAAFSivj4fIoB2bC0YPyv4s9VezBhAYthYpdZFMkDqYPU3VkYyQLQWElqqzZK/eUO8LFph/T8AOrwXXGH9P9AIwsPj +Hfk/sP9UN0sl/z8AAAAA/6++PrmbYfZpQxg/V5VfhC3UGECYu2+f+lUyQNOVBj93VjJAzKNkSQ9Ikr/vP63il5D8PwD5Ws+ZkPw/gEkzl/ph+T9wNUdU9mz+PwAAAMDb +yr4+7I4k9mRvGD/gutzlbd0YQOKCM0YndTJAeFODM551MkAuWjz8hTyRv+hMHlqR7vo/gNcJSpPu+j9Q4bKF3bP5P0B1bPzvCP0/AAAAwLj+vj6iZqfUgLIYP6uUR+BS +3RhAjSHkJgKiMkB1tvnhcKIyQO2ybaAsSI+/ybNV3WJw+D+Am+rRZHD4P+iA3VSMs/k/gFPaxKwI+z8AAACATkm/Pp0MjpJX5xg/p5s4yu/SGEBagnRZIsMyQD5H+waL +wzJA6qbvi6zFjL9nOlPNbnr2P4DsWMVwevY/OA/grapW+T8IlBFnXY75PwAAACBbgL8+OgpcSlnnGD/UrB1S79IYQEibbWUjwzJA7WjDEozDMkDySvasl8WMv41qIH9e +evY/AAAgd2B69j/44s3ZcFf5P2CltHJRjvk/AAAAAACAvz51Bfi5XOcYP1fR42Hu0hhAcdJefSXDMkDFsVIqjsMyQAhuBO9txYy/9nW74j169j8AAMDaP3r2P9BgQJpo +V/k/IPcFijmO+T8AAAAAAIG/Puv7L5lj5xg/9GJ4gezSGEDpL9fVJ8MyQHBWXYKQwzJAaSp6Io+/MkDWcd7DfCFUvgAAXABhevY/GDV8G1hX+T/QwWfAHo75PwAAYAVh +evY/xPSZwGjnGD8OS08Z69IYQBwOnTYowzJAyoUR45DDMkAK4Hdzj78yQIEY1Rp9IVS+AABUo8N69j9Az8e9S1f5P8jtN28ajvk/AABgqMN69j/c8nEgaucYPz99T7nq +0hhAYNVoUCjDMkBfltj8kMMyQPxGDomPvzJAWgYDMn0hVL4AAPDw3Xr2P+Bv/3FIV/k/uAueSBmO+T8AAAD23Xr2PwvvIeBs5xg/96NX+enSGEBPl/6DKMMyQEPrZDCR +wzJAKEg5tI+/MkBc81xgfSFUvgAAIIwSe/Y/cMms2kFX+T/Y0377Fo75PwAAQJESe/Y/aeeBX3LnGD//fpZ56NIYQJ1PH+sowzJAc8tyl5HDMkA2foQKkL8yQD41Bb19 +IVS+AACYwnt79j8QaaWtNFf5Pxitu2ESjvk/AACwx3t79j8m2EFefecYPzZnznrl0hhAUZI1uSnDMkDRZWNlksMyQJC577aQvzJA51gndn4hVL4AAIAvTnz2P9AtDloa +V/k/yH8iMAmO+T8AAIg0Tnz2P6C5wVuT5xg/uN4mgN/SGEB9YrVUK8MyQN4EmACUwzJAlG8ZD5K/MkBWIrLnfyFUvgAApgnzffY/SGC8zOVW+T+YiqTU9o35PwAAsA7z +ffY/k3zBVr/nGD/7XXmW09IYQFFBAokuwzJArP9ONJfDMkB/7Lm8lL8yQLHS4ceCIVS+AIAJvzyB9j+g+H8ZfVb5P0BYeTzSjfk/AAAQxDyB9j95AsFMF+gYP489nPG7 +0hhAk5TR5jTDMkCqg/SQncMyQKrGLw2avzJAv1GqfIghVL4AgD4u0If2PxCWSFCtVfk/iOFeh4mN+T8AAEgz0If2P0YOwDjH6Bg/QZuWYY3SGEBRb0t3QcMyQAuiIh+q +wzJAjuPzgqS/MkAADeW3kyFUvgAgIR73lPY/kIcGMBRU+T+QGOIJ+oz5PwCAKSP3lPY/4CW+ECfqGD9JLUgmM9IYQOXk0utZwzJAfCAyj8LDMkDJ+QTCuL8yQN6WK3Wp +IVS+ABD1QUWv9j/IE42h+1D5P4hzDMDii/k/AED9RkWv9j8TVbrA5uwYP/rfCTKK0RhAi09oJIjDMkBbalW/8MMyQGVthI/evzJA5/FNDNIhVL4A+DyL4uP2P9h6eJkw +S/k/cHAL49KJ+T8AgEWQ4uP2P3mzsiBm8hg/2tbdz2XQGEBteWnd2cMyQCjBZ2lCxDJAeVnHcR/AMkAg1m+3FyJUvgAsP7AgTfc/CCsfYS1B+T8o/oKULYb5PwCwR7Ug +Tfc/RnCj4GT9GD8jFUUiz84YQH/uq7xSxDJA8Q2UMrvEMkCgptahdsAyQC0ma1V1IlS+AJL4r6cf+D+AxxxLSDP5P3hHrSvJgPk/ADABtacf+D/g6YRgYhMZPx6N2VxL +zhhA36Bzn5zEMkBwhNsHBcUyQEIt0yN9wDJABwNCUnwiVL4A+MmlxMT5P1CI5rzOLvk/qNgOXX19+T8AmNKqxMT5PxPdR2BdPxk/vTksugXXGEDfIqFqpMIyQA7MKi8N +wzJATlqzRf69MkAMKaZXzh9UvgCVHclmDv0/ePoKHu96+T9I782b+5P5PwCMJc5mDv0/BfX4gOpmGT9h/R+M5+gYQP5cN1YRvjJAgM+98Hq+MkAvUEFc8rgyQPdsnClj +GlS+AL1kHs0AAEDQyQV6vhn6P1Cj9NI5yPk/AAzoIM0AAECi8sY47GYZP9N+h4Po6BhAFGDyFBG+MkDDv4Sver4yQHmvvhXyuDJALbbm3WIaVL4AAAh/3QAAQEDHe76x +G/o/mDJcvDzI+T8AAICB3QAAQN3tYqjvZhk/uGNecuroGEBl9GWSEL4yQOEuEC16vjJApPy2iPG4MkAWqXhGYhpUvgAARED+AABAUNMJJMMb+j+wPEePQsj5PwAAyEL+ +AABAU+Sah/ZmGT9aRhtQ7ugYQPTphiwSvjJAbjPmxnu+MkBNluFsOnyUv2w9EKUNAQBAAADkoA4BAEAAy63v5Rv6P0AtcEMwyPk/AAAAAAB6vz4s3QSv+2YZPx/zVTbx +6BhAhW2MVxW+MkAFhVfxfr4yQLCiD/safJS/GjckFPUAAEAAAPgP9gAAQPDdvQcAHPo/0Ig8FQzI+T8AAAAAAHq/PkTb3A79Zhk/Xec7/PHoGECFQdEvFr4yQGTUdMl/ +vjJAw4hwmBJ8lL/X6heH7gAAQAAA7ILvAABAGHTT/AYc+j/gRltvAsj5PwAAAAAAer8+c9eMzv9mGT+zjQKI8+gYQKhHWuAXvjJAY9GueYG+MkC51THTAXyUv/nu/mzh +AABAAADQaOIAAEAgTc/mFBz6P3j7nyPvx/k/AAAAAAB6vz7Rz+xNBWcZP99NcJ/26BhAvohoQRu+MkDhAB/ahL4yQLJ0sUjge5S/KqPKOMcAAEAAAKA0yAAAQLAOq7kw +HPo/ILhUjMjH+T8AAAAAAHq/Po7ArEwQZxk/Cp/NzfzoGEBO3nUDIr4yQAs28JqLvjJAnsekM517lL/zu1jQkgAAQAAALcyTAABAMOnyWmgc+j8gfWtee8f5PwAAAACA +er8+CKIsSiZnGT+Em48oCekYQOTXU4cvvjJA6PlVHJm+MkAayFsJF3uUv1S0T/8pAABAAIAk+yoAAEB4ycSL1xz6P2AsTgXhxvk/AAAAAIB6vz77ZCxFUmcZP/azMdYh +6RhA/Asdjkq+MkDt7i4etL4yQJdoC7QKepS/bNNRubD+/z8AgP6wsv7/P4Cld6a1Hfo/cM7nXazF+T8AAAAAwHq/PuHqKzuqZxk/XBn0EVPpGECVsOSXgL4yQMHGFh7q +vjJArM5yBvJ3lL/tYhMqavv/PwDAxSFs+/8/EDZNwHAf+j+QmWk6Q8P5PwAAAAAge78+rvYqJ1poGT91XJ8LtekYQGGxSpzsvjJAOfO/Dla/MkCkY2+fwHOUv7ALHvnc +9P8/AGDb8N70/z/wkVKH4iL6PxgLk6Bxvvk/AAAAAOB7vz5IDin/uWkZP7IP/Ah36hhA9r1/aMS/MkBpaYazLcAyQKUPiaJda5S/cij2TcLn/z8AAMpFxOf/PxjflG+0 +Kfo/OHvbING0+T8AAAAAPH2/Pns9Ja95bBk/uT8iN/PrGEClN/8Oc8EyQK/qVAvcwTJAMR2F8JZalL+d/c/Xi83/PwCA0M+Nzf8/WI/sDhI3+j/YtTXsmqH5PwAAAAAI +gL8+4ZsdD/lxGT/K89+6zO4YQNFY2pfMxDJAlEd+9zTFMkAlkpHFBjmUv1l0s5Qamf8/AAQNjRyZ/z/w45ewt1D6P8i0yoVZe/k/AAAAAJiFvz6uWA7P93wZPxZnLCAH +9BhAM3YHtXDLMkC6bwPe18syQG1lXR/c9ZO/eu4B8Scw/z8AAAzqKTD/P6DxR0DFf/o/MDNrhIEv+T8AAACAoJC/PkjS7071khk/Z0AGjK78GEAa4oP6fdgyQH3P9cDi +2DJAqoaIrGNvk79qUpW9C17+PwA5+rcNXv4/eJXwCqjN+j+wo3TQcpr4PwAAAIBOpr8+e8WyTvC+GT8iLqbAZAcZQIj2t26z8TJAHB/ymRPyMkCr9qxGE2KSv2pBbh4+ +ufw/gMpwG0C5/D8I8Y/kDy77P3jx57KNevc/AAAAoCjQvz4xnTUtDAIaP5p43d8NCRlA1Fv56vgVM0DH7351UhYzQPGv2OXSxpC/6ZIih6k2+j8A++eHqzb6P0CPgf0B +Pfs/CKGenFHc9T8AAABAKwbAPixDHOviNho/BATSbr3/GEBny89SwjAzQH6LTfgWMTNA8LY2cJIGj7/rvqpnIj34PwC5NmskPfg/+HUaBC7p+j+QZGUzZ6r0PwAAANBf +HMA+ykDqouQ2Gj/YW73+vP8YQK42gSvDMDNATV7X0BcxM0Ao9LVqfQaPv74mXvsRPfg/AADw/hM9+D9wjGATKun6P0j7q4hdqvQ/AAAAAAAdwD4FPIYS6DYaP2n0jx68 +/xhAgELj3MQwM0BSOeqBGTEzQEc8tV9TBo+/F5fFIvE8+D8AAFgm8zz4P4jpxzEi6fo/ODRCM0qq9D8AAAAAAB3APnsyvvHuNho/6JI9Xrr/GEA3iFJDxjAzQC0AGOga +MTNALt/8cuUsM0AAju4i45ZUvgAAPBIWPfg/AHzibhLp+j+gU8k1Oqr0PwAAYBcWPfg/UysoGfQ2Gj8sISgOuf8YQDSf4dLFMDNA8KK7dxoxM0BFUkjy5CwzQGpRvJji +llS+AAD8uHs9+D9gfCGeBun6P+jq6Dk/qvQ/AAAwvns9+D9rKQB59TYaP4c2lLS4/xhA2jfjtMUwM0ChtsJZGjEzQCGd88/kLDNA4IPfc+KWVL4AAFjUlj34P5g87ncD +6fo/kHdzkECq9D8AAIDZlj34P5olsDj4Nho/q090Abj/GEDRuOR4xTAzQAEuzx0aMTNAioJIi+QsM0CZGCQq4pZUvgAAKAvNPfg/2B7PK/3o+j8g2ps9Q6r0PwAAYBDN +Pfg/+B0QuP02Gj8QGGSbtv8YQMmY3QDFMDNAovzdpRkxM0CUK+gB5CwzQP5gopbhllS+AADIeDk++D9oKj2V8Oj6P4hXYJhIqvQ/AADwfTk++D+1DtC2CDcaP+78AdCz +/xhAQ9GmEMQwM0DYGdO1GDEzQPf2/u7iLDNAC25zb+CWVL4AAO5TEj/4Pzg2ym7X6Po/QC64T1Oq9D8AABBZEj/4Py/wT7QeNxo/t/M2PK7/GEC2JpcvwjAzQGFWG9UW +MTNAQ3WKyOAsM0Cke2cg3pZUvgAALwrEQPg/SOOmPKXo+j9AMaPFaKr0PwAAWA/EQPg/IrNPr0o3Gj9LfIQgo/8YQJ9272q+MDNA8OojERMxM0AsIxl53CwzQHd5l3/Z +llS+AABkdidE+D94sGBDQej6Pwi0Zc6TqvQ/AACIeydE+D8IOU+lojcaP1wwpRiN/xhAvEN/17YwM0AgGxZ/CzEzQJTeFdDTLDNAV6UXM9CWVL4AwJJN7kr4PxAFh/x6 +5/o/eNaVU+qq9D8AALlS7kr4P9VETpFSOBo/ZvC2xmH/GEDuXCCIpzAzQLVggzL8MDNA2aaRVcIsM0Ap7J1uvZZUvgBAzPZ7WPg/cMUmG/Xl+j/Q32ssmav0PwCA8vt7 +WPg/b1xMabI5Gj+nhOsXDv8YQNvZjkeIMDNAWcin99wwM0B6Fbm+niwzQPym6zeXllS+AMDlMpdz+D+4+//1A+P6P4CIORb+rPQ/AEALOJdz+D+ii0gZcjwaPyCpK31y +/hhAK3lPQEcwM0DfTEr8mzAzQJwx/ApVLDNA31zXFEiWVL4AuFlDzan4P/hDQYWL3fo/oAuvvOSv9D8AQH9Izan4PwjqQHnxQRo/J5jqyGn9GEA5fvMiuy8zQF+biPgP +MDNArs35lLcrM0ACXkwCn5VUvgD4aVM3Fvk/OKv3Lj3U+j+g053nJLb0PwBgj1g3Fvk/1aYxOfBMGj8wB+8oDvwYQBq4a/l6LjNAAmOBCdAuM0DJWge8VCozQBj5kv4h +lFS+ADQirv/u+T+Ikh+PBMj6P1h8OUptxPQ/ADhHs//u+T9vIBO57WIaP7fAT2MN/BhAc7NGUF0rM0C0Wh3ysiszQCAD87/xJjNAq3CjE3+QVL4A5ukFRqD7P0gYhpz9 +x/o/8EjV5wLo9D8ABA4LRqD7P6IT1rjojho/bkI56fIFGUDY6orIvyIzQL/lY/0WIzNADhf24skdM0CEHmtfqoZUvgAKCt3aAP8/sKe7UQ8h+z/wXEH5Zkr1PwC2K+La +AP8/lCuH2XW2Gj+8FYW+ABkZQNPmxd1hGDNAJtuP97oYM0A3Fd8U8BIzQDn8LroDe1S+gKm/zpMDAUBwFWbRi8z7PzhoJs7LwPU/AAlP0ZMDAUAyKVWRd7YaPxTPy8MB +GRlARb4OXWEYM0CnN/B2uhgzQGOVyY7vEjNAz0I2KgN7VL4AAJSVpAMBQIiZ4gCVzPs/EEcijNHA9T8AACCYpAMBQG0k8QB7tho/1T1hzgMZGUDrJZ5bYBgzQNOprnW5 +GDNAJk+cgu4SM0ByXkIKAntUvgAAMCPGAwFAUH4jYKfM+z+oCTQI3cD1PwAAyCXGAwFA4xop4IG2Gj9hNZvjBxkZQBzqXSJhGDNA7xxKPLoYM0Cz+WOOeMeVvxQbPi/W +AwFAAADQL9cDAUBAMi0fzMz7P7AKaCrUwPU/AAAAAAAJwD67E5MHh7YaP7wXc/MKGRlAov+nzmMYM0DAKBfovBgzQFQXa95Yx5W/OqrDbb0DAUAAAFhuvgMBQHAnxK3n +zPs/yMyJo7XA9T8AAAAAAAnAPtMRa2eItho/q7dxxAsZGUAuYyGFZBgzQIU0b569GDNAagg5a1DHlb+TjsTTtgMBQAAAWNS3AwFA2Ma3Bu/M+z9wj5t/rcD1PwAAAAAA +CsA+Ag4bJ4u2Gj9xlGlmDRkZQLOhE/JlGDNAk8MeC78YM0ABZNSEP8eVvyHuxZ+pAwFAAABYoKoDAUDQiW64/cz7P4gsxTedwPU/AAAAAAAKwD5gBnumkLYaP637OKoQ +GRlAUuv0y2gYM0DcrnrkwRgzQNDzB7gdx5W/ejbGN48DAUAAAFw4kAMBQOgquRobzfs/uPQ8qHzA9T8AAAAAgAnAPh33OqWbtho/2INWMRcZGUD6sKp/bhgzQCy6JZfH +GDNAxnZiHtrGlb/L7LxnWgMBQAAAUmhbAwFAcPTC2lXN+z+IvL6JO8D1PwAAAACACcA+l9i6orG2Gj9Skow9JBkZQLAG4+Z5GDNAkKRI/NIYM0DsEOXqUsaVvzj1gsfw +AgFAAAAYyPECAUC4dqlIy837PzghC0+5v/U/AAAAAGAJwD6Km7qd3bYaPzlj5U0+GRlApuGGtJAYM0BOzsHF6RgzQFbMIINExZW/o59xhh0CAUAAAAiHHgIBQNjOyNu1 +zvs/APvG4rS+9T8AAAAAYAnAPnAhupM1txo/a65PTnIZGUCihZtMvhgzQIWlgVUXGTNAGxF0sCfDlb9drdoBdwABQABgcwJ4AAFAmHOF34nQ+z8ozcgurLz1PwAAAACI +CcA+PS25f+W3Gj8zqDXO2RkZQM8E+m8ZGTNAiuE4aHIZM0DSWZf+7b6Vvyw+5u4p/QBAAJCD7yr9AECgO5teLdT7PwjW41ibuPU/AAAAANgJwD7XRLdXRbkaP6ssvMum +GhlAjtWXg88ZM0Bcg5FaKBozQJ3bPGl6tpW/k4s3oo/2AEAAWN6ikPYAQNjjVUhi2/s/2OXu9Huw9T8AAAAAbgrAPgp0swcFvBo/0fNMyTgcGUCeRLbeOhszQJ/gSnOT +GzNAFdxee5Kllb/wG2JwWukAQAC0G3Fb6QBAMORsMoTp+z+4KRZIRqD1PwAAAACZC8A+cNKrZ4TBGj/eaGEqPR8ZQAT3d2cOHjNAchTXd2YeM0BvJZOtv4OVvz/1mr/t +zgBAABB6wO7OAECgASWcqwT8PzBHrzj/f/U/AAAAgPENwD49j5wng8waP2+jOlXKJBlAcsSz2qgjM0DNJvbk/yMzQMtdGxoPQJW/R2FlzAuaAEAAzo7NDJoAQMAQyB2i +Nvw/wAcDNQFA9T8AAACAlhLAPtcIfqeA4ho/kWRT+QsuGUCbBMACrC4zQK3b3wkBLzNApZLQVIi4lL+Q8kKCKjAAQABm/oMrMABA8Nqm4vCJ/D8g0AFGPcL0PwAAAGC3 +G8A+CvxAp3sOGz/eJwAUzTkZQDo5XAjxQzNAN76ILEJEM0B/A1uGEqmTv3Y17vEsuP4/gPKY9y64/j+guLnSuvP8P1izd95Uz/M/AAAA4FUtwD7A08OFl1EbP9CfZJiw +PBlAnMfLi4tiM0CxTmUY12IzQCKbzmN5CpK/ZdLyq10w/D8AM8i0XzD8PyjwQXq6Df0/GGV6e9Nx8j8AAAAIq0bAPrt5qkNuhhs/vs4GKhQ0GUAygrFlJXkzQFRmENFs +eTNAWA2N1EDEkL/aZBxMpTL6PwDpR1enMvo/gJb1mDrA/D+we7Kqtm/xPwAAACBcWcA+WHd4+2+GGz+Sx+++EzQZQAuFhhwmeTNAqgDEh215M0DCNlI7NsSQv451sLyU +Mvo/AADgx5Yy+j/4VSbVNsD8PwjhrYKub/E/AAAAAABZwD6TchRrc4YbP+WHvegSNBlAsN8viid5M0Bjiir1bnkzQFLs3AghxJC/QDHZnXMy+j8AAAipdTL6P+AYYk0v +wPw/UE2sMp5v8T8AAAAAAFnAPglpTEp6hhs/61RhPBE0GUBRKBlAKHkzQJCV8qpveTNAysXFMfd0M0AGaEpmReRUvgAA7IOZMvo/GE4kPiDA/D+YzSsVlm/xPwAAKImZ +Mvo/4mG2cX+GGz+P5UT7DzQZQO9zdCwneTNAOj+Al255M0CvNZMN9nQzQBfEiyxE5FS+AACI+gAz+j/gYyT0FMD8P3DxIWGib/E/AADA/wAz+j/6X47RgIYbP8E+r6UP +NBlAc+jw4iZ5M0CUIgpObnkzQPeRpb/1dDNA8ADf2EPkVL4AAKCRHDP6P6CG4fERwPw/uO+wqKVv8T8AAOCWHDP6PylcPpGDhhs/k/aL+g40GUCdOehPJnkzQLNRHLtt +eTNAybLII/V0M0DQxIMxQ+RUvgAA0L9TM/o/AP2j7QvA/D9gHuE3rG/xPwAAQMVTM/o/h1SeEImGGz9XhnWkDTQZQM1MzSkleTNAiyI3lWx5M0AtZgXs83QzQOwJw+JB +5FS+AAAoHMIz+j/oCtrm/7/8PwCnrla5b/E/AABgIcIz+j9ERV4PlIYbP98hCfkKNBlA4jZx3SJ5M0DrjkZJankzQD2UWHzxdDNA4okYRT/kVL4AAL7UnjT6P7CCCuDn +v/w/qGL+ldNv8T8AAPjZnjT6P74m3gyqhhs/DSUypQU0GUAzHCBEHnkzQMmUzLBleTNAwQ9mnOx0M0AuYx8JOuRUvgAAlEVYNvo/SJ977be//D/QaHAbCHDxPwAA0EpY +Nvo/sendB9aGGz99PIoJ+zMZQDc+Gg8VeTNAqWd1fVx5M0Belx3a4nQzQMGPnI4v5FS+AIDZJcs5+j84cpR0WL/8PzjanUFxcPE/AAASK8s5+j+Xb939LYcbPzW2SQLm +MxlAGnaAmwJ5M0A3wDoNSnkzQEaA/0vPdDNARXNVjxrkVL4AgMfgsED6P7C5TzObvvw/AJ0X+0Nx8T8AAAHmsED6P2R73Ondhxs/AR++s7wzGUBgaBmO3XgzQMvumAYl +eTNA9nSTCah0M0BRecZn8ONUvgBA+D98Tvo/4GhncCe9/D9o9lAi63LxPwCAMUV8Tvo//pLawT2JGz+kcEAUbTMZQPzvotqSeDNADNTIYNp4M0ATyyHsWHQzQOAtznSb +41S+ANDtoRJq+j+YR/zUWrr8P8CVLUBAdvE/AMAmpxJq+j8xwtZx/YsbP8j53bnZMhlAUllBEvt3M0DJVSO0QngzQFo3B1C4czNA0p65AO/iVL4AkBvmPaH6P+AZhqcs +tfw/wDgjrAV98T8AYFTrPaH6P5cgz9F8kRs/l7tpCuIxGUBsUxIFwnYzQHE9KOAJdzNAMqdtnG1yM0BgAizqi+FUvgAE/P+ND/s/KOpvfHes/D/YBaLZ/IrxPwBwNAWO +D/s/ZN2/kXucGz+SUiltqjAZQA0MPkQqdDNASQWdmHJ0M0Cxtm6Tsm8zQBIR21Sd3lS+ANqdChHs+z/4OCz1gqH8P+AZ2S+ZqPE/AIDVDxHs+z/+VqERebIbP/6kZ+D4 +MBlAvSeAgmZuM0CPGojkr24zQAIeSlioaTNA9XkbFCHYVL4Az4bMh6T9P8AeXQJFpPw/sCbI8G7q8T8A1LzRh6T9PzFKZBF03hs//svwlJQ7GUDe+eXFoGAzQH/kLKzs +YDNA7M/YJFZbM0Ay43aGwMhUvoD9iUY3iQBAwH0vW74D/T9AR0hQuIfyPwAWI0k3iQBAI2IVMgEGHD9amINkW08ZQJVRKB/IUTNAsynquxZSM0AkV3ng/0szQEcJY7pI +uFS+QJc34MMRAkAArVinu7X9PxjnQlNFMfM/AKDO4sMRAkDAX+PpAgYcPzdaLXJcTxlAYk11bcdRM0DqnVcKFlIzQNu/VSn/SzNA7Sm+9Ue4VL4AAATg1BECQMh9UCLF +tf0/oCSpQE0x8z8AAJji1BECQPtaf1kGBhw/neaIjV5PGUA9Ig0KxlEzQABkMKcUUjNAXm8Mu/1LM0ALIXJsRrhUvgAAmN/2EQJAWG2IGNi1/T+oA44bXTHzPwAAMOL2 +EQJAcVG3OA0GHD96Ak/EYk8ZQEgyIznGUTNActk91hRSM0ASIg3pUCGXv55CEjYHEgJAAACsOQgSAkAgaH8F/rX9P9igzwFbMfM/AAAAAIA5wD5KSiFgEgYcP1+JT+1l +TxlAjRfilMhRM0CxbI4xF1IzQAsR/PIwIZe/Ue3UPe4RAkAAAHBB7xECQDAmhHYatv0/EA7JEkAx8z8AAAAAgDnAPmJI+b8TBhw/wogDxWZPGUDwHuE1yVEzQP4IcNIX +UjNAPN4YbSghl7+ebTuV5xECQAAA2JjoEQJAqCDYCyK2/T/gXCTkODHzPwAAAAAAOsA+kUSpfxYGHD/zDGZ0aE8ZQDa13nfKUTNAMMkyFBlSM0CS7VFhFyGXv5oBCETa +EQJAAACgR9sRAkBgxk42Mbb9P6ha4IYqMfM/AAAAAAA6wD7vPAn/GwYcPyE2CtNrTxlAyA7X+8xRM0Add7WXG1IzQCnKwEn1IJe/8J2eob8RAkAAADylwBECQAA5FIpP +tv0/8JZ4zA0x8z8AAAAAADrAPqwtyf0mBhw/pw7Pj3JPGUAhdrwD0lEzQDyJr54gUjNA03uRGrEgl7+9qMFcihECQAAAXGCLEQJAuNX/LIy2/T/4ECpY1DDzPwAAAADA +OcA+Jg9J+zwGHD8g8EoHgE8ZQEwWWhPcUTNANod2rCpSM0AVyP67KCCXv1AM39IfEQJAAIB61iARAkD4wlpgBbf9P4gDkXFhMPM/AAAAAKA5wD4Z0kj2aAYcP1IzDO6a +TxlAsaHgMfBRM0A870/HPlIzQIU7Cf4XH5e/gDZ3vkoQAkAAQBTCSxACQLgfJn33t/0/0KdurHsv8z8AAAAA0DnAPv9XSOzABhw/Uq26mtBPGUD5DhtsGFIzQNeZMPpm +UjNA9EbffvYcl79vbx6ToA4CQABgvZahDgJAuGlIj9q5/T8QCmdCsC3zPwAAAADwOcA+zGNH2HAHHD8A9vZwO1AZQGiVRtVoUjNA3qqqVLdSM0BKsp1zsxiXv0ozUzJM +CwJAAED2NU0LAkDY92YXnL39P+giPe8ZKvM/AAAAADQ6wD5me0Ww0AgcPxgdaBIPURlA+t6CeglTM0CGR4zcV1MzQHOl0SktEJe/QsmrSKMEAkAAMFdMpAQCQLBXYcQM +xf0/iCQGTO8i8z8AAAAAtjrAPpmqQWCQCxw/2vr3NK5SGUDNquQQSlQzQLqhWTiYVDNAx9x/zB//lr975MPXUPcBQADgf9tR9wFAgCNw+6TT/T8Q+UgOohTzPwAAAADA +O8A+/wg6wA8RHD9+8TtWzFUZQPId7W/IVjNArFe8IhZXM0Db1f0FAt2WvxNPrpSp3AFAAFKLmKrcAUBAz9MmtO/9PzC1l5cn+PI/AAAAANA9wD7MxSqADhwcPzgBTeaK +WxlAfxDuC7pbM0ATmHrXBlwzQIO4ax27mJa/Jij8LlKnAUAAnhozU6cBQNBcbTdnI/4/gGcZz7G/8j8AAABA50HAPmY/DAAMMhw/MUUoRSdlGUCFfWlgcWUzQF+odWW8 +ZTNAzUmFOgYQlr+oIbjdhDwBQAA1V+KFPAFAkMAijeZ5/j8oZHZ4u1DyPwAAAEDxScA+mTLP/wZeHD9PGW9HgHEZQH1cL381eDNAd1FkFn14M0Df0FEtL/6Uvy7rZ9uU +ZgBAwEf/4JVmAECgNaChB+n+P+DXzm1qevE/AAAA0HVZwD5PClLeIqEcP5TljZcJdRlA0bL+2jWTM0AbPCGDeJMzQEkTW2/qW5O/Ik7+TZ4//j8A4PZboD/+PwhktXLb +CP8/iF6EbgxG8D8AAACgxG/APkqwOJz51Rw/id0ox79sGUARKRmwJqczQNDDcbNlpzNAVy0q+ccSkr/Y5lF1WD38P4AgWYVaPfw/qBsoH0O+/j/A6I5DosTuPwAAANA5 +gMA+6K0GVPvVHD/sEyVev2wZQPcGaVEnpzNA2yekVGanM0CNGJ5HvRKSv1wG579HPfw/AADwz0k9/D8gBQZuP77+P5AeD9+TxO4/AAAAAICAwD4jqaLD/tUcP8k8GYy+ +bBlA2isIlCinM0AjWQiXZ6czQARQhuSnEpK/Bt0RVSY9/D8AACBlKD38P+h0mws4vv4/QAEdFnfE7j8AAAAAAIDAPpmf2qIF1hw/g7oJ6LxsGUBo3AvJKKczQMpZAsxn +pzNA+IDyGKSiM0BmKACPUBVVvgAANJlMPfw/cOAPRym+/j8gYDhbcsTuPwAAeJ5MPfw/cZhEygrWHD9cAietu2wZQH1BnjQnpzNAN6XeN2anM0BMZc9zoqIzQKnczspO +FVW+AACYB7U9/D8QZxc1Hr7+PxCksXCWxO4/AADgDLU9/D+JlhwqDNYcP3psOlm7bBlAyh/DyCanM0DNOBfMZaczQBSZfwOiojNArto2Uk4VVb4AAMDg0D38PyAixkEb +vv4/0L82EKDE7j8AAADm0D38P7iSzOkO1hw/i1NpsbpsGUDmWQvxJaczQMXdhvRkpzNAYH7eIqGiM0D4NwVhTRVVvgAAGJMIPvw/uEFsWxW+/j/gcmNPs8TuPwAAgJgI +Pvw/FossaRTWHD81kvdhuWwZQDK/kkEkpzNAbRpdRWOnM0B+O5Nhn6IzQCw6mH5LFVW+AAC493c+/D+wdWyQCb7+P0C/i87ZxO4/AAAA/Xc+/D/Te+xnH9YcPyDN1cO2 +bBlAdE594iCnM0AIX+XmX6czQCWA2N6bojNAdF2XuUcVVb4AAMLAVj/8P/iHPAHyvf4/UOgX0CbF7j8AAAjGVj/8P01dbGU11hw/yxSZirFsGUDjgcEjGqczQKIXZSlZ +pzNAYDXS2JSiM0DeIfouQBVVvgAAWFIUQfw/+Awa/sK9/j9ASB7gwMXuPwAAoFcUQfw/QCBsYGHWHD8VyDkkp2wZQL5OBqQMpzNAvlghrEunM0AIYoLKhqIzQAi2URcx +FVW+AIBBc49E/D+QWsBkZb3+P6Cc4TP1xu4/AACGeI9E/D8mpmtWudYcP2Gk2oeSbBlAyBOCm/GmM0DQrY2oMKczQJVY1qRqojNAF6tJ3hIVVb4AAA2shUv8P0AZaOWr +vP4/4HE1ql7J7j8AAFKxhUv8P/OxakJp1xw/bnhREGpsGUAP5kZmu6YzQG09On36pjNAYF5RNTKiM0Bqw2FF1hRVvgDASvlxWfw/sI2VsT+7/j9An6jRNM7uPwAAkP5x +Wfw/jcloGsnYHD9vFM8jHGwZQIyDKmtOpjNA9sMHlo2mM0Ca67jFwKEzQI6IWnhcFFW+AJCwAEp1/D/ACQBhgrj+P6B3cwju1+4/AID1BUp1/D/A+GTKiNscPx0//EKM +axlAcmiAM3KlM0CU/pqGsaUzQKsGd6XboDNAMkWtcmYTVb4ASF6196z8P9iJlnlzs/4/wDtO+5Pr7j8AIKO696z8PyZXXSoI4Rw/sFoL05tqGUBqWZ3HsKMzQIX61mzw +ozNANDv3aQifM0Bluc7CcBFVvgBw+EhJHP0/CIIeiv+q/j8wBqojrRPvPwDQPE5JHP0/8xNO6gbsHD8s777Wc2kZQAvnUkcKoDNAAaROl0qgM0AKeEhRPpszQAYnvCBf +DVW+AGjyu8H6/T9gum6rl6D+P8AIROsNZ+8/AMA1wcH6/T+NjS9qBAIdPw/SJ5zlaRlAvGxd8jCYM0B/uIGxcpgzQLWwDOsdkzNAkofqUKUEVb4ABVaz7bb/P2C0HpyX +pP4/8NB+XCoN8D8ALJe47bb/P8CA8mn/LR0/mB9pztR0GUCeFmVdX4YzQH0iD16khjNANB0Q0b6AM0BCgzdm6/BUvoBN7Ya2lQFAMG5qYAAH/z8og+WDqdjwPwBri4m2 +lQFAspijioxVHT/RkWNj8YgZQF6qhlkGdDNAMMJ1tE50M0DHS95h520zQIpnrUaw3FS+AAKM68UgA0AwcjidAbz/PwCrUF8zqvE/AJcn7sUgA0BQlnFCjlUdP18t9HTy +iBlABpibgQV0M0ASJLLcTXQzQMZ3eoTmbTNAhTL2WK/cVL4AAOgE1yADQHD4X+z4u/8/mN4wAT2q8T8AAIgH1yADQIuRDbKRVR0/xnUdmPSIGUApcMPRA3QzQAjlKC1M +dDNAjM2wyeRtM0BcoIV9rdxUvgAAoDf5IANAeP1eFAy8/z9gQQhFUKrxPwAAQDr5IANAAYhFkZhVHT89An/e+IgZQLwdYZQDdDNAB8rR70t0M0AGOXY+NXyYv41czJgJ +IQNAAAA4ngohA0AAgm9lMrz/P2hREAJTqvE/AAAAAMBWwD7ZgK+4nVUdP4jcMxP8iBlAvFwTwAV0M0Cpfh4bTnQzQNLKOv4UfJi/dO6dZvAgA0AAAAZs8SADQOC/LiBP +vP8/AEHINzqq8T8AAAAAgFbAPvF+hxifVR0/Bc4G7vyIGUCSRUJUBnQzQMhTMq9OdDNAR42QZAx8mL9f7pCu6SADQAAA+LPqIANAsC9KyVa8/z/g4XebM6rxPwAAAAAA +V8A+IHs32KFVHT8gKaej/ogZQFWon3wHdDNAL49Z1090M0AdhTsx+3uYv/9/dj7cIANAAADgQ90gA0Agn2QbZrz/P3gW3GImqvE/AAAAAABXwD5+c5dXp1UdP1+wxg4C +iRlAbtRXzQl0M0ALbaUnUnQzQHUmjsrYe5i/Cw4/XsEgA0AAAKxjwiADQECoX76EvP8/8C7C8Quq8T8AAAAAgFbAPjtkV1ayVR0/JQaB5AiJGUD2xr1uDnQzQP/EMshW +dDNAojAm/ZN7mL//1cWdiyADQAAAMaOMIANAiItu/8G8/z8wHQUQ16nxPwAAAAAAV8A+tUXXU8hVHT8r6OKNFokZQAMWYLEXdDNAfuYjCWB0M0DzaSFiCnuYv8Uaqhwg +IANAAAAWIiEgA0DYxPBtPL3/P4DnZU5tqfE/AAAAAMBWwD6oCNdO9FUdPzlQXNgxiRlA52D+NSp0M0Cq9F+KcnQzQCyoRCv3eZi/YqPNGUkfA0AAgDofSh8DQPCCkPww +vv8/aPyS0pmo8T8AAAAA0FbAPo6O1kRMVh0/NwAsTGiJGUCe0KE8T3QzQHxkP4qXdDNA7Q9AutB3mL9xDIIRmx0DQADA8BacHQNACBGJ4BjA/z8gbJn48qbxPwAAAADo +VsA+W5rVMPxWHT+dSHGv1IkZQMtOhT+ZdDNAzsicf+F0M0DgbxjLg3OYv2cXq/Y+GgNAAJAd/D8aA0CwT7zF48P/P/iDSbulo/E/AAAAACxXwD71sdMIXFgdP09qJWar +ihlAWnzIGy11M0CjWNtAdXUzQHI/vrjpapi/kaFUmIYTA0AA0M6dhxMDQEh1BRhmy/8/cKrHGg2d8T8AAAAAolfAPijhz7gbWx0/VyWuoFCMGUA0LY0uVHYzQM0XtR2c +djNAKdRPx7RZmL/AXbY7FQYDQADAP0EWBgNA8NOrcR3a/z8g/cU+44/xPwAAAACWWMA+jj/IGJtgHT86J8Sseo8ZQOFjer+feDNAHyFFQ+d4M0Cf+s3MRzeYv8zrABgw +6wJAAKqoHTHrAkBghnGRW/b/P4BJM/+sdfE/AAAAgHtawD5b/LjYmWsdP1Kd0iBQlRlAJroXoix9M0CTcgdRc30zQKNsw05i8pe/36yIzVy1AkAAl2zTXbUCQNjyQYYc +FQBAGIKGhrVB8T8AAACAPl7APvV1mliXgR0/L6RlmRefGUDMT/sBHoYzQPmhlg5jhjNARRHGlG9ol79+vTosl0kCQADhlDKYSQJAKPUzAxpAAEA40o/rk9vwPwAAAGCi +ZcA+KGldWJKtHT+TK20OvasZQLPHIMpjlzNA7evBrqWXM0C3jJ1rGlSWv+8VE6S0cQFAQG5Rq7VxAUAw2skmVXcAQPDyV1dRFvA/AAAAkOVzwD7eQOA2rvAdP6gdejOb +rxlAYQ1KBj6wM0D+dl5ge7AzQLV4wwoDrpS/TbZoYPInAEDAFu9o8ycAQCjXcCOehwBAkDKR9/v07T8AAAAQZojAPtnmxvSEJR4/nfTD2GynGUCQbRaWmMIzQG1ynZXS +wjNAFv9qYtthk7+SLsfJ5kj+PwDot9zoSP4/sBZfhWhkAEAQUl/txFHsPwAAAMCFl8A+duSUrIYlHj95M/NvbKcZQO69jyqZwjNAeqH7KdPCM0CjFbaX0GGTv8+BDO3V +SP4/AAD4/9dI/j8caGcRS2QAQKAeG663Uew/AAAAAICXwD6x3zAciiUeP1RUTZ5rpxlAw9OBU5rCM0DIdLdS1MIzQLijTAK7YZO/0L+XM7RI/j8AAIhGtkj+P0B5GoVH +ZABAQByfL51R7D8AAAAAgJfAPifWaPuQJR4/VFsJ+2mnGUBmHUgqmsIzQN1GhSnUwjNAdftotcG9M0DsqY0ObjJVvgAASG3aSP4/WLaebEBkAECQoz7doFHsPwAAkHLa +SP4/AM/SIpYlHj9yH7/AaKcZQNUuAi+YwjNAhwmcLtLCM0AK412pv70zQBi63dtrMlW+AACMPUNJ/j+4evEaO2QAQMCvyB/OUew/AADgQkNJ/j8YzaqClyUeP/cx+2xo +pxlAE0W6p5fCM0Dw12yn0cIzQMYhnR2/vTNAlLrORWsyVb4AANAwX0n+P5wrBbA5ZABA0EG2MdpR7D8AACA2X0n+P0fJWkKaJR4/82h7xWenGUDhASmZlsIzQFsFDZnQ +wjNA3S8aBr69M0ATMa8ZajJVvgAAYBeXSf4/5BBR2jZkAEDAM7JV8lHsPwAAwByXSf4/pcG6wZ8lHj8nQqx2ZqcZQHnd/XuUwjNAvcNEfM7CM0DnrwvXu70zQGTfZsFn +MlW+AABM5AZK/j+QbrkvMWQAQPDqbp4iUuw/AACQ6QZK/j9isnrAqiUePyGdz9ljpxlA5RyFQZDCM0AKz5FCysIzQLM/zHi3vTNAnkGxEGMyVb4AABh+5kr+P+BmzN0l +ZABAkJ/7MoNS7D8AAGiD5kr+P9yT+r3AJR4/QNIco16nGUDbvgnMh8IzQPIhos7BwjNAU6DDu669M0C+HrKuWTJVvgAA8rClTP4/aMj6Rg9kAEBg72FoRFPsPwAAQLal +TP4/z1b6uOwlHj9AINBBVKcZQEah6952wjNAA8ub5LDCM0Dxd4s/nb0zQEhPZOhGMlW+AIC2EyRQ/j+cOnVN4mMAQNCNYATHVOw/AAACGSRQ/j+13PmuRCYeP/mEka8/ +pxlAdnAS/FTCM0BkuvMHj8IzQAoSgD56vTNAoCWLUiEyVb4AQIHNIFf+P2A1wCqJYwBAMOUYAc1X7D8AAM/SIFf+P4Lo+Jr0Jh4/ClA5TBenGUCzuvATEcIzQNCPOixL +wjNA1XwBGjS9M0BZiOcB1jFVvgBA9hEaZf4/vDepJdpiAECA+w4N3F3sPwCAQhcaZf4/HAD3clQoHj+Z9+yHyaYZQOQSFLqIwTNA9yJI68LBM0BPholHp7wzQJItAs0+ +MVW+AFCi3AuB/j+oVZsUiWEAQHCz2GsGauw/AMDu4QuB/j9PL/MiFCseP9w0dvc5phlABnkW4XXAM0CfXINEsMAzQLc30X2LuzNA4jf3FQ4wVb4AMIxr7Lj+PwgzhZUa +XwBAgEQhK4yC7D8AQNhw7Lj+P7WN64KTMB4/mtizLEqlGUDRnw+jR74zQOT6fWyCvjNAPrZVYEu5M0DXf6J8oy1VvgBsqAShKP8/oJwbFgpbAEAQtXfiWrTsPwDg8wmh +KP8/gkrcQpI7Hj9cg3euI6QZQG1xAj/JuTNAh8yl2gS6M0A3JulFqbQzQMeCEOupKFW+APFlbOoDAEAUQ+CTClYAQMDYe8P+Gu0/AAgLb+oDAEAcxL3Cj1EeP76spx6a +pBlAc11bGEewM0BYecdwhLAzQNCIwtjfqjNACzG1vCceVb6At/S6puIAQCRKo8gMWABAkLOeySz07T8Afpi9puIAQE+3gMKKfR4/DF4b9J6vGUCPP3tVP5szQFMGqYWA +mzNAjZS4QEqVM0DeegWt+gZVvsCHtd3gnQJAsKr0x/CHAECAig1ahtTvPwBlVuDgnQJAQc8x4xelHj/u8jEf58MZQE5Zj7ghhjNAUvl8xGaGM0Bsq5UNrn8zQEluiIXG +71S+QGmhSXYpBEB8Dzi03N4AQDh+kINp2/A/AGM/THYpBEDezP+aGaUeP2VxUDPowxlAKRF9wiCGM0Dnp5fOZYYzQKxbCRKtfzNA92pvd8XvVL4AAPhmhykEQBT8h1fh +3gBASEXNfXTb8D8AAJBphykEQBnImwodpR4/hJuVW+rDGUBAmVbWHoYzQM0dy+JjhjNAm9XuGqt/M0DcWTtbw+9UvgAAqKGpKQRAAP5KnureAEAolFxyitvwPwAASKSp +KQRAj77T6SOlHj8DdC+s7sMZQLYDtksehjNA+txDWGOGM0CJiVdpAs+Zv3NjTOK5KQRAAACu6LopBECAuhMs/d4AQMDmiqGQ2/A/AAAAAABmwD5otz0RKaUeP3Xfjujx +wxlAnT4AXiCGM0D4MS1qZYYzQF9iQd3hzpm/2hTbdKApBEAAADx7oSkEQPRuFBYL3wBAgGRp+Xjb8D8AAAAAgGbAPoC1FXEqpR4/JjZtxfLDGUA/x2jrIIYzQMzje/dl +hjNAfM9cL9nOmb8ZggCtmSkEQAAAYLOaKQRAVH3Qyw7fAECgT3iqctvwPwAAAAAAZsA+r7HFMC2lHj+FYyR/9MMZQK1uOQYihjNAs90YEmeGM0BPG5PTx86Zv1btSh2M +KQRAAACsI40pBECg8zA3Ft8AQHjemgxm2/A/AAAAAABmwD4NqiWwMqUeP5S+cfL3wxlAhkLYOySGM0DxVlBHaYYzQLRc/Bulzpm/bSjd/XApBEAAAEAEcikEQCz7Yw0l +3wBAQFD80Ezb8D8AAAAAAGbAPsqa5a49pR4/v3iI2P7DGUBA/gunKIYzQEpftbFthjNAWofBrF/Omb++Mfe+OikEQAAAW8U7KQRAGIKSt0LfAEAogzBaGtvwPwAAAACA +ZsA+RHxlrFOlHj8SFKaiDMQZQGnGS30xhjNA68dXhnaGM0DqghbO1M2Zv0eWAUHOKARAAIBlR88oBEAw0REDft8AQIggXm612vA/AAAAACBmwD43P2Wnf6UePyadoi4o +xBlAOp4sKUOGM0Cv/f0uiIYzQJFK6w+/zJm/QdJvRPUnBEAAwNNK9icEQASFnHb03wBAOAPOnevZ8D8AAAAAQGbAPh3FZJ3XpR4/86umJV/EGUDbkHN+ZoYzQDQg0H2r +hjNAZtZBkJPKmb+Ab7NIQyYEQABgGU9EJgRArMT6z+DgAEDYwf4YWNjwPwAAAABYZsA+6tBjiYemHj8yRgiQzMQZQPCqFx+thjNAxWmMEfKGM0BqsLCDPMaZv9MJ4kbf +IgRAAKBLTeAiBECIdZ5Mt+IAQNDmloAx1fA/AAAAAJxmwD6E6GFh56cePxTjnFelxRlA9vbBODqHM0D4UW4Rf4czQMGrAzaOvZm/L94yGhccBEAAwKMgGBwEQIR+nXNb +5gBA0PY3FObO8D8AAAAADmfAPrcXXhGnqh4/O+BZvU7HGUCP8+jNU4gzQC9uIXOYiDNAgWfsyzCsmb/dsFAfhg4EQAAU0CWHDgRAQPIWqYDtAED42O9JVsLwPwAAAAD2 +Z8A+HXZWcSawHj+pAL08gcoZQAq2zoGEijNAFqGSwMiKM0CyZfLXcomZv3Nftbhh8wNAALhRv2LzA0DkMEEzQPsAQIAl4tRSqfA/AAAAgMVpwD7qMkcxJbseP371xMpn +0BlA9TdMItyOM0B5b/CVH48zQBQq8kXrQ5m/4DClzg+9A0AA53rVEL0DQOgA/ZWfFAFAKIGNl7t38D8AAABAW23APoSsKLEi0R4/Y4LAVFDaGUAx7L3WZJczQDL7Lbum +lzNAabd34rO4mL9Kh+2ITFADQAD1M5BNUANA7BEdtDo/AUCQjalbRRbwPwAAAOBmdMA+t5/rsB39Hj+GXky/LOcZQD55L3XgpzNA0SGWVh+oM0BemzOi06GXv2FRuFZt +dgJAQFLYXm52AkAk3twXiHYBQKCoTyAPtO4/AAAAIACCwD5td26POUAfPwcuGCU36xlAJi0R0Je/M0Ah5RFc0r8zQGr8L83X95W/M31NmKApAUAAOaahoSkBQMxAyQDo +hwFAUBTVWVyW7D8AAADIi5XAPmgdVU0QdR8/OqWqcQrjGUDbXaiOG9EzQDhqXOdS0TNAHPJFmJ6olL8mpfbmuyMAQMAPNvG8IwBAiHSlY8FkAUCQMgnqTwbrPwAAALD2 +o8A+BhsjBRJ1Hz8djHcICuMZQCvnVxwc0TNAwg/ydFPRM0DvzQa0k6iUv+NQpWSzIwBAAADkbrQjAEDEu0mfv2QBQEBG0UVDBus/AAAAAICkwD5BFr90FXUfP8fuDDYJ +4xlAPHW2Nx3RM0Be1hyQVNEzQPjmiOt9qJS/cvQCYKIjAEAAAEBqoyMAQGRKfxa8ZAFAcEFt/SkG6z8AAAAAgKTAPrcM91McdR8/+Tw/kQfjGUBhsoLJHNEzQI42/SFU +0TNAPV/2o/LLM0BmRkHjqkFVvgAA2lO1IwBA1M0KBbVkAUAgPYnSMwbrPwAAiFa1IwBAjwVheyF1Hz+Mms1VBuMZQNUtI3sa0TNAfZIJ1FHRM0CkltJE8MszQJH2V1eo +QVW+AAAwuekjAEAALaK4r2QBQCCaJX9oBus/AADYu+kjAECnAznbInUfP23lugEG4xlAQ2ey3RnRM0CskLU2UdEzQO416aLvyzNAWwh+qadBVb4AABCy9yMAQJyIHk+u +ZAFAwAw4i3YG6z8AAMC09yMAQNb/6JoldR8//YudWQXjGUAhe8+iGNEzQE0uDPxP0TNA3RUVX+7LM0Bws8hNpkFVvgAA0KMTJABAaO45fKtkAUDwQnyjkgbrPwAAkKYT +JABANPhIGit1Hz+WPZMJBOMZQPRoAS0W0TNAJzGxhk3RM0ALnmTX68szQMo2VZajQVW+AABUh0skAEB40EDXpWQBQBCUwNTKBus/AAD4iUskAEDx6AgZNnUfPz8uQGoB +4xlAOF1EQRHRM0B8VdqbSNEzQObP4sfmyzNAfPJKJ55BVb4AADJOuyQAQFjbjpCaZAFAYMM4OjsH6z8AANhQuyQAQGvKiBZMdR8/ISKgLvziGUBoqkZpB9EzQNsaqcU+ +0TNAvbtbqNzLM0AoQKlIk0FVvgAAgtuaJQBAAHQrEIRkAUAAJOcQHAjrPwAAKt6aJQBAXo2IEXh1Hz9xOnfD8eIZQAjpPLfz0DNAA6o4FyvRM0DExT9nyMszQMhHMYl9 +QVW+AMBl9FknAEAo9mFDV2QBQOBbOu3dCes/AAAN91knAEBEE4gH0HUfP/dgeR3d4hlApITwSszQM0BSZyCyA9EzQI0x0dyfyzNA/KBvAVJBVb4AgDsf2CoAQKBonnn+ +YwFAEAeuYWIN6z8AgOMh2CoAQBEfh/N/dh8/bTiHkrTiGUCwn3hRfdAzQGrHFse00DNAA9sdp07LM0A3QqrO+kBVvgCA/ljUMQBASLomJFBjAUCwcmU5bhTrPwDAplvU +MQBAqzaFy993Hz9y6pd+ZuIZQMi4L9vezzNA0GrCbRbQM0AQDYK4q8ozQFp3PdxLQFW+AJAQXMw/AEA0HghoAGIBQEC37aCRIus/AKC4Xsw/AEDeZYF7n3ofP+VaGE3W +4RlA+hlU4p/OM0DKrS+v184zQPGtks9jyTNAJmwNxes+Vb4AvMmZulsAQPA0/V+UXwFAoE4sNwc/6z8AoHGculsAQETEedsegB8/ddctOeXgGUCY/UrIGcwzQG3sNQtS +zDNAAhG718vGM0BKreHWIjxVvgDOG7+PkwBAhMyMvYdbAUBQkp22rHjrPwBQw8GPkwBAEYFqmx2LHz/23x0OvN8ZQCOFnzntxjNAiJ2SbibHM0AI2VqXe8EzQGMYzkdu +NlW+AAPzExsDAUBQJMjqiVYBQMAv6bLa7us/ANiZFhsDAUCr+ksbG6EfPwvtDd8s4BlA14VP5xS8M0AtbpEXULwzQCXXRA1ctjNA26MiwnwqVb6AmbxeqeEBQJBc0AZv +WAFAQPxxLpDm7D8A6mFhqeEBQN7tDhsWzR8/O4dWhybrGUAAtmkTeaQzQALjCZS4pDNASA2VljKeM0CCjtcqixBVvkAu7RVGnANAyCaijaCHAUBw1vk1zgHvPwA+jxhG +nANA0AXAO6P0Hz+GbEOMYf8ZQC2OtwgljTNA0v6XzGiNM0Co/vo5YIYzQFRg7xn39lS+gKChCgYnBUDwMwNWnt4BQHA/gEtSi/A/AIBADQYnBUBuA47zpPQfP7/KqZ9i +/xlAL/CX+iONM0CsvKm+Z40zQLvGZCZfhjNA8KcG8vX2VL4AAEQdFycFQLBiO/ai3gFAAFhsWF6L8D8AANgfFycFQKn+KWOo9B8/YK9+xmT/GUDV5FbeIY0zQFVpy6Jl +jTNAo4g2/1yGM0DYRjOi8/ZUvgAAgEI5JwVAZNPONqzeAUAANVlydovwPwAAIEU5JwVAH/VhQq/0Hz/c0jcUaf8ZQAerDB0hjTNAQIGk4WSNM0ALoNf8kBObvwl1iEVJ +JwVAAABMTEonBUDAuDe4vt4BQPi1zBF/i/A/AAAAAABswD737ctptPQfP8KFbk5s/xlANy+AJSONM0DD67jpZo0zQDbXUSRwE5u/IfBfnC8nBUAAACajMCcFQAy675jM +3gFAsPQH2meL8D8AAAAAAGzAPg/so8m19B8/5W25Km3/GUB6EkmwI40zQPNyaHRnjTNA9DsLYmcTm7/XxpjEKCcFQAAAWMspJwVAbNMxTNDeAUBoWQ2pYYvwPwAAAAAA +bcA+PuhTibj0Hz8gt0njbv8ZQCFx2sUkjTNAhxnHiWiNM0CBd33dVRObv10FChUbJwVAAADQGxwnBUB8QZ6y194BQBDFHEdVi/A/AAAAAABtwD6c4LMIvvQfP5cfSVRy +/xlANb/68CaNM0Dm94G0ao0zQP+aXtQyE5u/F+nptf8mBUAAAK68ACcFQLCC6H7m3gFA8GlXgzyL8D8AAAAAgGvAPlnRcwfJ9B8/XUvDNXn/GUCFnjFHK40zQJj57Qlv +jTNAa5QTwuwSm7/0S5/3yCYFQAAAZf7JJgVAWKVCFQTfAUDo6Dv8CovwPwAAAACAbMA+07LzBN/0Hz9EJaX2hv8ZQFhqePMzjTNASRGftHeNM0DSV0idYBKbv5uE4Hpb +JgVAAICmgVwmBUBMzg05P98BQJC1we+nivA/AAAAAEBswD7GdfP/CvUfP+yZH3Ci/xlAWDtqS0WNM0B9lmUJiY0zQJBY3VJIEZu/MO28gIAlBUAAAIOHgSUFQPTDAl21 +3wFAiFXA3eGJ8D8AAAAAYGzAPqz78vVi9R8/9ED1Qdn/GUAn5974Z40zQIgchLCrjTNAnP62uhcPm7/q9t6JyiMFQABAp5DLIwVA9N5/FqHgAUB4EIjVVYjwPwAAAACI +bMA+eQfy4RL2Hz8uTFFhRgAaQFuJDUqtjTNAUjoI9fCNM0DgvjZ9tgqbvx/F0pFeIAVAAKCemF8gBUDUqItQduIBQNhyNDQ+hfA/AAAAAMBswD4TH/C5cvcfPzetOZAe +ARpAkhCJxTeOM0CK0zVXe44zQCXb1s3zAZu/NdvPeIYZBUAA0KJ/hxkFQFB9DOcX5gFAiAmZrRB/8D8AAAAAMG3APkZO7Gky+h8/iqkousYCGkCzz0EhTI8zQKEUb4CP +jzNAio4LoW3wmr9cB9Gl1QsFQAA4sqzWCwVAtCCQzjftAUCI2FONvHLwPwAAAAATbsA+rKzkybH/Hz8V+Y+Y9gUaQH5U/W1ykTNAa6ucaLWRM0CpGZMqXs2avwzsQpFx +8ARAAIRAmHLwBEC89uUK7PoBQOiKuOYvWvA/AAAAgNlvwD68tOpEWAUgP75AwkLXCxpA80eYbrWVM0Disdyh95UzQMoiTaAzh5q/LkM8VaC5BEAAI3JcobkEQBRe8Rky +FAJAYNPcM4Qp8D8AAADAXXPAPolx2wRXECA/wumVmbEVGkBUYF2aFZ4zQPy51UVWnjNA95JUh7b6mb/RErqZ3ksEQACFXqHfSwRADOjlKJA+AkCgpMbDuZPvPwAAAEBH +esA+I+u8hFQmID/2Mfy/aCIaQN9+6+5CrjNA36GopYCuM0CMGtoETOGYv71kymMDcANAQEdEbARwA0CEHgROPXUCQACDFlo6Iu4/AAAAMJ6HwD7+Vv5z4kcgPyuD04Um +JhpA2eW8pInFM0DeZKkaw8UzQEo7/NFzM5e/Ug4NfDIgAkDAtrmFMyACQOAuVbpThQJAYBoFepQO7D8AAACQyprAPvyp8dJNYiA/uKkjMK8dGkDE0OwyutYzQKkPwITw +1jNAkL3RZTThlb8Y3Ivv8BcBQMDMGvrxFwFARG5HMOxgAkDg2rUl9IXqPwAAABDvqMA+y6jYrk5iID/F0VTErh0aQHhj+7261jNAjzm1D/HWM0ABsnZoKeGVvxG7nFno +FwFAAAAsZOkXAUBEZ7Rg6mACQKD4iL3nheo/AAAAAACpwD5opqZmUGIgP0SxsuytHRpAxwYY1LvWM0BZC58l8tYzQI3+wG0T4ZW/3sa+LdcXAUAAAFA42BcBQOxBe8Hm +YAJAwM867c6F6j8AAAAAAKnAPqOhQtZTYiA/veF1PawdGkA+7F0zu9YzQExPAoXx1jNArFaF6ELRM0A8kNJ2X0dVvgAAKuLpFwFAwPgog99gAkAw411E3YXqPwAA0OTp +FwFAD573aVZiID813jD6qh0aQMj0F6G41jNAj6A08+7WM0BH3oZFQNEzQGeeDaJcR1W+AAC8Ih4YAUDwzxkV2mACQGDG3/8Xhuo/AABoJR4YAUAbneMZV2IgP2/sB6Sq +HRpAsvGL8bfWM0A1schD7tYzQBZkhZE/0TNAXwLG4FtHVb4AANQRLBgBQITznKLYYAJAENyCqSeG6j8AAIAULBgBQDObu3lYYiA/RBm+96kdGkBdm3KSttYzQJeC7+Ts +1jNA7x+BKT7RM0DHYTVeWkdVvgAA+O9HGAFAiOfFvdVgAkCgBef8RobqPwAAsPJHGAFAYpdrOVtiID/I1FqfqB0aQM0NONSz1jNA5UU1J+rWM0A8uXBZO9EzQKetC1lX +R1W+AAA+rH8YAUCc2uf0z2ACQGBMY6SFhuo/AADorn8YAUDAj8u4YGIgP9DOVe+lHRpAYG+jV67WM0D1TqGr5NYzQIFyMLk10TNA5nmWTlFHVb4AAKwk7xgBQIzaa2bE +YAJAwKEr9gKH6j8AAFQn7xgBQHyAi7drYiA/cKtRkqAdGkBpJ/xdo9YzQAJt+7PZ1jNA1gEyeCrRM0C15iQ5RUdVvgCADBXOGQFA1KhzVq1gAkAgPPuk/YfqPwAAtBfO +GQFA9GELtYFiID9G7F/klR0aQER8tWiN1jNAAeq3wsPWM0AQpT30E9EzQC8kJQwtR1W+AIDX84sbAUCov31qf2ACQECllC/zieo/AACB9osbAUDlJAuwrWIgP2e3zbiA +HRpAiENIdmHWM0DncVLYl9YzQCuJd+Tm0DNAUcSzqfxGVb4AYJ2pBx8BQFDcVWIkYAJA0PCj+N6N6j8AgEasBx8BQMaqCqYFYyA/p+GnIlcdGkA0m/JxCdYzQHoLEuQ/ +1jNAUCN6pYzQM0DaRg7Dm0ZVvgDgzfX+JQFAwF7mj3FfAkBAqNFZuZXqPwDAdvj+JQFAibYJkrVjID8/PSP4Bh0aQJ4GfetY1TNA6PbdfY/VM0CPed2p188zQCDB3W7Z +RVW+ABjwD+0zAUCcaBLZGF4CQFB+U1V5peo/AMCYEu0zAUAOzgdqFWUgP1kbsJhyHBpAa4996PXTM0ACPr27LNQzQF2DM71rzjNA2e8RrFJEVb4AHL1Ex08BQHTwPNia +WwJAUG4/GCbF6j8AsGVHx08BQBj9AxrVZyA/UBA1JXkbGkCAydMSKNEzQCxZPmlf0TNAgOrTFozLM0BNlirGPEFVvgC88HxzhwFAbKd4NGpXAkDgJSYIMgXrPwDgmH9z +hwFALFv8eVRtID9adU0oPxoaQPNDC25tyzNACYJ00KXLM0AfUp7brcUzQAN9+cPvOlW+AFnMkan2AUBEwJQOJFICQLA2UGMNiOs/ALhzlKn2AUBVF+05U3ggPxoz8OuN +GhpAUWxYaH6/M0B+i/34uL8zQCJR+9h3uTNAuWjOPNMtVb6AOE8AgNQCQDjwNr52UwJA4II4oKCY7D8A8PQCgNQCQKePzrlQjiA/pyhL90AlGkAwmYqzyqUzQLxSefYJ +pjNAwuyTBzefM0BFCW3QohFVvgCeOGB5jQRAEBA+oniBAkBgAZmQruPuPwDT2mJ5jQRALx4nSheiID9/0vKnODkaQEvKwcqsjDNA8+mapPCMM0BmQqJXm4UzQOPU07Ij +9lS+gOfpv4cWBkCUnajmVNcCQIhSOoKvkPA/AKqIwocWBkD+HA4mGKIgP/LiVLg5ORpAi6Q7qauMM0CPq0mD74wzQPblqzCahTNA4TIddiL2VL4AAJS+mBYGQFDk53lZ +1wJAKEC2bLyQ8D8AACjBmBYGQJsa3N0ZoiA/cych2Ts5GkAZny1mqYwzQCV1pUDtjDNAVXS94peFM0CcFa78H/ZUvgAA6Lu6FgZAUHGJoGLXAkCY0sFB1pDwPwAAeL66 +FgZA1hV4TR2iID//78gaQDkaQFlZh36ojDNAgYMpWeyMM0BKArzYIUacv8rhUnDKFgZAAAAUd8sWBkB4HA7udNcCQAhTSpfgkPA/AAAAAEBswD5CEi3hH6IgPyaI8ktD +ORpAJSKkh6qMM0CxE+dh7owzQKFEpbQARpy/nh0hjbAWBkAAAOKTsRYGQBiR2qeC1wJAgHX4V8mQ8D8AAAAAAGzAPk4RGZEgoiA/dYfTJUQ5GkCVKJoSq4wzQM21w+zu +jDNAuWWP3vdFnL95B+ClqRYGQAAApKyqFgZAuKe7UIbXAkBYXfokw5DwPwAAAAAAbcA+Zg/x8CGiID9a/I/ZRTkaQHPNhSisjDNAG5J8AvCMM0CfG2My5kWcv5NtXdeb +FgZAAAAk3pwWBkDMBGaijdcCQMDQAr+2kPA/AAAAAABswD6VC6GwJKIgPxas50BJORpAKadaVK6MM0Ag2+st8owzQNY9B9rCRZy/T6hVOoAWBkAAABZBgRYGQNjeK0Wc +1wJAQI4v852Q8D8AAAAAgGzAPvMDATAqoiA/QSYSD1A5GkCWmvqrsowzQPKuwIT2jDNA2VxCKXxFnL+K2DsASRYGQAAA/gZKFgZAYB98iLnXAkCQYvhbbJDwPwAAAABA +bMA+r/TALjWiID+BnFOpXTkaQP2BE1u7jDNARV5DMv+MM0DsC4TH7kScv08p34vaFQZAAACiktsVBkBsNS8G9NcCQFBqRy8JkPA/AAAAACBswD4n1kAsS6IgP11IidV4 +ORpAeFepuMyMM0AX4KyMEI0zQClmNQPUQ5y/0LeBov0UBkAAAEap/hQGQKTL4t1o2AJAMMPa3EKP8D8AAAAAUGzAPhiZQCd3oiA/D1vFDK85GkCfQWVx74wzQOeUED8z +jTNAn8hRd55BnL+85DfNQxMGQADA/dNEEwZAPE+Y/lHZAkDw+dRTto3wPwAAAABgbMA++R5AHc+iID+WS672GjoaQHM2H9k0jTNAv+YbmniNM0AjLn9SMz2cvwtccxjQ +DwZAAOA8H9EPBkAY8wEGItsCQCB3CrGdivA/AAAAAJhswD68Kj8Jf6MgP453sbnwOhpAnL2kgb+NM0AQRUspA44zQO57G9VcNJy/0nh9hugIBkAAIE6N6QgGQPj89TK5 +3gJA+K4RKG6E8D8AAAAACm3APkFCPeHepCA/WEbgB5Q8GkAX/z431I4zQA+cVawXjzNALtfNDq8inL8c0JDDGPsFQAC8b8oZ+wVAiNxYNsTlAkAIX1IFFnjwPwAAAADv +bcA+S3E5kZ6nID8SkCEfuj8aQOhO9Db7kDNAvUlcRz6RM0Ah5XJvUP+bvwLDEdd23wVAAB4N3nffBUDAzCRnTvMCQEjnvGKBX/A/AAAAgLVvwD5fzzHxHa0gPw7k9P2G +RRpAAMtjmj+VM0CYAjDjgZUzQAt1V7yHuJu/cVMkCyqoBUAABlgSK6gFQIRPflg/DANAkF2S28Uu8D8AAAAAO3PAPoiLIrEcuCA/4dtr1ThPGkC97YN/op0zQCOoBEDj +nTNAuSqE+M4qm79gQSeycTkFQICnyblyOQVAVKzKQ+81A0BAqgPb/p3vPwAAAEAmesA+2gMEMRrOID+2M2ixm1saQGT79xbVrTNA6WHH4RKuM0BiixXS7w6av+TUIFyr +WwRAAOmYZKxbBEDQ8rr1MWsDQBCCDkUHLO4/AAAAUIGHwD61b0UgqO8gP8Ij6HDPXhpAzNbBXiPFM0Dsel7nXMUzQGlnVLRfXZi/yfDhxPIIA0BAJI3O8wgDQMCYbVFY +eQNAUCIjfLQX7D8AAABAs5rAPkTFOH8TCiE/gbEZX+dVGkB1tSaEWdYzQHGUpOeP1jNAvNDSQzkIl78Ts/y8bP4BQEBwisdt/gFAUC7u6oJSA0BA2+B1lI7qPwAAANDb +qMA+E8QfWxQKIT9hCJfv5lUaQP+BYg9a1jNA6e/GcpDWM0BohGcuLgiXv3HfQBRk/gFAAADQHmX+AUBIfHKdslIDQLD5qgmIjuo/AAAAAICpwD6wwe0SFgohPw1FjRDm +VRpAz5jZJVvWM0CrJAuJkdYzQJ1SkQMYCJe/i4jJwlL+AUAAAFjNU/4BQGgGDNquUgNAENZKMW+O6j8AAAAAgKnAPuq8iYIZCiE/aiyBUuRVGkCAbhFgWtYzQDYeZ8OQ +1jNAtMYrVJjQM0DF9ElOqEZVvgAAAitl/gFAfDpjU6dSA0DAacvWgI7qPwAAqC1l/gFAVrk+FhwKIT9griAE41UaQNvgrpVX1jNAExqH+Y3WM0BDPiN5ldAzQEALWT2l +RlW+AAC0MZn+AUCE+hSvoVIDQJBa8JPAjuo/AABgNJn+AUBiuCrGHAohPxJ5AaviVRpAVGIs11bWM0A4ayc7jdYzQD85MLaU0DNAKsoFbKRGVb4AAFwRp/4BQIy9Ii6g +UgNAsNJWk9GO6j8AAAAUp/4BQHm2AiYeCiE/VB7L+OFVGkBYIiZaVdYzQMvKZr6L1jNAuexIMJPQM0C37V3JokZVvgAAnNDC/gFAMFVfLJ1SA0Awk0CS847qPwAAUNPC +/gFAqLKy5SAKIT+bx46U4FUaQM8QEmBS1jNAx/ndxIjWM0DTxHIkkNAzQEoXBoSfRlW+AAAkT/r+AUAcz6opl1IDQJDzwJA3j+o/AADIUfr+AUAFqxJlJgohP8yQ18zd +VRpAv6fLa0zWM0BHF67RgtYzQOw5qAyK0DNAofQ1+ZhGVb4AAA5Maf8BQHzWiieLUgNAwCx1kL+P6j8AALROaf8BQMCb0mMxCiE/1NluQNhVGkDBv8WCQNYzQIlS1ep2 +1jNAtjma3H3QM0BI2hPji0ZVvgAAWkVHAAJAVIFuMHNSA0AAUKuaz5DqPwAAAkhHAAJANn1SYUcKIT/eJ7MzzVUaQD2p1a4o1jNAAts/G1/WM0DToJp6ZdAzQNdjyLRx +RlW+AEDRNQMCAkBgur52Q1IDQIDXTNrvkuo/AAB5OAMCAkAiQFJccwohP67AiUq3VRpAuulk//jVM0BXu4V0L9YzQNiVDa800DNAvgIVUD1GVb4AYD0OewUCQLxcVtXk +UQNA4M9YBjGX6j8AgOYQewUCQPnFUVLLCiE/kmMnOYxVGkA0XUWCmdUzQC312AjQ1TNAp1/A+dLPM0DXBEFm1EVVvgCw75xqDAJAKEMA2SpRA0DwpTMRtp/qPwCAmJ9q +DAJAp9FQPnsLIT/z4ukXOVUaQALyLw/a1DNAOCu/uBDVM0Dwl3sWD88zQG3ECBECRVW+ANjwMEkaAkAolTrvw08DQJDS7u7KsOo/AICZM0kaAkAD6U4W2wwhP4JQz8me +VBpAkPe6RlnTM0DNk5k2kNMzQBLLWW6FzTNAOoZ8YVtDVb4AmAItBDYCQJB59v8pTQNAYA5Ksh/T6j8AEKsvBDYCQLsXS8aaDyE/Q6yvcplTGkBm7yE1UNAzQH1H/rKH +0DNAbvI+oGrKM0D2+B/3BUBVvgCIrkJxbQJAuPGMBMNIA0DAJwOXdBjrPwCQVkVxbQJALHVDJhoVIT/OxAqMR1IaQHFBA1MgyjNASIRK8ljKM0CVvPtQF8QzQK2grz47 +OVW+AAnYVCbcAkDkopXsE0MDQGBMosvFpes/ADB/VybcAkANMDTmGCAhP4rqQcllUhpAh0WWsUu9M0B0CA6phr0zQMTKoAj8tjNAIA2eiSgrVb6AOXr877gDQBzAJhiX +QwNAkFotetXK7D8ApB//77gDQNClFWYWNiE//wNYRrRcGkC9dQno36EzQDDxNOIfojNAjma82wObM0C64JlbIA1VvoDNLW6mbwVA8AbXwe5vA0AwSUY7Jz3vPwBzz3Cm +bwVAdjlu9txJIT/Ra5XsRXAaQBAyS5VLhzNAfmrLapCHM0DbDtB28n8zQMHoN/oP8FS+wAIwPn/2BkDQE6zZEMYDQJDexs0fzvA/AATOQH/2BkBFOFXS3UkhP4SvDPhG +cBpAfWTwY0qHM0DQaKg5j4czQBwwDUDxfzNAlISKrA7wVL4AAGQjkPYGQLQFC2xSxgNAMM0NbS3O8D8AAPglkPYGQOI1I4rfSSE/tz0DD0lwGkBgIjkBSIczQMW+YNeM +hzNA48yF0u5/M0Bi9y0RDPBUvgAAzO2x9gZA1BWvt1vGA0AYia6rSM7wPwAAYPCx9gZAHTG/+eJJIT9Y9v48TXAaQJNu8v5GhzNAnjxJ1YuHM0BZrCx0zmSdv6bmwkrB +9gZAAABCUcL2BkB8aMdObsYDQCh9TTFUzvA/AAAAAMBnwD6JLXSN5UkhP438Zl9QcBpAi0ucD0mHM0DBf5LljYczQF6prwqtZJ2/UDxZMKf2BkAAANY2qPYGQLhnsUB8 +xgNAIBC/mzzO8D8AAAAAgGfAPpUsYD3mSSE/Y4tYNVFwGkCpzJWcSYczQFw+cnKOhzNAncDAIaRknb97ll46oPYGQAAA3ECh9gZAWOJs+H/GA0CI+8FRNs7wPwAAAAAA +aMA+rSo4nedJIT/XDzbhUnAaQGNliLZKhzNAIVIxjI+HM0CKZeJPkmSdv1TfaE6S9gZAAADkVJP2BkBE18Bnh8YDQECHzL0pzvA/AAAAAABowD7cJuhc6kkhP7mBzzhW +cBpAxB1r6kyHM0AQAa2/kYczQPB1IqxuZJ2/JOx6dnb2BkAAAPh8d/YGQJAv20WWxgNAoNz9lRDO8D8AAAAAAGjAPjofSNzvSSE/Swx851xwGkBUqiZSUYczQIh8miaW +hzNA3rGVZCdknb/08pTGPvYGQAAAFM0/9gZAyKPZ/7PGA0AgftFG3s3wPwAAAAAAaMA+9g8I2/pJIT9h07tCanAaQFczdiFahzNAlOpN9J6HM0AynUjVmGOdv8+6oGbP +9QZAAAAfbdD1BkDk2P1q78YDQGiUPKp5zfA/AAAAAOBnwD5u8YfYEEohP3Hf1vCEcBpAdQl3v2uHM0CxpxaPsIczQDp64LV7Yp2/fV8XpvD0BkAAAJes8fQGQPxs5R1m +xwNA+NkheLDM8D8AAAAAAGjAPl+0h9M8SiE/O6CAK7pwGkAQ6//4joczQOvKL8LThzNAHBDac0Fgnb+WXIIiM/MGQADAAyk08wZApP5A9lLIA0DQIicwHsvwPwAAAAAQ +aMA+QDqHyZRKIT9TRNAaJHEaQLSrL2LVhzNAG92BHhqIM0AZuwLjzFudvywiWhG47wZAAEDfF7nvBkDQ7qdxKsoDQJB3DxH6x/A/AAAAAFBowD4DRoa1REshP+CMy+L1 +cRpA8l8QDWKIM0Dxa66vpogzQA9Hmo7jUp2/g4dox8HoBkAA6PTNwugGQPQEKJfQzQNAcKntlbPB8D8AAAAAxmjAPohdhI2kTCE/qUaFI5FzGkBDXyDFeokzQATxcjS/ +iTNAU7hfHhBBnb8ByLqX1NoGQACsVZ7V2gZA+IOlvPnUA0B4b5WoLbXwPwAAAACvacA+koyAPWRPIT8w2xTCpnYaQPogx8CpizNA/pT1ye2LM0Ck7es7Zh2dv6hR0N73 +vgZAAAyI5fi+BkCcbOxwwOIDQLivUtc9nPA/AAAAAHtrwD6m6nid41QhPx83ZTtRfBpAeCV0+P2PM0B6YiI3QZAzQOGYE0gH1py/cE9PsDWHBkAAMkC3NocGQNykNJIn +/ANAGPHkic1q8D8AAADADW/APs+maV3iXyE/44iQ8riFGkCYVYn5f5gzQEvbPKrBmDNAZavNKiNHnL/nrXB5kxcGQIDj0YCUFwZAxDRXEI0mBEC4HiTUownwPwAAACAT +dsA+IR9L3d91IT/RthCkepEaQAhG3qbuqDNAGcrlVi2pM0DyZ2tT8iibvzXpK1H9NwVAQOtlWf43BUB0AxivdFsEQPAPfKvzm+4/AAAAIKCDwD78iozMbZchP9Osdsu3 +kxpAKZ+2YpPAM0AkQ7/AzcAzQG4C+Irlc5m/5sGRVIviA0CAXwNejOIDQHjWYuCHZQRAwEEROOp/7D8AAADgGZfAPorgfyvZsSE/C3q0mx+KGkBfJc9gCdIzQH9nDo5A +0jNAtD1FDwscmL81GO6j6NUCQECPRa7p1QJA+PF4CVs6BEDQcEnjF/HqPwAAAHB3pcA+Wd9mB9qxIT9js+UmH4oaQGtvD+4J0jNAGuI0G0HSM0AdOH/j/xuYv9dju+nf +1QJAAAAU9ODVAkAAdNb7WDoEQGB+/kgL8eo/AAAAAIClwD733DS/27EhP2LGQz0eihpAXH+PCAvSM0A9U4E1QtIzQEyY84vpG5i/+05Wdc7VAkAAAKx/z9UCQIDJfeBU +OgRAcGR0FPLw6j8AAAAAAKbAPjLY0C7fsSE/N7sHahyKGkAgZYsnCtIzQM5WplRB0jNATq9dJwPMM0BvHmWevEFVvgAAMIzg1QJAPJfvqUw6BEDAyQEoBvHqPwAA1I7g +1QJAntSFwuGxIT+TlMMLG4oaQC6mQS4H0jNAaLPnWz7SM0AZJ4QdAMwzQHJpL1u5QVW+AACGTRTWAkBc6byBRjoEQODydBRK8eo/AAAoUBTWAkCq03Fy4rEhP1W2Z64a +ihpAlE09YwbSM0CIcwiRPdIzQCAzFU7/yzNA34x0fLhBVb4AAKgaItYCQESBn91EOgRAsF2IMVzx6j8AAFAdItYCQMLRSdLjsSE/dhK48xmKGkA7ZTPNBNIzQN+8SPs7 +0jNAgxQ2r/3LM0Ajhv2+tkFVvgAA9LQ91gJA1B+JlUE6BEDw9cprgPHqPwAAoLc91gJA8c35keaxIT/rXYl+GIoaQK1JGKEB0jNABQbCzzjSM0BSj3Bx+sszQEGnB0Sz +QVW+AAB+6XTWAkBk8zYGOzoEQCC39uDI8eo/AAAo7HTWAkBQxlkR7LEhP+c87pQVihpAaufESPvRM0B+cpd4MtIzQF9lyPXzyzNAIaT8TaxBVb4AAG9S49YCQNDe/Oot +OgRAgHXozVny6j8AABRV49YCQA23GRD3sSE/6/XAxA+KGkBXeKmX7tEzQDS2zckl0jNARJUD/ubLM0CuimlhnkFVvgAAvSPA1wJAaB8xwhM6BEDwsjSye/PqPwAAZCbA +1wJAiJiZDQ2yIT/pKYkwBIoaQI8AoDPV0TNAQPlnagzSM0ACFagMzcszQP8cT4aCQVW+AAAYxHnZAkBgCTan3zkEQGC2bqS/9eo/AADAxnnZAkB+W5kIObIhP3xJmzjt +iRpAai9DZKLRM0C48lOk2dEzQCMaqiKZyzNAIuZJyEpBVb4AYLr77NwCQHSXh0t4OQRAkAJdL0j66j8AgGL+7NwCQGrhmP6QsiE/bft7CsCJGkDuLWaoPNEzQHzZDftz +0TNAT2qWMTHLM0DXiAIt20BVvgAwm0bT4wJALLj6+6w4BECw1cPeWwPrPwBAQ0nT4wJAQe2X6kCzIT8DO92yaIkaQJnnP7xw0DNArakqNKjQM0CgnDHbYMozQDkCpHn7 +P1W+AEACSp/xAkBQVrDxIzcEQBCIw6CNFes/AECqTJ/xAkDvBJbCoLQhP4tXpgPGiBpAVCBME9fOM0AE9xHWDs8zQDIhfl6+yDNATl3HIDo+Vb4AhBUBNQ0DQLRWOd1H +NARAwHvTmRo66z8AQL0DNQ0DQEs0knJgtyE/2NHzErCHGkA5pBaHnMszQLG95ODUyzNAZK7OLXLFM0CtwIyvrzpVvgDiOP5WRANAEP0VImUvBEBQdW+i2YPrPwBA4ABX +RANAA5OK0t+8IT/1QJBrPYYaQGZe8McKxTNAoT0LVUTFM0CaZUgyvb4zQNMz/RZ8M1W+AAtDqnOyA0AQ8dUw4SgEQLB2/x7mGew/AHjprHOyA0B0UHuS3schP1+H2nEa +hhpAvAGpwna3M0DWOe3KsrczQIRDYerisDNA+Na5TJwkVb6A243dA44EQOwtJM1DKARAYF9kTwlQ7T8AcDLgA44EQFXLXBLc3SE/c7s0Dd2PGkAP1h42nZozQLNh7IPe +mjNA8kSxzX2TM0BOWaxFDAVVvoDXxFMmQgZATBg6iC9UBEBwhi5d/eLvPwB8ZVYmQgZAvVS1oqLxIT+iiC+X4aIaQKWrRezSfjNAg4MLThl/M0BRbPo6N3czQKN82emv +5lS+QBGJCIrGB0CgsyL1w6kEQGh3M83eLvE/AOYlC4rGB0CMU5x+o/EhP17BSZziohpAfWXWrdF+M0AZbdYPGH8zQAcNLPc1dzNAGlUqjq7mVL4AALjRmsYHQOyyGIzI +qQRAAFPbAe0u8T8AAEjUmsYHQClRajal8SE/9DCGpuSiGkANQ/Ywz34zQG6qapMVfzNAm7mNbzN3M0BXU8rWq+ZUvgAAFGS8xgdADKkoutGpBEBQKD1rCS/xPwAAoGa8 +xgdAZEwGpqjxIT+Qhg276KIaQDDfcxzOfjNAIM0afxR/M0AE3r7XGG+ev3MdjWfLxgdAAACebczGB0BMqokW5KkEQIAJF8EVL/E/AAAAAEBhwD7QSLs5q/EhP1MwXsrr +ohpA82IBOdB+M0DoikWbFn8zQOxd/Sv3bp6/YPFdGrHGB0AAAG4gssYHQDimdNvxqQRAwNnAo/0u8T8AAAAAAGHAPtxHp+mr8SE/IHI4m+yiGkCbhCbJ0H4zQL1VUCsX +fzNAr/65Me5unr/5TtkWqsYHQAAA7ByrxgdAVM5Kh/WpBEAYp4419y7xPwAAAAAAYcA+9EV/Sa3xIT+iW+c87qIaQAdccOnRfjNAmX9lSxh/M0AVujI93G6ev2Chzw+c +xgdAAADgFZ3GB0Ag6d3e/KkEQNgRL1nqLvE/AAAAAABhwD4jQi8JsPEhP2ySI4DxohpAjoMBKtR+M0B3TI2LGn8zQDMMIVS4bp6/iNG5AYDGB0AAAMoHgcYHQKjfbI0L +qgRA8MeMoNAu8T8AAAAAgGHAPoE6j4i18SE/KJIVBviiGkB9tRmr2H4zQO3K0gsffzNAox7xgXBunr/vX4TlR8YHQAAAletIxgdAeN4t6CiqBEDwtLsvnS7xPwAAAAAA +YcA+PStPh8DxIT+Q8t8PBaMaQHelIa3hfjNAWVs1DCh/M0BOA1/d4G2ev5U68qzXxQdAAAADs9jFB0BMkDyUY6oEQJCL5082LvE/AAAAAABhwD61DM+E1vEhPzL6Dhsf +oxpAhrqPsPN+M0DczlgMOn8zQHEEcpPBbJ6/eBMxO/fEB0AAwEJB+MQHQKQykMbYqgRAsPV2l2gt8T8AAAAAIGHAPqbPzn8C8iE/FDvcD1OjGkDf3uS0F38zQFkmGQpe +fzNApKh2/IJqnr/AszxVNsMHQADgT1s3wwdAoNYrlMKrBEDgDXNDzSvxPwAAAAAwYcA+h1XOdVryIT8qJ2RzuqMaQBc/dLNffzNAisWA+6V/M0D9iQjCBWaev86rln+0 +vwdAANCthbW/B0AEfQ/Uk60EQOjN0g6XKPE/AAAAAHRhwD5KYc1hCvMhP63SrSOHpBpACNAwiO9/M0B8NfW1NYAzQJjxvhsLXZ6/vyytrbC4B0AAsMuzsbgHQNAAW+0s +sQRAAKrEciwi8T8AAAAA6GHAPs94yzlq9CE/oI06NRimGkC3p2yQDoEzQKVBvolUgTNAD83zDBVLnr80eB5yqKoHQADIS3ipqgdAEEpUvDm4BEAIHxRsXhXxPwAAAADV +YsA+2afH6Sn3IT+L89h7GakaQIzRSB5KgzNAUkAqr4+DM0B+HyECJieev5rgqbGVjgdAALD0t5aOB0C0FB16v8UEQJgJiwnf+/A/AAAAgKxkwD7tBcBJqfwhP3quVYWb +rhpAVq9AQreHM0CxDRQE/IczQNYINRA9352/526ptGdWB0AAuC67aFYHQOhdzqSI3gRAALqIGlLJ8D8AAABAVGjAPhbCsAmoByI/4xhDFrS3GkDOIao+apAzQOiDj2mt +kDNA5oMePEZPnb8M1/fe7uUGQAD/7+Xv5QZAxLz6MHcHBUAQc3MA+WXwPwAAAGCCb8A+aDqSiaUdIj8KsWhO3sIaQLJi6oY3oTNAL1Lan3ehM0C19m/e9C6cv714x02v +BAZAwFudVbAEBkBw6aMttTkFQEDp7yctTO8/AAAAQF59wD5DptN4Mz8iP0J9FhVDxBpAO+HmYWS5M0CFcPgPoLkzQLStIya1dpq/td/Lhb2sBEAAd+COvqwEQHAAsqv6 +PwVA4Fj2kv4j7T8AAAB4SZHAPtL7xteeWSI/ignBdAu6GkAIROTmPsszQDD+zVF3yzNAg13Lel8cmb8O4e6XKp4DQACP7qErngNAsHcxWgASBUDgIOUfNIzrPwAAAND6 +n8A+ofqts59ZIj9Pa+f6CroaQCTGUXc/yzNAQBwh4nfLM0CGVIA6VByZvwlCtM0hngNAAAC41yKeA0CoL941/hEFQECWCz0njOs/AAAAAICgwD4++HtroVkiP4HTLwcK +uhpAPEMsmEDLM0Ba0cYCecszQDiy6rk9HJm/PFs/ORCeA0AAAEBDEZ4DQIQEJO35EQVAYI9kdw2M6z8AAAAAgKDAPnnzF9ukWSI/RIHIHwi6GkCNuw2jP8szQN0T1Q14 +yzNAstvujfjEM0C0yqgXLTpVvgAA1P0hngNAeBLTW/ERBUAwnx5WI4zrPwAAfAAingNA5e/MbqdZIj9a5mOyBroaQDDeFII8yzNAY5Ju7XTLM0ByJH5c9cQzQJ+D8Kkp +OlW+AABcdFWeA0BYWY7v6hEFQMB3/MxqjOs/AAAQd1WeA0Dx7rgeqFkiPzpf/1AGuhpAjnt7rDvLM0B/N/wXdMszQHKIgIL0xDNAhbLfvyg6Vb4AAJQtY54DQEj5STnp +EQVAMJXE232M6z8AAEAwY54DQAntkH6pWSI/pmg+jgW6GkCuiUcBOsszQFVVFm1yyzNAVSSEzvLEM0ATzrzrJjpVvgAA+J9+ngNAsKPlzOURBUAgom/5o4zrPwAAoKJ+ +ngNAOOlAPqxZIj8HCe0IBLoaQEia2Ko2yzNAoIZDF2/LM0CBU4Rm78QzQM13b0MjOlW+AAC0hLWeA0Bkdff03hEFQDCpZjXwjOs/AABgh7WeA0CW4aC9sVkiP0R7DP8A +uhpAIo3e/S/LM0AFwIFraMszQK+PaJboxDNA/pW28hs6Vb4AABFOI58DQHT3hEjREQVAwGTYr4iN6z8AALRQI58DQFLSYLy8WSI/WQBU7vq5GkCPu3mjIsszQCCQjRNb +yzNAg4HA9drEM0CY/8tQDTpVvgAALuD+nwNAUM5G/bURBUBQYsquuY7rPwAA0uL+nwNAyrPgudJZIj9bYgTZ7rkaQH1L7ewHyzNAybXiYUDLM0BtW66yv8QzQEiZEwvw +OVW+AMAGArahA0Bch2CdfxEFQHAF59Qbkes/AACuBLahA0C7duC0/lkiP5Yx4d7WuRpAG7rJeNLKM0BFmYP3CsszQK1rgiWJxDNAqXMWeLU5Vb4A4C08JKUDQOQrwrcT +EQVAIEj3weCV6z8AANU+JKUDQJz836pWWiI/jHJArKe5GkDf5Vt0Z8ozQJ/TowagyjNAZhkQ7xvEM0CELe8zQDlVvgDQN4oArANAPNDuUz8QBUCgpBYfbZ/rPwDA3owA +rANAXwjflgZbIj+XmEJLTLkaQE8TBvuQyTNAsqt+tMnJM0CVheIRQcMzQMT9DzNVOFW+ANhzjLi5A0Boe3gfpA4FQCDsZ+KPsus/AOAaj7i5A0DkH91uZlwiP1cB1Yeh +uBpAUKt2R+LHM0Ain6JPG8gzQM2EapeJwTNAH1cpUH02Vb4AjFEjJtUDQMhSC7CjCwVAgJ0Ndv3Y6z8AcPglJtUDQO5O2R4mXyI/1gGXaHu3GkBMavDkfcQzQDawyYu3 +xDNAV4o+qhO+M0AudY0OxjJVvgCANWn3CwRABFV0I3gGBUCA8iIXeCbsPwDY22v3CwRAAq3RfqVkIj8zn9NJ6LUaQEX7h3OZvTNAn2XKXNS9M0Cf/LQwDLczQCLCsuI5 +K1W+AFu20HB5BEAoGQUZYv8EQIAt7m3lw+w/AMBb03B5BEAracI+pG8iP+JdquqDtRpA2X5t6WOvM0AMylxroa8zQCG7xM6QqDNAR/YiHa0bVb4AJ8BMs1MFQDxzy2ye +/QRAAH+313EI7j8AnmNPs1MFQH3ho76hhSI/8s3ggcG+GkDjRiSEVpEzQGRa3YOZkTNA816wt/iJM0BegpZ40/pUvgBxleceBQdAiGtAlTMnBUBoBEOvblvwPwDONOoe +BQdABXD8TmiZIj/Jo3V9S9EaQJ7x20uIdDNAY2QMj9B0M0DSGfkHr2wzQKr9PuRg21S+gO5GIvSGCEDMLV6BoHoFQAjbBFRnpPE/AFziJPSGCEDUbuMqaZkiPwstLH1M +0RpAyeZ5Aod0M0BvieZFz3QzQKc+QbmtbDNAIFvYfF/bVL4AAHTOBIcIQHSXEwClegVAwHy1BXak8T8AABDRBIcIQHFsseJqmSI/kzqhfE7RGkD+SbRvhHQzQLBMmbPM +dDNAfQLQG6tsM0B2cwmuXNtUvgAAxCYmhwhAWFSi/a16BUAIMyhpk6TxPwAAUCkmhwhArGdNUm6ZIj8Ey5l7UtEaQDV/7U6DdDNAS0YHk8t0M0B5mxlUYmWfv3cBtNE0 +hwhAAAA81zWHCEBU3gD5v3oFQDjFGkugpPE/AAAAAEBYwD4YZALmcJkiP61xv3pV0RpAfH/seYV0M0D13KC9zXQzQO03A25AZZ+/sIPyVRqHCEAAAHxbG4cIQExMKnXN +egVAKMLRiIek8T8AAAAAgFjAPiRj7pVxmSI/LfxJR1bRGkAPnOsNhnQzQIzuhFHOdDNAw2DaYzdln7+YmwJGE4cIQAAAkEsUhwhAjLuZDdF6BUBYQqPugKTxPwAAAAAA +WcA+PGHG9XKZIj/AelngV9EaQHBm6TWHdDNACaNMec90M0A+L4hPJWWfv+hkIiYFhwhAAACwKwaHCEAgdV8+2HoFQJgzS7pzpPE/AAAAAABZwD5rXXa1dZkiP6PxVhJb +0RpAm2LihYl0M0Dmc9nI0XQzQCS54CYBZZ+/pJBf5uiGCEAAAOjr6YYIQCQMVJ/megVAALy4UVmk8T8AAAAAgFjAPslV1jR7mSI/YMnLdWHRGkCn+MkljnQzQD216GfW +dDNAl4GF1bhkn78+TdBmsIYIQAAAWmyxhghA8NbhXgN7BUCYYwqBJKTxPwAAAABAWMA+hUaWM4aZIj8jOZ06btEaQCOcb2WXdDNA5Lbdpd90M0AF7J0yKGSfv2Rgi2c/ +hghAAAAVbUCGCEDkTZDUPHsFQIgHiOG6o/E/AAAAAKBYwD79JxYxnJkiP1jc37uH0RpAfsUU5Kl0M0DxuiEh8nQzQHZfCuwGY5+/lBpoaF2FCEAAgPJtXoUIQEwsPJqv +ewVAiGvsqeei8T8AAAAAsFjAPu7qFSzImSI/akTqnLrRGkCxyMbeznQzQOvsERUXdTNAJYLTW8Rgn7+tPb1nmYMIQADASW2agwhAoADrjpR8BUBA51dYQaHxPwAAAADI +WMA+z3AVIiCaIj9DI0TZH9IaQKbHyskYdTNAwC6U8mB1M0DbvjQvP1yfvxs14VwRgAhAAKBxYhKACEBwa38eXH4FQEjSqyv1nfE/AAAAAAhZwD6SfBQO0JoiP8hnjzzo +0hpA21pcdqx1M0BB2ymE9HUzQDwNo6U0U5+/V2JnIQF5CEAAaP8mAnkIQMQfUt3hgQVAILHYq16X8T8AAAAAgFnAPheUEuYvnCI/sDuPuXDUGkBbTvMp03YzQFVB5wEb +dzNAOyyq1B5Bn7+O8iQW4GoIQAAozBvhaghAXFnRD8iIBUBg2dEOOYrxPwAAAAB0WsA+IcMOlu+eIj8iwJzsYNcaQFwgWv0deTNAlocTamV5M0AvtfNW8Byfv41l7sOb +TghAAOazyZxOCEBcLY71AJYFQMBIs0MLcPE/AAAAAFhcwD41IQf2bqQiPwRYbiPB3BpAz9M4aKl9M0DP3lsA8H0zQBEQkMSI1J6/jYyQ2QoWCEAAHJLfCxYIQNRYPewx +rgVAAGQvjiQ88T8AAADAGGDAPl7d97VtryI/mAP5U5flGkA21qbll4YzQJ9q/NvchjNAr+V7wJVDnr9xy2D+zKQHQABU2ATOpAdA8FytxvXVBUBgb7vkI9bwPwAAAGB4 +Z8A+sFXZNWvFIj9eVHl/QfAaQJXDghvYlzNA7sji6hmYM0DJy2omUCGdvzVvA54GwgZAQLNepQfCBkBoyG6K8wUGQCgVTvEgEfA/AAAAULR1wD6LwRol+eYiP2EAwpbt +8BpAEC95U6qwM0CUd8OZ57AzQF3GgksfZpu/+Sr+cshnBUDAxKB7yWcFQHTONfP5CAZAkABoRVLr7T8AAACoKYrAPhoXDoRkASM//p1fgizmGkCs4LT3/sIzQJGzhuQ4 +wzNAkfqf4oAJmr/B+wyxbFcEQEALobptVwRAuBN7F5XYBUAwgflzokjsPwAAAABBmcA+6RX1X2UBIz/kZygELOYaQMZM/ov/wjNAGge1eDnDM0CkKW+PdQmav4jYDthj +VwRAAACk4WRXBEBIoILfktgFQGAw+ziVSOw/AAAAAICZwD6GE8MXZwEjP42jtQcr5hpAQJqQtADDM0COIxGhOsMzQCz7DeleCZq/OuwSJlJXBEAAAKgvU1cEQLwsfm+O +2AVAIO8Kw3pI7D8AAAAAAJrAPsEOX4dqASM/RP3XDinmGkDPg4ew/8IzQA+RN505wzNAUc82U328M0CgpKzAETFVvgAAjpljVwRAdMCYj4XYBUCgA3j2kUjsPwAAMJxj +VwRALQsUG20BIz+ImVqUJ+YaQGs+m238wjNAtNvjWjbDM0DcPev/ebwzQE9nmi4OMVW+AABaw5ZXBECkf2ToftgFQDDHzHTcSOw/AAAAxpZXBEA5CgDLbQEjP2r7dy8n +5hpACTT0jvvCM0CRgGV8NcMzQFuG5hx5vDNA1A3YOg0xVb4AABxopFcEQBy4aCJ92AVA8A5eUvBI7D8AAMBqpFcEQFEI2CpvASM/XdS6ZSbmGkAe/KTR+cIzQFenZ78z +wzNAufTbVne8M0DSIlJTCzFVvgAAkLG/VwRAZIiVlnnYBUCgmJoNGEnsPwAAMLS/VwRAgASI6nEBIz/aBHHSJOYaQGO5/1b2wjNAPiNlRTDDM0C7AcDKc7wzQH78PoQH +MVW+AAB2RPZXBECUYsl/ctgFQKCIr4RnSew/AAAgR/ZXBEDe/OdpdwEjP5hbn6wh5hpAkeiZYe/CM0Cs1ERRKcMzQBfdbLJsvDNA3G775f8wVb4AAB5qY1gEQOzomVVk +2AVAoNVIdQZK7D8AAMRsY1gEQJrtp2iCASM/1boDZBvmGkCKG2F24cIzQBkgl2gbwzNAO5tZgV68M0DeUf+o8DBVvgAAy7Q9WQRAgJXdDkjYBUAA9ThgREvsPwAAcLc9 +WQRAEs8nZpgBIz9iFereDuYaQOTjOp7FwjNAIGmHlf/CM0BLRX8dQrwzQEQiMy3SMFW+AECpR/JaBED8LOq3D9gFQJDdDV3ATew/AABPSvJaBEADkidhxAEjPzPlIwX2 +5RpAXX4c543CM0D9Q5fox8IzQKvR+04JvDNASHdLLpUwVb4AgHVjW14EQChU7uOf1wVAQOV+8rhS7D8AgBtmW14EQOQXJ1ccAiM/z1kBE8XlGkC225tdHsIzQIcdeHNY +wjNAp9S9lpe7M0CNR0MTGzBVvgAQMHMtZQRA5OBSosPWBUBQVCKMrFzsPwAA1nUtZQRApyMmQ8wCIz9nVRAyZuUaQLRCq90+wTNApmReHHnBM0CGzYW5s7ozQJ8scmgm +L1W+AEho8tByBEAUTRauGNUFQCDWknedcOw/ACAO9dByBEAsOyQbLAQjP2RO+2q05BpAah8NK36/M0DQcb27uL8zQH7gJ03quDNAQ2viQDstVb4A/L5pFY4EQIStN674 +0QVA0M06GKaY7D8AsGRsFY4EQDZqIMvrBiM/OP1TNYDjGkDCdOAC9rszQPBxxzgxvDNA7orHtFC1M0DCJriyXSlVvgCINQuUxARAQMDGvI3MBUAgXZ/JUensPwC42g2U +xARASsgYK2sMIz9gRq2s0OEaQBAP5ubKtDNAqdEfbAe1M0CTURDGAq4zQC+bl9+FIVW+APRLmWYxBUB0idjV98QFQOCHBDQNje0/ACjwm2YxBUBzhAnraRcjP13j0YAy +4RpAg6CPgQumM0Dd6aa4SqYzQC3loPX9njNAG74ciWURVb4AQWdHVQoGQORLfRAwwgVAQBXQXubd7j8AbglKVQoGQMX86mpnLSM/CCbfffjpGkCmP8kF+IYzQFtEjuo8 +hzNArQP3qGB/M0DR++Rrc+9UvgB3XQ4CuQdA6Pc4A6vpBUBASaYZ2tHwPwBo+xACuQdATYtD+y1BIz9qyJ9AEvwaQET38URNaTNAAnl6lZdpM0DmMuxCO2EzQEkBhe0U +z1S+AMFrT0Y4CUCg0pvvHjsGQMgTrVOpJPI/AKQFUkY4CUAciirXLkEjP6GEXTsT/BpAtSNK8ktpM0AXhxBDlmkzQPbY9+o5YTNAQYMzfBPPVL4AAJTeVjgJQJSh8Vcj +OwZASE5Db7gk8j8AACDhVjgJQLmH+I4wQSM/tfPgMBX8GkDjAvlMSWkzQNApO56TaTNAtawNOzdhM0AO846ZEM9UvgAA1Px3OAlAcBXBKCw7BkDonICm1iTyPwAAYP93 +OAlA9IKU/jNBIz9dQPYbGfwaQP6lKCRIaTNASAmhdZJpM0CpjBEBLSSgv8hrq1GGOAlAAACgVoc4CUBo7qDKPTsGQGB+PeTjJPI/AAAAAEBPwD5gf0mSNkEjP3aBMQwc +/BpA9XHqXkppM0BeivqvlGkzQJ0JjvIbJKC/Be/9qms4CUAAAPSvbDgJQFiTqwNLOwZAAHL1bcok8j8AAAAAgE/APmx+NUI3QSM/ndPB1Bz8GkAQfB33SmkzQOLEEUiV +aTNAG1cmZhckoL8a6JuPZDgJQAAAlJRlOAlACAU1ik47BkCAZ8ejwyTyPwAAAAAAUMA+hHwNojhBIz/f5NxlHvwaQFwegydMaTNAGcg/eJZpM0DZsVZNDiSgv+N111hW +OAlAAADQXVc4CUCs0i6XVTsGQGBncA+2JPI/AAAAAABQwD6zeL1hO0EjP2qV8Ych/BpAfLdLiE5pM0CII5nYmGkzQOzltRv8I6C/QTdM6zk4CUAAAEDwOjgJQCDti7Bj +OwZAqOTg5pok8j8AAAAAgE/APhFxHeFAQSM/pTGVyyf8GkDwO9JJU2kzQI8uQZmdaTNA30huuNcjoL/cUSwQATgJQAAAIhUCOAlAKCzs4H87BkBg1DuWZCTyPwAAAABA +T8A+zWHd30tBIz8Zb8VQNPwaQEuOtMxcaTNA35VmGqdpM0B8/cbxjiOgvxLsxlmPNwlAAIC9XpA3CUC0QEU4uDsGQMiA2fb3I/I/AAAAAGBPwD5FQ13dYUEjPwLAylJN +/BpAvF3O0W9pM0BvrgYcumkzQL49GGT9IqC/eeBl7Ks2CUAAwFzxrDYJQMwsXcEoPAZAyNWzvx4j8j8AAAAAcE/APjYGXdiNQSM/jMluNX/8GkCYz1bZlWkzQGIvnBzg +aTNAjfo6R9ohoL98J0wP5TQJQAAARRTmNAlAuFc/PQk9BkBgpuJvbCHyPwAAAACQT8A+F4xczuVBIz/d6Ux14vwaQKo+vN3haTNAvK8dEyxqM0A2ZYgHlB+gvyQexUtX +MQlAAADCUFgxCUAo6abcxz4GQGCiGkoIHvI/AAAAAMxPwD7al1u6lUIjPz7e4+Cm/RpAykPju3lqM0AHooTVw2ozQHzYenAHG6C/QvK/nzsqCUAAqMSkPCoJQNg0zsA7 +QgZAaBqC5UEX8j8AAAAATFDAPl+vWZL1QyM/K2SBcyf/GkATlfHNqGszQJLpMbDyazNABL965e0RoL92yo+2AxwJQAAcpLsEHAlAhA+TVP5IBkDwMaG0vAnyPwAAAABF +UcA+ad5VQrVGIz/qCLHlBwIbQCGViksEbjNAsdGEv01uM0Bdkk3Tcv+fv1maFLWR/whAABZIupL/CEDcdGlW8FUGQFAeyZfQ7vE/AAAAADhTwD59PE6iNEwjP8Uu1ehI +BxtAqtlmwLByM0D9OcFZ+XIzQKrb94yWtp+/naMhnqXGCEAA55KjpsYIQDwfjOSUbQZAYHaEkHC58T8AAAAAFFfAPqb4PmIzVyM/HN9Q3uEPG0BfqYEs4HszQFsrMRgn +fDNAM/vHHLskn79APHwuslQIQADfZjSzVAhAwLg4NUWUBkAg+TtZilDxPwAAACCqXsA++HAg4jBtIz8venDsFRobQGQoAsydjTNADY3ReeGNM0B6MuV7qACev28Py6CD +cAdAgPqfp4RwB0CU8sZ0L8IGQIgKEyLvhfA/AAAAwE5twD7T3GHRvo4jPzIz/6wXGhtAtcfXdiSnM0AXZ5h6Y6czQCnfb4jBQpy/WGaXMicUBkAAFL06KBQGQCAzSVc3 +wgZA0J3SDdXE7j8AAADgWoLAPmIyVTAqqSM/jE1v1dcOG0DNRFxe/rkzQEKpSvA5ujNAllUUOgjkmr/d4l9tJgIFQAD8fXYnAgVAvKlBDZiPBkDQtQxnQRbtPwAAAJDh +kcA+MTE8DCupIz83eDFT1w4bQKu62/b+uTNAk0GuiDq6M0BRCnnV/OOavw+QxoYdAgVAAADkjx4CBUC4aSvDlY8GQEAc38szFu0/AAAAAACSwD7OLgrELKkjP2F4sU7W +DhtAvBfaJwC6M0Ck43S5O7ozQJjqQgzm45q/R0eUuQsCBUAAALTCDAIFQHhq6y6RjwZA0KOQlRgW7T8AAAAAgJHAPggqpjMwqSM/YF25RdQOG0AQd7AY/7kzQGzPfKo6 +ujNAKhOwGUazM0CtauyNLCdVvgAAlN4cAgVA8PCOBoiPBkAguyTHMBbtPwAAOOEcAgVAdCZbxzKpIz+jFCi/0g4bQMZucbj7uTNA27LbSje6M0CMIiqpQrMzQK0KeNwo +J1W+AAAqvE8CBUCgKQEpgY8GQIAjPuN9Fu0/AADYvk8CBUCAJUd3M6kjP8rwDFfSDhtAEaP40fq5M0AqBI1kNrozQMAqWr5BszNAvk5X4CcnVb4AAJRMXQIFQFAIh1R/ +jwZAQCppc5IW7T8AAEBPXQIFQJcjH9c0qSM/OLvehtEOG0AC8QUF+bkzQFiM7pc0ujNACiG56D+zM0D0pxToJSdVvgAAZG14AgVAPBe3q3uPBkAwb9iTuxbtPwAAIHB4 +AgVAxh/PljepIz9SvLLmzw4bQBftGWv1uTNAGv6q/jC6M0AacXA9PLMzQA1BiPchJ1W+AAD+rq4CBUA0HPFadI8GQBBHTtUNF+0/AACgsa4CBUAjGC8WPakjP+5qHKfM +DhtATWYnN+65M0CDZwnMKbozQGufxOY0szNANg5TFhonVb4AAAgyGwMFQPCtzLxljwZA0CaXWrIX7T8AALA0GwMFQN4I7xRIqSM/YFT2KsYOG0DXXtjO37kzQNBTXGYb +ujNAujYDOSazM0B+FndTCidVvgAAeTf0AwVAdEghjkiPBkBge51u+xjtPwAAHDr0AwVAVOpuEl6pIz9JLcM+uQ4bQCB4kvzCuTNAEqJamf65M0D5X9nbCLMzQO3v+Mvq +JlW+AMDGP6YFBUCIGDtnDo8GQOAQe7yNG+0/AABsQqYFBUBArW4NiqkjP1Kht5afDhtAnMlnUYm5M0Azk7n4xLkzQPkb6hrOsjNAqE7ktasmVb4A4BlGCgkFQLAiB/Oa +jgZA8K1u77Ig7T8AAL9ICgkFQBczbgPiqSM/hvrAB20OG0Do2JrgFbkzQN63BJ1RuTNAgTKhfliyM0AP/11tLSZVvgBAgynSDwVAHDSxb7eNBkAAsd2x/yrtPwAAKCzS +DwVAxT5t75GqIz+gIgLsCg4bQPUtQpUuuDNANYrve2q4M0BxnYXcbLEzQAVH/2owJVW+APCeSmEdBUCQaNby/YsGQDDpCqaiP+0/AIBDTWEdBUAhVmvH8asjP8GcuqpS +DRtAbuORWF62M0BkVhOUmrYzQIOOJfOTrzNA11QKojQjVb4A+OTvfDgFQCSOFM3AiAZAsNIhNQ5p7T8AYInyfDgFQNmEZ3exriM/OyJQbhEMG0AhhBdPt7IzQEskdDX0 +sjNAvFWzk9urM0AS1MkHNh9VvgASbZapbgVAzGY1PRuDBkCQAjQ6e7ztPwAAEZmpbgVASuJf1zC0Iz8kvZmORwobQAbB0TpPqzNApTOle42rM0B9CZbhUKQzQPvWLfYc +F1W+AKn619baBUDkn4DODnsGQNA19z6nZe4/AJCd2tbaBUArnVCXL78jP2djS45zCRtA66XYBRmcM0BdXj8OWpwzQJCi+azVlDNAvROLgH0GVb4Aq0m2dbIGQBAMIM1U +dwZAwNIOKBrB7z8Afuq4dbIGQO4SMhct1SM/+EisTMkRG0DSgaosJHwzQKUU7QtrfDNAMF4l4Fd0M0AHvQ5VmuNUvkDmch1vXghAIBXUpdacBkBoatjAgU3xPwBbDyBv +XghAlKaKp/PoIz99sW3weCMbQHItJGK8XTNAzg21zwheM0BzLCI+dlUzQPlcPrlxwlS+QM6qgzDbCUB0a7oGbewGQCBvxt6/qPI/AB9DhjDbCUBjpXGD9OgjP5+mb+Z5 +IxtAndiMB7tdM0DSDV11B14zQKpiR950VTNAuUtxP3DCVL4AAHj2QNsJQMwGJn1/7AZAaEr9VM+o8j8AAAj5QNsJQACjPzv26CM/K3970nsjG0BOwVxSuF0zQHegq8AE +XjNAz2KQHnJVM0AQotVLbcJUvgAAENxh2wlAKDvJLojsBkDAUHtB7qjyPwAAoN5h2wlAO57bqvnoIz/ngKGqfyMbQHWrfyS3XTNAM7MFkwNeM0CixwSPcIygv+13d95v +2wlAAADS4nDbCUDMmLeRmewGQDif47j7qPI/AAAAAABGwD6nmpA+/OgjPyFDqYyCIxtAOrZ8b7ldM0DPe5fdBV4zQAZWkGZfjKC/aYZBEFXbCUAAAJ4UVtsJQFR2v5ym +7AZAqPM8ieGo8j8AAAAAgEXAPrOZfO786CM/cx9wUYMjG0BszAMMul0zQPT3AXoGXjNA5mtp01qMoL+XuFTqTdsJQAAArO5O2wlAbLjdFqrsBkBwjaCN2qjyPwAAAAAA +RsA+y5dUTv7oIz8HRvjahCMbQKqDEUW7XTNALHvWsgdeM0CxWButUYygv5W6ep4/2wlAAADYokDbCUAgf/gKsewGQPj6bJbMqPI/AAAAAABGwD76kwQOAekjPywn5+2H +IxtAPTMqt71dM0Ayw3wkCl4zQJm4fWA/jKC/bnDEBiPbCUAAACILJNsJQEyDnfK+7AZAiDElqLCo8j8AAAAAAEbAPliMZI0G6SM/VDw/E44jG0DZllCbwl0zQLdZvgcP +XjNAGpI8xxqMoL9JpE7X6doJQAAArNvq2glA7G+lv9rsBkCYCxPMeKjyPwAAAADARcA+FH0kjBHpIz9BydhbmiMbQJFwcWPMXTNAR6EVzhheM0CLr6KU0Yugv0gyPnh3 +2glAAACbfHjaCUBkH61QEu0GQAhs5BUJqPI/AAAAAOBFwD6MXqSJJ+kjPwMosuSyIxtADHMD899dM0COnxRaLF4zQCGwEC8/i6C/NBOKuZLZCUAAgOi9k9kJQNwKnk6B +7QZASKRdsSmn8j8AAAAA8EXAPn0hpIRT6SM/e8sD1eMjG0BL3WgPB14zQMeBVG9TXjNARKh0YhqKoL/pRtY5ydcJQADANj7K1wlAQKgXul7uBkAwHagHa6XyPwAAAAAI +RsA+XqejeqvpIz/xMlEwRSQbQH+POj1VXjNAPCXdjqFeM0Afc2PD0Iegv+BjSzE21AlAAOCvNTfUCUDsuvZPF/AGQPCHjjHuofI/AAAAAEhGwD4hs6JmW+ojP0kwCNMF +JRtA8qwDbfFeM0CIKByiPV8zQKVFFG49g6C/0qz/+w/NCUAASGwAEc0JQIyEy3t/8wZAKBksevaa8j8AAAAAykbAPqbKoD676yM/Q6t61H4mG0Adu34dKWAzQMkAoxl1 +YDNAh0F/aBZ6oL9j1kYDw74JQACUwwfEvglAEM0e9yv6BkCocQLbDo3yPwAAAADMR8A+sPmc7nruIz+WRHUjUCkbQL92pcSVYjNAw9JgT+FiM0AD5Dr/xmegv0UEzO4m +oglAAM5o8yeiCUDAiSKY9gYHQNjI9r1ecfI/AAAAAMxJwD7EV5VO+vMjP81zHchyLhtAIs79P2RnM0C6quHprmczQLp4JSAjQ6C/o4w64uZoCUAA4xbn52gJQDRF6HJb +HgdAmNtaIXo68j8AAACAxU3APu0Thg75/iM/livs+M02G0Bb5gCL1nAzQBbQAXsfcTNA8gMk25Tzn78VIzRLTPYIQIBWjVBN9ghAhKXJGM5EB0AgDBA5mM7xPwAAACCT +VcA+P4xnjvYUJD/Obtu5g0AbQFDxllIVgzNAeA0e7VqDM0DlI2VP2s2evwsEB47SEAhAAEBRlNMQCEAcZklvrHEHQPCXX/w5/vA/AAAA0KNkwD4a+Kh9hDYkPzhZuAHL +PxtA0t5W01WdM0BYMNqhlp0zQI6XX6d2DZ2/Z67CsoSyBkAAY2e6hbIGQAyc6qSJbgdAYFzOHtak7z8AAABQS3rAPqhNnNzvUCQ/8vcvwws0G0CNapP4uLAzQH6jMDz2 +sDNAB14EDdCsm791aSuKAp8FQAC1z5IDnwVApMWau8c3B0BwOc3EA+rtPwAAAMBEisA+d0yDuPBQJD9XxB89CzQbQOAYaZW5sDNAZ6np2PawM0BhPXqYxKybv/R/H5f5 +ngVAAADEn/qeBUBg40KRGzgHQIBEkcb16e0/AAAAAICKwD4VSlFw8lAkPzQU+zAKNBtAyuITz7qwM0CWIlsS+LAzQCd2Zq+trJu/TgwIseeeBUAAALC56J4FQOyisr4W +OAdAoHImytnp7T8AAAAAAIvAPlBF7d/1UCQ/OtK5GAg0G0BXAJC3ubAzQE1TCvv2sDNArrC+hs6pM0A76vlCAh1VvgAAdov4ngVAqFa9GQ04B0AwGYK68untPwAAFI74 +ngVAvEGic/hQJD+5zrGGBjQbQDETxz22sDNAhvzjgfOwM0DCeMb8yqkzQPriMnb+HFW+AABAHyufBUCoWcPeBTgHQPBq7h1C6u0/AADoISufBUDIQI4j+VAkP5sWiBsG +NBtASeJ+ULWwM0AzJ8eU8rAzQOxnLQvKqTNAPfXIcv0cVb4AAPybOJ8FQLQ0Y/EDOAdAMAmmSVfq7T8AAKCeOJ8FQOA+ZoP6UCQ/O7s8RQU0G0CFbe11s7AzQMppjLrw +sDNA3jP6J8ipM0Ah8/Nr+xxVvgAAdJVTnwVAsJbFFgA4B0AAzi2hgertPwAAEJhTnwVADzsWQ/1QJD8rgdaYAzQbQDwSxMCvsDNAaH4QBu2wM0BeXY1hxKkzQCAHQ173 +HFW+AABSiImfBUAAj2ti+DcHQBCJ0FDW6u0/AAD4iomfBUBuM3bCAlEkP+z6y0AANBtA75RXVqiwM0CZ5f6c5bAzQCv3mdS8qTNAT5DFQu8cVb4AAOht9Z8FQIw4PP3o +NwdAIMBisn/r7T8AAJBw9Z8FQCskNsENUSQ/Xn++k/kzG0BagReBmbAzQNqtdMrWsDNA3EdMuq2pM0B6KVwL3xxVvgAAcDjNoAVA1J/vQMo3B0CAA7p+0uztPwAAEjvN +oAVApgW2viNRJD80l8BF7DMbQLsF+9R7sDNAPjXEI7mwM0BDbRWEj6kzQOOHz5q+HFW+AADZynyiBUCAVZgAjTcHQCB/Mjx47+0/AAB9zXyiBUCcyLW5T1EkP69dL9rR +MxtAyjhRdkCwM0Ccm/PPfbAzQDBFOhFTqTNAMXvPsn0cVb4AoBXl26UFQMASvmATNwdAsDZASsT07T8AgLnn26UFQIhOta+nUSQ/ZjtqxJ0zG0BrKT6fya8zQEunlw4H +sDNAmxLSEdqoM0CsbjjH+xtVvgDAI++ZrAVA6HXBoiM2B0AQB3ayXv/tPwBAx/GZrAVAX1q0m1dSJD/Oqu6bODMbQDE/OYrbrjNAPr8TJRmvM0AubFms56czQCsg0IH3 +GlW+ABDQWBW6BUB00OsgUjQHQMAshrCcFO4/AIBzWxW6BUANcrJzt1MkP16bGER6MhtA6Jmsxf2sM0A0IdS3O60zQBNlwUcBpjNAEm0jP+0YVb4A/GF8CdUFQNxQyaXm +MAdA0LYPTT0/7j8AIAV/CdUFQGmhriN3ViQ/D+7q4SwxG0DkeEvaO6kzQBSvN3x6qTNA8yXJHy6iM0DDFcDi0RRVvgCeoNTmCgZAyFboleoqB0DwVHVWEJXuPwAwQ9fm +CgZAIQCng/ZbJD9+08y1Si8bQLGqi7ieoTNA32Wgvt6hM0Bw7VGTbpozQCF2CRGADFW+AN3NUXR2BkB8kWtrRiIHQMACZR/4Qu8/AGxvVHR2BkCSvZdD9WYkP8+vpV1F +LhtAA/BQOgGSM0CEdtgaRJIzQLPEJH2MijNA89SnI3L7VL6A6Wcnz0wHQNTuo3CbHQdAQFVWFtFT8D8AWgcqz0wHQHM4ecPyfCQ/7uOX6TA2G0BSa+zYSHEzQIBmCrSR +cTNAirno/EtpM0BVjDjpvddUvoCX8Igv9ghATMISn/tBB0CwedLRfsnxPwCOi4sv9ghA28HRU7mQJD+AU+83ckcbQOekw3w9UjNAJ1sTBIxSM0Bs7FuOx0kzQNHEkH/m +tVS+gMCJAYlwCkCIHKNVoZEHQMho/vUILPM/AH8gBIlwCkCqwLgvupAkP+SNhihzRxtA5fRQGzxSM0C9QOGiilIzQIVzrifGSTNAtjZw/uS1VL4AADxZmXAKQOTdTdZf +kgdA8CiEuhgs8z8AAMhbmXAKQEe+hue7kCQ/kNO8CXVHG0AZMmpYOVIzQGOpe+CHUjNATiBSWsNJM0ADny384bVUvgAAoAi6cApAbEB2q2iSB0DwfJ9DOCzzPwAAKAu6 +cApAgrkiV7+QJD/qEjfMeEcbQHHTlyc4UjNAr/3gr4ZSM0ALnBL0BOygv9ETXb3HcApAAAAiwchwCkDY5GVVepIHQNBL0NxFLPM/AAAAAEA8wD7utdfqwZAkPwyO/Z17 +RxtAo9a2gjpSM0ATzJEKiVIzQFTfJ7Xz66C/80wOy6xwCkAAANTOrXAKQPx1tpWHkgdAYKfr9Cos8z8AAAAAADzAPvq0w5rCkCQ/2qtuXnxHG0CFO4sjO1IzQKrNSKuJ +UjNAJt3XG+/roL+LSYGbpXAKQAAARJ+mcApAJA8GHouSB0BY3i3IIyzzPwAAAAAAPMA+ErOb+sOQJD/sSEvffUcbQOqMM2U8UjNAkFi27IpSM0BJmzfp5eugv6LiZjyX +cApAAAAoQJhwCkCUrYIukpIHQOiqt24VLPM/AAAAAAA9wD5Br0u6xpAkPyDM4uCARxtAeF2B6D5SM0ChnI5vjVIzQLim9YPT66C/gNQvfnpwCkAAAPiBe3AKQJTY406g +kgdAcHzru/gr8z8AAAAAgDzAPp+nqznMkCQ/7fmK44ZHG0DDtRHvQ1IzQAXeM3WSUjNAnvprua7roL+Wt7gBQXAKQAAAfgVCcApA3O9FjbySB0DY/tNWvyvzPwAAAABA +PMA+W5hrONeQJD+AC8DmkkcbQMhDBfxNUjNAe0ZRgJxSM0AQmkEkZeugv7mApgjObwpAAIBsDM9vCkDQdIkA9ZIHQKB5qI5MK/M/AAAAAGA8wD7Tees17ZAkP/fKveSq +RxtAt9o3FWJSM0BHs9eVsFIzQOzTkPnR6qC/IUvyFehuCkAAQLkZ6W4KQCxeEMFlkwdA6AtfBmcq8z8AAAAAcDzAPsQ86zAZkSQ/6twNv9pHG0BvHstEilIzQKQmE77Y +UjNAbRXAoqvpoL96IUwuHG0KQADgFDIdbQpA+NsxqkaUB0DowAAWnCjzPwAAAACIPMA+pcLqJnGRJD+v/DLtOUgbQOVOq5jaUjNAzMVFAylTM0C23WjvXuegv2zaE1aE +aQpAANDgWYVpCkCUzMsDBpYHQNBcB7YGJfM/AAAAANQ8wD5ozukSIZIkP5LhKDH2SBtAS95cE3tTM0BQbqRgyVMzQL3NG3LF4qC/d3FLglRiCkAAuCCGVWIKQFSAz9x6 +mQdAiPuo+N0d8z8AAAAAVj3APu3l5+qAkyQ/1WhuZGZKG0Cn5thUu1QzQGSIm2cJVTNAsRjHHpLZoL+VFhdQ9FMKQADo/FP1UwpArBVjZz2gB0DQY3yElA/zPwAAAABe +PsA+9xTkmkCWJD99EK3cJU0bQHDk0wo5VzNA6awPqYZXM0Dk0AwjKsegv2MGxNYxNwpAANDK2jI3CkCkKSO2J60HQOCdcZgh8/I/AAAAgGxAwD4Lc9z6v5skP4rDFSYk +UhtAKqysVylcM0B3AOMOdlwzQPL+zENVoqC/Wk7wOaX9CUAAaTg+pv0JQCxzwqifxAdAcL6Uw7q68j8AAACAgUTAPjQvzbq+piQ/2q/FsjVaG0DrI3cZ3mUzQMV3pQop +ZjNAwKwQJptYoL/sDXprcooJQIB/QnBziglA3En9vYvqB0Cgj3jP4UvyPwAAAACHTMA+hqeuOry8JD+nHfncWmMbQBCZBECdeDNA+i5ExOR4M0CafIWz+omfv1hJQNzL +owhAQHkA4syjCEC8mog3hxUIQJiGGYbJdfE/AAAAEANcwD5hE/ApSt4kP7Dv2i3YYRtAE4tOdZaTM0ByMcoL2ZMzQP4h+7ZWx52/jjL0vrtDB0DAghjGvEMHQHyPR81t +DghA8PwdML1B8D8AAAAIRXLAPvBo44i1+CQ/ajarYI1VG0ANQo4CgqczQPP+NvXApzNAd62xCfNknL+Fz5Lf3S4GQEDXvefeLgZAHA+01afUB0Aw6jtkfLzuPwAAAICw +gsA+v2fKZLb4JD+HN3PWjFUbQAlos6OCpzNA4rI+lsGnM0BbnMyG52ScvyfaT+HULgZAAAB86dUuBkCMRxNMpdQHQGDZiwNuvO4/AAAAAACDwD5cZZgcuPgkP7X+/sGL +VRtAPx395YOnM0AbhE3YwqczQMP3AoHQZJy/kFHK5MIuBkAAAPTswy4GQBTWvTig1AdAMCs5QlG87j8AAAAAAIPAPpdgNIy7+CQ/yO4emYlVG0C7VSXIgqczQMH3qbrB +pzNA4du1jmmgM0BdtSny6xJVvgAAuHnTLgZABFg6EpbUB0CwjhzDarzuPwAAXHzTLgZAA13pH774JD/8+5/6h1UbQGpO8Dd/pzNArZ8bK76nM0A95mfuZaAzQGhNZw3o +ElW+AACixwUvBkDk4hh2jtQHQGCQrSa8vO4/AABIygUvBkAPXNXPvvgkP+BeI4yHVRtAz3WtRH6nM0BZOgU4vaczQD4k2vZkoDNAgz+YA+cSVb4AAMAxEy8GQKwzz26M +1AdAcJz22tG87j8AAGA0Ey8GQCdarS/A+CQ/VD0yr4ZVG0CPuCZefKczQNRj11G7pzNAzJS9B2OgM0CKBPnv5BJVvgAA8AUuLwZAzOJhYIjUB0Awn6BD/bzuPwAAkAgu +LwZAVlZd78L4JD/KjYD1hFUbQNP1EpF4pzNAuG91hbenM0AcMX4pX6AzQHXTs8jgElW+AABErmMvBkAskGtEgNQHQLAhhBVUve4/AADgsGMvBkC0Tr1uyPgkP/1334KB +VRtAoU/S9nCnM0BZa5jsr6czQNtW5mxXoDNAE4UOetgSVb4AAMf+zi8GQBwQEBBw1AdA4BeJuwG+7j8AAGgBzy8GQHA/fW3T+CQ/WkqmoHpVG0BBguzBYaczQAH0ebqg +pzNAvFhS80egM0B4OVjcxxJVvgAAIJ+lMAZAzOyctU/UB0Awm4oQXb/uPwAAwKGlMAZA6CD9aun4JD+xrVbobFUbQPXyjlZDpzNANlqrVIKnM0CURZn+KKAzQKH3PJ+m +ElW+AMAb3VIyBkBMWcA5D9QHQJCfat4Twu4/AAC931IyBkDZ4/xlFfkkP2OmOKhRVRtAiHyMeQanM0CA9MeCRaczQOE+4w7rnzNAt01MHmQSVb4AYD5OrTUGQMQDACaP +0wdAcLSTCYLH7j8AgOBQrTUGQLpp/Ftt+SQ/Bzaz6RtVG0CMA26mjKYzQBAz7MXLpjNA1YprFm+fM0CyhIYB3xFVvgDwFgViPAZAfEDzjJLSB0CwsDKdYNLuPwBAuQdi +PAZAfXX7Rx36JD8eExNxs1QbQJF66ZuYpTNADWz/59elM0ArX2zBdp4zQBc7ilzUEFW+AIhTxMpJBkCczzWJp9AHQOAH6bYm6O4/AKD1xspJBkACjfkfffskP8ILGX7u +UxtAZOK29q6jM0CcdkWc7qMzQFK5JYiEnDNAarvXZb0OVb4AfP6CmWQGQGwTBeAJzQdA4PFentYT7z8AUKCFmWQGQAy89c88/iQ/HnWm95NSG0Cj1VJz1Z8zQH/E9cwV +oDNAY5wt4JmYM0DZC9PNiApVvgCYsdErmgZAnILqNK3GB0AgIqGOxGvvPwDoUtQrmgZAIBruL7wDJT9D03a0l1AbQHgl0MUJmDNA/OwcjEuYM0CCNkr4q5AzQIclkDUF +AlW+AIDqPyIFB0B8o4pfWL0HQKidtb7pDvA/AMCKQiIFB0BJ1t7vug4lPwW6oSpeTxtAjgocuhGIM0DCfGdrVogzQHkKi7ZvgDNAyQJjdpbwVL6ALIIiS9oHQDwTIb6W +twdAkHth60jF8D8APiAlS9oHQJtOwG+4JCU/xyFEittWG0B+ZmAurmYzQGEUifn4ZjNAyIFj1IReM0BGNJFJK8xUvgA0sTM5gQlAtMcCZsraB0Dw2nNumULyPwC8SjY5 +gQlAI90YAH84JT/SiMOarmcbQKB4yu8TRzNAybtAgWRHM0BkBoE8cj4zQCfC3Tq7qVS+AMHvQlD5CkAELPOZ3SkIQACGZV+Dq/M/APqERVD5CkDy2//bfzglPx4ah4av +ZxtA+Q5ciBJHM0Ce/xMaY0czQBX2389wPjNAbEJZs7mpVL4AADiBYPkKQORWCu7hKQhAoDVAaJOr8z8AAMiDYPkKQI/ZzZOBOCU/owsWXrFnG0Co4n25D0czQIQuuUtg +RzNA1H2c9m0+M0D60U6ktqlUvgAAxP2A+QpApF9dluopCEAY+QR6s6vzPwAAWACB+QpAytRpA4U4JT+kqUENtWcbQMafJYcORzNA1uWYGV9HM0CuY8BYjkOhv8CbrGqO ++QpAAADcbY/5CkB0+UPn+ykIQNiAmiTBq/M/AAAAAEAzwD420R6XhzglP31FjdC3ZxtARtHu8RBHM0DBBfGDYUczQPWmHwV9Q6G/33QBWHP5CkAAADJbdPkKQFy8jeMI +KghAgO/PiaWr8z8AAAAAADPAPkLQCkeIOCU/neohjbhnG0BYk/CWEUczQCKh1ChiRzNAychJZnhDob+6SdMfbPkKQAAACCNt+QpApPfhWQwqCEAQkl0tnqvzPwAAAAAA +M8A+Ws7ipok4JT82m0UGumcbQPub8+ASRzNAeFybcmNHM0BD0J0ob0Ohv2mVdq9d+QpAAACosl75CkAMHHBGEyoIQKBZfnSPq/M/AAAAAAAzwD6JypJmjDglP9pia/i8 +ZxtARcj2dBVHM0Cw7iUGZkczQDx2RK1cQ6G/vvi6zkD5CkAAAOzRQfkKQIx57h4hKghAIPfgAnKr8z8AAAAAADPAPufC8uWROCU/LI8w3MJnG0AFjfGcGkczQGqBLy1r +RzNApx6MtjdDob/l7zoNB/kKQAAAbRAI+QpArJZzzTwqCEBAaiogN6vzPwAAAAAAM8A+o7Oy5Jw4JT9gdaGhzmcbQNLHuOwkRzNAoGAUe3VHM0Dh5ATJ7UKhv6ClF4qT ++ApAAIBKjZT4CkCc0J8gdCoIQCAqzlzBqvM/AAAAACAzwD4blTLisjglP/xDHiTmZxtABgiOizlHM0B/CyUWikczQChjnO1ZQqG/7VpEg6z3CkAAwHeGrfcKQBQChJ/i +KghAeNJY3tWp8z8AAAAAMDPAPgxYMt3eOCU/50iKBxVoG0A83lPGYkczQGI+YkmzRzNASQhkNTJBob/yTGxz3vUKQACgoXbf9QpAZEyZ/74rCEAI1ngC/6fzPwAAAABQ +M8A+7d0x0zY5JT97115IcmgbQEw8TjC1RzNA5XJNpAVIM0Cq/Fy/4j6hv8pKAUtC8gpAAPA6TkPyCkBUt+ZJdS0IQMA01M5RpPM/AAAAAJwzwD6w6TC/5jklP+YpkLMq +aRtAXI8I1llIM0BU5fErqkgzQBSmLb1DOqG/flOX1wnrCkAAiNnaCusKQKy6gQ7YMAhA0M98d/mc8z8AAAAAIjTAPjUBL5dGOyU/uQC0PJNqG0CU8OlookkzQFs/yYLy +STNA81kIYgUxob+MDC1pmNwKQAA8gGyZ3ApAxJIQk3Y3CEAYFLsEUY7zPwAAAAAzNcA+PzArRwY+JT9Fofp9Q20bQKFVEK8wTDNAbABiUYBMM0CZZXBehx6hv7+ej4Oz +vwpAAJ4Eh7S/CkDsHnZfGUQIQKB1MvAgcfM/AAAAgE83wD5TjiOnhUMlP20+GswjchtAaVNN0kFRM0C4d5mHkFEzQIlzIo6G+aC/htQVPuKFCkAA3s1B44UKQPTnPWgE +WwhASCLdFkM38z8AAACAgDvAPnxKFGeETiU/lb1tGft5G0BJ9VsdN1szQBc51QCEWzNATc8VBnWvoL/oE4LZJhIKQADTvd0nEgpA/CMTut5/CEAApQ0bicXyPwAAAAC8 +Q8A+zsL15oFkJT+15nQSsoIbQNSosOlybjNAlmp0SbxuM0A6g8QuKhugvwsNE+lxKglAgA9N7nIqCUB8mIFM1KgIQKi4zUrh6fE/AAAAMKBTwD6pLjfWD4YlP/lFgmKV +gBtA/3oIeB+KM0Ckw0LJY4ozQFIyINuocZ6/Tycx68vIB0AAqtjxzMgHQKQ+jRHnnghAWAi8utSt8D8AAAAweGrAPjiEKjV7oCU/Xfg/qdtzG0AAFnF4j54zQIW3pA3Q +njNAZ7al5LINnb+AdqHCs7IGQECdVsq0sgZARDhvxBdjCEBguN012ojvPwAAAHBSe8A+B4MREXygJT+0pI4b23MbQByyxR2QnjNAyx3bstCeM0DPz8NUpw2dv1r6OLqq +sgZAAADswauyBkB0lXoqFWMIQLCWlHXLiO8/AAAAAIB7wD6kgN/IfaAlP2TGJwDacxtAqE9uaJGeM0DKT0f90Z4zQDGDADWQDZ2/fmZoqZiyBkAAAByxmbIGQJSAffYP +YwhAACAQ9a2I7z8AAAAAgHvAPt97eziBoCU/bXRiyddzG0An0LpFkJ4zQLXuyNrQnjNAQPty3EyXM0CnNXo7IwlVvgAA2P2osgZAxOWqjgVjCEAgFOvkx4jvPwAAeACp +sgZAS3gwzIOgJT+JiHcg1nMbQDX0raGMnjNAOGJmN82eM0DBMGIoSZczQLHsf0EfCVW+AAAgCtuyBkB8943B/WIIQECftw0bie8/AADQDNuyBkBXdxx8hKAlP3VyM6/V +cxtAf4UgqYueM0BOXgY/zJ4zQDZyjytIlzNANWgIMh4JVb4AAMBi6LIGQIRcNK37YghAEIvcOjGJ7z8AAFBl6LIGQG919NuFoCU/plyzzNRzG0BIogS4iZ4zQNxQRU7K +njNA6u/oMUaXM0DDRhgTHAlVvgAA8BMDswZANCmnhPdiCEBgvj2VXYnvPwAAkBYDswZAnnGkm4igJT+etuMH03MbQB+5xtWFnjNAWxS9bMaeM0AgzJU+QpczQBlxMdUX +CVW+AABCdjizBkAM0HA072IIQOBJjEq2ie8/AADoeDizBkD8aQQbjqAlPwR8Bn/PcxtAK1wyEX6eM0A1FZSpvp4zQAoI11c6lzNAB3tJWQ8JVb4AAMY6o7MGQKQ8lJfe +YghAQO1Zt2eK7z8AAGQ9o7MGQLhaxBmZoCU/bSVUcMhzG0CpeaeHbp4zQD8A4CKvnjNAyo/3iSqXM0DwZRBh/ghVvgAAGsN4tAZA3NgabL1iCEAQOreZyovvPwAAusV4 +tAZAMDxEF6+gJT+ZuQ5funMbQEAhCXNPnjNAqorvE5CeM0Ae7rDsCpczQEOo+W7cCFW+AMD+0CO2BkAUXiFOe2IIQBCVeIGQju8/AACf0yO2BkAh/0MS26AlPz4f92ye +cxtAmpuqQxGeM0CF6e3vUZ4zQMxfBazLljNAmGE6hJgIVb4A4LnhebkGQDSi5fX3YQhAoIoL3RyU7z8AgFrkebkGQAKFQwgzoSU/mrhGSmdzG0BZA2rMlJ0zQPyUa4/V +nTNAO+U4Ek2WM0DZvHiUEAhVvgAQ3dYlwAZAzL/b0vRgCECAOxzEN5/vPwAAftklwAZAxZBC9OKhJT/GfXEI/HIbQOfR+HubnDNATNCIbNycM0BF6Oh8T5UzQBjECUwA +B1W+ADgZD33NBkBMKwu3/F4IQMDvNk92te8/AAC6EX3NBkBKqEDMQqMlP/JHkX8xchtALwxIVKeaM0A7TTyg6JozQINVYMxSkzNAU5GCGN4EVb4AOHqxKOgGQOTHU81E +WwhAgKPCQxbi7z8A0Bq0KOgGQFTXPHwCpiU//P5nv8twG0CskDrxuJYzQEGaE/X6ljNACXJJW1OPM0B5fvsukwBVvgCw3450HQdA/PDEX7NUCEAABtd88B3wPwDAf5F0 +HQdAaDU13IGrJT8Rs1HRuG4bQCoH5BjEjjNA2KLskAePM0DRDe91PIczQM3ycpPj91S+ADbsOt2HB0AsjMIA9EoIQHgRAhrOePA/ADSLPd2HB0CR8SWcgLYlP/G/dhVR +bRtA078kA3x+M0DHGcx0wn4zQBQh9IWwdjNAnhvWRR/mVL4AU1M151sIQKxICkFZRAhAqOZ1W78y8T8AGPA351sIQONpBxx+zCU/F4AKsG50G0AGmShfgVwzQBkYSQbO +XDNAtGk/Ry9UM0BOUPSlEsFUvgC8G7aKAApALLbAysplCECA+QVvzbbyPwDgs7iKAApAa/hfrETgJT+osrbe54QbQF4bfjppPDNA63rtvrs8M0CP/WZ2nzMzQD2bWiIc +nlS+QGOpxYR2C0DUo4OMN7MIQPDY0zBVJfQ/ACk9yIR2C0A690aIReAlP9Vbf8bohBtARFfLzWc8M0CuWn1SujwzQGotiQSeMzNAH302lRqeVL4AACzslHYLQCzy5c07 +swhAYEnVdWUl9D8AAMDulHYLQNf0FEBH4CU/yHkYluqEG0DcfmT0ZDwzQD7Km3m3PDNAVj7MIJszM0Br2ex6F55UvgAANDm1dgtAJDLPUESzCEDYKef/hSX0PwAAyDu1 +dgtAEvCwr0rgJT8fb1g17oQbQBxmfsFjPDNAnMXtRrY8M0Daa+Obr5Ohv4VYk2PCdgtAAAA2ZsN2C0A8M+JWVbMIQFiD0LCTJfQ/AAAAAEAqwD5+7GVDTeAlP2xds+zw +hBtANME/O2Y8M0DjUjvAuDwzQCsiezWek6G/YmWQM6d2C0AAADQ2qHYLQDyTDRtiswhAKBARa3cl9D8AAAAAgCrAPorrUfNN4CU/t+oYpvGEG0DwZz/kZjwzQDMYHGm5 +PDNAGEKjkZmTob9GF4/zn3YLQAAAOPagdgtAhN5qgmWzCEAoQQjhbyX0PwAAAAAAKsA+oukpU0/gJT9lb94Y84QbQOw2PjZoPDNAbyTduro8M0DbRvNJkJOhv7UejHOR +dgtAAAAwdpJ2C0CENAtRbLMIQKBH/MxgJfQ/AAAAAAAqwD7R5dkSUuAlP6n1R/71hBtA+N042mo8M0CFRlxevTwzQN/tkbp9k6G/rAOEc3R2C0AAACp2dXYLQMReru15 +swhA0C8GpUIl9D8AAAAAACvAPi/eOZJX4CU/DPmUyPuEG0CBUCIicDwzQEuxTqXCPDNAT7LJm1iTob+bJmtzOnYLQAAAEHY7dgtAfLt+JJWzCECAa6FVBiX0PwAAAAAA +KsA+6875kGLgJT+a9BZbB4UbQCPIxbF6PDNAFSIEM808M0BpGCNeDpOhvyTWFnPGdQtAAAC8dcd1C0D8DEiIy7MIQBCH9biNJPQ/AAAAAGAqwD5jsHmOeOAlP3OKu3ce +hRtAAgdP0I88M0DsdbFN4jwzQJt1feJ5kqG/wgfkcd50C0AAQIp033QLQETNgCg4tAhACBIUiJwj9D8AAAAAcCrAPlRzeYmk4CU/A4yNj0yFG0CX72oKujwzQA0TFoAM +PTNAjFTR6VCRob8bFFdtDnMLQACA/28PcwtAbKGoyxC1CED4eyhIuiH0PwAAAACIKsA+Nfl4f/zgJT9HrYc5qIUbQO7OyXIOPTNAsoUI2WA9M0Dop/zy/o6hv1rGqltu +bwtAAJBXXm9vC0DEPcCdv7YIQIDLnk/2HfQ/AAAAAMwqwD74BHhrrOElP96RaXhdhhtAqNkuFLc9M0DNXZ1bCT4zQCWXme9aiqG/KvxfFi5oC0AAiBUZL2gLQLyJf3gT +ughAmNxCe3AW9D8AAAAAWCvAPn0cdkMM4yU/eoN8rr+HG0Byle6ZBz8zQEg/36NZPzNAw8qpkxKBob/RTLkGrVkLQAA8gAmuWQtAfCxyQ5TACECQgnZBbQf0PwAAAABv +LMA+h0ty88vlJT9s7ptfY4obQOsFBrSlQTNA/aWEQ/dBM0DnY+eUgG6hvxmMqeioPAtAACST66k8C0C8POwD/MwIQOg1FGqI6fM/AAAAAJkuwD6bqWpTS+slP7wzd+Mq +jxtAJN56ONZGM0C4FTjVJkczQMscpudXSaG//YzzWZkCC0AA0SFdmgILQBycP4ly4whAMIIRMkSu8z8AAAAA5DLAPsRlWxNK9iU/N8UA5tGWG0BR0WUvCVEzQJhLC+9X +UTNA3bAJCff+oL9ZJB/+YY4KQIBY1AFjjgpAfGH54WkHCUBAiFrmyTnzPwAAACBTO8A+Ft48k0cMJj9/APkFLZ8bQGX5+hi8ZDNA0gMnPwdlM0BZTr4BD2qgv2tauXK3 +pQlAgAxzd7ilCUC0EQjFry4JQKBzi8DRWPI/AAAAMJtLwD7xSX6C1S0mP24t49OOnBtARh05ChSBM0DXkYoCWoEzQGVm8vyZDZ+//1+dTaBCCEDAiM1ToUIIQHx+odlh +IglAyBz14h8V8T8AAACYAmPAPoCfceFASCY/+o667XaPG0AOE5mcApYzQNAsw8FEljNAyVIPtDWonb+t+Kv0aSsHQMBj8PtqKwdAjGKv7NfkCECgn0nHEibwPwAAAKhG +dMA+T55YvUFIJj+F/xJddo8bQO+U7UUDljNAxL34akWWM0ChZFgYKqidv54OBeNgKwdAAABI6mErB0AcDc9E1eQIQEC5dzkLJvA/AAAAAIB0wD7smyZ1Q0gmP66svzt1 +jxtASPqVmASWM0BfQWO9RpYzQGsL6+ASqJ2/7KC3v04rB0AAAPzGTysHQFyh+vTP5AhA0P3aHfwl8D8AAAAAAHTAPiaXwuRGSCY/XnUh+XKPG0CuEBtyA5YzQPYmHpdF +ljNAumY7aJmOM0DzaJeFy/9UvgAAUtheKwdALGp5VcXkCEDovfBACSbwPwAA8NpeKwdAkpN3eElIJj8H0lNHcY8bQG6DY7z/lTNAmCMU4kGWM0DjjJOilY4zQE4AunjH +/1S+AABEp5ArB0DkUJleveQIQAAJGp8zJvA/AADoqZArB0CekmMoSkgmP7AgsdNwjxtAuA8gv/6VM0AL9/7kQJYzQJ8FEKGUjjNAzSY5ZMb/VL4AAHzvnSsHQPyoHD+7 +5AhA+Lx56z4m8D8AACDynSsHQLWQO4hLSCY/ndFz7G+PG0AtKJjE/JUzQAOe0+o+ljNAjvcHnpKOM0BsYTY7xP9UvgAA9H+4KwdA9E5JALfkCEDokUSEVSbwPwAAoIK4 +KwdA5IzrR05IJj+fqCkebo8bQGVYgs/4lTNAWOx29jqWM0BT3vGXjo4zQINoKum//1S+AADeoO0rB0AUW4aDruQIQIjJHraCJvA/AAB4o+0rB0BBhUvHU0gmP2UmV4Jq +jxtATLY+5fCVM0DfiqUNM5YzQLa3rYuGjjNAWr74RLf/VL4AAHziVywHQGxdj42d5AhAqGzlGt0m8D8AABjlVywHQPx1C8ZeSCY/rTm5TWOPG0DMaVcQ4ZUzQCXRojsj +ljNAu5vFcnaOM0Cfii78pf9UvgAABGUsLQdApFHcr3vkCEAQbrvokSfwPwAApGcsLQdAcleLw3RIJj8ehpjwVI8bQHW+CGXBlTNAj5EdlgOWM0DLN3Y/Vo4zQLS1/miD +/1S+AMBEZ9UuB0DsOFwtOOQIQIiyiZX7KPA/AADkadUuB0BeGou+oEgmP5nvuWY4jxtA05VrCIKVM0APWRRFxJUzQEw429IVjjNAMdcxPD7/VL4AYIRgJzIHQBQPxguy +4whAGO+pM88r8D8AgCRjJzIHQDWgirT4SCY/FeY5FACPG0BjtzU3A5UzQL28CotFlTNADB244ZSNM0ClUOfIs/5UvgBw4iXLOAdAJK/SVKniCEBwoM6BdzHwPwBAgijL +OAdA46uJoKhJJj+f/r5xko4bQDSb+TQFlDNAy6Y4t0eUM0Beh9ufkowzQPhmr3ue/VS+AFBe+xFGB0Cs1V0MpuAIQIgtVGTMPPA/AAD+/RFGB0A/w4d4CEsmP77veyPD +jRtA8ZousgeSM0BUj4eRSpIzQDx2uZ6MijNAEna2R3L7VL4ARHPLnGAHQFypIrbX3AhA8MupN4dT8D8AsBLOnGAHQPfxgyjITSY//t8/yFOMG0BFvsO6Bo4zQH+YZlVK +jjNAh+pWrnqGM0AMQ7OBE/dUvgDSdtGmlQdAvMXuIhnWCEAAGkfCQIHwPwC4FdSmlQdAaE98iEdTJj+BvFdjLYobQGBUVEDthTNAemHYVTKGM0B9HEdRP34zQPepBr48 +7lS+AN2wBov/B0CEuKtI/ssIQFCzMr3A3fA/AKhOCYv/B0BJCm1IRl4mPzOacrudiBtASnwc+111M0B5MUEXpnUzQBbGkodsbTNAwSMuXSzcVL6A3L0LidIIQEyXw+an +xAhAILM79t6a8T8AYlkOidIIQAyATshDdCY/deo1p2ePG0BK+PQc3VIzQLG0GYcrUzNAzW3UvWVKM0CPAD9ZkLZUvsDzGUMJdQpA7PY/IZDkCEDI+/736STzPwDGsEUJ +dQpAshOnWAqIJj+kGoFikZ8bQPuUM05VMjNAZqIOqqkyM0ANpzvkZikzQCUhzZwik1S+wCA1JAvpC0AsJu53hzAJQPCnxvpsmPQ/AITHJgvpC0CBEo40C4gmP2HawEaS +nxtAU+jV3FMyM0Dzc/Q4qDIzQIoDum1lKTNAAZitCiGTVL4AAJg0G+kLQIxes6iLMAlAoHEWdX2Y9D8AACg3G+kLQB4QXOwMiCY/2SFID5SfG0DPRhn6UDIzQBTPvlal +MjNAuXW1gGIpM0DTJm3mHZNUvgAAWFU76QtApGFiCpQwCUBQqcRpnpj0PwAA4Fc76QtAWQv4WxCIJj/QZWSgl58bQHomS8dPMjNAfL4oJKQyM0Css5kL+9yhv70oIEJI +6QtAAAA+REnpC0BE1ADOpDAJQGhCnBmsmPQ/AAAAAEAiwD7FB63vEogmP42cJE2anxtA8w0xT1IyM0CSQpirpjIzQH0ED5Tp3KG/A3dX9yzpC0AAAHb5LekLQLwIVWCx +MAlA+KVYMo+Y9D8AAAAAACLAPtEGmZ8TiCY/zEG2A5ufG0BlK/b7UjIzQC7OPVinMjNAIXGl6+Tcob/EgDKwJekLQAAAVLIm6QtAzPdnurQwCUAo2D19h5j0PwAAAAAA +IcA+6QRx/xSIJj+c+dNwnJ8bQPrkf1VUMjNAL2SIsagyM0BIENKa29yhv2856CEX6QtAAAAIJBjpC0CEpHNuuzAJQDgBDhN4mPQ/AAAAAAAiwD4YASG/F4gmP3357Uqf +nxtASVCQCFcyM0DgiBpkqzIzQNTxKfnI3KG/24lRBfroC0AAAG4H++gLQCTX7dXIMAlAMPDQPlmY9D8AAAAAACLAPnb5gD4diCY/fD2c/qSfG0CdB6VuXDIzQDS1Msmw +MjNAakLUtaPcob/GpxvMv+gLQAAAO87A6AtAVLBtouMwCUC4PuGWG5j0PwAAAADAIcA+MupAPSiIJj/J7+FjsJ8bQNz5nTpnMjNATpoyk7syM0AGHRMvWdyhv1jdjVlL +6AtAAACuW0zoC0CMqZsxGTEJQLiWK0mgl/Q/AAAAAAAiwD6qy8A6PogmP73IEibHnxtASvLN0XwyM0Dhm3Am0TIzQAvUOSHE26G/UVvqc2LnC0AAgAt2Y+cLQARytCiE +MQlAcPJmtqmW9D8AAAAAICLAPpuOwDVqiCY/jKMQifSfG0BWYCb9pzIzQOmp5Un8MjNAhSksBJraob/gAIWmkOULQABAqKiR5QtApCn3eVkyCUAQUnazvJT0PwAAAAA4 +IsA+fBTAK8KIJj+/qK/JTqAbQNSbukf+MjNA8lu1hFIzM0ApcavERdihv9DgSwPt4QtAAJBzBe7hC0CsW6+pATQJQPCD5zfjkPQ/AAAAAHwiwD4/IL8XcokmPzZFDzcB +oRtAG+N7rKozM0CGaPbJ/jMzQI9FTDCd06G/ryx3m6XaC0AAyKedptoLQHQhV0VINwlA+GGSaTKJ9D8AAAAACCPAPsQ3ve/RiiY/w8Hmzl2iG0BpIry0AjUzQLCCWZNW +NTNAFjTTs0vKob9iAfpIFswLQABgPEsXzAtApLeYqK49CUDwNgFs2Xn0PwAAAAAmJMA+zma5n5GNJj8mE39W9qQbQBeBBMOvNzNAa1R0JAM4M0DUCrJ5p7ehv+swJq71 +rgtAAAKMsPauC0BcabHy4UkJQBDaF81JW/Q/AAAAAF0mwD7ixLH/EJMmP1EGb9GnqRtARe0X7f08M0DFhFtWUD0zQD7CQ2xakqG/gd8pSa10C0AA69VLrnQLQKTGsufw +XwlA8Ix8ALMe9D8AAACAwCrAPguBor8PniY/1k9N3iOxG0D+tw4oa0czQCYDlam7RzNA5E2tJbFHob+0yd7KBAALQIDRFM4FAAtANCBhVx6DCUDYMVlJn6fzPwAAAGBg +M8A+XfmDPw20Jj9XXjEoLbkbQKuqCZuOWzNAhEeGbttbM0D9IfShObKgvxt1DQ16FgpAQN1NEXsWCkD0/RCZ46gJQAi3SuyhwfI/AAAAkAZEwD44ZcUum9UmPyzwUUQb +thtAlVFieIh4M0Bq8W0A0HgzQGMjDsQ/nJ+/pQsr0RGyCEAAYurWErIIQCx4EOp1mglAuGqF1rZ28T8AAABo9VvAPsa6uI0G8CY/ufKQAK+oG0CKgHif7o0zQKcDgz4y +jjNA/nYz34w1nr/2NGAO1pkHQEAOOhXXmQdA9NBreF9bCUBoUQIRVILwPwAAAJidbcA+lbmfaQfwJj95T0FtrqgbQOZdlEzvjTNAUz9/6zKOM0DHYa04gTWev2N0R/TM +mQdAAAAg+82ZB0B8Hg/EXFsJQPDLCFhMgvA/AAAAAABuwD4yt20hCfAmP7HXnUatqBtAqXbLpvCNM0DTFHdFNI4zQLG8oetpNZ6/alsWwLqZB0AAAOzGu5kHQBwFQltX +WwlAyPoc5jyC8D8AAAAAgG7APm2yCZEM8CY/glhf+aqoG0CzilZ9740zQEyDOBwzjjNAY+vFHWKGM0BKS2ch+fZUvgAAUqHKmQdAJHzPiUxbCUDgMDErSoLwPwAA9KPK +mQdA2a6+JA/wJj8mc5k/qagbQDME0rfrjTNAzWlkVy+OM0DEXWNIXoYzQCc/pgP19lS+AAAqN/yZB0CMLHptRFsJQPDBzT11gvA/AADQOfyZB0DlrarUD/AmP0Os1smo +qBtABu9XtuqNM0DiYBlWLo4zQF8UrkJdhjNANXWk6vP2VL4AACxwCZoHQJRSAERCWwlAuN5LuoCC8D8AANByCZoHQP2rgjQR8CY/WC9Z3qeoG0CzyWKz6I0zQEBUglMs +jjNAN4dCN1uGM0CC1J+48fZUvgAAMOIjmgdAfIcy8T1bCUCISlOzl4LwPwAA4OQjmgdALKgy9BPwJj8xmo4HpqgbQECdcq3kjTNARFpOTiiOM0C/jmUgV4YzQClGkFTt +9lS+AAAsxliaB0AMZHpMNVsJQPBOpaXFgvA/AADQyFiaB0CKoJJzGfAmP7j9ulqiqBtAYr16odyNM0Cg485DII4zQHYllPJOhjNAEvZXjOT2VL4AAPyNwpoHQHTRlwYk +WwlAiAhWiyGD8D8AAJiQwpoHQEaRUnIk8CY/89QZBJuoG0Cm4yyJzI0zQIvtcS4QjjNAW3OTlj6GM0A3ioL70vZUvgCA4ByWmwdABMUIiQFbCUCAKepa2YPwPwAAfh+W +mwdAvnLSbzrwJj81i+5ijKgbQNvWGFesjTNA0Ow/AvCNM0DfnxrdHYYzQM+TRNiv9lS+AEDNNz2dB0DUUL3GvFoJQPB63ApJhfA/AABrOj2dB0CvNdJqZvAmPzJR6lBv +qBtA+80P7WuNM0AUD/yjr40zQKyyS2TchTNA2qt8i2n2VL4AgDZii6AHQPwMQyU0WglA8BfkrSiI8D8AANVki6AHQJC70WC+8CY/kC7d7TWoG0D6rn0B64wzQJ+R+M8u +jTNA1HY8W1mFM0D97MDY3PVUvgCwMIknpwdAZB1SbSZZCUBwH1UA6Y3wPwBAz4snpwdAU8fQTG7xJj+dHkEpxqcbQAa8dszoizNAjgkgyiyMM0BkNXbrUoQzQNCguQ7D +9FS+ACAGH1+0B0DUOA4eGVcJQKB7bdVtmfA/AMCkIV+0B0DY3s4kzvImP4p2opLyphtA9gzK6+KJM0BBpBRIJ4ozQCN0OJZEgjNAgkJr6Y3yVL4AQF9ky84HQBxW8aY2 +UwlAKLjvNYiw8D8AkP1my84HQOINy9SN9SY/AJhelnqlG0A4fFZX0YUzQNkd9HEWhjNA/rZnHCJ+M0C9j8thHe5UvgCWiieYAwhAXPNLhU9MCUAwuPV7/97wPwBYKCqY +AwhA9mvDNA37Jj9qVsiuQqMbQJYMFh2XfTNAZdOQuN19M0DGFPUmxnUzQF6XZ54j5VS+AMRpJAFtCECEJXBe4kEJQAALiXn1PPE/AGgGJwFtCEAfKLT0CwYnP2f2KASP +oRtAUSnwO8hsM0AgGqvpEW0zQJSUDBG0ZDNA+nNtRs/SVL6AdZYEBj8JQHQVg7ziOQlAyHTKI+r88T8A0DAHBj8JQHGglXQJHCc/bYKbHQ2oG0ArBpyKz0kzQPwpPJwf +SjNA9f7SFjZBM0CZSvdHs6xUvsDxoNGJ3wpAxNqDmmZYCUB4Ub6YTYzzPwCKNtSJ3wpA+S7uBNAvJz+5QPKI7rcbQNdUxi/kKDNAVmhNRTopM0AdUd9G1B8zQAnr9kjb +iFS+AIlaz7dRDEDE8gETCqMJQPhjQnpBBPU/AKfr0bdRDEDILdXg0C8nP87q+GnvtxtAFStAuuIoM0BLfwvQOCkzQGHCO8zSHzNAYXNnstmIVL4AADTLx1EMQFxFoTQO +owlAeBQPJFIE9T8AAMDNx1EMQGUro5jSLyc/cQMOLPG3G0CdljLP3ygzQHxshuU1KTNAYmXz1s8fM0D4LEeF1ohUvgAA5MLnUQxAVGwEeBajCUDYxrZ3cwT1PwAAeMXn +UQxAoCY/CNYvJz/N5EWw9LcbQCLy6JzeKDNAiL90szQpM0AnB/Od+B+ivy27y3b0UQxAAABsePVRDECEDwv/JqMJQOBapSGBBPU/AAAAAEAawD4MI/Sb2C8nP33dWlP3 +txtAoesOMuEoM0DR6SFINykzQEkKwBbnH6K/EhCME9lRDEAAACwV2lEMQFyg7WMzowlAUOUOo2ME9T8AAAAAABrAPhgi4EvZLyc/ZnZYB/i3G0Ccklzi4SgzQK9ZT/g3 +KTNArJYpauIfor9t++DF0VEMQAAAhMfSUQxAbFXisTajCUDg5pnFWwT1PwAAAAAAG8A+MCC4q9ovJz96GE5v+bcbQJ9c90LjKDNAi7WpWDkpM0AxdvwQ2R+iv614iirD +UQxAAAAsLMRRDEAEnLFNPaMJQADNtQpMBPU/AAAAAAAawD5fHGhr3S8nP3/+Fz/8txtA7tgpBOYoM0AhVlsZPCkzQL/doF7GH6K/eVrb86VRDEAAAHz1plEMQBxVs4RK +owlA6OoQlSwE9T8AAAAAABrAPr0UyOriLyc/KFUm3gG4G0DMcoKG6ygzQM46sppBKTNAVk/k+aAfor/2u3SGa1EMQAAAF4hsUQxA/IVD8GSjCUBQbFSq7QP1PwAAAAAA +GsA+eQWI6e0vJz9GRi0aDbgbQEAsAov2KDNA65IunUwpM0ASwFUwVh+ivxz8hav2UAxAAIAprfdQDECkWZe9maMJQFh9ENdvA/U/AAAAACAawD7x5gfnAzAnP2UC5Ykj +uBtA1Ls7kwwpM0D4g2GhYikzQKPz4pzAHqK/r5wi9QxQDEAAAMf2DVAMQASBEDEDpAlA6JVcOXQC9T8AAAAAUBrAPuKpB+IvMCc/nTYCSFC4G0D3e5egOCkzQKiXsKaO +KTNA9IKndJUdor+dvEWGOU4MQAAg7Ic6TgxADJBme9WkCUBQkEIhfQD1PwAAAABgGsA+wy8H2IcwJz+SIiY/qbgbQE7y8q6QKTNAQff0pOYpM0CuPeAePxuiv2BgPqCS +SgxAAEDpoZNKDEAMZY+ed6YJQDgnNX6P/PQ/AAAAALAawD6GOwbENzEnPx+apxpZuRtANkVFmkAqM0AuIyJwliozQETYR16SFqK/6kFQs0RDDEAAQAS1RUMMQIywPCay +qQlAEOgwbLb09D8AAAAAQBvAPgtTBJyXMic/rvgck7C6G0AFzbOrnyszQDFmakH1KzNA3eiqijgNor/ZC6tYqDQMQAAwcVqpNAxA9Oz9dQCwCUCoxWQUDeX0PwAAAABi +HMA+FYIATFc1Jz976CntPr0bQBVBmLxaLjNA0O6R0q8uM0DqGHWng/qhv+72prVtFwxAAEiRt24XDEA8hwfqA7wJQAAa6nTdxfQ/AAAAAKUewD4p4Pir1jonP7CTb1Dc +wRtAGB9XrcQzM0D6QRHGGDQzQPzmcFwV1aG/6WhwYPHcC0AAaKJi8twLQLT4zm+00QlAeBqEcQmI9D8AAAAAICPAPlKc6WvVRSc/KMhqMDHJG0D+ZA9/aD4zQDCsEqa6 +PjNAWMFF6ymKob8a/px/4WcLQIDUW4LiZwtATG+4vyn0CUDgpeFMhg70PwAAAEDtK8A+pBTL69JbJz94zzDX79AbQP0oZWH1UjNA2rcax0NTM0A84QlIL/Sgv+1vj+CJ +fQpAgCpe5Ip9CkDcxPQ1kBgKQMAgYdPUI/M/AAAAwOs8wD5/gAzbYH0nP93QH2l0zRtAHA358oZwM0AeNYXxz3AzQJbUqmBQD6C/KuwKl+0XCUDAg2Cc7hcJQNSxcX0y +CApACK7ENyXS8T8AAAB4WVXAPg7W/znMlyc/JJLiKru/G0ABv+0iXYYzQCUIACSihjNAven6ELy2nr+cBkTtwv4HQMD8ufPD/gdA1NdRP7LHCUCAQtv2wtjwPwAAAGhf +Z8A+3dTmFc2XJz+YVyaVur8bQBTsk9NdhjNA7e2F1KKGM0DU8JNgsLaevyaUc8u5/gdAAADo0br+B0BEXpB/r8cJQJhJcxW72PA/AAAAAABowD560rTNzpcnP6GzqWm5 +vxtA9aDfNF+GM0BVFJE1pIYzQG2Gxv+Ytp6/BBnTh6f+B0AAAEiOqP4HQATC+f+pxwlAQLeqUqvY8D8AAAAAgGfAPrXNUD3Slyc/ht24Ere/G0AJ2AoJXoYzQOsU8wmj +hjNA84nFXbB+M0CcCqUgtu5UvgAA9DW3/gdAHDr0AJ/HCUCw+dyyuNjwPwAAlDi3/gdAIcoF0dSXJz8/K61Rtb8bQFaxVzVahjNAovLyNp+GM0CwSkV6rH4zQNzRu/Ox +7lS+AADiluj+B0A8dHDClscJQLDKcGfk2PA/AACImej+B0AtyfGA1ZcnP67l+dm0vxtALHgVMFmGM0ChduAxnoYzQDRhzHCrfjNAmViv1rDuVL4AAMjB9f4HQKwT2Y+U +xwlAaHgfD/DY8D8AAGDE9f4HQEXHyeDWlyc/y2ib6rO/G0CLD5AlV4YzQIGIuiechjNAiJjZXal+M0BCXpWcru5UvgAAmBcQ/wdAFC/QKpDHCUC40IdeB9nwPwAAQBoQ +/wdAdMN5oNmXJz8AxA4Msr8bQI94fxBThjNAlOdoE5iGM0AuRe43pX4zQOI6Wyiq7lS+AAAkw0T/B0D0jqFhh8cJQIhtmv012fA/AADAxUT/B0DSu9kf35cnP2HJtk+u +vxtA8zNH5kqGM0BNk67qj4YzQKiWAOycfjNAijnOP6HuVL4AAA0arv8HQHTb0NJ1xwlAUFXHPJPZ8D8AAKwcrv8HQI6smR7qlyc/8ugL2qa/G0D2UXqROoYzQNui3Zh/ +hjNAIRzJU4x+M0BrTlFuj+5UvgAAK8eAAAhAzO9gw1LHCUAgyD+/TdrwPwAAxsmAAAhABo4ZHACYJz+gQsn6l78bQHY5b+YZhjNA7bDK816GM0Dov+kha34zQFnmy8lr +7lS+AEB+HiYCCECESEHdDMcJQAiVqtTC2/A/AAAcISYCCED3UBkXLJgnP82bhmx6vxtAICuUitiFM0Ca/eCjHYYzQF7gabgofjNAEU2TeiTuVL4AwIvBcAUIQATS1POB +xglAcJZiQa3e8D8AgCnEcAUIQNjWGA2EmCc/jtu9EEC/G0BYP867VYUzQJ7+Ae2ahTNAtDJpzqN9M0A16W7Dle1UvgDAKdkFDAhArH3Yqm/FCUDQijIig+TwPwBAx9sF +DAhAm+IX+TOZJz+j1a9Zzr4bQE1dIMJPhDNA+csyI5WEM0CIioGemXwzQFf1ePJ37FS+ABi1TS8ZCEDcYeM0WcMJQKDNBAAz8PA/AKBSUC8ZCEAg+hXRk5onP/MARdr2 +vRtAMAomX0KCM0AoBDkgiIIzQE98BNCDejNAei/VxjrqVL4AFD5GfzMIQJzgBl5kvwlAyN0GIqMH8T8AcNtIfzMIQCopEoFTnSc/lA3d/Ha8G0CQnwTiIX4zQIwMJGRo +fjNAOJKvf1J2M0ArRpVQuuVUvgD8LEcTaAhAZILRM1i4CUAgEBusxDbxPwDAyUkTaAhAPocK4dKiJz8UUnkVL7obQEykgkXKdTNAqbrdTRJ2M0CM5IFM2W0zQCpVcyeh +3FS+AKS7HwrRCECE96/an60JQFCT9TwKlvE/ADxXIgrRCEBnQ/ug0a0nP0/WbHpauBtA0vNpV8JkM0Cz6nF8DWUzQPuceXOOXDNA2DTM3A/KVL4AHXZMKKIJQNSxW2gF +pQlASLfFcYpY8j8AXg9PKKIJQLm73CDPwyc/QcE0GZO+G0CK+fNDXkEzQEFRgOCvQTNA7dyoraU4M0BCoqwygaNUvsD4JKjVQAtA3E4HuULCCUBwR2pDuOzzPwBruarV +QAtAQUo1sZXXJz/XrYQjMs4bQKMDBs0ZIDNAkavBfXEgM0B2rglM6xYzQLtTARpKf1S+AD36EVOxDEBswEs2rgsKQJBjf9ClaPU/ACeKFFOxDEAQSRyNltcnPwh0lQEz +zhtAVInHUxggM0D8H8gEcCAzQIzhs83pFjNAz9Z5f0h/VL4AANz6YrEMQIT9AEqyCwpA6OfHpLZo9T8AAGj9YrEMQK1G6kSY1yc/ksG+vTTOG0BaWklhFSAzQLDO0xJt +IDNAxw4H0eYWM0DyjGlKRX9UvgAAnMyCsQxA9OmPcboLCkC49mZN2Gj1PwAAKM+CsQxA6EGGtJvXJz/zBx82OM4bQNqKyC8UIDNABdKK4WsgM0DhlZ+CKF2ivzBaGUyP +sQxAAABGTZCxDECEAe7AygsKQDD1X+7laPU/AAAAAAATwD5UPjtIntcnP05XUtA6zhtADplE0RYgM0D0z4uCbiAzQEnJHe0WXaK/gYp+0nOxDEAAAKrTdLEMQORcEvzW +CwpASOjm4sdo9T8AAAAAgBLAPmA9J/ie1yc/0qTxgTvOG0AmZNyEFyAzQAvKAjZvIDNA5pa2PBJdor/HS91+bLEMQAAADIBtsQxAbHzlPtoLCkBgUODfv2j1PwAAAAAA +FMA+eDv/V6DXJz/TsirlPM4bQOtzC+wYIDNA5zfwnHAgM0Cu+efbCF2ivyB2mtddsQxAAADE2F6xDECkpHHE4AsKQLAf2dmvaPU/AAAAAAATwD6nN68Xo9cnP/KAe6s/ +zhtA/WxmuhsgM0C97cdqcyAzQJNsSRr2XKK/prkSiUCxDEAAAD6KQbEMQGxt7c7tCwpAcLjuzY9o9T8AAAAAgBLAPgUwD5eo1yc/2+iXN0XOG0BMxQ9XISAzQN/BagZ5 +IDNAMggHl9Bcor/O/PrrBbEMQAAAKe0GsQxAZO9y4QcMCkBY0qm2T2j1PwAAAAAAE8A+wSDPlbPXJz+ZALxNUM4bQE4PMJAsIDNAvQx+PYQgM0AuGm2QhVyiv+h4qrGQ +sAxAAIDZspGwDEDEK7b8OwwKQEifX4rPZ/U/AAAAAOASwD45Ak+TydcnPw4asnFmzhtAwg6nAUMgM0DAMtuqmiAzQCzF5ILvW6K/FXSFPKavDEAAgLU9p68MQAQ9IQyk +DApAmFrJOs9m9T8AAAAAABPAPirFTo711yc/kkZcmJLOG0CN6m7hbyAzQPXub4LHIDNAhRaDZsNaor8w0yxQ0a0MQADgXlHSrQxApHSnjnMNCkDQPJO/zmT1PwAAAAAg +E8A+C0tOhE3YJz8eA9tg6s4bQKiOZ5TJIDNA1aAEJSEhM0CInoIoa1iiv7QXTG8nqgxAAMCCcCiqDEBshGEjEA8KQDje71jOYPU/AAAAAGgTwD7OVk1w/dgnPxPoFOCX +zxtAI04IyHwhM0B4reY31CEzQHPdxJe6U6K/BJojjdOiDEAAiGOO1KIMQOye8ZI/EgpAOClGys9Y9T8AAAAA/hPAPlNuS0hd2ic/crwApOrQG0AOrGVm4iIzQP1a65Q5 +IzNAJ4UQJVlKor8N0OlJK5QMQABEPEsslAxArJ5fxXcYCkCYRTWj20j1PwAAAAAnFcA+XZ1H+BzdJz94yOSkb9MbQDZ7fYKqJTNAiRXkLgEmM0CSaHIIlTeiv2TDMt3Y +dgxAABKq3tl2DEDEcI9JTyQKQKDxrAwXKfU/AAAAgHQXwD5x+z9YnOInP3+5JpT61xtAq+pmTy4rM0DmS9T5gyszQD4Ug10IEqK/oc8cEi08DEAAJ90TLjwMQMyQeBSp +OQpAkM08tBvq9D8AAAAABRzAPpq3MBib7Sc/PxPreivfG0BkZOHzBDYzQHaATqNYNjNA0mOCduDGob/4uyu5vsYLQICRe7u/xgtA1GkTUXVbCkD4dFojVG70PwAAAGD9 +JMA+7C8SmJgDKD/J1amdpeYbQCm4q//zSjNA2knb20NLM0Bz0d8DbjChv0S3Dear2wpAgJNy6azbCkDElS3BmX4KQJh3EZ1Bf/M/AAAA0E02wD7Hm1OHJiUoPzmQ8lnJ +4htAYFGBzhJpM0B8l7gpXWkzQHd4iPraSqC/Ojx1J/Z0CUDAWGgs93QJQDQ1UOl0bApAoACe/kQn8j8AAADQMU/APlbxRuaRPyg/qid0hMnUG0Aew+JMUX8zQOvrkJeX +fzNAu0Uk5Lksn796Vjw68VoIQMBFVUDyWghAZONK5KgqCkCYqfWEOynxPwAAAPiOYcA+JfAtwpI/KD8J937syNQbQCi71ABSfzNAeQJiS5h/M0Dk77Yqriyfv2rrXhHo +WghAAAB0F+laCECkSxcapioKQCA66X0zKfE/AAAAAABiwD7C7ft5lD8oPyVpkLzH1BtA5AK4aFN/M0BfhwOzmX8zQIfN3LeWLJ+/kYCkv9VaCEAAALzF1loIQIx9nIWg +KgpAmN3XbyMp8T8AAAAAgGHAPv3ol+mXPyg/bMC7XMXUG0DwDfg6Un8zQK21eoWYfzNA2MdTEId3M0DPN0miBedUvgAAvD7lWghAvJfOXJUqCkBAg/PlMCnxPwAAYEHl +WghAaeVMfZo/KD8qJQWVw9QbQH/cgFpOfzNAzt24pZR/M0BXIB8gg3czQCzAu2cB51S+AADQbhZbCECkV/T+jCoKQKC4USxdKfE/AABwcRZbCEB15Dgtmz8oPwSvihvD +1BtAHS/XUU1/M0DTjD+dk38zQPntQhOCdzNAggkMRwDnVL4AALCMI1sIQLySAcSKKgpA2MPg+mgp8T8AAGCPI1sIQI3iEI2cPyg/hc6dKMLUG0BQ4oJAS38zQP/4S4yR +fzNA1JeJ+X93M0D5mKsF/uZUvgAAcMg9WwhABNpBToYqCkBwpgmYgCnxPwAAEMs9WwhAvN7ATJ8/KD/HU/RCwNQbQIac1B1HfzNAMSZfao1/M0AaQxHGe3czQKqk5IL5 +5lS+AADYP3JbCEBUTKVjfSoKQDA0nNKvKfE/AABwQnJbCEAa1yDMpD8oP4ByYni81BtAbWBh2D5/M0A21G4mhX8zQCT4CV9zdzNATW8+ffDmVL4AAIku21sIQISp95Fr +KgpAaG/ESA4q8T8AACgx21sIQNbH4MqvPyg/r9lC5rTUG0D4JyBNLn8zQJGAM550fzNA/t2gkGJ3M0CX05Bx3uZUvgAAKwutXAhAfI7J/EcqCkDoTyE5yyrxPwAAxg2t +XAhATqlgyMU/KD9JFhPOpdQbQGjEMjUNfzNA9ChSjFN/M0BZp2TyQHczQNrnsFi65lS+AAB+wVBeCEDkRBwLASoKQKAUDCpFLPE/AAAaxFBeCEA/bGDD8T8oP2iF582H +1BtAT6as/8p+M0D0K+ViEX8zQC6lRLD9djNALrzeIHLmVL4AoGYimGEIQFyCTwp0KQpAqISgTDkv8T8AgAMlmGEIQCDyX7lJQCg/6zsSjkzUG0CJq/Z9Rn4zQICXZfmM +fjNAG/JpFXd2M0Cl/fSY4eVUvgDAJrUmaAhA/Kh+kV0oCkCAt5uUIjXxPwCAw7cmaAhA4/1epflAKD/5ogAO2dMbQGamACA9fTNAQ+rsy4N9M0DZ9maFaXUzQOMvKyjA +5FS+AAioHUN1CEAkWpK3PiYKQDgqkS75QPE/AIBEIEN1CEBoFV19WUIoPzhE5/j90htAxb7T+ih7M0AjtfwHcHszQILkE/1MczNAAL24w3viVL4AvO30eI8IQMwcmwc5 +IgpAgNIlgLZY8T8AEIr3eI8IQHJEWS0ZRSg/cpKZ4XbRG0A5J7IS+3YzQB47W+NCdzNAbJeDUg5vM0AAYCz37N1UvgCk5Y7YwwhADCbh5gobCkD4RFtHcYjxPwBogZHY +wwhAhqJRjZhKKD8wEO5MIM8bQN6qNQWJbjNAiEfvYNJuM0DX3hLQemYzQG6+G4631FS+AP0iCmYsCUB024eSDRAKQFBJv9Dk6PE/AJS9DGYsCUCvXkJNl1UoP0X4hnYt +zRtAknPSxE1dM0Dwp5lGml0zQFiG4Oj8VDNAqDR5ce/BVL4AFm1Rr/wJQATrPAnlBgpAOLJIIq+t8j8AVAVUr/wJQAHXI82Uayg/ARTSQybTG0CgsEkoiTkzQF4COTPc +OTNAzyPVJLQwM0BF/fi0+ZpUvgCtpMmqmQtA/Ia3Z/YiCkBgqHRtK0b0PwAOOMyqmQtAiWV8XVt/KD/Ll4tKiOIbQGA28qj0FzNAl5+w1k0YM0A6ymE6qg4zQN+uBzZt +dlS+ACbDgJkIDUA0P+wgQ2sKQFjsr/yqxfU/APVRg5kIDUBYZGM5XH8oPxGO4yWJ4htAgNdcLPMXM0Coy2BaTBgzQPCwurioDjNAmETwl2t2VL4AAChYqQgNQOR31idH +awpAkKsb97vF9T8AALBaqQgNQPVhMfFdfyg/rzib3IriG0Bh5TAz8BczQKPvv2FJGDNAa0trtaUOM0B6JsBbaHZUvgAA8AbJCA1A/EzPNU9rCkDQ6wDs3cX1PwAAeAnJ +CA1AMF3NYGF/KD/HNBhKjuIbQLgnoQLvFzNAwthnMUgYM0Ap12pqA5WivzDwRlbVCA1AAAAIV9YIDUAEIQFSX2sKQLDMOILrxfU/AAAAAEAMwD6cWYL0Y38oP4MWIdyQ +4htAYmSLr/EXM0B17tTdShgzQApj18fxlKK/wIpAyLkIDUAAAADJuggNQCx5xGZrawpAkIs19MzF9T8AAAAAgAzAPqhYbqRkfyg/E/WSi5HiG0DbfC9m8hczQFmnV5RL +GDNADAX0E+2Uor/iRy1vsggNQAAA8G+zCA1A1Khbn25rCkCwk1/OxMX1PwAAAAAADcA+wFZGBGZ/KD+wJ3HqkuIbQBsld9PzFzNAiJBcAU0YM0BXES2s45SivxhrBr2j +CA1AAADIvaQIDUAc/W8QdWsKQAC9uYK0xfU/AAAAAAANwD7vUvbDaH8oPxdODKiV4htAb0EDrvYXM0BNL2PbTxgzQLnbndzQlKK/Uae2WIYIDUAAAHhZhwgNQMxk/PGB +awpAeKaS65PF9T8AAAAAgAzAPk1LVkNufyg/yqK9IpviG0CBqQ5j/BczQJueY49VGDNADjh6PauUor+W9w6QSwgNQAAA0ZBMCA1ArD+ksptrCkAA09a9UsX1PwAAAAAA +DMA+CTwWQnl/KD8JhQwWpuIbQA848swHGDNA/0Qx92AYM0B6Eh7/X5Siv9/8nv7VBw1AAIBi/9YHDUA8mjAqz2sKQPiJqGTQxPU/AAAAACAMwD6BHZY/j38oPwD3W/S7 +4htAwVTsnx4YM0DUtv/FdxgzQFBqEoLJk6K/HMY82+oGDUAAwADc6wYNQESYP/I1bApA6Ctxu8vD9T8AAAAAUAzAPnLglTq7fyg/3N/Hj+fiG0CAvKxCTBgzQKJeaWCl +GDNA1YSuhpySor+Nr3CSFAUNQAAAN5MVBQ1AtF5U5gJtCkDYG5WNwsH1PwAAAABYDMA+U2aVMBOAKD+ALQZCPuMbQMnEX3unGDNA+z1xiAAZM0AqWruKQpCiv+K8xPhn +AQ1AALCP+WgBDUDU/kVfmm4KQAiRFsSwvfU/AAAAAKwMwD4WcpQcw4AoP67vrpXp4xtAxLCauV0ZM0CmMV+lthkzQEwGX36Oi6K/1nl0pQ76DEAA4EimD/oMQNz1q5u/ +cQpA8B13eY+19T8AAAAARg3APpuJkvQigig/4jwyBjjlG0DLkMNpyRozQNZ1ExMiGzNA7gmIFSaCor+Ej6SBW+sMQADMi4Jc6wxAHEdIeeN3CkAo7moBVqX1PwAAAAB0 +DsA+pbiOpOKEKD9sMgNvtOcbQHPB25udHTNAoTbXwPUdM0BLdQgRVG+iv0U3nVrzzQxAAPCpW/TNDEC8Yh6ZkoMKQGh3G2QHhfU/AAAAAMsQwD65FocEYoooPxpo1Wcu +7BtAe4XQXjkjM0Am53F9kCMzQCC0tKerSaK/clkKNhyTDEAAW2E3HZMMQKT4k6qcmApAWChYZvpE9T8AAAAAcBXAPuLSd8RglSg/quwT+z3zG0BRTaoaPy4zQG+TsDWU +LjNAWghJiEz+ob8NHfKUVx0MQIAT25ZYHQxAXLuC3+25CkBYLh4IGcf0PwAAAGCPHsA+NEtZRF6rKD/kjsXFb/obQNOOpBqJQzNAe6bOUdpDM0C4/OvDbGehv9+6IPKZ +MQtAAHoj9ZoxC0C81geg590KQHB5xsb30/M/AAAA8CswwD4Pt5oz7MwoP2BF2T0o9htAdl6wxypiM0COa/hldmIzQBgYLdQ1gaC/pXWGG+TJCUAATR4g5ckJQFhtJbLF +yApAwD8ylyR28j8AAACAfUnAPp4MjpJX5yg/9BWzSfLnG0Cc7bjryXgzQPfnzmcReTNALl5MnnGYn7+TqavDGK8IQIBhbskZrwhATNfsBSuCCkBQ+55dy3PxPwAAAIAr +XMA+bQt1bljnKD+wd8+v8ecbQNO6uKLKeDNA1kStHhJ5M0AhpajcZZifvwLBY5QPrwhAAAAkmhCvCEAcdd58soQKQFCxsTPDc/E/AAAAAIBcwD4KCUMmWucoP0IQBHzw +5xtADaq3EMx4M0CBU2mME3kzQAe+YVlOmJ+/dVzUNf2uCEAAAJQ7/q4IQPwOPNashApAkMDe37Jz8T8AAAAAAFzAPkQE35Vd5yg/t7N1FO7nG0CTWGXhyngzQM9uTl0S +eTNAhn3myORwM0Bh7Oce5t9UvgAA0okMrwhApPUeiaGECkCAiO1nwHPxPwAAcIwMrwhAsACUKWDnKD+4xfNG7OcbQP8yafXGeDNAqL0Jcg55M0C5QTvN4HAzQLt5C9jh +31S+AAD0jD2vCEAMFwkQmYQKQGgD2jHtc/E/AACYjz2vCEC8/3/ZYOcoP3y+7cvr5xtA8Cet6cV4M0Cwnn5mDXkzQP2GUL3fcDNAHoYTtODfVL4AANieSq8IQDwo082W +hApAeK59I/lz8T8AAIChSq8IQNP9Vzli5yg/VLnp1ernG0CnIzTSw3gzQMByZ08LeTNA+CN6nd1wM0DXnyJs3t9UvgAAoMJkrwhABBCNSZKECkCgpM8GEXTxPwAAUMVk +rwhAAvoH+WTnKD925hHq6OcbQB6GPKO/eDNA8YYzIQd5M0DDzMdd2XAzQATZOtzZ31S+AAAmCpmvCEC8feNBiYQKQChQs81AdPE/AADADJmvCEBf8md4aucoP5sZIxPl +5xtAZ/c2Rbd4M0DAX7XE/ngzQOHZTN7QcDNAh2JTvNDfVL4AAAGZAbAIQOy6GjZ3hApAUKJ5XKB08T8AAJibAbAIQBrjJ3d15yg/Q7xIaN3nG0AWjdKIpngzQM3UXwvu +eDNA7+P93r9wM0AN1CR8vt9UvgCA9LXSsAhANASyLFOECkBwHwJ+X3XxPwAAkLjSsAhAkMSndIvnKD+gup8ezucbQE2TpA6FeDNAA9tPl8x4M0DixfvenXAzQLZASfqZ +31S+AMDl7HSyCEAcFn5SC4QKQHjYAdHddvE/AACC73SyCEB8h6dvt+coP//Zcruv5xtAx320FEJ4M0BwypypiXgzQKs0Z9lZcDNAfbyY8FDfVL4AoOhOubUIQLxcXoB8 +gwpAMCi3ttp58T8AAIVRubUIQFMNp2UP6Cg/ta9ftXPnG0ACYIcKvHczQL7J7bcDeDNAQ1oAuNFvM0CVHlbFvt5UvgAQVuNBvAhA/BXRY2KCCkCwVNCA1X/xPwAA8uVB +vAhAARmmUb/oKD9qruWn/uYbQJoDFp2vdjNA9O6Ie/d2M0BtqlgcwW4zQD6TaQ+a3VS+APgaTVLJCECEqRM+PIAKQNiGdQ7Pi/E/AMC2T1LJCEBdMKQpH+ooP+TWS3Qg +5htA2yG8XpV0M0BrBImf3XQzQOWNiIKebDNA93nrJk/bVL4A8JIecOMIQFwBJ+UnfApAOP9PBdKj8T8AUC4hcOMIQBVfoNne7Cg/VhFWEZPkG0CSN1dbW3AzQAiJ2mGk +cDNAoWEfzFNoM0BoqR1rs9ZUvgC+4YufFwlA3OCjLdx0CkAoOGMPF9TxPwCQfI6fFwlAhryYOV7yKD8/WHirL+IbQGFPLXPRZzNA3QMdCRxoM0BGwP+NqF8zQELwVYZk +zVS+AIvFK8x/CUBUYaubomkKQHgFkAWbNfI/ADhfLsx/CUBnd4n5XP0oP+dx4VAi4BtARyTN6GdWM0Bkvz+ttVYzQGZjbpv8TTNAw3wb+Wq6VL6AcIPFUU8KQLQm5nH9 +XwpAgIHe+nX88j8AvBrIUU8KQCrtanlaEyk/eNglu+LlG0DvEsJFTDIzQN6rQ6OgMjNA4gh1UF0pM0CBHTpUGJNUvkAELY6+6gtA/DvBywV7CkC4O9Yj1Jj0PwBpv5C+ +6gtA0IDDCSEnKT9uht5xDvUbQADWoa1vEDNAJxIfO8oQM0DPHmrCCwczQOwhTOk+blS+QLGOCz9YDUBkOiVAU8IKQEBhLxOLG/Y/AHgcDj9YDUCff6rlIScpP+3YYUoP +9RtABqIKLm4QM0DJ9c27yBAzQMBTxj0KBzNADKL/Rz1uVL4AAOjSTlgNQFRyZg+QwwpAmO7yL5wb9j8AAHDVTlgNQDx9eJ0jJyk/0hVw+xD1G0AjC9suaxAzQFaOKr3F +EDNAKZB9NAcHM0CZXmUFOm5UvgAAkGFuWA1A5KW3cZjDCkDgjIdpvhv2PwAAIGRuWA1Ad3gUDScnKT9XYZldFPUbQHGlUP9pEDNAqp/XjcQQM0CwJfB9/Meiv+M6x4R6 +WA1AAAAmhXtYDUBAxCcyqcMKQNjGFvTLG/Y/AAAAAAAGwD7jdMmgKScpPznOIucW9RtAo03ItmwQM0BGM9BExxAzQI4bdc/qx6K/Dvsm5F5YDUAAAITkX1gNQNy4gMq1 +wwpA4C+Q7awb9j8AAAAAAAbAPu9ztVAqJyk/v29QlBf1G0AGxDxwbRAzQHLGIv7HEDNAIA5lGObHor8S5h2GV1gNQAAAfIZYWA1AeFQIJbnDCkDAVJenpBv2PwAAAAAA +BsA+B3KNsCsnKT/qE6buGPUbQP4lJeNuEDNAF2LHcMkQM0BUvESq3Meiv0NmC8pIWA1AAABsyklYDUBcR9fZv8MKQKjPqxuUG/Y/AAAAAAAGwD42bj1wLicpP0KjL6Mb +9RtAHKnyyHEQM0AkWQ1WzBAzQB/PAs7Jx6K/oGPkUStYDUAAAERSLFgNQPhS6kLNwwpA0Oz5A3Mb9j8AAAAAgAbAPpRmne8zJyk/zuC7CyH1G0A9rICUdxAzQIZGjCDS +EDNAv855FaTHor8KU45h8FcNQAAA7WHxVw1ANPPkEujDCkCQwSrVMBv2PwAAAADABcA+UFdd7j4nKT/O7bjaK/UbQMGmaCuDEDNADx9Wtd0QM0CpOVOkWMeivxgKwoB6 +Vw1AAIAhgXtXDUBEGyyqHcQKQMjN3nmsGvY/AAAAAAAGwD7ION3rVCcpP/ECRnBB9RtAz3JoWJoQM0AvzRne9BAzQH7as8HBxqK/ZQWpvo5WDUAAgAm/j1YNQOguALaI +xApAWCyQzKMZ9j8AAAAAEAbAPrn73OaAJyk/wrWxeWz1G0DHlyevyBAzQGZOYSwjETNAQSot+5PFor8GknY4t1QNQABg2Ti4VA1AvHCwQl7FCkBQ1RWXkhf2PwAAAAAo +BsA+moHc3NgnKT+fJ/wFwvUbQGOapU8lETNArWnyu38RM0ApEQdpOMOiv88KGyQIUQ1AAKCCJAlRDUAQl7svB8cKQAB5m8BwE/Y/AAAAAHwGwD5djdvIiCgpP4QhxQVr +9htA06msXN4RM0DkKCmnOBIzQLtRkDCBvqK/tH/h26lJDUAAoFLcqkkNQPz55VRQygpA0DgFZS8L9j8AAAAAEgfAPuKk2aDoKSk/DnhvrbT3G0DyBEinTxMzQJHLSa6p +EzNA1Sa5cBK1or+tTCHQ7DoNQACIpdDtOg1AJDdYsL/QCkCw9f3utfr1PwAAAABFCMA+7NPVUKgsKT+Wz+b3JvobQC67uQEvFjNAkiNdgogWM0CcIEbDM6Kiv/SSHeFw +HQ1AANzH4XEdDUCwg6TpEd0KQBhR/OTn2fU/AAAAgKQKwD4AMs6wJzIpPx/p3lWK/htANSCR4+AbM0CNss9ZORwzQG0yNB5yfKK/yo4xT3LiDEAATCdQc+IMQEw3m75/ +8wpAaIG6Rt6Y9T8AAADAWw/APinuvnAmPSk/j94J12IFHEAvjc8YEiczQA1hgYNoJzNATWdX8OAwor9okYh3X2wMQICLEnlgbAxAsHsQQ6sXC0CokjlqDBn1PwAAAKCf +GMA+e2ag8CNTKT9dyAmGFAwcQHNqgRCwPDNA3Dj/hwI9M0DBjuv9npmhvw4PwGwIgAtAADZobwmAC0BMfUizKzwLQMCC5DYsIvQ/AAAAgIIqwD5W0uHfsXQpP4ZQ6wsi +BxxAgh9xjspbM0A9W/lWF1wzQEvJWg/XsqC/hNr9B3AXCkCAa0EMcRcKQLDdI90xIQtAUEOVQvW+8j8AAAAQOUTAPuQn1T4djyk/tID5jZn4G0D/nrXrwnIzQGEUvoEL +czNA8R3LMNb6n79krx5W9/sIQADMkVv4+whAuPh9g4rUCkBgbagQobjxPwAAANAxV8A+sya8Gh6PKT+brt/ymPgbQNQzh6XDcjNA+7RtOwxzM0Cc+wFoyvqfv5KMQSHu ++whAAAC0Ju/7CEBsMSKzQ9UKQFgdiMaYuPE/AAAAAABXwD5QJIrSH48pP0YDqLyX+BtApa8pGcVyM0B3SMyuDXMzQPNCcNay+p+/TrSHt9v7CEAAAAC93PsIQIzuKpQ9 +1QpAqD5PMoi48T8AAAAAgFfAPosfJkIjjyk/EOtBUJX4G0ArWYbow3IzQFqcYH4MczNA+If0NsVqM0DgsoT0UtlUvgAAEuXq+whAmP+VVjHVCkCo7WbJlbjxPwAAqOfq ++whA9xvb1SWPKT932B5/k/gbQHRpG/K/cjNAFQmviAhzM0Cdc+cwwWozQBppgqJO2VS+AADEvxv8CEB4QkMpKNUKQHjueArDuPE/AABowhv8CEADG8eFJo8pP9AnIQOT ++BtAhS2X475yM0BhO1x6B3MzQKH7Nx7AajNAvHSRe03ZVL4AAOTGKPwIQJgZE7cl1QpAWB3iG8+48T8AAHDJKPwIQBsZn+Unjyk/WOMtC5L4G0D7yo3GvHIzQHa1tV0F +czNAoCHY+L1qM0CzkK4tS9lUvgAAFNVC/AhAtBbJ0iDVCkBI874+57jxPwAAwNdC/AhAShVPpSqPKT/eBngbkPgbQOaFdYy4cjNAoSpjJAFzM0By8RKuuWozQOrk4pFG +2VS+AAB28Xb8CEBYZzkLF9UKQBhvt4QXufE/AAAI9Hb8CECoDa8kMI8pPx76zjyM+BtA/PsuGLByM0A7Gaix+HIzQK2gchixajNAwv4zWj3ZVL4AAAIq3/wIQMAsK4AD +1QpAqKOjEXi58T8AAJws3/wIQGT+biM7jyk/+WSHgoT4G0Dh6kkvn3IzQDoJ2svncjNAND/a7J9qM0AA+nfqKtlUvgCAXZqv/QhA7LtRetzUCkDI7GgvObrxPwAA+Jyv +/QhA3N/uIFGPKT+M5yAadfgbQMLhH1x9cjNAoULe/sVyM0DhikqUfWozQAcehwkG2VS+AIAUeFD/CEBsW56vjtQKQMhcpnq7u/E/AACvelD/CEDNou4bfY8pP2l/63lW ++BtAnqVMsDlyM0CnjGhfgnIzQFzPr904ajNAZpfCQbzYVL4AgIInkgIJQOxh0R300wpAGKHnT8C+8T8AgB0qkgIJQK4o7hHVjyk/YC2G+xn4G0DFE61CsnEzQP0KiAr7 +cTNANaKQWq9pM0BpKLKaKNhUvgDgR1YVCQlA/GWABcPSCkDQIVv1ysTxPwDA4lgVCQlAcTTt/YSQKT9rpw4EpPcbQCz6pQ+jcDNA/BsPCexwM0DMGsj8m2gzQB+Mku4A +11S+ADC/8hoWCUDwt0rpcNAKQPg6wSrk0PE/AABa9RoWCUD2S+vV5JEpPyjvjBTE9htAan5bS4NuM0C89CCozG4zQKy78+NzZjNAxahOH7DUVL4A+KUhIzAJQOAeYkAM +zApAiPtiNSbp8T8AoEAkIzAJQAB754WklCk/MxiihzP1G0CUkfJQPmozQGxhb3WIajNA/2tpRB5iM0C7RGesCNBUvgBu+yknZAlApEWLUjvECkBYIb546BnyPwB4lSwn +ZAlAFNnf5SOaKT9QMm2LyvIbQF9/w82eYTNAY1yfhephM0Ax7jKHXVkzQFngubKixlS+ANwsgfzLCUCosX9+T7gKQEg2dS1jfPI/ALTFg/zLCUA9ldClIqUpP0v6lGyy +8BtABN7aVQtQM0AK7+JDWlAzQN1llN+HRzNAMt8ZXXyzVL6ACqGZ0ZoKQPgphAEjrgpAoM4n+BxF8z8Aejec0ZoKQI8NsiUguyk/CZU4dVX2G0DAM5zdoCszQCfnGnP2 +KzNAZ9+sMpoiM0Dkj5eO1YtUvkAcVinWNAxAMEwp93jJCkCousxu/+T0PwCY5yvWNAxAF5wKtubOKT/P8inRQwUcQFAHuvSCCTNAzbEjxt4JM0A14M+9BwAzQIB1onO2 +ZlS+QFktmQuhDUAA5jhkCBcLQBAcH0ygavY/ADC6mwuhDUDmmvGR584pPzNpDaZEBRxAf19pcoEJM0AIoRlE3QkzQLdFdzYGADNAYg9uz7RmVL4AAARSG6ENQDBw9Chs +FwtAuNv/h7Fq9j8AAIhUG6ENQIOYv0npzik/bbPbT0YFHEDb5cZtfgkzQLRVBEDaCTNALejEJwMAM0C7BASHsWZUvgAArMM6oQ1AIO2vIHUXC0BQps7/02r2PwAAMMY6 +oQ1AvpNbuezOKT/DxoOjSQUcQComRD99CTNA3ty4EdkJM0BL0Kutk/aiv3V1XL9GoQ1AAABev0ehDUA8ftgLhxcLQLjmmn7havY/AAAAAEAAwD4qkBBN784pP+csKyJM +BRxAR41zAIAJM0DRaGfS2wkzQDCqw/SB9qK/67lxDiuhDUAAAHQOLKENQChLVYSUFwtAmDkZCcJq9j8AAAAAAADAPjaP/Pzvzik/YK1xzEwFHED9Zn+8gAkzQBnmUI7c +CTNA+trrOn32or8nhhCsI6ENQAAAEKwkoQ1ACC+WGpgXC0AYNIiluWr2PwAAAAAAAcA+To3UXPHOKT/f7fggTgUcQKuNljSCCTNAA1QjBt4JM0CaBjzHc/aiv1DKTecU +oQ1AAABM5xWhDUD8w9VGnxcLQIBwbN6oavY/AAAAAAAAwD59iYQc9M4pP2fs5MlQBRxAlI7BJIUJM0D/48T14AkzQCIa299g9qK/1FjGXfegDUAAAMpd+KANQIg1tp6t +FwtAQJVaUIdq9j8AAAAAgADAPtuB5Jv5zik/yeIyG1YFHEC6XgoFiwkzQLbU+tTmCTNAzDIUETv2or9fj69KvKANQAAAs0q9oA1AbC/8S8oXC0AYjc00RGr2PwAAAABA +AMA+l3KkmgTPKT+Kzqa7YAUcQBw5Z8WWCTNA2vkxk/IJM0AlLnJz7/WivxpoYiRGoA1AAABmJEegDUAYX5ycAxgLQMgtDgC+afY/AAAAAEAAwD4PVCSYGs8pP41v7/N1 +BRxAT9xNRa4JM0AjWc0OCgozQOpp3TdY9aK/fvVJ11mfDUAAgE7XWp8NQCCpLBZ2GAtAyOz5n7Fo9j8AAAAAUADAPgAXJJNGzyk/60MKQqAFHEDQDc9B3QkzQBGduAI5 +CjNAJd1xvyn0or+J6SE7gZ0NQAAgKTuCnQ1AgIWEaloZC0CgLXkFmWb2PwAAAABwAMA+4ZwjiZ7PKT8GnplU9AUcQPinoi07CjNAusRi3ZYKM0De6pnJzPGiv/t+APvP +mQ1AAHAM+9CZDUBII9CXIBsLQDgfBWdoYvY/AAAAAMQAwD6kqCJ1TtApP+StulSaBhxAzQub0PYKM0D34xFeUgszQA5BIMoS7aK/pmXSW22SDUAAEOhbbpINQKgI5gKj +HgtAYAPGgwla9j8AAAAAWgHAPinAIE2u0Sk/ve/nzd0HHEBXADNEbQwzQO6+PY3IDDNApVbQfZ7jor9ih5Wkp4MNQACYvqSogw1AIPQLDYAlC0CgqocfVUn2PwAAAACR +AsA+M+8c/W3UKT8POT8LQwocQLV8EOVWDzNAMDfcpbEPM0BwEOu9tNCiv69Jv2gaZg1AAPAOaRtmDUB4Cx2ZmjILQJDeBr0RKPY/AAAAgPoEwD5HTRVd7dkpPznw8e6J +DhxAT7HfJR0VM0Djq43YdhUzQBqv/w/dqqK/mYH/aPkqDUAAq5tp+ioNQHynMTtQSgtAoBateR/m9T8AAACAwgnAPnAJBh3s5Ck/57lCPSMVHEBUijVkdiAzQEP+BQTO +IDNAEuMrTCBfor/LkgR3orQMQIASN3ijtAxAcCOfjMdvC0CY+01khGT1PwAAAOAnE8A+woHnnOn6KT/TzyxnThscQEHTX69hNjNA6RjbTbU2M0BYD0RDicehv/pXGnnG +xwtAgA9ve8fHC0Dod8blIpQLQJBdgRgxavQ/AAAAgEslwD6d7SiMdxwqP41maeirFRxABH/Rb+tVM0DOrgJLOVYzQOkA831E4KC/a7HLBGteCkDApMEIbF4KQOiu8mx0 +cwtAyKwqggMC8z8AAABAXz/APixDHOviNio/cIyWTt0GHEAHmaX3NW0zQHJvU5F/bTNA3V5CW3kqoL85tJeeXUIJQIB/waNeQglAcFfF8JIdC0DY7tjwBPjxPwAAALCc +UsA+" +} diff --git a/xschem_library/ngspice/solar_panel.sch b/xschem_library/ngspice/solar_panel.sch index 64ac973b..0d27de84 100644 --- a/xschem_library/ngspice/solar_panel.sch +++ b/xschem_library/ngspice/solar_panel.sch @@ -121,14 +121,11 @@ N 860 -470 860 -430 { lab=#net3} N 960 -650 980 -650 { lab=#net4} N 310 -450 345 -450 {lab=PANEL} C {title.sym} 160 -40 0 0 {name=l1 author="Stefan Schippers" net_name=true} -C {code_shown.sym} 245 -245 0 0 {name=CONTROL value="* .control -* save all -* tran 5n 500u uic -* write led_driver.raw -* .endc -.option savecurrents -*.save all -.tran 20n 200u uic +C {code_shown.sym} 245 -245 0 0 {name=CONTROL value=".control +save v(panel) v(sw) v(led) i(vpanel) +tran 1u 200u uic +write solar_panel.raw +.endc * .dc VP 0 21 0.01 " net_name=true} C {code.sym} 15 -225 0 0 {name=MODELS value=".MODEL DIODE D(IS=1.139e-08 RS=0.99 CJO=9.3e-12 VJ=1.6 M=0.411 BV=30 EG=0.7 )