From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 27601 invoked by alias); 21 Sep 2010 19:32:17 -0000 Received: (qmail 27555 invoked by uid 22791); 21 Sep 2010 19:32:03 -0000 X-SWARE-Spam-Status: No, hits=0.4 required=5.0 tests=AWL,BAYES_50,RCVD_IN_DNSWL_NONE,RCVD_IN_RP_RNBL,TW_CP,TW_NB,T_FRT_STOCK1,T_FRT_STOCK2 X-Spam-Check-By: sourceware.org Received: from smtp-102-tuesday.noc.nerim.net (HELO mallaury.nerim.net) (62.4.17.102) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Tue, 21 Sep 2010 19:31:47 +0000 Received: from hector.lesours (ours.starynkevitch.net [213.41.244.95]) by mallaury.nerim.net (Postfix) with ESMTPS id 8900EA1056; Tue, 21 Sep 2010 21:31:42 +0200 (CEST) Received: from glinka.lesours ([192.168.0.1] helo=glinka) by hector.lesours with smtp (Exim 4.72) (envelope-from ) id 1Oy8Z4-0008QJ-5J; Tue, 21 Sep 2010 21:31:42 +0200 Date: Wed, 22 Sep 2010 02:16:00 -0000 From: Basile Starynkevitch To: Basile Starynkevitch Cc: gcc-patches@gcc.gnu.org Subject: Re: gengtype improvements for plugins, thirdround! patch 6/7 [wstate] Message-Id: <20100921213151.0332d8b3.basile@starynkevitch.net> In-Reply-To: <20100921212926.f7688cfd.basile@starynkevitch.net> References: <20100921210301.d92889be.basile@starynkevitch.net> <20100921210829.5f2ea8b0.basile@starynkevitch.net> <20100921211217.df1ef337.basile@starynkevitch.net> <20100921211628.969ed469.basile@starynkevitch.net> <20100921212431.f07dad12.basile@starynkevitch.net> <20100921212926.f7688cfd.basile@starynkevitch.net> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="Multipart=_Tue__21_Sep_2010_21_31_51_+0200_l=7Nwv6JCGIhGwng" X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org X-SW-Source: 2010-09/txt/msg01741.txt.bz2 This is a multi-part message in MIME format. --Multipart=_Tue__21_Sep_2010_21_31_51_+0200_l=7Nwv6JCGIhGwng Content-Type: text/plain; charset=US-ASCII Content-Transfer-Encoding: 7bit Content-length: 3637 On Tue, 21 Sep 2010 21:29:26 +0200 Basile Starynkevitch wrote: > > Hello All, > > [join work by Basile Starynkevitch & Jeremie Salvucci] > > References: > http://gcc.gnu.org/ml/gcc-patches/2010-08/msg02060.html > http://gcc.gnu.org/ml/gcc-patches/2010-09/msg00616.html > http://gcc.gnu.org/ml/gcc-patches/2010-09/msg00663.html > http://gcc.gnu.org/ml/gcc-patches/2010-08/msg02063.html > http://gcc.gnu.org/ml/gcc-patches/2010-08/msg02065.html > http://gcc.gnu.org/ml/gcc-patches/2010-08/msg02068.html > http://gcc.gnu.org/ml/gcc-patches/2010-09/msg00983.html > http://gcc.gnu.org/ml/gcc-patches/2010-08/msg02069.html > http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01150.html > http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01153.html > http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01713.html > > The 6th part [wstate] of our patch series (thirdround) is a slightly > improved version of > http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01150.html by adding > comments notably taking into account Laurynas remarks in > http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01151.html & > http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01153.html > > diff -u -p -N $(svn stat . |awk '/[AM]/{print $2}') \ > --from-file ../thirdround_05_typedopt/ > \ > $HOME/Gengtype_Thirdround/patch6_wstate-relto05.diff > > #################### gcc/ChangeLog entry relative to patch piece 5 [typedopt] > 2010-09-21 Jeremie Salvucci > Basile Starynkevitch > > * gengtype-state.c: Added new file. > > * gengtype.c: > (type_count): New static variable. > (new_structure, find_structure, find_param_structure) > (create_pointer, create_array): Use type_count for initializing > state_number field of types. > (main): Initialize state_number in predefined types. Call > read_state and write_state appropriately. Show the > type_count when verbose. > > * gengtype.h: Updated comment about per-language directories. > (read_state, write_state): New declarations. > > * Makefile.in (MOSTLYCLEANFILES): Added gtype.state. > (GENGTYPE_FLAGS): New variable. > (s-gtype): Runs gengtype twice, once to write the gtype.state, > once to read it. > (build/gengtype-state.o): New target. > (build/gengtype): Use it. > (mostlyclean): Remove gtype.state > ################################################################ > > > > Also, how should the gengtype program be installed? Perhaps it should > be named gcc-gengtype? I still need help on these minor issues, in > particular as ways to patch gcc/Makefile.in.... There has been some > discussions & suggestions, but I was not able to imagine a > gcc/Makefile.in patch from them. I confess that I don't understand all > of gcc/Makefile.in in particular the installations tricks. > > I am as usual attaching the cumulated patch w.r.t. trunk 164437. Sorry attachment in previous email was wrong. http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01714.html I attached by mistake a draft version of the email, not the relative patch. Apologies! > > Ok for trunk? > > Cheers. > -- > Basile STARYNKEVITCH http://starynkevitch.net/Basile/ > email: basilestarynkevitchnet mobile: +33 6 8501 2359 > 8, rue de la Faiencerie, 92340 Bourg La Reine, France > *** opinions {are only mine, sont seulement les miennes} *** -- Basile STARYNKEVITCH http://starynkevitch.net/Basile/ email: basilestarynkevitchnet mobile: +33 6 8501 2359 8, rue de la Faiencerie, 92340 Bourg La Reine, France *** opinions {are only mine, sont seulement les miennes} *** --Multipart=_Tue__21_Sep_2010_21_31_51_+0200_l=7Nwv6JCGIhGwng Content-Type: text/x-diff; name="patch6_wstate-relto05.diff" Content-Disposition: attachment; filename="patch6_wstate-relto05.diff" Content-Transfer-Encoding: 7bit Content-length: 78299 --- ../thirdround_05_typedopt//gengtype-state.c 2010-09-21 19:56:44.000000000 +0200 +++ gcc/gengtype-state.c 2010-09-21 19:58:32.000000000 +0200 @@ -0,0 +1,2469 @@ +/* Gengtype persistent state serialization & de-serialization. + Useful for gengtype in plugin mode. + + Copyright (C) 2010 Free Software Foundation, Inc. + + This file is part of GCC. + + GCC is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3, or (at your option) any later + version. + + GCC is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with GCC; see the file COPYING3. If not see + . + + Contributed by Jeremie Salvucci + and Basile Starynkevitch +*/ + +#include "bconfig.h" +#include "system.h" +#include "getopt.h" +#include "errors.h" /* For fatal. */ +#include "double-int.h" +#include "hashtab.h" +#include "version.h" /* For version_string & pkgversion_string. */ +#include "obstack.h" +#include "xregex.h" +#include "gengtype.h" + + +/* The state file has simplistic lispy lexical tokens. Its lexer gives + a linked list of struct state_token_st, thru the peek_state_token + function. Lexical tokens are consumed with next_state_tokens. */ + + +/* The lexical kind of each lispy token. */ +enum state_token_en +{ + STOK_NONE, /* Never used. */ + STOK_INTEGER, /* Integer token. */ + STOK_STRING, /* String token. */ + STOK_LEFTPAR, /* Left parenthesis. */ + STOK_RIGHTPAR, /* Right parenthesis. */ + STOK_NAME /* hash-consed name or identifier. */ +}; + + +/* Structure and hash-table used to share identifiers or names. */ +struct state_ident_st +{ + /* TODO: We could improve the parser by reserving identifiers for + state keywords and adding a keyword number for them. That would + mean adding another field in this state_ident_st struct. */ + char stid_name[1]; /* actually bigger & null terminated */ +}; +static htab_t state_ident_tab; + + +/* The state_token_st structure is for lexical tokens in the read + state file. The stok_kind field discriminates the union. Tokens + are allocated by peek_state_token which calls read_a_state_token + which allocate them. Tokens are freed by calls to + next_state_tokens. Token are organized in a FIFO look-ahead queue + filled by peek_state_token. */ +struct state_token_st +{ + enum state_token_en stok_kind; /* the lexical kind + discriminates the stok_un + union */ + int stok_line; /* the line number */ + int stok_col; /* the column number */ + const char *stok_file; /* the file path */ + struct state_token_st *stok_next; /* the next token in the + queue, when peeked */ + union /* discriminated by stok_kind! */ + { + int stok_num; /* when STOK_INTEGER */ + char stok_string[1]; /* when STOK_STRING, actual size is + bigger and null terminated */ + struct state_ident_st *stok_ident; /* when STOK_IDENT */ + void *stok_ptr; /* null otherwise */ + } + stok_un; +}; + + + + +#define NULL_STATE_TOKEN (struct state_token_st*)0 + +/* the state_token pointer contains the leftmost current token. The + tokens are organized in a linked queue, using stok_next, for token + look-ahead. */ +struct state_token_st *state_token = NULL_STATE_TOKEN; + +/* Used by the reading lexer. */ +static FILE *state_file; +static const char *state_path = NULL; +static int state_line = 0; +static long state_bol = 0; /* offset of beginning of line */ + + +/* Counter of written types. */ +static int state_written_type_count = 0; + + +/* Fatal error messages when reading the state. They are extremely + unlikely, and only appear when this gengtype-state.c file is buggy, + or when reading a gengtype state which was not generated by the + same version of gengtype or GCC. */ + + +/* Fatal message while reading state. */ +#define fatal_reading_state(Tok,Msg) do { \ + struct state_token_st* badtok = Tok; \ + if (badtok) \ + fatal ("%s:%d:%d: Invalid state file; " Msg, \ + badtok->stok_file, \ + badtok->stok_line, \ + badtok->stok_col); \ + else \ + fatal ("%s:%d: Invalid state file; " Msg, \ + state_path, state_line); \ + } while(0) + +#define fatal_reading_state_printf(Tok,Fmt,...) do { \ + struct state_token_st* badtok = Tok; \ + if (badtok) \ + fatal ("%s:%d:%d: Invalid state file; " Fmt, \ + badtok->stok_file, \ + badtok->stok_line, \ + badtok->stok_col, __VA_ARGS__); \ + else \ + fatal ("%s:%d: Invalid state file; " Fmt, \ + state_path, state_line, __VA_ARGS__); \ + } while(0) + + +/* Find or allocate an identifier in our name hash table. */ +static struct state_ident_st * +state_ident_by_name (const char *name, enum insert_option optins) +{ + PTR *slot = NULL; + int namlen = 0; + struct state_ident_st *stid = NULL; + + if (!name || !name[0]) + return NULL; + + slot = htab_find_slot (state_ident_tab, name, optins); + if (!slot) + return NULL; + + namlen = strlen (name); + stid = + (struct state_ident_st *) xmalloc (sizeof (struct state_ident_st) + + namlen); + memset (stid, 0, sizeof (struct state_ident_st) + namlen); + strcpy (stid->stid_name, name); + *slot = stid; + + return stid; +} + +/* Our token lexer is heavily inspired by MELT's lexer, and share some + code with the file gcc/melt-runtime.c of the GCC MELT branch! We + really want the gengtype state to be easily parsable by MELT. This + is a usual lispy lexing routine, dealing with spaces and comments, + numbers, parenthesis, names, strings. */ +static struct state_token_st * +read_a_state_token (void) +{ + int c = 0; + long curoff = 0; + struct state_token_st *tk = NULL; + again: /* Read again, e.g. after a comment. */ + c = getc (state_file); + + if (c == EOF) + return NULL; + /* Handle spaces, count lines. */ + if (c == '\n') + { + state_line++; + state_bol = curoff = ftell (state_file); + goto again; + }; + if (ISSPACE (c)) + goto again; + /* Skip comments starting with semi-colon. */ + if (c == ';') + { + do + { + c = getc (state_file); + } + while (c > 0 && c != '\n'); + if (c == '\n') + { + state_line++; + state_bol = curoff = ftell (state_file); + } + goto again; + }; + /* Read signed numbers. */ + if (ISDIGIT (c) || c == '-' || c == '+') + { /* number */ + int n = 0; + ungetc (c, state_file); + curoff = ftell (state_file); + if (fscanf (state_file, "%d", &n) <= 0) + fatal_reading_state (NULL_STATE_TOKEN, "Lexical error in number"); + tk = XCNEW (struct state_token_st); + tk->stok_kind = STOK_INTEGER; + tk->stok_line = state_line; + tk->stok_col = curoff - state_bol; + tk->stok_file = state_path; + tk->stok_next = NULL; + tk->stok_un.stok_num = n; + + return tk; + } + /* Read an opening left parenthesis. */ + else if (c == '(') + { + curoff = ftell (state_file); + tk = XCNEW (struct state_token_st); + tk->stok_kind = STOK_LEFTPAR; + tk->stok_line = state_line; + tk->stok_col = curoff - state_bol; + tk->stok_file = state_path; + tk->stok_next = NULL; + + return tk; + } + /* Read an closing right parenthesis. */ + else if (c == ')') + { + curoff = ftell (state_file); + tk = XCNEW (struct state_token_st); + tk->stok_kind = STOK_RIGHTPAR; + tk->stok_line = state_line; + tk->stok_col = curoff - state_bol; + tk->stok_file = state_path; + tk->stok_next = NULL; + + return tk; + } + /* Read identifiers, using an obstack. */ + else if (ISALPHA (c) || c == '_' || c == '$' || c == '!' || c == '#') + { + struct obstack id_obstack; + struct state_ident_st *sid = NULL; + char *ids = NULL; + obstack_init (&id_obstack); + curoff = ftell (state_file); + while (ISALNUM (c) || c == '_' || c == '$' || c == '!' || c == '#') + { + obstack_1grow (&id_obstack, c); + c = getc (state_file); + if (c < 0) + break; + }; + if (c >= 0) + ungetc (c, state_file); + obstack_1grow (&id_obstack, (char) 0); + ids = XOBFINISH (&id_obstack, char *); + sid = state_ident_by_name (ids, INSERT); + obstack_free (&id_obstack, ids); + ids = NULL; + tk = XCNEW (struct state_token_st); + tk->stok_kind = STOK_NAME; + tk->stok_line = state_line; + tk->stok_col = curoff - state_bol; + tk->stok_file = state_path; + tk->stok_next = NULL; + tk->stok_un.stok_ident = sid; + + return tk; + } + /* Read a string, dealing with escape sequences a la C! */ + else if (c == '"') + { + char *cstr = NULL; + int cslen = 0; + struct obstack bstring_obstack; + obstack_init (&bstring_obstack); + curoff = ftell (state_file); + while ((c = getc (state_file)) != '"' && c >= 0) + { + if (ISPRINT (c) && c != '\\') + obstack_1grow (&bstring_obstack, (char) c); + else if (ISSPACE (c) && c != '\n') + obstack_1grow (&bstring_obstack, (char) c); + else if (c == '\\') + { + c = getc (state_file); + switch (c) + { + case 'a': + obstack_1grow (&bstring_obstack, '\a'); + c = getc (state_file); + break; + case 'b': + obstack_1grow (&bstring_obstack, '\b'); + c = getc (state_file); + break; + case 't': + obstack_1grow (&bstring_obstack, '\t'); + c = getc (state_file); + break; + case 'n': + obstack_1grow (&bstring_obstack, '\n'); + c = getc (state_file); + break; + case 'v': + obstack_1grow (&bstring_obstack, '\v'); + c = getc (state_file); + break; + case 'f': + obstack_1grow (&bstring_obstack, '\f'); + c = getc (state_file); + break; + case 'r': + obstack_1grow (&bstring_obstack, '\r'); + c = getc (state_file); + break; + case '"': + obstack_1grow (&bstring_obstack, '\"'); + c = getc (state_file); + break; + case '\\': + obstack_1grow (&bstring_obstack, '\\'); + c = getc (state_file); + break; + case ' ': + obstack_1grow (&bstring_obstack, ' '); + c = getc (state_file); + break; + case 'x': + { + unsigned int cx = 0; + if (fscanf (state_file, "%02x", &cx) > 0 && cx > 0) + obstack_1grow (&bstring_obstack, cx); + else + fatal_reading_state (NULL_STATE_TOKEN, + "Lexical error in string escape"); + c = getc (state_file); + break; + } + default: + fatal_reading_state (NULL_STATE_TOKEN, + "Lexical error in string escape"); + } + } + else + fatal_reading_state (NULL_STATE_TOKEN, "Lexical error..."); + }; + if (c != '"') + fatal_reading_state (NULL_STATE_TOKEN, "Unterminated string"); + obstack_1grow (&bstring_obstack, (char) 0); + cstr = XOBFINISH (&bstring_obstack, char *); + cslen = strlen (cstr); + tk = (struct state_token_st *) + xcalloc (sizeof (struct state_token_st) + cslen, 1); + tk->stok_kind = STOK_STRING; + tk->stok_line = state_line; + tk->stok_col = curoff - state_bol; + tk->stok_file = state_path; + tk->stok_next = NULL; + strcpy (tk->stok_un.stok_string, cstr); + obstack_free (&bstring_obstack, cstr); + + return tk; + } + /* Got an unexpected character. */ + fatal_reading_state_printf (NULL_STATE_TOKEN, "Lexical error at offset %ld", + ftell (state_file)); +} + +/* Used for lexical look-ahead. Retrieves the lexical token of rank + DEPTH, starting with 0 when reading the state file. Gives null on + end of file. */ +static struct state_token_st * +peek_state_token (int depth) +{ + int remdepth = depth; + struct state_token_st **ptoken = &state_token; + struct state_token_st *tok = NULL; + + while (remdepth >= 0) + { + if (*ptoken == NULL) + { + *ptoken = tok = read_a_state_token (); + if (tok == NULL) + return NULL; + } + tok = *ptoken; + ptoken = &((*ptoken)->stok_next); + remdepth--; + } + + return tok; +} + +/* Consume the next DEPTH tokens and free them. */ +static void +next_state_tokens (int depth) +{ + struct state_token_st *n; + + while (depth > 0) + { + if (state_token != NULL) + { + n = state_token->stok_next; + free (state_token); + state_token = n; + } + else + fatal_reading_state (NULL_STATE_TOKEN, "Tokens stack empty"); + + depth--; + } +} + +/* Safely retrieve the lexical kind of a token. */ +static inline enum state_token_en +state_token_kind (struct state_token_st *p) +{ + if (p == NULL) + return STOK_NONE; + else + return p->stok_kind; +} + +/* Test if a token is a given name i.e. an identifier. */ +static inline bool +state_token_is_name (struct state_token_st *p, const char *name) +{ + if (p == NULL) + return false; + + if (p->stok_kind != STOK_NAME) + return false; + + return !strcmp (p->stok_un.stok_ident->stid_name, name); +} + + +/* Following routines are useful for serializing datas. + * + * We want to serialize : + * - typedefs list + * - structures list + * - param_structs list + * - variables list + * + * So, we have one routine for each kind of data. The main writing + * routine is write_state. The main reading routine is + * read_state. Most writing routines write_state_FOO have a + * corresponding reading routine read_state_FOO. Reading is done in a + * recursive descending way, and any read error is fatal. + */ + +/* When reading the state, we need to remember the previously seen + types by their state_number, since GTY-ed types are usually + shared. */ +static htab_t state_seen_types; + +/* Return the length of a linked list made of pairs. */ +static int pair_list_length (pair_p list); + +/* Write a pair */ +static void write_state_pair (pair_p); + +/* return the number of pairs written. Should match the length given + by pair_list_length. */ +static int write_state_pair_list (pair_p list); + +/* Write a type. When a type is written, its state_number is updated, + to ensure that a "reference" to a seen type is written on next + occurrences. */ +static void write_state_type (type_p); + +/* Write a null-terminatel string using our Lispy lexical conventions, + similar to those of C or MELT. */ +static void write_state_a_string (const char *s); + +/* Compute the length of a list of pairs, starting from the first + one. */ +static int +pair_list_length (pair_p list) +{ + int nbpair = 0; + pair_p l = NULL; + for (l = list; l; l = l->next) + nbpair++; + return nbpair; +} + +/* Write a file location. Files relative to $(srcdir) are quite + frequent and are handled specially. This ensures that two gengtype + state file-s produced by gengtype on the same GCC source tree are + very similar and can be reasonably compared with diff, even if the + two GCC source trees have different absolute paths. */ +static void +write_state_fileloc (struct fileloc *floc) +{ + + if (floc != NULL && floc->line > 0) + { + const char *srcrelpath = NULL; + gcc_assert (floc->file != NULL); + /* Most of the files are inside $(srcdir) so it is worth to + handle them specially. */ + srcrelpath = get_file_srcdir_relative_path (floc->file); + if (srcrelpath != NULL) + { + fprintf (state_file, "\n(!srcfileloc "); + write_state_a_string (srcrelpath); + } + else + { + fprintf (state_file, "\n(!fileloc "); + write_state_a_string (get_input_file_name (floc->file)); + } + fprintf (state_file, " %d", floc->line); + fprintf (state_file, ")\n"); + } + else + fprintf (state_file, "nil "); +} + +/* Write a list of fields. */ +static void +write_state_fields (pair_p fields) +{ + int nbfields = pair_list_length (fields); + int nbpairs = 0; + fprintf (state_file, "\n(!fields %d ", nbfields); + nbpairs = write_state_pair_list (fields); + gcc_assert (nbpairs == nbfields); + fprintf (state_file, ")\n"); +} + +/* Write a null-terminated string in our lexical convention, very + similar to the convention of C. */ +static void +write_state_a_string (const char *s) +{ + char c; + + fputs (" \"", state_file); + for (; *s != 0; s++) + { + c = *s; + switch (c) + { + case '\a': + fputs ("\\a", state_file); + break; + case '\b': + fputs ("\\b", state_file); + break; + case '\t': + fputs ("\\t", state_file); + break; + case '\n': + fputs ("\\n", state_file); + break; + case '\v': + fputs ("\\v", state_file); + break; + case '\f': + fputs ("\\f", state_file); + break; + case '\r': + fputs ("\\r", state_file); + break; + case '\"': + fputs ("\\\"", state_file); + break; + case '\\': + fputs ("\\\\", state_file); + break; + default: + if (ISPRINT (c)) + putc (c, state_file); + else + fprintf (state_file, "\\x%02x", (unsigned) c); + } + } + fputs ("\"", state_file); +} + +/* Our option-s have three kinds, each with its writer. */ +static void +write_state_string_option (options_p current) +{ + fprintf (state_file, "string "); + if (current->info.string != NULL) + write_state_a_string (current->info.string); + else + fprintf (state_file, " nil "); +} + +static void +write_state_type_option (options_p current) +{ + fprintf (state_file, "type "); + write_state_type (current->info.type); +} + +static void +write_state_nested_option (options_p current) +{ + fprintf (state_file, "nested "); + write_state_type (current->info.nested->type); + if (current->info.nested->convert_from != NULL) + write_state_a_string (current->info.nested->convert_from); + else + fprintf (state_file, " nil "); + + if (current->info.nested->convert_to != NULL) + write_state_a_string (current->info.nested->convert_to); + else + fprintf (state_file, " nil "); +} + +static void +write_state_option (options_p current) +{ + fprintf (state_file, "\n(!option "); + + if (current->name != NULL) + fprintf (state_file, "%s ", current->name); + else + fprintf (state_file, "nil "); + + switch (current->kind) + { + case OPTION_STRING: + write_state_string_option (current); + break; + case OPTION_TYPE: + write_state_type_option (current); + break; + case OPTION_NESTED: + write_state_nested_option (current); + break; + default: + fatal ("Option tag unknown"); + } + + fprintf (state_file, ")\n"); +} + + + +/* Write a list of GTY options. */ +static void +write_state_options (options_p opt) +{ + options_p current; + + if (opt == NULL) + { + fprintf (state_file, "nil "); + return; + } + + fprintf (state_file, "\n(!options "); + for (current = opt; current != NULL; current = current->next) + write_state_option (current); + fprintf (state_file, ")\n"); +} + + +/* Write a bitmap representing a set of GCC front-end languages. */ +static void +write_state_lang_bitmap (lang_bitmap bitmap) +{ + fprintf (state_file, "%d ", (int) bitmap); +} + +/* Write version information. */ +static void +write_state_version (const char *version) +{ + fprintf (state_file, "\n(!version "); + write_state_a_string (version); + fprintf (state_file, ")\n"); +} + +/* Common routine to write the common content of all types. */ +static void write_state_common_type_content (type_p current); + +/* Write a scalar type. We have only two of these. */ +static void +write_state_scalar_type (type_p current) +{ + if (current == &scalar_nonchar) + fprintf (state_file, "scalar_nonchar "); + else if (current == &scalar_char) + fprintf (state_file, "scalar_char "); + else + fatal ("Unexpected type in write_state_scalar_type"); + + write_state_common_type_content (current); +} + +/* Write the string type. There is only one such thing! */ +static void +write_state_string_type (type_p current) +{ + if (current == &string_type) + { + fprintf (state_file, "string "); + write_state_common_type_content (current); + } + else + fatal ("Unexpected type in write_state_string_type"); +} + + +/* Common code to write structure like types. */ +static void +write_state_struct_union_type (type_p current, const char *kindstr) +{ + DBGPRINTF ("%s type @ %p #%d '%s'", kindstr, (void *) current, + current->state_number, current->u.s.tag); + fprintf (state_file, "%s ", kindstr); + write_state_common_type_content (current); + if (current->u.s.tag != NULL) + write_state_a_string (current->u.s.tag); + else + fprintf (state_file, "nil"); + + write_state_fileloc (type_lineloc (current)); + write_state_fields (current->u.s.fields); + write_state_options (current->u.s.opt); + write_state_lang_bitmap (current->u.s.bitmap); +} + + +/* Write a GTY struct type. */ +static void +write_state_struct_type (type_p current) +{ + write_state_struct_union_type (current, "struct"); + write_state_type (current->u.s.lang_struct); +} + +/* write a GTY union type. */ +static void +write_state_union_type (type_p current) +{ + write_state_struct_union_type (current, "union"); + write_state_type (current->u.s.lang_struct); +} + +/* Write a lang_struct type. This is tricky and was painful to debug, + we deal with the next field specifically within their lang_struct + subfield, which points to a linked list of homonumous types. + Change this function with extreme care, see also + read_state_lang_struct_type. */ +static void +write_state_lang_struct_type (type_p current) +{ + int nbhomontype = 0; + type_p hty = NULL; + const char *homoname = 0; + write_state_struct_union_type (current, "lang_struct"); + /* lang_struct-ures are particularily tricky, since their + u.s.lang_struct field gives a list of homonymous struct-s or + union-s! */ + DBGPRINTF ("lang_struct @ %p #%d", (void *) current, current->state_number); + for (hty = current->u.s.lang_struct; hty != NULL; hty = hty->next) + { + nbhomontype++; + DBGPRINTF ("homonymous #%d hty @ %p #%d '%s'", nbhomontype, + (void *) hty, hty->state_number, hty->u.s.tag); + /* Every member of the homonymous list should have the same tag. */ + gcc_assert (UNION_OR_STRUCT_P (hty)); + gcc_assert (hty->u.s.lang_struct == current); + if (!homoname) + homoname = hty->u.s.tag; + gcc_assert (strcmp (homoname, hty->u.s.tag) == 0); + } + fprintf (state_file, "(!homotypes %d\n", nbhomontype); + for (hty = current->u.s.lang_struct; hty != NULL; hty = hty->next) + write_state_type (hty); + fprintf (state_file, ")\n"); +} + +/* Write a parametrized structure GTY type. */ +static void +write_state_param_struct_type (type_p current) +{ + int i; + + fprintf (state_file, "param_struct "); + write_state_common_type_content (current); + write_state_type (current->u.param_struct.stru); + for (i = 0; i < NUM_PARAM; i++) + { + if (current->u.param_struct.param[i] != NULL) + write_state_type (current->u.param_struct.param[i]); + else + fprintf (state_file, "nil "); + } + write_state_fileloc (¤t->u.param_struct.line); +} + +/* Write a pointer type. */ +static void +write_state_pointer_type (type_p current) +{ + fprintf (state_file, "pointer "); + write_state_common_type_content (current); + write_state_type (current->u.p); +} + +/* Write an array type. */ +static void +write_state_array_type (type_p current) +{ + fprintf (state_file, "array "); + write_state_common_type_content (current); + if (current->u.a.len != NULL) + write_state_a_string (current->u.a.len); + else + fprintf (state_file, " nil"); + + fprintf (state_file, " "); + write_state_type (current->u.a.p); +} + +/* Write the gc_used information. */ +static void +write_state_gc_used (enum gc_used_enum gus) +{ + switch (gus) + { + case GC_UNUSED: + fprintf (state_file, " gc_unused"); + break; + case GC_USED: + fprintf (state_file, " gc_used"); + break; + case GC_MAYBE_POINTED_TO: + fprintf (state_file, " gc_maybe_pointed_to"); + break; + case GC_POINTED_TO: + fprintf (state_file, " gc_pointed_to"); + break; + } +} + +/* Utility routine to write the common content of all types. Notice + that the next field is *not* written on purpose. */ +static void +write_state_common_type_content (type_p current) +{ + fprintf (state_file, "%d ", current->state_number); + /* We do not write the next type, because list of types are + explicitly written. However, lang_struct are special in that + respect. See function write_state_lang_struct_type for more. */ + write_state_type (current->pointer_to); + write_state_gc_used (current->gc_used); +} + + +/* The important and recursive routine writing GTY types as understood + by gengtype. Types which have a positive state_number have already + been seen and written. */ +static void +write_state_type (type_p current) +{ + if (current == NULL) + { + fprintf (state_file, "nil "); + return; + } + + fprintf (state_file, "\n(!type "); + + if (current->state_number > 0) + fprintf (state_file, "already_seen %d", current->state_number); + else + { + state_written_type_count++; + DBGPRINTF ("writing type #%d @%p old number %d", state_written_type_count, + (void *) current, current->state_number); + current->state_number = state_written_type_count; + switch (current->kind) + { + case TYPE_STRUCT: + write_state_struct_type (current); + break; + case TYPE_UNION: + write_state_union_type (current); + break; + case TYPE_POINTER: + write_state_pointer_type (current); + break; + case TYPE_ARRAY: + write_state_array_type (current); + break; + case TYPE_LANG_STRUCT: + write_state_lang_struct_type (current); + break; + case TYPE_PARAM_STRUCT: + write_state_param_struct_type (current); + break; + case TYPE_SCALAR: + write_state_scalar_type (current); + break; + case TYPE_STRING: + write_state_string_type (current); + break; + + default: + fatal ("Unexpected type..."); + } + } + + fprintf (state_file, ")\n"); +} + + +/* Write a pair. */ +static void +write_state_pair (pair_p current) +{ + if (current == NULL) + { + fprintf (state_file, "nil)"); + return; + } + + fprintf (state_file, "\n(!pair "); + + if (current->name != NULL) + write_state_a_string (current->name); + else + write_state_a_string ("nil"); + + write_state_type (current->type); + write_state_fileloc (&(current->line)); + write_state_options (current->opt); + + fprintf (state_file, ")"); +} + +/* Write a pair list and return the number of pairs written. */ +static int +write_state_pair_list (pair_p list) +{ + int nbpair = 0; + pair_p current; + + for (current = list; current != NULL; current = current->next) + { + write_state_pair (current); + nbpair++; + } + return nbpair; + +} + +/* When writting imported linked lists, like typedefs, structures, + param_structs, ... we count their length first and write it. These + eases the reading, and enables an extra verification on the number + of actually read items. */ + +/* Write our typedefs. */ +static void +write_state_typedefs (void) +{ + int nbtypedefs = pair_list_length (typedefs); + int nbpairs = 0; + fprintf (state_file, "\n(!typedefs %d\n", nbtypedefs); + nbpairs = write_state_pair_list (typedefs); + gcc_assert (nbpairs == nbtypedefs); + fprintf (state_file, ")\n"); + if (verbosity_level >= 2) + printf ("%s wrote %d typedefs\n", progname, nbtypedefs); +} + +/* Write our structures. */ +static void +write_state_structures (void) +{ + int nbstruct = 0; + type_p current; + + for (current = structures; current != NULL; current = current->next) + nbstruct++; + + fprintf (state_file, "\n(!structures %d\n", nbstruct); + + for (current = structures; current != NULL; current = current->next) + write_state_type (current); + + fprintf (state_file, ")\n"); + if (verbosity_level >= 2) + printf ("%s wrote %d structures in state\n", progname, nbstruct); +} + +/* Write our param_struct-s. */ +static void +write_state_param_structs (void) +{ + int nbparamstruct = 0; + type_p current; + + for (current = param_structs; current != NULL; current = current->next) + nbparamstruct++; + + fprintf (state_file, "\n(!param_structs %d\n", nbparamstruct); + + for (current = param_structs; current != NULL; current = current->next) + write_state_type (current); + + fprintf (state_file, ")\n"); +} + +/* Write our variables. */ +static void +write_state_variables (void) +{ + int nbvars = pair_list_length (variables); + int nbpairs = 0; + fprintf (state_file, "\n(!variables %d\n", nbvars); + nbpairs = write_state_pair_list (variables); + gcc_assert (nbpairs == nbvars); + fprintf (state_file, ")\n"); + if (verbosity_level >= 2) + printf ("%s wrote %d variables.\n", progname, nbvars); +} + +/* Write the source directory. File locations within the source + directory have been written specifically. */ +static void +write_state_srcdir (void) +{ + fprintf (state_file, "\n(!srcdir "); + write_state_a_string (srcdir); + fprintf (state_file, ")\n"); +} + +/* Count and write the list of our files. */ +static void +write_state_files_list (void) +{ + int i = 0; + /* Write the list of files with their lang_bitmap. */ + fprintf (state_file, "\n(!fileslist %d\n", (int) num_gt_files); + for (i = 0; i < (int) num_gt_files; i++) + { + const char *cursrcrelpath = NULL; + input_file *curfil = gt_files[i]; + /* Most of the files are inside $(srcdir) so it is worth to + handle them specially. */ + cursrcrelpath = get_file_srcdir_relative_path (curfil); + if (cursrcrelpath) + { + fprintf (state_file, "(!srcfile %d ", get_lang_bitmap (curfil)); + write_state_a_string (cursrcrelpath); + } + else + { + fprintf (state_file, "(!file %d ", get_lang_bitmap (curfil)); + write_state_a_string (get_input_file_name (curfil)); + } + fprintf (state_file, ")\n"); + } + fprintf (state_file, ")\n"); +} + +/* Write the list of GCC front-end languages. */ +static void +write_state_languages (void) +{ + int i = 0; + fprintf (state_file, "\n(!languages %d", (int) num_lang_dirs); + for (i = 0; i < (int) num_lang_dirs; i++) + { + /* Languages names are identifiers, we expect only letters or + underscores or digits in them. In particular, C++ is not a + valid language name, but cp is valid. */ + fprintf (state_file, " %s", lang_dir_names[i]); + } + fprintf (state_file, ")\n"); +} + +/* Write the trailer. */ +static void +write_state_trailer (void) +{ + /* This test should probably catch IO errors like disk full... */ + if (fputs ("\n(!endfile)\n", state_file) == EOF) + fatal ("failed to write state trailer [%s]", xstrerror (errno)); +} + +/* The write_state routine is the only writing routine called by main + in gengtype.c. To avoid messing the state if gengtype is + interrupted or aborted, we write a temporary file and rename it + after having written it in totality. */ +void +write_state (const char *state_path) +{ + long statelen = 0; + time_t now = 0; + char *temp_state_path = NULL; + char tempsuffix[40]; + time (&now); + + /* We write a unique temporary file which is renamed when complete + * only. So even if gengtype is interrupted, the written state file + * won't be partially written, since the temporary file is not yet + * renamed in that case.... */ + memset (tempsuffix, 0, sizeof (tempsuffix)); + snprintf (tempsuffix, sizeof (tempsuffix) - 1, "-%ld-%d.tmp", (long) now, + (int) getpid ()); + temp_state_path = concat (state_path, tempsuffix, NULL); + state_file = fopen (temp_state_path, "w"); + if (state_file == NULL) + fatal ("Failed to open file %s for writing state: %s", + temp_state_path, xstrerror (errno)); + if (verbosity_level >= 3) + printf ("%s writing state file %s temporarily in %s\n", + progname, state_path, temp_state_path); + /* This is the first line of the state. Perhaps the file utility + could know about that, so don't change it often. */ + fprintf (state_file, ";;; @@@ GCC gengtype state\n"); + fprintf (state_file, + ";;; DON'T EDIT THIS FILE, since generated by GCC's gengtype\n"); + fprintf (state_file, + ";;; The format of this file is tied to a particular version of GCC.\n"); + fprintf (state_file, + ";;; Don't parse this file wihout knowing GCC gengtype internals.\n"); + fprintf (state_file, + ";;; This file should be parsed by the same %s who wrote it.\n", + progname); + fprintf (state_file, ";;; file %s generated on %s\n", state_path, + ctime (&now)); + /* The first non-comment significant line gives the version string. */ + write_state_version (version_string); + write_state_srcdir (); + write_state_languages (); + write_state_files_list (); + write_state_structures (); + /* The writing of structures probably wrote a lot, so we flush to + disk and check for errors, e.g. to catch disk full situations a + bit earlier. */ + if (fflush (state_file) || ferror (state_file)) + fatal ("output error when writing state file %s [%s]", + temp_state_path, xstrerror (errno)); + write_state_typedefs (); + write_state_param_structs (); + write_state_variables (); + write_state_trailer (); + statelen = ftell (state_file); + if (ferror (state_file)) + fatal ("output error when writing state file %s [%s]", + temp_state_path, xstrerror (errno)); + if (fclose (state_file)) + fatal ("failed to close state file %s [%s]", + temp_state_path, xstrerror (errno)); + if (rename (temp_state_path, state_path)) + fatal ("failed to rename %s to state file %s [%s]", temp_state_path, + state_path, xstrerror (errno)); + free (temp_state_path); + + if (verbosity_level >= 1) + printf ("%s wrote state file %s of %ld bytes with %d GTY-ed types\n", + progname, state_path, statelen, state_written_type_count); + +} + +/***************************************************************** + * End of writing routines! The corresponding reading routines follow. + *****************************************************************/ + + +/* Forward declarations, since some read_state_* functions are + recursive! */ +static void read_state_fileloc (struct fileloc *line); +static void read_state_options (options_p *opt); +static void read_state_type (type_p *current); +static void read_state_pair (pair_p *pair); +/* Return the number of pairs actually read. */ +static int read_state_pair_list (pair_p *list); +static void read_state_fields (pair_p *fields); +static void read_state_common_type_content (type_p current); + + + + +/* Record into the state_seen_types hash-table a type which we are + reading, to enable recursive or circular references to it. */ +static void +record_type (type_p type) +{ + PTR *slot; + + slot = htab_find_slot (state_seen_types, type, INSERT); + gcc_assert (slot); + + *slot = type; +} + +/* Read an already seen type. */ +static void +read_state_already_seen_type (type_p *type) +{ + struct state_token_st *t0; + + t0 = peek_state_token (0); + + if (state_token_kind (t0) == STOK_INTEGER) + { + PTR *slot = NULL; + struct type loctype = { TYPE_SCALAR, 0, 0, 0, GC_UNUSED, {0} }; + + loctype.state_number = t0->stok_un.stok_num; + slot = htab_find_slot (state_seen_types, &loctype, NO_INSERT); + if (slot == NULL) + { + fatal_reading_state (t0, "Unknown type"); + } + + next_state_tokens (1); + *type = (type_p) *slot; + } + else + { + fatal_reading_state (t0, "Bad seen type"); + } +} + + +/* Read the scalar_nonchar type. */ +static void +read_state_scalar_nonchar_type (type_p *type) +{ + *type = &scalar_nonchar; + read_state_common_type_content (*type); +} + + +/* Read the scalar_char type. */ +static void +read_state_scalar_char_type (type_p *type) +{ + *type = &scalar_char; + read_state_common_type_content (*type); +} + + +/* Read the string_type. */ +static void +read_state_string_type (type_p *type) +{ + *type = &string_type; + read_state_common_type_content (*type); +} + + +/* Read a lang_bitmap representing a set of GCC front-end languages. */ +static void +read_state_lang_bitmap (lang_bitmap *bitmap) +{ + struct state_token_st *t; + + t = peek_state_token (0); + if (state_token_kind (t) == STOK_INTEGER) + { + *bitmap = t->stok_un.stok_num; + next_state_tokens (1); + } + else + { + fatal_reading_state (t, "Bad syntax for bitmap"); + } +} + + +/* Read a GTY-ed struct type. */ +static void +read_state_struct_type (type_p type) +{ + struct state_token_st *t0; + + type->kind = TYPE_STRUCT; + read_state_common_type_content (type); + t0 = peek_state_token (0); + if (state_token_kind (t0) == STOK_STRING) + { + if (state_token_is_name (t0, "nil")) + { + type->u.s.tag = NULL; + DBGPRINTF ("read anonymous struct type @%p #%d", + (void *) type, type->state_number); + } + else + { + type->u.s.tag = xstrdup (t0->stok_un.stok_string); + DBGPRINTF ("read struct type @%p #%d '%s'", + (void *) type, type->state_number, type->u.s.tag); + } + + next_state_tokens (1); + read_state_fileloc (&(type->u.s.line)); + read_state_fields (&(type->u.s.fields)); + read_state_options (&(type->u.s.opt)); + read_state_lang_bitmap (&(type->u.s.bitmap)); + read_state_type (&(type->u.s.lang_struct)); + } + else + { + fatal_reading_state (t0, "Bad tag in struct type"); + } +} + + +/* Read a GTY-ed union type. */ +static void +read_state_union_type (type_p type) +{ + struct state_token_st *t0; + + type->kind = TYPE_UNION; + read_state_common_type_content (type); + t0 = peek_state_token (0); + if (state_token_kind (t0) == STOK_STRING) + { + if (state_token_is_name (t0, "nil")) + { + type->u.s.tag = NULL; + DBGPRINTF ("read anonymous union type @%p #%d", + (void *) type, type->state_number); + } + else + { + type->u.s.tag = xstrdup (t0->stok_un.stok_string); + DBGPRINTF ("read union type @%p #%d '%s'", + (void *) type, type->state_number, type->u.s.tag); + } + next_state_tokens (1); + read_state_fileloc (&(type->u.s.line)); + read_state_fields (&(type->u.s.fields)); + read_state_options (&(type->u.s.opt)); + read_state_lang_bitmap (&(type->u.s.bitmap)); + read_state_type (&(type->u.s.lang_struct)); + } + else + fatal_reading_state (t0, "Bad tag in union type"); +} + + +/* Read a GTY-ed pointer type. */ +static void +read_state_pointer_type (type_p type) +{ + type->kind = TYPE_POINTER; + read_state_common_type_content (type); + DBGPRINTF ("read pointer type @%p #%d", (void *) type, type->state_number); + read_state_type (&(type->u.p)); +} + + +/* Read a GTY-ed array type. */ +static void +read_state_array_type (type_p type) +{ + struct state_token_st *t0; + + type->kind = TYPE_ARRAY; + read_state_common_type_content (type); + t0 = peek_state_token (0); + if (state_token_kind (t0) == STOK_STRING) + { + type->u.a.len = xstrdup (t0->stok_un.stok_string); + DBGPRINTF ("read array type @%p #%d length '%s'", + (void *) type, type->state_number, type->u.a.len); + next_state_tokens (1); + } + + else if (state_token_is_name (t0, "nil")) + { + type->u.a.len = NULL; + DBGPRINTF ("read array type @%p #%d without length", + (void *) type, type->state_number); + next_state_tokens (1); + } + + else + fatal_reading_state (t0, "Bad array name type"); + read_state_type (&(type->u.a.p)); +} + + + +/* Read a lang_struct type for GTY-ed struct-s which depends upon GCC + front-end languages. This is a tricky function and it was painful + to debug. Change it with extreme care. See also + write_state_lang_struct_type. */ +static void +read_state_lang_struct_type (type_p type) +{ + struct state_token_st *t0 = NULL; + struct state_token_st *t1 = NULL; + struct state_token_st *t2 = NULL; + + type->kind = TYPE_LANG_STRUCT; + read_state_common_type_content (type); + t0 = peek_state_token (0); + if (state_token_kind (t0) == STOK_STRING) + { + if (state_token_is_name (t0, "nil")) + { + DBGPRINTF ("read anonymous lang_struct type @%p #%d", + (void *) type, type->state_number); + type->u.s.tag = NULL; + } + else + { + type->u.s.tag = xstrdup (t0->stok_un.stok_string); + DBGPRINTF ("read lang_struct type @%p #%d '%s'", + (void *) type, type->state_number, type->u.s.tag); + } + next_state_tokens (1); + } + else + fatal_reading_state (t0, "Bad tag in lang struct type"); + read_state_fileloc (&(type->u.s.line)); + read_state_fields (&(type->u.s.fields)); + read_state_options (&(type->u.s.opt)); + read_state_lang_bitmap (&(type->u.s.bitmap)); + /* Within lang_struct-ures, the lang_struct field is a linked list + of homonymous types! */ + t0 = peek_state_token (0); + t1 = peek_state_token (1); + t2 = peek_state_token (2); + /* Parse (!homotypes .... ) */ + if (state_token_kind (t0) == STOK_LEFTPAR + && state_token_is_name (t1, "!homotypes") + && state_token_kind (t2) == STOK_INTEGER) + { + type_p *prevty = &type->u.s.lang_struct; + int nbhomotype = t2->stok_un.stok_num; + int i = 0; + t0 = t1 = t2 = NULL; + next_state_tokens (3); + for (i = 0; i < nbhomotype; i++) + { + read_state_type (prevty); + t0 = peek_state_token (0); + if (*prevty) + prevty = &(*prevty)->next; + else + fatal_reading_state (t0, + "expecting type in homotype list for lang_struct"); + }; + if (state_token_kind (t0) != STOK_RIGHTPAR) + fatal_reading_state (t0, + "expecting ) in homotype list for lang_struct"); + next_state_tokens (1); + } + else + fatal_reading_state (t0, "expecting !homotypes for lang_struct"); +} + + +/* Read a param_struct type for GTY parametrized structures. */ +static void +read_state_param_struct_type (type_p type) +{ + int i; + struct state_token_st *t0; + + type->kind = TYPE_PARAM_STRUCT; + read_state_common_type_content (type); + DBGPRINTF ("read param_struct type @%p #%d", + (void *) type, type->state_number); + read_state_type (&(type->u.param_struct.stru)); + + for (i = 0; i < NUM_PARAM; i++) + { + t0 = peek_state_token (0); + if (state_token_is_name (t0, "nil")) + { + type->u.param_struct.param[i] = NULL; + next_state_tokens (1); + } + else + read_state_type (&(type->u.param_struct.param[i])); + } + read_state_fileloc (&(type->u.param_struct.line)); +} + + +/* Read the gc used information. */ +static void +read_state_gc_used (enum gc_used_enum *pgus) +{ + struct state_token_st *t0; + t0 = peek_state_token (0); + if (state_token_is_name (t0, "gc_unused")) + *pgus = GC_UNUSED; + else if (state_token_is_name (t0, "gc_used")) + *pgus = GC_USED; + else if (state_token_is_name (t0, "gc_maybe_pointed_to")) + *pgus = GC_MAYBE_POINTED_TO; + else if (state_token_is_name (t0, "gc_pointed_to")) + *pgus = GC_POINTED_TO; + else + fatal_reading_state (t0, "invalid gc_used information"); + next_state_tokens (1); +} + + +/* Utility function to read the common content of types. */ +static void +read_state_common_type_content (type_p current) +{ + struct state_token_st *t0; + + t0 = peek_state_token (0); + + if (state_token_kind (t0) == STOK_INTEGER) + { + current->state_number = t0->stok_un.stok_num; + next_state_tokens (1); + record_type (current); + } + else + fatal_reading_state_printf (t0, + "Expected integer for state_number line %d", + state_line); + /* We don't read the next field of the type. */ + read_state_type (¤t->pointer_to); + read_state_gc_used (¤t->gc_used); +} + + +/* Read a GTY-ed type. */ +void +read_state_type (type_p *current) +{ + struct state_token_st *t0; + struct state_token_st *t1; + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + + if (state_token_kind (t0) == STOK_LEFTPAR && + state_token_is_name (t1, "!type")) + { + next_state_tokens (2); + t0 = peek_state_token (0); + if (state_token_is_name (t0, "already_seen")) + { + next_state_tokens (1); + read_state_already_seen_type (current); + } + else + { + t0 = peek_state_token (0); + + if (state_token_is_name (t0, "scalar_nonchar")) + { + next_state_tokens (1); + read_state_scalar_nonchar_type (current); + } + else if (state_token_is_name (t0, "scalar_char")) + { + next_state_tokens (1); + read_state_scalar_char_type (current); + } + else if (state_token_is_name (t0, "string")) + { + next_state_tokens (1); + read_state_string_type (current); + } + else if (state_token_is_name (t0, "struct")) + { + *current = XCNEW (struct type); + next_state_tokens (1); + read_state_struct_type (*current); + } + else if (state_token_is_name (t0, "union")) + { + *current = XCNEW (struct type); + next_state_tokens (1); + read_state_union_type (*current); + } + else if (state_token_is_name (t0, "lang_struct")) + { + *current = XCNEW (struct type); + next_state_tokens (1); + read_state_lang_struct_type (*current); + } + else if (state_token_is_name (t0, "param_struct")) + { + *current = XCNEW (struct type); + next_state_tokens (1); + read_state_param_struct_type (*current); + } + else if (state_token_is_name (t0, "pointer")) + { + *current = XCNEW (struct type); + next_state_tokens (1); + read_state_pointer_type (*current); + } + else if (state_token_is_name (t0, "array")) + { + *current = XCNEW (struct type); + next_state_tokens (1); + read_state_array_type (*current); + } + else + fatal_reading_state (t0, "bad type in (!type"); + } + t0 = peek_state_token (0); + if (state_token_kind (t0) != STOK_RIGHTPAR) + fatal_reading_state (t0, "missing ) in type"); + next_state_tokens (1); + } + else if (state_token_is_name (t0, "nil")) + { + next_state_tokens (1); + *current = NULL; + } + else + fatal_reading_state (t0, "bad type syntax"); +} + + +/* Read a file location. Files within the source directory are dealt + with specifically. */ +void +read_state_fileloc (struct fileloc *floc) +{ + bool issrcfile = false; + struct state_token_st *t0; + struct state_token_st *t1; + + gcc_assert (floc != NULL); + gcc_assert (srcdir != NULL); + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + + if (state_token_kind (t0) == STOK_LEFTPAR && + (state_token_is_name (t1, "!fileloc") + || (issrcfile = state_token_is_name (t1, "!srcfileloc")))) + { + next_state_tokens (2); + t0 = peek_state_token (0); + t1 = peek_state_token (1); + if (state_token_kind (t0) == STOK_STRING && + state_token_kind (t1) == STOK_INTEGER) + { + char *path = t0->stok_un.stok_string; + if (issrcfile) + { + static const char dirsepstr[2] = { DIR_SEPARATOR, (char) 0 }; + char *fullpath = concat (srcdir, dirsepstr, path, NULL); + floc->file = input_file_by_name (fullpath); + free (fullpath); + } + else + floc->file = input_file_by_name (path); + floc->line = t1->stok_un.stok_num; + next_state_tokens (2); + } + else + fatal_reading_state (t0, + "Bad fileloc syntax, expected path string and line"); + t0 = peek_state_token (0); + if (state_token_kind (t0) != STOK_RIGHTPAR) + fatal_reading_state (t0, "Bad fileloc syntax, expected )"); + next_state_tokens (1); + } + else if (state_token_is_name (t0, "nil")) + { + next_state_tokens (1); + floc->file = NULL; + floc->line = 0; + } + else + fatal_reading_state (t0, "Bad fileloc syntax"); +} + + +/* Read the fields of a GTY-ed type. */ +void +read_state_fields (pair_p *fields) +{ + pair_p tmp = NULL; + struct state_token_st *t0; + struct state_token_st *t1; + struct state_token_st *t2; + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + t2 = peek_state_token (2); + + if (state_token_kind (t0) == STOK_LEFTPAR + && state_token_is_name (t1, "!fields") + && state_token_kind (t2) == STOK_INTEGER) + { + int nbfields = t2->stok_un.stok_num; + int nbpairs = 0; + next_state_tokens (3); + nbpairs = read_state_pair_list (&tmp); + t0 = peek_state_token (0); + if (nbpairs != nbfields) + fatal_reading_state_printf + (t0, + "Mismatched fields number, expected %d got %d", nbpairs, nbfields); + if (state_token_kind (t0) == STOK_RIGHTPAR) + next_state_tokens (1); + else + fatal_reading_state (t0, "Bad fields expecting )"); + } + + *fields = tmp; +} + + +/* Read a string option. */ +static void +read_state_string_option (options_p opt) +{ + struct state_token_st *t0; + + t0 = peek_state_token (0); + opt->kind = OPTION_STRING; + if (state_token_kind (t0) == STOK_STRING) + { + opt->info.string = xstrdup (t0->stok_un.stok_string); + next_state_tokens (1); + } + else if (state_token_is_name (t0, "nil")) + { + opt->info.string = NULL; + next_state_tokens (1); + } + else + fatal_reading_state (t0, "Missing name in string option"); +} + + +/* Read a type option. */ +static void +read_state_type_option (options_p opt) +{ + opt->kind = OPTION_TYPE; + read_state_type (&(opt->info.type)); +} + + +/* Read a nested option. */ +static void +read_state_nested_option (options_p opt) +{ + struct state_token_st *t0; + + opt->info.nested = XCNEW (struct nested_ptr_data); + opt->kind = OPTION_NESTED; + read_state_type (&(opt->info.nested->type)); + t0 = peek_state_token (0); + if (state_token_kind (t0) == STOK_STRING) + { + opt->info.nested->convert_from = xstrdup (t0->stok_un.stok_string); + next_state_tokens (1); + } + else if (state_token_is_name (t0, "nil")) + { + opt->info.nested->convert_from = NULL; + next_state_tokens (1); + } + else + fatal_reading_state (t0, "Bad nested convert_from option"); + + t0 = peek_state_token (0); + if (state_token_kind (t0) == STOK_STRING) + { + opt->info.nested->convert_to = xstrdup (t0->stok_un.stok_string); + next_state_tokens (1); + } + else if (state_token_is_name (t0, "nil")) + { + opt->info.nested->convert_to = NULL; + next_state_tokens (1); + } + else + fatal_reading_state (t0, "Bad nested convert_from option"); +} + + +/* Read an GTY option. */ +static void +read_state_option (options_p *opt) +{ + struct state_token_st *t0; + struct state_token_st *t1; + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + + if (state_token_kind (t0) == STOK_LEFTPAR && + state_token_is_name (t1, "!option")) + { + next_state_tokens (2); + t0 = peek_state_token (0); + if (state_token_kind (t0) == STOK_NAME) + { + *opt = XCNEW (struct options); + if (state_token_is_name (t0, "nil")) + (*opt)->name = NULL; + else + (*opt)->name = t0->stok_un.stok_ident->stid_name; + next_state_tokens (1); + t0 = peek_state_token (0); + if (state_token_kind (t0) == STOK_NAME) + { + if (state_token_is_name (t0, "string")) + { + next_state_tokens (1); + read_state_string_option (*opt); + } + else if (state_token_is_name (t0, "type")) + { + next_state_tokens (1); + read_state_type_option (*opt); + } + else if (state_token_is_name (t0, "nested")) + { + next_state_tokens (1); + read_state_nested_option (*opt); + } + else + fatal_reading_state (t0, "Bad option type"); + t0 = peek_state_token (0); + if (state_token_kind (t0) != STOK_RIGHTPAR) + fatal_reading_state (t0, "Bad syntax in option, expecting )"); + + next_state_tokens (1); + } + else + fatal_reading_state (t0, "Missing option type"); + } + else + fatal_reading_state (t0, "Bad name for option"); + } + else + fatal_reading_state (t0, "Bad option, waiting for )"); +} + +/* Read a list of options. */ +void +read_state_options (options_p *opt) +{ + options_p head = NULL; + options_p previous = NULL; + options_p current_option = NULL; + struct state_token_st *t0; + struct state_token_st *t1; + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + + if (state_token_kind (t0) == STOK_LEFTPAR && + state_token_is_name (t1, "!options")) + { + next_state_tokens (2); + t0 = peek_state_token (0); + while (state_token_kind (t0) != STOK_RIGHTPAR) + { + read_state_option (¤t_option); + if (head == NULL) + { + head = current_option; + previous = head; + } + else + { + previous->next = current_option; + previous = current_option; + } + t0 = peek_state_token (0); + } + next_state_tokens (1); + } + else if (state_token_is_name (t0, "nil")) + { + next_state_tokens (1); + } + else + fatal_reading_state (t0, "Bad options syntax"); + + *opt = head; +} + + +/* Read a version, and check against the version of the gengtype. */ +static void +read_state_version (const char *version_string) +{ + struct state_token_st *t0; + struct state_token_st *t1; + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + + if (state_token_kind (t0) == STOK_LEFTPAR && + state_token_is_name (t1, "!version")) + { + next_state_tokens (2); + t0 = peek_state_token (0); + t1 = peek_state_token (1); + if (state_token_kind (t0) == STOK_STRING && + state_token_kind (t1) == STOK_RIGHTPAR) + { + /* Check that the read version string is the same as current + version. */ + if (strcmp (version_string, t0->stok_un.stok_string)) + fatal_reading_state_printf (t0, + "version string mismatch; expecting %s but got %s", + version_string, + t0->stok_un.stok_string); + next_state_tokens (2); + } + else + fatal_reading_state (t0, "Missing version or right parenthesis"); + } + else + fatal_reading_state (t0, "Bad version syntax"); +} + + +/* Read a pair. */ +void +read_state_pair (pair_p *current) +{ + struct state_token_st *t0; + struct state_token_st *t1; + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + if (state_token_kind (t0) == STOK_LEFTPAR && + state_token_is_name (t1, "!pair")) + { + *current = XCNEW (struct pair); + next_state_tokens (2); + t0 = peek_state_token (0); + if (state_token_kind (t0) == STOK_STRING) + { + if (strcmp (t0->stok_un.stok_string, "nil") == 0) + { + (*current)->name = NULL; + } + else + { + (*current)->name = xstrdup (t0->stok_un.stok_string); + } + next_state_tokens (1); + read_state_type (&((*current)->type)); + read_state_fileloc (&((*current)->line)); + read_state_options (&((*current)->opt));; + t0 = peek_state_token (0); + if (state_token_kind (t0) == STOK_RIGHTPAR) + { + next_state_tokens (1); + } + else + { + fatal_reading_state (t0, "Bad syntax for pair, )"); + } + } + else + { + fatal_reading_state (t0, "Bad name for pair"); + } + } + else if (state_token_kind (t0) == STOK_NAME && + state_token_is_name (t0, "nil")) + { + next_state_tokens (1); + *current = NULL; + } + else + fatal_reading_state_printf (t0, "Bad syntax for pair, (!pair %d", + state_token->stok_kind); +} + + +/* Return the number of pairs actually read. */ +int +read_state_pair_list (pair_p *list) +{ + int nbpair = 0; + pair_p head = NULL; + pair_p previous = NULL; + pair_p tmp = NULL; + struct state_token_st *t0; + t0 = peek_state_token (0); + while (t0 && state_token_kind (t0) != STOK_RIGHTPAR) + { + read_state_pair (&tmp); + if (head == NULL) + { + head = tmp; + previous = head; + } + else + { + previous->next = tmp; + previous = tmp; + } + t0 = peek_state_token (0); + nbpair++; + } + + /* don't consume the ); the caller will eat it. */ + *list = head; + return nbpair; +} + +/* Read the typedefs. */ +static void +read_state_typedefs (pair_p *typedefs) +{ + int nbtypedefs = 0; + pair_p list = NULL; + struct state_token_st *t0; + struct state_token_st *t1; + struct state_token_st *t2; + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + t2 = peek_state_token (2); + + if (state_token_kind (t0) == STOK_LEFTPAR + && state_token_is_name (t1, "!typedefs") + && state_token_kind (t2) == STOK_INTEGER) + { + int nbpairs = 0; + nbtypedefs = t2->stok_un.stok_num; + next_state_tokens (3); + nbpairs = read_state_pair_list (&list); + t0 = peek_state_token (0); + if (nbpairs != nbtypedefs) + fatal_reading_state_printf + (t0, + "invalid number of typedefs, expected %d but got %d", + nbtypedefs, nbpairs); + if (state_token_kind (t0) == STOK_RIGHTPAR) + next_state_tokens (1); + else + fatal_reading_state (t0, "Bad typedefs syntax )"); + } + else + fatal_reading_state (t0, "Bad typedefs syntax (!typedefs"); + + if (verbosity_level >= 2) + printf ("%s read %d typedefs from state\n", progname, nbtypedefs); + *typedefs = list; +} + + +/* Read the structures. */ +static void +read_state_structures (type_p *structures) +{ + type_p head = NULL; + type_p previous; + type_p tmp; + int nbstruct = 0, countstruct = 0; + struct state_token_st *t0; + struct state_token_st *t1; + struct state_token_st *t2; + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + t2 = peek_state_token (2); + + if (state_token_kind (t0) == STOK_LEFTPAR + && state_token_is_name (t1, "!structures") + && state_token_kind (t2) == STOK_INTEGER) + { + nbstruct = t2->stok_un.stok_num; + next_state_tokens (3); + t0 = peek_state_token (0); + while (t0 && state_token_kind (t0) != STOK_RIGHTPAR) + { + tmp = NULL; + read_state_type (&tmp); + countstruct++; + if (head == NULL) + { + head = tmp; + previous = head; + } + else + { + previous->next = tmp; + previous = tmp; + } + t0 = peek_state_token (0); + } + next_state_tokens (1); + } + else + fatal_reading_state (t0, "Bad structures syntax"); + if (countstruct != nbstruct) + fatal_reading_state_printf (NULL_STATE_TOKEN, + "expected %d structures but got %d", + nbstruct, countstruct); + if (verbosity_level >= 2) + printf ("%s read %d structures from state\n", progname, nbstruct); + *structures = head; +} + + +/* Read the param_struct-s. */ +static void +read_state_param_structs (type_p *param_structs) +{ + int nbparamstructs = 0; + int countparamstructs = 0; + type_p head = NULL; + type_p previous; + type_p tmp; + struct state_token_st *t0; + struct state_token_st *t1; + struct state_token_st *t2; + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + t2 = peek_state_token (2); + + if (state_token_kind (t0) == STOK_LEFTPAR + && state_token_is_name (t1, "!param_structs") + && state_token_kind (t2) == STOK_INTEGER) + { + nbparamstructs = t2->stok_un.stok_num; + next_state_tokens (3); + t0 = t1 = t2 = NULL; + t0 = peek_state_token (0); + while (state_token_kind (t0) != STOK_RIGHTPAR) + { + tmp = NULL; + read_state_type (&tmp); + if (head == NULL) + { + head = tmp; + previous = head; + } + else + { + previous->next = tmp; + previous = tmp; + } + t0 = peek_state_token (0); + countparamstructs++; + } + next_state_tokens (1); + } + else + fatal_reading_state (t0, "Bad param_structs syntax"); + t0 = peek_state_token (0); + if (countparamstructs != nbparamstructs) + fatal_reading_state_printf + (t0, + "invalid number of param_structs expected %d got %d", + nbparamstructs, countparamstructs); + *param_structs = head; +} + + +/* Read the variables. */ +static void +read_state_variables (pair_p *variables) +{ + pair_p list = NULL; + int nbvars = 0; + struct state_token_st *t0; + struct state_token_st *t1; + struct state_token_st *t2; + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + t2 = peek_state_token (2); + + if (state_token_kind (t0) == STOK_LEFTPAR + && state_token_is_name (t1, "!variables") + && state_token_kind (t2) == STOK_INTEGER) + { + int nbpairs = 0; + nbvars = t2->stok_un.stok_num; + next_state_tokens (3); + nbpairs = read_state_pair_list (&list); + t0 = peek_state_token (0); + if (nbpairs != nbvars) + fatal_reading_state_printf + (t0, "Invalid number of variables, expected %d but got %d", + nbvars, nbpairs); + if (state_token_kind (t0) == STOK_RIGHTPAR) + next_state_tokens (1); + else + fatal_reading_state (t0, "Waiting for ) in variables"); + } + else + fatal_reading_state (t0, "Bad variables syntax"); + *variables = list; + if (verbosity_level >= 2) + printf ("%s read %d variables from state\n", progname, nbvars); +} + + +/* Read the source directory. */ +static void +read_state_srcdir (void) +{ + struct state_token_st *t0 = NULL; + struct state_token_st *t1 = NULL; + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + if (state_token_kind (t0) == STOK_LEFTPAR && + state_token_is_name (t1, "!srcdir")) + { + next_state_tokens (2); + t0 = peek_state_token (0); + t1 = peek_state_token (1); + if (state_token_kind (t0) == STOK_STRING && + state_token_kind (t1) == STOK_RIGHTPAR) + { + srcdir = xstrdup (t0->stok_un.stok_string); + srcdir_len = strlen (srcdir); + next_state_tokens (2); + return; + } + } + + fatal_reading_state (t0, "Bad srcdir in state_file"); +} + + +/* Read the sequence of GCC front-end languages. */ +static void +read_state_languages (void) +{ + struct state_token_st *t0 = NULL; + struct state_token_st *t1 = NULL; + struct state_token_st *t2 = NULL; + t0 = peek_state_token (0); + t1 = peek_state_token (1); + t2 = peek_state_token (2); + if (state_token_kind (t0) == STOK_LEFTPAR + && state_token_is_name (t1, "!languages") + && state_token_kind (t2) == STOK_INTEGER) + { + int i = 0; + num_lang_dirs = t2->stok_un.stok_num; + lang_dir_names = XCNEWVEC (const char *, num_lang_dirs); + next_state_tokens (3); + t0 = t1 = t2 = NULL; + for (i = 0; i < (int) num_lang_dirs; i++) + { + t0 = peek_state_token (0); + if (state_token_kind (t0) != STOK_NAME) + fatal_reading_state (t0, "expecting language name in state file"); + lang_dir_names[i] = t0->stok_un.stok_ident->stid_name; + next_state_tokens (1); + } + t0 = peek_state_token (0); + if (state_token_kind (t0) != STOK_RIGHTPAR) + fatal_reading_state (t0, "missing ) in languages list of state file"); + next_state_tokens (1); + } + else + fatal_reading_state (t0, "expecting languages list in state file"); + +} + +/* Read the sequences of files. */ +static void +read_state_files_list (void) +{ + struct state_token_st *t0 = NULL; + struct state_token_st *t1 = NULL; + struct state_token_st *t2 = NULL; + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + t2 = peek_state_token (2); + + if (state_token_kind (t0) == STOK_LEFTPAR + && state_token_is_name (t1, "!fileslist") + && state_token_kind (t2) == STOK_INTEGER) + { + int i = 0; + num_gt_files = t2->stok_un.stok_num; + next_state_tokens (3); + t0 = t1 = t2 = NULL; + gt_files = XCNEWVEC (input_file *, num_gt_files); + for (i = 0; i < (int) num_gt_files; i++) + { + bool issrcfile = FALSE; + t0 = t1 = t2 = NULL; + t0 = peek_state_token (0); + t1 = peek_state_token (1); + t2 = peek_state_token (2); + if (state_token_kind (t0) == STOK_LEFTPAR + && (state_token_is_name (t1, "!file") + || (issrcfile = state_token_is_name (t1, "!srcfile"))) + && state_token_kind (t2) == STOK_INTEGER) + { + lang_bitmap bmap = t2->stok_un.stok_num; + next_state_tokens (3); + t0 = t1 = t2 = NULL; + t0 = peek_state_token (0); + t1 = peek_state_token (1); + if (state_token_kind (t0) == STOK_STRING + && state_token_kind (t1) == STOK_RIGHTPAR) + { + const char *fnam = t0->stok_un.stok_string; + /* Allocate & fill a gt_file entry with space for the lang_bitmap before! */ + input_file *curgt = NULL; + if (issrcfile) + { + static const char dirsepstr[2] = + { DIR_SEPARATOR, (char) 0 }; + char *fullpath = concat (srcdir, dirsepstr, fnam, NULL); + curgt = input_file_by_name (fullpath); + free (fullpath); + } + else + curgt = input_file_by_name (fnam); + set_lang_bitmap (curgt, bmap); + gt_files[i] = curgt; + next_state_tokens (2); + } + else + fatal_reading_state (t0, + "bad file in !fileslist of state file"); + } + else + fatal_reading_state (t0, + "expecting file in !fileslist of state file"); + }; + t0 = peek_state_token (0); + if (!state_token_kind (t0) == STOK_RIGHTPAR) + fatal_reading_state (t0, "missing ) for !fileslist in state file"); + next_state_tokens (1); + } + else + fatal_reading_state (t0, "missing !fileslist in state file"); +} + + +/* Read the trailer. */ +static void +read_state_trailer (void) +{ + struct state_token_st *t0 = NULL; + struct state_token_st *t1 = NULL; + struct state_token_st *t2 = NULL; + + t0 = peek_state_token (0); + t1 = peek_state_token (1); + t2 = peek_state_token (2); + + if (state_token_kind (t0) == STOK_LEFTPAR + && state_token_is_name (t1, "!endfile") + && state_token_kind (t2) == STOK_RIGHTPAR) + next_state_tokens (3); + else + fatal_reading_state (t0, "missing !endfile in state file"); +} + + +/* Utility functions for the state_seen_types hash table. */ +static unsigned +hash_type_number (const void *ty) +{ + const struct type *type = (const struct type *) ty; + + return type->state_number; +} + +static int +equals_type_number (const void *ty1, const void *ty2) +{ + const struct type *type1 = (const struct type *) ty1; + const struct type *type2 = (const struct type *) ty2; + + return type1->state_number == type2->state_number; +} + + +/* The function reading the state, called by main from gengtype.c. */ +void +read_state (const char *path) +{ + state_file = fopen (path, "r"); + if (state_file == NULL) + fatal ("Failed to open state file %s for reading [%s]", path, + xstrerror (errno)); + state_path = path; + state_line = 1; + + if (verbosity_level >= 1) + { + printf ("%s reading state file %s;", progname, state_path); + if (verbosity_level >= 2) + putchar ('\n'); + fflush (stdout); + } + + state_seen_types = + htab_create (2017, hash_type_number, equals_type_number, NULL); + state_ident_tab = + htab_create (4027, htab_hash_string, (htab_eq) strcmp, NULL); + read_state_version (version_string); + read_state_srcdir (); + read_state_languages (); + read_state_files_list (); + read_state_structures (&structures); + if (ferror (state_file)) + fatal_reading_state_printf + (NULL_STATE_TOKEN, "input error while reading state [%s]", + xstrerror (errno)); + read_state_typedefs (&typedefs); + read_state_param_structs (¶m_structs); + read_state_variables (&variables); + read_state_trailer (); + + if (verbosity_level >= 1) + { + printf ("%s read %ld bytes.\n", progname, ftell (state_file)); + fflush (stdout); + }; + + if (fclose (state_file)) + fatal ("failed to close read state file %s [%s]", + path, xstrerror (errno)); + state_file = NULL; + state_path = NULL; +} + +/* End of file gengtype-state.c. */ --- ../thirdround_05_typedopt//gengtype.c 2010-09-21 16:16:19.000000000 +0200 +++ gcc/gengtype.c 2010-09-21 19:40:11.000000000 +0200 @@ -70,6 +70,10 @@ int do_debug; /* For verbose messages to the user. */ int verbosity_level; +/* We have a type count and use it to set the state_number of newly + allocated types to some unique negative number. */ +static int type_count; + /* The backup directory should be in the same file-system as the generated files, otherwise the rename(2) system call would fail. If NULL, no backup is made when overwriting a generated file. */ @@ -572,12 +576,14 @@ new_structure (const char *name, int isu else if (si->u.s.line.file != NULL && si->u.s.bitmap != bitmap) { ls = si; + type_count++; si = XCNEW (struct type); memcpy (si, ls, sizeof (struct type)); ls->kind = TYPE_LANG_STRUCT; ls->u.s.lang_struct = si; ls->u.s.fields = NULL; si->next = NULL; + si->state_number = -type_count; si->pointer_to = NULL; si->u.s.lang_struct = ls; } @@ -587,6 +593,8 @@ new_structure (const char *name, int isu if (ls != NULL && s == NULL) { s = XCNEW (struct type); + type_count++; + s->state_number = -type_count; s->next = ls->u.s.lang_struct; ls->u.s.lang_struct = s; s->u.s.lang_struct = ls; @@ -598,6 +606,8 @@ new_structure (const char *name, int isu { s = XCNEW (struct type); s->next = structures; + type_count++; + s->state_number = -type_count; structures = s; } @@ -634,11 +644,12 @@ find_structure (const char *name, int is if (strcmp (name, s->u.s.tag) == 0 && UNION_P (s) == isunion) return s; - - s = XCNEW (struct type); + s = XCNEW (struct type); + type_count++; s->next = structures; structures = s; s->kind = isunion ? TYPE_UNION : TYPE_STRUCT; + s->state_number = -type_count; s->u.s.tag = name; structures = s; return s; @@ -661,8 +672,10 @@ find_param_structure (type_p t, type_p p if (res == NULL) { res = XCNEW (struct type); + type_count++; res->kind = TYPE_PARAM_STRUCT; res->next = param_structs; + res->state_number = -type_count; param_structs = res; res->u.param_struct.stru = t; memcpy (res->u.param_struct.param, param, sizeof (type_p) * NUM_PARAM); @@ -689,7 +702,9 @@ create_pointer (type_p t) if (! t->pointer_to) { type_p r = XCNEW (struct type); + type_count++; r->kind = TYPE_POINTER; + r->state_number = -type_count; r->u.p = t; t->pointer_to = r; } @@ -703,8 +718,10 @@ create_array (type_p t, const char *len) { type_p v; - v = XCNEW (struct type); + v = XCNEW (struct type); v->kind = TYPE_ARRAY; + type_count++; + v->state_number = -type_count; v->u.a.p = t; v->u.a.len = len; return v; @@ -4571,8 +4588,10 @@ dump_structures (const char * name, type printf ("End of %s\n\n", name); } -/* Dumps the internal structures of gengtype. */ - +/* Dumps the internal structures of gengtype. This can be used to + debug gengtype itself, or perhaps to understand what is happenning, + e.g. the role of some difficult to grasp GTY-s. So it might be + useful for plugin or GCC developers. */ static void dump_everything (void) { @@ -4787,8 +4806,12 @@ main (int argc, char **argv) static struct fileloc pos = { NULL, 0 }; outf_p output_header; - /* Mandatory common initializations. */ + /* Mandatory common initializations. */ progname = "gengtype"; /* For fatal and messages. */ + /* Initialize the state number of statically predefined types. */ + string_type.state_number = - (++type_count); + scalar_nonchar.state_number = - (++type_count); + scalar_char.state_number = - (++type_count); /* Set the scalar_is_char union number for predefined scalar types. */ scalar_nonchar.u.scalar_is_char = FALSE; scalar_char.u.scalar_is_char = TRUE; @@ -4815,8 +4838,12 @@ main (int argc, char **argv) DBGPRINTF ("inputlist %s", inputlist); if (read_state_filename) { - fatal ("read state %s not implemented yet", read_state_filename); - /* TODO: implement read state. */ + if (inputlist) + fatal ("input list %s cannot be given with a read state file %s", + inputlist, read_state_filename); + read_state (read_state_filename); + DBGPRINT_COUNT_TYPE ("structures after read_state", structures); + DBGPRINT_COUNT_TYPE ("param_structs after read_state", param_structs); } else if (inputlist) { @@ -4844,9 +4871,9 @@ main (int argc, char **argv) DBGPRINT_COUNT_TYPE ("structures after parsing", structures); DBGPRINT_COUNT_TYPE ("param_structs after parsing", param_structs); if (verbosity_level >= 1) - printf ("%s parsed %d files\n", progname, (int) num_gt_files); - - } + printf ("%s parsed %d files with %d GTY types\n", + progname, (int) num_gt_files, type_count); + } else fatal ("either an input list or a read state file should be given"); if (hit_error) @@ -4893,11 +4920,30 @@ main (int argc, char **argv) happen before writing the state. */ set_gc_used (variables); - /* We should write the state here, but it is not yet implemented. */ + + /* We write the state here. It could eventually happen that the + state file is written after some plugin files have been parsed, + perhaps to enlarge the state file for other plugins needs. But + this is an uncommon scenario. */ if (write_state_filename) { - fatal ("write state %s in not yet implemented", write_state_filename); - /* TODO: implement write state. */ + DBGPRINT_COUNT_TYPE ("structures before writestate", structures); + DBGPRINT_COUNT_TYPE ("param_structs before writestate", param_structs); + /* We definitely don't want to write a state file if some error + occurred while reading input files processed by gengtype, + because we only want to write sane state files! */ + if (hit_error) + fatal ("won't write state %s after errors", write_state_filename); + write_state (write_state_filename); + if (do_dump) + dump_everything (); + + /* After having written the state file we return immediately to + avoid generating any output file. */ + if (hit_error) + return 1; + else + return 0; } --- ../thirdround_05_typedopt//gengtype.h 2010-09-21 16:11:46.000000000 +0200 +++ gcc/gengtype.h 2010-09-21 19:40:29.000000000 +0200 @@ -434,6 +434,13 @@ extern size_t srcdir_len; extern const char *read_state_filename; extern const char *write_state_filename; +/* Functions reading and writing the entire gengtype state, called from + main, and implemented in file gengtype-state.c. */ +void read_state (const char* path); +/* Write the state, and update the state_number field in types. */ +void write_state (const char* path); + + /* Print an error message. */ extern void error_at_line (const struct fileloc *pos, const char *msg, ...) ATTRIBUTE_PRINTF_2; --- ../thirdround_05_typedopt//Makefile.in 2010-09-20 21:13:15.000000000 +0200 +++ gcc/Makefile.in 2010-09-21 19:41:05.000000000 +0200 @@ -1492,7 +1492,7 @@ MOSTLYCLEANFILES = insn-flags.h insn-con insn-attr.h insn-attrtab.c insn-opinit.c insn-preds.c insn-constants.h \ tm-preds.h tm-constrs.h \ tree-check.h min-insn-modes.c insn-modes.c insn-modes.h \ - genrtl.h gt-*.h gtype-*.h gtype-desc.c gtyp-input.list \ + genrtl.h gt-*.h gtype-*.h gtype-desc.c gtyp-input.list gtype.state \ xgcc$(exeext) cpp$(exeext) cc1$(exeext) cc1*-dummy$(exeext) $(EXTRA_PASSES) \ $(EXTRA_PARTS) $(EXTRA_PROGRAMS) gcc-cross$(exeext) \ $(SPECS) collect2$(exeext) lto-wrapper$(exeext) \ @@ -3798,6 +3798,9 @@ ALL_GTFILES_H := $(sort $(GTFILES_H) $(G $(ALL_GTFILES_H) gtype-desc.c gtype-desc.h : s-gtype ; @true +## Common flags to gengtype [e.g. -v for verbosity or -B . for backups]. +GENGTYPE_FLAGS = + gtyp-input.list: s-gtyp-input ; @true s-gtyp-input: Makefile @: $(call write_entries_to_file,$(GTFILES),tmp-gi.list) @@ -3806,7 +3809,13 @@ s-gtyp-input: Makefile s-gtype: build/gengtype$(build_exeext) $(filter-out [%], $(GTFILES)) \ gtyp-input.list - $(RUN_GEN) build/gengtype$(build_exeext) -S $(srcdir) -I gtyp-input.list +# First, parse all files and save a state file. + $(RUN_GEN) build/gengtype$(build_exeext) $(GENGTYPE_FLAGS) \ + -S $(srcdir) -I gtyp-input.list -w gtype.state +# Second, read the state file and generate all files. This ensure that +# gtype.state is correctly read: + $(RUN_GEN) build/gengtype$(build_exeext) $(GENGTYPE_FLAGS) \ + -r gtype.state $(STAMP) s-gtype generated_files = config.h tm.h $(TM_P_H) $(TM_H) multilib.h \ @@ -3902,6 +3911,8 @@ build/gengenrtl.o : gengenrtl.c $(BCONFI build/gengtype-lex.o : gengtype-lex.c gengtype.h $(BCONFIG_H) $(SYSTEM_H) build/gengtype-parse.o : gengtype-parse.c gengtype.h $(BCONFIG_H) \ $(SYSTEM_H) +build/gengtype-state.o : gengtype-state.c gengtype.h $(BCONFIG_H) \ + $(SYSTEM_H) errors.h build/gengtype.o : gengtype.c $(BCONFIG_H) $(SYSTEM_H) gengtype.h \ rtl.def insn-notes.def errors.h double-int.h $(HASHTAB_H) build/genmddeps.o: genmddeps.c $(BCONFIG_H) $(SYSTEM_H) coretypes.h \ @@ -3948,7 +3959,7 @@ build/genautomata$(build_exeext) : BUILD # These programs are not linked with the MD reader. build/gengtype$(build_exeext) : build/gengtype-lex.o build/gengtype-parse.o \ - build/version.o + build/gengtype-state.o build/version.o build/genhooks$(build_exeext) : $(BUILD_ERRORS) # Generated source files for gengtype. @@ -4404,6 +4415,7 @@ mostlyclean: lang.mostlyclean # Delete files generated by gengtype.c -rm -f gtype-* -rm -f gt-* + -rm gtype.state # Delete genchecksum outputs -rm -f *-checksum.c --Multipart=_Tue__21_Sep_2010_21_31_51_+0200_l=7Nwv6JCGIhGwng Content-Type: application/octet-stream; name="cumulatedpatch6_wstate-gengtypethird-r164437.diff.gz" Content-Disposition: attachment; filename="cumulatedpatch6_wstate-gengtypethird-r164437.diff.gz" Content-Transfer-Encoding: base64 Content-length: 57149 H4sICHrymEwCA2N1bXVsYXRlZHBhdGNoNl93c3RhdGUtZ2VuZ3R5cGV0aGly ZC1yMTY0NDM3LmRpZmYA7b1pexs3sjD6mX7Oj4CV2BIlUtHiXXFOFFl2dMeW /UjyZHITX06LbEo8Jtmc7qZljcf3t9/aABR64SI7s7z3+MyJ2N1AASgUCoVC LUfjXvzxibnodr+7iMcX+fUkbmd5lMeb3VtPv/zfrXa7XQm8sZbGHwbZIBmb reatjY2NBUr9+KNpb7W2zMZ2a+feg8fmxx9vbXy3bl5IJTOJ02yQ5fE4N1Tf ZHE6iIaDv0c5QrhregBYv9q8tWGMeZvF/enQ9JPU2PbNYGwmw+kF/BklvRjK UcmDZHKdDi4uc7N20DQ7W9tbxjxP49icJv38Kkpj8zyZjnsEu2WOxl1b8exy kJn+YAiAMzOJ0twkffPi4MB+h5/4pY+wMoG1Z66TqelGY5PGPRhWOjifwpgG uYnGve+gs9CzQf8aX0CbcUqA8svY5HE6yrABfHhx/BYRFKfR0LyZng8HXfNy 0I3HWWwi6Aq+yS7jnjm/puI4GgJUMaI9Ew+gTGo+IJ4BobstA91Yi3LsaWqS CZZqQveuzRDQzz2SwoWR+gH1ENfY9GUCeM8vARqM6GowHJrz2ExpbloGSppf js5+fv32zOwf/0qgftk/Odk/Pvt1D0rnlwmUiD/EDGswmgwHABpGkEbj/Bqx 8erw5OBnKL//09HLo7NfoesE5fnR2fHh6al5/vrE7Js3+ydnRwdvX+6fmDdv T968Pj3cBFzE8RxcEqQ+zQmgrBfn0WCY2SH/CtOYQf+GPXMZfYhhOrvx4AP0 LjJdIKj5M0VQomEyvqCRIg73gLa5U0RVB6/f/Hp0/GIXOnvUN+Mkx89U7fvL PJ88+e67q6urzYvxdDNJL74bMtjsux88YY/ddAAl/F9xGo8GQNbR8MO02x2Y 7/+H32xm8uZHJNXNfvoD923cMz9FGfbkNI/S6/F7WLV599J8f05vf8z0281x nEO99e+w8W8G4+5w2ovNynk3GfcHF5uXK/ptdg0LelR4eRHnQGyFl3GaJmkG LxvAE57DXPSjPBoCRrAhX6yXAG7j9mBcrH8ZZZd5dF54a8nXg5U3HSRgmJG7 ZvL+InxXajM5BwR03xdAf0zji/hjaWjMgeg1/h+0egbTzAyNJhs6ajKi8CwH IoE/QETD+OOgC5STJ+9hbpEO8gxfwnK9AGLLeJ6gMMxCD+sQC4L+TrvCLTtU FYbQArpKp0Rckzh+31Ffmc6n4y5xT2NeBq0a5Bcwi9l0hGsPSXUcf8w1gExw o0Zme/5+AFQEfYojIBweFFWRGvF4Ogo6ir35hB06PXv9p87x6+PDVqOBk3QM bCBFztGTqlLk6Pjs8MXhSYsKHY1zwH4aNCHlTs9OYC0JsFOe5YpiLw+fnwG7 YHAv436OjB32nssYNqGw6MnRi5992RPaQWoLH++/OuS2kSLbiE/A5jgaxcht Bz2oNegP4lRqfd5z2Dyl2ZzCJOCCpNpA0EPioj0YAnAhnCEPIkOICNl2IaAH KgeTJ2jG6Xr97PUT8wtOMnIzoME0+cBsCIYDWysyjzSGHx8QabqhvrBbI5T8 Pr6+StJeRl2Nej0sH9m3Bub6HKAhRwXgo03cQWFjuMJmBcwohp3RVgSOhxsT NDWU/QT2mHAUQusO113ABbwb9DqIgN+23+0RziNAYDQcXpvzwQXSx13oC2xF uKcOxhHyR4t0BA/LD3lGJ0QZvNkrL163vqQnOE8DQkxh8doNMY0jHqxf+4QI hJe879B64RHDbtpNB9zBjOpOx7xAzwgiL36ki+Ew6UbC5YuL21xdDmDpQUeG GTXeiUprn4tYMG5y/PLHfYGgM5g8oWpVbIAqUR3Yk6Lx4O8sCkSwIz9/bYZJ 8r4dXUIvzN+m8VR2WJAKqvteRb8W30K/FQzEI3IP5z4vcKNbGw38Bw2XEUw1 p2NfhDBuiWtAIiiUAH4bM2ERcHiytF0o2E2Gew1XEJ6mo3FYFBlBzmS7TlWQ IFy/aWeYRMByuXQlJqQizoariA9MeEJ3fkiE+BbMOXxDhAvxy1gb3F2NGpoa h9PbUvoTr1g3VBgVo4QAa9YsFdziTN7LjkrLM6ghTFrWK+yHf8fVxH0HALJ6 kblUrV/mQxW8TjBEj4UWj54dHp+52h+SQU8KT/KUx0MtESe6GoB8zUU/82wQ tex5dk2yTy/uI0Ucv335Ega0f3bYgYYOj81a5eytN7eEp+QhTzGTBJALwwUS AclznAkl9/NRgiQzTXGrcXvY2SWvJrVpF1agSAky/9MMeayjnBazZccS/Eqd tQgRV77DT0tj3pOhvc38YQR5EDZNYowDTlz3+dHLQwuS1oH7Ei4T/E6rglv0 xQb2kEhLFD5v+W8kafPH82RI33B6k34/i0lsOo/hZDjGrsED1VcyzQEcmHAy 4NNVOshzPJKAQJeFA/DtS6EOFgI2AJWlNwLvOYqxhqRb2PSyLLoAFkRkafHj yIEn95qmFGYKRPZ4eE2TNB0PB+/hoUVLIhnDBhdNJjEgiSDRflk8fLsD6/n0 4uK6RXCSNGw68kdm3qV4g7gCERVPIRd0nsndlPJ2hqKMPUMClhwEAI5n4kBC 5NHLuBH60NOFHTMJ27KWSOjvSAneIdZgp2m9yi6awMcT86nR+L2CAbhFZs6j HjzAHEC1PVd40Ddr/KVJ7FFeG27QrK3cyZ7c6eH/QLT8EA2BO/hte8+sGOhA C2s1uBrDav/gOHmLgVZ9Rgqb8Rk2i+ae71I8zOLGrD4u1kG/dlpqofiGPvNk rKH2Zib6OxPg4HmfZuH5KG9tbm42eSL+JfOAXfjD5qFlOp0/73f2T16cdjrN vS+eE+qsb696ToqNVkwPLyU6YKVeegMB2ovoyPlRi0MHDTw7GDo7hFyrZs/k 7/bN+TWJ1GZNs2J802IZDDaoOM07rC4irdE4a4qQ9uYMhIBsmOSeYbPkAPWH tHFs7ZXEG715AwpdTaoL9HKbuvOPfxj68dvWuyZPQhqDED7WpaVlkumBnnsd erFWEO5bhkcjXd9z7WDpWthuBNB3/LGGQJoyGuw2V1yrGVrTfBzRzEEJ2KmB b1aXbJoNJwXhP26W2xnFI9zB1rC9ltlqmXmQgtpQqAuHcqqNJC9HJ8YGF7FT hx9l2IIIefNZaPH1VEQI0VHALgMSxIcB7EuA0skg5S3j1eHLs1XRY/DWxUfY LBnxXtJNejFrGpwQjHpk2Pfydgpb6WCEG5nVsB0cEERznkbj7uVtA0dZggL8 Co98VxFKSVCwsKfByfkcNlRUZV3TQZcO1dK9TdbuEhwYRQTiEgqkXisDG1Wa THNaqD1oaGDVeNkk6sZ8AO4moxEgPeNNlsX+rKV1BIzlDNc9CsTZjHXpRa5b G+VjnFlD0dWuN1xaXbeqSPABcREkneqV5kHn79UKjS5A6nyCGoITPLDRIyz2 zYtNE/VRForsCP3xG6pfxHnXLi6cuqZas/D9qTl8/bxyOZEy4mdAHEwDY7Fl WHJCfuj1KQ7Q6u/jVYH0yTJgz0A3NvbClyz1OUTAEECwL3SUy18kQBw0Xnn1 2XGDo9PTN/sHh9CDpjRdKIwam/eDiZt8bDzNPXnEo0Eb9pRkXDGePTechu1K D47ajU+0VdQht/HZFmZBCoD9YLbM3btQ47ZgyQ2tiDyBXUBbYxmc+fZr8GYp KBtcjGOrBgrn8+j02dGLozNEK7J07mF71f/e8KhpyLFMnaLtSdRvJYbEY0ZX 1+6r4SwvQgnYt37WjcZ9/b1lVu70Vlrm7rhpvn9KV12NChnJrBXPQ1DRKldZ 9B9YdcCKb5MW4V8Ojg9/qTky6qIipZDa6Glw7C4XkjORn+tyka6e77YngnJJ 4spPlfBSLkJKCLXjBx+n402rN4AyY2ESiivk7y0RaRqKULaIx3yArNHOolym CH2txCQWmfkvnQVRJP+7zcKiSO4OE1IQpLVq7QKWm/8SLFsd/H8kmpUm3epj kLzlWqmE56PT/Zdvft4PeWRH8chv1e/b6vc3FbskoVqago505OdeoURJFNeS uEwznQQGvaz4QUB2BuMBSKd3fSPLsWDZ1HD0x29f3XD0ss3ZLm1fpMlV0CcQ NZp7s7dZu3l+zwyfTorA79/TFljYYH+QXWHOFjSrP2uI2CaA8aAJx395/dPz o+Oj05+L/ad58KV5qiqPcACoZY6OTw9Pzsp9IXOFEDSUL/aiwNS/bBXj5dh/ yHZFmERA7ig0n5uKdF84KMQgVuBhJP7bNB7TkcEMI3Nwu5q9rpTZK813F2AX O03if6YP1hVr/pw7VVr4hVVbKHajpbtWuaSaJJyurLKgahfMJ7fQjk7fnIAo Qwvey7K/r9q1V1w7hZ66BWTXteKjToQPheQvBSxyte/iJ6dSmsFUaG6uyLAC eoSnfKzW6EYAdTVafYIPC3Rq9feIxPzGLBbWUCxLWjhfooXzG7WQL9FCfqMW xku0ML5RCx+WaOHDjVroL9FC/0YtpEu0kN6ohZUlWli5UQuwuBZv4vcbNWEW b8HcqIGPtoFP/AcPqnI0Js79Udg2f6s/gW7tfMQzaPdj0533P+Kvpq26wBCg smsJ+Zivuth51l8rlw+2YkrF+9yKb2cWrjS2aBttNHpxP5oOc8HZMt0SXeli PfsszPiz4+ny4kYH+83NTYZbFAxv2718YYXB27G65uaer9RLkHWblRIjRWTQ cmSZLgrCpBUnrJYbYRROcWs1OkUc68fuLCW3kxLNBjfUMttzJEY2FPj3lBmt Rr0kO1oxMEReQe4uT4WUnidrvkjQhhh4SfxxEneRWHASI/iVurNk/UXeArqq KLeX5XeGvRVeY8IrSiJgU90K0OW/NogKbAtOYhhv/CHOAkMdVmoDpaTR+D2N 89nhm7OfWwVt6lbNlbk1q3qBRpJiwcF2DTGbI8r3RZTtJYOqNeTSvXiSX2p9 exqP6B1QA/2dpWZfn1iDibvq00zFfPI+VC6IaO1aFfk5OCEgx3FNcW0vYvs+ MOyqOwV17KVCHkZZe++1wAxP4Dsy90Nes51qqkXk14MdUrvtCVxdOUEFRVsH bJfqbZ6ITJwRDNrSpbGzaFPTjdcltzZKFmwVk1szI+NwImQWqidBI/V2cSLG jsVQAYUTxj7zBVWiqRX0FqvjYApk+1p0ixFLPz4YxqNJfr2iOU5pOiz2T6N+ PETbUF7CJVM7XGmRCU35xE6GGHWl9a9+JiB1G8vELT9A8URRpyJOZ0W8Z8/U weeJ2loUVZ3FAH/g+s43gGhwPeaL9MEmMI/gnr1yeOdJMgzHM8hEA1M3pJYp Xq8vMMh+BONSt2x6VEhvTsdSX01e3ca9azTxIAK1R+X18GdviZDAHn+lbkbZ Cm3qHXGsmw6W6QFtojMFslizjubHfFGbuFKxeUKf3L82mVyBPJiRqXvxozPA rf48gc1w1OFC1SU+RNDw+VDVpxKnSctcxezlkcC0yuhoRGTWbkkdhyS2vKMI xEy0AYOhEhBbCUgJX8cdZdrFpe0m5ktyReTLtvArtPwTsB7LCmDn+evX3NOI aneTFPAxScYMutCEh431aDPmAujLg0NFu0HpBQhMGawAYAZZN2ZwV5FYnqFv EMKyEnYmXhpY9Tuhjl8qN2rC7DhmQ3a0bKNLPTI9Rx+xZJoBf8liMUokizsx Ohuksnr4/gytHsbd2Lw4+7WN0Kgkkx9ZfrONGpoZ9MK1Glh6Y0tkspdZy8UT 2XWIs40vgMcTT9MeF6OoF+PbSTRIK+wB8XUHC3YEwBq9mVDlpm3nF5xDAIzf ivtUMMFUQEC42qnvpdyL2v5Ya0V0eGJvpVGEqiY1IGJshB80wS70tjyeYmeo 9OxBkeuLYRLgJ7sOchT2B3kWzCV+nE56eOBpiU0rbBUZmtaTJ1lkVtK4H6eo Nl3BjxGRSBEwLFaSCdjEscsGs92iyWYJwQRljew2J6WRoCjZduexoT1J8uUN Glq9DPx2gJl/wC0CeDqPJBuMBsMIrWRgKElGdHOA5ltidDKrY5F1TgpMsDLX x4NkNJnmcQWtslsQ0YOSoPtpMhIDmzQTLI3j0oSDBDyTgpUMPD4n6rRaZ1tK H5CQaa7hG6y7Z4Z79HnY/oGEQN6fGIzYbwhp8zu1R9sZoUMamb6xb8TzATLw NB7Ciw9k5fPtWpZ2ewM4BCM/+NsU6rHfQUqq95xZWIocHm1P4JAN56cBMg2x AhLiy5j68qvEmRIVHDnaGbCtpDftsp2TN4HlpUkmsmiulAGlAK/KUbKDhq1H 5bUjD7IeAgHjnHh0loxhW7pGkxK8iBUnrN6g32+xc+Sg78xwsXeFJjLeELB8 TCbj0XmWDJFS8EybVcnFmuxwYHx2Z5nFPq/34b88+1bwwDdWwEV9FD63fyBZ qEIyDqg47cKUhTbdYlPS7XaiDG0LGX77B5pxK0a7ckAStDuKVVifyIAco8YZ SC+KCrIEfVGRTyQpmpglFgT8YxKg80JABt7MJOjpRZwTfjoMu2PJjq3TVX9D ixIFo3Qc6NvzeKDs+328dhtqWdyvyBmgmj148M2qU8G8dhZrBIc+GAPDYQSw WKsGHDZd3ZohKxpPJR5L1eWbv4+d6utzKNBXVxgPhjyMItewPJE8rRZYAljK sT1+DBmfFHlasd1L8b2QS2aOTc6aCQJ6p2cATbYNBuSB1OzHurBeQ67i0wLE 2Sj/PHMjtIpJa25c3v9axODKe2CsytBmOG8u6nZBmQ167Mqppg/kCdO2Yn5f WSlfwNNWtAd1cRFu7ZlsY6PEolCRkXnNnr6mw2UklxJ8S+fb+/33qNSevgiQ auelaueLVMtL1fJFqo1L1caLVPtQqvZhkWr9UrX+ItXSUrV0kWorpWoVM15R 7/dyvd9n1lOXEaVbaqsXA1hVFh+FW4XqRf/7R7nWWbN3Qvae+bNie6675UFq U2y2xW/L/p9foriBZ1UQAuncSmIECt+0vtJ5K88qptnCf43/ZsAPxRXNLsHq ocmqXfGG9VKt/cNg3E825fvtQMFRs/ArKjb3FtkPTLgh1A6VpP8bDpQkPhlm +VwR9h3fze8NnPGBxd60P1x70R5x6fYPtmdVU2XLEOdOQQDAg8TyE1cFZtlp XKyDsNN8effy5OvS2A2nE+UCqVqNAZLEwuFWQ7qToVgR1FtshAH23Z5o4SCH CfdRYrav35wdvT6Wi7snzkKonr9YbLjd1zLhIsizX98cVgIMVvHC4I4PT88O n1UCLCzEmSD9ThF6hr3mynl0Yabj9+PkKhBpFxTEaqTZFxgAh8lpHjOXYpr8 4JclvRJNKkKDbwU19KfZUrsjF31/uciQPalnFgDJbNb1+Sn2c895QgvN+xdP FXF77UI4pZVzudAMKPyfD/JRNIGRTTBMxjhnH1pxK8bTOLA26AXePQ6j8cUU nX3nTRAW7AjgNf3Af2YzCT4x4F1W05YvyfDWVxeZXTqy6pOZfbJVAtFbXs7n WrZ2xU7kebCFtsSR5CAZjQCsVWoDsyfQcrigb+hCjxSB+jCMG1D23C5p27im 9d/m6qIVNIpYAjrI4MyDBxtRd7o7g+E16WVYNZHFcwUtAhMoIot7g+L4uBjv SpVxMiZzj1ncOyxqZ8MbMZahLgqyCE+qCON76w0TbDC2mkG7vWXufKiJCImb Lxg4yA/PxtllzKFZaDrwciObkh4cytxeSPBdaj58lcWYZCgeF7nUvMFXKUQW RLvvaIG5Hdil01Nryge5wcgDdQuphD6o06HwIpVIDC896YSSpxazz356QSes 5+RVzWP40dyZmG+Aya3eyVaB0UmVFntBolethWwtbN1GEN4ZudfTzWwTtuRZ bIfFJdu7vWXpsyClSYPLyaVBLxeQ0ioXktPnUldR7UZPtqvlkVntV9ANrTmq lCuC0ihalIoGO1xQvLBlBTwWZRzRRMvKXoT4Zq3dObTqiHSFP84/SOEQaHBc QXOnKzUKji20yCDql87SY6C3XzQEJ3T6z57HAn+F/wHddt9f0y0GxgyZRCBj TNGoC6Ti8+kFX4VdxeQP4f28yX6HQ1+R6r2PKkR04B4gk5Y7X9UqKxOnrMRs SYwSCpqT8aVgISzeZQILdDpKppnwLQ6SeAkQY46VYmPgiYMGx1qBw0EK6wkj M0bDLLGu5T1NxYrKFpLrFqBK1hRTn6mY1RZL6cv8Wt+UaAZKdfAQaKssTByq b0IiMN/qZZtuwfBSBaOdDrpT2LHRe57n217B00TJLlagI5leil2ozi3U42ua GWkoMy6yHHW1nVm/GL0faMh2T1ip2AWq2b86UTA266h/j7DtjhdcGP4bHCvc /q4mTbmg626r4eImhvCKO5oCQoaWfkxQusWNh1sZvQo2CLkVO6SbRbGskNsx 1QOaAx3I1N1UAqDg5kvfIrw9xqPy6xM8z789OOu8IRw2m5XXdq5rer6ePjWl 8zOF27Dki+pURcp6fJWtWNMlW6eAEmxwK5CVqrdN7gDbj9zpkY5cTcbXpZky A0Yk3uA2hmyb0Arv73wVIzIa7jKL8CRtGjWXKQ32Zp3ZNaiqk958MWnmrqTB o+Z3qiZkQAzPDMz3gPRXnTf7J/uv4LF8q1MQxAKY9PDb4J2+mF28R7a2J2lr iTlfM/K5VlC7W9ecvTMtkYNEjlto7rnszGmvmWpp5Q+Y5YpBYVDJNLpeaExU 8gYj4hZWvoJwH20OA1vfhYR7qrS4ktlJ9zVFFpHyoipcU7Ccbofiyy6hHbJV 1sisV546/DB1F7RWX8yvilriFwedt8dvT5X+tWZwCH6MDazM0OgitAVhzYf0 av/Xnw47b15jeI1nnbPXC0AdRdfndoX1Onkyp4WlYM+Fquy03+aD4QB2oBuo yI4TmGwxLSLrp1BQB6F5fZzk69rmbjJNJ8l8LdciCrYFlJwzRLvvyKy4l1DQ Qj9gjo2KkpU5j7sRTL0TRJ3ZqCA0/jgZDrqDHE8hzo7y5+QKY1G3ghMQxa9i gyGOuBrlAgPtb2MKUYwR5/0RY9aZwAadd/LXjEXsGHhSXu9uSbrS8iY8W59x cP0kzSMxh/P2vpZmrNWxlSkyzDRAKQqyPEl61n7URTqH0yCV4mMZmyTDxpQN yCwvMPfkj0M8VLGFyDlac5JJJx0hHeZn0tMS6rl/0t2Fvwku7RDB+L1tXM22 xKgh62Q2mZpB9H7nKMTEKkckrTme2Jmm7uOZ5Ec4myRDF7+belAHs3BaWeQE Vqufc44x5WbKJjmF60dvnoPXg3JMeVKyZwtkXrWhl2xFCAqdespAKg7T9TCY yZ+UoYSC2Fw4mCbj1zIULfrMhfFy//hFLWrKior5Y0ORuxZgxSljLsTTg/2X +xXICq5I5kOxl84NY2oV+9VQijY/NWp17++7/FVuwfp//mHNOwB8TT7XvDGf ox4tbIwwRwyuMkOorlKr4S5skP7cXn268iXpPLWITlv02TOmuOaYjhpMlDV4 j13AaaNoi7+A98Vcg/zwTr9wpc52+UveqX+qurRiQi0peQLrfjn2Fo38FerQ Z4TQQealJKSQTtepdrOWv4tC37CWcgRjTXPg+dUysFZR+cyhJUWrzKa65Ajh ZA7MysQXh0KHMTCUTMcwZ++neMxOY3BERZVxhDfrpLxmm1Y9w+xk0ff5KMhr Cpoa+RQqjl7QkNYOahHhhxzjSnFAx+fuW5Vxsv14E/NkB9jpyUJoc22Uw+K1 VsphsXmm4ch/YAbOUdS8hnF+iIfoHb0jpGpr433eVZoAnu/0HJppGJM0uRAf x6Dpz6XZ8YS22DUUqc8rZsiqREMV/8xl6gEuvVhte7QEZ8+w6rabY38j9HW7 VcvB53DaL5p4NUCKCwKASzRQdwWGFKBZSztbRs9aSQhU4AbUEAC+AUGodheg inAYjjAUkOYf0c0vJJDy5Dl/37l2T84xuGLO4GM1a3W1bsJbfZMOv9jQgoy1 0HQtZ/Ug/4jF5fFbWlO24QqrHXZc6w1SkK6T9Fpc+pyLX6bug6UwdcFVYHUC qRCsUkpfJ8/l1OTJFU70TJ+s3iCdbdImfmdLWbRNx1oO4SxDrKJCwiXntkX8 9jJLDwWqHTgKDHDvvaKQ8OzFvL11Z6sMH0tmpgNZRrCEdtkQEUSgzgW7i2XV 1zblcpX3N/qyG9VUtb6D3j+NCsIP9NkT0L8N3v3TnQeLvZ3jP8h9LgTv1iDm uQ06p0HxIcP2imY32MJMT7+wxWU9CpkcvqT9Sk9DXfHzkl6Dy+wTell8gSUv FZy1DutXk6/Oxg1ujRAigWrmLiZXsHI1YZ5D1wSlIzCFfIIUpIHVHWw9OYyB rabKRoPtNFAX3E1QloKu9AYX6FrEjBqD7xyNldVIyxxsbOAyQtV8pKBwvhQ7 ZknJgXliuxMsTp+DJVXnWZqtiIIe1xUNS93L3ogM4GgHRebqZ6RYONmkZEfL qNhbW8B+eM5+3RSR4eg1h8/I+DjbG2TvTX86HOJxVUXKd75fQBpAhuT3VfTk C7MsWJVVH/vV07aclAZDuvvbnewdQPkIq46jeKzBn3ESRPLCewI1VB3UBBFE tFGITkIZA9kdHqOccEKNsb8m6FLOQBORwhgTQoVxvAYqkZRNx4Fa0nQ6QTUA RiU7J40A0ai1roPz9CRJI5AFiPewsoUj9/CtDOevAEGBwpiIlIB8HeNLAbZA xhGkl+a34HfqYsPZmfZpxnQAXkxZ0gH5L7lyrxgAdrVTldFMCuD3bNrvDz7+ dm/rnYNl1u4CLCv48kWXHf10PPjbNC4ige9hBplgoseR0zCkAKxmFqHWaQbx oipxcQUU9jXmWzRHTr5yERAEzlUyXs0xegGteLbis9E+nJFYsYfCDa7jXKDY nsp9Gt2TbqrlYBPfeBwF6W/8a9HpZWO74nWNiuKmbbaBFbTvDHvtO73NfDRB xosz28QptFbFzGFhe5oA7a5JI+UJBXqBFW7ZDOd50h3wcQz8Esa4ypjngLvV 0VVXrpRIrmuELl+y6J+7RU/geC/m/KR2pRKMJ8QxeWClJiuZQu2ZYLfyTKDa cr2wBMAJguANMjLrRetOC0W8qa65e15neWrDmXACP5HnbPikN3F6GU0yn1Vo yhfjspdw/lv0yUKuMs2J6loo8vWInrtsKjpAYSBXiYOrN5K9vT3z448/ktQQ ph5y8khVRR4+1X72+nj1zBw+OzozZz8fnVJ6RLt+ghx80MSqz/S3KHjk5mzc wXhSyezzAdNMpLZsndwPE/otPArCHWUSVo1cDSi3OyKbbpU1kojPjKNhtrn4 UCxc2VvPJXexyzpJFo1IiJeJHFAH+aYnN0tts05p2JClXI/+xNKtplMG2lWc WlGqpdBxMm5LliBKjUMnVMl2JCay2HOL9iALeSgrO7+sMGN5+VBqD7fVxvgi pFbfldijZLPGpJh1m8Ew7aJ3KcmpjBN7eBoi2DF5kcEG3h9OM3WoIhmIYuFc xt33HHCNRCRJQwUUyrKTE5YAkflU9ARWrISzhomjdDhQgVBJkuLWdNhSzBrR F06no5mGPBUIF4QwCXZ2ZS8oyuyNRarleGq1Ur/8raBKLBdQOqsKyFZGVfsO iys10fwJX/9SxFAPMCtNPKsHXsblol+nXREey3ux2olqOyKV75BTQlV/Sl3h Di7QNw4NWrEnztidt2s1dmHfYNHeQUZ6nVtVEBzhdXS9uXu1pap6Y5Gmver7 LzxefOk/ClR4yKEYizESb3OgxZnhEFEqwgiWFLbwS/+pXLdJehWlPdOLu7CL Mm+yuzhmPNTOJOvOPsxboTlTrJKXoq5ZG6XL2gjX1KvwA1+X2+2aGoGd1bpS wdeUD+wV1vEvFg5DKxbvv4P70XIIwgL08A583YYgrMVUEMxp3Xuy1VRY2BPY TflJDIRG0fwTldXbB5ekTKxtysRq4yFKhuVYTbtcMVPwQyrqjfKAEXQHKYtl LhQiMZhBXqWfSKlD4dSJb2qYoHWRjKl+HC0xo9SphAKXDMycKiBtElGsoVQK Nt+Y2Lj5QI7Vw3CTom3iCiSpB1YXTntLepVv4dVNKcL3lmai5YDE+RapWHS2 vaJWrTLlrUrDQ12GBSq+XZ+0uROdYvl/zh66ZT5tfTafVVRmqbxZsJjLt8oJ 9nzji87rXYEOp9PXnWKmKEIKQSoFr6sKOJ1vURYDinVhnKNx47MfSkUYbpUA YF1wZGNyOkqt8Hr+FITbqOzJT5iJ0lKZVgx/VusXytDCDX3lF6DLsMYMyrSj KrjuS8zL2cxnPYgbVNnlJfu7ZGe/Tk+99d28TlY44Nf0z5f8ov5F+srrywN7 FP1Fq+J6rIeBPeo4l2Vc9XyrlmvNZVrSBeQiM5jIrNW63HK0q/F6nEcf6XjH HZixKiMrg87xAQ+pp+TXttQeAWXZrhjT1ntr4oUIzBsfztpqFtlo2Ih1TnoB H2GeeB1ZSHr2zCOxoQfcxtQI7b9T3pJDj1wJvGB9bF2eIGfpzbsFt1C08a65 MCx2B085vekE+16ZOaVZ09eKHoof7eLdbIW9WW6HqpLD7655gMqutFSchVFd WgTSyvJOXNcVUF6vLB3wGl1DWE1lJV4nQfdVIIDmF+27OM+cf8lO2CJLfXag BNX1ijgJX7bQyeD//yfr3GP533SZlzv4tVb5/67xRdb4QkvbT9JKpVglS3qe h7I+4Vc5KOtlXV624mOz5MItEZzupF8Ti62FmeieNGfhZrafsz4Dl92cv4zd kU/RvwW7s5hiP+rFeEbZk405nEOnYxtioam4xxKcQ3lpLyANB7HV5jPwmUgI 9AiLjBPVtnjLxuNddKhLj20R9sC9oxGrbX/GGonCVVI6mmmhD08OwbGgbf1O e/EEDmeYTgS4EhzYJPFD1aHNXiFHNnyRc9XFG6hBrkMZ2awkFM5o0wURwkLF yEHi9+tCB81ysVvk6Hjj04wmoLpC24sU2gkz0ZXZiHIr/M+TnWZISCW6u6mc VC+h/bESVN0A/nly1E1ECux1xZFhCYFsGWFscUFsaSEMzbTYdr0YU4vNqcqB sgZZGMZMUByGzCKVrQ2PNXsF0QIvf5XpoZVd/rrjev+GjDh0hKTvmR7a9PSD +Z5Gvv2DITMtfhr/0FSX7rPX78vD52dv9k8sJd29a6rXLVpn+V6sNGsqSAM7 cxVfVqeISccoUtPdSslYGZbb4GyieMx3ZijMQktfag9niSZDc9Pa5bOrEqMU rHx9L6xxr/CM0tbKY7P8ZwaZNGzmUK7g7ngtatwX9s4ppTaoX9YuLfMKWxO7 KAOwJBwy6TKP0sUWotEVcilXU5JNd3hy9OJnJKXaTMu2O5wi2venuVhnviKr 822rhVXVZunAEATb0pJQTUCwebrp+jhgWsKwQcBucsLQEQK++HhWGr3ejxff jmcf1UoBxwLftoVjjs3myzfW8FTHLtManzoSLYkaiyLBxThrhh7cs3bjctSy mjuhi65ZJOyUam1G1Kn1iY47NYNWlxU8w6lRoahk1qlhAOhub/cWPAa6SFQV gJYDUw49VQZZjGi1BPjZgCtAzmOCgzF7flTEHRN+W0fInopsmCt3cCPrK6Gs cpir2uDVS9p+/KtNDepi58y0BJin7FT2IrPjjM9OKq82/ZVDGzAFSecCukgp gXWfyfLVnqcaLse1Tw1nI3qhRbGbWRWOTOy91Vm6irnXhs6qYit3Z4fOClV3 quESKVXbTS3EnWqP6wuQ1myhfymxHMTrMKRUpVjOR7RSVNwyve00977W7qit gfQ2Wbv5BXNdYUukgwHVnMlnLufGvB6HVh8rLnnYJydEz+h7QZtfaXMShjOi ZdtYiLsrE4+v0q2v0idSa3xhd+qDPS3XExLHyz1Z99EL/nJwfPiLM8W0IuxN euwF8fUbd1lCvv8zeqwvYG/e4eDc88/odlmxevPOa1H3n9P7ilPbF3Sft8R/ Us+Dq72bd5ouF/45XdZ3bjM6bLM81sq755HPx7J2O7CKvOmWeDMliFkZDdjr ljQfgU3GggqOm9xtzTH59POmdGMLa1QcctmyrFp5Up04vBRcRAUWQbd4TFnB ali66amILFIS/BZIoG3MeZIMDUyEhGt4CqODge59uWxYzJ8dZs4OrLXZOUx9 /9fIlmszhEvBndf4osfWmsbbjMo+gTbQ41eXUGfr1mcv2PD+inDRMFWq7O2q 06BIpOxQLk7HNTdDXr3rcFbmmnIYVn7uGDwingCI33bekbX6s6OTzukhqrvO Xp+0QJ7CFGFmiwzUBQp3B53yin7QRGctD7Rl2GHIkp3VIvts709VKJfO+bXN Ni6wdR3yiCp9KDPmebBVdZXFHpX2lYfqRj39lM4PC6ij8fbLsgnmYS3j4o0S OiU4Cl5NY89WvuQsddONY2Yvm//6XSSY5OCOJZjSrZvcTYbjXqlRZ8ptI0Z8 XERFUOOaJFuEvM1Hk0Vu6efvDjNu+L+Y98++TPwDLgMZVV9+E8g3ezIRC9zr FSO6zb/B8zWq3djuwgQvu5otzNtPXedrlq5o5ohjCdNBhvNqkI3QkzruWZq1 F/1uQd/pmYsk5yBE0l7Lt7bEJqeZy+wFPIdh2pVI/VU3eMWEuut+OkeTKlFQ mCnf9y/mi1LO3qzS536JKpiS77pLsyBr8hcZwRBUnWl9GaO6P4yBV/Rq3mX4 8hesr+SAwxGAxuF0Vx8O6PSwED3UpIoPkykX5xPvQutuHj1K6JBa2T3J6b5Q B2uzxy9BsL5P0nLxPC2NTPK004N5qCVkTq49f+hBGvo/0jas3GSQ1f7fbJHU 9PHrLxlkrDLVQVtqzfwr5iRP/t1nhHr4L5mPIpMYq3Twc1hEmTesL8gc/sPu piy6/ujbqXI3j/dfHfqjOqK3xEMF+8oEawFzEFKY0GxJsgVt+6EOvIUypaVD 4R7x3aBH7ezNuz9bwIJsMYyEuofF74EIlbP62Ki6/rGkboNcNBqfXdsLcAN3 ubls84GYcMPGmQHcqPmCEFDXAXwzmwkJBK+wnr9EGjfROszphrgMgzDHHWqV 5P/FdPtLaOytFFnCwOeljis0n2j5oFj30luBHfRVxGFuEF6YcsS6Stio0cxb 6hQPdVFgvAQrby8RrNrg/Be0CR0kZAFU8VX0+ZYAv4r+4t90d8m+/vZydYk6 rCVWT8kE2C78u+FEKGbNM+sDeoRsWeY9rO3Xtpp8LFm7uj6VarAN8WKgq4t8 nr8dff6XKiJvsLIzrVckFQYLDILc0nlQ4v61VLC86CIaoP5ehxAU8yiVo2+W VOiiCuqAt4UIg//niYgywJX/+PuhMj/AzAJEGy6TJ9nQhQEmbRRVCpgZZXbR 2fUohYV0nKDHqbdD4mjVXUI5wXUhy8HGSqGDI9FV7qk9/05GQcJJQZlZ+8FG oT/ydrbT1Bdf43hJwS271KSDi0sKggqovIyzQXazfd9hYsa9tsohV2Hgr2Ox /ZvYIH71JYzjK6/fWlsQG5Lun3UUdEoPWZZ6BdXQpt12OIl9aTP1ligVh8CZ 23BFzQWdCy3YxUwsrYZPt+d0e4069wFd2nkNNOp89HRp9tL7SidVzUmXsD6c gfaFDjco1CNttkS0d0Br0m8sduzgxRGmqqyRe6rP7Hb3Mf8WFj96v6jBniSo 9HblqhNC4ZQ0tsBMlwpOSbkZFwhLOTc3Y/GAJa+rTlc3uQ+ezb/knAGFqq9P q08bwSyXNpvwOrPqpMHkKwPnG7pG5ZGimu5LJ4kqEPJuCeu6cppKcUCQWPDA dKYjzmPQ3GMPE8x0kZqrwXBoYhCwXChOw5PvR1JOePm5aDkwK/Fjga9yiGhL Zi5jYV0OyIDcpF//a01Q9mFAdH0te4IKGwE9JTOtDL7QmsBGw72xOYEiqCUM Cqw/l2eePj+rNilwUrvz2vQtOjuDf6F1gZsl2VaaNxPci2DWFInNjtddlWGP jm0qbamhu6Dq7JVh8tR1RXWU6bcuMudiDsM69L/1bPLvdICmiq1NXlsurd8x uy6nR21x1t5Chsz/ZVps3uoQ/+VsSyH9C5jTwprNJSUO64KlJZ/K84bIHg2j 6Yb29GW0nk6g+Eqqzjp46v1XV2ouwqTUalYKBkk7qNYdbQsSK26+YI6ohTPv /tlhB6bx8LhlWApf0duAarqwI8A/21iw+pdOS2qZpmpqBtvUjSiWVquDRbY5 PxlwjdeO4p7B69rkwF6WwE+ElcqvN+e8/8tTRZWkpuNrsNXCNH0pc62JIfOH XSktw3L/w/mrKa8r3jm+PuMNeUHAe+dbWJVXP/Fn/WYul3auNyTAi2dNhQwf drTKNNjVDnvQKiNTeGsIchZ7nZmuW99b+cxH9lDs82GHtvTF42+Q0ft/hUt9 LWYx+EceiQXx/9bHYcpcvthR2KwclVaQw+P8YzC29K8+Av+iDUzQ3EbRwY0u sNzaDLicX6D+XHoj4c7DmSHbBcnnCyffcvb5meffimTxXysA57/ZpRoP9f/E a3GZxIVvviRXO8fkhS/4w+aHn3OHbBW/4fULRRObfTLjLg7GKkVsnc9ZFv9t iumgvixFSUXC8n9qZNk/MpLlV94aHbq+ztYYRooM8rfP2xvDfOf2ovvPhweh DU+rKn38lx04lkg+v0D8nMYi1qLafniR4IpBTnm3lIxbSg1Tzhf/FSyl/9UB HfxitraghXH/IZEsC62WsV1x5WUZF/nLUsrZOXxKp6X9lzGq/zg/WcAZouyP YlYX7En/Byo3VAuev3kffsvfbLHmAkzKli3wqFJQjuf7L08PlVVJqYfzGdss amjMJofGUtTQcLM7L6DGSpP9BZYPpbHSdLZ8S9FRQYOjw2efSwKynbo4C7OI pzGLehZ3VZgzR8sIpYzZatTUSKXWtUNv2X1A/uyoHmzfuT+kiDaxuYscdGgi u1oMbFrptQ1aE3XZGMhFHbfIj+GtJJpFiHpVdafphVKWNKriiLh5XTCSCOn3 50QTuUE4EcSWCifScHEyaQBzQ4nUxxJxukOvi2zMBQ1/bOUszsNY8VSxRURv y1hexOIHFdir9fXZWdaLx4XgNhwmieYWtme/MVSICMu5ykgTShpYrJHPS6pl bi+uBVlEVsL1oDpYFlm+oqBkW53ZXsXZTvK2zzMKstnd/1coWkwogsOx3QcX 3MoK5m/1wsxS1CD9mEkLxSDHmWPklVmmDWWZDglmOs4GF+MYiAZLsGuiaCjl nMhh0yn4PxEPv9Wh1l1S3opPGG5dJkrs3MqB1+2YfFbvWxsg/0fDbFZ/tlsm fLEzp4fbM7rIOvqaijszKu6UB7ddjL7Mia53qgdNE4n56F2kapuK3s1ji80J e+b82owiIAjSZzrPnW6NhX940Kd9y61/e2TC4HLJBNcTh91aSVeKehEu5q7t HPmatZXnyFt6GFqbYHg6RR8MJEU7lN/uZO9WJLQX7xioX4vTFKVw+DNOJLCD VdLTro5/1FsJ0bQ920Zqu3g0KaqGB5RBRvV0L1AJ+x6EO0yN8rkBmzwheG31 9/GqOl/0h1NYcYDDXjLNC0FoSqvzKX+mXNxd6CRO3s7W9sOWKa7KlimvjJYK 4segSS/RAWiVkO9t7SBkfEXgrV/BGr2K/9Y07IKg4Vb5ghX8v4rlrEK8MkOO 6BQr0/fYc3wZojIxu6tsyxzF9oWkPKzm4vedZeOUFZLhDAPlW/KQgpiu3T1n DVFX2ujeDY3x6q1B7oZmIKXZ8Decd/3VZqldKwY0v3D1mDtD5EN5nG0W7lL6 eQyHjAD181aD6ku/O0yyuHbmoAN9x2y4qKT71SzHTgcyGOZnM9lMMRpcwHzk rdVMHY57VhXlOG+bKlj+ezTuxR+fYBTN7zxrvvX0y//darfbBbCNNbRkoFW4 /eDevd2HgKuNjVKhqyR9j8TaTSawff/4o2nvbLW27z8wG/D34a758cdb5pb5 ZjDuDqe9GA4BsGH0Bxeblyv6bXad5fEIX7b9S9dMWJZwncHLBuAMdwCePdye dN08meSFmkAYQLltoDb8oEpbL8PLFaQGARuyHjjhTt5fhO94UlQDyOqAvxWg f0zji/hj4WVyDjPbfV94Gwz5FvbkGQyOU0e0YGPupgne5OZAD5QuIBkPrymM LiYTRMKRLt1qQ9U/DcYcDJA3gCt0GcCMqT0YRB6NxZekTblLsAiJnZ9utY1k HT/Yf7l/0vLPpGAInt8enPlnSl7sHyUpqn9B2T79o8rapyqpfD232rB4YSTC xJwYqTUIezLUfXOFySgTWJJZZnqEs8s0mV5c4kuUcoAnEJ91ww6joNxq08DD l2adE061Q+UIa+ELLzE6z57tMvToNXvAU1esxLzqw1atBpFy2tVhraRTKidS qVkfB6j2E0pyumf7fCOBrtuRCg/ZVu6J0rBYrcxGQrF3hajDKFHR+yAQGPfH iqUuagTPkdbFw6s+VqEvojTFcXwDFIGymsuCZLa3HDyBg6Y9mPYD+Sm5IGPC TV5plBQkQWOtHM42o2n30sD2lF7TdiCX8n452V4wQOqFR2YvzrrpgGebAm8q lJZyBCEiCLXGJ+shQ3P/Dt7IE56+cJFz3hInllxd4tZE4x8wmcLKvow+xOgn hAIfDAB4IkoT8ZghoQEequTIKApQEvlcwwlmEbXYicbjBPcbTuVq/vpXTuuD LKO/urrpgB3BOPtY3YoqwIIIfxjM+gLbYq8l7JVGpwOg0u3Q8AZ5C2vB4mUn J3JnAsIDmCiemnMcFk85rF9EraCrmFPII9K/w1dM/epoJSQeMj/8jyZqR/nW gtUlcNlzlYMUUPJAXzk1tcy2BbDHj9KRTxYhemXl0cWefV+3mEhs4tXJwSbd 2+Iyq9B4C+dsB7kIg7SD9OmzsVDpXkLSawwyyrBRM47CMMOBDeOxAx3NBoCv iz3kRGBuwb9bAEmfAwtCevnZTEPmQ8xQIlUQq8C8S3ACtsdjy5xYTq+4J8TB rfNnNiVS7In2xM6btY9NCgXwO/RgDR5smMKnaufE6xBbpqqQ2i+NLUa3LViy kDiyCj7IuoVuvT4ReLaDM7tn28Rbm1KRQr8qy6gBNB32J8PpBTAPhVzamADx cKwTLQZyFyk3SkBKIqEnYlYNszSUeQP+BSeF3rQb98IJ8lry9XUBZHcSWyQb /B0OMGZ83gm/M5M/tcwX+B1sGRkcfDkYtt6xCmIF7BgFmQLezBMopBvn0z6n 0C68dKyFq8EbJmUnIgVNGd61mNIlDkucEncXbKreE9atpYJCdohJ2QcFR1x9 r7AQgo+ERx6e7JdBqy2TTQekMaRdQO1pLd4EUGCFLQ2+dIH5RCKqwcSPYCfG rh4dv3l71nl+9PKQ02ZnNn0t7e+0J3lLDAIJSGQQvioM8lV0bfVreCorYYF2 84/A+8cWCXDC0IPs4I7ZwQPTOSlMqYm1UEK0ZeGA2NZfiqBYV6xLNHkWX0/T ijQRlC48k6zrMmG6MitJcJ6YkrxBmZ2VN3gCbwHq3sNE8HG8haLBa4B2nLST CZ6fXyN2ETmbQujuNgC2GjnCW3GtFdD3aQsT9DaFX++fwUHip7dnsG1Tfs3O Dg/uz07LMLVSjxUvcIiYyDxQWVaMtKDkEXMZXUKnQy/S5mxRtB2ugVAiDfsP mLuMhxNO137hDorotQ+CUac3JccA+4SFdBcWZYmyQDJmiITcaDZDbOuFWmSF 7TmssD2HixDR3uWWy+gqsgwA9pzP2OcozY7iLCNtnZzWgAJShbSCFklj6wtk /XaVrF/odyDyb3A+QJJqJWYzSdQ0P1OMaJHjALI4Vxck3hZ7HF8N+YQRybV5 T47mWCkB9IHI+LcpZhi8gD58sKEgirsZC7AdatptUZWGxO3yhbjnBoLA86j7 fjpR/CS7TKaogIuNTUxDsTwAA21W02CYJnhPI/HUQGTSMgl8Sa8GWSwBn5As 1naaRqriLYO5ogZQ2bZJQOA4gXylZcaJ7Q5MH7F4PMOYBKbLLv+o0GRBFnMD XRdIHRosI+klcUi6C2a9MXYuxFSJRbLBkbllQrpgPTer9wrGjgW+bSpngbYP vriHFVzJ8GdXg/aHN6wqg0vjIVEZayNL281SndaGG3MrV3W9AMDjG8kda8Ly 7Q8+kl4fOz9ATeiS45a6Sw61UKvc0f8iPd1xMv57nMJput9HwZAVwnh0TboU akZYMCpItx89bj00G9tbD1qPDLygsp0o59un8BbQJW+aJJknLWzWmA8RbmSY SimatMwou2BqM3YLJ104AG+ZlTvZkzu9JwaV6UnGOUrkp092qnMzwSebmAnP GK5SmM1pVjuIP2WeIlluLJxm2DoOpgQMBtQyZKeCGnq8A+MLMLw/wxL84XKQ dxjZTw2gDLg06aC3H7Ye3AMc795vPbqPSP4YZbaBwNCJ1BAin+A8HrltF2Zv 3BvS7k0qVfx6RrIqqnmAjZVOhFXkt+5s/Uo7rDYExH1OnVLU+8rSTpPnXeWG UZdFJw4i5E61ohgmeSpyCcjwkTZA0thkvGeyhphy3cIJKwnSksEWxYdHEpZB TszwPHTFKh0S03M0AMP2rW6pm4zg+D3IUDE2NlbaqscV9pUG+BtaInVINO90 eKdadKheg95dUeOmbUaP/Qbj5q0KzyfRkPLcx1HK2ne8MHfSiptFPx6/2fqL DieiodBN+yXldqNATzCy/nRYAZFrdy6dChJp8s+0bxNi4rTtDjt2Qx/MpM7Q BL2SRr1FfShKl+puVFfiXsLBj3IZFoXr2hMgdBowlhKOknGMa938tH96SGRx KvaFWCeOQKKzw5b7j3CzXsfdJlw6Em8rEm0Y3rwCFFI1ghD3123z/fe+tc73 CP6HVZLsgMEXjo/YQzqynF8bLrnJfBgGgKvPGl14wQqFmTymhOFa5SlJAlHH RgAJxoBVUyD9Tpl6sTWQbIH6Nkl0gv5epQmI/dcCLCsBasnpgM7Gqb1sxvWa xtl0mC8ACGSzXAMjefXFgUmTJEdZ7RrHhZZFUECwiQpllreBXoBjt/OkTacd PJbAjI82b7UFTSgpgmgfwWYvEwKVM6BelN5Ho7g3AGlreC0Go05Xt5o5nQUK pAjrfNrvwxBxpkCMPOeoabIT4eEOh5rb/k7HsJTxTqmFOnNRo8OsECS6/AWc 4E10+/y6jX9lJbllovSqt9oXJWtLfcbPxWj1G5jQw+P9n4CsDn4+PPgTGe0q Qyt3aHSE0+Ibcnv4xRt4dDD35w+bRpLPFu4MaxPOH7BlT36ZTgnAs59e0Mm7 c/D6LfwXlXN8taiMfEzv/IJa5WMGm4Kg+auSsGFALZLPgKy02LtOO7e7GIJ9 9RNPNF7CMx7IYMmyx6a77jhjpiyK/uBik7JhwvkIb2Aj4Y1tjgBHK3ltbU3h vrndxBUc+h2ZNhr2tL2RHHsGs33M0y101ZQk0vaBbnmfbilfbVGwSgFS8ctv 4m7yW3bAsKbSz9piSjn9NIigMXnqLAbIi2DyNN8zE/jf0wmHHWgSP/R6c013 cmZpK7cJ9+R8EtrsjYAsG0glwB17K2yJc0K7gfDWxojPg5/3Tzo/HZ01zYZZ c/exZD7N8/rbwKvlbcw55SzNqHZB7oCLAOECf1ibsK7YukKQVkNdQj9hnyc7 PTaizjks0fd7YXm6pPblaQZnl397cKbLq4g9FeVJF+6K0/zPKC134K680MWM GnRJ7soTTc0orVTqro4is1k9UxftvnuKHkt1YVFGsFVwYTwrTMcpbr20d6+J 75lxZsnls8Hv4xV3QIA/IJTfuQOC+R2rBHnyBK192LJGnQ+BrJotZjHEVywV eYssRxc/bOHNg5v2H7aseU+pL75trglnKw7Vg/zHd0PRnGIIYcuELdcyUcRi DdtIFfCbapXalSBEFmrQrFCSa5coZaF2pSY3TNWKDUsJz9WClhV9udY14SzU CQWEOxIYoBX6owqX2GbdQfR3ynSBpPhNPO5B179bL2y6zkzmVNR1wj2ZbbE0 V9jRWSTl+6dhfAFyKpwd7QmIgnG6E5eV+QZZhQBSUJ/DQ0lyUDJDK2TuTblW 8nzd8/RtZN0/zGPu7bbsuG73cMwbgIzNXdhMt98G/L6NhvJSeGx+gCbsJ3vT eqsN/yNJ/xRPg4hQfz5umZdHp2ecLqAXA22NUNNxmVyxeMgOQleo+CTru1t8 q4uSnixJQwes/WGWSGSXQqTcqlMPQcEW7Qn9zFXJ/CyjWIH6xTjj2cxEuwmC WBKT1EsKhXtbD1vb22Zj994D/AuvCtMaSnv4BtmXbNPuEm9sPQm39uwXPbnd aYqPWGBtu06AMXYi4kmSbYqBoW3Qh9pQH6vchFwPXUeohs9Ra4IOBl7eizl5 t8vuk/UVy96TVfVmel26DtN62NsD3IMwQZN3b7u1vQuT92irtf1gmcmzHkhG PM1MI5jOgXLQU12D3/1atLPCS2ppnZvQxvdPSwNrVPuTjrUPabvR0IHdlVcX bZ6xj+WOZpOnA4zY4BZph7X7Vsb+2xTPWmjMSNeUdKKzvme4uP9nirgi7Y7T 9mTWi4+FfOVTRojoIzIbjMKGk/ZT4AARWe5d2qWObIDg4xQxx4h6dPtla7L/ GwXv9je7fG0Uf4SpY9NphLWaGce4kedy/Qrvz9LJTQ3AO+ItUpGGume7irig knfd0m76YRT0vndj0vGuWEtj0gf1B8CjRnzmRXsDnLaVW8Y71SFRODRgLgqa bd4zxglNOq+B+/d5DTx+iH+XWQO2rSfFgAXSBnCld7z+uCCN+B9P3ZD3LOZL 29zB6+NTOIbun56tWWagMR86KlbUR2y7QtI66YzQXXM0QiVLz324SIBKyHOK LYTo9Wdkp3ZRF8EzJt3M7bmSrpO8BDc23hELHseeH9T0VQHbmAUMS9uVD320 ojUbBU56aJFOl7HD5DwaWi3AGJaTVWi+x4cI7x5Yc0KbbTS+JmK4v/2wtfPA bNy7/xj/LkEMfNnBUhAbjZA0pM5ezgLZahKVO5MkxRNfrk9F02IMuAv/s1aQ 5tPWZ7ycqa+/UVm/CIKN/2y/86uk2G86Y4qEMEjNdDO0dTP9YXRBzPGWzCwp 7iaTFO0ecCo+RMMpSg4iSIJoOCb7MZBMvG64BiXc1BhWNjb1tGyAPR8rZRAb lSCqEDOjT1/aoRv0hqfpJdBbZqOXkaqL9EJFNNqEBOLk4seijAjZZrb0KThu 7BUhOh8XWKSlRjYqoG9Ug90ow/MXm1KlPxj3ghPNlMnMRmiFI0+N/WOTr7oe 7N5rbe+YjfsPQTK9h2t5HF95WOFKZjcaOjpkdKhs0TiAwfiMHAMxJ8Q7D33n R16q8lGYGnyRYwWxKisfDVFoy5xw5K0VUKnARbJBKS8O5Wex30fxqDu5xt7A Vga7oj3K6LKu8DBzeZ+LahFdpGAkKX0Mv7vU7ax/s511sT51bAd8HXphmnZg meFKebvhCsjlbg0z/v6ZJ/je4xbw6vuPd/m6+EbTizM7DO50M+9wqecuq5uX qrkUPCyEBofCiqmYM0sKRjWyCE0PthBND+yt+k3QJEK+7OC1FCrf3YgCVqBs lj2eXI2ZiNLmzBL9OduzOjXDo4QjzA6cQx/sPGo9uPkwaaGXsCmn1azCnlgt +n88Ncr5hiSSkxg3RXu/2slA8HaXrehhgHLF5iXesQTiyRXJanLdYuhWjAy6 yJxxFKXvTQpPfOfM6n6Jw8BnHB7fim92pYmEfVtGaw+ggf1Cxb2D04LYM3qo LGdtuhmb7wuhe8Z87Aq65GW5d2bDBetTb/EMb1+vCF5Wmi0rIRv/rknS5ieR ObMiU36q5MZ3VjIVZW2beIfVy9zS2viMlGJMSw+3t0mn8eAe7SDwijajRalJ qEWfOsW9mfuaRxd86ITVC3MgpvBQmN6GQHT/6Kqong2Z2R8Lm03dMq1eZ34f ke6Z/9Ym8E/0nQG7c85d0R4ZqFtja9PKtj0CaG52HwEb23jwcKe1veWmpiAn zBYS7DqnRhyrD1hcGs/Es6lAp1QLN1x9mxCWEtQXBSNVYgGOWIzZbGfQwZhu 6iKb+AfNgVwhK01UFaaHlpE/Vs5gdDbNuvcwE3nr4YMHaL31cGun9RgnRiwB rdHLmrr2FH5lci0BFOdAyqc3mojCNPB1k8fvQthNCSUBvvKCyJK6XYgwgHsQ bLUPtx+17j9SOGADD0WUBe8fugn2Q/4gG8iHWUP/MGMX/hAOn+7OKpjABpWc g4kPiIVI4UFesAko28q7RfpBuKi2JBn7XLpufZIXHSn+KJMdWeqP+4k5On5O pvWHfzmT/KfErWmxSOpksb0F3DnbIm22IsqyJZskjKpW57XonMlubcgUF9La e28zhNQy5Q2j6CNbzvGdlGZYvjEFJG6SX785wy2ED/v2mzAY9quRV5xY0qnD 4RW2vCk4exoYMTQNe+76+CoJueQbwvcBh7MQY+8bTTDhfCF0e5zcagu6l8Uz x6kRPAsMIvT5gNYNA5LFyTBYOCrMVf1U+XL8PGNmTXn2THn22m726qetRCDI DIKJF30R1zB6omkVb4RTzU7Yzopx4Uln+8DSyl5+jYkX+MJTpuPfVbmRr5ua hTd3kpZZYuEcHB+enh0+C2ZB8Pq0ZsFt3DJzuClbsK740a0ETvRq+ZgQk4iI Omy6zYq2tkfbWyhvbeAWp3f3JQAhgfU42yyMNerhZUaH1AqSsgTKbvECgGLe fx83nqT4mqIwPTXiwu8wVuAO3AGNmJbpNTWKqymrrh6dGsjAuEfZ3kV9RdPd M6fWtsyc8VKwM/XaGW7BGe/N61MMWvMVgJBAkpi/Oi3aqlUE8u05zdvuDgpl j7a24Q+eihMVtiY8x2RqzjXJQE9fJVneZveSoaY7nDxGYZKGBqas4Lvl3UFw mtE2fE3FTmjpGAlVvDvw2ZazYGCkTlfoYmlnA18W3RHIBbmvi7Gwpd3E9+Tk 9+jeNqELqP2hovLFu08m+VjaETrHf/CvAw7hX8MA4a11TZeX+lQr9tKV3/x1 kb4KXm8Ze+sW1pK7bLntcWvBYoKF2UcPH7a27wMu7ln1abC4oqFgZQZKRGqm AGtEKmhGDCJDRBcAK9srm2IJjG5fV2grjPQ8QiN6SuNFHsXdWMBQDAmG45YI Wmj24klM1xZseos++TGwyRWMP7FizmMyD02n1gJa4g90nEJTzzEHomrJjK6s NH3AAqlgZ6rAaUpFWhhVJ1/5YiCALASyLaHhZkApSKBzevTFsHTHHFKF5gu6 N+VisnIn62BuFbPSh2lm+y14GvQ2Npots92iW1VRTw3jj3Ha4btG3QMXGq0t WjaRUHJHZyh5XKCf4EDsYeIrg+1J6AkJRML8l+mEZJSvBEqOitEFK/XsdTUL PcAlemTHz/GGxCLctwergVLVOGoNNyrFiXi9eby3ROhpMwYLtIXxLal7xKh6 TY4O68sVZrxcXCbGKQnFeoJFRRs/oZJFcE+pi9RDAtj4nV2+MNAecNzHj+4z xw3kgjT/2EH3/bWKjcnsn7ygQDEFRdlddReqdMRAKeME6L+86njFF9ZGoWwB O+UqZGOD3c0nvpZTfRTVhysysBWUeHj9pPmHuLtwbSyr6jMm7z8E0Wxje2vn PotoN0El2sAcvz477Bwdnx53Xu3/xflwsPWXEWtXoVYyshiMxQ5IdAgoY9g7 SdICd0nNpqGyDpeEkX49P6RJIEKkNt30zKhamKgaCHyrt1QfmN1R6cE4G5Oh x2/ddzfrTj0woWWxaqASssInZb5qyahD5bLpuWWnwkcbRS7quulYKFPOg4e4 xQPp7N4XI76bLcOSYgC2cxcZJPDRQPdCusk+/fXVT69fdk4On3ee7Z/tO7Yn akCRLbLrEfVbeL5xL+r27zSG8/0EY6rCEQIeVqzdna24HMnNa9V+ECkwQscQ ad2+WLYHen/1zZ8nw0UIQkqGJMHKz5tgbmNGvxdbcXPaXhB/N+hHQX76cix6 s69gafkRyMqyq7honIhq85Ozv3QOXj87FBNFWoTbj/nSaXv7/oMvWIQN1z0Y 6fScrJPEHgAeQ2GPcMTfkE3nyKYDltO0l2zFmgWaDb870YFEEe7NCrH/Px0d PzNrd+9sNX04+zrYhfmsa4Ji3FMbVU0EQytM/FccHJ2/9o/POm9eAy/bf/bs 5PD0FK/0/qihzm2QDOPsbkLpIShkumO2QnQ727tkI7O9/fCR3KfdXADr812e y96GlWlnG6idja+ORxymgC+Q5eF7d/+LgJruA64Q08B3v8kbtAM8e/32zZvD Ey7sPnheCS1VMRpeooBh6zaxsuItshfmytxBF3p4iZY2aluayb+kQWNvrr3G q5Z3aaYVsiruGTUgPfpasEjSRingZ4wQEJu/iuv22gptK/HHyUpz1R76yQtW CnC4HnS9Z7K8t8VkubO1Kzfwob5QoFXTJaJ1/+zs3+dcMGu79RS4APVxJKsV d8YDTnB2cnjYeQ0rYf/4Wefl4fGLs5/N2hoiqGksM5gNvB9wmuKuvTilus65 zCYLdW6hNmb00dyqJ2BLJ0tRMFPgw/uk797e2X1UtRuLxrqa+ppu398jjZ5x yr3AR1UbiPA3sdthRFrHBOttQm87E47C37Y5Zmqh8F3+IBM41kQbIxBC8XF1 ecDPfVe+gRZCR6fPjl4cnamyv91/17RfSw2bDfMAgPl2bSRx19eFOmtNwBfu rc3uVNNdn/xpkf42rHkUFbOxGtUlmpsUNA4kL+Yp3kZUN27+2+hn0zarW6vm CbsSMbE9ZheE7Z37j0XXuhSx0SGbU3r/Bj1554LRsJ9OwZtCE/8KbNTDASWq +uudzMZeXmn5HpMswdYa1cNjMUq3XtZgeP30jgwj1PZLe3QbJ9LSbICu+KYz jnUn+rCmatrMbbuq6bApdUKfvwRlc3MreWPJGnMoke/7FS22G8F9DsPqyIWD Gwf5Oy9QbtPmNDOBA5UujvKJ29gtu8LkeaULPr9hE77djJkZoK2SzEKmtbJ7 7z7af23vbstF5CRNunGWdS66HXtVthbeGxXDEcv9T3Dfaxl2Ipcw8I4ugBPL sdslju15UQ7LaziILAvB+eKkDvAUBFxuOovKOO/YDvHqXoROhUrlJP+lnQEy QMKqYXAbdR3VtgN8Gg6g6vNvFbG7jqoI2sWtbl194+2Opx4PxigV7u7syJ58 k8mXNng/ZfDz+pq9H0xKncSXMzdjV13dI1sgQgfr/hPacYQhzgrWCpjzyJIA 3y7u1XGU+pY1SynNPNsmuLm/YefEnsH10V2aW39ymQx/l3eGesKXh38+fMl+ jZd8eqBEaxQBYYBej/04pay0NtQM3aF/VZhG+55XkL7fgcsBzmmN1bukIM8h Ir53f4v4173t+3i9Cu/qGnUXqz6zTHhzPVFBVKCM957myCjw6P1rKEYK2pta fhZmmrGRb56D0Ky7MDF3JmYVJQNpgu7uKJ8dTDhwqIklNf5u130ZdxMmB+Xa 5MPlcTgDrO98Aj7vzUiUsyPd1/lxqLt3eubF2a9t+OVGXkiU47v52frsPcc7 9FE0meBFsdjVI0E8tyG0tLt+riJv2XBdm12O4U/ze/8xz+/9B2IGi9m5Oj7O lk0GyDHgRxOAgx6KyEwmNhai94XSGwDHUZoT47IPqFk4nqS4H6u8bWw81RcH 3lKYQm9OEISEHEZZng0xyR3ZkqfdS7y1apnV71YLB7Q1X9TKqCAe+5cbZhsk 474w/AdbbE+7ff/hbmvnkVosAV6MxMx9LlG5eKZtUjgOocVhYymgJ/CF55zF 7VvJWdqUWGK32Jk5RxGTtBMcWxON054zvfoorkWfu5qZmh9SFGcsqLyxUOXK eWw7qYD1aE3zg4rYqvw+jk47Qa5XKPubL/iuqYqiiThuKjCfNsOrLxlsZ9aM BB08fJjYDaPz+wmBiaw5i8g2CmOhw0g4no1Z46HzSTCmjfKYxC+jdlwbelxy XiyOzSZ71comcWWzptBfhzrbs6hTMungkjduzcM++LxIsjbC9NHxm+doTujx P7tXVB47Rkgpdq6mY1ipum8EBfpHYEurag7/W4D3LcT3CukG7NRKFrI561CI 9OYALDdV2tw1DUBxSP36SV3A4H5g2fhFoGzXrD53JgEX4qA4ymG1ftJ3hTAU g3B2OMVto7HCA0yKRvvkYrGM+021m7S3F11jdjWUwuFci6/dc4o4yrHHWza8 ZDS+rmP7C66iee2KafSboPnZTc9eGZWhnIOFMSNss1sXfJX/QmTr+QyKgwlx LH4/1vPrWzbXDcW7lTCNwh3IuLUCLzYU7lGfJ2Wc5BiW3h7cJEC57ROFRie1 ELKbYZK85wCRKWLNcROWkolOiab26lZ+uEIXYgFFSGmJK9wMtt8Gg0QOIk+x c2VFxWbFPsRL7uE9jPEDS+7eYwn2UylMubqpWlxownmRt4PEKETbeNR47jeW meWQzhdk8Bx3aw6LLxeaQcwHQBoY+JTWKoUqtnkMLYfCfqsOI4W71EfIHYUA HZOMivQujqC0eJ14GE6fq/x0FhMvVLIr9mlF7PUKEpnfRjVpzWrGbVXGODqn ALnmKaNlzRb9bx1QfAVweidrc/QdLtByCBSF3sMtoMsttD568PBx6x5fQs+h TGraOqn8F1Leujl0R7WOBCnPyF06yrKkO6C0CJoqOQIyhzZhMc8WlOh0yLSm OYe7y1WKaC48J8mNBFVTbduo1l3oJmb85tBY2aCnI00hD8M+wxtKVUTaDArB y+HyMAa26xclNyE4GPwIjVCrR4pcAY6dg00oI11G9LezJkVu2bAc2g42Mul0 GNM09Qxl6JxgFNxLOBansClNM8vIOV0wFs4EgzaOtYrRT987FN1vH7kAC/lk 8w3Dsu220MYW4DIcFWU85CDeWFbhHoG51Bd7qNcZSH+SPsWSpjUqgbnouG1X vEI8IknYGLs9rcNBzJzQ6FM/fMqAy33W3XD8wA6wTbZtqD0AKL4ZaMGnScni v01R+eRS2xImZYxocswGl29enx79BaBgkqVxj6dkOoQVgT2Ls0xCCYwijBcb 6fQ4koaX+NQVemHlaTTO0PIudiE9XQrObpICtAlaJ6P7ZGFcnNUkLGPHKrRe Bm4TxpleMsRQok/Mt1uIDiRlClXv1hbmDUtjHkPLfLtdVYYtKZhGqKAnwzTD 7JwY+Owyzii/jcgtOHuSFdbswzC+/VZDBkBE7pIaCBVNsPpH0l0ZFq2FBKN0 U+YcoKAUrdEc47BeMWTAgEIcUFrL7Q3QK+BjNF1YILOhzrvkqUAxu9H3FGPA S/551j9hNLkW53jB0I+4QKY+uFVip+aumwQAAm1+R6mhnPSpIzGFCdmOJA/Q h+S9TZZLjWE+ABoxuuilg4uLmBN0/EIfy59aVasAYLiFjoHwHHNxrAP2CUcu llhg0jjL97ffAgls4SXHt9uUf4KASDT8azd7LCI6fVxkUdhiDsCBR3uI3SPx DOnHVzwL3GvBOMbtY+lzeK2RxxsEbFfTHGBMsylxX4BNQfh4NrKZTAD5tsx3 P41xiqD0yIZq53EIQkZCbfNyp234AKp8JZpJsj3KvDWmJA3AUSaxqC5V13gb wbFkMOSsyEUzjo6O7GCC+a2TaQbQKGtqUZjLEKnMKSli4sU4InsLdNDp8iXM YKxYmvBVm4tPervWh48droBU38mbBeclzsZl/3LydBdPS+8tFRpMhA3iMfLI vYZPAyW0xinUkDtI3/iAQLVSCmq2R9Egn1N8M0ydzMnPoQ4Sc8uSg5i6rJuT wxedw7+cHR4/O3zmQFILnVx6k8YM8wAAUDL1Mh93ljPJOfJN5n3SpoNaGia6 Xk5zGuVZcVHhQEfRe6Ey192ALOggBjwXV9q3j8kIy5YDnjshvc6YU619u+X2 i6vLZOgBEkMWKcfnjqrpLYBwvZ3bWaP3GYZZIpx1/WrPxrNz7KAPZ0Tgo9Mh RuXPHNx1YRG8ZHLL63komLBrrIrmhR3Os2BVSPX0CMUN4vSXIPcS+JEqKbya HItUEm6Vt+vznqyv53YdWYZls++Y9c3LqrSrYYK2XpJjWhQAsMDqmtNcd0Zz LK9Rc91Fm/O5ql+iUeqLw79gJBJeNM2twvfnJ29f7h+cVfANKuuOnyqZSioi 1QXGMaa4g16cFImRnaRPqBjt8iQ5jojos9vGHLjpy5yAhusFpLE0HuE+nca3 rdxYxZqUkEzZe4hVScbAbrsfjQbD6+/KuSsHmTWNdGT/yaz8P2trv/0/371b /6653nSV13777Uk0HE9HT9512u/Wm7//vtn9dkWMBDRjailEy2c8oFlA7W93 Ny/Rqs5BhhfoAKbR/7mFA12qM5dfrTOXNZ0BdP6UwKR0KckPrIq78BNNTjat IE2QMVcqLhlYePLQNbdrsYugFuu9dJzBc58Z+qK4w67+MU0BZrqT77qTMjbc K0LH5Dt6moEPB2XpGbUtUXdtQ4X+mrDDMlN33e9u0HM9ka7AjJ5jCej2b93L d0v2XCHaNjS753T4QzXkdFJAd/hF+q5fzhyCKniDCQjaltEETc8YVHL+P93v 8D9t4Lm048iY6J3+gLm2gsL1IwrKLTugQsM4nkK7M4bzQp3X7C2/5EjF/RSl HGHGbr9r2Qj81IV1Z7NuhV3MauutS8KEW7bZ0wJMjihO56EqfWaoZhikcndZ PGmUb7uKFfUBkVUrkuuovF/zcOq2m5vtMjRflpXLdlJq+XNLkASi8QglDp+y FjU7OQKBs0Mb3WAwex17osLYtBgrc8NHSKeSFd/rbggTcc8z1vPJ5WDgp4mF YjMuAKLKctTSiLpcHlH4t9RyzQZS0eJgvHyTg3H9JvIKsBXx9QyI0axO40Rz mOooIvmQgjD0gyMfdJXdHLbClvml/69rUcm9p7LKlGpMJNI+JRBVQrCeXJa9 ifHS+Au0Q3xXkxkfbOyaKREOwSjALwm/tzZmC9sSgIRFX9TsSmQqfoYusTp8 49MMVb7PmOWvsdxrfcqCthazrtA2X5SY4c7EVb6TGekm/pQeUhR9a0BobcBs bJUJj0kNz4+Mmqu6lqi6kgiGV38p7G4RSmNxQO9kGhhZrtlvLfWFzyJ8pabK /+ANQJyZnBwxhB4GWZlegDxeAO2NA1aNZ0SvFYJzAxzuKVchHS56ovtRNmJ8 hnE6YKzu7it4XRWN9jQBQlPTca+CCf5orfnYScfNoW/5N4+Ad1Km+mPTeQds BF5W1aWtUR/+sTnmZqFVVigGkwdu00+Tcd6O1ZAyYdaNAM2U5TRc7XyeRuB4 1te5A7HyHG0bJ4Kke228lKmYAVTrmTVH8x4b7lUhOA8t0Vahm75aYIYp/G9V l10lBuZX6YpbeqWZcHnyCO+f7b3G4ny1q+9gMhZWUPG3kMBSoRNeX0ZcsRml gullIHn7e4xj/kP7e8xD+oNInmVq171v+T7kYT0hNV24msXPVnAsx+I5xFV8 pXiimy6JXxdfeQry3/4IPp8OBhcD2MO/OscPxlCxCiov8qnf5Y4rWET1/tm1 pZA5q7HCnlPZlNpCuK1wt6lc9vZlgALNB3yX5ZNF8lPdgjbhknn/LCvXJkJ1 VwBIv3N5GF0nMkBeQJEZYbytLppJ06XaIKfbGdHC8qHk7OQUI2q5iza5MX1+ 9PJ4/xWBcao0fSX85tX+2cHPvH+Fy4im4daGBehJteP7ULD1GAzHGHk4jS+o Vic3E/rx2/bWOxe+yJhwWeRpZpeZjdoI4KPue3zsyG+10DJybiisvjS6Kr5X TUxy/UWTDneZqYZ/S6xIbraDlidm7a7qSVOlMs0pU3u2B6SBSU3zjY2m3SMJ I134jp+8+w8F1ln9dtXZtmKOUHIGzH/bfuc/NviL7LX7ppdMMfwfX3TKragm haprUeeTKdXoZgyvAaxhwhTvNwUkngrcLZCvSaYI/835sOg8K3jZvsCEVwFi WtR1dsiDBeCdxZwXIo2xWRqduJ5/u6XuNHA86i7UDdUf4xo2IywMgJ05GYXk rLmnvmfoFSZ0yGXfbaajTpboQnF1odgVCjb65OmdHlTB/3LhpySrYkq/GP6f 37kgEmQUnfzwlDy7YviRJc5l1SG0Cp9CnBsCGOPtJwUE0wOnG87oYvQS0IbC rLsgVupsJBrMyHx922KwH+WwjeAuQyHMLDHgdXzxYoqWSJ5yuiekyeFVdM1u EDYQbApiCYiDUR//S6Gn7L08NTfRCSQ+e08o+2ombXV53X3Wi7OyIG0fTYpL inzZ8oW/vP7p+dHx0enPJcDEurg0F/XhMKhyyBB40whB6HKaTuwdm1yAj9CQ hdDoSpfZlo2dn6d7Tga0WefVnVOrNtl8i2PYIS1kMUb/6sIU0LVJRlayo4gM mHTSdwr7m3FKdQwADDJe/AFtZ3xSOgSJ7KKQL957dgWAny8D0loZvhVKKBgq EShn1MR7kY2Sy4Jee96OuhZG7rblxDJxZs2iwOjiSPMdWkqmf5JtgyKr15gP lj5Ysbn0QQnQTHjSUnHP8yDKX7QQXi+M9oPv5pap5CTERKx6jY21+UJNoSlB O5RCyhebH2X1A9b9QIns47GypwKSIMOMy2QihQf5aiZgOBsc8DBqZRimTVFW YC4bRLuQufKpWcmuszwebV6uONcUzmZpq4hFHyW45LKoCqKgrTYbzNHYTIZT ELbNKOl5Q3Ey856OgTqzolmadTTzDiBGQHT0UWUZ6NbaXMHdqIL7CxkhuWyW QTpM2E+tK378t2lEFo8C5Rfk0+NVWox0BasXn7ejGwSddVHfSHZR/SjmhPDp RU1N6s/zjq7vcoBq91htq68LY5wilwxUT3CxEPm4C3rlG68RlWs1dARS0WZg pp65TL+Fu3/j7RzaC2jMLOcR1eBkQbcqPErMmpwWmdyl16TURSsiNvsaO4tF merpGA4kVVZhcqMufDaV/Klda/ji7JRsSLph9PfB8NrrjO1ayhH0wKs5w/0Q zXLYcMyhjxRcHEf7TubvOtQo/XG24kDbtwEvEPuc38K6n6kDoLCNNXz/g9nR /mS21AZ8a++0zApdeOwUnL4xqMlCla9nVt6trbyLlUmdv+uCmoQZnUKWXncQ 9/Tl8z7ZOsFWJOEw6J5rFDvNOt7dkF8u0JNO1Rp7ld4eFEZKQMs0SXZFZjPn SHBaZgf+nk3iKzahw1RYqBy0ZxRWkX2P0sAPm5cCaI1vyMb0kZJWI1ui/FqY 8xPqs7kFwUUZguSK0XSYDyZDy2xDyP7OIOd05nAuipt45QBbIaXlvYrJOxs9 DchmRMDYerTVBWq1NTEVhTpW4zeZppMkI4cEf7uRNR1f0P7+42D2lb0ETP4j Hfmn0knS1vvt0bumK2bZpGM1G+YxAWZV2eZlGMQgJKXAhkNVaWna8UYdrkR3 Za84tPLI2LpjfvPu1j5sU+7vF2hIDBa+dkPlyZr4FT5nhnZmz9AuQVu048ok I+i5s874Z3ddEDm/39UYd7YZ/+x+h4YV87tfNMQojCK0yZg/GLR4ACj3FhrO vdnDuS/wxKhizljKNhh6KEVzDDeSwjZUus5c9L7PhVfT5nUkLLzb1La/1vF1 jyUJlAWVpkxLE/T9mzs9Y2uK6hsRRt9a89qygoNV0pTuEtuNeZdkHGirrp00 Lim7zpybQ0oOT+gseY42207Yuo5zFuZZyPLSj5RAi3YnkBWVYXGaivBFr+o7 5lPliP2mU1cxCDFixljmdSCcRncOmueWYwPuQF8GnfA6MkRfw+Ou6EvDeGE3 sH40GGZe+yXk4Ow7vQqMUUzmvBEm1cRTJsrQ0zG59EpFisQGIluWsbjBMgT6 lFCFmIySxO1DLKDDcXqfIaiH0MZxMrWHwEaDjuvpR/hwPu3/tr3ziGiqATIi ZiFds1/IHMPm87MvOe5aA6ePeok4a5n50+WBliC2txmmVQu6G0eD68ySLTdH iixZZw6ATwX/WdSUplqADe9Tq8RVPoe1LaxKlUajVN4e2F6i8ygcJ5LpBTlA oyoM6IrVEU4bwdOpjnMES7x8ZI7IliYXJzaLAhIB+fDk7dAHfWtVb+t+supZ q/OIP0bktYJebqxtbpPdOmvx6Oj27VaL3Gi+3XEHn293W6IX98u98o6F0W+p ZyLeWYp2+JWN2Ee8i4YUd+cvdHvcapltgOiAu/CLn9zcF+4vAbd0zHMIvpM5 9wPHxMVrwTHxRs1hz9Icl5nP4G2fPKXQApt9qeUbk2FKJGerwqhplT0lVKPB TZPtAN81yZMqHFD4H9pJaKmmk7oP1E/1QlVBwqmDz6YJFMDzE/ND0nSh3xop MEK3OccJnaIz6av13SgYCrEjlgVhaSfstQkw7W8dhVcFnjTBNDQovMlTm4Nu 3gh5BnSQb5TUAvB3i/D1YPiapDSW/lNYKkuNSBZK0p8zOJyHvnaks66LLOTg hXIyinMkuZbLoHMedd+7rHyD0Sju4eEeWBgZ4aFrNHnvkRdrX80mkkjSb9qq n3xmPyyIcefYYfopjHjPf7R59Pw7ZP6Nz470rBjgHX96NlxcDyNLWB8icnqC Q78MtTfgLR3FrdQm5rsONHl4OcoeQMSqxdTLbet6SpLA7AWYO2WrJiWHDZ6S JOje52orWtIim8tzvdHwm6a719M8tSA6wnhoLISCEGKljByUR5Iq81uhJs9W Fmeu6DY8GE9jPY7PwU3fZ2+xd1tj8h//MLcdnXINewcRCFotMfrE6SHpTm4n JJZReMnpwrwPxigbDuOcpszKfdYazEo5QDVCB85tXWkorcmWVTVaA9svkDCk f07OgFVJBoAtWVAsaVCwhmBh2UMUyufaERTOSnt0QZTWRqtObdQ/zdBDPaUP IqJNEwqLFb82wm0NLRdT2eGTdCbrsqwqtee0en5V6o1Xxh+heyBmD+XENYM8 uFOhjw6ftkhrBr/Csetg75hm0faluAPSbcFFt9tBD9MURXQ8nKfatlJjh2Eu jR+TOtmvFkNlRpruVcSCsdfHZyq2UXSjq2SiE32dfKOrZIIS3P1WXCXXtbLA vbJcIRfulnGWy4Fr9M1vOXLNzIviosY9DFFmRRmYFLPEFXNTX/guXFniO9KG G8YSkqiymixUeKFH97Zau1tmY2d7Z7v1YKsU2LQ7TLK4Ezic20iYHI3Zymsq qOlVOoBtZcylObipD9TcL7EtqMvyXtIPONenUC9zWxLYdejqEsUKx7ScYsoY oj+00bTpNzGOJzbrYuteqcwhDNmVDq6RRYCW7QHB+AgbdlN4IvKxg45WI/4g Pqaw6EFbfUROzB2i4/c2V4ffeOVCVotEBagCUx8qO4WwvkqnaJYdIqjtrcoW seCXtegkgvKcGp5Ue2IuTqU9DhhnVdF9P50UdAHsVUpf+JYWRIVCwCjd94u8 /fz1682uiTLLa3/aP/jT2zfPjk6+sx//X97SbQAYbtc7/XrBC4fEXzGuXvlI HPQYuEwXGJSqAMT5ncrDoSI/Wcw2ocj/u+Jj8KqT2O2oiyG1Nak/77z+U5N2 pgKYluoJIdzreiLSPgJDlVHewUhMboq9iG6qYFVPvJZq5y5Mi8bSmhRV5pcv R9vCzVdi2JUvWISuK9XrL2znC5YeYT5gy2SD16iP1IxUo2hEuqIDN1+lSY4a wfYuXdpj4bjXnqKNOjxj+GZLLDqKs+5Dq5KGpLvu/qSid9vz+1MKH13dsJqD 8mjZyK/QM8e+5HzmlHuv1bSUXIVuaw5RExm7NKL38SQvDyXo+mdnTwN9tZTs k3bJC68XDV7TFb8jbRdXf8vZvdRH8t6uiOTNE3CnJ84YM2fABfLe+K9bLuoY BbIhoSJ4s44iwZ4NBgnCSUoB7Esmc85WrhxTUMy5nLTSx+ZdGpfH25RrfWdn Z5dz2SoByBCT6GCIT9yeRNhh8YUv+CXDrg4gL7mMaJRlWBh2HvNjjF1gemct l7XmwUEUSHiurJNBpyKMKO8i3OM2q1vEbo4itLXodbyJiAwjzFOB9LRo1VYF jouDxfNDdtlJkyTv8LliLZzW/rCQKWPS/6jzSAffrF9OEPcw47d1dWSV8Bzf 3209wDl+cK9FAcllDu0IEYEBclCPRsA6Fre8KhJL8lhg5f+WLNrErTKQy7uX MBmcoMFJsewJgHHGMEVH5/j18eET54kmzH06luiWg7/j9is5WLl3K3ZBexic t+PkiVvRQa/erCgWUDtOKAk9nW5OBEc7W/fuUe6snd37DyWp4FU0fF9KoiDT 6L5JIgkesMrikaiI83XZJ/SL8Pqmh2eBuJd1YNQ5pc/qR4Bl1gTUfnTHDDw4 9Sj12B72xNCLZEZamKQuj1db5/ESIJKPZ1EglLYjqU0EtFHTgs/kU50uZKGk LOqTTUJWAjcuwoOtoWNTdT0WcySmkfv3KZfLzu6DR5Lhb3kaISNE20KH3TZs 4789Zv+X37dWzX8D5p4EX8StYy4+HPSsiA7/ZU5KNg+M0ngWqAHflWlhQSiL kUOhiWWIIX3fuUyS98WxLzDW+pQ3hZU6P6vM4qgpNVqDoEKem5v2SBLdLIBJ TAhZwuHcWpj6U+e+2tmVbK07D3Ye3HDRWJuMICMcse9sU1LC4f2xt7vnEFw9 g3EWbUZdUp42rLUnXfGgYu2aY7qe+0oSiNNBW80sX7dK1q8BxTRc6i4ZSXUG L3tHzStCZwOsWaINvXwsFbbhPWwIGCSx8yEa/rZDSeKGPfit7sEXa8MdvCvT Mbl1XNEPt4oBhbW9CT9tyyd8Ac87NrEb50OeMHF8EkqDLXyHKA228J17N6Y0 FDM9h57IqaDhXBpRK8Ndtdhu/5DGFIit0x8rb5MZH/mb3637M3ZrpeeYs0zb jQZnevX8x9ZedM0CCHgc9EL+vmgXXM7KWRy+2ElPFkv1Valj5jZYHJJKEzi/ yTCRWqOBz06aWKC+zf2qQMgrtwsvAEWIKJjrAmmVJ2xxgMtgs67dmVhdSMwy uhNrVWLRP/6hUnr6780m4TVctohZu6axEzRvTdc7f2VrhIE82qWz8IPHj/gs fCP2wQlWG317KsnyHpqlwbuVO9mTO70nUJUCOz6RxG+UxHQA28iAfUP+CtS6 ire1fxUysSlOSa9EWZRhBnDja//At1fuUbIDKyVJo1HtWRNAaM4AAUNRiHKm bbIp2wkWfozTdhuAO/KG6aK11xRp4P79bUrosPPowYPWzkN1GCVUUlY6fQq1 SoKmO1+Lx2PpXggvBlUa5eD46lUL60QdlXl0iJQzL1VssuKkQqciZZ1aiRJ5 IBWJzujtMS6Y1ye4Zt4enGGK+8ymFK5vxS8Wv/b4vIvZ+ARWCYrWlQQAseDB z4cHf+r4C8bOq/0XRweYQopu8UNLg8hckisv3i/i/TGll0iSnqHOxAOVnES5 sLl0gXA82UZ3th/Yra3dVlfw1EmkDU4xOHinfxdHy6d7IDAoU4FJXw1P7040 JYwE30o41jmL5t4qMormonDDmaVgrB5UW8yDjMKihEWHPp9LNgS6lyfHsDzz hg+YaYFCYOvYbj5OiAravNigdIiRINAtjKaYOem0ha5KgSvrakax4fEq6fXJ 0YvOKRMLR9Ig3KOPYCYr/dG91vYjWOmPt7daO6xQIRUgRgIprlZZnUk6uOj4 xZq1+O7UWnPe7QWWnL0ma3p6m4lN/jeDIQBYXvskDVvZi+JXZFoAr0x93p6V +hz4x2DcwYLFY6P/EuYynp+FmWui1FsNE7/cDGZ3kFJs/2q49uuysMvH7rbV wMiHipTObeuWqMYkvg/IIDT2tMPyUjO3sdTMSXrhGXmrN2bNrDrgLD3BSzZd JIClmy7QwZLNV9HJEl0oksvCrdeTU9D6ckRlqvQLWaBfUMCQq6KZoyYeZ35S wE51w7eXbtgBJF/MsGXitg93H6OKf3frwUMRXYnXctbg6qsbU7iAscJdoElS YETOvcqd+YsFoKxfgLmzXztFRp2OWYyIR3j71XNBoDKV5Mxr78Perfw+Bhh3 svXv6DINmm3/gH6X8ThndLNPASdSwQaopVHUTZPMpTLRVlSb5rltfhUG2aPg bIy8B5SaG7D3eFtydN8IfQ3Lj0DkJcm5ZmxUdAWkaIn8urbVhDHyxtRYbl9q 1DO3YlJ1XEPLQd9YAnqgFapYx5yg3YhNSLuhbqyslM6Elzttprxv6i1j42YV NyWrt9Jj5AW5kyVMPoHiqaXwmSTR2q8Y289J6ERTj3Z3maa2gbh2HnzBkvwk 3bbfskB7lGXqPIF+eVx3D8sZ/pjp+XSW6LRW2RIisGa1Fh24VsnnSUFFgIV4 nA1Kgw2FveVmBqJWVlgJ3HC9AEhVbHRdZDFWaSsuVD7SkzUoUv0vmnyXhmB7 XwomatN4h/1vmVLvZ/e80PGCrVdFnKfAPehinKToecC948zlkof8GwyqpcOe QlOqc/IJeEwT30ole7Zj+rDHInufDlQB/2OiKVpKOxBI2C8O5Cz2rHP22p2z RNf6CPMxEnk/3pVz/B9I3lD+j6RwPp7eiM5vSujU5B9A6TyUkN7xaVHKV9/c S6jeMmoSFl0VVC8c6JesDG8bnvlM2zXmREXzHCuAoAsne/xwEjlnq1U01SK0 FGWOz6UcoHVS0gWsI6htnvJqeXz/Ea+W3e1HgYAxy7SmvFrk7qOoPVKCbENr Nf9Xmvg/RZrY3br3ELnsxu69rYete/dKhuo3Nq6ql+SFtHUQ9/E5Gw+oLz6v rwTzZmcBZYK/Fwj5qpQV8Q+h15LViIyUaQPBiDcc5pIl43oYpDK+yGX10dMn rhNugh4VM3bAt6ew2/30K9HXsw7ugKy6NdXxF4poF4brkOd2by1b2K9NGzuh Tl3cKPP6sDFoCnn+AG0tAXtJKs0Cg76gaFKK11d0oFV7XAkxjNhFhhZ3+C69 1qoqqJbNAtmSGWrYvuD25neHP1B6mTeBNH2azP0chjhUZeYh749BnOpAGXsz euMXSgetCOetr8970uRSG67NVALk+eLs13bcU+vP3DVWUkF9MRn9+a+bNTuy pdkS5q3S+tXg4jI3Zy6BKzq3jpNx2wX9G1L40ey/SffAbPXxTusxctUHj8U0 ZZZ56S1JKoLBu54fk46BhozedJhgvpgmnFhze6YVaj+06uyj0/hiFer8roo2 oBWKccnZPXaB9WZdX1BhvLOADcomHPXXF9nAR9abd/tAnodZ7QWHQJl1zbHw 2GrvOWz0dLtp9cn7lu3ei3uWBOvhlm6TUouC1W3Inry9cw9vi3fvb91jldvy Rr+uGSiwg1Ygw8meod/kgWAD7si7p/SnxPf4pTMNV7yu3aAzzfkgH0UTI38Y Z/qDQHBXxstUEp89EEwxFSnwFBIJWDDss3Ej4E3qMBLx9cZGy778gS3qGaW7 u4zS7d2bo7RRsApWgYuw6XctZWWwggmq03Eozd/BTGGdO1lnRRcVI+xJH3Ov WImzeq2WWjQFDN+kssP0vOGZld/eCc824nzk9gbG8v0txvLu1lcn3P9AUg37 xGKt4Omx4OnxF1EjOdhwV+4iqdtjyyJTaRwp/kdQXmsW3e083Go9Anw+APp7 7M/AiE69v2EoSvj1wZ1Y8I+gNbCbIypzZu4Fw0lTZbK2kElXvTFWncVlo2hu ubEUiILp1UzLq2p7SjO/PZaiB5kedVhRJunxFvlB7D54uG39IG4yTaLZa5R8 WaILZQTJCRUCrwnUWhSMI6dqmqvsI2dbJxasGxvcA22hvVx7Gwu3t4xNXaFb amqd/RqVkAtFEFts06gHJkNb6znp9ixtt+WgUJaDvr+DpFm/9+Ahz/qje49K s56h0Q1PdpQOkO/BAeg8SYakVutMupeOkQcuStajI3C/o3QVIIoT/3TGtZaz OEIQ44BgsX+oWephoOx6V5aG9jIJ7PMXaWVjkVYWX8rlvqgpn8k3BHdqIZsC RrfnwCjxAqaBx/eJPT96+IC9xJakAMylMRzAdoF8ec8/i5EEigj+ZWG/bbvC LNZ/YDtEMdzCrz7gyJorKDsat8qO1WHFjUYYqcSVbNquTFhUYVFA7W19q516 cWAIA6KL4v2N8HX/MXsD7T4GhGml7pJrZi7lmcXo2zia8jvZDCIY9DtoTBH3 ggXi3ha8BzzHUyW8d/oS7SyzRCp6ExqZ1PfJNLQiXJUFLFPcRW73dsnqkDSy rhDZEYYllTVmdfGCUSZdv0BtzMmnr0hWLmHFrnD4QCKoh7s7xITvbW/vsIA0 ToCc0HftA0YnDLZR3HPFexypaiAaC+uPWUhBkFM40ywZfuBrCoApig051SSZ D1KR+EhAzJHN2pYnN/h153IT5D2VAlDV4OmZW1HkwrbEM/olNrhGR+eSj5gN o0moHoyh5xjEIuZc9z561U3qUVRAKJPpaEfw3MFgFFs2WlKHc1mu5dDn7RWM OwETgIEGLKZmguEvLVyMgGyoTJnLVsh28SbVEWWqMtLKva2dXWTW9+AH+rzA u950NBG0Z3QljBqbeAxDUNvqhE9jCd/MUEfEBCVxHrs28IlS5z2BIzEO30XQ 4rWoIqkohuWowroEJ9YlmAMGkCNvsNif0GLX7bmES1XNCgsQ7u+ix2m4uFLL UMmS3wMUAIQ4NvJnjG1s+6bw/ayG2Cuv3BR72ZUbqwbCTtEqGVU3SdPpBCHI QrozeRKGx0pCyJ/1UnQTYdwxzPVNDmifhYx27zEZ7TzkPX9xKgrun6gabqxA 6GE1e0CWb7g5W1Wlx9d6V74/MbKP38EFgPZw8LNHBmAW4KpZ5U+0x7dYrMNH Ak3Ed3PALDFU+Uu4FputoDmnfj6Ju9M0G3zAwJCIjkz5/7X4goZCMkYuTlfb 5Wumudhm+eve/UdWBCesKr15sANIGsPwoi+Y6kPObY133DRQ69BBnpCY0cX1 khTkmE1TNQY1bR4KF5dsuUoujdJ5zBk18kRCm51PL3ySi0GexcM+4WYSp5fR hJLTo892CjQGY7iixEiZxDtEzxnOwRJvXmxyoMBkSEHdMHan6Q36gFJUL6M2 O42yCd1AcPZdVNWP6J7gnBXO0K/+dEgymKT2gV8vDg6gkzCTCXTI2iqW6Z2i rpELqIoKRlO5s/W49Xgb5vLB1r3W7oMHbjIrqhD9/Jdky3zNq90SRqQzZsKy 6wwTm/lro8oOQZiFRS0Vt6v5N/Sk/CSZ2C/jIdpTuH/jBLa8i+mIFkKDjZlW L1cNZ7n/hPsfRZFydSor/DmscJ5k8ewKH1QFxM/cLvV0BSQjVaOywjNVgSfY 10jjv00HKRxCfDWp9UbVytJub5AuUutU1eLAOb5ifa2fVC3iOtkibR2pWrCl 9CjwiWC7vlaqatFZRVWrr3Vla+FVEeWAisjoiBQRlNbvMhlqyeyT1DQ1s8n/ pMyWIeif9zjRn15mG8TKOlOKPC/rZeNT4bLxLX59UgwVZGVTv+/lpn1p/mHa baR9syI6uhXze/4NZT/nMKX4cdNdeBbqP6P6zL4qAPAHiVCFmXro+U4mHE4u NjVWZvb2z9SaDd9W0Z79hIJKOiJeUdv1DxYYLsoCsKMxyqAZZ02lu12YyQPm 2xeUFz5DvgWcHjMHZbVt9Bg9sI4LDeCeQfzThtfEMLSYw7AO0huCJAz5e8Zo GzffH8z3/LYNy/IHigi/EqJU8BOP0aQkVoy9trFTaoyXufkeeH/bBbf7oRo6 ZSPvX9Peg3uF5EbyMfHqmvqJmnK8wXy/TEvFyHs0Nr6KVWGnKts9onaZu5jv 6W8bD0kLtOqTHQYZoLB2bXNX1JxiMOZ7+iNTWNnmLxSPLrJkAgVrwacE3nO9 BaCfQOFK4J9reI5dW3Vc5w6GBSyFJ5u8v5CKcg5umfC5NJ6TeJKkOcZlzhwP g4dOSu8703TYVMm030R4nMVpwTbR0tOK6uyDp6UEWBpKTJCxYf2O1A3FfODO XZv6HX5/sGPGb2zK196mzst5Ucz+VItmjWFgbTi1Xn74c+/Nk9MnPz05enL1 JH3yTIdtr5RQJLJjUzLPbKgAUuowOcmDgyRIKU9wYxK+LpHmgo2j8ugFsofU s0xRqhYMXKzdbaH2n1VtIpSgYUc91U33bGXilVKzl3TokTR3FZWeuUq0raha 9FxX7Y2tJtxUheIDVMJcueB7OiekvxUkRQEU2yvGZbdHVeu1bsXnQmLIlWoU nNpuCd+t7ZZ8X7gbRV5s22c4nTBBIr+s7uFPtoeeXX+1ThZZ+Y07eWQ7Kby9 tof0nfRiC3eSA8BjnZo5TG3jihXXdgDLdKjMDWgLKyvmbfsThPn3RYSNSvuV Xb+yXdeblPS9ZB84A2x5nHwFcNOB6vb0SF33JbKCaIsKISYMap7g5EzGswYz SpnVO93VYgzNiU19UsUlfUy++COIASRbDPFGU2mZPjtrwGqmUeTdpTy/6M8u 5w0+tPtkA5nKTiCRFVQqVYdx1MjDNoE7DmJe5TEIxBQWX8O8vUpvXUi8axig aRtuwZUrJuxlj5vqtL02KmpgpoZ74m8DsyGAJUtRIUUvlFNqp/Nr0TwVdXyf XVL0/0KhgP+hXSLn5woQSf++E+nh5yi7NGy3kvRRI/W3qa5A7DoLtQt4RdHR xoYdfLMnAJ/jLKBKC/XbEYlv4/hKmyaeY5aK7LKNWgqObiDwlVWefvCj1om6 haaInt6cnaybbJjkNv6/j8mh83yTuXo0Yk665ej1tiLPIBw8vHHFLeP1J7O+ TRX35/2TMBWzjUWgIthvMKCNHalL+QmccdKWeilJC1wP+O0ouhigkUcx5gQV wfu1CYanoKJiG+v6iXiBmjRrfN2EL9YK09dC842j49PDkzOupq9IqYY1DnB4 W8fXFct6f4h895rN9RUtBYuYQwn3/bITzGvTzKY0sedonOAfW3IKoa7LQDnu voDrK0FZkXo2nZCIHfj96MTgBYqHmh+iYSe/tUFoxGfWBnNWDKZLCvK6PrFE WW2S68PyBaFizaSEdJ/mWsbim5abkLX69NjFYwyQvvQ9/ltdzz9aMzV+vJ49 kI91I/m4V1/puq7SdeXwP2pfea4fUKEg5ra9YK7Fx8dmqz6X+LXH1n/dIkwZ DFZdPAIZewaSiMwugXvbWD1w4V5jkuDu8YmUSMIatnCfbBvhYVoA2+J83GgJ 44T+LVnes4CzxozgquQT2mlMNVgrz7usgrBOeN+kNCGk/uJczVZWoCSFclJb kfg5yA1ok7SB0t2M0B63jVaA7d6KhDtig/leRPoKzppsXKzfKAiqWNOqDUfD PcXrAElFmQUpb1z8YLl1wd1oPB2dxyldDBBaYZu6hlZiG6KRHCEcFLm4pqsL Ft+kPpx8zdrGBh1XuxjSQHgtOwiMEwxzni5TZeHyGGYy5rgGUhWIi+iTrpPs AEnH5YfFRYujC3s73SwAfGqe7788PSx1s6Lg2cnbQ9u9A04uhD2kfZ5Zrlz2 +K2/Ur4r7EqYdY6yjiPnkqRFa4+2tlqmgg/LS83gWopZhBSBKfdsmvKqjrg1 WyOAdXgT7sgkXmd5POpczqqxwoUwI7EEiarRvHiNCRf8BpbX4fH+T9AcBZ46 On5ht2B70i/e0wd6A3mHAOHFXVmS+n233Xb7MKpzga9hcnng1fzUVLI2vjFr d+G737v16chd4Yk1l5kMyOMnyr3vGYvKwJDx2xrw5q6C6g1BNr6Jx71Bv8xj HtTxmDfCY1ACVooxf2p1QUBKMvF3xRxVnjnbVGf86AWgiuNrcSJqGS51esfP QlCwmHVr5cXBAR7Xqg9WDobTOBDwXQ9c7zP07Z7/VnvcuV/sm/3OQu/hAQW2 gW2xVYTR3AvMNNUZqfp0VM5ZhGpNvEPClFzog/T3OE1MYNfPGS9J68mnOATI ZtqSfpC3LRefqOLcdf+dzvqDGbyVqM+SPpTahv+3Er3qgs4YVD6zhTgiu53m fDhWkC/Ac9J8VcIgT5fqyKsI/g5dt3M6bTn6kuY+KipQ7PI0BZppValptNxu P1YviBKT6By8fgv/RWscZIreToATf3oYKy1lRTAPTuAQWgWqlD9CjM2UgTwR /tOnZrcZhF5UGA7pNFxv2zPWm1von9U56ewyRv5Ers0RKj1gW59OeHa+4Y0b D9LUD1jz6BaHcssVBrDGebqKbQo6XAcjzriZXVIuyEEg+4zsekFxBwQarE3I 4X2K7m304QxkSwki4PfBPf1RjGU6nZdHx7AJ4ipx32HvEfHAGRWuHLx99fbl /tnRnw87+ycvTmE67pLdmgNGGvX6+ieH+y87f95/+faQ5nvp+s+P/nL47EsA 9JIpGlIDk1i66hQqPbjXuVnFR0vX+p+rJO0tXev/Onjeme4sXQ1PivMq+dJv zk5WnDWl9cBdK5mgBlCbFnrAbzzd6uVZq5pDt+aLvFIjxzIYb7OVJ0RbD/hw s0LFTPX5qpX87tkej+SbQc2ZswTx85IsEtuEVfzF/NHDKTJHtb/UZZvSt56C BJvpiFkYe3kzf7PJr7zCWbSlamLEbE0ddaydIunG20FyGLbvcLLmb+3eO/jP G9mJgVtuXr6z/NlfbZsVncHPrPyGDW9Tp3fIbgB/Hb9bseFAZ1+9tDl07Dxy tH3mYLko0ajdmWz/ihux8HC7X6tIgpeDvEOhAcOElttyDp9zSIPpjfdUuRkH P0ke06Zb2U6af+QghWvNPZdu9ou2L56G8g4muoa6Lab9BdtL+wu2lvaXbCvt m20p7ZtsJ+2lt5L20ttIe/ktpL3s9tH+2lvH4hdTVrH3MbhiKl1XtZB6ZaVS Gsy0aE5i869/IGmNRe8IDxkRLvxxcHIJL7jwUqLycOkl/ONEs42qKy2JZTXr 3GhczOPZmyWt1mCnVFtYsFsUT5PfY+4aDKcQnA/DcSg0ZDcfiZ8nPvejgkdD Dm8faMwfZdAfK0+mH5cSE8Ij28dZsoLqVUlk+OiD8yzRjGSRN+VdwiUM9/L5 F2kaKhQ+Npd3CBdD5kAVFXDIOikE5QpN6XzhcljyceA+0eVPSC+0CnH3gRdj NHgcEsWUl5Ps2orynPBAedNw5RasRAowV3y3FtiNNyp2zqrI8LBrdmyEokJE FSpCN3ZaPJumNirKZTyG7sZj4KkXogoJhDwWMPpO6cuW7syyLAiynrenQxs4 0GnLnXuU7uWac17kdSeD+iUWQwWva8edHkAcYYJGZJMgP47zKWncpWFKSA4V pDtKBhpkRtJjirBKJgEBqyCuex5DCV5Y1o5WOQxo5CjglG+epDEGmDENQF9/ muYCJbcZEMaYtJRvKbIurIN0kHh1NVBBlXFHcU+ZK9irGYi/VPlRBatGwOd5 k9T25KSSjFcxjcmYjJWvSvaXOGKaCaJ75HBJtztNMSAj2wDipuQNhXiiQOrH RMxQ5vzayeykajqPuxEQFS7iZAzNhw1n0VhPW3a7uKoDRueyD/MQAiMdoSEq i9y2cs4cVtTXmukN9jxRtmMfSv4cdtXbq3HqBhCutevJ43GROMkMhhjJYAQM dBDRxKCbTMNEdDV7wYbMCAPjWSnrus2ZGCptBWJ0JO+3PNu18cKAg/mAHjIa hyAVWVCHFKxQtPlQmL0O2YVQtSysJ0KcVAluMDHgW7C7/Hfh+YlR8cn2tCZ/ oRUnAWoZGEMqWuWrf8V1ueyaXK610soNEZqVYqTXzgWIwxKC1B8oQ9V+EIL+ ZsxLOsWdAbAzRlaFy5vwuCWbrFQEF1Aaxt6bgdBJ97IThLENQrguBsYro8lP bHeLQwjce/zwPocYmm2NUGBCrHar4EPuFi0UxdtOob3UZQ3b7xQvPtqVNxz2 5qJch79Yw55nxLnPeWeOzjGfAlZpW0bn95SWifOuyhcwWxo7Gvfij0/QuuQ7 54h4eevpl/+71W63C2AbcCjF+HYgLWw/uHdv9yEw3o2NUiE4Xb/HYXWTyTV7 +m+37puN7Ra6BZLr6BveNEPTRTxQWl8icpNUXj6E4wOAl5Iv49pB0+xsbe20 8L+79N979N+H9N9H5jnOxmnSz69Qfn6eTNEkgxxSj8bdTVpCi0PD/25vUaU5 cGG+yAfUSnk2eRAcPDZtzrWt1s6u2djZbt3jIPkRuRKQZgmK7VmFEcM4eP3m 16PjF7soafYpSRV8vmW+GfQxwy9W6Lw4PH5BcRp+vuVUU8X35P26zyAnqPCk Lo+SDEVxXBpEW97QhNCNkjzaAdg4kiTCn8do1QLjil0aJBtt8m8g/bIrFW7T bMpBDrJRtxuTa7dMt3UHRin+PYyxZQ4wPN5+L0I1ZSRngDSeADuBdlm0iiTc mYC3WpHpOBtcoBGIWpPWWvPPIsvbwDM+FIWDzasvtLjbJzMONqZjt9txhpXY fnSMdNsn1aY9zgf2pJuMOJL4bPYPgiI2o05+FGM8JJOyRYUz0SOzKPUdTj2f aq0m5PjF9pRiK0PgQRLriYUK+ow4fzTt8PyLPah0L+Puez69DHKu34tj65Wc ew0uDRU9nllPBJBdaq+cc3uhlw8rRR2WO0KETDRQ+zy5mGobGRouDWGv0SCL y6voOisZh0oNtqKAkRfQ4UycyEt4mvfJIA1/7CHQAwzN2TMYdSDOJsmYxHol a7aIyqdAe96Fx15/zov76cai7/SdReyenSVUKcPi8IuBl1Nu+YcPAoo7oti+ 4kUsAohMfxh/HCBxU+QO2DNohmmhjKdwtiblN4NA63W7Xiopyj/V2+RAo2br 4+7D7e693d0+TtzjnXv3Hz/e3tpFnPTi7mAUDVkteBVlJoUfyQhP+pdJAkuN 14Vkp/JLZi6tBrRkJ13YXClJne+gWw421V8/GnevjRhgwnGue2l6g2wyRNqK gBWm6GIGg4ADm7BBOt3bwzvT/BjFDjnf36YDNS4IVPNTXyODVrpA72PKLEiX 0YH3V6H/1an21o7QyBWorvE7V+8l5lOD//3uklKVMjSe49mUbHCx/p4uTPEY 5TPFWaWfyvb6dtn4uonVG+XwHGru7kwQlEzhHcoATfk+V1pU12ZV8Ha3603b dqvciaDSEE9mBWO0lrsvaarRqZRCyA3o0LcIfgGrnwp1kZMgcyjQvnH+BGfW lQCVV0oJwFSPcX5RQpRJlkCraorWjVM9u8+ikA/00tLavrLnJKdzZBEsGxBm UPuF5O2UfZvdFa8Cigg9vOVISAVJ3k2cnW+nQCJN8QCeyEGd92fy5EYE+l2B kn1zpGLUzfehV/AD63jLP7nfs5EchsNrXvPY5ysOhCFsPxOtpjXj6Jk4Soek k8TjQC0CA4ONis+BpaJF40mcpwNYt3hf1/XWm2oz0rs5X+Ayf2C+MRApYBLl l3bHG3BAkGCTr93gmTYw99YGaSWVd4i/GNT+IWYh9xAJHyDWws/DDbZlTwgU LSQeQrc+xDQECtwNR49kZL5dc4pjZhJYGIrKxhwhQ+wPPuK0PGdjU1YsXgGT lF7r+Cy4LfKOwjfLttkONbtWE8XbTtMLsfu1pB1VeFc4e3+6P1UYubVReaFQ FzhcHH374k9Q0GfWJUD1PgvqBOZ4GLaoVfuhs81nT4z41gqzQmhAE/jC/HXb fP+9+Wn/9JAb/h6Fgx9WSVQY9GlPU3ya0iCI4pFLboo+js8gli79jbtTyiW4 EU5HnORUiNzgDTkB1OQAZ4UpcxBKutAdxiRWwGFkgHpIOLoMrwVYVgLEuooI wwe9txpKOOkA8+R46AsAwjOPBkb6WRui0J5I0JkQCuhlO5oSXjEOWjtPxIV4 kibAwEd0/mOmHlKUEtiYooKgyuUtt4qawsydJlA/zqesIlW5A40lIGseL53i 8lb5HHRYH0SG8QXwWjhLMytD5oxc2O4gnoWlccno4642kVyvXInsa58VEVZE VSuQiMcWc9V+QfNxVUASCD5jhaglTrvVR13C1PzjLmcEkJOSY+5xzwVRChxb ShkLnE5XcynJ3ix2u4BhjGG1Z4NYYbol0QpGJCpHKeohSIUwGGM0BQxgEKGv Y560mKnHH8k6p8e3Sak/o/+ZrgNJxICVYg8j7p5w4O6Wg7jxoqSj6URWT46U lUKNLZLJdkWNHvCNEw2iRTOiFK7Wq+McEHYlWCycXjDQKCY2x3Cje6WvpDzi eJH6axA3isvobEdlONZnYd0FgqMrQVEsJNNMBCoM5HURjUmOiTJmdhySEdOm gMyEg4GNE2aTaMqLa+YuHyf5mZ2y4a2+0heMSmhVe43gUV1Ke1T6FGaTKUJ0 9516fp4Nsm6K7AIJnmKBujRFYtXkg5VtWlZKiYiwEFWglU3qJ4z193SrRWf5 Yzo/ETfHHBho+Y6ZUkbxiK6kM3vYHowpaLM7AnOGqYP9l/snDOhUufywFkmd d43LSAXSO5c/48h0JHP5c5jRqaukIBIGUmSQxKVNeVqCSpTDqLpOj9GHUaO8 /oAcmNoFIBKElcG8Ec5CtAlbtEAr93f/5GT/V66zT2E7UcPoCxfaULm1Wg2K 73uA4t84b8OBx6kfnNxu+ysDR2CW3L2qAvddsf2hwpcJrOfrERZC7oMR6eI0 RrfMEjA9ehVYNsCjZMrRiXJoBlw8FQqERw5SuXLDguWGCkTYI13H1mzk5xZS XUdy89GfbXxry9GbHXyDEFzRbVfAvershEWyJuLeFhNWoRQvekHZOGK0Quie PihOK4hfdfwiUiEzl1pGVesoCEIqFCTrog0lpy78JtR4lWSOBzqAZAtJ5bMi UJxSAMkwiZ8VIQbFOY4ol5cggJRIENGyysFEO5M8XQ1QKTv7VYR3xjBpWcaV 8kvYAi8u7ZlUFHmx404Fjv5J6wYtl6cAotQdsmmRyIKJiMF4nkCWWZuah6ui UbDUVGpcVCEXphb/w1WQW3jSkMr4Wbt7Yh/YBZK2RZQ1Ai6D8h+WWcWKqxIV ODpPPvgucHU55ejTpMSXZi0nGk2g/iqgFHXzrlIfVNdAMlDlBct+Qild5Lq8 IF3mlarNVOHqfzYSs15Nf5FYaNiKYEJ6q26f0aDHUpxS+A1rDISDpPYTnqH3 1CI/xaOJS/iNtCjqhg/CPy2pKWGHrn3osHq8/+qQj0uoLoBRw0nv+WsYxfHh X86swkFT5oAP95Qa3W3C3kM1svtdgA4f07Y6erX/jk21TFHrMPv22RRJS2Im FzpGG9zsbtHUfLVOyURX90YCF8/uj9DPEj1ChllH/DM7Yg8YC3UIYZY65ROU yPbVKKWqQNoNE/fkvkf7TJFIiJEWP7T0/Yl9fEmGFM5p5SwiUiokJKok4jns 8+wydvJ/wD9DtoNFj+D4XyUhVYRf9rDpeGV1oq5KEOi5yMdRuZtZHUYwCLfw KSCnvq7WwqCVyF5Yi0xU9iBvwK2UDudJ3wbm7RUrnTkHBFGWYi66MW/84uw7 QEGA2mf9or23wh1BWTZyvG+so80dHbcKpXhbh3OLaitISVYX5U7oyGu76PD7 4gCkZUw0CvJLYCeqRmuVWS2U7fgaS77aEwq7k9DOJuuds+n5kuyFr4kBW4Z2 favPi5I9c+FLDIcnloLEoq9ikm9RQZ6hESZIWf0olXZpw7pC61Ty58GTtVu1 Odmh5hLAmXxTaX9GRi/V//pXEJ/P4w6eofqrq6wE806drD82ysAFmmLTRRa5 +ULKW06UKG+Qs+WwUvENcnd3lZFZqYCRxaYR9mr/158OVSrREHkc96YKhah6 QzJgTNBFAUwjl5TW3GET55Kj/uuWfZtqcf3CM4HOBajBMaS/RIJx6TQzsqiv S64Z3rgdv33Fxw6DBh0sT0zlyOXNAzC3UDo4R7pGQ2anaxmGVp4hWyQYn6y1 T1ngbylXZXcwDgVEd3p+z7G4FN7zZNJmHzV7lkIcyqGyZYWgj/mqywgxfq+M jy+GyXk0ZKvpVY+dVQSyGmgIVveIhlRu+HbWcmbDyG7UYc/1BSdeOKS6xqad gPqjb381AOoQBVPITCSBP3TOexkNS+FSXX3mw56IRlcq14jTaHL43TwaDDN/ eWOHkw66769vF/YYyehgw5HowCrEYHj1izX5XbdkyUQdo2DCvjzOnYn5vm0L qUN801kn+cGBxTUZSVwpMvkWPT1Ux6nHSMUCBfDgbDdQt3SFOnOJRdZzhIqr xUY7G8cXdAljk41Si4G1hY7L4sd9GMFy1vzZ6dbD9c36eFUOGUTm6YV20onW bNADYSzh6Gg4g6Hzk1S3k1iUAqQUy+Z2O0HQ0+JG3Jq7HVp2OmNTlMUZbIry ELo99BOYiiscGp+1vvSQhmCRURCnIOOIEZBOhlYfbr+WckSUWqX0pHRkm+xV lmf1C/IBr9ZyT1p3ZPdEwJqTt6OLixQJjF0lbS5hxABz9yfFc+Cn0H7BZchj qQuRgyAjBolp3gZ4E3gdmH5XSnhS21qYFUU8to0laZV75htUgh2ur8K2VMjS ZuVDS9n2SFfRzXKmTt9LNv0pa+G8osVyUWCKsrocroNWZHsozxbf5RYZKV5y Z2JemGaon3NXHnjnWkRGidW7TUdEVATwC907MMfnmBoxMg9V18m9EWdDVv1C ANw1UtykA2BtsFEVx2PFOm/P0xuk+TXWJi7ecmaTC+0DHn+yOFSP7CWuyWoW DKmhPWVTNqrQx7i6Iqlt61eEW6butMI5mZCDJWOcoUC0rUg+uFdUdTNV4qRz KMpMLCEVkM8m0r39xfMRpZxl6+m5qlRtg066VFNQpgZaVFOpRg0TI5YVSUV0 4Ws/bnIeGXQrD4Yax9jib04WfLfnMN5FFy4vTBb06bO4z9lM7vM5uIYRjH82 U60/4ttaPqTRwVDdYoS3QVriVFHcNKD8KikCIrqV2048NRYd4zHqbebMb5FH RZNJigkC2Utnho1O0KHA/35vVhm3VvDErTiTOqQzW+JMqwGTDW+gw1lZZ3vH Dn6i/Ez6og+A6Tv72/RYFR7VBmDPr106L2UnQmGVnRz/xDnfisFc0D6qbaMe HZmtmHQHU78EpnHQj70iaF5+T4qvaZMuvVXs8knBSkWnhy+gqmXu4gCBGlQ+ KQ1WM4KbwA1SA1Y3ISy1YvScK63QIZFwiu+ZvxZ66GZTzHLq5scbOMr0mPe9 b9CUEbeYwjxZh2ZHGMrs4CxGGxFLs7xVSSosGyMDjfkwbvw4DrNj8bKTazj8 XDi70qx33qx9bGpT0DV49ikllQz3j38oE9CKUnp31caid+8aKkwUoU6BFW1g PLrZo+YRuv245fxXlx326xPpq0XAvOGrIf3jH6ZcSq4dZxdSOGpK/GnyX/mz U2TYyI/oRAsjpqDQ53F+FYvvo7e8EB9mZ31hnAFjzqXgPDOhI36nl5DJR8g4 3Y5DZcUqhC8eav0ayt6TyiJemKB6I5dglfpZKsp2HefTPssRhZdyIrIR6eDN XqXxOZvjczRXvWdZqVP1umAGEUaADaxlz/y9n/hV0j5iNXGDcXc47ZH9Mt4c AnfIr9lIjBRtYlvmdGqVzYZumJyfBAMFtdgCQYLTt5Ac6OImaScTXBWvsQPI iAQq+bm6xLt2TKE6/pTkI9lyzP4ZsMKf3p4B86PIBJ0dp6sfh24L2XTAIUlZ 4HUazRZjwkak6cVd2IAjudyFFkYwNNzbj47fPOcrKGfJQhgjLHlrAQJGUXSx At4Wi8GUYruFQBdiZsUNSGYs4hRD0uvR4Ml4ieeCrKrYehVNBQ1l1iOnDYCH oqwNJ86nBzbDZ/Wa5NzDEZKPBwMWb+zQ4C3Lk1TEDqcpYHwSEFGv8nDlmJIg s4qpxemE0NyfpsTZB+MPIrVYspW5neMwUraUa2qqVhaxN5hqhQzu2k2m2l5Q 6OnWU11jDazH7EJSV5v/nhYzStVanbF1sa33kl27MOQxB8RS10ahNZqPd1Xy D2O1T+L17+TEUh0woqpLFeFs9ioLVvnbu9wC7ua4rhfI19PY6CC0OXoqoTVn j0y6ZSmjFSBN7GjCh3teNYT2orWZ5kk63KW+0kQDbpwpPCCGYTC4Hc7J5d/a KM+yNMfBMYpaCqIQVDUlGy3xV6T8wGQz3EAJIH3vRDltjLe820lh81yfJFnI aEfZBbPaSiZLzqvbW617ZuP+9r3Wzn302JRrMVGBQaciVHlhVk2yeCHNaMy5 RpwdqDHPj05AVj57/afD484vR2c/c2gt89SwgH10SjaelqpR048UaXM1KWNV d5MIp7JhRhpYvicihSqJJKxBJdUDG6ZalbNcG1JF8nka9KXEBWlg06LvRV5M D7WnnA68H+FkmkITYT5UyQJ4uwRR3Ln3Si8RXL0HmhUIXXyeteejvEVThx5S QchoEZA55UxV0pg7vSdmxQAAzHq/0pLijVrfI+t61DLffNOBqaNYbOiJFPgQ ESn2zi84zwzdDvKpE9NcKzLHiMuh2YC9s0faLw5UxQpYewXkenZdMWLjBPi6 9u1gvB9VyyA4A/D2Ptd7UdXg+7v1cQJNEW7XvwtdqRYagIVQ7CwAK7llVTt4 3jISRLvCCb4NcvLm8A9xhGfQCzjD24JVDvEPAof49npb0jLHvXaO12b4BhnH H+ktf7/o5b71eFHX+Iqq4iZvvtBNnpzk7yF+4L8Pb+ohf+cTesmz0G9WzmGl 9QcXm5cr+q3zXEOGY19yGB10Z9P/MHOEzcngjbrVVfClhGuwpD+iaznzkf/6 98Bl+YP8kJgAOzDSjR3AMA34+vo8RrE5SH/dVyHYKQ4UbohrfRsjToLefARu vrYdhID2B0Yb97jvTnTlb1W+Z6oRVUGCWG5Lgu2qNUjn3c3uH7MKBfgi69AV rQ1Ncf8rh6Z4wOvjRoEoHvi1tb31FUJObD8mbvP45qvpS9dSY8H146v6DyuS bt5f/WQk18JSkvzzbbTXwNMkq1fkqtq7KFCd6TnfujFGdjH6zMb27oPWI8QJ R0CUJVUpHUpinA8RO0VFExtgsk64IJAsloKk0SqutFZxJUnurAXBsWhT6fRY aKhZ1ZKRsZDlhVmLJi0DI+UV/qHUB0ICBfNH3O3e224BWW7s3tttPUbkZWyD SLIv/tDmkRNYm45nsXT81F5ZZPHfOHZPkPrbrK02VwP+JedMMRGw1o4IuSXu ugQ4cKCrtm6tqoNtkF9VdJ7hMfkJr/DV9dV1gFf9HrsG3CgCIBcwIrom+TgQ CyyM8CaR/8yBIQKM0h6d0ijgHsDL06ib3zLqYJ6k2l0PdZDip41rnm+l0K4u I28vXK9JJidzI1b5/zNFsjTn9Nna+vlyfHUPDQ+GyosND4GwQHleHz7meX20 xfNqbXB52gqT2ippCGma/SSuySTmmBZLcGinuzDVC82xvR4JSwZ2wqXibm6P Q9NatMJ9YqCLfk7NamtVE2bxsbnKd3lfEZjNfeUQe0tMgCdqQVUspk8cSmsH +fkG/4EXZdPkYO0FHG7FZbpEnZJ4HMTXGBW5xYRCgU0Nu8aweD5F/fR7jBHe 9Gs26n2IUE+35vN3zJrJlRX8/5IP9azF6qrYiOmfZVN78JB2NfzzkLkQIZNP UezLp5GBTnwZsDm6rWc0W54eKJd0UjJWPYgRAx9QyGEBVviFTbcuZlaTLJ72 kvYAJfhBfwAbz2059nPDHG5ZZXV2uLTx6HBMD7d3W/dgCT7cBvl3267B+cNo kK2VjurA1oqie2hQ8GKm2n/8w9im8ZbjxdmvrJJgKCpLzSDrXNDaxSI/HT5/ fXLYOXqm8rlgTzAfdn49itL3ccqsXyID19fnr7WVsRc4xdxp3dWjZ9xHyuKj 6M40OIS+fPoYZS56v5u8JxKXZKFdmPCw0VAhRMO4oYM0tpbtpai6a6Jm1qlm wsDaldVQV3uOxBR9AAbNgacsANaEX2jzcQqOTeFGUIHWlPC3fZX7iXzAjI1m l4zI66/YLJl0oU4cQRWDRPj659PBkDiFQ6el+jy6EH1Ro+j5kWI8HMqWPism RFFWseRRWHU2JbnNTDWcNF33REmuwtKQjKjGyxMtQ40Mh6YnZU83GSY2BK9r EjdiUuBR0C+O9ZFOyaodB83xntG8GkOiEMiwsxojs0iSafLJE7lkliBTOLgS VbaKbThEqczKNahQ2QkUTnI4VFic0IBQqh5fDONFcUKVArx8DZxUomQxKdeX XxB5n1kKdqh7i2e6fDpmYxcyy/TsUYKi9ZKYIlLAgp3QhStaJRc9jfxNJ1uZ op0gWilobnwDHrz//Ozw5OYs2FdfkAO3XRIuAlOVyaw4ktVPq02dhORTkJGk YIAJ/dDQNduthGup5xPlWglBmbAhD9fi146+GRYsS0Y4WSMUpc+dSzTFIqCI rH575+zgjVkNkTb5xsALI6oQtIS5Ewb4UIUUR8/uaBUU9VL359XyN5LEQuPJ tayFNCTmK3f9umpJs5RaPQthffaJ3NqWQ80kFNw1pqO4cx4NcYg96N+n1Zbh TgIS9dDhcfaAoUBhmPTmiwZnCe+zsI2NRv2YKA/6rAHx8ifItNKceIh/8bPN 7UzJrCt7K+fwh/fvtba3QVh8+KC1s7O4sHjLOLOpw+O3r55UyvKV0le7Qvpq f2Xpq61j1hU7sNEoNh/G+lZi2/4F3YJezZLeCvuhl3iKt9D/Ounmnyk+/Dts y59vzdpaTKN6bcnSqjxU+rQ8sIiaQbzkV9H7mIx9BuOvqqFWcGcop4NSZb30 o92HeL7FP3S+fbZ/dnh6tv/qTadrnjzF2G2XMYb5hFPft2vuY5MW+KCP7LD1 7doVSO5d1D59u3Zy+OejU7LZgyL2AWABsFsb9hnxB89MF4VShSY9vFuGL+FI sXrv8TZpVu893uF+v3p9evby14OXh/vHeP14SlcM2bhN1sabl/xgVcr0dMvw yyjPU1sAf+fR+WaXH5MJGrvYJ0wFndkHWqaw2BH27wAqH8n3S/xJX1P3DQNw k2QHL0aDcZsg4DnNgat4wLptPJCl+RAeLvL2Ov3Biwb/C3XSUA8f2rRMNklx jLe0N6x64TN1U+8/AhV9uwarKv6YN013MlEP3e3gYb3dm45G1/7dt2uHfzk7 2e+82T89PTxtEjz/7uTsVBU5ef3iZP8VvIH22t00yTIPh+udvjk8gO9wdBgC 39zxn4d50r5KMVxqquvQndfOvfu0f8GPB0wqCN8a/idPnA9AF1o4eA3U86Lz M3br9NfTs8NX+LuLxI6mBB/iNHvifm3i+/agj4K4p+FbaMmAKxFh259d9+tS 03SwpOABQ/L9+fCE3h/++c3P8AjbIe98c6EuAolTQTdwoK/ewDKhAvsvX3bs 8/OX+y9O3cs3b+QZ8N9oPxOgTx34TtY07Weu4aeqE/iJa9nRPvUD54+kDX60 RXfUuw8fP2J1MDb84ozWcOdn4QdwYII/7m1TPbzcP8bZ4Q6rEiUSl4dL88Rk bdZx7JkfMZ0fmrd+842NFsbuCax7k8SIFAao/UEZyqA1HTy0fzKb9PY86r6f TrJ3m7c2XDx0Qh2wIbQfKKwx2wV+5fuh3z4xlnMDFn98AiOkXEY2bQgGG806 ecJhOB0+mq18NGlfDDY5166gmFS49Hd7l5SYNe3YHsRPWBvjbja/XaPnjl/X UAEV+5hf4Lc771p+Rpo878Uhg+gG8//2GOPFN+dCl4ChJSAb35jn6FDWkosq zu5kr04zdkn1eWDQb2yJVsOpU6Yu4b/2qeph+6jEQNtXmodin09j2BB6nAS6 mKoGO+7UvG481gdNYsKzceQ3AW+miOip5LlCyE/+mNGmwWiQeQiXEVpBsrED 6LkE526rzUfEnc5edd7wyj0jnjqaDvPBcHBO2xyT6Q5p2ncf7QLDppQFPII7 mwmsWfON6cUTjNk97g44H9KHgdzuxh8nw0F3kJs04G2d569POj+9PXr5DKYJ uTv9LrM6eR0wu0Y7Md/+aL79XpgDd8XxYEb+aDIYenfb6oYxThklxiIwGRq9 RkNzYEYRbHGhOS1drZGJt2vn1kahYUBEFfevnLtlN5qNr4K7jRttFBuzNgr8 aLv51PeYgb750wtoQOr5B1/zp7cv3p68xL7QD6plJxdNu8zPbMcfkJeN+ITJ dtFtkO893DqV41wX7c0RBIef5ugE52mUXqMWforreBO+8xyKlQISs/wkvFaL HNakQZbG4/u0NB5vb7MhgV/bLOMhUP9UBfdWgR+QzZit5l50taVEXedKoNjs JQAmljB14Boo0AUwNwow2Ww4gGnjVtbD3DDVSCx0OAA7axZUS9xjxC6KeySm j5McJhgfbUOi9IfNIKfOAZX+fLb/U4izUQ8ojSRP/zCjD8DjY7ZrvmwIp3x8 b4s29Mf3HzE5fLsGoJBUn9x56tq5U2D5zSduvR6eqP5E0zwZRXlU3CGeGC78 8uinU7Px1LSHI7LQEWJ3KwOpHnXVYttPFj+4dF49o10pTjdvtWfvRU+qabOa yoqU8kXAyoyzhgwLbFih7zJJ3mflTnhUn7w+OW0y5l7YbTI0+0Jm40hNElg9 foAr/t69bZu/isIKY1zs8RNymthUbxD2s3gY2yR/fj8OjJ+6KI+nI9Pu27Og fgFPG/QUbPcOMEChI2yGEQbJRi3ztdfb9hsdiv4/jR6qbemyAgA= --Multipart=_Tue__21_Sep_2010_21_31_51_+0200_l=7Nwv6JCGIhGwng--