# Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: squid3@treenet.co.nz-20080309114142-3ttiyvr5lfjt17gy # target_branch: file:///src/bzr/squid-repo/trunk/ # testament_sha1: 8241c7f85568354576cb424db4ba632bdae750d1 # timestamp: 2008-03-10 00:47:26 +1300 # message: Squid 3.1 .h Automated Testing # base_revision_id: cvs-1:amosjeffries-20080304190036-twb710i2jh8c2qqp # # Begin patch === modified file 'doc/rfc/1-index.txt' --- doc/rfc/1-index.txt 2007-11-13 06:46:55 +0000 +++ doc/rfc/1-index.txt 2008-03-09 10:31:52 +0000 @@ -53,6 +53,11 @@ rfc2187.txt Internet Cache Protocol (ICP), version 2 +rfc2181.txt + Clarifications to the DNS Specification + Squid uses a number of constants from the DNS and Host specifications + (RFC 1035, RFC 1123) this defines details on their correct usage. + rfc2227.txt Simple Hit-Metering and Usage-Limiting for HTTP === added file 'doc/rfc/rfc2181.txt' --- doc/rfc/rfc2181.txt 1970-01-01 00:00:00 +0000 +++ doc/rfc/rfc2181.txt 2008-03-09 10:31:52 +0000 @@ -0,0 +1,842 @@ + + + + + + +Network Working Group R. Elz +Request for Comments: 2181 University of Melbourne +Updates: 1034, 1035, 1123 R. Bush +Category: Standards Track RGnet, Inc. + July 1997 + + + Clarifications to the DNS Specification + +Status of this Memo + + This document specifies an Internet standards track protocol for the + Internet community, and requests discussion and suggestions for + improvements. Please refer to the current edition of the "Internet + Official Protocol Standards" (STD 1) for the standardization state + and status of this protocol. Distribution of this memo is unlimited. + +1. Abstract + + This document considers some areas that have been identified as + problems with the specification of the Domain Name System, and + proposes remedies for the defects identified. Eight separate issues + are considered: + + + IP packet header address usage from multi-homed servers, + + TTLs in sets of records with the same name, class, and type, + + correct handling of zone cuts, + + three minor issues concerning SOA records and their use, + + the precise definition of the Time to Live (TTL) + + Use of the TC (truncated) header bit + + the issue of what is an authoritative, or canonical, name, + + and the issue of what makes a valid DNS label. + + The first six of these are areas where the correct behaviour has been + somewhat unclear, we seek to rectify that. The other two are already + adequately specified, however the specifications seem to be sometimes + ignored. We seek to reinforce the existing specifications. + + + + + + + + + + + + + + +Elz & Bush Standards Track [Page 1] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + + + +Contents + + 1 Abstract ................................................... 1 + 2 Introduction ............................................... 2 + 3 Terminology ................................................ 3 + 4 Server Reply Source Address Selection ...................... 3 + 5 Resource Record Sets ....................................... 4 + 6 Zone Cuts .................................................. 8 + 7 SOA RRs .................................................... 10 + 8 Time to Live (TTL) ......................................... 10 + 9 The TC (truncated) header bit .............................. 11 + 10 Naming issues .............................................. 11 + 11 Name syntax ................................................ 13 + 12 Security Considerations .................................... 14 + 13 References ................................................. 14 + 14 Acknowledgements ........................................... 15 + 15 Authors' Addresses ......................................... 15 + + + + +2. Introduction + + Several problem areas in the Domain Name System specification + [RFC1034, RFC1035] have been noted through the years [RFC1123]. This + document addresses several additional problem areas. The issues here + are independent. Those issues are the question of which source + address a multi-homed DNS server should use when replying to a query, + the issue of differing TTLs for DNS records with the same label, + class and type, and the issue of canonical names, what they are, how + CNAME records relate, what names are legal in what parts of the DNS, + and what is the valid syntax of a DNS name. + + Clarifications to the DNS specification to avoid these problems are + made in this memo. A minor ambiguity in RFC1034 concerned with SOA + records is also corrected, as is one in the definition of the TTL + (Time To Live) and some possible confusion in use of the TC bit. + + + + + + + + + + + + +Elz & Bush Standards Track [Page 2] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + +3. Terminology + + This memo does not use the oft used expressions MUST, SHOULD, MAY, or + their negative forms. In some sections it may seem that a + specification is worded mildly, and hence some may infer that the + specification is optional. That is not correct. Anywhere that this + memo suggests that some action should be carried out, or must be + carried out, or that some behaviour is acceptable, or not, that is to + be considered as a fundamental aspect of this specification, + regardless of the specific words used. If some behaviour or action + is truly optional, that will be clearly specified by the text. + +4. Server Reply Source Address Selection + + Most, if not all, DNS clients, expect the address from which a reply + is received to be the same address as that to which the query + eliciting the reply was sent. This is true for servers acting as + clients for the purposes of recursive query resolution, as well as + simple resolver clients. The address, along with the identifier (ID) + in the reply is used for disambiguating replies, and filtering + spurious responses. This may, or may not, have been intended when + the DNS was designed, but is now a fact of life. + + Some multi-homed hosts running DNS servers generate a reply using a + source address that is not the same as the destination address from + the client's request packet. Such replies will be discarded by the + client because the source address of the reply does not match that of + a host to which the client sent the original request. That is, it + appears to be an unsolicited response. + +4.1. UDP Source Address Selection + + To avoid these problems, servers when responding to queries using UDP + must cause the reply to be sent with the source address field in the + IP header set to the address that was in the destination address + field of the IP header of the packet containing the query causing the + response. If this would cause the response to be sent from an IP + address that is not permitted for this purpose, then the response may + be sent from any legal IP address allocated to the server. That + address should be chosen to maximise the possibility that the client + will be able to use it for further queries. Servers configured in + such a way that not all their addresses are equally reachable from + all potential clients need take particular care when responding to + queries sent to anycast, multicast, or similar, addresses. + + + + + + + +Elz & Bush Standards Track [Page 3] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + +4.2. Port Number Selection + + Replies to all queries must be directed to the port from which they + were sent. When queries are received via TCP this is an inherent + part of the transport protocol. For queries received by UDP the + server must take note of the source port and use that as the + destination port in the response. Replies should always be sent from + the port to which they were directed. Except in extraordinary + circumstances, this will be the well known port assigned for DNS + queries [RFC1700]. + +5. Resource Record Sets + + Each DNS Resource Record (RR) has a label, class, type, and data. It + is meaningless for two records to ever have label, class, type and + data all equal - servers should suppress such duplicates if + encountered. It is however possible for most record types to exist + with the same label, class and type, but with different data. Such a + group of records is hereby defined to be a Resource Record Set + (RRSet). + +5.1. Sending RRs from an RRSet + + A query for a specific (or non-specific) label, class, and type, will + always return all records in the associated RRSet - whether that be + one or more RRs. The response must be marked as "truncated" if the + entire RRSet will not fit in the response. + +5.2. TTLs of RRs in an RRSet + + Resource Records also have a time to live (TTL). It is possible for + the RRs in an RRSet to have different TTLs. No uses for this have + been found that cannot be better accomplished in other ways. This + can, however, cause partial replies (not marked "truncated") from a + caching server, where the TTLs for some but not all the RRs in the + RRSet have expired. + + Consequently the use of differing TTLs in an RRSet is hereby + deprecated, the TTLs of all RRs in an RRSet must be the same. + + Should a client receive a response containing RRs from an RRSet with + differing TTLs, it should treat this as an error. If the RRSet + concerned is from a non-authoritative source for this data, the + client should simply ignore the RRSet, and if the values were + required, seek to acquire them from an authoritative source. Clients + that are configured to send all queries to one, or more, particular + servers should treat those servers as authoritative for this purpose. + Should an authoritative source send such a malformed RRSet, the + + + +Elz & Bush Standards Track [Page 4] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + + client should treat the RRs for all purposes as if all TTLs in the + RRSet had been set to the value of the lowest TTL in the RRSet. In + no case may a server send an RRSet with TTLs not all equal. + +5.3. DNSSEC Special Cases + + Two of the record types added by DNS Security (DNSSEC) [RFC2065] + require special attention when considering the formation of Resource + Record Sets. Those are the SIG and NXT records. It should be noted + that DNS Security is still very new, and there is, as yet, little + experience with it. Readers should be prepared for the information + related to DNSSEC contained in this document to become outdated as + the DNS Security specification matures. + +5.3.1. SIG records and RRSets + + A SIG record provides signature (validation) data for another RRSet + in the DNS. Where a zone has been signed, every RRSet in the zone + will have had a SIG record associated with it. The data type of the + RRSet is included in the data of the SIG RR, to indicate with which + particular RRSet this SIG record is associated. Were the rules above + applied, whenever a SIG record was included with a response to + validate that response, the SIG records for all other RRSets + associated with the appropriate node would also need to be included. + In some cases, this could be a very large number of records, not + helped by their being rather large RRs. + + Thus, it is specifically permitted for the authority section to + contain only those SIG RRs with the "type covered" field equal to the + type field of an answer being returned. However, where SIG records + are being returned in the answer section, in response to a query for + SIG records, or a query for all records associated with a name + (type=ANY) the entire SIG RRSet must be included, as for any other RR + type. + + Servers that receive responses containing SIG records in the + authority section, or (probably incorrectly) as additional data, must + understand that the entire RRSet has almost certainly not been + included. Thus, they must not cache that SIG record in a way that + would permit it to be returned should a query for SIG records be + received at that server. RFC2065 actually requires that SIG queries + be directed only to authoritative servers to avoid the problems that + could be caused here, and while servers exist that do not understand + the special properties of SIG records, this will remain necessary. + However, careful design of SIG record processing in new + implementations should permit this restriction to be relaxed in the + future, so resolvers do not need to treat SIG record queries + specially. + + + +Elz & Bush Standards Track [Page 5] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + + It has been occasionally stated that a received request for a SIG + record should be forwarded to an authoritative server, rather than + being answered from data in the cache. This is not necessary - a + server that has the knowledge of SIG as a special case for processing + this way would be better to correctly cache SIG records, taking into + account their characteristics. Then the server can determine when it + is safe to reply from the cache, and when the answer is not available + and the query must be forwarded. + +5.3.2. NXT RRs + + Next Resource Records (NXT) are even more peculiar. There will only + ever be one NXT record in a zone for a particular label, so + superficially, the RRSet problem is trivial. However, at a zone cut, + both the parent zone, and the child zone (superzone and subzone in + RFC2065 terminology) will have NXT records for the same name. Those + two NXT records do not form an RRSet, even where both zones are + housed at the same server. NXT RRSets always contain just a single + RR. Where both NXT records are visible, two RRSets exist. However, + servers are not required to treat this as a special case when + receiving NXT records in a response. They may elect to notice the + existence of two different NXT RRSets, and treat that as they would + two different RRSets of any other type. That is, cache one, and + ignore the other. Security aware servers will need to correctly + process the NXT record in the received response though. + +5.4. Receiving RRSets + + Servers must never merge RRs from a response with RRs in their cache + to form an RRSet. If a response contains data that would form an + RRSet with data in a server's cache the server must either ignore the + RRs in the response, or discard the entire RRSet currently in the + cache, as appropriate. Consequently the issue of TTLs varying + between the cache and a response does not cause concern, one will be + ignored. That is, one of the data sets is always incorrect if the + data from an answer differs from the data in the cache. The + challenge for the server is to determine which of the data sets is + correct, if one is, and retain that, while ignoring the other. Note + that if a server receives an answer containing an RRSet that is + identical to that in its cache, with the possible exception of the + TTL value, it may, optionally, update the TTL in its cache with the + TTL of the received answer. It should do this if the received answer + would be considered more authoritative (as discussed in the next + section) than the previously cached answer. + + + + + + + +Elz & Bush Standards Track [Page 6] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + +5.4.1. Ranking data + + When considering whether to accept an RRSet in a reply, or retain an + RRSet already in its cache instead, a server should consider the + relative likely trustworthiness of the various data. An + authoritative answer from a reply should replace cached data that had + been obtained from additional information in an earlier reply. + However additional information from a reply will be ignored if the + cache contains data from an authoritative answer or a zone file. + + The accuracy of data available is assumed from its source. + Trustworthiness shall be, in order from most to least: + + + Data from a primary zone file, other than glue data, + + Data from a zone transfer, other than glue, + + The authoritative data included in the answer section of an + authoritative reply. + + Data from the authority section of an authoritative answer, + + Glue from a primary zone, or glue from a zone transfer, + + Data from the answer section of a non-authoritative answer, and + non-authoritative data from the answer section of authoritative + answers, + + Additional information from an authoritative answer, + Data from the authority section of a non-authoritative answer, + Additional information from non-authoritative answers. + + Note that the answer section of an authoritative answer normally + contains only authoritative data. However when the name sought is an + alias (see section 10.1.1) only the record describing that alias is + necessarily authoritative. Clients should assume that other records + may have come from the server's cache. Where authoritative answers + are required, the client should query again, using the canonical name + associated with the alias. + + Unauthenticated RRs received and cached from the least trustworthy of + those groupings, that is data from the additional data section, and + data from the authority section of a non-authoritative answer, should + not be cached in such a way that they would ever be returned as + answers to a received query. They may be returned as additional + information where appropriate. Ignoring this would allow the + trustworthiness of relatively untrustworthy data to be increased + without cause or excuse. + + When DNS security [RFC2065] is in use, and an authenticated reply has + been received and verified, the data thus authenticated shall be + considered more trustworthy than unauthenticated data of the same + type. Note that throughout this document, "authoritative" means a + reply with the AA bit set. DNSSEC uses trusted chains of SIG and KEY + + + +Elz & Bush Standards Track [Page 7] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + + records to determine the authenticity of data, the AA bit is almost + irrelevant. However DNSSEC aware servers must still correctly set + the AA bit in responses to enable correct operation with servers that + are not security aware (almost all currently). + + Note that, glue excluded, it is impossible for data from two + correctly configured primary zone files, two correctly configured + secondary zones (data from zone transfers) or data from correctly + configured primary and secondary zones to ever conflict. Where glue + for the same name exists in multiple zones, and differs in value, the + nameserver should select data from a primary zone file in preference + to secondary, but otherwise may choose any single set of such data. + Choosing that which appears to come from a source nearer the + authoritative data source may make sense where that can be + determined. Choosing primary data over secondary allows the source + of incorrect glue data to be discovered more readily, when a problem + with such data exists. Where a server can detect from two zone files + that one or more are incorrectly configured, so as to create + conflicts, it should refuse to load the zones determined to be + erroneous, and issue suitable diagnostics. + + "Glue" above includes any record in a zone file that is not properly + part of that zone, including nameserver records of delegated sub- + zones (NS records), address records that accompany those NS records + (A, AAAA, etc), and any other stray data that might appear. + +5.5. Sending RRSets (reprise) + + A Resource Record Set should only be included once in any DNS reply. + It may occur in any of the Answer, Authority, or Additional + Information sections, as required. However it should not be repeated + in the same, or any other, section, except where explicitly required + by a specification. For example, an AXFR response requires the SOA + record (always an RRSet containing a single RR) be both the first and + last record of the reply. Where duplicates are required this way, + the TTL transmitted in each case must be the same. + +6. Zone Cuts + + The DNS tree is divided into "zones", which are collections of + domains that are treated as a unit for certain management purposes. + Zones are delimited by "zone cuts". Each zone cut separates a + "child" zone (below the cut) from a "parent" zone (above the cut). + The domain name that appears at the top of a zone (just below the cut + that separates the zone from its parent) is called the zone's + "origin". The name of the zone is the same as the name of the domain + at the zone's origin. Each zone comprises that subset of the DNS + tree that is at or below the zone's origin, and that is above the + + + +Elz & Bush Standards Track [Page 8] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + + cuts that separate the zone from its children (if any). The + existence of a zone cut is indicated in the parent zone by the + existence of NS records specifying the origin of the child zone. A + child zone does not contain any explicit reference to its parent. + +6.1. Zone authority + + The authoritative servers for a zone are enumerated in the NS records + for the origin of the zone, which, along with a Start of Authority + (SOA) record are the mandatory records in every zone. Such a server + is authoritative for all resource records in a zone that are not in + another zone. The NS records that indicate a zone cut are the + property of the child zone created, as are any other records for the + origin of that child zone, or any sub-domains of it. A server for a + zone should not return authoritative answers for queries related to + names in another zone, which includes the NS, and perhaps A, records + at a zone cut, unless it also happens to be a server for the other + zone. + + Other than the DNSSEC cases mentioned immediately below, servers + should ignore data other than NS records, and necessary A records to + locate the servers listed in the NS records, that may happen to be + configured in a zone at a zone cut. + +6.2. DNSSEC issues + + The DNS security mechanisms [RFC2065] complicate this somewhat, as + some of the new resource record types added are very unusual when + compared with other DNS RRs. In particular the NXT ("next") RR type + contains information about which names exist in a zone, and hence + which do not, and thus must necessarily relate to the zone in which + it exists. The same domain name may have different NXT records in + the parent zone and the child zone, and both are valid, and are not + an RRSet. See also section 5.3.2. + + Since NXT records are intended to be automatically generated, rather + than configured by DNS operators, servers may, but are not required + to, retain all differing NXT records they receive regardless of the + rules in section 5.4. + + For a secure parent zone to securely indicate that a subzone is + insecure, DNSSEC requires that a KEY RR indicating that the subzone + is insecure, and the parent zone's authenticating SIG RR(s) be + present in the parent zone, as they by definition cannot be in the + subzone. Where a subzone is secure, the KEY and SIG records will be + present, and authoritative, in that zone, but should also always be + present in the parent zone (if secure). + + + + +Elz & Bush Standards Track [Page 9] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + + Note that in none of these cases should a server for the parent zone, + not also being a server for the subzone, set the AA bit in any + response for a label at a zone cut. + +7. SOA RRs + + Three minor issues concerning the Start of Zone of Authority (SOA) + Resource Record need some clarification. + +7.1. Placement of SOA RRs in authoritative answers + + RFC1034, in section 3.7, indicates that the authority section of an + authoritative answer may contain the SOA record for the zone from + which the answer was obtained. When discussing negative caching, + RFC1034 section 4.3.4 refers to this technique but mentions the + additional section of the response. The former is correct, as is + implied by the example shown in section 6.2.5 of RFC1034. SOA + records, if added, are to be placed in the authority section. + +7.2. TTLs on SOA RRs + + It may be observed that in section 3.2.1 of RFC1035, which defines + the format of a Resource Record, that the definition of the TTL field + contains a throw away line which states that the TTL of an SOA record + should always be sent as zero to prevent caching. This is mentioned + nowhere else, and has not generally been implemented. + Implementations should not assume that SOA records will have a TTL of + zero, nor are they required to send SOA records with a TTL of zero. + +7.3. The SOA.MNAME field + + It is quite clear in the specifications, yet seems to have been + widely ignored, that the MNAME field of the SOA record should contain + the name of the primary (master) server for the zone identified by + the SOA. It should not contain the name of the zone itself. That + information would be useless, as to discover it, one needs to start + with the domain name of the SOA record - that is the name of the + zone. + +8. Time to Live (TTL) + + The definition of values appropriate to the TTL field in STD 13 is + not as clear as it could be, with respect to how many significant + bits exist, and whether the value is signed or unsigned. It is + hereby specified that a TTL value is an unsigned number, with a + minimum value of 0, and a maximum value of 2147483647. That is, a + maximum of 2^31 - 1. When transmitted, this value shall be encoded + in the less significant 31 bits of the 32 bit TTL field, with the + + + +Elz & Bush Standards Track [Page 10] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + + most significant, or sign, bit set to zero. + + Implementations should treat TTL values received with the most + significant bit set as if the entire value received was zero. + + Implementations are always free to place an upper bound on any TTL + received, and treat any larger values as if they were that upper + bound. The TTL specifies a maximum time to live, not a mandatory + time to live. + +9. The TC (truncated) header bit + + The TC bit should be set in responses only when an RRSet is required + as a part of the response, but could not be included in its entirety. + The TC bit should not be set merely because some extra information + could have been included, but there was insufficient room. This + includes the results of additional section processing. In such cases + the entire RRSet that will not fit in the response should be omitted, + and the reply sent as is, with the TC bit clear. If the recipient of + the reply needs the omitted data, it can construct a query for that + data and send that separately. + + Where TC is set, the partial RRSet that would not completely fit may + be left in the response. When a DNS client receives a reply with TC + set, it should ignore that response, and query again, using a + mechanism, such as a TCP connection, that will permit larger replies. + +10. Naming issues + + It has sometimes been inferred from some sections of the DNS + specification [RFC1034, RFC1035] that a host, or perhaps an interface + of a host, is permitted exactly one authoritative, or official, name, + called the canonical name. There is no such requirement in the DNS. + +10.1. CNAME resource records + + The DNS CNAME ("canonical name") record exists to provide the + canonical name associated with an alias name. There may be only one + such canonical name for any one alias. That name should generally be + a name that exists elsewhere in the DNS, though there are some rare + applications for aliases with the accompanying canonical name + undefined in the DNS. An alias name (label of a CNAME record) may, + if DNSSEC is in use, have SIG, NXT, and KEY RRs, but may have no + other data. That is, for any label in the DNS (any domain name) + exactly one of the following is true: + + + + + + +Elz & Bush Standards Track [Page 11] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + + + one CNAME record exists, optionally accompanied by SIG, NXT, and + KEY RRs, + + one or more records exist, none being CNAME records, + + the name exists, but has no associated RRs of any type, + + the name does not exist at all. + +10.1.1. CNAME terminology + + It has been traditional to refer to the label of a CNAME record as "a + CNAME". This is unfortunate, as "CNAME" is an abbreviation of + "canonical name", and the label of a CNAME record is most certainly + not a canonical name. It is, however, an entrenched usage. Care + must therefore be taken to be very clear whether the label, or the + value (the canonical name) of a CNAME resource record is intended. + In this document, the label of a CNAME resource record will always be + referred to as an alias. + +10.2. PTR records + + Confusion about canonical names has lead to a belief that a PTR + record should have exactly one RR in its RRSet. This is incorrect, + the relevant section of RFC1034 (section 3.6.2) indicates that the + value of a PTR record should be a canonical name. That is, it should + not be an alias. There is no implication in that section that only + one PTR record is permitted for a name. No such restriction should + be inferred. + + Note that while the value of a PTR record must not be an alias, there + is no requirement that the process of resolving a PTR record not + encounter any aliases. The label that is being looked up for a PTR + value might have a CNAME record. That is, it might be an alias. The + value of that CNAME RR, if not another alias, which it should not be, + will give the location where the PTR record is found. That record + gives the result of the PTR type lookup. This final result, the + value of the PTR RR, is the label which must not be an alias. + +10.3. MX and NS records + + The domain name used as the value of a NS resource record, or part of + the value of a MX resource record must not be an alias. Not only is + the specification clear on this point, but using an alias in either + of these positions neither works as well as might be hoped, nor well + fulfills the ambition that may have led to this approach. This + domain name must have as its value one or more address records. + Currently those will be A records, however in the future other record + types giving addressing information may be acceptable. It can also + have other RRs, but never a CNAME RR. + + + + +Elz & Bush Standards Track [Page 12] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + + Searching for either NS or MX records causes "additional section + processing" in which address records associated with the value of the + record sought are appended to the answer. This helps avoid needless + extra queries that are easily anticipated when the first was made. + + Additional section processing does not include CNAME records, let + alone the address records that may be associated with the canonical + name derived from the alias. Thus, if an alias is used as the value + of an NS or MX record, no address will be returned with the NS or MX + value. This can cause extra queries, and extra network burden, on + every query. It is trivial for the DNS administrator to avoid this + by resolving the alias and placing the canonical name directly in the + affected record just once when it is updated or installed. In some + particular hard cases the lack of the additional section address + records in the results of a NS lookup can cause the request to fail. + +11. Name syntax + + Occasionally it is assumed that the Domain Name System serves only + the purpose of mapping Internet host names to data, and mapping + Internet addresses to host names. This is not correct, the DNS is a + general (if somewhat limited) hierarchical database, and can store + almost any kind of data, for almost any purpose. + + The DNS itself places only one restriction on the particular labels + that can be used to identify resource records. That one restriction + relates to the length of the label and the full name. The length of + any one label is limited to between 1 and 63 octets. A full domain + name is limited to 255 octets (including the separators). The zero + length full name is defined as representing the root of the DNS tree, + and is typically written and displayed as ".". Those restrictions + aside, any binary string whatever can be used as the label of any + resource record. Similarly, any binary string can serve as the value + of any record that includes a domain name as some or all of its value + (SOA, NS, MX, PTR, CNAME, and any others that may be added). + Implementations of the DNS protocols must not place any restrictions + on the labels that can be used. In particular, DNS servers must not + refuse to serve a zone because it contains labels that might not be + acceptable to some DNS client programs. A DNS server may be + configurable to issue warnings when loading, or even to refuse to + load, a primary zone containing labels that might be considered + questionable, however this should not happen by default. + + Note however, that the various applications that make use of DNS data + can have restrictions imposed on what particular values are + acceptable in their environment. For example, that any binary label + can have an MX record does not imply that any binary name can be used + as the host part of an e-mail address. Clients of the DNS can impose + + + +Elz & Bush Standards Track [Page 13] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + + whatever restrictions are appropriate to their circumstances on the + values they use as keys for DNS lookup requests, and on the values + returned by the DNS. If the client has such restrictions, it is + solely responsible for validating the data from the DNS to ensure + that it conforms before it makes any use of that data. + + See also [RFC1123] section 6.1.3.5. + +12. Security Considerations + + This document does not consider security. + + In particular, nothing in section 4 is any way related to, or useful + for, any security related purposes. + + Section 5.4.1 is also not related to security. Security of DNS data + will be obtained by the Secure DNS [RFC2065], which is mostly + orthogonal to this memo. + + It is not believed that anything in this document adds to any + security issues that may exist with the DNS, nor does it do anything + to that will necessarily lessen them. Correct implementation of the + clarifications in this document might play some small part in + limiting the spread of non-malicious bad data in the DNS, but only + DNSSEC can help with deliberate attempts to subvert DNS data. + +13. References + + [RFC1034] Mockapetris, P., "Domain Names - Concepts and Facilities", + STD 13, RFC 1034, November 1987. + + [RFC1035] Mockapetris, P., "Domain Names - Implementation and + Specification", STD 13, RFC 1035, November 1987. + + [RFC1123] Braden, R., "Requirements for Internet Hosts - application + and support", STD 3, RFC 1123, January 1989. + + [RFC1700] Reynolds, J., Postel, J., "Assigned Numbers", + STD 2, RFC 1700, October 1994. + + [RFC2065] Eastlake, D., Kaufman, C., "Domain Name System Security + Extensions", RFC 2065, January 1997. + + + + + + + + + +Elz & Bush Standards Track [Page 14] + +RFC 2181 Clarifications to the DNS Specification July 1997 + + +14. Acknowledgements + + This memo arose from discussions in the DNSIND working group of the + IETF in 1995 and 1996, the members of that working group are largely + responsible for the ideas captured herein. Particular thanks to + Donald E. Eastlake, 3rd, and Olafur Gudmundsson, for help with the + DNSSEC issues in this document, and to John Gilmore for pointing out + where the clarifications were not necessarily clarifying. Bob Halley + suggested clarifying the placement of SOA records in authoritative + answers, and provided the references. Michael Patton, as usual, and + Mark Andrews, Alan Barrett and Stan Barber provided much assistance + with many details. Josh Littlefield helped make sure that the + clarifications didn't cause problems in some irritating corner cases. + +15. Authors' Addresses + + Robert Elz + Computer Science + University of Melbourne + Parkville, Victoria, 3052 + Australia. + + EMail: kre@munnari.OZ.AU + + + Randy Bush + RGnet, Inc. + 5147 Crystal Springs Drive NE + Bainbridge Island, Washington, 98110 + United States. + + EMail: randy@psg.com + + + + + + + + + + + + + + + + + + + +Elz & Bush Standards Track [Page 15] === modified file 'include/Array.h' --- include/Array.h 2007-11-26 20:09:54 +0000 +++ include/Array.h 2008-03-09 10:31:52 +0000 @@ -30,17 +30,22 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_ARRAY_H #define SQUID_ARRAY_H +/** + \todo CLEANUP: this file should be called Vector.h at least, and probably be replaced by STL Vector + */ + #include "fatal.h" #include "util.h" +/* users of this template also need assert() */ +#include "assert.h" + /* iterator support */ template - class VectorIteratorBase { @@ -72,7 +77,6 @@ }; template - class Vector { @@ -118,7 +122,7 @@ void * Vector::operator new(size_t size) { - return xmalloc (size); + return xmalloc(size); } template === modified file 'include/GNUregex.h' --- include/GNUregex.h 2003-08-04 04:53:47 +0000 +++ include/GNUregex.h 2008-03-09 10:31:52 +0000 @@ -1,10 +1,11 @@ /* * $Id: GNUregex.h,v 1.9 2003/08/03 22:53:47 hno Exp $ */ - #ifndef SQUID_REGEXP_LIBRARY_H #define SQUID_REGEXP_LIBRARY_H +#include "config.h" + /* Definitions for data structures and routines for the regular * expression library, version 0.12. * === modified file 'include/IPAddress.h' --- include/IPAddress.h 2008-02-06 05:39:42 +0000 +++ include/IPAddress.h 2008-03-09 10:31:52 +0000 @@ -35,10 +35,15 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef _INC_IPADDRESS_H #define _INC_IPADDRESS_H +#include "getaddrinfo.h" +#include "getnameinfo.h" +#include "inet_ntop.h" +#include "inet_pton.h" + + #if HAVE_SYS_SOCKET_H #include #endif @@ -56,14 +61,9 @@ #include #endif - #include #include -#include "getaddrinfo.h" -#include "getnameinfo.h" -#include "inet_ntop.h" -#include "inet_pton.h" /* FreeBSD hack: * This OS has at least one version that defines these as private @@ -402,6 +402,7 @@ #endif }; + inline std::ostream & operator << (std::ostream &os, const IPAddress &ipa) { === modified file 'include/List.h' --- include/List.h 2008-02-27 04:49:32 +0000 +++ include/List.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: List.h,v 1.8 2008/02/26 21:49:33 amosjeffries Exp $ * @@ -34,7 +33,8 @@ #ifndef SQUID_LIST_H #define SQUID_LIST_H -#include "cbdata.h" +/** \todo FUBAR: cbdata.h is over in src/ */ +#include "../src/cbdata.h" /// \ingroup POD template === modified file 'include/MemPool.h' --- include/MemPool.h 2008-02-27 04:49:32 +0000 +++ include/MemPool.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - #ifndef _MEM_POOLS_H_ #define _MEM_POOLS_H_ === modified file 'include/SquidNew.h' --- include/SquidNew.h 2003-07-08 04:44:28 +0000 +++ include/SquidNew.h 2008-03-09 10:31:52 +0000 @@ -30,10 +30,11 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_NEW_H #define SQUID_NEW_H +#include "util.h" + /* Any code using libstdc++ must have externally resolvable overloads * for void * operator new - which means in the .o for the binary, * or in a shared library. static libs don't propogate the symbol @@ -41,6 +42,7 @@ * for the extern version in squid */ #include + _SQUID_EXTERNNEW_ void *operator new(size_t size) throw (std::bad_alloc) { return xmalloc(size); @@ -57,4 +59,5 @@ { xfree (address); } + #endif /* SQUID_NEW_H */ === modified file 'include/asn1.h' --- include/asn1.h 2003-01-23 07:34:50 +0000 +++ include/asn1.h 2008-03-09 10:31:52 +0000 @@ -1,6 +1,8 @@ #ifndef SQUID_SNMP_ASN1_H #define SQUID_SNMP_ASN1_H +#include "config.h" + /* * Definitions for Abstract Syntax Notation One, ASN.1 * As defined in ISO/IS 8824 and ISO/IS 8825 @@ -33,7 +35,7 @@ **********************************************************************/ #ifndef EIGHTBIT_SUBIDS -typedef u_int oid; +typedef u_int8_t oid; #define MAX_SUBID 0xFFFFFFFF #else typedef u_char oid; === modified file 'include/assert.h' --- include/assert.h 2006-05-13 03:52:24 +0000 +++ include/assert.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: assert.h,v 1.3 2006/05/12 21:52:24 hno Exp $ * @@ -31,7 +30,6 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_ASSERT_H #define SQUID_ASSERT_H === modified file 'include/cache_snmp.h' --- include/cache_snmp.h 2007-12-15 06:11:41 +0000 +++ include/cache_snmp.h 2008-03-09 10:31:52 +0000 @@ -1,7 +1,6 @@ /* * $Id: cache_snmp.h,v 1.30 2007/12/14 23:11:44 amosjeffries Exp $ */ - #ifndef SQUID_CACHE_SNMP_H #define SQUID_CACHE_SNMP_H @@ -19,7 +18,9 @@ #include "snmp.h" #include "snmp_impl.h" +#if 0 #include "asn1.h" +#endif #include "snmp_api.h" #include "snmp_vars.h" === added file 'include/getfullhostname.h' --- include/getfullhostname.h 1970-01-01 00:00:00 +0000 +++ include/getfullhostname.h 2008-03-09 10:31:52 +0000 @@ -0,0 +1,11 @@ +/* + * $Id$ + */ +#ifndef _SQUID_GETFULLHOSTNAME_H +#define _SQUID_GETFULLHOSTNAME_H + +#include "config.h" + +SQUIDCEXTERN const char *getfullhostname(void); + +#endif /* _SQUID_GETFULLHOSTNAME_H */ === modified file 'include/hash.h' --- include/hash.h 2003-01-23 07:34:50 +0000 +++ include/hash.h 2008-03-09 10:31:52 +0000 @@ -1,10 +1,11 @@ /* * $Id: hash.h,v 1.8 2003/01/23 00:36:47 robertc Exp $ */ - #ifndef SQUID_HASH_H #define SQUID_HASH_H +#include "config.h" + typedef void HASHFREE(void *); typedef int HASHCMP(const void *, const void *); typedef unsigned int HASHHASH(const void *, unsigned int); === modified file 'include/heap.h' --- include/heap.h 2003-01-23 07:34:50 +0000 +++ include/heap.h 2008-03-09 10:31:52 +0000 @@ -40,10 +40,12 @@ * the top of the heap (as in the smallest object key value). Child nodes * are larger than their parent. ****************************************************************************/ - #ifndef SQUID_HEAP_H #define SQUID_HEAP_H +/* Squid autoconf definitions */ +#include "config.h" + /* * Function for generating heap keys. The first argument will typically be * a dws_md_p passed in as a void *. Should find a way to get type safety === modified file 'include/inet_ntop.h' --- include/inet_ntop.h 2007-12-14 12:03:25 +0000 +++ include/inet_ntop.h 2008-03-09 10:31:52 +0000 @@ -1,6 +1,8 @@ #ifndef _INC_INET_NTOP_H #define _INC_INET_NTOP_H +#include "config.h" + #if HAVE_INET_NTOP /* Use the system provided version where possible */ === modified file 'include/inet_pton.h' --- include/inet_pton.h 2007-12-14 12:03:25 +0000 +++ include/inet_pton.h 2008-03-09 10:31:52 +0000 @@ -1,6 +1,8 @@ #ifndef _INC_INET_PTON_H #define _INC_INET_PTON_H +#include "config.h" + #if HAVE_INET_PTON /* Use the system provided version where possible */ === modified file 'include/initgroups.h' --- include/initgroups.h 2004-11-07 05:09:19 +0000 +++ include/initgroups.h 2008-03-09 10:31:52 +0000 @@ -4,6 +4,8 @@ #ifndef SQUID_INITGROUPS_H #define SQUID_INITGROUPS_H +#include "config.h" + /* if you have configure you can use this */ #if defined(HAVE_CONFIG_H) #include "config.h" @@ -14,4 +16,5 @@ #endif SQUIDCEXTERN int initgroups(const char *user, gid_t group); + #endif /* SQUID_INITGROPS_H */ === modified file 'include/md5.h' --- include/md5.h 2007-11-30 11:34:12 +0000 +++ include/md5.h 2008-03-09 10:31:52 +0000 @@ -1,6 +1,8 @@ #ifndef SQUID_MD5_H #define SQUID_MD5_H +#include "config.h" + /* * This is the header file for the MD5 message-digest algorithm. * The algorithm is due to Ron Rivest. This code was === modified file 'include/memMeter.h' --- include/memMeter.h 2005-09-15 05:20:14 +0000 +++ include/memMeter.h 2008-03-09 10:31:52 +0000 @@ -1,7 +1,11 @@ - +/* + * $Id$ + */ #ifndef _MEM_METER_H_ #define _MEM_METER_H_ +#include "config.h" + /* object to track per-action memory usage (e.g. #idle objects) */ class MemMeter { public: === modified file 'include/parse.h' --- include/parse.h 2003-01-23 07:34:50 +0000 +++ include/parse.h 2008-03-09 10:31:52 +0000 @@ -1,7 +1,6 @@ /* * $Id: parse.h,v 1.12 2003/01/23 00:36:47 robertc Exp $ */ - #ifndef SQUID_PARSE_H #define SQUID_PARSE_H @@ -26,11 +25,12 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ -/* - * parse.h - */ - -/* + +/* NP: we only need struct variable_list and typedef oid from SNMP library */ +/* we use as ptrs. If this was true C++ we could pre-define their classes. */ +#include "snmp_vars.h" + +/** * A linked list of tag-value pairs for enumerated integers. */ struct enum_list { @@ -39,7 +39,7 @@ char *label; }; -/* +/** * A tree in the format of the tree structure of the MIB. */ struct snmp_mib_tree { @@ -63,7 +63,7 @@ #define TYPE_COUNTER 6 #define TYPE_GAUGE 7 #define TYPE_TIMETICKS 8 -#define TYPE_OPAQUE 9 +#define TYPE_OPAQUE 9 #define TYPE_NULL 10 #ifdef __cplusplus === modified file 'include/radix.h' --- include/radix.h 2003-10-20 18:33:01 +0000 +++ include/radix.h 2008-03-09 10:31:52 +0000 @@ -1,10 +1,11 @@ /* * $Id: radix.h,v 1.18 2003/10/20 12:33:03 robertc Exp $ */ - #ifndef SQUID_RADIX_H #define SQUID_RADIX_H +#include "config.h" + /* * Copyright (c) 1988, 1989, 1993 * The Regents of the University of California. All rights reserved. === modified file 'include/rfc1035.h' --- include/rfc1035.h 2008-01-11 10:49:18 +0000 +++ include/rfc1035.h 2008-03-09 10:31:52 +0000 @@ -30,11 +30,11 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_RFC1035_H #define SQUID_RFC1035_H #include "config.h" + #if HAVE_SYS_TYPES_H #include #endif @@ -45,8 +45,19 @@ #include #endif -/* rfc1035 - DNS */ -#define RFC1035_MAXHOSTNAMESZ 256 +#include "rfc2181.h" + +/** + \par RFC 1035 Section 3.1: + * To simplify implementations, the total length of a domain name (i.e., + * label octets and label length octets) is restricted to 255 octets or + * less. + *\par + * Clarified by RFC 2181 Section 11. (RFC2181_MAXHOSTNAMELEN) + */ +#define RFC1035_MAXHOSTNAMESZ RFC2181_MAXHOSTNAMELEN + + typedef struct _rfc1035_rr rfc1035_rr; struct _rfc1035_rr { char name[RFC1035_MAXHOSTNAMESZ]; @@ -56,12 +67,14 @@ unsigned short rdlength; char *rdata; }; + typedef struct _rfc1035_query rfc1035_query; struct _rfc1035_query { char name[RFC1035_MAXHOSTNAMESZ]; unsigned short qtype; unsigned short qclass; }; + typedef struct _rfc1035_message rfc1035_message; struct _rfc1035_message { unsigned short id; === added file 'include/rfc2181.h' --- include/rfc2181.h 1970-01-01 00:00:00 +0000 +++ include/rfc2181.h 2008-03-09 10:31:52 +0000 @@ -0,0 +1,27 @@ +/* + * $Id$ + */ +#ifndef _SQUID_INCLUDE_RFC1123_H +#define _SQUID_INCLUDE_RFC1123_H + +/** + \par RFC 2181 section 11: + * A full domain name is limited to 255 octets (including the separators). + * + \par RFC 1123 section 2.1: + * Host software MUST handle host names of up to 63 characters and + * SHOULD handle host names of up to 255 characters. + * + *\par + * Also Ref: RFC 1035 Section 3.1 (RFC1035_MAXHOSTNAMESZ) + * + \par + * Squid accepts up to 255 character Hostname and Fully-Qualified Domain Names. + * Squid still NULL-terminates its FQDN and hotsname strings. + */ +#define RFC2181_MAXHOSTNAMELEN 256 + + /// Back-port macro for old squid code still using SQUIDHOSTNAMELEN without RFC reference. +#define SQUIDHOSTNAMELEN RFC2181_MAXHOSTNAMELEN + +#endif /* _SQUID_INCLUDE_RFC1123_H */ === modified file 'include/rfc2617.h' --- include/rfc2617.h 2003-01-23 07:34:50 +0000 +++ include/rfc2617.h 2008-03-09 10:31:52 +0000 @@ -46,10 +46,11 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_RFC2617_H #define SQUID_RFC2617_H +#include "config.h" + #define HASHLEN 16 typedef char HASH[HASHLEN]; #define HASHHEXLEN 32 === modified file 'include/snmp.h' --- include/snmp.h 2003-01-23 07:34:50 +0000 +++ include/snmp.h 2008-03-09 10:31:52 +0000 @@ -39,7 +39,9 @@ #endif /* These come first */ +#if 0 #include "asn1.h" +#endif #include "snmp_error.h" #if 0 #include "mibii.h" === modified file 'include/snmp_api_util.h' --- include/snmp_api_util.h 2003-01-23 07:34:50 +0000 +++ include/snmp_api_util.h 2008-03-09 10:31:52 +0000 @@ -1,10 +1,12 @@ /* * $Id: snmp_api_util.h,v 1.5 2003/01/23 00:36:47 robertc Exp $ */ - #ifndef SQUID_SNMP_API_UTIL_H #define SQUID_SNMP_API_UTIL_H +/* NP: required for typedef ipaddr and indirect config.h */ +#include "snmp_pdu.h" + /*********************************************************** Copyright 1997 by Carnegie Mellon University === modified file 'include/snmp_debug.h' --- include/snmp_debug.h 2003-01-23 07:34:50 +0000 +++ include/snmp_debug.h 2008-03-09 10:31:52 +0000 @@ -1,23 +1,15 @@ /* * $Id: snmp_debug.h,v 1.13 2003/01/23 00:36:47 robertc Exp $ */ - #ifndef SQUID_SNMP_DEBUG_H #define SQUID_SNMP_DEBUG_H -#ifdef __cplusplus -extern "C" { -#endif +#include "config.h" #if STDC_HEADERS -extern void -snmplib_debug(int, const char *,...) PRINTF_FORMAT_ARG2; +SQUIDCEXTERN void snmplib_debug(int, const char *,...) PRINTF_FORMAT_ARG2; #else -extern void snmplib_debug (va_alist); -#endif - -#ifdef __cplusplus -}; +SQUIDCEXTERN void snmplib_debug(va_alist); #endif #endif /* SQUID_SNMP_DEBUG_H */ === modified file 'include/snmp_impl.h' --- include/snmp_impl.h 2003-01-23 07:34:50 +0000 +++ include/snmp_impl.h 2008-03-09 10:31:52 +0000 @@ -1,10 +1,11 @@ /* * $Id: snmp_impl.h,v 1.15 2003/01/23 00:36:48 robertc Exp $ */ - #ifndef SQUID_SNMP_IMPL_H #define SQUID_SNMP_IMPL_H +#include "asn1.h" + /* * Definitions for SNMP (RFC 1067) implementation. * @@ -46,6 +47,8 @@ #define SID_MAX_LEN 64 +#if 0 /* defines performed globally by config.h */ + #ifndef NULL #define NULL 0 #endif @@ -56,6 +59,7 @@ #ifndef FALSE #define FALSE 0 #endif +#endif /* dead code. */ #define READ 1 #define WRITE 0 === modified file 'include/snmp_msg.h' --- include/snmp_msg.h 2003-01-23 07:34:50 +0000 +++ include/snmp_msg.h 2008-03-09 10:31:52 +0000 @@ -2,6 +2,8 @@ #ifndef SQUID_SNMP_MSG_H #define SQUID_SNMP_MSG_H +#include "config.h" + /********************************************************************** * * Copyright 1997 by Carnegie Mellon University @@ -37,10 +39,8 @@ extern "C" { #endif - u_char *snmp_msg_Encode(u_char *, int *, u_char *, - int, int, struct snmp_pdu *); - u_char *snmp_msg_Decode(u_char *, int *, u_char *, - int *, int *, struct snmp_pdu *); +u_char *snmp_msg_Encode(u_char *, int *, u_char *, int, int, struct snmp_pdu *); +u_char *snmp_msg_Decode(u_char *, int *, u_char *, int *, int *, struct snmp_pdu *); #ifdef __cplusplus } === modified file 'include/snmp_pdu.h' --- include/snmp_pdu.h 2003-01-23 07:34:50 +0000 +++ include/snmp_pdu.h 2008-03-09 10:31:52 +0000 @@ -1,6 +1,15 @@ #ifndef SQUID_SNMP_PDU_H #define SQUID_SNMP_PDU_H +#include "config.h" +/* required for oid typedef */ +#include "asn1.h" + +#if HAVE_NETINET_IN_H +/* required for sockaddr_in definition */ +#include +#endif + /********************************************************************** * * Copyright 1997 by Carnegie Mellon University === modified file 'include/snmp_session.h' --- include/snmp_session.h 2003-01-23 07:34:50 +0000 +++ include/snmp_session.h 2008-03-09 10:31:52 +0000 @@ -2,6 +2,8 @@ #ifndef SQUID_SNMP_SESSION_H #define SQUID_SNMP_SESSION_H +#include "config.h" + /********************************************************************** * * Copyright 1997 by Carnegie Mellon University @@ -31,7 +33,6 @@ struct snmp_session { int Version; /* SNMP Version for this session */ - u_char *community; /* community for outgoing requests. */ int community_len; /* Length of community name. */ int retries; /* Number of retries before timeout. */ === modified file 'include/snmp_util.h' --- include/snmp_util.h 2003-01-23 07:34:50 +0000 +++ include/snmp_util.h 2008-03-09 10:31:52 +0000 @@ -1,10 +1,11 @@ /* * $Id: snmp_util.h,v 1.10 2003/01/23 00:36:48 robertc Exp $ */ - #ifndef SQUID_SNMP_UTIL_H #define SQUID_SNMP_UTIL_H +#include "config.h" + #ifdef __cplusplus extern "C" { #endif === modified file 'include/snmp_vars.h' --- include/snmp_vars.h 2007-12-15 06:11:41 +0000 +++ include/snmp_vars.h 2008-03-09 10:31:52 +0000 @@ -29,6 +29,8 @@ * **********************************************************************/ +#include "asn1.h" + #ifdef __cplusplus extern "C" { #endif === modified file 'include/squid_mswin.h' --- include/squid_mswin.h 2008-02-27 04:49:32 +0000 +++ include/squid_mswin.h 2008-03-09 10:31:52 +0000 @@ -31,6 +31,12 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ +#ifndef _INC_SQUID_MSWIN_H +#define _INC_SQUID_MSWIN_H + +#include "config.h" + +#ifdef _SQUID_WIN32_ #define ACL WindowsACL #if defined(_MSC_VER) /* Microsoft C Compiler ONLY */ @@ -738,3 +744,8 @@ }; #undef ACL + + +#endif /* _SQUID_WIN32_ */ + +#endif /* _INC_SQUID_MSWIN_H */ === modified file 'include/squid_windows.h' --- include/squid_windows.h 2006-09-09 21:29:59 +0000 +++ include/squid_windows.h 2008-03-09 10:31:52 +0000 @@ -30,6 +30,12 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ +#ifndef _INC_SQUID_WINDOWS_H +#define _INC_SQUID_WINDOWS_H + +#include "config.h" + +#ifdef _SQUID_WIN32_ #ifndef ACL #define ACL WindowsACL @@ -40,3 +46,7 @@ #undef ACL #undef _MSWIN_ACL_WAS_NOT_DEFINED #endif + +#endif /* _SQUID_WIN32_ */ + +#endif /* _INC_SQUID_WINDOWS_H */ === modified file 'include/sspwin32.h' --- include/sspwin32.h 2006-09-09 21:29:59 +0000 +++ include/sspwin32.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: sspwin32.h,v 1.2 2006/09/09 15:29:59 serassio Exp $ * @@ -32,9 +31,11 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef _LIBSSPWIN32_H_ #define _LIBSSPWIN32_H_ + +#ifdef _SQUID_WIN32_ + #define SECURITY_WIN32 #define NTLM_PACKAGE_NAME "NTLM" #define NEGOTIATE_PACKAGE_NAME "Negotiate" @@ -74,4 +75,7 @@ extern BOOL Use_Unicode; extern BOOL NTLM_LocalCall; + +#endif /* _SQUID_WIN32_ */ + #endif /* LIBSSPWIN32_H_ */ === modified file 'include/strsep.h' --- include/strsep.h 2006-07-06 01:49:54 +0000 +++ include/strsep.h 2008-03-09 10:31:52 +0000 @@ -16,38 +16,43 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * USA. */ - #ifndef GNULIB_STRSEP_H_ #define GNULIB_STRSEP_H_ +#include "config.h" + #if HAVE_STRSEP /* * Get strsep() declaration. */ +#if HAVE_STRING_H #include +#endif #else -/* Searches the next delimiter (char listed in DELIM) starting at *STRINGP. - If one is found, it is overwritten with a NUL, and *STRINGP is advanced +/** +\par + Searches the next delimiter (char listed in DELIM) starting at *STRINGP. + If one is found, it is overwritten with a NULL, and *STRINGP is advanced to point to the next char after it. Otherwise, *STRINGP is set to NULL. If *STRINGP was already NULL, nothing happens. Returns the old value of *STRINGP. - +\par This is a variant of strtok() that is multithread-safe and supports empty fields. - Caveat: It modifies the original string. - Caveat: These functions cannot be used on constant strings. - Caveat: The identity of the delimiting character is lost. - Caveat: It doesn't work with multibyte strings unless all of the delimiter - characters are ASCII characters < 0x30. - - See also strtok_r(). */ - -SQUIDCEXTERN char *strsep (char **stringp, const char *delim); - -#endif +\note Caveat: It modifies the original string. +\note Caveat: These functions cannot be used on constant strings. +\note Caveat: The identity of the delimiting character is lost. +\note Caveat: It doesn't work with multibyte strings unless all of the delimiter + characters are ASCII characters < 0x30. + + See also strtok_r(). + */ +SQUIDCEXTERN char *strsep(char **stringp, const char *delim); + +#endif /* HAVE_STRSEP */ #endif /* GNULIB_STRSEP_H_ */ === modified file 'include/strtoll.h' --- include/strtoll.h 2007-08-18 00:56:24 +0000 +++ include/strtoll.h 2008-03-09 10:31:52 +0000 @@ -1,19 +1,31 @@ +/* + * $Id$ + */ +#ifndef _SQUIDINC_STRTOLL_H +#define _SQUIDINC_STRTOLL_H + +#include "config.h" + #if HAVE_STRTOLL /* * Get strtoll() declaration. */ +#if HAVE_STDLIB_H #include +#endif #else -/* +/** + \par * Convert a string to a int64 integer. - * + \par * Ignores `locale' stuff. Assumes that the upper and lower case * alphabets and digits are each contiguous. */ - -SQUIDCEXTERN int64_t strtoll (const char *nptr, char **endptr, int base); - -#endif +SQUIDCEXTERN int64_t strtoll(const char *nptr, char **endptr, int base); + +#endif /* !HAVE_STRTOLL */ + +#endif /* _SQUIDINC_STRTOLL_H */ === modified file 'include/util.h' --- include/util.h 2007-12-15 06:11:41 +0000 +++ include/util.h 2008-03-09 10:31:52 +0000 @@ -49,15 +49,10 @@ #include #endif -#if !defined(SQUIDHOSTNAMELEN) -#define SQUIDHOSTNAMELEN 256 -#endif - #if defined(_SQUID_FREEBSD_) #define _etext etext #endif -SQUIDCEXTERN const char *getfullhostname(void); SQUIDCEXTERN const char *mkhttpdlogtime(const time_t *); SQUIDCEXTERN const char *mkrfc1123(time_t); SQUIDCEXTERN char *uudecode(const char *); === modified file 'include/xusleep.h' --- include/xusleep.h 2007-04-24 12:30:36 +0000 +++ include/xusleep.h 2008-03-09 10:31:52 +0000 @@ -1,1 +1,11 @@ +/* + * $Id$ + */ +#ifndef _INC_XUSLEEP_H +#define _INC_XUSLEEP_H + +#include "config.h" + SQUIDCEXTERN int xusleep(unsigned int); + +#endif /* _INC_XUSLEEP_H */ === modified file 'lib/Makefile.am' --- lib/Makefile.am 2007-12-15 06:11:41 +0000 +++ lib/Makefile.am 2008-03-09 10:31:52 +0000 @@ -96,7 +96,14 @@ ##FIXME - set these in configure.in and reuse TESTS=$(check_PROGRAMS) -check_PROGRAMS=tests/testAll +check_PROGRAMS= \ + testHeaders \ + tests/testAll + +## Special Universal .h dependency test script +## aborts if error encountered +testHeaders: $(top_srcdir)/include/*.h + $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "$(top_srcdir)/include" || exit 1 tests_testAll_SOURCES= \ tests/testArray.h \ @@ -114,3 +121,4 @@ tests_testAll_LDADD= @SQUID_CPPUNIT_LA@ @SQUID_CPPUNIT_LIBS@ tests_testAll_LDFLAGS = $(LIBADD_DL) + === modified file 'lib/getfullhostname.c' --- lib/getfullhostname.c 2003-01-23 07:34:50 +0000 +++ lib/getfullhostname.c 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: getfullhostname.c,v 1.20 2003/01/23 00:37:01 robertc Exp $ * @@ -32,9 +31,9 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - -#include "config.h" - +#include "getfullhostname.h" + +#if 0 /* we SHOULD NOT need ALL these here. */ #if HAVE_LIBC_H #include #endif @@ -62,30 +61,43 @@ #if HAVE_ARPA_INET_H #include #endif + +#endif // 0 + + +#if HAVE_UNISTD_H +/* for gethostname() function */ +#include +#endif #if HAVE_NETDB_H && !defined(_SQUID_NETDB_H_) /* protect on NEXTSTEP */ #define _SQUID_NETDB_H_ +/* for gethostbyname() */ #include #endif -#if HAVE_UNISTD_H -#include -#endif - + +/* for RFC 2181 constants */ +#include "rfc2181.h" + +/* for xstrncpy() - may need breakign out of there. */ #include "util.h" -/* - * getfullhostname() - Returns the fully qualified name of the current - * host, or NULL on error. Pointer is only valid until the next call - * to the gethost*() functions. +/** + \retval NULL An error occured. + \retval * The fully qualified name (FQDN) of the current host. + * Pointer is only valid until the next call to the gethost*() functions. + * + \todo Make this a squid String result so the duration limit is flexible. */ const char * getfullhostname(void) { const struct hostent *hp = NULL; - static char buf[SQUIDHOSTNAMELEN + 1]; + static char buf[RFC2181_MAXHOSTNAMELEN + 1]; - if (gethostname(buf, SQUIDHOSTNAMELEN) < 0) + if (gethostname(buf, RFC2181_MAXHOSTNAMELEN) < 0) return NULL; + /** \todo convert this to a xgetaddrinfo() call */ if ((hp = gethostbyname(buf)) != NULL) - xstrncpy(buf, hp->h_name, SQUIDHOSTNAMELEN); + xstrncpy(buf, hp->h_name, RFC2181_MAXHOSTNAMELEN); return buf; } === modified file 'src/ACL.h' --- src/ACL.h 2008-02-27 04:49:32 +0000 +++ src/ACL.h 2008-03-09 10:31:52 +0000 @@ -64,10 +64,10 @@ SQUIDCEXTERN err_type aclGetDenyInfoPage(acl_deny_info_list ** head, const char *name, int redirect_allowed); /// \ingroup ACLAPI -SQUIDCEXTERN void aclParseDenyInfoLine(struct _acl_deny_info_list **); +SQUIDCEXTERN void aclParseDenyInfoLine(struct acl_deny_info_list **); /// \ingroup ACLAPI -SQUIDCEXTERN void aclDestroyDenyInfoList(struct _acl_deny_info_list **); +SQUIDCEXTERN void aclDestroyDenyInfoList(struct acl_deny_info_list **); /// \ingroup ACLAPI SQUIDCEXTERN wordlist *aclDumpGeneric(const ACL *); /// \ingroup ACLAPI === modified file 'src/ACLData.h' --- src/ACLData.h 2008-02-27 04:49:32 +0000 +++ src/ACLData.h 2008-03-09 10:31:52 +0000 @@ -31,10 +31,11 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_ACLDATA_H #define SQUID_ACLDATA_H +class wordlist; + /// \ingroup ACLAPI template class ACLData === modified file 'src/ACLHTTPHeaderData.h' --- src/ACLHTTPHeaderData.h 2008-02-27 04:49:32 +0000 +++ src/ACLHTTPHeaderData.h 2008-03-09 10:31:52 +0000 @@ -31,11 +31,20 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_ACLHTTPHEADERDATA_H #define SQUID_ACLHTTPHEADERDATA_H +class HttpHeader; +class wordlist; + +/* becaue we inherit from it */ #include "ACLData.h" +/* for String field */ +#include "SquidString.h" +/* for http_hdr_type field */ +#include "HttpHeader.h" +/* because weuse its MEMPROXY_CLASS() macros */ +#include "MemPool.h" /// \ingroup ACLAPI class ACLHTTPHeaderData : public ACLData @@ -53,11 +62,11 @@ virtual ACLData *clone() const; private: - http_hdr_type hdrId; // set if header is known - String hdrName; // always set + http_hdr_type hdrId; /**< set if header is known */ + String hdrName; /**< always set */ ACLData * regex_rule; }; -MEMPROXY_CLASS_INLINE(ACLHTTPHeaderData) /**DOCS_NOSEMI*/ +MEMPROXY_CLASS_INLINE(ACLHTTPHeaderData); #endif /* SQUID_ACLHTTPHEADERDATA_H */ === modified file 'src/ACLIP.h' --- src/ACLIP.h 2008-02-27 04:49:32 +0000 +++ src/ACLIP.h 2008-03-09 10:31:52 +0000 @@ -57,16 +57,16 @@ IPAddress addr2; - IPAddress mask; /* This should perhapse be stored as a CIDR range now instead of a full IP mask. */ + IPAddress mask; /**< \todo This should perhapse be stored as a CIDR range now instead of a full IP mask. */ - acl_ip_data *next; /* used for parsing, not for storing */ + acl_ip_data *next; /**< used for parsing, not for storing */ private: static bool DecodeMask(const char *asc, IPAddress &mask, int string_format_type); }; -MEMPROXY_CLASS_INLINE(acl_ip_data) /**DOCS_NOSEMI*/ +MEMPROXY_CLASS_INLINE(acl_ip_data); /// \ingroup ACLAPI class ACLIP : public ACL === modified file 'src/ACLIdent.h' --- src/ACLIdent.h 2008-02-27 04:49:32 +0000 +++ src/ACLIdent.h 2008-03-09 10:31:52 +0000 @@ -35,9 +35,7 @@ #ifndef SQUID_ACLIDENT_H #define SQUID_ACLIDENT_H -#include "ACL.h" #include "ACLChecklist.h" -#include "ACLData.h" /// \ingroup ACLAPI class IdentLookup : public ACLChecklist::AsyncState @@ -52,6 +50,10 @@ static void LookupDone(const char *ident, void *data); }; + +#include "ACL.h" +#include "ACLData.h" + /// \ingroup ACLAPI class ACLIdent : public ACL { @@ -82,6 +84,6 @@ char const *type_; }; -MEMPROXY_CLASS_INLINE(ACLIdent) /**DOCS_NOSEMI*/ +MEMPROXY_CLASS_INLINE(ACLIdent); #endif /* SQUID_ACLIDENT_H */ === modified file 'src/ACLRegexData.h' --- src/ACLRegexData.h 2008-02-27 04:49:32 +0000 +++ src/ACLRegexData.h 2008-03-09 10:31:52 +0000 @@ -31,10 +31,14 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_ACLREGEXDATA_H #define SQUID_ACLREGEXDATA_H + #include "ACLData.h" +#include "MemPool.h" + +/** \todo CLEANUP: break out relist, we don't need the rest. */ +#include "structs.h" class ACLRegexData : public ACLData { @@ -53,6 +57,6 @@ relist *data; }; -MEMPROXY_CLASS_INLINE(ACLRegexData) /**DOCS_NOSEMI*/ +MEMPROXY_CLASS_INLINE(ACLRegexData); #endif /* SQUID_ACLREGEXDATA_H */ === modified file 'src/ACLReplyHeaderStrategy.h' --- src/ACLReplyHeaderStrategy.h 2006-05-07 04:13:18 +0000 +++ src/ACLReplyHeaderStrategy.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: ACLReplyHeaderStrategy.h,v 1.9 2006/05/06 22:13:18 wessels Exp $ * @@ -32,9 +31,11 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_ACLREPLYHEADERSTRATEGY_H #define SQUID_ACLREPLYHEADERSTRATEGY_H + +class ACLChecklist; + #include "ACL.h" #include "ACLData.h" #include "ACLStrategy.h" @@ -42,7 +43,6 @@ #include "HttpReply.h" template - class ACLReplyHeaderStrategy : public ACLStrategy { === modified file 'src/ACLReplyMIMEType.h' --- src/ACLReplyMIMEType.h 2006-05-07 04:13:18 +0000 +++ src/ACLReplyMIMEType.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: ACLReplyMIMEType.h,v 1.8 2006/05/06 22:13:18 wessels Exp $ * @@ -32,15 +31,11 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_ACLREPLYMIMETYPE_H #define SQUID_ACLREPLYMIMETYPE_H + #include "ACL.h" -#include "ACLData.h" -#include "ACLReplyHeaderStrategy.h" #include "ACLStrategised.h" -#include "ACLChecklist.h" -#include "HttpReply.h" class ACLReplyMIMEType { @@ -52,9 +47,13 @@ /* partial specialisation */ +#include "ACLData.h" +#include "ACLReplyHeaderStrategy.h" +#include "ACLChecklist.h" + template <> -int -ACLReplyHeaderStrategy::match (ACLData * &data, ACLChecklist *checklist) +inline int +ACLReplyHeaderStrategy::match(ACLData * &data, ACLChecklist *checklist) { char const *theHeader = checklist->reply->header.getStr(HDR_CONTENT_TYPE); === modified file 'src/ACLRequestMIMEType.h' --- src/ACLRequestMIMEType.h 2006-05-07 04:13:18 +0000 +++ src/ACLRequestMIMEType.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: ACLRequestMIMEType.h,v 1.4 2006/05/06 22:13:18 wessels Exp $ * @@ -32,14 +31,11 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_ACLREQUESTMIMETYPE_H #define SQUID_ACLREQUESTMIMETYPE_H + #include "ACL.h" -#include "ACLData.h" -#include "ACLRequestHeaderStrategy.h" #include "ACLStrategised.h" -#include "ACLChecklist.h" class ACLRequestMIMEType { @@ -51,8 +47,12 @@ /* partial specialisation */ +#include "ACLData.h" +#include "ACLRequestHeaderStrategy.h" +#include "ACLChecklist.h" + template <> -int +inline int ACLRequestHeaderStrategy::match (ACLData * &data, ACLChecklist *checklist) { char const *theHeader = checklist->request->header.getStr(HDR_CONTENT_TYPE); === modified file 'src/ACLSourceASN.h' --- src/ACLSourceASN.h 2007-12-15 06:11:41 +0000 +++ src/ACLSourceASN.h 2008-03-09 10:31:52 +0000 @@ -32,10 +32,15 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_ACLSOURCEASN_H #define SQUID_ACLSOURCEASN_H + +#if 0 #include "ACLASN.h" +#endif + +class ACLChecklist; + #include "ACLStrategy.h" #include "IPAddress.h" === modified file 'src/AccessLogEntry.h' --- src/AccessLogEntry.h 2008-02-26 07:15:48 +0000 +++ src/AccessLogEntry.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: AccessLogEntry.h,v 1.9 2008/02/26 00:15:48 rousskov Exp $ * @@ -31,7 +30,6 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_HTTPACCESSLOGENTRY_H #define SQUID_HTTPACCESSLOGENTRY_H @@ -39,10 +37,12 @@ #include "HttpRequestMethod.h" #include "HierarchyLogEntry.h" #include "IPAddress.h" +#include "HttpRequestMethod.h" /* forward decls */ - class CacheManager; +class HttpReply; +class HttpRequest; class AccessLogEntry { @@ -127,6 +127,8 @@ headers; + // Why is this a sub-class and not a set of real "private:" fields? + // It looks like its duplicating HTTPRequestMethod anyway! class Private { @@ -142,6 +144,10 @@ HttpRequest *request; }; +class ACLChecklist; +class StoreEntry; +class logformat_token; + /* Should be in 'AccessLog.h' as the driver */ extern void accessLogLog(AccessLogEntry *, ACLChecklist * checklist); extern void accessLogRotate(void); === modified file 'src/AuthConfig.h' --- src/AuthConfig.h 2008-02-27 04:49:32 +0000 +++ src/AuthConfig.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: AuthConfig.h,v 1.5 2008/02/26 21:49:34 amosjeffries Exp $ * @@ -30,24 +29,30 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_AUTHCONFIG_H #define SQUID_AUTHCONFIG_H -/* +class AuthUserRequest; +class StoreEntry; +class HttpReply; +class HttpRequest; +class CacheManager; + +/* for http_hdr_type parameters-by-value */ +#include "HttpHeader.h" + + +/** + \ingroup AuthAPI + \par * I am the configuration for an auth scheme. * Currently each scheme has only one instance of me, * but this may change. - */ - -/* This class is treated like a ref counted class. + \par + * This class is treated like a ref counted class. * If the children ever stop being singletons, implement the * ref counting... */ - -class AuthUserRequest; - -/// \ingroup AuthAPI class AuthConfig { === modified file 'src/AuthUser.cc' --- src/AuthUser.cc 2007-12-15 06:11:41 +0000 +++ src/AuthUser.cc 2008-03-09 10:31:52 +0000 @@ -157,7 +157,7 @@ * This must complete all at once, because we are ensuring correctness. */ AuthUserHashPointer *usernamehash; - auth_user_t *auth_user; + AuthUser *auth_user; char const *username = NULL; debugs(29, 3, "AuthUser::CachedACLsReset: Flushing the ACL caches for all users."); hash_first(proxy_auth_username_cache); @@ -182,7 +182,7 @@ * entries at a time. Lets see how it flys first. */ AuthUserHashPointer *usernamehash; - auth_user_t *auth_user; + AuthUser *auth_user; char const *username = NULL; debugs(29, 3, "AuthUser::cacheCleanup: Cleaning the user cache now"); debugs(29, 3, "AuthUser::cacheCleanup: Current time: " << current_time.tv_sec); === modified file 'src/AuthUser.cci' --- src/AuthUser.cci 2007-05-09 21:26:12 +0000 +++ src/AuthUser.cci 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: AuthUser.cci,v 1.3 2007/05/09 15:26:12 wessels Exp $ * @@ -34,6 +33,11 @@ * Copyright (c) 2003, Robert Collins */ +/* for assert() */ +#include "assert.h" +/* for xstrdup() */ +#include "util.h" + char const * AuthUser::username () const { === modified file 'src/AuthUser.h' --- src/AuthUser.h 2008-02-27 04:49:32 +0000 +++ src/AuthUser.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: AuthUser.h,v 1.7 2008/02/26 21:49:34 amosjeffries Exp $ * @@ -35,9 +34,15 @@ #ifndef SQUID_AUTHUSER_H #define SQUID_AUTHUSER_H +class AuthUserRequest; +class AuthConfig; +class AuthUserHashPointer; + +/* for auth_type_t */ +#include "enums.h" + #include "IPAddress.h" - -class AuthUserRequest; +#include "dlink.h" /** * \ingroup AuthAPI @@ -60,7 +65,7 @@ /** the config for this user */ AuthConfig *config; /** we only have one username associated with a given auth_user struct */ - auth_user_hash_pointer *usernamehash; + AuthUserHashPointer *usernamehash; /** we may have many proxy-authenticate strings that decode to the same user */ dlink_list proxy_auth_list; dlink_list proxy_match_cache; @@ -72,11 +77,11 @@ * but how many requests will a single username have in parallel? */ dlink_list requests; - static void cacheInit (); + static void cacheInit(); static void CachedACLsReset(); void absorb(AuthUser *from); - virtual ~AuthUser (); + virtual ~AuthUser(); _SQUID_INLINE_ char const *username() const; _SQUID_INLINE_ void username(char const *); void clearIp(); @@ -84,9 +89,7 @@ void addIp(IPAddress); _SQUID_INLINE_ void addRequest(AuthUserRequest *); - void lock() - - ; + void lock(); void unlock(); void addToNameCache(); === modified file 'src/AuthUserRequest.cc' --- src/AuthUserRequest.cc 2008-02-13 06:29:25 +0000 +++ src/AuthUserRequest.cc 2008-03-09 10:31:52 +0000 @@ -202,7 +202,7 @@ static void authenticateAuthUserRequestSetIp(AuthUserRequest * auth_user_request, IPAddress &ipaddr) { - auth_user_t *auth_user = auth_user_request->user(); + AuthUser *auth_user = auth_user_request->user(); if (!auth_user) return; @@ -213,7 +213,7 @@ void authenticateAuthUserRequestRemoveIp(AuthUserRequest * auth_user_request, IPAddress const &ipaddr) { - auth_user_t *auth_user = auth_user_request->user(); + AuthUser *auth_user = auth_user_request->user(); if (!auth_user) return; @@ -328,7 +328,6 @@ * Caller is responsible for locking and unlocking their *auth_user_request! */ auth_acl_t - AuthUserRequest::authenticate(AuthUserRequest ** auth_user_request, http_hdr_type headertype, HttpRequest * request, ConnStateData * conn, IPAddress &src_addr) { const char *proxy_auth; === modified file 'src/AuthUserRequest.h' --- src/AuthUserRequest.h 2008-02-27 04:49:32 +0000 +++ src/AuthUserRequest.h 2008-03-09 10:31:52 +0000 @@ -66,7 +66,7 @@ * it has request specific data, and links to user specific data * the user */ - auth_user_t *_auth_user; + AuthUser *_auth_user; /** * Used by squid to determine what the next step in performing authentication for a given scheme is. @@ -107,7 +107,7 @@ virtual const AuthUser *user() const {return _auth_user;} - virtual void user (AuthUser *aUser) {_auth_user=aUser;} + virtual void user(AuthUser *aUser) {_auth_user=aUser;} static auth_acl_t tryToAuthenticateAndSetAuthUser(AuthUserRequest **, http_hdr_type, HttpRequest *, ConnStateData *, IPAddress &); static void addReplyAuthHeader(HttpReply * rep, AuthUserRequest * auth_user_request, HttpRequest * request, int accelerated, int internal); @@ -115,21 +115,21 @@ AuthUserRequest(); virtual ~AuthUserRequest(); - void *operator new (size_t byteCount); - void operator delete (void *address); - - void start ( RH * handler, void *data); - char const * denyMessage (char const * const default_message = NULL); - - /** Possibly overrideable in future */ - void setDenyMessage (char const *); - - /** Possibly overrideable in future */ - char const * getDenyMessage (); + void *operator new(size_t byteCount); + void operator delete(void *address); + + void start( RH * handler, void *data); + char const * denyMessage(char const * const default_message = NULL); + + /** Possibly overrideable in future */ + void setDenyMessage(char const *); + + /** Possibly overrideable in future */ + char const * getDenyMessage(); size_t refCount() const; - void _lock (); // please use AUTHUSERREQUESTLOCK() - void _unlock (); // please use AUTHUSERREQUESTUNLOCK() + void _lock(); // please use AUTHUSERREQUESTLOCK() + void _unlock(); // please use AUTHUSERREQUESTUNLOCK() /** * Squid does not make assumptions about where the username is stored. === modified file 'src/ChunkedCodingParser.h' --- src/ChunkedCodingParser.h 2007-12-27 05:33:31 +0000 +++ src/ChunkedCodingParser.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: ChunkedCodingParser.h,v 1.1 2007/12/26 22:33:32 hno Exp $ * @@ -29,18 +28,27 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_CHUNKEDCODINGPARSER_H #define SQUID_CHUNKEDCODINGPARSER_H +class MemBuf; + +#if 0 #include "RefCount.h" - -// ChunkedCodingParser is an incremental parser for chunked transfer coding -// used by HTTP and ICAP. The parser shovels content bytes from the raw -// input buffer into the content output buffer, both caller-supplied. -// Ignores chunk extensions except for ICAP's ieof. -// Has a trailer-handling placeholder. - +#endif + +/* for size_t */ +#include "config.h" + +/** + \ingroup ChunkEncodingAPI Chunked Encoding API + \par + * ChunkedCodingParser is an incremental parser for chunked transfer coding + * used by HTTP and ICAP. The parser shovels content bytes from the raw + * input buffer into the content output buffer, both caller-supplied. + * Ignores chunk extensions except for ICAP's ieof. + * Has a trailer-handling placeholder. + */ class ChunkedCodingParser { @@ -49,8 +57,12 @@ void reset(); - // true = complete success; false == needs more data - bool parse(MemBuf *rawData, MemBuf *parsedContent); // throws on error + /** + \retval true complete success + \retval false needs more data + \throws ?? error. + */ + bool parse(MemBuf *rawData, MemBuf *parsedContent); bool needsMoreData() const; bool needsMoreSpace() const; === modified file 'src/ClientRequestContext.h' --- src/ClientRequestContext.h 2007-05-26 12:38:03 +0000 +++ src/ClientRequestContext.h 2008-03-09 10:31:52 +0000 @@ -1,3 +1,15 @@ +#ifndef SQUID_CLIENTREQUESTCONTEXT_H +#define SQUID_CLIENTREQUESTCONTEXT_H + +class ACLChecklist; +class ClientHttpRequest; + +#include "config.h" +/* for RefCountable */ +#include "RefCount.h" +/* for CBDATA_CLASS() */ +#include "cbdata.h" + #if ICAP_CLIENT #include "ICAP/ICAPServiceRep.h" #endif @@ -44,3 +56,4 @@ CBDATA_CLASS(ClientRequestContext); }; +#endif /* SQUID_CLIENTREQUESTCONTEXT_H */ === modified file 'src/ConfigOption.h' --- src/ConfigOption.h 2004-12-20 23:30:12 +0000 +++ src/ConfigOption.h 2008-03-09 10:31:52 +0000 @@ -29,12 +29,15 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_CONFIGOPTION_H #define SQUID_CONFIGOPTION_H +class StoreEntry; + +/* for Vector<> */ #include "Array.h" + /* cache option parsers */ class ConfigOption @@ -58,12 +61,11 @@ }; template - class ConfigOptionAdapter : public ConfigOption { public: - ConfigOptionAdapter (C& theObject, bool (C::*parseFP)(char const *option, const char *value, int reconfiguring), void (C::*dumpFP) (StoreEntry * e) const) : object(theObject), parser (parseFP), dumper(dumpFP) {} + ConfigOptionAdapter(C& theObject, bool (C::*parseFP)(char const *option, const char *value, int reconfiguring), void (C::*dumpFP) (StoreEntry * e) const) : object(theObject), parser (parseFP), dumper(dumpFP) {} bool parse(char const *option, const char *value, int reconfiguring) { @@ -73,7 +75,7 @@ return false; } - void dump (StoreEntry * e) const + void dump(StoreEntry * e) const { if (dumper) (object.*dumper) (e); === modified file 'src/Debug.h' --- src/Debug.h 2008-02-27 01:43:30 +0000 +++ src/Debug.h 2008-03-09 10:31:52 +0000 @@ -31,9 +31,8 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - -#ifndef SQUID_DEBUG -#define SQUID_DEBUG +#ifndef SQUID_DEBUG_H +#define SQUID_DEBUG_H #include #undef assert @@ -52,6 +51,9 @@ #define assert(EX) ((EX)?((void)0):xassert("EX", __FILE__, __LINE__)) #endif +/* defined debug section limits */ +#define MAX_DEBUG_SECTIONS 100 + /* defined names for Debug Levels */ #define DBG_CRITICAL 0 /**< critical messages always shown when they occur */ #define DBG_IMPORTANT 1 /**< important messages always shown when their section is being checked */ @@ -97,4 +99,4 @@ return (os << (int)d); } -#endif /* SQUID_DEBUG */ +#endif /* SQUID_DEBUG_H */ === modified file 'src/DelayBucket.h' --- src/DelayBucket.h 2008-02-27 04:49:32 +0000 +++ src/DelayBucket.h 2008-03-09 10:31:52 +0000 @@ -31,11 +31,12 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_DELAYBUCKET_H #define SQUID_DELAYBUCKET_H class DelaySpec; +class StoreEntry; + /* don't use remote storage for these */ /// \ingroup DelayPoolsAPI === modified file 'src/DelayConfig.h' --- src/DelayConfig.h 2008-02-27 04:49:32 +0000 +++ src/DelayConfig.h 2008-03-09 10:31:52 +0000 @@ -33,10 +33,10 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_DELAYCONFIG_H #define SQUID_DELAYCONFIG_H +class StoreEntry; class ConfigParser; /// \ingroup DelayPoolsAPI === modified file 'src/DelayPools.h' --- src/DelayPools.h 2008-02-27 04:49:32 +0000 +++ src/DelayPools.h 2008-03-09 10:31:52 +0000 @@ -31,7 +31,6 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_DELAYPOOLS_H #define SQUID_DELAYPOOLS_H @@ -40,11 +39,6 @@ \ingroup Components */ -/* forward decls */ -class CacheManager; - -#include "Array.h" - /// \ingroup DelayPoolsAPI class Updateable { @@ -55,7 +49,14 @@ virtual void update(int) = 0; }; +/* forward decls */ +class CacheManager; class DelayPool; +class Updateable; +class StoreEntry; + +/* for Vector<> */ +#include "Array.h" /// \ingroup DelayPoolsAPI class DelayPools === modified file 'src/DelaySpec.h' --- src/DelaySpec.h 2008-02-27 04:49:32 +0000 +++ src/DelaySpec.h 2008-03-09 10:31:52 +0000 @@ -29,18 +29,19 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_DELAYSPEC_H #define SQUID_DELAYSPEC_H +class StoreEntry; + /// \ingroup DelyPoolsAPI class DelaySpec { public: DelaySpec(); - void stats (StoreEntry * sentry, char const *) const; - void dump (StoreEntry *) const; + void stats(StoreEntry * sentry, char const *) const; + void dump(StoreEntry *) const; void parse(); int restore_bps; int max_bytes; === modified file 'src/ESICustomParser.h' --- src/ESICustomParser.h 2007-05-29 19:31:36 +0000 +++ src/ESICustomParser.h 2008-03-09 10:31:52 +0000 @@ -29,14 +29,20 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_ESICUSTOMPARSER_H #define SQUID_ESICUSTOMPARSER_H +class Trie; + +/* inherits from */ #include "ESIParser.h" -class Trie; +/* for String variables */ +#include "SquidString.h" +/** + \ingroup ESIAPI + */ class ESICustomParser : public ESIParser { === modified file 'src/ESIParser.h' --- src/ESIParser.h 2008-02-27 04:49:32 +0000 +++ src/ESIParser.h 2008-03-09 10:31:52 +0000 @@ -29,32 +29,41 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_ESIPARSER_H #define SQUID_ESIPARSER_H +/* for size_t */ +#include "config.h" + class ESIParserClient { - public: virtual void start(const char *el, const char **attr, size_t attrCount) = 0; virtual void end(const char *el) = 0; virtual void parserDefault (const char *s, int len) =0; virtual void parserComment (const char *s) = 0; virtual ~ESIParserClient() {}; - }; + +/* for RefCountable */ +#include "RefCount.h" + class ESIParser : public RefCountable { - public: typedef RefCount Pointer; + static void registerParser(const char *name, Pointer (*new_func)(ESIParserClient *aClient)); static Pointer NewParser(ESIParserClient *aClient); static char *Type; - /* true on success */ + + /** + \retval true on success + \retval false on what? + */ virtual bool parse(char const *dataToParse, size_t const lengthOfData, bool const endOfStream) = 0; + virtual long int lineNumber() const =0; virtual char const * errorString() const =0; @@ -95,4 +104,6 @@ #define ESI_PARSER_TYPE \ static ESIParser::Pointer NewParser(ESIParserClient *aClient); \ static ESIParser::Register thisParser + + #endif /* SQUID_ESIPARSER_H */ === modified file 'src/ExternalACL.h' --- src/ExternalACL.h 2008-02-27 04:49:32 +0000 +++ src/ExternalACL.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: ExternalACL.h,v 1.10 2008/02/26 21:49:34 amosjeffries Exp $ * @@ -32,10 +31,9 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_EXTERNALACL_H #define SQUID_EXTERNALACL_H -#include "ACL.h" + #include "ACLChecklist.h" class external_acl; @@ -52,8 +50,11 @@ static void LookupDone(void *data, void *result); }; +/** \todo CLEANUP: kill this typedef. */ typedef struct _external_acl_data external_acl_data; +#include "ACL.h" + class ACLExternal : public ACL { @@ -89,7 +90,7 @@ char const *class_; }; -MEMPROXY_CLASS_INLINE(ACLExternal) /**DOCS_NOSEMI*/ +MEMPROXY_CLASS_INLINE(ACLExternal); extern void externalAclRegisterWithCacheManager(CacheManager & manager); === modified file 'src/Generic.h' --- src/Generic.h 2004-12-20 23:30:12 +0000 +++ src/Generic.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: Generic.h,v 1.7 2004/12/20 16:30:32 robertc Exp $ * @@ -30,12 +29,15 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_GENERIC_H #define SQUID_GENERIC_H +/** \todo CLEANUP: checks towrap this header properly */ +#include + +#include "dlink.h" + template - struct unary_function { typedef _Arg argument_type; @@ -61,7 +63,6 @@ } template - class Stack; template @@ -78,7 +79,6 @@ */ template - class InstanceToSingletonAdapter : public C { @@ -119,7 +119,6 @@ /* generic ostream printer */ template - struct PointerPrinter { PointerPrinter(std::ostream &astream, std::string aDelimiter) : os(astream), delimiter (aDelimiter) {} === modified file 'src/HierarchyLogEntry.h' --- src/HierarchyLogEntry.h 2003-10-17 03:40:16 +0000 +++ src/HierarchyLogEntry.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: HierarchyLogEntry.h,v 1.1 2003/10/16 21:40:16 robertc Exp $ * @@ -35,8 +34,12 @@ #ifndef SQUID_HTTPHIERARCHYLOGENTRY_H #define SQUID_HTTPHIERARCHYLOGENTRY_H +#include "rfc2181.h" #include "PingData.h" +/** todo Cleanup: break hier_code type out. We don't need the rest. */ +#include "enums.h" + class HierarchyLogEntry { === modified file 'src/HttpHdrContRange.h' --- src/HttpHdrContRange.h 2007-08-13 23:20:50 +0000 +++ src/HttpHdrContRange.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: HttpHdrContRange.h,v 1.4 2007/08/13 17:20:51 hno Exp $ * @@ -30,34 +29,37 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_HTTPHDRCONTRANGE_H #define SQUID_HTTPHDRCONTRANGE_H +class HttpHeader; + +/* for SQUIDCEXTERN */ +#include "config.h" + +/* for HttpHdrRangeSpec */ #include "HttpHeaderRange.h" -/* http content-range header field */ - +/** HTTP Content-Range: header field */ class HttpHdrContRange { public: HttpHdrRangeSpec spec; - int64_t elength; /* entity length, not content length */ + int64_t elength; /**< entity length, not content length */ }; -/* Http Content Range Header Field */ +/** \todo CLEANUP: Move httpHdrContRange* functions into the class methods */ + SQUIDCEXTERN HttpHdrContRange *httpHdrContRangeCreate(void); SQUIDCEXTERN HttpHdrContRange *httpHdrContRangeParseCreate(const char *crange_spec); -/* returns true if range is valid; inits HttpHdrContRange */ +/** returns true if range is valid; inits HttpHdrContRange */ SQUIDCEXTERN int httpHdrContRangeParseInit(HttpHdrContRange * crange, const char *crange_spec); SQUIDCEXTERN void httpHdrContRangeDestroy(HttpHdrContRange * crange); SQUIDCEXTERN HttpHdrContRange *httpHdrContRangeDup(const HttpHdrContRange * crange); SQUIDCEXTERN void httpHdrContRangePackInto(const HttpHdrContRange * crange, Packer * p); -/* inits with given spec */ +/** inits with given spec */ SQUIDCEXTERN void httpHdrContRangeSet(HttpHdrContRange *, HttpHdrRangeSpec, int64_t); -; SQUIDCEXTERN void httpHeaderAddContRange(HttpHeader *, HttpHdrRangeSpec, int64_t); - #endif /* SQUID_HTTPHDRCONTRANGE_H */ === modified file 'src/HttpHdrScTarget.h' --- src/HttpHdrScTarget.h 2007-05-29 19:31:36 +0000 +++ src/HttpHdrScTarget.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: HttpHdrScTarget.h,v 1.3 2007/05/29 13:31:37 amosjeffries Exp $ * @@ -30,17 +29,22 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_HTTPHDRSURROGATECONTROLTARGET_H #define SQUID_HTTPHDRSURROGATECONTROLTARGET_H +class Packer; +class StoreEntry; + +/* for MEMPROXY_CLASS() macros */ +#include "MemPool.h" +/* for dlink_node */ #include "dlink.h" - -/* http surogate control header field */ - +/* for String */ +#include "SquidString.h" + +/** HTTP Surogate-Control: header field */ class HttpHdrScTarget { - public: MEMPROXY_CLASS(HttpHdrScTarget); dlink_node node; @@ -59,9 +63,14 @@ extern HttpHdrScTarget *httpHdrScTargetDup(const HttpHdrScTarget *); extern void httpHdrScTargetPackInto(const HttpHdrScTarget *, Packer *); extern void httpHdrScTargetSetMaxAge(HttpHdrScTarget *, int); -extern void httpHdrScTargetUpdateStats(const HttpHdrScTarget *, StatHist *); extern void httpHdrScTargetJoinWith(HttpHdrScTarget *, const HttpHdrScTarget *); extern void httpHdrScTargetMergeWith(HttpHdrScTarget *, const HttpHdrScTarget *); extern void httpHdrScTargetStatDumper(StoreEntry * sentry, int idx, double val, double size, int count); +/* for StatHist */ +#include "typedefs.h" + +extern void httpHdrScTargetUpdateStats(const HttpHdrScTarget *, StatHist *); + + #endif /* SQUID_HTTPHDRSURROGATECONTROLTARGET_H */ === modified file 'src/HttpHeader.h' --- src/HttpHeader.h 2008-02-27 04:49:32 +0000 +++ src/HttpHeader.h 2008-03-09 10:31:52 +0000 @@ -36,6 +36,7 @@ /* forward decls */ class CacheManager; + /* because we pass a spec by value */ #include "HttpHeaderRange.h" /* HttpHeader holds a HttpHeaderMask */ @@ -167,8 +168,10 @@ /* these two are defined in structs.h */ +/// \todo CLEANUP: Kill this. typedef struct _TimeOrTag TimeOrTag; +/// \todo CLEANUP: Kill this. typedef struct _ETag ETag; class HttpHeaderEntry === modified file 'src/HttpHeaderMask.h' --- src/HttpHeaderMask.h 2006-04-22 19:07:36 +0000 +++ src/HttpHeaderMask.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: HttpHeaderMask.h,v 1.1 2006/04/22 13:08:39 robertc Exp $ * @@ -30,12 +29,15 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_HTTPHEADERMASK_H #define SQUID_HTTPHEADERMASK_H +/* for SQUIDCEXTERN */ +#include "config.h" + /* big mask for http headers */ typedef char HttpHeaderMask[12]; SQUIDCEXTERN void httpHeaderMaskInit(HttpHeaderMask * mask, int value); + #endif /* SQUID_HTTPHEADERMASK_H */ === modified file 'src/HttpRequestMethod.h' --- src/HttpRequestMethod.h 2008-02-26 07:16:47 +0000 +++ src/HttpRequestMethod.h 2008-03-09 10:31:52 +0000 @@ -72,9 +72,6 @@ METHOD_ENUM_END // MUST be last, (yuck) this is used as an array-initialization index constant! }; -/* forward decls */ -typedef struct _SquidConfig SquidConfig; - /** * This class represents an HTTP Request METHOD === modified file 'src/HttpStatusLine.h' --- src/HttpStatusLine.h 2007-05-29 19:31:36 +0000 +++ src/HttpStatusLine.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: HttpStatusLine.h,v 1.4 2007/05/29 13:31:38 amosjeffries Exp $ * @@ -31,10 +30,19 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_HTTPSTATUSLINE_H #define SQUID_HTTPSTATUSLINE_H +class Packer; +class String; + +/* for SQUIDCEXTERN */ +#include "config.h" + +/* for http_status */ +#include "enums.h" + +/* for class variables */ #include "HttpVersion.h" class HttpStatusLine @@ -43,7 +51,7 @@ public: /* public, read only */ HttpVersion version; - const char *reason; /* points to a _constant_ string (default or supplied), never free()d */ + const char *reason; /**< points to a _constant_ string (default or supplied), never free()d */ http_status status; }; === modified file 'src/Makefile.am' --- src/Makefile.am 2008-02-26 07:19:29 +0000 +++ src/Makefile.am 2008-03-09 10:31:52 +0000 @@ -409,6 +409,7 @@ IPInterception.h \ ICAP/AsyncJob.cc \ ICAP/AsyncJob.h \ + SquidConfig.cc \ TextException.cc \ TextException.h @@ -479,6 +480,7 @@ disk.cc \ $(DISKIO_SOURCE) \ dlink.h \ + dlink.cc \ $(DNSSOURCE) \ enums.h \ errorpage.cc \ @@ -816,6 +818,8 @@ defines.h \ $(DELAY_POOL_SOURCE) \ disk.cc \ + dlink.h \ + dlink.cc \ $(DNSSOURCE) \ enums.h \ errorpage.cc \ @@ -1155,9 +1159,9 @@ event.cc \ AsyncCallQueue.cc \ AsyncCall.cc - - -check_PROGRAMS+= \ + + +check_PROGRAMS+= testHeaders \ tests/testAuth \ tests/testACLMaxUserIP \ tests/testBoilerplate \ @@ -1165,7 +1169,6 @@ tests/testDiskIO \ tests/testEvent \ tests/testEventLoop \ - tests/testHeaders \ tests/test_http_range \ tests/testHttpRequest \ tests/testICMP \ @@ -1174,6 +1177,15 @@ tests/testURL \ @STORE_TESTS@ +## Special Universal .h dependency test script +## aborts if error encountered +testHeaders: *.h DiskIO/*.h ICAP/*.h + ../test-suite/testheaders.sh "$(CXXCOMPILE)" "." || exit 1 + ../test-suite/testheaders.sh "$(CXXCOMPILE)" "DiskIO" || exit 1 + ../test-suite/testheaders.sh "$(CXXCOMPILE)" "ICAP" || exit 1 +## src/repl/ has no .h files and its own makefile. + + ### Template for new Unit Test Program ## - add tests/testX to check_PROGRAMS above. ## - copy template below and substitue X for class name @@ -1361,6 +1373,8 @@ ConfigParser.cc \ $(DELAY_POOL_SOURCE) \ disk.cc \ + dlink.h \ + dlink.cc \ $(DNSSOURCE) \ errorpage.cc \ $(ESI_SOURCE) \ @@ -1480,6 +1494,7 @@ tests/testMain.cc tests_testDiskIO_LDADD= \ $(SWAP_TEST_LDADD) \ + libsquid.la \ @SSLLIB@ tests_testDiskIO_LDFLAGS = $(LIBADD_DL) tests_testDiskIO_DEPENDENCIES = $(top_builddir)/lib/libmiscutil.a \ @@ -1529,6 +1544,8 @@ ConfigParser.cc \ $(DELAY_POOL_SOURCE) \ disk.cc \ + dlink.h \ + dlink.cc \ $(DNSSOURCE) \ errorpage.cc \ $(ESI_SOURCE) \ @@ -1683,6 +1700,8 @@ ConfigParser.cc \ $(DELAY_POOL_SOURCE) \ disk.cc \ + dlink.h \ + dlink.cc \ $(DNSSOURCE) \ errorpage.cc \ $(ESI_SOURCE) \ @@ -1794,43 +1813,6 @@ @SQUID_CPPUNIT_LA@ \ @ICAP_LIBS@ -## test headers checks that individual headers can be parsed with no dependencies. -## as such, it needs a new .cc file for each header it parses, so that they -## can be #included with no baggage. If the binary links, the test passed. -## We could write a script to pull out the compiler configuration from autoconf, -## but this is easier to understand and more robust against changes in autoconf. -## RBC 20060422. -HEADERS_TO_TEST = \ - tests/testHeader_ACL.cc \ - tests/testHeader_AsyncEngine.cc \ - tests/testHeader_cbdata.cc \ - tests/testHeader_CompletionDispatcher.cc \ - tests/testHeader_ConfigParser.cc \ - tests/testHeader_client_side_request.cc \ - tests/testHeader_comm.cc \ - tests/testHeader_dlink.cc \ - tests/testHeader_errorpage.cc \ - tests/testHeader_event.cc \ - tests/testHeader_EventLoop.cc \ - tests/testHeader_HttpHeader.cc \ - tests/testHeader_HttpHeaderRange.cc \ - tests/testHeader_HttpReply.cc \ - tests/testHeader_HttpRequestMethod.cc \ - tests/testHeader_RemovalPolicy.cc \ - tests/testHeader_SquidTime.cc \ - tests/testHeader_Store.cc \ - tests/testHeader_StoreEntryStream.cc \ - tests/testHeader_URL.cc \ - tests/testHeader_URLScheme.cc \ - tests/testHeader_wordlist.cc -tests_testHeaders_SOURCES= tests/testMain.cc $(HEADERS_TO_TEST) -tests_testHeaders_LDADD= \ - @SQUID_CPPUNIT_LIBS@ \ - @SSLLIB@ -tests_testHeaders_LDFLAGS = $(LIBADD_DL) -tests_testHeaders_DEPENDENCIES = \ - @SQUID_CPPUNIT_LA@ - tests_test_http_range_SOURCES = \ tests/test_http_range.cc \ access_log.cc \ @@ -1862,6 +1844,8 @@ debug.cc \ $(DELAY_POOL_SOURCE) \ disk.cc \ + dlink.h \ + dlink.cc \ $(DNSSOURCE) \ errorpage.cc \ $(ESI_SOURCE) \ @@ -2022,6 +2006,8 @@ ConfigParser.cc \ $(DELAY_POOL_SOURCE) \ disk.cc \ + dlink.h \ + dlink.cc \ $(DNSSOURCE) \ errorpage.cc \ $(ESI_SOURCE) \ @@ -2240,6 +2226,7 @@ time.cc tests_testString_LDADD= \ + libsquid.la \ -L../lib -lmiscutil \ @REGEXLIB@ \ @SQUID_CPPUNIT_LIBS@ \ @@ -2305,6 +2292,7 @@ tests/testUfs.h \ $(SWAP_TEST_SOURCES) tests_testUfs_LDADD= \ + libsquid.la \ $(SWAP_TEST_LDADD) \ @SSLLIB@ tests_testUfs_LDFLAGS = $(LIBADD_DL) @@ -2379,6 +2367,8 @@ ConfigParser.cc \ $(DELAY_POOL_SOURCE) \ disk.cc \ + dlink.h \ + dlink.cc \ $(DNSSOURCE) \ errorpage.cc \ $(ESI_SOURCE) \ === modified file 'src/Mem.h' --- src/Mem.h 2008-02-27 04:49:32 +0000 +++ src/Mem.h 2008-03-09 10:31:52 +0000 @@ -31,15 +31,16 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_MEM #define SQUID_MEM -/* forward decls */ - class CacheManager; +class StoreEntry; +class MemPoolStats; +class MemPoolMeter; -#include +/** \todo CLEANUP: protection to wrap this system include */ +#include class Mem { === modified file 'src/Packer.h' --- src/Packer.h 2006-05-03 20:04:44 +0000 +++ src/Packer.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: Packer.h,v 1.2 2006/05/03 14:04:44 robertc Exp $ * @@ -30,19 +29,21 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_PACKER_H #define SQUID_PACKER_H +/* for SQUIDCEXTERN */ #include "config.h" /* see Packer.cc for description */ - class Packer; /* a common objPackInto interface; used by debugObj */ typedef void (*ObjPackMethod) (void *obj, Packer * p); +#if HAVE_STDIO_H +#include +#endif /* append/vprintf's for Packer */ typedef void (*append_f) (void *, const char *buf, int size); #if STDC_HEADERS @@ -71,5 +72,4 @@ SQUIDCEXTERN void packerPrintf(); #endif - #endif /* SQUID_PACKER_H */ === modified file 'src/PeerDigest.h' --- src/PeerDigest.h 2007-09-21 17:41:52 +0000 +++ src/PeerDigest.h 2008-03-09 10:31:52 +0000 @@ -95,24 +95,17 @@ void *operator new (size_t); void operator delete(void *); - struct _peer *peer; /* pointer back to peer structure, argh */ - CacheDigest *cd; /* actual digest structure */ - String host; /* copy of peer->host */ - const char *req_result; /* text status of the last request */ + struct peer *peer; /**< pointer back to peer structure, argh */ + CacheDigest *cd; /**< actual digest structure */ + String host; /**< copy of peer->host */ + const char *req_result; /**< text status of the last request */ struct { - -unsigned int needed: - 1; /* there were requests for this digest */ - -unsigned int usable: - 1; /* can be used for lookups */ - -unsigned int requested: - 1; /* in process of receiving [fresh] digest */ + unsigned int needed:1; /**< there were requests for this digest */ + unsigned int usable:1; /**< can be used for lookups */ + unsigned int requested:1; /**< in process of receiving [fresh] digest */ } - flags; struct @@ -127,7 +120,6 @@ time_t received; /* received the current copy of a digest */ time_t disabled; /* disabled for good */ } - times; struct @@ -143,7 +135,6 @@ sent, recv; } - stats; private: @@ -151,6 +142,7 @@ }; extern const Version CacheDigestVer; -#endif + +#endif /* USE_CACHE_DIGESTS */ #endif /* SQUID_PEERDIGEST_H */ === modified file 'src/PingData.h' --- src/PingData.h 2003-10-17 03:40:16 +0000 +++ src/PingData.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: PingData.h,v 1.1 2003/10/16 21:40:16 robertc Exp $ * @@ -31,10 +30,15 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_PINGDATA_H #define SQUID_PINGDATA_H +#include "config.h" + +#ifdef HAVE_SYS_TIME_H +#include +#endif + class ping_data { === added file 'src/SquidConfig.cc' --- src/SquidConfig.cc 1970-01-01 00:00:00 +0000 +++ src/SquidConfig.cc 2008-03-09 10:31:52 +0000 @@ -0,0 +1,10 @@ +/* + * $Id$ + */ + +// just for the global definition of Config and Config2 +#include "structs.h" + +struct SquidConfig Config; + +struct SquidConfig2 Config2; === modified file 'src/SquidString.h' --- src/SquidString.h 2008-02-12 06:01:23 +0000 +++ src/SquidString.h 2008-03-09 10:31:52 +0000 @@ -41,6 +41,10 @@ class CacheManager; +/** todo checks to wrap this include properly */ +#include + + #define DEBUGSTRINGS 0 #if DEBUGSTRINGS #include "splay.h" === modified file 'src/Store.h' --- src/Store.h 2008-02-27 04:49:32 +0000 +++ src/Store.h 2008-03-09 10:31:52 +0000 @@ -29,7 +29,6 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_STORE_H #define SQUID_STORE_H @@ -55,15 +54,13 @@ #endif class AsyncCall; - class StoreClient; - class MemObject; - class Store; - class StoreSearch; +typedef unsigned int ping_status_t; + /** \ingroup StoreAPI */ @@ -143,24 +140,18 @@ u_short flags; /* END OF ON-DISK STORE_META_STD */ -sfileno swap_filen: - 25; + sfileno swap_filen:25; -sdirno swap_dirn: - 7; + sdirno swap_dirn:7; u_short lock_count; /* Assume < 65536! */ -mem_status_t mem_status: - 3; - -ping_status_t ping_status: - 3; - -store_status_t store_status: - 3; - -swap_status_t swap_status: - 3; + mem_status_t mem_status:3; + + ping_status_t ping_status:3; + + store_status_t store_status:3; + + swap_status_t swap_status:3; public: static size_t inUseCount(); @@ -373,6 +364,7 @@ /// \ingroup StoreAPI SQUIDCEXTERN int storeTooManyDiskFilesOpen(void); +class SwapDir; /// \ingroup StoreAPI SQUIDCEXTERN void storeHeapPositionUpdate(StoreEntry *, SwapDir *); === modified file 'src/StoreFileSystem.h' --- src/StoreFileSystem.h 2006-05-29 06:14:59 +0000 +++ src/StoreFileSystem.h 2008-03-09 10:31:52 +0000 @@ -41,6 +41,8 @@ class CacheManager; +class SwapDir; + class StoreFileSystem { @@ -52,7 +54,7 @@ static Vector const &FileSystems(); typedef Vector::iterator iterator; typedef Vector::const_iterator const_iterator; - StoreFileSystem() : initialised (false) {} + StoreFileSystem() : initialised(false) {} virtual ~StoreFileSystem(){} === modified file 'src/StoreMeta.h' --- src/StoreMeta.h 2003-08-05 04:14:37 +0000 +++ src/StoreMeta.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: StoreMeta.h,v 1.3 2003/08/04 22:14:41 robertc Exp $ * @@ -30,24 +29,125 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_TYPELENGTHVALUE_H #define SQUID_TYPELENGTHVALUE_H class StoreEntry; +// WTF? typedef class StoreMeta tlv; +/* for size_t, SQUIDCEXTERN */ +#include "config.h" + +/** + \ingroup SwapStoreAPI + \todo AYJ: for critical lists like this we should use A=64,B=65 etc to enforce and reserve values. + \note NOTE! We must preserve the order of this list! + * + \section StoreSwapMeta Store "swap meta" Description + \par + * "swap meta" refers to a section of meta data stored at the beginning + * of an object that is stored on disk. This meta data includes information + * such as the object's cache key (MD5), URL, and part of the StoreEntry + * structure. + * + \par + * The meta data is stored using a TYPE-LENGTH-VALUE format. That is, + * each chunk of meta information consists of a TYPE identifier, a + * LENGTH field, and then the VALUE (which is LENGTH octets long). + */ +enum { + /** + * Just a placeholder for the zeroth value. It is never used on disk. + */ + STORE_META_VOID, + + /** + \deprecated + * This represents the case when we use the URL as the cache + * key, as Squid-1.1 does. Currently we don't support using + * a URL as a cache key, so this is not used. + */ + STORE_META_KEY_URL, + + /** + \deprecated + * For a brief time we considered supporting SHA (secure + * hash algorithm) as a cache key. Nobody liked it, and + * this type is not currently used. + */ + STORE_META_KEY_SHA, + + /** + * This represents the MD5 cache key that Squid currently uses. + * When Squid opens a disk file for reading, it can check that + * this MD5 matches the MD5 of the user's request. If not, then + * something went wrong and this is probably the wrong object. + */ + STORE_META_KEY_MD5, + + /** + * The object's URL. This also may be matched against a user's + * request for cache hits to make sure we got the right object. + */ + STORE_META_URL, + + /** + * This is the "standard metadata" for an object. + * Really its just this middle chunk of the StoreEntry structure: + \code + time_t timestamp; + time_t lastref; + time_t expires; + time_t lastmod; + size_t swap_file_sz; + u_short refcount; + u_short flags; + \endcode + */ + STORE_META_STD, + + /** + * Reserved for future hit-metering (RFC 2227) stuff + */ + STORE_META_HITMETERING, + + /// \todo DOCS: document. + STORE_META_VALID, + + /** + * Stores Vary request headers + */ + STORE_META_VARY_HEADERS, + + /** + * Updated version of STORE_META_STD, with support for >2GB objects. + * As STORE_META_STD except that the swap_file_sz is a 64-bit integer instead of 32-bit. + */ + STORE_META_STD_LFS, + + /** + \deprecated + * Object size, not implemented, squid26 compatibility + */ + STORE_META_OBJSIZE, + + STORE_META_STOREURL, /* the store url, if different to the normal URL */ + STORE_META_VARY_ID, /* Unique ID linking variants */ + STORE_META_END +}; + +/// \ingroup SwapStoreAPI class StoreMeta { - public: static bool validType(char); static int const MaximumTLVLength; static int const MinimumTLVLength; - static StoreMeta *Factory (char type, size_t len, void const *value); + static StoreMeta *Factory(char type, size_t len, void const *value); static StoreMeta **Add(StoreMeta **tail, StoreMeta *aNode); - static void FreeList (StoreMeta **head); + static void FreeList(StoreMeta **head); virtual char getType() const = 0; virtual bool validLength(int) const; @@ -57,15 +157,13 @@ int length; void *value; tlv *next; - -private: }; -/* - * store_swapmeta.c - */ +/// \ingroup SwapStoreAPI SQUIDCEXTERN char *storeSwapMetaPack(tlv * tlv_list, int *length); +/// \ingroup SwapStoreAPI SQUIDCEXTERN tlv *storeSwapMetaBuild(StoreEntry * e); +/// \ingroup SwapStoreAPI SQUIDCEXTERN void storeSwapTLVFree(tlv * n); #endif /* SQUID_TYPELENGTHVALUE_H */ === modified file 'src/StoreMetaMD5.h' --- src/StoreMetaMD5.h 2008-02-27 04:49:32 +0000 +++ src/StoreMetaMD5.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: StoreMetaMD5.h,v 1.5 2008/02/26 21:49:34 amosjeffries Exp $ * @@ -30,11 +29,15 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_STOREMETAMD5_H #define SQUID_STOREMETAMD5_H +/* for inheritance */ #include "StoreMeta.h" +/* for MEMPROXY_CLASS() macros */ +#include "MemPool.h" +/* for STORE_META_KEY_MD5 */ +#include "enums.h" class StoreMetaMD5 : public StoreMeta { @@ -51,6 +54,6 @@ static int md5_mismatches; }; -MEMPROXY_CLASS_INLINE(StoreMetaMD5) /**DOCS_NOSEMI*/ +MEMPROXY_CLASS_INLINE(StoreMetaMD5); #endif /* SQUID_STOREMETAMD5_H */ === modified file 'src/StoreMetaObjSize.h' --- src/StoreMetaObjSize.h 2007-09-19 14:54:50 +0000 +++ src/StoreMetaObjSize.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: StoreMetaObjSize.h,v 1.1 2007/09/19 08:54:51 hno Exp $ * @@ -30,11 +29,11 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_STOREMETAOBJSIZE_H #define SQUID_STOREMETAOBJSIZE_H #include "StoreMeta.h" +#include "MemPool.h" class StoreMetaObjSize : public StoreMeta { @@ -45,6 +44,6 @@ char getType() const {return STORE_META_OBJSIZE;} }; -MEMPROXY_CLASS_INLINE(StoreMetaObjSize) +MEMPROXY_CLASS_INLINE(StoreMetaObjSize); #endif /* SQUID_STOREMETAOBJSIZE_H */ === modified file 'src/StoreMetaSTD.h' --- src/StoreMetaSTD.h 2008-02-27 04:49:32 +0000 +++ src/StoreMetaSTD.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: StoreMetaSTD.h,v 1.5 2008/02/26 21:49:34 amosjeffries Exp $ * @@ -30,11 +29,12 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_STOREMETASTD_H #define SQUID_STOREMETASTD_H #include "StoreMeta.h" +/* for MEMPROXY_CLASS() macros */ +#include "MemPool.h" class StoreMetaSTD : public StoreMeta { @@ -48,6 +48,6 @@ // bool checkConsistency(StoreEntry *) const; }; -MEMPROXY_CLASS_INLINE(StoreMetaSTD) /**DOCS_NOSEMI*/ +MEMPROXY_CLASS_INLINE(StoreMetaSTD); #endif /* SQUID_STOREMETASTD_H */ === modified file 'src/StoreMetaSTDLFS.h' --- src/StoreMetaSTDLFS.h 2008-02-27 04:49:32 +0000 +++ src/StoreMetaSTDLFS.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: StoreMetaSTDLFS.h,v 1.2 2008/02/26 21:49:34 amosjeffries Exp $ * @@ -30,15 +29,16 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_STOREMETASTDLFS_H #define SQUID_STOREMETASTDLFS_H +/* for inheritance */ #include "StoreMeta.h" +/* for MEMPROXY() macros */ +#include "MemPool.h" class StoreMetaSTDLFS : public StoreMeta { - public: MEMPROXY_CLASS(StoreMetaSTDLFS); @@ -48,6 +48,6 @@ // bool checkConsistency(StoreEntry *) const; }; -MEMPROXY_CLASS_INLINE(StoreMetaSTDLFS) /**DOCS_NOSEMI*/ +MEMPROXY_CLASS_INLINE(StoreMetaSTDLFS); #endif /* SQUID_STOREMETASTDLFS_H */ === modified file 'src/StoreMetaURL.h' --- src/StoreMetaURL.h 2008-02-27 04:49:32 +0000 +++ src/StoreMetaURL.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: StoreMetaURL.h,v 1.5 2008/02/26 21:49:34 amosjeffries Exp $ * @@ -30,15 +29,16 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_STOREMETAURL_H #define SQUID_STOREMETAURL_H +/* for inheritance */ #include "StoreMeta.h" +/* for MEMPROXY_CLASS() macros */ +#include "MemPool.h" class StoreMetaURL : public StoreMeta { - public: MEMPROXY_CLASS(StoreMetaURL); @@ -47,6 +47,6 @@ bool checkConsistency(StoreEntry *) const; }; -MEMPROXY_CLASS_INLINE(StoreMetaURL) /**DOCS_NOSEMI*/ +MEMPROXY_CLASS_INLINE(StoreMetaURL); #endif /* SQUID_STOREMETAURL_H */ === modified file 'src/StoreMetaUnpacker.h' --- src/StoreMetaUnpacker.h 2008-01-08 00:12:28 +0000 +++ src/StoreMetaUnpacker.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: StoreMetaUnpacker.h,v 1.3 2008/01/07 17:12:28 hno Exp $ * @@ -30,11 +29,14 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_TYPELENGTHVALUEUNPACKER_H #define SQUID_TYPELENGTHVALUEUNPACKER_H class StoreMeta; +class StoreEntry; + +/* for ssize_t, SQUIDCEXTERN */ +#include "config.h" class StoreMetaUnpacker { === modified file 'src/StoreMetaVary.h' --- src/StoreMetaVary.h 2008-02-27 04:49:32 +0000 +++ src/StoreMetaVary.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: StoreMetaVary.h,v 1.5 2008/02/26 21:49:34 amosjeffries Exp $ * @@ -30,15 +29,16 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_STOREMETAVARY_H #define SQUID_STOREMETAVARY_H +/* for inheritance */ #include "StoreMeta.h" +/* for MEMPROXY_CLASS() macros */ +#include "MemPool.h" class StoreMetaVary : public StoreMeta { - public: MEMPROXY_CLASS(StoreMetaVary); @@ -47,6 +47,6 @@ bool checkConsistency(StoreEntry *) const; }; -MEMPROXY_CLASS_INLINE(StoreMetaVary) /**DOCS_NOSEMI*/ +MEMPROXY_CLASS_INLINE(StoreMetaVary); #endif /* SQUID_STOREMETAVARY_H */ === modified file 'src/String.cci' --- src/String.cci 2008-02-12 06:01:23 +0000 +++ src/String.cci 2008-03-09 10:31:52 +0000 @@ -160,7 +160,9 @@ len_ = newLength; - if(len_ == 0 && buf_ == NULL) return; // buf_ may be NULL on zero-length strings. + // buf_ may be NULL on zero-length strings. + if(len_ == 0 && buf_ == NULL) return; + buf_[newLength] = '\0'; } === modified file 'src/SwapDir.h' --- src/SwapDir.h 2007-09-28 06:22:37 +0000 +++ src/SwapDir.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: SwapDir.h,v 1.15 2007/09/28 00:22:37 hno Exp $ * @@ -30,7 +29,6 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_SWAPDIR_H #define SQUID_SWAPDIR_H @@ -92,8 +90,8 @@ }; /* migrating from the Config based list of swapdirs */ -extern void allocate_new_swapdir(_SquidConfig::_cacheSwap *); -extern void free_cachedir(_SquidConfig::_cacheSwap * swap); +extern void allocate_new_swapdir(SquidConfig::_cacheSwap *); +extern void free_cachedir(SquidConfig::_cacheSwap * swap); SQUIDCEXTERN OBJH storeDirStats; SQUIDCEXTERN char *storeDirSwapLogFile(int, const char *); SQUIDCEXTERN char *storeSwapFullPath(int, char *); === modified file 'src/access_log.cc' --- src/access_log.cc 2008-01-20 15:54:28 +0000 +++ src/access_log.cc 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: access_log.cc,v 1.130 2008/01/20 08:54:28 amosjeffries Exp $ * @@ -396,8 +395,10 @@ LOG_QUOTE_RAW }; -struct _logformat_token +/* FIXME: public class so we can pre-define its type. */ +class logformat_token { +public: logformat_bcode_t type; union { char *string; @@ -416,14 +417,11 @@ enum log_quote quote; -unsigned int left: - 1; - -unsigned int space: - 1; - -unsigned int zero: - 1; +unsigned int left:1; + +unsigned int space:1; + +unsigned int zero:1; int divisor; logformat_token *next; /* todo: move from linked list to array */ }; === modified file 'src/acl.cc' --- src/acl.cc 2008-01-20 15:54:28 +0000 +++ src/acl.cc 2008-03-09 10:31:52 +0000 @@ -32,11 +32,19 @@ * */ +#if 0 #include "squid.h" +#include "HttpRequest.h" +#endif + #include "ACL.h" #include "ACLChecklist.h" #include "ConfigParser.h" -#include "HttpRequest.h" +#include "dlink.h" +/* for special-case PURGE test */ +#include "HttpRequestMethod.h" +/* for Vector<> Instances */ +#include "assert.h" const char *AclMatchedName = NULL; === modified file 'src/acl_noncore.cc' --- src/acl_noncore.cc 2007-09-01 11:56:37 +0000 +++ src/acl_noncore.cc 2008-03-09 10:31:52 +0000 @@ -285,7 +285,7 @@ } /* maex@space.net (06.09.1996) - * destroy an _acl_deny_info_list */ + * destroy an acl_deny_info_list */ void aclDestroyDenyInfoList(acl_deny_info_list ** list) === modified file 'src/auth/Makefile.am' --- src/auth/Makefile.am 2005-10-23 17:55:31 +0000 +++ src/auth/Makefile.am 2008-03-09 10:31:52 +0000 @@ -19,3 +19,14 @@ INCLUDES = -I. -I$(top_builddir)/include -I$(top_srcdir)/include \ -I$(top_srcdir)/src + +check_PROGRAMS= testHeaders + +## Special Universal .h dependency test script +## aborts if error encountered +testHeaders: basic/*.h digest/*.h ntlm/*.h negotiate/*.h + ../../test-suite/testheaders.sh "$(CXXCOMPILE)" "basic" || exit 1 + ../../test-suite/testheaders.sh "$(CXXCOMPILE)" "digest" || exit 1 + ../../test-suite/testheaders.sh "$(CXXCOMPILE)" "ntlm" || exit 1 + ../../test-suite/testheaders.sh "$(CXXCOMPILE)" "negotiate" || exit 1 +## ./ has no .h files === modified file 'src/auth/basic/auth_basic.cc' --- src/auth/basic/auth_basic.cc 2008-02-13 06:17:50 +0000 +++ src/auth/basic/auth_basic.cc 2008-03-09 10:31:52 +0000 @@ -360,11 +360,11 @@ CBDATA_TYPE(AuthenticateStateData); -static auth_user_t * +static AuthUser * authBasicAuthUserFindUsername(const char *username) { AuthUserHashPointer *usernamehash; - debugs(29, 9, "authBasicAuthUserFindUsername: Looking for user '" << username << "'"); + debugs(29, 9, HERE << "Looking for user '" << username << "'"); if (username && (usernamehash = static_cast(hash_lookup(proxy_auth_username_cache, username)))) { while (usernamehash) { @@ -570,7 +570,7 @@ /* now lookup and see if we have a matching auth_user structure in * memory. */ - auth_user_t *auth_user; + AuthUser *auth_user; if ((auth_user = authBasicAuthUserFindUsername(local_basic.username())) == NULL) { auth_user = local_basic.makeCachedFrom(); === modified file 'src/auth/digest/auth_digest.cc' --- src/auth/digest/auth_digest.cc 2008-02-13 06:17:50 +0000 +++ src/auth/digest/auth_digest.cc 2008-03-09 10:31:52 +0000 @@ -456,12 +456,12 @@ } /* USER related functions */ -static auth_user_t * +static AuthUser * authDigestUserFindUsername(const char *username) { - auth_user_hash_pointer *usernamehash; - auth_user_t *auth_user; - debugs(29, 9, "authDigestUserFindUsername: Looking for user '" << username << "'"); + AuthUserHashPointer *usernamehash; + AuthUser *auth_user; + debugs(29, 9, HERE << "Looking for user '" << username << "'"); if (username && (usernamehash = static_cast < auth_user_hash_pointer * >(hash_lookup(proxy_auth_username_cache, username)))) { while ((usernamehash->user()->auth_type != AUTH_DIGEST) && @@ -483,11 +483,9 @@ static void authDigestUserShutdown(void) { - /* - * Future work: the auth framework could flush it's cache - */ - auth_user_hash_pointer *usernamehash; - auth_user_t *auth_user; + /** \todo Future work: the auth framework could flush it's cache */ + AuthUserHashPointer *usernamehash; + AuthUser *auth_user; hash_first(proxy_auth_username_cache); while ((usernamehash = ((auth_user_hash_pointer *) hash_next(proxy_auth_username_cache)))) { @@ -498,11 +496,11 @@ } } -/* delete the digest request structure. Does NOT delete related structures */ +/** delete the digest request structure. Does NOT delete related structures */ void digestScheme::done() { - /* TODO: this should be a Config call. */ + /** \todo this should be a Config call. */ if (digestauthenticators) helperShutdown(digestauthenticators); @@ -570,12 +568,12 @@ return 0; } -/* log a digest user in +/** log a digest user in */ void AuthDigestUserRequest::authenticate(HttpRequest * request, ConnStateData * conn, http_hdr_type type) { - auth_user_t *auth_user; + AuthUser *auth_user; AuthDigestUserRequest *digest_request; digest_user_h *digest_user; @@ -1301,7 +1299,7 @@ /* find the user */ digest_user_h *digest_user; - auth_user_t *auth_user; + AuthUser *auth_user; if ((auth_user = authDigestUserFindUsername(username)) == NULL) { /* the user doesn't exist in the username cache yet */ @@ -1380,28 +1378,24 @@ DigestUser::DigestUser (AuthConfig *config) : AuthUser (config), HA1created (0) {} -auth_user_t * +AuthUser * AuthDigestUserRequest::authUser() const { return const_cast(user()); } void -AuthDigestUserRequest::authUser(auth_user_t *aUser) +AuthDigestUserRequest::authUser(AuthUser *aUser) { - assert (!authUser()); + assert(!authUser()); user(aUser); - - user()->lock() - - ; + user()->lock(); } AuthDigestUserRequest::CredentialsState AuthDigestUserRequest::credentials() const { return credentials_ok; - } void @@ -1417,7 +1411,7 @@ credentials_ok (Unchecked) {} -/* delete the digest request structure. Does NOT delete related structures */ +/** delete the digest request structure. Does NOT delete related structures */ AuthDigestUserRequest::~AuthDigestUserRequest() { safe_free (nonceb64); === modified file 'src/auth/digest/auth_digest.h' --- src/auth/digest/auth_digest.h 2008-02-27 04:49:32 +0000 +++ src/auth/digest/auth_digest.h 2008-03-09 10:31:52 +0000 @@ -44,7 +44,7 @@ }; -MEMPROXY_CLASS_INLINE(DigestUser) /**DOCS_NOSEMI*/ +MEMPROXY_CLASS_INLINE(DigestUser); typedef class DigestUser digest_user_h; @@ -74,13 +74,13 @@ virtual const AuthUser *user() const {return _theUser;} - virtual void user (AuthUser *aUser) {_theUser=dynamic_cast(aUser);} + virtual void user(AuthUser *aUser) {_theUser=dynamic_cast(aUser);} CredentialsState credentials() const; void credentials(CredentialsState); - void authUser(auth_user_t *); - auth_user_t *authUser() const; + void authUser(AuthUser *); + AuthUser *authUser() const; char *nonceb64; /* "dcd98b7102dd2f0e8b11d0f600bfb0c093" */ char *cnonce; /* "0a4f113b" */ === modified file 'src/auth/negotiate/auth_negotiate.cc' --- src/auth/negotiate/auth_negotiate.cc 2008-02-27 04:49:32 +0000 +++ src/auth/negotiate/auth_negotiate.cc 2008-03-09 10:31:52 +0000 @@ -479,8 +479,8 @@ debugs(29, 4, "AuthNegotiateUserRequest::authenticate: authenticated user " << negotiate_user->username()); /* see if this is an existing user with a different proxy_auth * string */ - auth_user_hash_pointer *usernamehash = static_cast(hash_lookup(proxy_auth_username_cache, negotiate_user->username())); - auth_user_t *local_auth_user = negotiate_request->user(); + AuthUserHashPointer *usernamehash = static_cast(hash_lookup(proxy_auth_username_cache, negotiate_user->username())); + AuthUser *local_auth_user = negotiate_request->user(); while (usernamehash && (usernamehash->user()->auth_type != AUTH_NEGOTIATE || strcmp(usernamehash->user()->username(), negotiate_user->username()) != 0)) usernamehash = static_cast(usernamehash->next); if (usernamehash) { @@ -556,14 +556,14 @@ } -/* send the initial data to a stateful negotiate authenticator module */ +/** send the initial data to a stateful negotiate authenticator module */ void AuthNegotiateUserRequest::module_start(RH * handler, void *data) { authenticateStateData *r = NULL; static char buf[8192]; negotiate_user_t *negotiate_user; - auth_user_t *auth_user = user(); + AuthUser *auth_user = user(); assert(data); assert(handler); @@ -678,8 +678,8 @@ { const char *proxy_auth, *blob; - /* TODO: rename this!! */ - auth_user_t *local_auth_user; + /** \todo rename this!! */ + AuthUser *local_auth_user; negotiate_user_t *negotiate_user; local_auth_user = user(); @@ -688,7 +688,7 @@ negotiate_user = dynamic_cast(local_auth_user); assert (this); - /* Check that we are in the client side, where we can generate + /** Check that we are in the client side, where we can generate * auth challenges */ if (conn == NULL) { === modified file 'src/auth/ntlm/auth_ntlm.cc' --- src/auth/ntlm/auth_ntlm.cc 2008-02-13 06:17:50 +0000 +++ src/auth/ntlm/auth_ntlm.cc 2008-03-09 10:31:52 +0000 @@ -414,7 +414,7 @@ /* see if this is an existing user with a different proxy_auth * string */ auth_user_hash_pointer *usernamehash = static_cast(hash_lookup(proxy_auth_username_cache, ntlm_user->username())); - auth_user_t *local_auth_user = ntlm_request->user(); + AuthUser *local_auth_user = ntlm_request->user(); while (usernamehash && (usernamehash->user()->auth_type != AUTH_NTLM || strcmp(usernamehash->user()->username(), ntlm_user->username()) != 0)) usernamehash = static_cast(usernamehash->next); if (usernamehash) { @@ -485,7 +485,7 @@ authenticateStateData *r = NULL; static char buf[8192]; ntlm_user_t *ntlm_user; - auth_user_t *auth_user = user(); + AuthUser *auth_user = user(); assert(data); assert(handler); @@ -601,7 +601,7 @@ const char *proxy_auth, *blob; /* TODO: rename this!! */ - auth_user_t *local_auth_user; + AuthUser *local_auth_user; ntlm_user_t *ntlm_user; local_auth_user = user(); === modified file 'src/authenticate.cc' --- src/authenticate.cc 2008-02-27 04:49:32 +0000 +++ src/authenticate.cc 2008-03-09 10:31:52 +0000 @@ -113,41 +113,41 @@ } } +/** + \retval 0 not in use + \retval ? in use + */ int -authenticateAuthUserInuse(auth_user_t * auth_user) -/* returns 0 for not in use */ +authenticateAuthUserInuse(AuthUser * auth_user) { assert(auth_user != NULL); return auth_user->references; } void -authenticateAuthUserMerge(auth_user_t * from, auth_user_t * to) +authenticateAuthUserMerge(AuthUser * from, AuthUser * to) { to->absorb (from); } -/* - * authenticateUserCacheRestart() cleans all config-dependent data from the - * auth_user cache. It DOES NOT Flush the user cache. +/** + * Cleans all config-dependent data from the auth_user cache. + \note It DOES NOT Flush the user cache. */ - void authenticateUserCacheRestart(void) { AuthUserHashPointer *usernamehash; - auth_user_t *auth_user; - debugs(29, 3, "authenticateUserCacheRestart: Clearing config dependent cache data."); + AuthUser *auth_user; + debugs(29, 3, HERE << "Clearing config dependent cache data."); hash_first(proxy_auth_username_cache); while ((usernamehash = ((AuthUserHashPointer *) hash_next(proxy_auth_username_cache)))) { auth_user = usernamehash->user(); debugs(29, 5, "authenticateUserCacheRestat: Clearing cache ACL results for user: " << auth_user->username()); } - } -/* _auth_user_hash_pointe */ void AuthUserHashPointer::removeFromCache(void *usernamehash_p) @@ -165,14 +165,14 @@ */ } -AuthUserHashPointer::AuthUserHashPointer (AuthUser * anAuth_user): - auth_user (anAuth_user) +AuthUserHashPointer::AuthUserHashPointer(AuthUser * anAuth_user): + auth_user(anAuth_user) { key = (void *)anAuth_user->username(); next = NULL; hash_join(proxy_auth_username_cache, (hash_link *) this); - /* lock for presence in the cache */ + /** lock for presence in the cache */ auth_user->lock(); } @@ -181,5 +181,3 @@ { return auth_user; } - - === modified file 'src/authenticate.h' --- src/authenticate.h 2008-02-27 04:49:32 +0000 +++ src/authenticate.h 2008-03-09 10:31:52 +0000 @@ -54,7 +54,7 @@ static void removeFromCache (void *anAuthUserHashPointer); MEMPROXY_CLASS(AuthUserHashPointer); - AuthUserHashPointer (AuthUser *); + AuthUserHashPointer(AuthUser *); AuthUser *user() const; @@ -62,7 +62,7 @@ AuthUser *auth_user; }; -MEMPROXY_CLASS_INLINE(AuthUserHashPointer) /**DOCS_NOSEMI*/ +MEMPROXY_CLASS_INLINE(AuthUserHashPointer); class ConnStateData; @@ -79,7 +79,7 @@ * subsumed by the C++ interface \todo does 'subsumed' mean deprecated use a C++ API call? */ -extern void authenticateAuthUserMerge(auth_user_t *, auth_user_t *); +extern void authenticateAuthUserMerge(AuthUser *, AuthUser *); /// \ingroup AuthAPI extern void authenticateInit(authConfig *); @@ -88,7 +88,7 @@ /// \ingroup AuthAPI extern void authenticateShutdown(void); /// \ingroup AuthAPI -extern int authenticateAuthUserInuse(auth_user_t * auth_user); +extern int authenticateAuthUserInuse(AuthUser * auth_user); /// \ingroup AuthAPI extern void authenticateFreeProxyAuthUserACLResults(void *data); === modified file 'src/cache_cf.cc' --- src/cache_cf.cc 2008-03-04 19:00:36 +0000 +++ src/cache_cf.cc 2008-03-09 10:31:52 +0000 @@ -1378,7 +1378,7 @@ #endif static void -dump_cachedir(StoreEntry * entry, const char *name, _SquidConfig::_cacheSwap swap) +dump_cachedir(StoreEntry * entry, const char *name, SquidConfig::_cacheSwap swap) { SwapDir *s; int i; @@ -1465,7 +1465,7 @@ } static void -parse_cachedir(_SquidConfig::_cacheSwap * swap) +parse_cachedir(SquidConfig::_cacheSwap * swap) { char *type_str; char *path_str; === modified file 'src/client_side_reply.cc' --- src/client_side_reply.cc 2008-02-17 00:42:27 +0000 +++ src/client_side_reply.cc 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: client_side_reply.cc,v 1.154 2008/02/16 17:42:27 rousskov Exp $ * @@ -33,6 +32,10 @@ * */ +/* for ClientActiveRequests global */ +#include "dlink.h" + +/* old includes without reasons given. */ #include "squid.h" #include "client_side_reply.h" #include "errorpage.h" @@ -41,7 +44,6 @@ #include "HttpReply.h" #include "HttpRequest.h" #include "forward.h" - #include "clientStream.h" #include "AuthUserRequest.h" #if USE_SQUID_ESI === modified file 'src/debug.cc' --- src/debug.cc 2008-02-27 01:43:30 +0000 +++ src/debug.cc 2008-03-09 10:31:52 +0000 @@ -31,12 +31,17 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - +#if 0 #include "squid.h" +#endif + #include "Debug.h" #include "SquidTime.h" #include +/* for Config */ +#include "structs.h" + int Debug::Levels[MAX_DEBUG_SECTIONS]; int Debug::level; === modified file 'src/defines.h' --- src/defines.h 2007-12-15 06:11:41 +0000 +++ src/defines.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: defines.h,v 1.123 2007/12/14 23:11:46 amosjeffries Exp $ * @@ -30,7 +29,6 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_DEFINES_H #define SQUID_DEFINES_H @@ -41,6 +39,10 @@ #define FALSE 0 #endif +#ifndef BUFSIZ +#define BUFSIZ 4096 /* make unreasonable guess */ +#endif + #define ACL_NAME_SZ 32 #define BROWSERNAMELEN 128 @@ -59,7 +61,6 @@ /* Select types. */ #define COMM_SELECT_READ (0x1) #define COMM_SELECT_WRITE (0x2) -#define MAX_DEBUG_SECTIONS 100 #define COMM_NONBLOCKING 0x01 #define COMM_NOCLOEXEC 0x02 === added file 'src/dlink.cc' --- src/dlink.cc 1970-01-01 00:00:00 +0000 +++ src/dlink.cc 2008-03-09 10:31:52 +0000 @@ -0,0 +1,101 @@ +/* + * $Id$ + */ +#include "dlink.h" + +/* dlink are Mem-pooled */ +#include "MemPool.h" +/* for xstrdup() */ +#include "util.h" + + +dlink_list ClientActiveRequests; + +MemAllocator *dlink_node_pool = NULL; + +dlink_node * +dlinkNodeNew() +{ + if (dlink_node_pool == NULL) + dlink_node_pool = memPoolCreate("Dlink list nodes", sizeof(dlink_node)); + + /* where should we call delete dlink_node_pool;dlink_node_pool = NULL; */ + return (dlink_node *)dlink_node_pool->alloc(); +} + +/** The node needs to be unlinked FIRST */ +void +dlinkNodeDelete(dlink_node * m) +{ + if (m == NULL) + return; + + dlink_node_pool->free(m); +} + +void +dlinkAdd(void *data, dlink_node * m, dlink_list * list) +{ + m->data = data; + m->prev = NULL; + m->next = list->head; + + if (list->head) + list->head->prev = m; + + list->head = m; + + if (list->tail == NULL) + list->tail = m; +} + +void +dlinkAddAfter(void *data, dlink_node * m, dlink_node * n, dlink_list * list) +{ + m->data = data; + m->prev = n; + m->next = n->next; + + if (n->next) + n->next->prev = m; + else { + assert(list->tail == n); + list->tail = m; + } + + n->next = m; +} + +void +dlinkAddTail(void *data, dlink_node * m, dlink_list * list) +{ + m->data = data; + m->next = NULL; + m->prev = list->tail; + + if (list->tail) + list->tail->next = m; + + list->tail = m; + + if (list->head == NULL) + list->head = m; +} + +void +dlinkDelete(dlink_node * m, dlink_list * list) +{ + if (m->next) + m->next->prev = m->prev; + + if (m->prev) + m->prev->next = m->next; + + if (m == list->head) + list->head = m->next; + + if (m == list->tail) + list->tail = m->prev; + + m->next = m->prev = NULL; +} === modified file 'src/dlink.h' --- src/dlink.h 2006-04-22 19:07:36 +0000 +++ src/dlink.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: dlink.h,v 1.1 2006/04/22 13:07:36 robertc Exp $ * @@ -30,7 +29,6 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_DLINK_H #define SQUID_DLINK_H @@ -47,14 +45,22 @@ dlink_node *next; }; -struct _dlink_list +struct dlink_list { dlink_node *head; dlink_node *tail; }; -class dlink_node; - -typedef struct _dlink_list dlink_list; +/* mported form globals.h */ +extern dlink_list ClientActiveRequests; + +/* imported directly from protos.h */ + +SQUIDCEXTERN void dlinkAdd(void *data, dlink_node *, dlink_list *); +SQUIDCEXTERN void dlinkAddAfter(void *, dlink_node *, dlink_node *, dlink_list *); +SQUIDCEXTERN void dlinkAddTail(void *data, dlink_node *, dlink_list *); +SQUIDCEXTERN void dlinkDelete(dlink_node * m, dlink_list * list); +SQUIDCEXTERN void dlinkNodeDelete(dlink_node * m); +SQUIDCEXTERN dlink_node *dlinkNodeNew(void); #endif /* SQUID_DLINK_H */ === modified file 'src/enums.h' --- src/enums.h 2008-02-27 04:49:32 +0000 +++ src/enums.h 2008-03-09 10:31:52 +0000 @@ -429,104 +429,6 @@ MEM_MAX } mem_type; -/** - \ingroup SwapStoreAPI - \todo AYJ: for critical lists like this we should use A=64,B=65 etc to enforce and reserve values. - \note NOTE! We must preserve the order of this list! - * - \section StoreSwapMeta Store "swap meta" Description - \par - * "swap meta" refers to a section of meta data stored at the beginning - * of an object that is stored on disk. This meta data includes information - * such as the object's cache key (MD5), URL, and part of the StoreEntry - * structure. - * - \par - * The meta data is stored using a TYPE-LENGTH-VALUE format. That is, - * each chunk of meta information consists of a TYPE identifier, a - * LENGTH field, and then the VALUE (which is LENGTH octets long). - */ -enum { - /** - * Just a placeholder for the zeroth value. It is never used on disk. - */ - STORE_META_VOID, - - /** - \deprecated - * This represents the case when we use the URL as the cache - * key, as Squid-1.1 does. Currently we don't support using - * a URL as a cache key, so this is not used. - */ - STORE_META_KEY_URL, - - /** - \deprecated - * For a brief time we considered supporting SHA (secure - * hash algorithm) as a cache key. Nobody liked it, and - * this type is not currently used. - */ - STORE_META_KEY_SHA, - - /** - * This represents the MD5 cache key that Squid currently uses. - * When Squid opens a disk file for reading, it can check that - * this MD5 matches the MD5 of the user's request. If not, then - * something went wrong and this is probably the wrong object. - */ - STORE_META_KEY_MD5, - - /** - * The object's URL. This also may be matched against a user's - * request for cache hits to make sure we got the right object. - */ - STORE_META_URL, - - /** - * This is the "standard metadata" for an object. - * Really its just this middle chunk of the StoreEntry structure: - \code - time_t timestamp; - time_t lastref; - time_t expires; - time_t lastmod; - size_t swap_file_sz; - u_short refcount; - u_short flags; - \endcode - */ - STORE_META_STD, - - /** - * Reserved for future hit-metering (RFC 2227) stuff - */ - STORE_META_HITMETERING, - - /// \todo DOCS: document. - STORE_META_VALID, - - /** - * Stores Vary request headers - */ - STORE_META_VARY_HEADERS, - - /** - * Updated version of STORE_META_STD, with support for >2GB objects. - * As STORE_META_STD except that the swap_file_sz is a 64-bit integer instead of 32-bit. - */ - STORE_META_STD_LFS, - - /** - \deprecated - * Object size, not implemented, squid26 compatibility - */ - STORE_META_OBJSIZE, - - STORE_META_STOREURL, /* the store url, if different to the normal URL */ - STORE_META_VARY_ID, /* Unique ID linking variants */ - STORE_META_END -}; - enum { STORE_LOG_CREATE, STORE_LOG_SWAPIN, === modified file 'src/fs/Makefile.am' --- src/fs/Makefile.am 2008-01-08 18:10:48 +0000 +++ src/fs/Makefile.am 2008-03-09 10:31:52 +0000 @@ -32,6 +32,18 @@ INCLUDES = -I. -I$(top_builddir)/include -I$(top_srcdir)/include \ -I$(top_srcdir)/src +check_PROGRAMS=testHeaders + +## Special Universal .h dependency test script +## aborts if error encountered +testHeaders: ufs/*.h coss/*.h + ../../test-suite/testheaders.sh "$(CXXCOMPILE)" "ufs" || exit 1 + ../../test-suite/testheaders.sh "$(CXXCOMPILE)" "coss" || exit 1 +## diskd/ has no .h files +## aufs/ has no .h files +## ./ has no .h files + + ## targets below to emulate distributed makefiles coss/all: libcoss.a coss/clean: clean === modified file 'src/fs/aufs/StoreFSaufs.cc' --- src/fs/aufs/StoreFSaufs.cc 2008-02-27 04:49:32 +0000 +++ src/fs/aufs/StoreFSaufs.cc 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: StoreFSaufs.cc,v 1.3 2008/02/26 21:49:43 amosjeffries Exp $ * @@ -34,10 +33,16 @@ * Copyright (c) 2003, Robert Collins */ +#if 0 #include "squid.h" #include "StoreFileSystem.h" +#include "DiskIO/DiskIOModule.h" +#endif + #include "fs/ufs/StoreFSufs.h" -#include "DiskIO/DiskIOModule.h" + +/** \todo FIXME: break UFSSwapDir out so we don't need all the guff */ +#include "fs/ufs/ufscommon.h" /** \defgroup AUFS AUFS Storage Filesystem (UFS Based) === modified file 'src/fs/coss/CossSwapDir.h' --- src/fs/coss/CossSwapDir.h 2008-02-27 04:49:32 +0000 +++ src/fs/coss/CossSwapDir.h 2008-03-09 10:31:52 +0000 @@ -1,8 +1,20 @@ +/* + * $Id$ + */ #ifndef __COSSSWAPDIR_H__ #define __COSSSWAPDIR_H__ +class StoreEntry; +class CossSwapDir; +class CossMemBuf; +class DiskIOStrategy; +class DiskIOModule; +class ConfigOptionVector; +class DiskFile; + #include "SwapDir.h" -#include "StoreSearch.h" +#include "DiskIO/IORequestor.h" + #ifndef COSS_MEMBUF_SZ #define COSS_MEMBUF_SZ 1048576 @@ -14,18 +26,6 @@ #define COSS_ALLOC_ALLOCATE 1 #define COSS_ALLOC_REALLOC 2 -class CossSwapDir; - - -class CossMemBuf; - -class DiskIOStrategy; - -class DiskIOModule; - -class ConfigOptionVector; -#include "DiskIO/DiskFile.h" -#include "DiskIO/IORequestor.h" /// \ingroup COSS class CossSwapDir : public SwapDir, public IORequestor @@ -100,6 +100,9 @@ /// \ingroup COSS extern void storeCossStartMembuf(CossSwapDir * SD); + +#include "StoreSearch.h" + /// \ingroup COSS class StoreSearchCoss : public StoreSearch { === modified file 'src/fs/coss/StoreFScoss.h' --- src/fs/coss/StoreFScoss.h 2008-02-27 04:49:32 +0000 +++ src/fs/coss/StoreFScoss.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: StoreFScoss.h,v 1.4 2008/02/26 21:49:43 amosjeffries Exp $ * @@ -30,11 +29,10 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_STOREFSCOSS_H #define SQUID_STOREFSCOSS_H -#include "StoreFileSystem.h" +class StoreEntry; /** \defgroup COSS COSS Storage Filesystem @@ -72,6 +70,11 @@ open, create, close, unlink, read, write, stripe_write; }; + +class CacheManager; + +#include "StoreFileSystem.h" + /// \ingroup COSS, FileSystems class StoreFScoss : public StoreFileSystem { === modified file 'src/fs/diskd/StoreFSdiskd.cc' --- src/fs/diskd/StoreFSdiskd.cc 2008-02-27 04:49:32 +0000 +++ src/fs/diskd/StoreFSdiskd.cc 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: StoreFSdiskd.cc,v 1.3 2008/02/26 21:49:44 amosjeffries Exp $ * @@ -34,10 +33,15 @@ * Copyright (c) 2003, Robert Collins */ - +#if 0 #include "StoreFileSystem.h" +#include "DiskIO/DiskIOModule.h" +#endif + #include "fs/ufs/StoreFSufs.h" -#include "DiskIO/DiskIOModule.h" + +/** \todo FIXME: break UFSSwapDir out so we don;t need all the extras */ +#include "fs/ufs/ufscommon.h" /** \defgroup diskd diskd Storage Filesystem (UFS Based) === modified file 'src/fs/ufs/StoreFSufs.cc' --- src/fs/ufs/StoreFSufs.cc 2004-12-20 23:30:12 +0000 +++ src/fs/ufs/StoreFSufs.cc 2008-03-09 10:31:52 +0000 @@ -1,5 +1,3 @@ - - /* * $Id: StoreFSufs.cc,v 1.2 2004/12/20 16:30:45 robertc Exp $ * @@ -35,10 +33,18 @@ * Copyright (c) 2003, Robert Collins */ - +#if 0 #include "StoreFileSystem.h" +#endif + #include "fs/ufs/StoreFSufs.h" + +#if 0 #include "DiskIO/DiskIOModule.h" +#endif + +/** \todo FIXME: break UFSSwapDir out so we don't build all the extras */ +#include "fs/ufs/ufscommon.h" static StoreFSufs UfsInstance("Blocking", "ufs"); === modified file 'src/fs/ufs/StoreFSufs.h' --- src/fs/ufs/StoreFSufs.h 2008-02-27 04:49:32 +0000 +++ src/fs/ufs/StoreFSufs.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: StoreFSufs.h,v 1.6 2008/02/26 21:49:45 amosjeffries Exp $ * @@ -30,19 +29,18 @@ * * Copyright (c) 2003, Robert Collins */ - #ifndef SQUID_STOREFSUFS_H #define SQUID_STOREFSUFS_H -#include "squid.h" -#include "ufscommon.h" -#include "DiskIO/DiskIOModule.h" - /** \defgroup UFS UFS Storage Filesystem \ingroup FileSystems */ +class DiskIOModule; + +#include "StoreFileSystem.h" + /** \ingroup UFS, FileSystems * === modified file 'src/fs/ufs/ufscommon.h' --- src/fs/ufs/ufscommon.h 2008-02-27 04:49:32 +0000 +++ src/fs/ufs/ufscommon.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: ufscommon.h,v 1.13 2008/02/26 21:49:45 amosjeffries Exp $ * @@ -29,26 +28,20 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_UFSCOMMON_H #define SQUID_UFSCOMMON_H -#include "squid.h" -#include "event.h" - -#define DefaultLevelOneDirs 16 -#define DefaultLevelTwoDirs 256 -#define STORE_META_BUFSZ 4096 - -/* Common UFS routines */ -#include "SwapDir.h" -#include "StoreSearch.h" + +#define DefaultLevelOneDirs 16 +#define DefaultLevelTwoDirs 256 +#define STORE_META_BUFSZ 4096 class UFSStrategy; - class ConfigOptionVector; - class DiskIOModule; +class StoreSearch; + +#include "SwapDir.h" /// \ingroup UFS class UFSSwapDir : public SwapDir @@ -293,8 +286,12 @@ void doWrite(); }; -MEMPROXY_CLASS_INLINE(UFSStoreState::_queued_read) /**DOCS_NOSEMI*/ -MEMPROXY_CLASS_INLINE(UFSStoreState::_queued_write) /**DOCS_NOSEMI*/ +MEMPROXY_CLASS_INLINE(UFSStoreState::_queued_read); +MEMPROXY_CLASS_INLINE(UFSStoreState::_queued_write); + + + +#include "StoreSearch.h" /// \ingroup UFS class StoreSearchUFS : public StoreSearch @@ -334,6 +331,7 @@ bool _done; }; + class StoreSwapLogData; /// \ingroup UFS @@ -362,6 +360,7 @@ } }; + /// \ingroup UFS class RebuildState : public RefCountable { === modified file 'src/globals.h' --- src/globals.h 2008-02-12 05:36:52 +0000 +++ src/globals.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: globals.h,v 1.143 2008/02/11 22:36:52 rousskov Exp $ * @@ -30,26 +29,38 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_GLOBALS_H #define SQUID_GLOBALS_H +#if HAVE_STDIO_H +#include +#endif + +#include "rfc2181.h" + +/* for ERROR_BUF_SZ, BUFSIZ, MAXHTTPPORTS */ +#include "defines.h" + +/* for iostats, StatCounters */ +#include "structs.h" + + #ifdef __cplusplus extern "C" { #endif extern FILE *debug_log; /* NULL */ - extern SquidConfig Config; - extern SquidConfig2 Config2; +//MOVED:structs.h extern SquidConfig Config; +//MOVED:structs.h extern SquidConfig2 Config2; extern char *ConfigFile; /* NULL */ extern char *IcpOpcodeStr[]; extern const char *dns_error_message; /* NULL */ extern const char *log_tags[]; extern char tmp_error_buf[ERROR_BUF_SZ]; extern char *volatile debug_options; /* NULL */ - extern char ThisCache[SQUIDHOSTNAMELEN << 1]; - extern char ThisCache2[SQUIDHOSTNAMELEN << 1]; + extern char ThisCache[RFC2181_MAXHOSTNAMELEN << 1]; + extern char ThisCache2[RFC2181_MAXHOSTNAMELEN << 1]; extern char config_input_line[BUFSIZ]; extern const char *DefaultConfigFile; /* DEFAULT_CONFIG_FILE */ extern const char *cfg_filename; /* NULL */ @@ -67,6 +78,7 @@ extern const char *pingStatusStr[]; extern const char *storeStatusStr[]; extern const char *swapStatusStr[]; + class fde; extern fde *fd_table; /* NULL */ extern int Biggest_FD; /* -1 */ extern int Number_FD; /* 0 */ @@ -79,7 +91,7 @@ extern int config_lineno; /* 0 */ extern int do_mallinfo; /* 0 */ extern int opt_reuseaddr; /* 1 */ - extern int icmp_sock; /* -1 */ +//DEAD extern int icmp_sock; /* -1 */ extern int neighbors_do_private_keys; /* 1 */ extern int opt_catch_signals; /* 1 */ extern int opt_debug_stderr; /* -1 */ @@ -109,11 +121,10 @@ extern int n_disk_objects; /* 0 */ extern iostats IOStats; - extern struct _acl_deny_info_list *DenyInfoList; /* NULL */ - - extern IPAddress theOutICPAddr; - - extern IPAddress theOutSNMPAddr; + extern struct acl_deny_info_list *DenyInfoList; /* NULL */ + +//MOVED:icp_v2.cc extern IPAddress theOutICPAddr; +//MOVED:snmp_core.cc extern IPAddress theOutSNMPAddr; extern struct timeval squid_start; extern int shutting_down; /* 0 */ @@ -128,7 +139,7 @@ extern double request_failure_ratio; /* 0.0 */ extern int store_hash_buckets; /* 0 */ extern hash_table *store_table; /* NULL */ - extern dlink_list ClientActiveRequests; +//MOVED:dlink.h extern dlink_list ClientActiveRequests; extern int hot_obj_count; /* 0 */ extern const int CacheDigestHashFuncCount; /* 4 */ extern CacheDigest *store_digest; /* NULL */ === modified file 'src/icp_v2.cc' --- src/icp_v2.cc 2008-02-27 04:49:32 +0000 +++ src/icp_v2.cc 2008-03-09 10:31:52 +0000 @@ -48,6 +48,7 @@ #include "wordlist.h" #include "SquidTime.h" #include "SwapDir.h" +#include "IPAddress.h" /// \ingroup ServerProtocolICPInternal2 static void icpLogIcp(const IPAddress &, log_type, int, const char *, int); @@ -67,6 +68,9 @@ /// \ingroup ServerProtocolICPInternal2 static icpUdpData *IcpQueueTail = NULL; +/// \ingroup ServerProtocolICPInternal2 +IPAddress theOutICPAddr; + /* icp_common_t */ _icp_common_t::_icp_common_t() : opcode(ICP_INVALID), version(0), length(0), reqnum(0), flags(0), pad(0), shostid(0) {} === modified file 'src/pconn.h' --- src/pconn.h 2007-12-27 08:03:13 +0000 +++ src/pconn.h 2008-03-09 10:31:52 +0000 @@ -1,19 +1,35 @@ - +/* + * $Id$ + */ #ifndef SQUID_PCONN_H #define SQUID_PCONN_H -/* forward decls */ +/** + \defgroup PConnAPI Persistent Connection API + \ingroup Component + * + \todo CLEANUP: Break multiple classes out of the generic pconn.h header + */ class CacheManager; - class PconnPool; +/* for CBDATA_CLASS2() macros */ +#include "cbdata.h" +/* for hash_link */ +#include "hash.h" +/* for IOCB */ +#include "comm.h" + +/// \ingroup PConnAPI #define MAX_NUM_PCONN_POOLS 10 + +/// \ingroup PConnAPI #define PCONN_HIST_SZ (1<<16) +/// \ingroup PConnAPI class IdleConnList { - public: IdleConnList(const char *key, PconnPool *parent); ~IdleConnList(); @@ -30,7 +46,7 @@ static PF timeout; public: - hash_link hash; /* must be first */ + hash_link hash; /** must be first */ private: int *fds; @@ -41,6 +57,15 @@ CBDATA_CLASS2(IdleConnList); }; + +class IPAddress; +class StoreEntry; +class IdleConnLimit; + +/* for hash_table */ +#include "hash.h" + +/// \ingroup PConnAPI class PconnPool { @@ -64,22 +89,27 @@ }; + +class CacheManager; +class StoreEntry; +class PconnPool; + +/// \ingroup PConnAPI class PconnModule { public: - /* the module is a singleton until we have instance based cachemanager + /** the module is a singleton until we have instance based cachemanager * management */ static PconnModule * GetInstance(); - /* A thunk to the still C like CacheManager callback api. */ + /** A thunk to the still C like CacheManager callback api. */ static void DumpWrapper(StoreEntry *e); PconnModule(); void registerWithCacheManager(CacheManager & manager); - void add - (PconnPool *); + void add(PconnPool *); OBJH dump; === modified file 'src/protos.h' --- src/protos.h 2008-02-27 04:49:32 +0000 +++ src/protos.h 2008-03-09 10:31:52 +0000 @@ -29,7 +29,6 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_PROTOS_H #define SQUID_PROTOS_H @@ -39,7 +38,10 @@ #include "Packer.h" /* for routines still in this file that take CacheManager parameters */ #include "IPAddress.h" - +/* for parameters that still need these */ +#include "enums.h" +/* some parameters stil need this */ +#include "wordlist.h" class CacheManager; class HttpRequestMethod; @@ -59,6 +61,7 @@ * cache_cf.c */ SQUIDCEXTERN void configFreeMemory(void); +class MemBuf; SQUIDCEXTERN void wordlistCat(const wordlist *, MemBuf * mb); SQUIDCEXTERN void self_destruct(void); SQUIDCEXTERN void add_http_port(char *portspec); @@ -185,6 +188,8 @@ /// \ingroup ServerProtocolFTPAPI SQUIDCEXTERN void ftpStart(FwdState *); +class HttpRequest; + /// \ingroup ServerProtocolFTPAPI SQUIDCEXTERN const char *ftpUrlWith2f(HttpRequest *); @@ -211,6 +216,8 @@ /* http.c */ +/* for http_hdr_type field */ +#include "HttpHeader.h" SQUIDCEXTERN int httpCachable(const HttpRequestMethod&); SQUIDCEXTERN void httpStart(FwdState *); SQUIDCEXTERN mb_size_t httpBuildRequestPrefix(HttpRequest * request, @@ -255,6 +262,7 @@ SQUIDCEXTERN void httpHdrCcStatDumper(StoreEntry * sentry, int idx, double val, double size, int count); /* Http Header Tools */ +class HttpHeaderFieldInfo; SQUIDCEXTERN HttpHeaderFieldInfo *httpHeaderBuildFieldsInfo(const HttpHeaderFieldAttrs * attrs, int count); SQUIDCEXTERN void httpHeaderDestroyFieldsInfo(HttpHeaderFieldInfo * info, int count); SQUIDCEXTERN http_hdr_type httpHeaderIdByName(const char *name, int name_len, const HttpHeaderFieldInfo * attrs, int end); @@ -433,6 +441,7 @@ SQUIDCEXTERN void peerSelectInit(void); /* peer_digest.c */ +class PeerDigest; SQUIDCEXTERN PeerDigest *peerDigestCreate(peer * p); SQUIDCEXTERN void peerDigestNeeded(PeerDigest * pd); SQUIDCEXTERN void peerDigestNotePeerGone(PeerDigest * pd); @@ -579,6 +588,7 @@ /* * store_swapin.c */ +class store_client; SQUIDCEXTERN void storeSwapInStart(store_client *); /* @@ -667,12 +677,13 @@ SQUIDCEXTERN peer_t parseNeighborType(const char *s); /* tools.c */ -SQUIDCEXTERN void dlinkAdd(void *data, dlink_node *, dlink_list *); -SQUIDCEXTERN void dlinkAddAfter(void *, dlink_node *, dlink_node *, dlink_list *); -SQUIDCEXTERN void dlinkAddTail(void *data, dlink_node *, dlink_list *); -SQUIDCEXTERN void dlinkDelete(dlink_node * m, dlink_list * list); -SQUIDCEXTERN void dlinkNodeDelete(dlink_node * m); -SQUIDCEXTERN dlink_node *dlinkNodeNew(void); +//UNUSED #include "dlink.h" +//UNUSED SQUIDCEXTERN void dlinkAdd(void *data, dlink_node *, dlink_list *); +//UNUSED SQUIDCEXTERN void dlinkAddAfter(void *, dlink_node *, dlink_node *, dlink_list *); +//UNUSED SQUIDCEXTERN void dlinkAddTail(void *data, dlink_node *, dlink_list *); +//UNUSED SQUIDCEXTERN void dlinkDelete(dlink_node * m, dlink_list * list); +//UNUSED SQUIDCEXTERN void dlinkNodeDelete(dlink_node * m); +//UNUSED SQUIDCEXTERN dlink_node *dlinkNodeNew(void); SQUIDCEXTERN void kb_incr(kb_t *, size_t); SQUIDCEXTERN int stringHasWhitespace(const char *); @@ -798,6 +809,7 @@ #endif /* external_acl.c */ +class external_acl; SQUIDCEXTERN void parse_externalAclHelper(external_acl **); SQUIDCEXTERN void dump_externalAclHelper(StoreEntry * sentry, const char *name, const external_acl *); @@ -805,7 +817,7 @@ SQUIDCEXTERN void free_externalAclHelper(external_acl **); typedef void EAH(void *data, void *result); - +class ACLChecklist; SQUIDCEXTERN void externalAclLookup(ACLChecklist * ch, void *acl_data, EAH * handler, void *data); SQUIDCEXTERN void externalAclInit(void); === modified file 'src/repl/Makefile.am' --- src/repl/Makefile.am 2005-08-21 03:08:38 +0000 +++ src/repl/Makefile.am 2008-03-09 10:31:52 +0000 @@ -18,3 +18,11 @@ INCLUDES = -I. -I$(top_builddir)/include -I$(top_srcdir)/include \ -I$(top_srcdir)/src +check_PROGRAMS= testHeaders + +## Special Universal .h dependency test script +## aborts if error encountered +testHeaders: heap/*.h + $(top_srcdir)/test-suite/testheaders.sh "$(CXXCOMPILE)" "heap" || exit 1 +## ./ has no .h files. +## ./lru/ has no .h files. === modified file 'src/repl/heap/store_heap_replacement.h' --- src/repl/heap/store_heap_replacement.h 2000-06-09 00:05:30 +0000 +++ src/repl/heap/store_heap_replacement.h 2008-03-09 10:31:52 +0000 @@ -1,3 +1,13 @@ +/* + * $Id$ + */ +#ifndef _SQUIDINC_STORE_HEAP_REPLACEMENT_H +#define _SQUIDINC_STORE_HEAP_REPLACEMENT_H + +#include "heap.h" + extern heap_key HeapKeyGen_StoreEntry_LFUDA(void *entry, double age); extern heap_key HeapKeyGen_StoreEntry_GDSF(void *entry, double age); extern heap_key HeapKeyGen_StoreEntry_LRU(void *entry, double age); + +#endif /* _SQUIDINC_STORE_HEAP_REPLACEMENT_H */ === modified file 'src/snmp_core.cc' --- src/snmp_core.cc 2008-01-23 04:07:19 +0000 +++ src/snmp_core.cc 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: snmp_core.cc,v 1.82 2008/01/22 21:07:19 rousskov Exp $ * @@ -36,10 +35,13 @@ #include "comm.h" #include "cache_snmp.h" #include "ACLChecklist.h" +#include "IPAddress.h" #define SNMP_REQUEST_SIZE 4096 #define MAX_PROTOSTAT 5 +IPAddress theOutSNMPAddr; + typedef struct _mib_tree_entry mib_tree_entry; typedef oid *(instance_Fn) (oid * name, snint * len, mib_tree_entry * current, oid_ParseFn ** Fn); === modified file 'src/squid.h' --- src/squid.h 2008-02-27 04:49:32 +0000 +++ src/squid.h 2008-03-09 10:31:52 +0000 @@ -255,7 +255,9 @@ #include #endif +#if 0 // moved to include/rfc2181.h - RFC defined constants #define SQUIDHOSTNAMELEN 256 +#endif #define SQUID_MAXPATHLEN 256 #ifndef MAXPATHLEN @@ -299,11 +301,6 @@ SQUIDCEXTERN size_t getpagesize(void); #endif /* _SQUID_MSWIN_ */ -#ifndef BUFSIZ -#define BUFSIZ 4096 /* make reasonable guess */ -#endif - - #ifndef SA_RESTART #define SA_RESTART 0 #endif === modified file 'src/store_dir.cc' --- src/store_dir.cc 2007-09-28 06:22:37 +0000 +++ src/store_dir.cc 2008-03-09 10:31:52 +0000 @@ -612,7 +612,7 @@ } void -allocate_new_swapdir(_SquidConfig::_cacheSwap * swap) +allocate_new_swapdir(SquidConfig::_cacheSwap * swap) { if (swap->swapDirs == NULL) { swap->n_allocated = 4; @@ -630,7 +630,7 @@ } void -free_cachedir(_SquidConfig::_cacheSwap * swap) +free_cachedir(SquidConfig::_cacheSwap * swap) { int i; /* DON'T FREE THESE FOR RECONFIGURE */ === modified file 'src/structs.h' --- src/structs.h 2008-02-12 05:28:47 +0000 +++ src/structs.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: structs.h,v 1.575 2008/02/11 22:28:47 rousskov Exp $ * @@ -30,7 +29,6 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_STRUCTS_H #define SQUID_STRUCTS_H @@ -43,13 +41,13 @@ /* needed for the global config */ #include "HttpHeader.h" -struct _acl_name_list +struct acl_name_list { char name[ACL_NAME_SZ]; acl_name_list *next; }; -struct _acl_deny_info_list +struct acl_deny_info_list { err_type err_page_id; char *err_page_name; @@ -66,6 +64,8 @@ char *replacement; }; +class ACLChecklist; + #if SQUID_SNMP struct _snmp_request_t @@ -88,8 +88,9 @@ #endif +class ACLList; -struct _acl_address +struct acl_address { acl_address *next; ACLList *aclList; @@ -97,27 +98,27 @@ IPAddress addr; }; -struct _acl_tos +struct acl_tos { acl_tos *next; ACLList *aclList; int tos; }; -struct _acl_size_t +struct acl_size_t { acl_size_t *next; ACLList *aclList; int64_t size; }; -struct _ushortlist +struct ushortlist { u_short i; ushortlist *next; }; -struct _relist +struct relist { char *pattern; regex_t regex; @@ -135,13 +136,10 @@ /* forward decl for SquidConfig, see RemovalPolicy.h */ class RemovalPolicySettings; - - class external_acl; - class Store; -struct _SquidConfig +struct SquidConfig { struct @@ -694,9 +692,10 @@ char *accept_filter; }; -struct _SquidConfig2 +SQUIDCEXTERN SquidConfig Config; + +struct SquidConfig2 { - struct { int enable_purge; @@ -708,6 +707,8 @@ gid_t effectiveGroupID; }; +SQUIDCEXTERN SquidConfig2 Config2; + struct _close_handler { PF *handler; @@ -917,7 +918,9 @@ #endif -struct _peer +class PeerDigest; + +struct peer { u_int index; char *name; @@ -1594,6 +1597,8 @@ int syslog_priority; }; +class logformat_token; + struct _logformat { char *name; === modified file 'src/tests/testEvent.cc' --- src/tests/testEvent.cc 2008-02-26 07:21:13 +0000 +++ src/tests/testEvent.cc 2008-03-09 10:31:52 +0000 @@ -1,11 +1,14 @@ +#if 0 #include "squid.h" +#endif + #include +#include "testEvent.h" +#include "event.h" +#include "AsyncCallQueue.h" #include "CapturingStoreEntry.h" -#include "AsyncCallQueue.h" #include "Mem.h" -#include "testEvent.h" -#include "event.h" CPPUNIT_TEST_SUITE_REGISTRATION( testEvent ); === modified file 'src/tests/testEventLoop.cc' --- src/tests/testEventLoop.cc 2008-02-26 07:22:07 +0000 +++ src/tests/testEventLoop.cc 2008-03-09 10:31:52 +0000 @@ -1,13 +1,18 @@ +#if 0 #include "squid.h" +#endif + #include +#include "testEventLoop.h" +#include "EventLoop.h" +#include "Mem.h" + +#if 0 #include "AsyncEngine.h" #include "AsyncCallQueue.h" -#include "Mem.h" -#include "testEventLoop.h" -#include "EventLoop.h" #include "event.h" - +#endif CPPUNIT_TEST_SUITE_REGISTRATION( testEventLoop ); === removed file 'src/tests/testHeader_ACL.cc' --- src/tests/testHeader_ACL.cc 2006-04-22 19:18:37 +0000 +++ src/tests/testHeader_ACL.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "ACL.h" === removed file 'src/tests/testHeader_AsyncEngine.cc' --- src/tests/testHeader_AsyncEngine.cc 2006-08-12 07:43:10 +0000 +++ src/tests/testHeader_AsyncEngine.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "AsyncEngine.h" === removed file 'src/tests/testHeader_CompletionDispatcher.cc' --- src/tests/testHeader_CompletionDispatcher.cc 2006-08-07 08:28:22 +0000 +++ src/tests/testHeader_CompletionDispatcher.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "CompletionDispatcher.h" === removed file 'src/tests/testHeader_ConfigParser.cc' --- src/tests/testHeader_ConfigParser.cc 2006-04-23 17:10:29 +0000 +++ src/tests/testHeader_ConfigParser.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "ConfigParser.h" === removed file 'src/tests/testHeader_EventLoop.cc' --- src/tests/testHeader_EventLoop.cc 2006-08-07 08:28:22 +0000 +++ src/tests/testHeader_EventLoop.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "EventLoop.h" === removed file 'src/tests/testHeader_HttpHeader.cc' --- src/tests/testHeader_HttpHeader.cc 2006-04-22 19:18:37 +0000 +++ src/tests/testHeader_HttpHeader.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "HttpHeader.h" === removed file 'src/tests/testHeader_HttpHeaderRange.cc' --- src/tests/testHeader_HttpHeaderRange.cc 2006-04-22 19:18:37 +0000 +++ src/tests/testHeader_HttpHeaderRange.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "HttpHeaderRange.h" === removed file 'src/tests/testHeader_HttpReply.cc' --- src/tests/testHeader_HttpReply.cc 2006-04-22 19:18:37 +0000 +++ src/tests/testHeader_HttpReply.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "HttpReply.h" === removed file 'src/tests/testHeader_HttpRequestMethod.cc' --- src/tests/testHeader_HttpRequestMethod.cc 2006-05-09 05:38:33 +0000 +++ src/tests/testHeader_HttpRequestMethod.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "HttpRequestMethod.h" === removed file 'src/tests/testHeader_RemovalPolicy.cc' --- src/tests/testHeader_RemovalPolicy.cc 2006-08-21 06:50:40 +0000 +++ src/tests/testHeader_RemovalPolicy.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "RemovalPolicy.h" === removed file 'src/tests/testHeader_SquidTime.cc' --- src/tests/testHeader_SquidTime.cc 2006-08-12 07:43:10 +0000 +++ src/tests/testHeader_SquidTime.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "SquidTime.h" === removed file 'src/tests/testHeader_Store.cc' --- src/tests/testHeader_Store.cc 2006-08-07 08:28:22 +0000 +++ src/tests/testHeader_Store.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "Store.h" === removed file 'src/tests/testHeader_StoreEntryStream.cc' --- src/tests/testHeader_StoreEntryStream.cc 2006-05-03 20:04:44 +0000 +++ src/tests/testHeader_StoreEntryStream.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "StoreEntryStream.h" === removed file 'src/tests/testHeader_URL.cc' --- src/tests/testHeader_URL.cc 2006-05-09 05:38:33 +0000 +++ src/tests/testHeader_URL.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "URL.h" === removed file 'src/tests/testHeader_URLScheme.cc' --- src/tests/testHeader_URLScheme.cc 2006-05-09 05:38:33 +0000 +++ src/tests/testHeader_URLScheme.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "URLScheme.h" === removed file 'src/tests/testHeader_cbdata.cc' --- src/tests/testHeader_cbdata.cc 2006-08-21 06:50:40 +0000 +++ src/tests/testHeader_cbdata.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "cbdata.h" === removed file 'src/tests/testHeader_client_side_request.cc' --- src/tests/testHeader_client_side_request.cc 2006-04-25 13:13:33 +0000 +++ src/tests/testHeader_client_side_request.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "client_side_request.h" === removed file 'src/tests/testHeader_comm.cc' --- src/tests/testHeader_comm.cc 2006-08-07 08:28:22 +0000 +++ src/tests/testHeader_comm.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "comm.h" === removed file 'src/tests/testHeader_dlink.cc' --- src/tests/testHeader_dlink.cc 2006-04-22 19:18:37 +0000 +++ src/tests/testHeader_dlink.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "dlink.h" === removed file 'src/tests/testHeader_errorpage.cc' --- src/tests/testHeader_errorpage.cc 2006-08-21 06:50:40 +0000 +++ src/tests/testHeader_errorpage.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "errorpage.h" === removed file 'src/tests/testHeader_event.cc' --- src/tests/testHeader_event.cc 2006-08-07 08:28:22 +0000 +++ src/tests/testHeader_event.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "event.h" === removed file 'src/tests/testHeader_wordlist.cc' --- src/tests/testHeader_wordlist.cc 2006-04-23 17:10:29 +0000 +++ src/tests/testHeader_wordlist.cc 1970-01-01 00:00:00 +0000 @@ -1,4 +0,0 @@ -/* This test tests that the header below can be processed on its own with - * no other #includes. Dont add any! - */ -#include "wordlist.h" === modified file 'src/tests/testHttpRequest.cc' --- src/tests/testHttpRequest.cc 2008-02-03 17:00:29 +0000 +++ src/tests/testHttpRequest.cc 2008-03-09 10:31:52 +0000 @@ -1,9 +1,12 @@ +#if 0 #include "squid.h" +#endif + #include -#include "Mem.h" #include "testHttpRequest.h" #include "HttpRequest.h" +#include "Mem.h" CPPUNIT_TEST_SUITE_REGISTRATION( testHttpRequest ); === modified file 'src/tests/testMain.cc' --- src/tests/testMain.cc 2004-08-30 09:28:45 +0000 +++ src/tests/testMain.cc 2008-03-09 10:31:52 +0000 @@ -6,7 +6,6 @@ #include #include - int main( int argc, char* argv[] ) { @@ -34,5 +33,3 @@ return result.wasSuccessful() ? 0 : 1; } - - === modified file 'src/tests/testString.cc' --- src/tests/testString.cc 2007-05-29 19:31:36 +0000 +++ src/tests/testString.cc 2008-03-09 10:31:52 +0000 @@ -1,8 +1,11 @@ +#if 0 #include "squid.h" +#endif + +#include "testString.h" +#include "SquidString.h" +#include "Mem.h" #include "event.h" -#include "Mem.h" -#include "SquidString.h" -#include "testString.h" CPPUNIT_TEST_SUITE_REGISTRATION( testString ); === modified file 'src/tests/testURL.cc' --- src/tests/testURL.cc 2007-05-24 02:59:14 +0000 +++ src/tests/testURL.cc 2008-03-09 10:31:52 +0000 @@ -1,11 +1,13 @@ +#if 0 #include "squid.h" +#endif + #include #include -#include "Mem.h" #include "testURL.h" #include "URL.h" - +#include "Mem.h" CPPUNIT_TEST_SUITE_REGISTRATION( testURL ); === modified file 'src/tests/testUfs.cc' --- src/tests/testUfs.cc 2008-02-26 07:24:00 +0000 +++ src/tests/testUfs.cc 2008-03-09 10:31:52 +0000 @@ -1,4 +1,7 @@ +#if 0 #include "squid.h" +#endif + #include #include "testUfs.h" === modified file 'src/tests/test_http_range.cc' --- src/tests/test_http_range.cc 2007-05-29 19:31:36 +0000 +++ src/tests/test_http_range.cc 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: test_http_range.cc,v 1.3 2007/05/29 13:31:48 amosjeffries Exp $ * @@ -33,12 +32,21 @@ * */ +#if 0 #include "squid.h" -#include "Mem.h" //#include "Store.h" +//#include "client_side_request.h" +#endif + +/** \todo CLEANUP: This file shoudl be called something_stub.cc */ + #include "HttpHeaderRange.h" -//#include "client_side_request.h" +#include "HttpHeader.h" +#include "Mem.h" + +#if 0 #include "ACLChecklist.h" +#endif /* Stub routines */ void === modified file 'src/tools.cc' --- src/tools.cc 2008-02-12 05:44:50 +0000 +++ src/tools.cc 2008-03-09 10:31:52 +0000 @@ -84,8 +84,6 @@ SQUIDCEXTERN void (*failure_notify) (const char *); -MemAllocator *dlink_node_pool = NULL; - void releaseServerSockets(void) { @@ -1056,93 +1054,6 @@ fflush(debug_log); } -dlink_node * -dlinkNodeNew() -{ - if (dlink_node_pool == NULL) - dlink_node_pool = memPoolCreate("Dlink list nodes", sizeof(dlink_node)); - - /* where should we call delete dlink_node_pool;dlink_node_pool = NULL; */ - return (dlink_node *)dlink_node_pool->alloc(); -} - -/* the node needs to be unlinked FIRST */ -void -dlinkNodeDelete(dlink_node * m) -{ - if (m == NULL) - return; - - dlink_node_pool->free(m); -} - -void -dlinkAdd(void *data, dlink_node * m, dlink_list * list) -{ - m->data = data; - m->prev = NULL; - m->next = list->head; - - if (list->head) - list->head->prev = m; - - list->head = m; - - if (list->tail == NULL) - list->tail = m; -} - -void -dlinkAddAfter(void *data, dlink_node * m, dlink_node * n, dlink_list * list) -{ - m->data = data; - m->prev = n; - m->next = n->next; - - if (n->next) - n->next->prev = m; - else { - assert(list->tail == n); - list->tail = m; - } - - n->next = m; -} - -void -dlinkAddTail(void *data, dlink_node * m, dlink_list * list) -{ - m->data = data; - m->next = NULL; - m->prev = list->tail; - - if (list->tail) - list->tail->next = m; - - list->tail = m; - - if (list->head == NULL) - list->head = m; -} - -void -dlinkDelete(dlink_node * m, dlink_list * list) -{ - if (m->next) - m->next->prev = m->prev; - - if (m->prev) - m->prev->next = m->next; - - if (m == list->head) - list->head = m->next; - - if (m == list->tail) - list->tail = m->prev; - - m->next = m->prev = NULL; -} - void kb_incr(kb_t * k, size_t v) { === modified file 'src/typedefs.h' --- src/typedefs.h 2008-02-27 04:49:32 +0000 +++ src/typedefs.h 2008-03-09 10:31:52 +0000 @@ -37,7 +37,7 @@ #define SQUID_TYPEDEFS_H typedef unsigned int store_status_t; -typedef unsigned int ping_status_t; +//MOVED src/Store.h (only use) typedef unsigned int ping_status_t; typedef unsigned int swap_status_t; typedef signed int sfileno; typedef signed int sdirno; @@ -47,18 +47,13 @@ size_t bytes; size_t kb; } - kb_t; -typedef struct _acl_time_data acl_time_data; - -typedef struct _acl_name_list acl_name_list; - -typedef struct _acl_deny_info_list acl_deny_info_list; - -/// \ingroup AuthAPI -/// \deprecated Use AuthUser instead. -typedef class AuthUser auth_user_t; +//UNUSED typedef struct _acl_time_data acl_time_data; +//UNUSED typedef struct _acl_name_list acl_name_list; +//UNUSED typedef struct _acl_deny_info_list acl_deny_info_list; +//UNUSED typedef class AuthUser auth_user_t; + /// \ingroup AuthAPI /// \deprecated Use AuthUserHashPointer instead. @@ -74,28 +69,20 @@ class AuthConfig; typedef Vector authConfig; -typedef struct _acl_snmp_comm acl_snmp_comm; - -typedef class ACLList acl_list; - -typedef struct _acl_address acl_address; - -typedef struct _acl_tos acl_tos; - -typedef struct _acl_size_t acl_size_t; - -class ACLChecklist; - -typedef struct _ushortlist ushortlist; - -typedef struct _relist relist; +//UNUSED typedef struct _acl_snmp_comm acl_snmp_comm; +//UNUSED typedef class ACLList acl_list; +//UNUSED typedef struct _acl_address acl_address; +//UNUSED typedef struct _acl_tos acl_tos; +//UNUSED typedef struct _acl_size_t acl_size_t; +//UNUSED class ACLChecklist; +//UNUSED typedef struct _ushortlist ushortlist; +//UNUSED typedef struct _relist relist; struct http_port_list; struct https_port_list; -typedef struct _SquidConfig SquidConfig; - -typedef struct _SquidConfig2 SquidConfig2; +//UNUSED typedef struct _SquidConfig SquidConfig; +//UNUSED typedef struct _SquidConfig2 SquidConfig2; typedef struct _close_handler close_handler; @@ -105,27 +92,25 @@ typedef struct _ETag ETag; -class fde; +//UNUSED class fde; typedef struct _fileMap fileMap; typedef struct _HttpHeaderFieldAttrs HttpHeaderFieldAttrs; -class HttpHeaderFieldInfo; - -class HttpHeader; - -class HttpHdrCc; +//UNUSED class HttpHeaderFieldInfo; +//UNUSED class HttpHeader; +//UNUSED class HttpHdrCc; typedef struct _TimeOrTag TimeOrTag; -class HttpHeaderFieldStat; +//UNUSED class HttpHeaderFieldStat; typedef struct _HttpHeaderStat HttpHeaderStat; typedef struct _HttpBody HttpBody; -class HttpReply; +//UNUSED class HttpReply; typedef struct _ConnCloseHelperData ConnCloseHelperData; @@ -139,9 +124,9 @@ typedef struct _DigestFetchState DigestFetchState; -class PeerDigest; +//UNUSED class PeerDigest; -typedef struct _peer peer; +//UNUSED typedef struct _peer peer; typedef struct _net_db_name net_db_name; @@ -155,13 +140,11 @@ typedef struct _iostats iostats; -class MemBuf; - -class store_client; - -class StoreEntry; - -class SwapDir; +//UNUSED class MemBuf; + +//UNUSED class store_client; + +//UNUSED class SwapDir; typedef struct _http_state_flags http_state_flags; @@ -169,7 +152,7 @@ typedef struct _body_size body_size; -class HttpRequest; +//UNUSED class HttpRequest; typedef struct _cachemgr_passwd cachemgr_passwd; @@ -196,8 +179,6 @@ typedef struct _Logfile Logfile; -typedef struct _logformat_token logformat_token; - typedef struct _logformat logformat; typedef struct _customlog customlog; @@ -225,7 +206,7 @@ typedef void FQDNH(const char *, void *); typedef void IDCB(const char *ident, void *data); typedef void IPH(const ipcache_addrs *, void *); -typedef void IRCB(peer *, peer_t, protocol_t, void *, void *data); +typedef void IRCB(struct peer *, peer_t, protocol_t, void *, void *data); class FwdServer; typedef void PSC(FwdServer *, void *); @@ -240,6 +221,7 @@ typedef int QS(const void *, const void *); /* qsort */ typedef void STABH(void *); typedef void ERCB(int fd, void *, size_t); +class StoreEntry; typedef void OBJH(StoreEntry *); typedef void SIGHDLR(int sig); typedef void STVLDCB(void *, int, int); === modified file 'src/wordlist.h' --- src/wordlist.h 2006-04-23 17:10:29 +0000 +++ src/wordlist.h 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: wordlist.h,v 1.1 2006/04/23 11:10:32 robertc Exp $ * @@ -30,7 +29,6 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. * */ - #ifndef SQUID_WORDLIST_H #define SQUID_WORDLIST_H === modified file 'test-suite/splay.cc' --- test-suite/splay.cc 2006-04-25 16:40:29 +0000 +++ test-suite/splay.cc 2008-03-09 10:31:52 +0000 @@ -17,12 +17,16 @@ #include #endif +#if 0 #define assert(X) {if (!(X)) exit (1);} #include "splay.h" #undef assert +#else +#include "splay.h" +#endif + #include "util.h" - class intnode { === modified file 'test-suite/test_tools.cc' --- test-suite/test_tools.cc 2008-02-27 01:52:54 +0000 +++ test-suite/test_tools.cc 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: test_tools.cc,v 1.11 2008/02/26 18:52:54 rousskov Exp $ */ === added file 'test-suite/testheaders.sh' --- test-suite/testheaders.sh 1970-01-01 00:00:00 +0000 +++ test-suite/testheaders.sh 2008-03-09 10:31:52 +0000 @@ -0,0 +1,44 @@ +#!/bin/bash +# +# test all header files (.h) for dependancy issues. +# +# Ideally this test should be performed twice before any code is accepted. +# With or without inline enabled. This is needed because the .cci files +# are only included into the .h files when inline mode is enabled. +# +# This script should be run from the makefile with the directory path and ccflags +# +cc="${1}" + +if [ "${2}" == "" ]; then + dir="." +else + dir="${2}" +fi + +for f in `cd ${dir} && ls -1 *.h 2>/dev/null`; do + echo -n "Testing ${dir}/${f} ..." + if [[ "${f}" == "cf_gen_defines.h" || "${f}" == "cf_parser.h" ]]; then + echo " IGNORED!" + continue + fi + if [ ${dir}/${f} -nt ./testHeaderDeps_${f/.h/}.o ]; then + ( echo "/* This file is AUTOMATICALLY GENERATED. DO NOT ALTER IT */" + echo "#include \"${dir}/${f}\" " + echo "int main( int argc, char* argv[] ) { return 0; } " + ) >./testHeaderDeps_${f/.h/}.cc + + # run compile test on the new file. + # DEBUG: echo "TRY: ${cc} -o testHeaderDeps.o ./testHeaderDeps_${f/.h/}.cc" + ${cc} -o testHeaderDeps_${f/.h/}.o ./testHeaderDeps_${f/.h/}.cc + rm ./testHeaderDeps_${f/.h/}.cc + fi + if [ ! -f testHeaderDeps_${f/.h/}.o ]; then + rm testHeaders + exit 1 + fi + echo "OK." + # unit-tests require an app to run. + # our most-recent object suits this purpose + cp ./testHeaderDeps_${f/.h/}.o ./testHeaders +done === modified file 'tools/Makefile.am' --- tools/Makefile.am 2006-05-11 18:25:39 +0000 +++ tools/Makefile.am 2008-03-09 10:31:52 +0000 @@ -13,7 +13,11 @@ INCLUDES += @SQUID_CPPUNIT_INC@ TESTS=$(check_PROGRAMS) -check_PROGRAMS= +#check_PROGRAMS= testHeaders + +### Special Universal .h dependency test script +#testHeaders: *.h +# ./ has no .h files SUBDIRS = === modified file 'tools/cachemgr.cc' --- tools/cachemgr.cc 2007-12-15 06:11:41 +0000 +++ tools/cachemgr.cc 2008-03-09 10:31:52 +0000 @@ -1,4 +1,3 @@ - /* * $Id: cachemgr.cc,v 1.6 2007/12/14 23:11:53 amosjeffries Exp $ * @@ -135,6 +134,7 @@ #include "assert.h" #include "util.h" #include "IPAddress.h" +#include "getfullhostname.h" #ifndef DEFAULT_CACHEMGR_CONFIG #define DEFAULT_CACHEMGR_CONFIG "/etc/squid/cachemgr.conf" # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWaws5w4C9Id/gH/9ebB///// //////////9iZJ4B9KSF6B07TNsk21U19K6HPPHdqrvne5by97LmWqj3anvd1KWtFcsVDTOwaCgD PbwUslRFJSPesDgCic9292+nvvDvHey4AAA9AAAA0AAOmhffZca+qTNtFNKUABFQkEgHOp32pQoS JBgYLLWzLAG7gGnIgqgbMOfbEdPa2lSKQFEr4AAGfY+tCg+inQCh0HQBSQCqAE+fOAAAfXdYD0oA UAAC73AHvsA+lAAAADQAdsAAdAAAFAFNAAaAABRRRQFHrIOmg8AyB8L1qfATznd3V3TXodel7Th1 QG2z3A+k8e6+8voJBQHub0FdKD0dfNbNarbMvc9UdNe46a7p3XqtwApJLT0vWX2H0fToA97Ho77D 17ZGu7z7AKAMhxPdgE27vvUUJDvbpR6dzJe7nClDvc6FxjGYppkBujo6RmK0NansGUrlqiQ1h3AM nGwGbZt2BzSx3WapkyCnR3cegM8ArO2vdbhsR6sFUBSruzlHbZu3oo94GSw0+Zu3ce94FFrCCk59 my3b3Deksyb7hGtaxdhjm3N13buzTWqC2Att2W56dve998nvdcV0zn3OJPbU+nvd3e933G833mBO +AHp3wAAADhu77O9M7fd1e1LcwdcB87r6Dl0L25ucZ13DXbuq27art22vdPA27107dxAAAA9x33j 4dj72N89dvXdvPdz17m0Xtb157e24zLMN7rdWQKsH1o8AAAA3r73TTbetOne1bu9zvJ3O89uqZZt MY23pznc70D7feAIAPoAB9933j751xcl6Fdevcfd3MZ93B2dzt2DmlgH1uiewAAAO++3fVWt9w3K 1i0a1m13MRE7MbADN13AAAAfd3PYth2Zaa+7jtNs3uY5GzACAAA6AD3ZPM9xd263XRt3bu5dnZkm wARgAAAB7s+xkX02zN9jdlsZOmID63QAAAAd2RJEl7WZNs2x7Z3cuB7TX0HPrHF7tDuTAHarVZjA 0qpHpvMZNDx6B4DlECiRUgABa22BbMgFAAAAAKCRbUZAZsUFFBWgaZAaAEg2wAEgkNAKDMaoLIFK ErIxQBQUAQqAiqSpE8hpUokA07D3hvGgPaGAxvubsGraSzG20qtaatvAATdB1HGcte+7pQnsFqBo GYJprk7ttsfAKUKt2ik1gQuAGzWp3aO7Ku6o2oyQJAW2Nmx6FOR4AM9trE7ajostHIRBXcZOjTPq u569682r633dh07Nmtt8d6O933beA9AE+4fZvbVqzSvNrvn0reT0tUiL6zua5i7zyn18ouze8q+9 e0LZmrWgWgmjcAHQF3GhSh26c2000pXXCHTSGEZWS6ypcJbZtgraCqBbd98+ePoGRKqLDKLt31vZ qrZgl3aKcz2ZK61kz1qSpOktVLTw733c8WvpyQsmkiQqUJjTQBWNLJmlYaztpdtRCYbSrNivdrkh gERKsjVGEoZRk0USfZo7aRJJsNeslPNvKKDW2taGqTA2t9nXrKAPZlmtRN9V69vvLUz52Vt8+vlt 97r2RL6xTO44na7g7ppFCLarXRu0aSVa0le+7jfe+nTOxTvm7dvfF4zbKhGU3uZXWwawrV7hzoFK sfW6UKGzEyrMgKakVlNvu7u2qO2ipU+59KrTvovhYaoCEJUJQQAQIEBNAmQaBNMjRMJpo1NMTVNP U8jUe0g1PSDanqACU0ASkRNEmmmkp6mnplH6KGho0ekDQAAAAAAAAAlDJCCJiTQFMTU2FPRpqYjU 08jU0Yg02ppp6TTTRoaPSA0A0CTSRBECBCGg1GI01NJsVP1NlJtPVMRhkynqaepoAaPUGQAAUpIg IE0AJkaGgIAAmICaYTI0nonpqaZU/TRNpTynqeSHqBUUQgQAIABNAAJk0AAIAjTIGInlSflT8VH6 TUeUelH2GCu3AT/EqYK/bg/YYX4cKvwMw/FovKYqc1lVWDFKvyYKpsZCGxko/wMqJNZmFTqyTTCS zBNxaEmFTImH6vw5NlSfwLDexmDGRVqn4NFJsxX8eE0xKPM00JhikxiwxYYxlVTDIUxYmMKsMUsC sMYqoxipjBRihKsgH0KMCpP90lYUVVRizDGB52Uaw0yrngl/BCyqlkjEVuxH3NfjZtMxcWEmmSIq kXmvPl0Zj/Blk/9f0Xif4bkNlSRWJYpV2xgBxw7liF2sq/5JmmJxJjAMSmmLRYRmUtoSVIhhZFU7 WD7s4o1UMKwsFVgqqkKVFSiJSpIjtYFaWKWYxYJNMRWliKxksZRYyLGSrjJWmqYxFRpVWRfBsQ1S mDEcmI3jFRNmNSVglp0YmqoYwSH/Y1PESR5zp/7r0OZ62pXebP/9f5Nz85jKD/sflMGRn5gMAcmj /oYOD9w/sIySf1gScex3bOXK/uf/4/9uph8qv+zc3v/LL6Hif+FVP/2w4m9K4NXwq5mWzVWGGWrV s3MHJHoR1vqdrCJOzpcPBoOpTV5leNOjxJhP/bxOL/8dDwbORqZYMJ3phh0qw8TLD2MMJh/9mH/t NNu1N7sf7Xuf0Nm93Ha9TmbnwMup5UQavMcXtV9af/L0tnofe2bh5XBh5W5yJI1REGJECgSNSgOQ P/yalRFP+xY0ICcxyZgw8rDL0utvc6lYcmXByf2OB5TsbEe9MvsaI9z0PU6HU4Edjk3wI0aspuc7 Jlh5HVyPteppjsaaaaMOTq2ql4v/20cDnYNS5//D1FCoVEBIjFxATcc+RsZMmhMqls9bq0Yw3fY6 rdU8jd2N3mabPS4qnF/uVNKnubtHVzaVOjEWnyMaMpIrpdbKSPjczrbNWX0smHF5288apI1cWXJ2 tESa4MPK4Pa1Jo9TreNk38eI5sFjkMfEkdTseYojHmew+BgqS9DvNCPyOR/3v83A+tu9SqtoX+Wd uK2FMouDUjClVV9p2etif/WsnwcOFY4aOFtttD5Tiw1aux6HmcVV3+Vq9rcb9zJzSQcTV8SJx6yb 1dpwO5sMMOj4PW+huhdlidh17IzCPr5fHQ/NlLy4ulDydft6NyJ7KCaKji/+mrMH2Tulru/5tIO7 gxIRSx5mrLKfqmMIy8zpaDytUkYN7mYBFIGh4HUsUEQMHASuYJGpMRMEsydVkRRorCYVi4smsGZ3 KxfYyxiyeTpdDZ0MJ0vU+dkaq+X5WDKpJVFMT6n1PM7w86sVMfE9h3Oh/zehyeZUnznqYIk/BTKv gVEb3leJh5VexuMLEbPU5DdiHVgcGKtMLTk0nS0YE0UiOL5GDyN7B6FPEpSqoUo8FOTVyZeZ2tHM 3KdTLqbNG9QcPIkXKkzU9xMcsMVFDgyeR1ATkPoct8PM0dzd5FSQzELBq38WitWvRB1458QD3yLl utWamiVnJMkuMmW2mJIb+kME1sg0RUEwXUpVsoSVMqjBJFix7vG87KcNowbsxhmivblgyVCTrdhg IQ0aJwcifpE2BpnKUSOB0tI0jRG9UK6GXFlh7Ha3HM0dz5nUbO5pVNOMMTK+/zO3HI4KT53pPAqv S8zlIHXW4lnH4GjMkkVY8p2H1Ohom8sdVxGLhhRcYRatSDcxofIwcVatipgmGVMjJVGFYVhhhMKw pllVZJkwYO9zPweQJ18DvOC5kydw4xMp5+JyHQEmyU/7M3v7j65W539dD6oMh+rJpIP+qiU4y4d/ 0o4fmgu8Kop7d4/2sQV1LNmNk/p/p/r9g+fv7hsev0JDgxOQ9IwVr+7l9s40WRaj8k7OZclUY+ma zJVGa6N6jp/Tai95ieOLxWzsbx3k0m2Q/lEzunaVU8rf7eDXDru1IJ+Fk9EVUEZ8rVgjB0m0IKQq T1ewWO5m4myL42eeKl3Zv8n3KQJxPxPle03noWQ++GMMejmxn2KOL63Nmd/Q8zM7Fka9RfvORE6m SZAsWORyC1N+PocZUVQh/B3+dvsc2z+xzNc5mpXTKpq89azV/yO3XFp/c1DqGDwHD9v1eAnI+lPs gbdSQxQ6lv2aIfo8C3tFFb+fs5S/Lzx0WbeE42Y/7YP9d/oP5T2/KyDC3/ocIVv8IHegKn0J5J9S eOdkXtuwOopozKKcKbL9EWXkdn6LQxPzQO1RZFIZ06/Nfmn/55oc8dZ+W5zPf8/y9j8S/Ldz9f2Y xMkmEYKMiPQoMFmAcrUXV+dZkd4t8I7oIhccWWiXfoXbx3Op2RQ8v0rhvn2mjaffi8fPnpfHrX35 hKinl9jFLVizcKv/6BugiIZMobdP2/9H6/giHUdSjgeX/U4iXUTt/N4OOj4VY4+xlpTMaYZpjO6/ BoalelhhWZP2GR+aQ2kx+D8Z8GXJZJOyFUlSQvlKOyo9ejo2QfFjZAOSvr2GyX/EgF7XHys7FlEy U72HXthNZVqbqjfp8jO+qo2KyrCvyvw6ITIgwMjixccUE84F1T270kBRvw9IH66TbEygwEghUpC0 KX6ln8hmhQ+BNYK70aDg1uGDafpu397o3zS7KaeLWf+oxDjEyB2zSGD/m6J4VzUGtVxe0owLF6eV kSJFWS+ngaF8PuZESxCdfpHrn339Vwrk+9ZrpG60IkVk9qiDhj3ocnV0BcKj2Wfwk3wVBnCwdppo pZbSlQUhenhZokSbM/9tYeQupfFabbykPK5iQspTJyGUqrCicbMQCFzbYgJXJIsucXj3lZs63BzM GcajaXZJRMHnz0bjkmIpVfyVByIGzdWHtyWT9m5vIPdgW/LJD0NbyDuyfRH4/7M9Iifou+bArJq2 HWUMeh+x8FmkUuKg4pyUK8Wd+lD+8hUUSGBhR+s67dYzWUCcMEpUoqxTgtBnPcqB1XEaM1MWjJZM cE5GJzgdcz5ZSFvuTJYhPk/JD31ZFmvlYV24XSKmHgI8KPBMRwTGJCjpUGZmT8JaXuLsX18+QJMJ 4BJgzqlh6ZYZ4vQhv/kL6GWmFbj10YbyKclfyFFdmgVFckhU0ckpDkpPsMKgaP8Mw7n+PrRjezZ/ ePY70UlTBgVv7/cUyB5J5aHDkyTRvEka330yJKMHlIbmC95MssUiybv6R4MDBfFIQckTHG5VElpZ +Iq736nJ1uyZNj3fT1LIsycYTAsoS5yjZqYmvNgyzXUzMlWW5fQ8zLT09HXnz2Yh0sSIS/xNTJBC 6LM9GRxl8R23ZGGk6Or95QfGrPx7lkZugmTofZkEek9DOVQinIH/yRKHClB0LCqCHDDKiVRYn2Wg jje7F5tiQzTEfN0xnIscWEGSyyyq+Mv5i7L39o2LGjnRgxcVFUUhaYYFZM/3jqXEKKkeKcGCm/m8 ERY1lhCONP0OWx9beKWRLmlk2i1TLwc5nI2lKcWmFC0syap/enseeTDHvOjCYsSkodZDeskOTl5t IV1GIyhAkR45fylkpIt7L3h160KfLkRmRh9NUzPVo78mBllCEJbNoKSIjXc93dTu277Fi34u76GO OIGgqfTOWxUjAO1G6243LMzec2Uobn1KMOnJPwPWy4sKL0KNPZllzxZSD7jpP6NnD+SbnQ7NO/Sr FdCESHPc8EV2B46GdxeYqrbxKWuX0WZEjOEIX82oXlmC8qguZqj2knwRkUzoxQpYT6vVTJOKOPPy D5ZXiTmRE6RVHFZ04s2pz3x0b+Grea/ZzmClSI/i0PctZNVZiuKxfwaVj3TsbR2VGdkUV1q/wx89 /lZKPh8OCeBoj+FrkYeuHA03pNYQ9ITJtFXFBtM/TqwKotSRhicd2V5VJnpSPjkuyWC2QPer0YUQ sMXvkcTxNR77FH8jEPvZ1qp01mefPy1LhEFsMKPBfGJylh8OHxZyKxilR8K4v0isQL2hAqsR7q68 3oeQoZO45gWT7bjQ5aqrZ0kY0osSB5s4LtAVqs5KM9/+qvQWRZRi2fjZ7rvWsYZ/3n2bG2KMH2dO 0+18YOmnHE5N61Ugplu5XJLUXKu5s6KsfNYmcxlFirNBSLDYQTv7+JGlovKpq89u705+E1Ff5P9r o/Xd3NytGL8U4Wohy/09xmzsj0qTB/H29KVZ+Xk+CdKC8LVwko6ljZ0LEksfZ27++OboVsqNAwrD /DrR+KypsKkzU+wqT5iy1F33d71G9mY1OvtmNYmtePRRcVLuXjRcxxJgs0WY3od66pzo4niWZPgY jd/s8s+b2ovEliJiuJ2F90mEfgPK3ks7ojAZTwZEiClWSAbMkKDJP7Xl5x+sn5+6tqFVPjU0SYqo Qw9fF+rWRKWnKc4De9i/o+/paoxRo96jEE9Z5S9hEiqGzJ/W4ni7JBmLqWHUZJbtVYqncobKk7di 8pzmHvoTU0eBjHlX85NU9dJwaIzIR9vzY8QocTEpeDuqJ6laysic3bKjQo4PYZH5NBYBDh5etiIq ne0wUt1aa1myXVhUKMXeSoTTNLEO32a7T/c7gut/+Vz8mVh/UwyhnVxEUXHhBqs3lyj4/dphBAS6 +LE56ZIGCyy2Y4pIWd6S56M2qtQUais1W3V4YeRVgnzGgK8bPcUrEa0Ue4ZXulJrCKjwWNarCjnw 3PTx0yeXMVGaoz5UPmbOGNUOZkJrsiSRz9soqPFFY25OdtxHg48Z4e+OzOBlpYe2qqGixFesukdS BllbTxYxhjEwwo9K0hgUindF3ISBsw/JXFXBC8WxAigUUvpu6Wkl/4QQcWBo7qbqaaTnzj2ohZdf sJ1kw5tJ2XnUdINvB3NS+lh4EH9jjd+ki9ekiMyOWRm6KrONiUUgRVV3NC1C8+TverxHVi1pYPJc zILVaRGPYtIsFotfjbWkI6+JgZw88XyO/KnPtlx0ZhJ6kHLI6zUl7+/SYToN/FNgkl1VUvN7wLyh 6QLVgp1iz9OXtse88w7zEsuKHbsJHheeG37c3Jbt3+zV55TDfI54ykLtRmGMSg7RGdUWUtbCdd5z LLqpuqY709bjSZjreSodCJsczvpPErL4fwY16hlPDloSCug49OG5M+k1sk1JjF2mTUgTgfrc+uiE 1P6vfbuiS7s6Xj7O0ZrgTK3VXMCuDrVYxGNrirMKpqifrKBSCwFAoKxh92pQRPv+dgX1hsVEnGyF SNYEHVjfWJZfbEPb591vxxIwmdLQDujRXDT46Dns+ySOXBjxcG+uTk92N1D3qH7iiHFyAqPRw1Zj 6ax+MAYezIOVoVTmpFVtI8j0s4e2RWfn65A85c1S6ZVJB42jzgNS3k6UIipM+lk3iZsTNnheL1kY 8HcdSb2QzA6ToVWh80irwy1lUIRIRY+d3WRloi7danAsKSPmUrm+l22xKZZqQrEqXtWVisQmm49n MKHzsxAVBZKp7t4EE5ycVR/iWhBCAtA7MQywbyzHeJtOE5s71lyGChxXnSZa8RxyiM3LA48BlU2k MJ9Ypm6cJUOed+//44x4P2pU6thzd39Jo2k8GrDj7qbcH5nXz7OOOvuHqcWn7k2ihnuOIuGMTLKe z9TyMt+vay81hfiXBwYYfD58Olq87LChVQoP7epA4FPcmI+JE5Hs4+2Pj8/z5N4F1+DKqf5k6/xI fEJUmcon6P73e7dFXcTmY/qqlWkr5NO49KZyLtX04q7oKl7WQ7Dp8gha4kREYqgpT2vdZeqDE6Ry dHXJMG1GotFEbGdsNe8sTzcHUpqYcuZd515vnLTZEZLlkRm4qtXb7kROdptdjQdOuS9vczV47stJ tEENuNvoEcblpU0xnK6M4Qw0YxgZGWLvJYQQbV/h+1J+knZLol2hLVnKYI2Z4t5mUPeP2UqieMvo h8mX53vFPV9B9IGPoQw39AQPQQ9vkdgU9hOnNGA2xdO/2Z969lQqYCf2iJfA9JzKqupT7TqdzxN6 fC6Grpe5/Bzo4K6nFxYZc7AMmUqdzmbmTc87EP4WCCzFN28lT82eBB7hAUrXzNfDvF63U1KmFVEV TDN5GWZXCNfI+RzJSCSEmEmBdZKjiSY7Nit56ZiDYWtW2s8Dnexvejjs4b+MlxJi5YgQD9B1Mjlh g+B1GOQp7wwJ0rQsWJH4lCr1uZ1uR2q4O50MSs0jrd70a5MVarCPIqVl42GTLpeLHjaGjyuGdmzh OLFSfBq8HlNE10CuphiZeXOpY8HWy3OY8G290upwciJ5CppqeFR+ZseR1DUUNALHUucHAfsOBRRQ mZKJoKnOzMrnSMHGFDJ3v94HIoeA5qhSZzrr9qsyDK3q5FOkvX9M0/tmxZT6+FGVlOijXjTuavoe 3qnZxYfDyHoeKHa6W5h7DJ1GoxM1HDYIFDU7jwOZwImTQiWHBQyQkfOfSaIdPfLSqNwq8G5kFFHI hSlKKeYRNBRO8j3Oz4DzO98De8b2vI4vY8b4TuekdbvP9rRzvkdDZTxtzA0cx0Js8p8LberfPMy5 cLLWpvTJjhImRGIm56ipE/UQO4gfBE4PQ78mMqKMJyVDKjc1qaPs63W/ub3adbt8jc9W3u7J6bpn TGLcnzevk8j63rJy5leN4BPO53a1TWnEzsqDhsULn0HeMDlCZUSKj+0uXLjHoYNEE8rESYp7zkTI mBmkzMjjkg+ih6sBHz84iet/P59ZmgficHAhHtrL9UQQZeCoo3XwPTbYPXr828Y/2SV5dfewYiak kk/D8jZD8/d72Apv3V6fodTEyl5T9AgdpoYVikFP68sziw6Px3PZPP/B8LX61X3nZEl/Et7oRNV3 JUlxRwnuOlfjO3bGMnOOGhBP23YkptHF4ElM3Z5QjKc3m02OdDXyBDkSpCY9ujhT7xRtxd8rreUV 20PWKFIx7150jldI5iyyoy6tLimjqS1qqry7QxObze+72SIZeLizXOYBGFXp9tGf2R7fr/ujaG6v nWg/H6m1FWvwH0rF514/wnWipebcVfzaK35fcGL2JC3FpGmfSI0R4P6qyaeGlYeWjjLzVlxo0FT/ JadJPpq++0SMC+razeX9/60Y9CgHzHqNDnPsOg+Apobm+fHuer9PznB3K3ODDJvOZXBGjxnzvOeM 85405FPgdzi5j534n0yaaOh1MMIxuPrXqbMut2OjVL8TZPGl1joYh9szI4O9h+B8z9/T1OibcfI0 fgjxnec52Nz8Gr0mGG95427dwczdPyvZOR5Hsc6ugb5NXpY/EvoaNyz0Ht9vJzO1J43nePr8kYcz ZHobnepuaHifg3GDsNpxhxaaF4YGBhgbz+uNoyNinh9TD4qfrjsRo9TwZdh9KV0NXkjB1Fb3VpX9 Pnxz30dN78Zv4Itw+fL4/l83y1b+3/UHH872WAimPUqRUcXZ2szd6kVqpBUkiDQn5fl7XW1OB+4w Ia1PmefyHB+Y1gTgp/Qwwn/8/Q5jIdqsWVWLGGGzsZfAauea4iSP73/hvdr5k3NzJaq6G7/y+F3N zBEO80PYJ6HzntMESYiESZpqksB7jqQehvL+apEmhcuUoXJmx/wb6/7TPyHoyJnmh+HxZmUaj3jF eSaW+DBkFQFiionNP0GFhrR4OyXXU2Jp5N3DTrmpqJpwJjwHBZKWFEyQ2QQCp3/d3R5Bia+yZLcT wj9Juvb00snNLuOxSaP5GCfa8rtldiel7WEc0OEBJJ80BSTsjPpGc/E/bN/8r8d75X6/6My5143Y 8A1C1aF67nDH6VWfSldUMJzqrupJqS1Fqol9gdWslFQSjYiGTjXTzSHRKcB/VwhrU27XRPGrPV8I dPP+E6kP0gkh7z/PA/THGueyrE/QmKmTFO8/BYZYZUhgJJBEkGSf65If2qyDERYjFUiqv/MqqrgQ hoBCJEjwEBGCVKlqGrS23W2225gerq693LzK8x59j+sgkRiRAgMfqJjCIhuIiEEbn3d9PDnPT1Rd sc5V/jiN2sfK72Q3THZW9PZMzGWzpdCf1GCqYhz2erYhSsp4z0yZmdsblXURl3Hq9PlXGRej7m3O T6SXvIyPPaIV3WPl1Ec5tul3n7Hjz1l3F69xLxb+Es2Ivz5LjV7TjC8PjjtzndSTwyTpJ79Uzq/q nrPE5J2DOIx/Jg6QtsmZMyz1Zm21Jnj2JOilR73A6fB9K2kXN53CLXgyLGqV22GWyp0VMSYk4l1+ GkXo/vuiTipET+qKIIfz20uoH/MRP8KBrH35078DuDDKRgxoep2vKiOSBIdHrcDVvOD38VdCmutX 8frfJfJb3l+3//biN+3u0d1U8koep510cIuLiqcUhsflyuePf/i9BtC6khmBatDVTwxjFSPgpiuN GtT4FFWAPvGBNb3kgpykPV0RCcDyzEgdPCPNhFnTjA2wNOphKB/KkwQDhJYnYhjJwk5YbBgVLGsI NsIWDDsYBYMOkkmkDSErDHlm0lQiJpkBYvCLNCEcvLJpkUAzRrjRDgSSy2BpgbTQgcCBjDJusGE2 ldpoEMcYbVDUSaGBdEoHLoMpJ28vR+RZ4Q1E75Cm7oyV6zulmSc0LyhhksMGVqQonFLAKnKcJDgX d4YciGnRqhJthykNwtIbZchYGkmnSVB4sNRIaWCGnTNDA6ZuDkakKFlhKFLJ01xbLBSIMlQs6pYI KLBDq6YnJYCJOnSeB7Sp46s6tO2YrOXSjjFlYd5ZiKGkomxmRNa5wmphZp0yTDUsmMMmAyhm7MB1 NXGHDYzSSUEurIXJZoe3ENbJTGOGTDTqMjGHdKCkYiaqCUGbVqxhUorAVBFkURDrLJDE7TaHegKR RVnbDtOeNhk4yWc+CmDOkIBmBUGHNlkWQi8pwwUad5A0gjByjEFE3QMcmWVDZgIGTJgdk6GfnG5F ikywuWZou4JDdJYcJmZTeiXd1DdNSg2GQZdE6MhWPBdMNzDO9E2kxhGhZBGCgVDlMhxbBhpOHSYX DJIGa3mDGymCUTbLLLKDRMyUMnWsGa6uQ2DKJLGTSGR4msMJywuUlDKYhvUsNslZpBVDWUKIWJbL DQlmigUG5mtb1uSGENx0Mu0sVSiF4Zd3wZKNEAqCnOidZIaSYITQyScMhZgNkAWFSQ2kwmHZkAFh DEA0MkOmYwRgsIhszJJiTlk0+BA8ISds2kDlOTkIUFk6SYzbKqLCtQWE5GEqm+pSYtYTtJNMmgYQ 6ZyMkwCHQnRkhwyTbPCQ0hiQN72ZAx8MvAcEw0wJ0wRA0wFgOmkWjKhDlyFsCoQ5acXlIeEgLCpA UOWbZO0kxhBQg6sFnTOcpBzDAxhBYCg5YSocNYFyhndNMigcWiMqHbFWV2ycZZMSsHdnDJygG0A4 4pKgZaApznOAdsm2Q2yTaTGSYkOUPAk2heYFCHSF1GgiScM3zTSAdCCgcsJ0YWHhMZDcZWQRADuM U2zlxga1STwk0MMSD4PGaBkFJxukh0mkFJDw1gGkrIGWysi6QJOE4Q7YSiC2b7JGFklKjbhiDQsN rDfRsgKGuKBiCgLJ3lON0m0A2mMhwyQR6Q33ZA8JCV2rCIlSUTjqwmKJB7tEO7ThCVk3Swc8YQxh 47oGCMEFxuqSFOaFa+E5GHaSsk5ON5oQNiOtGTEqdMNIY6MuCSbYs6ZMYcmqG0zjWTgcYbTZuhww 2lcDKQUorjNoEJlouIa1YbwLKwHLUlHeWbQoISYMAWRQWERikFBEkWEVZMTwkNiGhKIFb1ZtmDyK MRA4tIJlCcMhRDlJrKSYIVqumVkTVILIVgGIQvd2mkNIB2hwhFDHpArA4YSp3zYHGym7ZFIjIRZd WSdJDx3TpgLJDjmhOUKkOmScMNeKB4YHPNDpA6ZJp5YEvFgvDCBpOuGgB2yEzXWAFRQOBkDMsghq wNMDnvMDpbYuRi1iq6sq54LMU3YccXPAaQxPHNJDbKw4YbZJp29G6GkiMAxkmmAHKHbxzSHKQg9W coFcYbRNrJazprkjNFVG7DAONRim+klGBtANjCThlSj0mRmRkOhJRk0geMKcNQ8M0YWeE2yc7lDt Dtk6ZplTTJykNlKEPCaSeHtBQ8OIcCGoMWEWHIyE0ihjJ3Q5wOEnCeap2sPgn2zWfFn7dw06beOG 9T+LDxKVlptXSu6+X4VUFydqxlzJc5dGO9J4FU5ccockzcH4a0YurKByS+D8BJU/AImpIZAEAzIQ KosYkjMh3R68PY8TqYfM3exn5Wj6n6PhfYaO143d757Ep0O2bQK86qwPtPH0tz43Hck8g4Dz80TA TUHXxWHfhPumLUeAx7iCQ4O5gNRJkX6n52T9o/dG1wwUMtDLlBTMGFPu1gJdayOi5QyIjbbYoSFM aUbV0M0kyo5mY6MsVaizJbZq6c02ZexJJ4T+lN/uds1e5wcmHeywww1aqkjLwIImjAwIeaqIqqqr hyckoYIRhRZYfQmZi01f0cYaIjio4OKCCjDopOBCGxDjXfRtFK1Nk4CIwIgjG7DisSoHa+vuMTKU OQnRBwZaSebVXrHF6ZO3h6VXlXauKrjt010NeFdMmPDtVeFdq4quO3TXQ1kY7DUhHHOFDjg45IFl aMD27imlUME0nYEiaU7o2FmAQQODmjjBBoyZSMtmE2VJwcGEqjVWzZo1aMq2UmFDVRsqSsMso3qb lRglElERIaNlCGylCmFIGHRhAMQUONggbTRxnHHGKEWWSUSQJspMKGqjZUlYZZRvU3KSqNAhpKHA oc0gCjmGBEMW9pgntq4klqGM0Mdm0EDg21Du7G70wzvDsU2Zdv2lVu5DO8OxrVVabpSAEJJSUQ47 GGsNsWuBlg0FNTJqyMNxTYn3jiB+5An55rb6EZQcBQ2g7bbqIXG5sulDxcMrIXAmTOoV600+BYWa bGnYmjCmCYYdBlHtVVVVaXYXKbM6LLlWtL3lFhYbzhK2oSsJGwsMJEJsNDgRIM3TDPwcCBA5xBAx AkQwwwDBJpkgqq9W20UXYQqNKKLaSeWGTtxERJBRJaCCxFkDjBaFpwTiTnKiQ7Didiod1nQ7Smm4 A7BZDEKgqgxbQlSKKqiy8kiGGZhBAOFHSlQXaSCx4MosKPjADcxrJUIbEKkzPN2NnZxbbLiM4q+P clXM0vJuGZ0yTMmU7vOIMea7cqRHMjq6reb5OjEOVZJxfBV4WLXGTHG8TMbM7ukMscZMabglMMww tYGLEmSYGHazocd7ip7SJ6icbWYYRqZhh4T3yeQdIoeF2G9uxeZhVUsweaV4LR3dD64OzDFljjjj lgT23b0Tu1OsbZEMRBrEnaGBwLkbm09Aoh4CDmAQCJCH4ZsQIYYpQOtetUKwoDBmYu8bUuBnGTMs pCYMBFHpt50Reon2YI5m7ZkGaEmILyORaUFEuWQI4hvMjBFiDDDwwxA4QZMkUSMUOUYzA1w7pp06 bDMkxpWpQYrCeDGD1qBXUld5RylZgmOJiVRBUWIMVgLBIKgKAocTNMEJxJxTIvOupwaP3Rzxyuiy hxiCCjQcQOIZFDci8LDgthvbBgTeChhhKIhoOsOdWnLbKZqKmWoUbDbQSSWxwTZBo4D2440iNTFl OBd2ib64nqtxiNWAJILJvOhmYasx0zJJsSnMyGGGpDMkMsLIvroqbB6sOcSG5CEILeWdPYaIQjp5 YEzCEGUhDlQb31jeGvAnKPEODXO5O0AMZYQFAo6k5tODgpnFKc7FwEnAxW5QUMMKYYHHCAQIHOJz KZ8NJhl7xS4wwsR4Lkkcgk0R4RZA5BNsyGIZvGoQ5jOOHDSQaV0FEO67YdpTXQnEYZAqUoRd9w72 UTJQ4SIgwgcJOHIwJK4g4gM3Vr+Zy+bHe++Yb6GgGwRBJGEnAE4FSQVFixdcOhoznx42c75swF4O V4KIRDPIwwnoijJYsdjiSCSiCzQwkcgGOhkUxT13DWOWxllmmhJFiY7Z5EpnmgOVFj1AhDy1kGdw ImaOQcjbpkYSDMYQFsww4UMMQKKywQwXZQzMPc8dB69IMIIHIHIZtGH9rleyfUxuO3iyzrrql4UK Jkc5yySDCDScsQi3HMNKJdDy8Q5ISMzD0NXZIMyCAfRtFGGYoSSseRDklFCgs808mzLk6CESU5wn JkHcighYU5iXA2C4MB7QqZJgoqB9v9mzN1R9ipg5lRhwCqAds9CHNBERwSRskjIuXmnuUrq8OP0I 3O5zt7gjiUiQHB0HGUFzzT54fwKlCZdPam6SSAJRLQLuY8m0kjKSKcnJjmlS1XzVac0yY6LbbbdE 9UcO6c+kkZhW1uBuSJySR9BJC1/K/X9TDxvXJKKuRJ90iQ3uBSccSNViz1VMMo6xrt004tH0bH0n i8K86txvc7zMhzuqT5/zJ0WFSWSLQ43+isYxjWIgmxj2MIkTuZVWyR/zSUpUVSqqUqIKP9j4WDIq lSVZJIqVJbUWKsgqyvIyo/Hstf2Kw0wWMqsYPvyWmlRBiCqUlklUqed+RlenGiVJCqipVKkpUoqq irEKskVRVlLIqUlWKqVSlCqqoqiqiVVVSkVUpjuqlkmlMsX9T9A0NiYwv0ZE7cphCn5SsKqrJVan NgwZUy5stFVKpJvf0MImSKVSpSpIsskiWAq1Sion89RgoqpVBSg2oYKSqpJY7HYwyxdmmmVSwxlj KDFge9WHoVs0VHveZpfFlX42HOyjg4Py7+ThOTH9q72uCliVXiklP6UzYc+WTPv8NPPU6UlVSkk8 RhnwaGSGdD4Mo9Nf+9B+H/rGmu7Cf3V5ikxdSwmFSaWJioknEyRiLKWGKrGK4Yq0MqsGWKmFipiU xlgw3MVMKKwwYVKUwpMKlU9qjCoqpKKUpVTKSRMISsmDYQsmVJSXrprSLKyMVvVJGEqXJSfWlTLz fZ53GzPs9mWt+HjzmP/eZP/fqw7q+O6/DhvLI/lW3XDrLn9PcwvK4uh3/Zprq/NYz9bXkEqCjEVg qNZQRRZ/dqf1GgwpggxFGMjIhIhIqpRP4ZjUTZ08ICvJGikEGKpEP8lCxFURIepZWavp9tZBjEiC LNCBX9thfCHbnnsyeNFVPZsFOCynVgFB/spVWIJCMSRGCr7X6Aww/8KFVi15NV3rzNNL+rFplWRi ZMftahzy2ZGLJeD4NU0qbMYxppjDKZlTSpo+BpU0pthjC0xjJpFo00piMy0ZDFTRjGhppgWWqyaT VYy0yGlTWlaNNGKCsEPBQuDSFJIIiSiAIyKUsk/yLIyzFYwpYTCjCYMGBUWpZKlkYUpsrEyWYVFM IfCTFMBhZRgSIBENDhgkKczLUwliybNMYY0YlaWqpEEQESoFggSjEoFEpRKYYepH3qsqq+tdH+jn RE4J7WEjl2MfmxfyovtMrd/Jq0L+gX8gsF3FT/SldqVxVOSpiQ0i/UpzpHKkHUhAZCBRKJRKJRKJ RKJRKJRKJRKJRKJRKJomAkJMKYjGHIYgxUcSphhUyqDgniaOp1pVfI0c6qbGzLiTeNz/o3Gu9sbs lbpifrrkaJq+hSmxIZE2f/iq3Zf1JNzJlVKr5XB9jUw6HFl0spKaNzewrDRzq3KwrVuKrgrKqrKb 2UlbhoqsHMdCdypyfScyNH5jCNUbzocjLRg3uY2YJscjmRuaGDAwbjvblVN7+oc7KbKrQOpW4+oy 4B6aQ5KcyjoHFr/LKJztTb/MNEcj1Ode1JG26SRgwj4rua8NzU3Hk/RZNDNjJNJtgX5dnZMCH3CJ KA4FiQk6lnImAHdAD5w+75YKEVFQ4ywlsyb39rwN3HHXflykvFyrTmyvjuqaVMVMVODLceTfZ0Ye KeRP18u0puxfQwnIxFsYrFgfzMS7n8ao/AcB7DDpB5YPlg71TmqcxpU4KmwLgNHYnagn8xX/CslY LU7lUuKc6ltH8wrKBsiyqXitDetLK0jak3qtkdUbFU60jhSO2kaaaaaaaaaaaaUpSlKUpSlKUpTC B8MkhOz0EkxTMxjFMUzOs2osyRWFRkVcard70TZU87J+YmJiYm+x7YshG+yWi2S1/y3Z8Y0RiwPc 8m/JxoYscrLsbhIpkZstiN6RNH+R7DdFxMV5jzGpTDKh4YixkWG7deY2d756p2N31Pa/tVDDaRX2 VRYkdxkV/gepzeU07l3eAfeN4m5yexHLuLbYFVLSTgf4MPUy5Su9NN6TKqp3HE7U3MzzJ8rDV1zs iN+7Ucyf7OSyVTCdp1NHmbzznoTQ7yaDsUOLcH2Ol7Gr1ODpOY3v2O9hOdUrmT2GSeM8BOp/yYVh WE7HO8DnYPI7Q4D7Ff6lYfjVxeDFPIcivSty0JkpyST4D7WBuPSmp407XS8adzsPS5HVxL7Xg6NP Ur86uT3Md7m7UxbBuN7rYVO1OgZGyNnFqbjV1uk/kehvQ/K8DcyfiV52jBUknp7E8zxZ7Pp1++Oe PkSeU4nYw5hwQ85hT7TxH0MuySelh/sedWFZYMPyivE/f8inguqPVl+NW50st7Q31ODi5K9jwYMt U2VOv4GE8Y/U4HoaHWwyrJl+x+55Wg8zXQ+95nWKe95DehPwDr5GHwYk8h8HwH8CdKxjIqqqv9fk PvPrfkvC9VUvF2tIvfehFsjYqfO6r9hyYedycToqcZjpbVyHM+wWnJ5uJgcz+w5zRxITmOYYSqql MIwYUlSSMGAxKVFH9L2OhSqVSqVXvakkalhJTLRSqVSqskie19bJ9f4ce34j1HnwRPuc/w/SfF1e SNY+u1FgpfigdxBvwWf5MXS99uXQsAnoXQoRUREQSVd7HxckgbqAIkPw+VeosPl/uaZUYU7k2gaD j37H0EH8GVH70RjxUQH7MxDjyPApS/zOiMkFXJ7jbHoPUclSybb8K/57uaspw045afrv8bnQes7q CozfUeSmvj5eH/FP5xXogRdLiy92YHb9n8YB/NcvKldxbszx+VGWlHPj5Mcu/w/urpjn7IGP82i6 7KqH+fSPIlJEZzd39/DqL/2n1dRlO7HLpL/LLXVvk3OTatjQhy9xVufxa788fqakT2OXsX2+GNU9 5a4bGtiasQxzr8RU33TXtzaMX5n43k1ng9j63c4H6nu+c00L4dZ5M955fR27+DpP1uZo5PnFVPtj 6pE/LJzELVLVah7WFRwPM5PJw9x+B/Ivf53i/aR7Uk4n5TofzS22qoWVUtSqlVb/NEk+p/gZkE/R /0tttttttt7TJImcqqqqqv9kkJJ6SQkmw7kCSexT/GfQX+kW7y8R1qHKBq1I0hmZmYqqqqqqqqqr QP9X4SdE5KfiB8KqxMKwU+k+BvK8xvHoQe1I5isVP6fW17mjQDBi6sNMj8vXv6r53Q+duT6Jl+0T 2iWRCyIVVVVVVVVVVVVfzJlDU7lMNGDRlNNjQw4QYMlTSpocDTSTFkijmZTid6juBxGB6jJgmV87 g/C0ubxcU06UO4sHt0o9DHlVxLtHG4bD2VJ2Cl8odVO5e8xokwe91Nj1KRxUnEOsan4lHeVlRVU7 2p2PI9I8rtOEjZZCnWyk/EvDnHI2Osw55k3vQYbm9JGBz7MGZCvq0uJ+tzbw8uqtA9Rj2T7V1djH cwU6HI6ntb/P3Xf146z86b5x+mTWTFZSk16A/E/Jjt+/9ieJ+VHed51HxteCZFSUZVr1eRp5KK78 yUzErLJipiykLMpVmJC/NkGsJTMIWZEzKEZkpZiqZkizJGYkRmAmslVrKIxDLMmmCWlpTNIWNGaQ sWpjM1QMazNQrWn+GNlSzJG2VLGtVK1lFZlQ1hWlghmUZkRmBLYRKoLRJC1C2BJai2FDMiMxQNYq tZEZikswpmEMxSMyqxhGYqVmSpYwxgmMirMKLMlmKODcQJ2/xw38Hl+5/ZD4L9UQ9B+497PT6j5F fmPxu7n7X9rqV2NPEwO7/ekDCkqpBVFTCwpUzAmMgrExV82CITBYSTq7uvyf0Xt12BE2bNf09Vz4 t3j3accY1h3e528hj3A7tpGs7hrJjH0J2a03ojiphpO7CObQdqfIaCNap4NaDLIkt3rbOCbNHo2m kqW6jNe2JGzCkHcLZrnuigYy4eIvrx9Jqrx1Rs0VeHBd3OyZ1nZzvJAU/M4dRUzMdXKKx4E9lbPc KMx7mr2XYzMOs8zDBRPvRuz70VjO1eIDJiHlSJ8MjME57Cyzjh8Mu+IoJBCIDiSRyixzTBFzD4rc i60jFb1dVkbrmCESYGicuMriBRVk1MjkkGnHFFtY2PF9dpPVyIntaxtDTjgY7Lu1OTsJi6Dbfqai WwKbbiZfeL54jNupUw/Y8Pz1RemQGhph2dsPnN0a+HHCMHa6DJqdy5HOOEVGU+kGMLVTbmjpSdDa xDFthlTS6eYpiZ5pJawpt3Np62KnIsICtVllEE6OM7LBFzOvlTipXVqMttY1iWo19mbrn5PKOLoO wNzU9XHVmbrHMTPNJLWFN25tPtxU8QOPRLdiixzcvSH3ew13uy9OCZioMm9NyVlTzvZfgYGb56SN jvMlTQ8p5Py/2OUY/1+U/XPlc6pqpzZGxk1ZTYxbNKn2tqO4YJjx6efl39S9HB6QN+cMcYC4zrOr q69NsmcMbk6yomE8rZ3Oghs89Qnl/ejNMBMpbJz1xnoTE2FLJaSWsKbbiZfN5Y+3ElG9dZRRVddm NhBbnURGQjOKh7q4MMfvfP+wXXxqLEN/cbDDn4VJ6oUA0ugyERTUWKmgzaLpN5/bP2kPdbuEJDWs EauTOY4IQUIPmZYw3VyhGSozIiX979dRyWvZJ6X1xUHJJxMC34qCqAqB/pTbtR9u0DjnLkb99ctK bD0L0nhDWSWQQI3Rw0TF5BFptfIMEcm5HAmtEgmlEHPSY3nBAjy1HgQePPj5xNy41Nr6gwwcs8/o k8SFWXAbkuVJRt1I7khieKi8VvxBxA3iGOMBcc852np8qax/pbjKng3Srt5IKbCyyjhHFnTN7nWm N0KWS0ktYU23Ey+cXJwuT8bBMPMGTWm5K2niUaPxcPLypE+mRmbExrzmP0vvW4ih5gPHx89+D/kn 1DNP2OFobhB9Fj/c39vLBkMfcFiNEaIgt2gSRQo4S6QV2UTdL595nSGjyUOTR5y9F0w5S+KAoXxN DIEWfIZCJNHYmDWjodsTcIoQaYPiahUjihwwvalSnerepe3GKDGqBsMNICSh7RwhCG1x2CRDiYNE 2IcjBOJzkiYMph3Q6KXp2KUxRg7cIIEYdkMxtBkUgkjoETu9Qxza1NA6Gksog4R/7BGCDx4/lJ8X z9fpBEO4VC8mKE4NkeC5e+JMRFoRS4sF0clZjJnWrAO3MuSqzo06uQ++Y/eMkM+ODfO+Ncko+CPg iBFitPb2mgW9MMYIYJQXzuc0FvJwhxDaIXHJIOaRgvAyAgsekaJPrEMDvctMIkRw880swngmWtG8 OxrjliEJqsunkDeBPqMFaCBGFdMg4hyx2m3ahchDqYGxNk22vJwgkTJBI4qq6ZiYsvdjilONiZx3 NE+PCKRYqWjsVA1oYyoNoh6NSTMnHqGQgLVZUYdRhWVlnN84QyKZWc8Cmb5zGWFEff2bBMD6woMm rNye2SuLsjyOCZiy8CrvjKq38espFkyDREi7KmdciJrKVM/EB0xDypE9GxuJ+ozu2stuw2CYfaeJ FUmx13RwXayXHNmZo6SwmYqDpvTslNY1xqwzZ8IWhBHFohRJqjIqjYlS5jBbIZoQFsVUN8WIwWvU EkFmksDoDTIC/mKbHRyauchBwmqHIVrXCqY16YCWEyRAmxGCJMHbS+YnMsBtCQiDbdLqdoKmjKAT UO3C1EChDQIosci3A3bYmTlyrgqB0wYVW9RAlDp+B4ZtiW0XaZycYG8eMmCvTr29Q9RmCenOdHH0 AzS/yj6f5oZzeeqpel2ZsRQQ6Wo97JJYJU6ZMsSfWNDNsGwxrwuEPr8FgdEQOJ1nGNANE9smF3HV cNPO0C23OWq1SNRCLEquZCId4dnFalYtlyFyhcmKQcI5M1W3QQIoQhYoscKHx32qGdTc9LTI7Ugf rMnUFd3SMYoU45itUqdy0zpofSMhzlqpfX0fXgTj+70mSVXp+OZ80+ZuZZBHFQ8vApo2LuO3cIIw qHmD6mrNjCMELprli17otQkqPB8hsMPneOPYEs8znPKc7py6ZXesvNnUNwCjh2Fm0fJjKOCZcEzA m6WmJbFzvO6O2NeG4zMUGBpGc7Ooot5spulxmJZMDtoldTCvLt43kTJDll2HPWu7cdWGTuGoBxGc 81mg56DUgZnJtNY8LW2ILJrct4sm+hmt3Y3OwO66H+voPmOMMceG8V8gcVp5I4n58nVI9yIUfIzY nK2zjdOks8Uxihtp4A5pZ/W8rb9jG0MWZUasVOxtXTM3k7FOaIkVRUA3Q7ZMxyCqqCS3ZtT70NSF rs/UQFomXHEFtE5lMztdwStdyrx3gYjHLTagsVruc3jhQ3IlNaxWtdxstPArXOWljm05RhRBnZ2N ZRZUUO92oEWp3meShSyk8XLEnoEEDNBr7sPlnHO87p4wmxgoZ2lrK115pp5Sp25FNDNC8s1yU6JF CpWqx4WYGQM0C1YumvTluMd8Hfc765kEYcckt3KQ3F7tcVpqTq8clah1ZCohmkE0LklS3XIUqFq4 EzcC1Srp1sBA0IbENa4xS1SxIg5DiDPhFe9m9OmUmLwLWdTUU2hbbcTL76tHy+2d5s0s7HnejqOS yMY5iZ5pJawpu7Np6famyrEPWqL68niyMpRodIeEEsCFa8Z7zXTHKElSu756xvbLGgWmbWmHbcpg y3Y0NaomAcp8gYxkwme5lhuYscyMCZC0zF84Kn4UR0DVemSPNTIRFwNXPfgVRnp3t8VuXcQ9xGbc +WZGVma+ZOGx1pzNqMFCe32ur2eDhBIzIJO5xYXm9RnMyyb8MGnGdb0Sc2GxDOnjVkw8MvLth085 ZsZEMt7qMlj29fI/bnhTcscuL7R3hv7sBknm4yTIZKU+RnKJlVVLVpT1SQj3QSd6saaVSyub85b/ T/hmWnZY9RfMyVDoxSPblV9hklHmPT5vO9DNOEQ9O+39M/rmsT/cxF/1vmwtuC2L7t69jtlbkCK0 p31suOMfLzI5E5fdVlOZA/agkeas2N3ZK6C4qM2+vwzHGmhYe7fTBJ69e7x9K33dkDmnK4qKyKye uHzZWojKq3sruyXzseRzayH6H4rdx5nr2a4zbTjrEcUSWYOYYcccccYf4yQkkk8ePHhDiHHHHPHj jjjjiSCCBEmnGGEmFkEEEGFmGGiNMNEYYYcWWWcYECMMLJHNIILKKNMILLNMKKHJHMHKLKLLLMOO MLLCyyyyihAihxxyiijjjiSTiizjBzSSDSjjTSyyyyzjhGmDjjmGGBhxpoQI04QiTTSCDiRyyyhE lkD5vds3A4prbt8x30ntJWGRhW9caWOWc1ogkwcwkRwmqoOt2gcokRpxBJJJhppZBFxW5A7U8v09 3Snd6x8CFVPMxU4lNamJ0Nt8pqJbApuuJl94tElzoiiSm27IMHL4ggcRQPfVtJuRF9VQ9dFVko3D oKh9p4kVSXHXdcFlrqg0jeUs51kkyYa+XXVMOlkGQM5hQhDlEaXhydHYXQtqAuYF131biICJWgee gdfEkGcFzRrwuXwTdoKxCLmSZqpmHsiqMio/GzZMkQ9pzltF+fWTYhiFprSNU3YI31lXYy3OWicZ u2eUdJhYYE9pkPwKmmhjE1VMpu3uHPzS8nTuIGWMJN6iFWQlc7N+7yLA+CZgB+l6lqNHGGZCD5Pw +fje9rAzeENGK/nObX1UelX8jJqcjflCvKuaVu4luQ2sFBBkV16SNrW/Fs4ETGVWhrs1Z+wdJmOz Cp83Ylkxn+N3xwvYUGshs2iMxTB5r+dRa7Ve4P+lFa4cgHHDzZdNyxXTt55IJR7JhozoY1lyeXlJ 8qQIaU7iEnUL6x6Q0ty2OE2owKcG8vK1yKQ0RNM0PTpeabZ2IdGX0JPyTeeXt5fDovmJEBd/PTCa xH2DzblH0vRlFcT21VrdzD3WFVl07Z7bJGDfDgL+p2mFMFfPNGowdjjGJp482pWeBknPI8wwM6py vpfHvQxUp/d4hxBiONdiZMud09kszOjjAdihZLkLFSZmyeRVhMBUY4E8IdiVKjXAWkD7L2fQvY5d 4abEzRc9h6FXYTurSIlnGaEussIymaFjHXEoBxMx2A40CbFiOUriByRNotuIkTFU+cRRPMgOnZgk aZHMdh2bHiS+GmxmtlSLE68xtojxxvkHvZNR4HfriYdGe0aPAcmYZJvOgYwh3HY6CYYdG+e16nYM bCyNc0hmizYLq4ZuazngNEWgwEBCDS24yii0qiGZotkT0273e2rlUzFiJYRm8B71iLLuyHIwvAdT Jk2WbfwfPiXyU7z+oQbHyRkCSB0zXY9HpNkDBBkJh/mbDNKZrglqncLIBsBNkkySBjVwhQzbDzFO QkxNdASf6oZjSWJjiXF6odYIaErc4lzOlrJBqi69wWwOiDB2yHfdNp51VO0dTq1hRLawzTA7BQMY Oa2uwam69JinKDBOmaCU7WYPVTAZ17LD24YkJkmLXBA7PjOwpdjWQQZ19bzY3ODnz2YHLzznCt+H UHvEnWEUFeIKG9sMzeczBb6LYxOCIfTSRvNmRibnduBA4tEFCyh2Kx8MHY5k6GLzWIT2QN2A7XCo wlhJmcoTfXRE7GeYtiZtpJawpvezaenmLPXE5M6aYUS6zKTGcxkNBbWFNtxMvnFnW/YWDEhfJmSZ mOEOjEOmDr2BwrSASOh2ahM+OZ3Q2pLBDoxxxnkxQZjjLH+G03np4pZ4RsECOzdjIorNGSBMQQMQ mEDCB2cbB0OBd1GoNE0F+ua0djIcrkJ2bOHbZfDXamQPw4hMWpQXemmlM3MhnmyDa06L1uTp5BIc zrnZo6cEmRho7v5En94kPW+t8H4jTS0rH3vY00btGw/dnz+30KhZQPMUQETrtv159OUuq9aoIiFB xyrRZ36xQpTzsZKYzwKjVzbhrOZoa0TDZJLOG23WoyszM0pcPvUQWRjBF0yreNjCcI2jXXhiTjjR 8zw8kFFkngcw8CLpnsiHxJ49UvF4OcYOa+dS69NuHMKMzdud1qQkY6jAfBmZi62MTCnOnJNBoJKv iTCrsVEQ+qxZBWG9BfYSFlWRQVLg7oLWjvpOVKsmtyUxeMZDQW1hTbcTL5xdV3Ga6NON44qbcm3J FJJcU2HD3NvnbbFsTNtJLWFN3ZtPTzEZZ3dUEm9NEbmblxJGJsZsXCef1eJ41bnRURWzjx58deqM dRRjMRkVHVa6iBgZkja5JefzlliKZvYdskQ4xzJoQJuPEDKWT7NDlyNsjjQZMNduwtBPz4RaD845 yZtQkcjjToOTMi/Rs4Qy1whAzTZQKDCdC+7a19687MizQThO0MxQdYzDsDpNDtUsnGyHr/N7MyDA PC9z97lBSYlYvvHzMIZt19qYY4Q6pW1zDVVwxhY5ce4JGfpIYunEY9zB00JiEXRjRZjsz2+u40ZR JTpdzC57tiyTuyaiXjolo0TsGiB/5f6h/Z8Ozk9GCel030uhBTZ5sOFZ54wyBeDk9DTMKhwgZMU9 OQxghuwo6jrEmCIcw7lBOu13TQBEOwj7G9DMRSW4nNKt2PZC6548OY743qGghZqFAjBGCgy8lfIR ckJkfYX8ljveh1juUQK4oQWhu5P6XJTOJmgIHpdThCHEYmCWUk9llAY19Ac4nAqG2JeoarLfrpxB SMXwaoFfc0GNwU2+zaenw32XV3CY7gpbLSS1hTZcTL5xc1VaxesSQO5sPsFTWHRkI6SIfngU8dFv JxI7FYFqZaSWoKa7iZfO5ZddaFPa89jGWgqoaSWsKbuzaenmBPEDBqu5xqJpgco2GB3c6kdEiA1t 0i44qSRM0FlQ2vCi7cYeIcfjKZk+QhHLMd0BEdEa5AmLeyiWCciKOmMeowkHGE9x5mJe9doIMiR3 7pbyoeIb1mJgtDHogeGYRopgSGvt4uhqt2lFcOMS5JjxLYjKVwwOJJ9yLFwmYcjjJJTBE7mbYMgm od0t3KYLbxEtJtPDxEFwVj+lyHexgquHJp6Y8mHSUQPjO4FLddmeX1FILOlQNz2XIEtmQxi3t7q5 M6akQQdMgUjZ42JZjJ2ZXhyfGEHSOTbxUQlvYXV9JODwZadqTvQzHpcB8nqnNwYUkTJPOwblQie1 rKAUOwuO2MoHo4gGoFd6Wnlgq8vOXYBA+xZFWSFJjbeOZaQN0nQxHPviTtXqd3SuF7zke8ogImGa E2IDYnpabduK6OTGJiMqrpG5AcW4ahXEWmJzMUjou3GwExwU4QtNJgY7nblT40AJA+VcgJog6iKZ pTG017MuOGIyah1E9GLq6NgHwNlWkngkxAbSUhelDcmaZNgsTBoueyAlDdV5LrIdtWU+C53ZhFvO 20WhhAgc56NshjUxJu0CkZseZriMxjln+qf7AN9/r8ARB7CYIPZMREG3G/PPNWp8sSXZaqn1dN1c q7hTlO8/tb1j/tEVVThkXuUt1BR5mGAoic8vVzGsTNNJLWFN7c2np0aa2zLaDGoZxwzxw4MLsnNW ReZrXvHSVA/MdJ1XhUbe7VJ7UdGeYZkeEYDi92ZUzMTZ7M9dyr28nImPdMkiJJt62SCEWPnITPnB 0VnPBtQSabm5QUcXbMHVlmNi6Y02igmYqDJvTslbU71cQtWNHEBUxDypE+HRmO/FoyFM3TlOnMq+ kGNqjju4pHSlVU2McxLUY8OdLYxDGtx1PlojoKHiWmH3ExfBS2WklrCm24mXzi8vbvYqulGYdBUP tPEiqS467VcFloJL2Cdgzd/BxkJ7m5NitI1hgolPDxlzpzb3BjfnGC0JI5bOnIT0FqVtU7LSmruA OmzolAe/mG/JHEwVeqZb1wcEjOg9jsD7K91DYKFpw40oB8pXMUo0l0Nainbo1EMOmc23hsEhxSdI kBX5mPtpDfdY/s+VGDkhBbOBLJHjYaUzVkwzxorPlDQmaDbjOcpHFwQzRGRpygeBCYZ6qZOWOPyr lUMNbc+rAsuDsdgM6YDginMgugaUli2np4gKTGc7u9bgXxTMOKpH1MydnxBWdhuxda9dndQ2XEyG 643dzxOvVVfUamIp5m1BiZpuTZKQyd92rnRAPzkO8qUAseRNSG3hzUxltcSuTIx0nRomLNd0bKZx st2McHJHchEinb5ps1A+XNPYO+WOWPfPGuYjBMNiDlrlRSG7KuUqSWIqYm6CsHar2OWJIu3yIpEs kBIO9rUcupzE8GQNy5ZTypQ9O0oMxwh10StRydJ31NPR0VljiGfiXhghdvL07tA7wpyrjVXmlHjf J3aaJVdLUk0Lt4hiRBipXLl27JapFaGWhNSxqK1/PFP1eS89xAlBC2nnIIaE0fwFQoc8uIPhMkMI YpcoOHi5glM3LVVjmoKRREVJOUKvEioKTBcOEJ0GoEuVKlsvSBJ0XuEDobFSbFKblSlNw44bPXrV cjsOmyo6CyGpmunpMRTwm63KFa0QcpVotHCITFiIfYEmqn5Ukh8uClSopnJQ3PDQway5FdUyxWOy 6DS3oY5WtW4O5zy9EDOoq7RVamB9ekSi5jHkQJm1MUibeRUo7C2Q8sxCYhYnXWQ9z0OMLnTUVZq2 dWMzPzmIwJtm6cdwCVe5DFJqUoHl1cEy6YxRwoeAOl+c2qzcAtFuLpumyUluJW1Mxch3XeGDJciE ash8EwjU41BmQQZMDFpsUcHVLBSQrRtOy6Y6XZoEzlDhyHOJu8bIMZoTEiPirno8aZcncW+lKdeH Ywc9kjWGGiaBmqXDDi8L62LVPWQsRQNPPcp6OLhgy5Z7NoGxfA6WhCAynQmMUeaSxSw2sWjoYt7e PVxUGvjxDxciDSHYt94pqIQ0JjJrLUuUwQtcKhmdpo2yShhKlvLAzaYNUManIQ0Klw7s1KjNu25v V0dIcq47R+npAh84hJwz0O/R/iYr6D4ItepqPqm0Lb6yJmY6+FJorB5uL8abo57PCKKJOIHESeIM JIIPHrqurmUOcIosgs59nl2J5q1EYZFaxbFzjSS2hTbubT0+1MS9m0dJMPNuZb1R2lw8vKqeZy47 e4Jyu2r3TeyDqJJuzMysVXFbJ0GE1xmZWKrip7Kqr3ewg6iSbszMzcuDpgeyya47MzsuDn643s3Y OdO79l9zkadnBHdEc9FW+Gj6Q5cPq3rTqOxWiNjOuImJlbJHRnbETV7k3biI46HxYY5nHfiHAdBy yRSQBQeohQtkAnybz8p70ely/jsxheBDBZz152KVFu2JpTYgp3DUNaqaLka8cjujTQmGYtUo16e1 Ig4JuZs3FsIwoL58w2LuOJDXO4og5m1VOSIPJj4IyXbUWaTWqhxBS/b25IkzrkZ4TsVs2SHOO1rU 3k1pKdHaOy86ee3wBfXXWexiBeZM2y7rzU41LRBirTZJaIdiFCK13UJmuvRCaEVDwoLNgbmc0ga0 cpQ4+wchrh4yqkyF0MdGYbTCVrttuaQMWAmSO6bnkxs7osZUwPwWQcCYb8o8uWYChoYMVJ480PDs G7MYrWmOxqpENBUMz643qDDCWWuzShW5T7HhDSqzJ16G7sONmmEmNhU4QzTdwzTm1IdcGSkxqdUL kJTIZDoYShXo9jvaYoREtMMYtSQYg5MFrlXZASkoBBzIOyIGhJcHZryBcEQkFp1ZZkMK05buxzux iJWVboyd2qp61zlW4W9O6dMQ4O7K5HQkvZeOKRaZYc8YJzhqBaieaGOfrH6y2BbRARBlvI2iCiBw oRaMTVGQBfEohinTlIt2qy6YUnQw+lEBiKO6GJyYDHfcHYpEYbA3RNSNKgeB6zUqx+H0DCNIYtCC sraGLRMaT1AQImjoYIQ0cqUMxy4QStJ3ZYiqKi1TGINEcibTZsjEc6HipBvsI3JbyfHw87eJdkvR PSEJkIxVnQzrlK6naNek6ZK18/DDBuFEYW3z5jq/mDL3zI6CDSTSSiSjSwlpHjx63axK97si91+5 G7qu+JLw3t3c7spXUk3cnHad27vc/ThT6otYtdVNERht3JY6MJBQzEC/wP5H6P85PfWxpw3lQSAf U/RDWsTqV9qVcuSc7ZzkvkNS45ZJHU7s4xQihGo03oCYJMkakz67HYnDOHDZd1Lrqg57hi8QNUTx FUxSN7YH0dkmI5y8JgH0cMMy4tnqZYcDEf5P91Z6Q5HhLXZCNV2nblSb1uTpQJoZj/fH+02e7S2b 3VDSixfYjydTlDwzLXCYhSnisglqtmzXxD27DiHdz4pEcM1lVaJwmzl12XUNQ1SQ07Zw7e0xByrH aE8Y0Q2ZwKmKGDleOWIJE1aOcihSboocfrgwhq3t5pYJocwTPbmiaGTPBZAcpsghiIlW2sdCKIe2 AgmzlgbE6Gc7s57KcjD6fSECfYSeOjielEoIXxj5319Kcq20o+mXmftc8IoMNIOPGGlkkGGkNcD1 MvW1aVwlWUQD1FaPMw0GGk0qLZvWbw/irDNBnF9F78nzC34XSBieTRZp012J2zfTYpp0J4Scoah/ nYVxpBra/vbIHkOuJHYtUsXKOOIYShHc/CEtRZdF6SYO2m49kazJM1GDgk6lIu4DlAiHe1ZQ4StT mEwxmocmCWksQK8dneIzni0SV4ejmzh5NTKFYhtEYpVJzN46mJwObdgoGNVlDjYsWkDjWkjU0rlB I4OtXJPW4k0bevAoZjCBwtWnXwh8Xla8m8U7rklanw9EGVBLjs4wSktTiIXly5YrWqRDrFiaGTHJ LJ65fWpbLiBtXQ46tUuVCacf+hLsYv9Yx4XL4pup5ymb4gXsgkRSH+PpVwzcJtULE6eDVGwbT9xJ EyWAmiht2Jt6a8NcenE6TGYUqOPLp2bHDlyblShUvr7APwCP6Jm3xf3Lb8JdH3UzNMvvHs+sKgzc +5yDDCDDxFIcuNqy4zeqt0eXybys7qIjc3ee41/DHsQdnocS8vr+wPQvediiQdBxUwKWWC3FDJQY MEWIKTFOEzTEdU9USbg1q0hMI4djaKIB4HbpTDvCInHHO81huWdsnOxsxuqlKTlxx2w5dq0TGVmO 9811eboN0QO3h2rWqVYiVqYwRqrOqdBM1r7Q5r0tULy8IsRyYQhnU8O2CLEIQSJjMfCBOApHNTYJ nscoRK9Tadmg9s2LEkyXLBFnEwcOPjEJ2YxOuEWIMbNjGiKkaU2lDhitUIcRoj8/PwJvqVu6dHx6 +rL5yYWorkQaaFTlk1oyttVqUisIbc1s0tqONooJmKg6b07JW1O9XQ63ZXPhgVL1VY5RHTjjlWdU mVOPojzM8+35/ceO8e89ErDwz0E4bilMzKYBXYk8iYJ+/N76u2PNDjI8OxKsR5DavCOXvs9XysPG +XlRCGPkxZLYT0GFWWTiZnIHILHG4VHS8AaQ7DoAk4ctcJoTUI4QcIuR2hNJY5tmqW7bxSte4H1z kITGitavjLbKgPWJ2D9IcRsueECEFxB7qYxwMLd6txW5uYdPWk9xhSqVSva9DwfImk/G6/acXAeN KPjViljyPyMMniav7HOK61YOUnUwTkqVOKqrCqiqKqqqqpSqqKqqqqblYUqlKpSqpVVVUqqGFRNa yio61cWjDVqmBVUqkpVVVVVUpSlKlVVUqqqqqqqqVVVVVVVSIiImFKIiIiIiIiIIlpRNUoiIiIgg gIiIIWlKqqpVVSlUqqVSqqVVVVFK0YYVFVVKp+xgmFVKVVSVSlVSkqqqoqaMGFKpNFNzLCqqqpVF KnoNWGVVRVKpVVJVK8xonFP2tnSrc3KrnSRububYyoZ3ZSdr+E/iy4z6bq/THJMbnJg+xaWTbRX/ 3KyllLKwWVld+30ZT/hJkq+9U+f5/9lUuw/ZVLVUvRXaVOX91JoEmSpgU9VUwSf00mKlRuVRRJFi IOv1/m7rjmOnu4b2h881cTz/Fqyo+OJ9s1yKlKKVMgT3MmSSJIA/YxER9X3qPnpubOwpG8sf2c3P f05rH3n85sPck/EnzmlfFuee+7/FtDbCvtzxxFa7zGn7jsfrOL5tzZOCaTyYyKeTs+1OrklnPD6y Eg1ZRLTEKL+6VkkO56GL7Pjr+3ptP2eSvVJretVY2mqwZN33/Tzfqb+Vs2Pl+MTgcUUY8f0/rdNH 6+d1XmU/e9E8jm4ftg3WgwdBPAVG/oxQ1PaNpL94XIBzLnoeQnzBac/526iuFRRvCuf4IiSM9r1Y x/oFw/5Aff4iDH18oFlSXm7mpDFAiHY7wQ5CP3BwJThQZDwUY8P+UHXjpwlYo828X68vT9CdUrSy h4H27AIPEYY/ipyO6HnUOA2kC/HEYCIbV3IQN6SnB2s/9Jb2gInlTV9MxhJWhn6j7wmEtz4B1/QY PsiHmd3oHcKCXdgVLyNiqc4G5btcN9P6nn61fOHy6TUZFgyMpkWUxZWUwsrKYWVhZTFlMkEnmQoT idpqTEn113xx5D7HLPRIKFVBYiqrBECL/aJxJhDYc6n7ObnrOY+bbkdcJJwUij5z2MtH0a4R+Ysg mVfjViaMRq4svUo56vR/w3NmW5s9g4fSIJ7/ZEI+PmhyU0TQJED5p/5PrKvm6J6xSoqeVPdMrE9z S1MrJy0NJy0tTFiaJSWCRIJGFlEGQpBNdU+pqSMk7t/8EqYe3f3c+muO7Rzc0/x6c03Seyx1310n zlh98kID/o96ff695yHxVlYYw/qQxk7D8b6fHz3htucR9R8ylR+kUcTj28HaeToOaGlWK8AylwU7 EEPwCYNKQS5ascWtgtg3REDMqbypqo6OLw+Dw6++e+eNqaTVxOnUm//j7ZH749DhteXc5ssFjs29 G/MSMGQfT29nTr2aHkaYMhSrIzDAqF1A5hEUQ6glaci57xTetVlwKmWDNTD6E7mXU8nc4yzrxvui OmOhyzDiDbeBEP0zCsvwFG3L6BZRjyXZQU9vTw7XGJFHSij/h8hRtf1elr5fnVZ4L18G3UzX2pqc y5nxlKSLNNWXs/nJft8+Td6qVInPDwXHpc05GZe1Z+K+LeJBCChvMjDseomOCikSm1vTa0x+bJ+k TQ5sDP5SjBLKs4L2ezwjbLU53eve2Q9bdpeF2o8Us+bwMBsNJZcMzf1hWRrKnFO8Mn6xIsfas+Ov EBlVULTUgm3sr2J8drzvay1NLsqhzabY97x/Zn929d4EZdu/s9n/osPRnV/z8PLnx8c+vnM7pgdk KSkaoiRQikYMBgwYMjBIMGMEjBjBlqDJjdQoUWW6fEO1USokU7kLh61AyL3qc1V2uzCs/KC/byp4 xX1ynUj+4JW8BRE8hUUVBxRMKhhERPzM/BR3oKIgaSGmOGYUUTNYUYYm1eDQbcMWx2QVz6df6J3p 8DzOnF3vIOwOBqBtpsM1kRXKQYOIFtiXhwn245j68cnfyMC0XnsTXM7vEeU5P7U7WFVhMO6T6k5p yvmxYjoMlRuWfzGvrs4d2L5MY8/u5brpXsY0z2aGveVPWn6lTuVMVMVOSp73BPB9L9Sp/bVL3llU uJ0Rep/U7FT0Km6oYYC7FT0YWQDiyI9b+j6rdWTLGDKyZYsiyCkYJFCJEjBSahbYDBhGZWTCyYWT CyZk1NTUxZMojP0JYMGMEYMGDEgxIMYMZlkezPWnRUy+X71ruMuTMs8IxjWTmPl6+m5VlxpxDj07 VbrsOb+62dwycOCptGyYNKmVqZVk5tJqePfO/D68450UwuNDGyncmk5Bgnee+W6bI8FpNU65wvJ+ XLx4pwcu9O1PAqam7e6Lhvk4sxdbc0to7pwq1MmtmXa0m03mk1NT9+p9ObDy2NUyxVRRYqosWLLF WLHr5jw0iPX0ZnCqqqqqqqqqqqqqwZ7ipqdhcoPCzKvDZNOLgZmMjLJ6XpegwrtVVNyqp+t+hg6K WpwquC1/G4V5qwp+vHUv+v25ZtpW1vW9HO1nnbYfIfEWOhnc+BXoTJKPYUckwxlMlmeFB4JIiRGa ZRPkm3BMSjArQqGIYgyJ6pUGXNaNSVOEkwTTAxUcLRo1FCUQleEILWftYC7+6gfub3ScMJtgeGLB QRgonysDygoYyVh2wgglVCGJWCycc0JpMtkpShaUEQpS0GSukxiwiihMp2tNKGLgHeXY5AIEMbY5 SNgiH1SgOizExF7GPdFoht97TNtHQZkMZvvIZtnTG39icodPEOPJym9US96DJzIYXZEM6bSyEJEK 3mTFMlwOlrvVXLy6en1M2VkRkw0P6oiqM133T+h/mAkQX4+JzlDxpv4HE6yekuoe0TiYX9CtFfib l0LY9jwcn8yuAPFyOR2PUaXc/G5PyDiP9s3TCY5LWtTXhq/qF+Sn9D/BDmeT+SnzO5llhZ6R2z7j s+noxjGMY+dNNa1bbbbWM/cf+I9TQdhQpqT9330Xo/qIQe4YehQ2fc9u970kf7Gj/BCtGqvcbzJl E0EBwxzXu/L8Gf9r0tKxUrQIwSCi4aapZovytR9K9p8vP5/dC3TN5jWkY/8eHo/ufelm9D8mi6tv uiEZ+JaD8fYfPm7AKbPmwo2Pdd1471UJ5rtSuIiKuHMUHL0bFxplXckCs4xIGZ75MGeadiyCcudy ZGewNDuQ90Em6D1nvX7IhwdwoJlEFY+oNtCBS/7RuTnKTWm0SElS6onGrQqGxIxC9vf+/zJGZkut x3WulIazwN+6A6nXvYiKVy1X3Jd7TnI/sPz1jzODgVz7xRTYEVARhNl2hlQ2dkVRWpwYAMTn1YnB gaq7ZafANJCCKbiCL3CD13BtHvRmqXDcDb6AmBQDFQ64OG5kSqjbqxuefaj2HQYctH8f7fp11upD uq01b8qj2y+snTOe+V7N7kFWVpqZ8Kre/PIMHtUdT2ZLhcKpZZKWWAUZPH5/4m0af+h6zz9P8T+e P3szHwC392/rEPWE9PyGE5r5KdewYB0Oi+Hm2veNEV1RVDC+Hv7qRxIaYbP8V5CzIsJ4qgwsD7Tl UnFHMm05GJyZHAGFsqQFn6S5KVqWJpB0gvreAQqwMt6u08wjVZPAWxKf7LfAgX7X+T3XYaCqq/AD qCDjpXwJ4nMbcOqHAnXrwAjD989slPJNCqEoLF78RiWlLnziLwVFFClagwSFA3Dke/kHAoAukV7r NqCspwYHdvz5Py9dHIXeguvQHd1Ybjgc08yhQjaTVrl8ybRmWctizlRVWGRP7RLFQXS0ZXlazSoM 5KDF4F5NafYcJhQGLO6LOE+rbgEm6H8jXqZl2wUPF2yMgyq2sSEOGJq8VEktiNCYRJIICQCVfVqX oGASn9S/c59acjVKX0DLnIYU2VV/YYmLpbhmhWbsLLiSzBmho5hqt1zYVm7BvnG5tukuFOGmy5t2 /1D2lUSoquIxRj/QnLw8EppTgreKiD+UhnAb/Myrx7zy1QiHWOQlSEK6n5K/lY9IE57hAIp+/n+9 KFdHgldT6/xJU2bYebjWMQTyA7zyL4zRx7u037/0cZyfBTniW2ydZZx1WSclDoFhkRARu5diPuI2 VETgSp8T/AjdY2kPVouRPfyNJQIzaY41GuqxaSebN7aOKqRox7ZAVVVeX4OS2YiR4FRqnl90j/gR zk1wf1h9IXmVvmcD1B7gYxRsL0Ft829l6xogiJ43tkeNAoDn4ktZcLQmpYMsuFGlK8Dtv9ZK0RGs xZUT7FuTgePOv+P4Q37SFscPYTzWVUdQ5PFjudd6r3el35mefHW3YovSXeQxSXSkApB9wQyCJuCm 6MyKygoqgMLEnRMQEYRn5pE5IOZC5INDxm87OZWfgrDii0fHvCmlQWFOS/YEBhEilv9kD3hpoEjU SeDUmWJf62JelCR5hUkQDsn7UTZL6/ZXTxv5+2jD/iNbkPn68mezA+udBv/Fr86qqIqooq7h/Mlu 8YkSxCNJwwSFH2CH5vw6ZU1IL6aIkvUe9S0QlH7dneuuOT/DSL6O0lBhmWDP9h6Cn4ByQ+Wxr+w8 q/aqaZ00L+Co/ngMKq/EpGnzs3ziYotA5F0ydhjwFA9pOAikiBKwQ+OzCMzDImoIxA8IuIaqVCgw oWURxOcLEjXjbEM2oywhCWY+c/QZKc/DtUW3u7lSd+mLwtdeHrN8r3Rt8VYmWHKTQZQwVQ8qMSyc hGDMI84Z2MBIqQ/qKG1pmiwuRgFSSJ0YqUDmtjYUU3jKIJUJwAcIaxDCUVYT4JvqRdVyo/QLsU1z E+NqFOIiWPUOKEybThelUeMp8qo62jGjD73I0d5gY3NzmOMLyXi6+FHNRDgE03Depscj8T776/8X RU3c7wvhlprFeA8kZqyY1GppqYZPxytJ07XRMJvmGVvvjRkyZbab/ZXCpGpfR2jtHBLb2I7PYTpU nT63dzqc8fqq8hZSXTFTHczhxep2/3ufKDeRioTB3HYfx8HC0QY+dhPxFuEOvgrOqUbtZ+8sZfxV HakjoeIZN85GGjhv7u3HYeSpLT+mSN8eV5dFxdtEif5OpUxVsiKT4mjGMeyecm71qnnaDiY+1HJl 7k8GTJVYHfz9OPB4FxxHmWCuZBhEQVBBE36RCZq8CVUF5RC5FIKehP64zj6Cpw+N38105d0cD611 WeJHcPNzSVW87VRJ8/n4FQ8RQYiaERd23MFwJb9ST2rF2qdPXOHdKTG3DTdUvl1Ym08Gdbxt2fEb jX2dbuT0oVVhYw0xioxUOhh0GKcnR39srQafr5IHJErGNG5KcZAgGuAJHeHJzvqIxsask2ng7wdQ dUWSo6nOjtSy1UhaklqIqBUOk935+xzPX92nDThu/y121eB6uqQ26WHiepps9pqNPS1j8Gq6N3mK nyDPmOH1aduciztVS4a8zdrTT6lUs0TjOZ6GWSpMvTU4qmWDysOxptv60yjadbzP4AegHoSSEQ3+ 2be8KY1JyeCztBGMWnKizqECvtPARkjL193czxsEw0YwXMw9kgp2pFzX1CIhWMQwqA2CbIdNgoEo R4WdhsBOIxf7RlnO/6mJzT0tuxfkKrTLlMVWHrBvoRukqkV1bMvRUngD2CDnIPHJFBIoewDygm+N bPyqQr+2REH3YiIMcD95nbo0PGzEX9TV4UlZqSnbqEa0GUSDvJpRo6txsB0MoiHAhvL+o5XJLVo7 ZFihS4fgXH10pruDIIiDG9yBfRXO/afqDmGakEiLTPCTfTTzyyikCASQNhB/YHJA0qT9pzno0uG3 BVtnyfb35eHl73XOUabOr2m/a8rj2IDdVSieyZLw7MSfXsp9hBltP9GxGEaaeJiZxcxQJh9AL2rD mnuMeP5cllIIKqyIhfXTaQJ5oScVY60Wv3Q9ecHz/nPx4r8NU5r81fv/nz979zLpXmMTelqclYKT eMIVjCEZzjShZOnm31KCj+O5x65rzUKL7z9xIV6ifel8qeuPmTidO35DuJ97yKpeDY3ozwjmRUWP 0nHVHL054X6uOM/rLs/FJIl6D2ujv2vxLwZj8TiTgbudvbjfF8TYwKE3KiwsklYd2/6+Dnc39pcN sc/Fa8RkUDL6qTiIJopo4Q7Fv3a+t7DwfxHU/yH+Uk/e+Zzqrc8avmb1V86v5KqvcU0VruaOgy0M OTrbV3aRr+J9StG9uOtSSNCqmy5PM0bnRcp/vzcf3vXt0VOip489fbwMZj4GA5rndxypthpwn6Ek ibOtq8ev6t2+PcdCawRPchG38ngixloppR4tAuqtX17taHqmMaRGFNYJqVxh5mZqnMTToU3zWJX8 t9HHF+/70GL/UvL6uy1XShR5/PHO/9RY71KYXCLd8pH6q9rxJVSurAqIQRDWFhtw5bESi8w+Zu7A fwhxNqYoaAOFDd2nBZPKmSnYRyf14TMUzPCoWaWC0P2WTF1IegSoxBpUaULM+WK6JopwI3FiaUPM VbiF7QEkZGRRBUSMiiCvuEP6qwXEj1wYnArCO8TE5E4f0mwgVBEeZLJ1lZIkioxgw/lkh3ZV90nN N06zRMOx6w9fa2OHeb/u3Glrzn+7oxfOYpXijvR/Lz75u4XDaNo8R1cWBZ57Av4Ab0BCogqDh5X8 iugrr+TwgML7ep4/8ftDmWJpTZvreIR+xX+Kzef6+rRN15oTaDhsMOslFain8P724INaYTtEc73+ 0lH+snh72tNavFXqCgw63BRsgzS3tD1Y9wPYo2FgNDKxP8Al3r9H95Fwus1kunzEn+De7OvAQnNq 0CQQDgLrIHHFRGZEhO20GXAr2M2vaRUSJ/iY94RkOEgkJrgkiP7zDJiFy0An0YkXhU+slU3SMYEC q0DVmxSGixpNOoe2QRr4Vn7yJIFNSB1HPrUeQdNWIIQ8/9ZKUfFmQKq689lbws3QhR9GYTvWpAiO If0Q5iViBBU4ZxXqzFWHVe/mTDsEjgz+8iRD0T37zofIcY71f0ObgiNj2Qx7O04119m7oNJyxDgK FLlCdRReblTxEPVjzE2DgQ5CHdHz71O4L811YLlkLCFUiKnjv5EMx+w/oQqB4+AaInzhUk4Dv6Yd 0YDpUdhKSsw4urpc6qwyOOkz7WJXamyO0ap6nm8/N4nVtG/hMHmyv60+2vrnH2bP/kQ/1X05ZOoU md3++kCix5MNJ3KwYU+f1EoB36suBBfJQrbxmIeCC0xNJqD1Fs8eZ6nhpuXc2LjUzlrwRxRx1fir gOsUcW93M976XQfg4Hwut4nW6TVuV1mSpk6XuMntJ7m4lBjcuMLmSpKDDGVZVhBwfPtaHMJMT430 Oib2TMmGN6tnrTWnI+/6fE7vC2fd8OEMCHx1hnfPq54VecmkimuVnCCxlZBBEgB7kqnO6m/Mxer4 u10RSDqOqhZWovASGXUjQ6MPMxuo4N+1s5cKfWnKcmOf8aPd0ueGZJLpi0IRaTwqW5dSqiZON3Q6 iGWQZC4nZEDjWU2bIcKGdcneOQSRYCTugVW6p9QaBEwmU6r5H2unkc9vIPriIghRxjqFet9GEnZN s4uZbYIRPlrX3l0g82YfcFgmZkmsvf/NdEcdvLCocoGTRI4kCdccMLOu6My456hDPMDsdohynrQo Oa4Y6N3Q+tA3D/jPAs9l5S9x/l+Ub8qMU/dY4CY0iQN5Rd9pNRFbHwq6wZpjOzHincv9kZKkq48a j6sWIflhGfm3zmbjXq8tptkYkYLOz19EmGas+l5MRuKIqJFKd7VISjKn+94joKZ8f8/yrEWJws5h dfCGJ3zOMOTORhw+8cGJvNZKDsLjnKCeZ6npsHR5HtLCMd5WZYx1OQyhkG20vGGfpHmbNP4mP8ts OnzHeZuQ3FlO1VhGHfCq1UXCjkdiLEPCEncF9oPJfnYkXCAsrlg+sZKIvMwxZUMKzZx62POs0LS/ go8RZvrd8bez6J2J2u3lQqdHOQo0g2B6c+by1GrEyemhGGWGiMNLI8NCB4xnbRNxSpEJqDHtIj5o GtAyRYXU4RwUF3LiML92dx4L4CgVL8leLLO+urSJsyu2vHGe9u8nQ4vXPvLTtsysmXeVqnS9O3Lk QmIKgqGZGtNZxBQYLLEvPUOwMmVtp2bW0fkaBj+OrA31EgrzVVFFSMqm+gEnk3M3OYKTRsN7x1l/ t+mdcMzMNoYQS7/R2taY+k/yKOykweZMnN5H1eNp7+ry2tgcAJiCGBBbKy9ly8r957wNRDzDkFv5 0jzvqPzfdoaTFc+5RhbQem0SZv4/xn17la6HrMD1owh11OoKDUXTiRs+w7KK8bNaNgiG8pNz/b0p +iEIx0/QN0pJuFdcRRr1UrIlJqXYajeJHo2j3yd3ELwq83R55jTQ4ppjCre0+lnJVWivJ4RIrSmK y4Q9qHRuUpN+p4CEhDPp80EICFO0prkgnNlgNC8GMGZEU6nRCn5B3nYJhMICYfxDRqv5UzGc2R1V VNFaPZvLIaJpWu8IE20eUPtjEm05/YelIQk8t9vwJ+Esu0er2PP07Nz0beenM6pLJ9ufJ2q6US6x I5LPD2Z6ycE74q/ZT8DF7evrCJl5N/Rz/z83V597XlhfLsyJJonpLGCva9yev7/6W/w/l/j/l98p S6h3hy0qOH3A+uoEDzg3DB7yKJI7H+sYBxEmTmIH2lj7AyiR9R5gwi287Rt+f6/enWTfyWfrz7sq qqq/NFIQ0h75QNCse2+fnvdq2jzEREIiIhlAZVMKrMRzMhzdx6XEd/etLHPqJMzOHvaihOjKsHQY 9fs9h7D1CId4Z7div3snwfvXvgjsznguq9eknSawZvyh87xXt6+7u/WBipqfjU2W+vFKWZPEQDTy PvLilFPVY7zIX9AYUBEsz7EUFlhH2HU7kiCSD+cx07d+eVmoWP2DLeLlJ7aurzkN/iULu0T7uboN FG44W24dbvMWIvIpMiGxRaFC6ryEKomDAop+kEmYJzLh+Q6H9oqGoTceKjpUw2CeqEYTX4TjijKl J/CMJEvLh4BKTTrVlQ5ooiIRj5qj/WHQdRSasaUA1BQRA1jIkNmrvDWDqat64yvA9kkT9sJeHeaq qqqqqq39Lm5dnf1/u9HI8B3eEnmGjn6/wNmDMaiolBDUzz2hoHsrZVNyZz1jFQVnwhsnbvtW1YMG 7U0mTJiZWTBkqLFjXEYksUWLGnNq6+h2sft5ns39d5uYKlQOUOQJrubw08mNIG5hmfQT2iSgY1m4 2uW2CMIaZd768XFjR7Yht0CsgjOgpRDgNshOE2tTU5zRu7P3MOM5jxuhyeydzc8jiekTihu15u/L matHU/D5vEfjPGwn21JGUkUj8SmioKqSlG8pJurKtSo1SobGE4Mg3myVo440uCmjdg0lkOO3nk5Z GhGh63Mqmer1yTsSxTU2IiIiIiJQP2whwdnE0uVJCjCh9Fe7xF2VI6N8bDOpaUKEdHj2+9ZdiPw7 6ylaTKueKbvcZIjC+GXnzvQ80vucWpv63pA9BMPxwjp82r3v8pQl0vhdZMVV8U53SHijtTtmJnzw ov8Y/6/MfcW/nD847aRd/aHqX+ppQq6O58UVdZEWu37qz+vE4VjML4uXNRrSrtakJilozAL9I0WD tFZUVNVSyw9p5DW1JUmPhcE9FKNKmOsoyo81lnZ0wqXrebWi1UoEwiH+IV2pas6SlizLNmhJW8oU UkusYEFKOVJMUc4it1Wd6vPNdNyROi05D4zWJZTRHq5AH0gaBAHCpU0co2J008JUOLWKnIcQwGM4 DJfOHihC2l8WB1WeVt/BpVq+YFLs4aE9A0E2tSXBOL0+fbQwa2MhQay7yyixVdNaQbYhHBYNxb4W dJPqtcTtLSVrRMzvS0pbXAqWX7V+eXjNp6E7slJ+HWn1mfRrzbfRSUbRg8virJgmVrC2FV62u1tr OtQu1pDpWAQYqXRyl3rKs50WNwtO01jVq0M8ru/smHGLzrdzSroRIdgQAOSggIRQYNfmAeXpk1eD HymM41yMsnBd4rKjTh/YFX9QN1nCU7uf1ibhyEzp41Gik1PKBD5UCzeja6EgXQWFrwGg0SEWtGsy L2moa92se7N4HjF5Gh6iZYrdrU9YQPSbP+Cv9YN7LacECx2Et84dQobiUm2OTyDc8D8iZ3FBVYRZ owbCoOo9VGNVtVpLo15hDE1iOLT6xmlGjUvKmwTYnBnLDq8BUBxQ+77/nHSPkcnR1WZ6HhoaniEQ wgz18xqnwvU/tZ0LOD19Ve4ElFhq0UoA4FjHizFU4dgeorfBdjzmhaLh8MMA/izxIxE9hqdRDqkN zHkIKOGBs92Ip7YNoamZAqkKd8l7wgfULspUJjGRg9QiIpXvlL2ihoVQ5Cad9fHvXLqFyCGQl+65 SkYdM31mxZaDUdl9TsQX7yRBFNO4kbgcGA3JDHeeQnEbhVpAzoclxRlbGQLBgDD7ECHiVfwLVQUa fyGYsFZEhghMwIVIpDggyFgTQgFUBQtAbSg2yUZO5Jogx0vIrsqYAnhdC3NeS9BqRKslZU4A7CiK hCK0kMNMmfSaF3+YyHk5C1XtYHkSnMn7hcL67Pn4sGN36GIZHDbGdcGMLmnfF9TnYdsO0RwM5Xlu fudOTJPw6+L2tg2QjA/KnK9m9IXoIc9qw8RkYVVgqw6w90fCpKMDCU9Q459ZDkbpciahkhgc9Q5o amiGd+TSXkHan4mSDCDCkz0AnwZY2uzbbSjs+qED0OQT8UOBJnhfBhaUG+lw5UbBHeIMjhE3g/K5 ZyfU7nqsOzt21W9xVpORlZ/EKh8SrVyJihAZhaEHl5AszXlF4ZqjbimT7Zl8bSLcd7aQDKonD25L HmUWZMvTAdhOyFg+gORiZaJVYrGL9XYsXB7waSDaAxRR8AzDii2tC+u88EzkLUKarKpCKZn95I7E USeJsWrPPGsOovNh0eMXNzkvIifnPjYZs84nQT5xHgiiVEbm9fVnBc3WvJrI5PQiQ4MhReApfrQf ODKQ+Q4qOCVopqjoezbU0RqJzxQHBDvAswhyxATA4wYCwTlq7QjOR9o2fi2P4/LWjEOc1i9W9RQ8 3pPx1iPOqF4+N8jbVb3UsPwHcJMFFb0WzlFQfrREgYID0ql6KpZVLP527kcFf6zZwP7na08125ez 9b8qvSaNWh8JxVJ9xTUqO9Uk8ik5mD8phP4zE/Yfzk0MV2qn4UkZOKSLIj3HmMm4fGp3Nn8lP2Kh 7VOYo9knOfOPI0fOodKs4YcldDDgbGif3sNWSv2NWXOsR4KHAywXaC971tKp0TCp/ZFYqn+x6nym 4wps1SOxKk/VMn8HE5GTqPG9jQ0MmGX8Ghk1KVWDhOsyaq1V5WWD1lPmK2b36TDL+IpwKdKh1vud qZHuVOZhg5K62GGSup6Xe4s4TBs2Y2NUU7XqcHFdiOBP72bspW+Gz/QPsY/S0xJplpkMZVVYxVJ9 nh/D9b/I9rcSfLMYfRD7bP47vo3T0uD8U/PxhByfzTWH9m0E1dz1utpp8jljf2PG5n1KfiV6VNFf Keh1vW6n79z5GPYm8dRUFur2qxCfa4W2mf82Gnp06mjOdPkfS+bY+51csvjjuWScLLZ46snPNkJw iziEVRRgKH2ElVPRqL+skDQhofeMQ/mzZB/keBj1qup/IqUJn6Sh8Ii4djJ0OLCTY8x4MOTk8SvZ OuQeb2vx/tcx/aw7vv/W/Dv0LF/U9BU3fS+I9T5nIPWfH9z3xEnpQnwPG9rJSnU9Kq0fueRhU9J0 nAjs8LfYj0CTmfyeDwOhPEne6TnaHgfMbqXU5PSev0uaxeqSvSV4Pve5yHFyVXAw5MOlVVVVl+9V VVV70wbnytTJzEcnZOKqcWHlKcCuZh2oPJ5P6T9h/yNjJ1t03p+DDtZc6vU1Pmng4kRgJIkJoUdf oPKp7Zz17dkkkkkkvcGA9h7HyfiI+EOBwOBxOhzcujot6DiOd2p0qrtfr93JJHlIrs+1N757xk6e /j6DPmc59b+s6jLqHk+lPsFFF0+okQM8w2Oh8g9YdbqZODUREOD+V5CpyfiKnNhUxsVPY0PxKdDn bOt7OMrnSZKyqdFX7nkdrueh+d2Pe/5uTr9vHhmYxnqQnU/ueJ4EW2SEkj/NSqn1VFK/xYwiVY+R FZZYi1asuZl9Fpasv7zC/QxRbGQYrGLCuIxjFK0xXpGk00OjStmMKiKqqlUFCoiVaMjAohIkoUoF CkhVcQkofBT7RhDc4Oh/8w9nx8SC17Hfwes2NtBDYJpG1X+x1VpBIMa4/V2cOCLFTKpgx5FTtRYq e0xK+l9b9D75K8DJKw7F+k+ts8HwYK7mUy7zi1b38ysK1c7cYaMHzsu95mjmcz0m98X0/Tbb3z2c nwvwb27db3DpedJG91FKlVVVVHmDzrJ+uyEwoqke8wkeyIy/4TJx/Svzul1stTc8p6jc52mLTdaV Ob/WVNkd5kZlzZFYWLUqonOVnOCCoWCSfUMHzv6kmglJ20kMEtMlK+ZlMv2ysV/yD+lpjKS4r+th o4MOTTUpvaYYVow0P+zDUaxKYalMDOTCYiSKr/+2Giq0YSsNWWWzY1YNBlo3SVlkVoYNVmVassmV YUVVYTMVWSqXUw1K0KYaYTVUaA2JSmzRoTDQYRAwSmhMMGhSiQZ+k/qLLkgjOQySSMoaCQQygQzG P+zhbubgaLixGn9Cv+o88b0fqc2pWMxiphhhlK55H92SNsoVRpT7lf0w7HJJD0opHtfqRB8x+9VL wKnCnYMUwMQYql3KnBU0lbKmKmItkWGIsVNCppU0qHvYNkXdRaOJU4E/DRoqbJ+VOqfOnJqK+l/1 UVLIsWRUqYcyqqt3bbaqgxGCwRgopCAhIgDCMkIqogxhCKqrGQFBIECKqqqqqrCQgJJIkhIqqqqq kjEdqmiarKyGVTEGI/IkYpaQwUdxV88YFqpwqYSwlikZBXqittmzDFrTSlSqpUqqVKqlSqpUxImG FKlVSpVUqeUqOYqQlJFIrIwYJIwjd0e+/mV1fS+P9umj6b82Pm/oNf9LnBvOLrV+QX2kkhPZWKKi AsVYRjGCICiMVGKqEJCMAZIZKYLFWVlMJP3KxUxWMkyfhQBhPpTKr5TE80xcXOUxoZMpliZWViYm TLGDIREBQGMFWQRgqwUZBkPzF6Fg1VwNNm1V680qfk1omT2KmVcGzToORpRbqW6lgpoczCrFtsYD IYkiPekio8pTUp31TDGHIyrZlRycmGhtjRhbGjUL/yQ2KmHBHNUxG84DYWBwiwUWCiwUWCkUikUi yIgosFIpFIpFIpFOA7GRXUqcCpzVMcHEyLSndKB9SQ+VfO+x2u63XzjiacnfWlxbWrTHVdS4qpfm eZuu9g4JkL6qmN0x+wYwZKO6iZA2rtk0aZSocUbxo/L/+LZbMNDGOIaaaD61brzLGPYY5vZG6682 9t+3Ts2JaOCaKmjTGn3u6i0bv2tODHJo73DgzrrhwyNU/6MepUmolSpwYK7iSPEQ/UEgWEkSH8oU UR/MVBvOnyhy20DktV8/5f78fR1T7ZuT0Sf6JymU+Q/EVSqZT5z5ZOh+lHc1TesrV3jKRl5m5+f2 41jYlBkk6mN1tturCqYKVMKjBT2j+QKThIEVVVVVVVVVVVVtt1Jqn/n8TgpUo0aBVHU2H5GUYGim 50tBkbNGisjRDgSeomGajzqMPc9cgTnGhoiVUoU3FaTRhf1OBU5GBLtDcxwTZEGGROR8LCdCnOo3 K0fW5N5zNiNlJMsqwnkaMssqZSpFVlhoWyGg8zB9jFWljtdRjvNldVd5pzaUjBipjBUwxU0tH4Wl NGFbqsVYLDDR7WzTgCUoelCDChf5aW2222222222220hSJwcBc1bbbbbbbbbbeDCkMChU51KVuUV +hhN6u1SaNkYJhhhVUrnZOTmNUmCtVfSYSZVJvDmiRNQ3Hc7lVlhsmE0SsK1PlZPzqqiqqqKyaAQ DoAQKIhKGjpDQK0FaBsSRUZRVHJ/8v/hpwqN5wWVjkw0pqxBsEn3NCexWxqHibg0DvjfEbMvE3Tr aMKqqpUKqSbPMw2SnBhlkqsJqwqv+Awwy1cTRo2KMNUwopQd6elEqv51T+hkw+01TYqTRZ+v8hT2 RhhEl5tSt1mZiZMnBDaJ+KY+QeNhecdDWPIixok6lChhIo4pejrQ3cRu0xoaWMJ0cIr7iwk8T+5q jZT8rEyr1vytU+wkiwWIn+rJGzagf/0yqGMfSrIO5XzFTxX20i7nrdYN1y88V5Wl6WNif3nX/gEh vxZW7/2eTu7+hr6SwFIKe4/+RH/cf7zL/UVPrPlf4vGfFu/zYeCzM0YUwdjD3ne/ZFeD7o3R5n51 djsc7yu2f7lnS9DEkidOTk4x8aZZO86mr/Y1QnQ/W/7jV+9rw8T7nSfwMv1ukp+p5jgqvvcA4Pud ryTc7k7H3FUqngf0D/JX7xkw9R0zn/07GX3w/e/1hluexxOLuST/1O00+KPyvS+l/Icb2P8EW8S+ iUsI2tRpIyLGSMT+J/obBbL4MelX63xPkZMPifg+dwHkK6FdLfETmZMTBj/o+KpuqZ8d9a1prWZr WvSj8LEbosRzOLm73ItTBZNNG7T9dybzgdL525DzFeZ651sqntVoynzlaon8zVimy05rQ4qn4hU2 GsTMqzJlkFWRGRQFhBZJIoArERQSIqLIKQSKMUYxRYKsHknGLEZGQeZxR7zvToYd7D+taMPf7Pil rD+1g/NP3v8Wyabeo3n+xQHEskTFZVU/qqWRD4/4tOe+dNl+r4PL/7N/9Ntzq7n9/6v0du737p/4 s/bprP0MXCfJn6CTpqFH6JfR/xP/0/K/koVOvSxmXDOQrcoYYqQM21RaszEUrMopvk07jSAPmwq9 +5qYcpqejbbt29PVcU41o7WYwnNH1MKldJqf/aan5WujJnq0epWG9hWx+qZv/3xQ2azVsvpbnoMt D/efU4J+ovUP7vM58pp5qUvVrYsbFeHb9IbJ6t36+PHhHKvZ6eFvGYL2spVzW3rzaduqnO+o1P72 ThPHVqeOlUtGX+L/Fpsr061MdmiE6tr5c0mXdjg4A1hUtxiVkQCRgjBYM+lIVhjALD8v58kMZKhy 5/++9ulGbaio0btTwbPKx+0yrSMue9rd3dubi3PM+RtN8afI86o8bLD3P636WX71d6vsb3jatH+j iyy/0P6nndr+1qnJ0Mne0Tk6H0stlOd+Zg/qV5WWB9j3sJ83owYiO/OUT/8UkcVN/26+GZr9OJwf 6/3eRs87luUr/RsTW3c40BKnIlpBOzsSVlZT2qhdY3JOyoen9+GaH6PjK6rr/GZ1rZlf2DippmuW XLRQrNA9+5rDSaRR/jgTC2KpRSsbrM9rTUigqyZaNaJlsUFrSY7tJiNlKiIwRgosRVgH+VANaq/v aNy5lIY8eNZmm9Wbes3m95DeOlM1hy6/jzrWoidFNe2u78X11f+h4yz0rSCMRgpGlk7wstKHF0cX WGvDjhRMaZy5iezLp2/5tGYf9RnSEV4aX/SfX8dENgkqPgxfhxe3z3VptMW3/15+nxHjU5NGzoj+ 78j87Z4mz5e9P8U55geLVnEZ86R2Z+TxP2eB/c8R+o34TwP0nmT/vkYpIwUEYCxdkCWqqqgRBZAW KrIyKqskgsGCI5mcHcV3lYGUsomVgYLKTgi9E+iNklPmDzBgMllLK6DZ25mMzMQnOA+8i1FXVUrS 2pFtq29sOeg/8RR6I9rCPmsfmT8EP4pOExms8HhUVSK/OBSqiqK+4Uqoqiv0pVSQVRVFUVRVFUVR VFUVRVFUV+KSroKVUVRVFUVRVFUVRVFUVYqgqgqgqgqxVirEQVRQVQVYqxVirFWKsVRVFUVRVFfx ANh/gfempJCbIv/wqfcuU0jeqXs/nPlrlxzLFMozGZUypjMhhUdFXdVFsR9rEKTEkRz77fMROd9z RiOPq+5870HP793++ncD8wewQvsqqqqqr+iQ0QkMxdJ9eVccpHufsd7Y8vf2SS2i+Ex75lbRHdNS R+QZUfon0TRLViLqiLEjnjdj2XhWS3kYOHH2rloMrivdb549MD6EkEP9h/Tz/Kf0f1/PpVVVVVX+ g2/rkULOvUpRVmaGTumEpKsg+IcCHGyJMPWCh5Su4aSMLEUki+3i0zEefdza22222226Sdak5+ea 625aE06odUZR5PIjCPKjl6zxnEwfS7fxt8k6em3cfa6x17RHen1HnZjhwt4GUmc25PP8Hj6jr3kc jCSRKfZ5NIj5Nu0zseL5P3+eTVIOR8OOw3Qxjsttucj2fx+H3W3Rsep64symeFvjMoPf8Tbdifma SSX4PS93X5372/yO5/5Pvb0TyvBo9qmIh83lNKn5F0QWL2tmP3tl7ZFu8n1/6fNrsEQU+q3tp8/1 fuyIlr+EZLWM2PaVPhSFgQ+k1EEROVCGGRWVS2WtMqxVYrGFYMVhlEyiPKmeep2vN5Ps1nb2b/f5 W+wopRvPmx/6u12zQgV4z+W1+7FMVe7u7JL64+34xlL6eWkzwzmZrjnrO16If4Hh0Zkh8PlHmUrs q2fAqKsnNz4EbnSvsdRxpNsW4Rgn639aMaVLLKttmL99T+vOCfpHJ+D4m5tW/fd7WOGGOS4JY5lu WIn0PY/pE/I7P6SQ/7T/dfsaac26p3HcrtTt7vZja8xrVwa1lmYoR/enwHOjesSUYGFpZS3KTMwz Byd49p/H1bx9Z+06nvNDtZdJ4jBU+48HnbmjUpgfoMO40NmUw1MvOn1uwy8z8Z+2L3E+VYT4MdXI YeDZGx3VaDnPcbGUkaqHJTeoexl+5H8EjrSGkyK96xhh9D7HwaY2t21aNmCncqYeTk+R5H5X0NDu VO15mH8lTey3uRzK+RzvG8E+0qJ1qkiz6+lhll7et5t+HtODnjmnPNyKxqW2xqW2ttRPyDg4Tjjj hd260Zi2lLR+ZwRMmtI2poER9bTnaKrLubmx5WGzDQ/Wr/4eZJHA6vj7LaqlKrR3+iuYfrfpfvfU 3AmzZh0vM2Nz8jC4JWMliXlV4BrRwHg8rY4J87/ucXzVetkxORyXxlA7E7JUeJrmEnVZJYW1bIha OZKRK3IYUGhqnJ6SaPISG4pg/gYfQqZV97mVvMHufsOTY4lRHBMk/2q+9l4MuhTDYwqtz5DJlqrx xOybSmqtFOcdQweUtbDKFQorLEvpKmI/W+c1V066OIzWRtlaxaeLcmFyjxI+i1asl2qfD9D9jEww 3vz73kUd7638j6D/0fKec+r9lvv/F1Di/Xt5ph9mfq7MXT/1/Dc/cKa8thvyRVVV5kUIC+gonepL lnk/8P2N+qzkYRDQOB5nRyfnfmcH0m6Nz+D3un2sRu5P5qnbQp6UwjNdrkdHU9H1D9Q0GR+Qj4A+ UKP2EW2qsjwSHhJVKsOCW2rbRpZVSiQoinYQA7gsWLJIJksZSulI6QOcVmMxz+X2+cbPp38f5/Vy oH97BueH90fSLes5aE0QQDyFEJ5jy3iBn4e3jl8DtXl+Jk+Gc6E18PhY/b1+roRHx4ew9nqPWKKS +eIn6xQQp6QiLR2D3xjDGW9XOPt+r3k7+Ms/VDEEyinvd/Wpf5WsYrqj2TBt/DkrENTmfF05coU3 CnROMCwkfEFkkvwKMczH0k5ys07JH6f5FpKk3jmp2RlPMTkjKyiqp8jr+vBetdWKs8IqrxZoetjS X1xGkoN7XPboHJ2kTrzyojZFmpJUUjghrKP+HV6S9dmzQ2WTL0/vdnkBNakYxITUi3IIsmmZX0be ofoCjS+uRR4eeSMF9WJMD/SGn3kWNM+V6K6yL34j2mzK1ln5gp4lRggElD5mGUukFPDxi6Kakr+8 6Dmp3NLMHoDrWuIEE9h15H1UI/Fv6x7rVU+68nVPyP0giKJ/yVsH/e2XR+VxbP+itBfBiqes/vPw vzvK9ir+lU/mMQvUxt5FQ06rV8+5ytl1f4plJJ6Un+qTtcp6H5D/i+OPbLbailW1YssSxbIf4zoP 7P6Y8dSfufyLhTUqHzrPvH9z+L6X3P2n1HS5J5CVxe98z4HicGjyPkPU+x7299qtT3tFZaNziy5N x8TxtWWW5yHvbnYr/YrpanJ3KmpydLc0Mv+qsN74XQfIalec5nSrU9acx1MOhh4Hc/U/kbNlfAc5 uPIcGFdhzGj9TZ4nQ53pcFe1wavBzHjel7j+x0HrHqaxhJ8ipo9bSNp/a/5uZW1LKyksKylgwXMx 4lJIcGzZhkUeB5m5HifmfzTxn7k3P2IQBRhyS+QiePb0pLv+b9fv/f8Y+9vT03j/ppPx98ofHr00 /6Nr/I6/xh3/LZc+b+F8eH092vVu/vn3PD1myO/nr12fkf6jkOVRCImPjrC+P0HthImVYMHkzSKc Cj7R4kPqKjxLlWEwYwmKjpd7DS25JCbeX1ePw0+h5/na/KU/YcdK9ZW9Xp6d2cVY8qjbRjst28+Z LuMqd6idwokXx4LXje2PG/g0NaTbBhWElk/tsYsHSaOjCkw0oivbQQ4aqzLLPJ+J4EG5fqy8tLYu qBlBMy5i4lHNWWUMqilMN44kwmYONqK1EQL/alZCRd+MMSrGFRiEaNrvx3pIR6fYx2PQ83pSIHgL j0vaXXx8aeXTHrvr3+vEMa666a6+YuY+TqxoDHtCPI3EREbpnE8enhypTn7sXtaV9+m6yFNh2NjT g9brBMW5aTpGUsRxZYhRi0FfSWK6d2nG8ZZLGRjcRTdDWU98c+esIyv+suBscuC9sPTaoQLFqlc8 X3jI9BlO0PLWtStckQrMa8+PX+v88f5PzAfo/3tXfdvbhbatm3muIqTd9j+h8zDuVXr/eMREP4Fg f4Cm6kkST08fsZcD3J+Q/k50/7bH84y/ajzvieDi+5h6PTxPGeyjsfF5/pxjGMWyqspUqW222222 URllRojRS20qKIjVRKlS/vzDLbbhmYzIqxSKs8CoWxJarX/uBAZPUiNp3ORfjbLDcTijnumcmLSb i4TSg5KpXTlXSjCkJgQ6CTkhMFwGSnMpsmVMYmKZHIpsLC2iyWRSVVLGiDeSZIb4hvRTIKQzENIU WraiyWWlLatkihZI3kMIhzH8j8pvdiSbJ8n0NxWjA0b6WJlosuh8YonLqe70tIIMelOG7Hccg/sJ 9fwoGH1n+hcCtj73R2tNNG7uakuwx+P+I70keJPM73Q7H485TgfMerB3V0qckCUn52Er+RUwpOkv K9vTXyL4urk+m9haNm8wnMSEsO1/FgghgU72ye579HlfiR1OvciD4GfEfUpHJIpVKqpXby9r8Sdr Z0Ht5n6jJ8k/O6lV7HEeJAnt8HW0HaZV3+Vk3G5l5/OmgkR0A2dRXe3VxecRc72OnTRmc0ms5bmz iTNdBXc8W/xjQ5qes/oTzdhI7FIqUIqQjyk7SvlVkZV8ijgVTjuHjqx32572DvfK0XY+s09qvru3 sCPnDrzabjDUw+MyewA+U0Mq2e9sevQE6seT1+qk1D4HsbMj1lPH1EYHSWfKu3t0edhjKqT1sI+g xJjDmVh3dzgr0v9Gp6injSofsSkelT4KcR8DD3Ji8iC3el7F4ejc4ILD2er5rmvUT3BciaUQExDv 8jsdCRf07xD47qIvvFQVBmZmtt94GsFLaCCiv9JBganZDYQwjgm6cEwt02E1DCcU4JxTinBNk85O JNk3TEtJ7XXso8u7RTo88kh7DrepsSfAeHhHLQ/BOvmXwcx5WxojxMHnWKrwfpSNgg4NF+M97Dc6 FV5jufe7Su1c+9p3uip0X3HEu551O47XpeQkh1kkfI6Xh/ZjznF2HW+Jymjy1JHyJT0O9Defgepz Olzq5OLqex4mr4VcxxUrewwV9ivWqTzvOw4sKZUrB9w5AsKfPzRO/lbHgAmg6fYaCczyL/OYCafR 7COPkdt2Nvd0oVz0XrV2uzqr5Hueh8rvj4n8ri1eD0drc+1o8HqMMODc87VhZq/g4vE/mbn/J8h8 j5FT6xcfq/fty9/R/zJ+4djPqf2xMLSEr0ene56lT54jWyezMTBhG76sL7MvK/92rTjXpyjRPI5O T8kERCI/u3Pe9TLbTXxwOjCduXBONlRbY5ZX+CGKgVM195+8oe56lPB68mfMSmi6XyJ6b3ckSPYe o0OsJn7u2EfKu0UuCjERT/IcmfxPlEFmD6SEfOSDD7gSVATxXE+WvCsxT+AhkNyPM7zoEiEp8jBy IHI5HIcmVPIqfQWl2gTHgH+zQof0JEg+R6B6iECVfL3MhmXNZqQPTJB/ao/5zGeExoIWaDsL5XWU AVaxFuoUjkic+UPMnb4uoIV1iV2HbkfSgfzvN0Y46Zu+Oy+m8LKnRLaOzskHYXh3IrAVS12Uf3b7 fpl2pbnm0oZfAeuLxi0uxYYksvGUO5fK8nPADvbt3Nqv5zur/7xETg+cQ18vo2c+75fssTPfPMoz an0MyrSFn9sXeLkT6/j9kuNz7H7xTgfe+vTwPZ53Aw+OySNfg7/ge649nuuHv2xw7NPZptYx7mWm VqbJtLpWT1zQ3jv1zcHhN997dvOd9Nd9O7pOP46xWLacei4anVbly5T4z9Sc59s4nOXknKd8+afG c59k886TveMeedblWTzzTy9s8/hzrzdnGdPOsWYsW049Fw1O1cuU884zzTjXmnCd080805TzTzTv nkjvdmL0V2VmV4Lo1OCYnkkkHEIIKhokRhD50NEJIVQ5IbIaLamGtpRWMUaM4dIGiCheKHkCnQ3I mCiJqSUTQ0ESKXHbFmparsbZmYu4uxN5znVMi0nGdJ2puTlMndXEaTZPGeM5TtnON0FLITQKqqOg VQwJDecNIT1srGlGjOG0ByNzxvzlpOhqy/QPkYYk/sTtex8Z/1SbzZH71b30k/KfWhhWpzOSfO/5 k3pK1hyG8mk/w+/6X2e4e/XnP4N/npl2VbKWqsqkW4kj/edKTB8LyMHmPe9rsOOpzWMS0ss7MWRZ F/GWvxbLZbFu2p++v4GlP0MEaJB2tjJm2Er/pTHyvrQehSvaep+DKQ1TRrXwRZJGn42umWmPyZ23 43bCthmbRMEagdmmhsdTGbMggqz/SLBBQmwQmLJCAQETjtEjFIKJQmc0WLHNrdw4cK3dGqwLfYab W2KT9dV/l7n9Kp/H/HpL+qj8WMrGUyp82JNYzLbbb+H5bjHswtkaH43wOx+Rqn3JQ2IlUKlRypUo VGT8bMfqn9RVWr9Csfqk366wtB9xGQDyUjHkeR3NnY73keRzhcFMSyXNzNINNNNJAbWYYEaaaQaa aaSGsNFJSrJFSyt7e3st7e3t7eBrVrdvxnOcb7bJGib29ub3uPG872nqDLLA+Ykj6EfE+9950og9 zpdJ3pp293dnWTZHVEhBQftFGSzJkoRIhFQkkJJIkQhk6oCwhB5Ej+SWRGr065o9MiOBQDwQ94gy Hqrabra+Ic40OCmq3LSNqaS+lPCdyfom9WTwTlOSfRNk4TkmT+CfSXknNPROTLHQvoHOeSvOn4rm v4X1XS8qc3V0mTlamrzTFs1MWty8k8s1Mm88s2TyTyOQ8jedbwvC8LwvqXnrtm08075653TJk4zE 7bead1s1Nr2uk53meCGVlPk1c0Vi9GjOGkDmkUua6jkoihoshQGXxZjK3DI4xzeC412O6d6cEyYn gnbVibJ3TdONXnTadqbRbk7J1TvTcnVOFZNI8K2Gqtq8R6EmhhEoBqhdLiULCqRCwmEIgonhsORM DiEISSSSQhCPZ0fHC24O3bpybR5Lpu9D34uEN+JWpXXwjaoiICDSLAchICZQVEgIiECI9R3NJ9Rc Hfx32zPjw16a4TtG7rV8ieQtKblksWqeWuK2RutFqmS4u9OydLecHHoujUNlrpOC2W6zXKdquzpf I49rxrHcXIdGc7gnb4J+xO5O3qZWkbCUniOlV3VCam2VqWgnRWszFvF0qp/jOqm8Ypdmuqs7OkpY dlniDRL1ZJURWxocK0bdsDjQuKxrgfYpgfqQg+sdNFo+0oPmFG/L+cqwE478xIbvOBfnzblvPb7d i54tR+Wu+ksdab2liGWuQw663P6WuuJLWl41qrebdYLI1WmjSammGeD9IH1ATPMclLvLsggV6dVz u8cnBye9dHj9tT03O8hydyomwVy+z88z7QnObznOfsddROC4DlypcuMXKly51ORsiITDZNRGxjD4 xjEJzm85znMiTJjEyZycnWjreHtTDiHo8GouZnXzVfK5HaPsbdPfnIvMe9uf8BU4JxpdWKrysfqc WBDaWT7uzpPPFVJuaGebzd2nobjqbp+OZSRyv5EkdpCVJFI6ujdy78cdfZtpttjb37X/13v5rxXE +ls8Z3nXe3WtYXwK5bVPmHAJ6ByORxS3YpkydymKZKBk+RfOTQw+Y4GixwNg0fPbqt4rzP9iqqe2 m+Nz6joNH7FD9qvWqTih9ch4/37UtL+i4kMiqQk/9jDHP9H6if4B9igE7CSCHJycBEIiIyCDFqVO ev/7/3/+t3/xnGf7s58z0K8b4HtYeN63rf/L/keRPE8D/KeojrSxK9mFu2bn8Q+zZ7OnyfJmpZrb 0O1UexYSB+8PYIZIkSwowgoaCWqCXuSJGUiI/IToH+af+Z977v50h+yF/nsmMflX5Lm6pkv3i8qg vE2jJjIQGY+yk3bIP39owTExUzyPE8XluTwep6n6rJ+q2fxm5/2uxeq2X1H1sN7ppX0maWz5fr2g /4vGuCpflSH8D9ge4N1yXofBY0sbKx+pU00bDovWYxX1rVhU/qXBkRYwrHGnJ9rJ8KV8SaBXxYfM 6CfrtpMlJ+hr1n7no0bn3/h/pDJ+wHyrAV/zFKv5BPU5TUk0uEn4kf1h1pZLbbbZInSbjXcnUeV5 5+3vf/BJGZUztNT4THSsjxdnKJJmfsWHZbWlwrIqqqqKqqqqqqqqqqqqqqqqqqqqqqqqqrC206H4 nUbqf3yJHg/c/dJ9CfTKk4p1L5vzYn031Wnme14BtTFe9MViYpia5BDJ58/xMk87ha+U4LkwsYuF pWFojKgoKCgoKCgoKCgoKCgoKCgoKCgoKC1lggqypispisRvyZYplsMtvQ022TXE5tXY+xjH4T/u dXh1VO4qfMaKmEkbipI8g7xzu/71jL8TDSM/k+9+Rtj/bd/2YzRlf+y7elmBxMyEE9MopbOvFTvp 9oc8HBs/ePk8lnRePL2Z3xEhBkPCFN2EjxQwc1zkA28jJtQANiWcCaYs0gaJEqchmgpsS8m4V8hu yEF4OuSQ4wLDm7kIhbMIcFm8LEgPTwkCstIuULm/q+o8SyOHZmBmjeTXwuYVIf0M8XI/dmQLLMPq CzApLnd6ax86tIcyopprNMDBSPbEaoWE6eYZmCWvHN95Job7nO6SN6mLE2UZWQ4LGykb0AyF5GIc TMFi5ABCG93NQg8e7pN876A8HFmDJJWQPDCpIYyQ8eGgTENImLEHJgC0zeQNiADMU51UvQzomsWI 0VNlVYLRKsmKDesYbPOAzUIaUzHXLcVk5Mhvqu8Pdp3gJwkmoydiQNM2ybEkNMMQA5ywnKBwMJDb IdJ3EJ0MJxl4YGJpkJWdsO2YwOEk0MpyUgHJ4yzCHKBUMV0y1THqM9rJMchkhqTMFryB0DDdLEtT KNYW2DllTbFb5Lfnz5t5dMITYJCjOGQxAng6ptkOtWE8dDoyQF1opJ0gaZIjDbIaiQ0kJWYgcoSG oMk8N7vg5mXp61shUDaScskokKzpJNshrxKQPCTvk4714GBOGDBKBJvJma0wQaiqtDzHd7sMUK9c 9WWFlmFjjiJKJLJKEcaCIi4uSSaOHzNnhsaixxymnCeLHPaOiHXsWWgqlIKEqbsbmYGHGYG1kjWk LUHEs1VLYZzgTOmeGd3BshkWE7YGhAONFIVCTw2CEKgLrmhHH30YUAyQxaYQWOxSZrQ2JgYe58+6 WYptkjrZLkxOuOeI6ZJtZ1dWkcsJvYjmwNZRzxTrlOmOvOpAHwUgbQnXJZOUk5YLCUvJhJLYWwtG tSTjqb213agzdlJixpwWEnI9MhDkSTGQ0kiiMgGMg516yw9jBYSK7kAyLgC28jxI7sWdxlR1ZDcy hz6tLpi2xZlDTm10yhDT4QFkk5ZPGUk4QBSThxJh3QZ1YiGqxNF4WSSOKhxWRmw320NSCBKg7zer Mclh2Tu6weGZpRnnGChJBYQUBQCqwCIyFTrgsk7QFbZDBCG0h1q9MJN8UJpL4sBYVSY44htUaXKt y654siNVkTakJjyWwBZJghDTIVHKQXLZDxqhJx3dMkNjIjBZDvVkUFkgsgLOSS4w2TG94kmVoXhE mqe5PhgMV4bpevAPEAOPGtnebgFQLppFhGlkKVxVIxYTcUbVHGyHGiqGd2JJYyR1SBUkNMgvQyAc DJ4QNMUq2o0qHCwZrbfwxmbKFpE30dCAeGAYyZaBOHEkxlSTOd5OECKAHh4BhNsnAgLDSdJicMiw nLA4YaEBYSoHhgCITGBWE5pZJvmyBWEnjVgGMOWdMhOlLQh4TaQeykJWKB1aTtJOmdJIeBhO2TlG +kqi2NKhpriGFJJssjCw14d0D+9ZJLCMUHrqeNLNNy3eozQePPbz2a8SEJ2mCEFgLDs6s7dIdMDG E7SeEd1YHh32dYE8CBwzaScskowhpAxkrAFlemSHhk0vBYEN92E0kmIBynTITaSTEPDAOkDhmlYd ICahYTwknjmkJ476MhWXq1IdJO0hykgdMnjiWEDEMSdJNsgeGQWTt78WB08BaQWEKMh2DAmkk5Yc ccqcjG7slMMucZiUwMWIDUxqGG8Um1DFRwrZQ32RijjYaKkbQwJ0zlA8Mk7QNJCcIQOUvBYHSS1G 8Y9bFg1y7MFJjyLEN4QBiYYYhlW7I4zJOmU1jnjbImsI3ZXBgYJJoSTYwPDDpk7QJyJIsE7L431s 1JiScJJ4EhwwkFgjA26TwkcmTMJq1oN2TplN8o5ZODEcRDMP5q7Ratn0xT6w1INEwam1MQJmatsI ZUZqThRxjXFVorjdKGqo1sMWaVJhUypwo3rJIJv8DVzODN8yq3cvSwQAgwRRZRJJQpC0Nz+IG0NF SRVxwbGTnVVNTcYTgk9QySiqT/IZwxP5SnNo2bqdTDFzLLvZs2ajta2N6q2yd5gfdbrmbN+N3NzG ElnbqWyJkueJgVV35t7lOhmIoSqBgh2NDmleGaNhcBGauFdw1xhtqCZ5XSP3IpjeP+Mgog8YIJGZ jkMgo3Jk0lRhqbN5SJxNjCY3G/BxV7vmWQRFEQQlSML1tcKIiCeV5/ujmSqgIIjCY4/gbhG7Ccu7 VzxB1cHRpptEuztNb8mk0YSuDBplSt8pXVkoAgKKfdFEV30oJyRCRQDALGY2SOcwaGgUpT5kXkLn NgYR9hsxZRUIIri1ZxsvBeYpvNtPJhR41rnYaSZIo7TEwN0uXUYnFj7e6ckFjyBLmEkrEX7xTrqc bSRgLOfacG1dkLfZxacZGNZW3TFWby6PiL8KyKOgZvvYt2YZq+osSKGo/WZhNMzC9CkOUudYX4yr i4mtVuNWjFxNHJ6C6sjYKRKSMU5T2FMtIhWj5KBoCMZCouzxwqYZVoc0RA6bhxTGi0vbZZsa6Iwa I7pwahErKTM3LkTJ6bi13aUyYNp6keaImXCFEwvEOqFAqjQ2OZYAJ3EuAU2ijCMyCOwwNwAw6Gi0 LH1t8PXr6kmE2HpZPVkIeZCTsTklEijzOcXTbE5pxwsgk9TSsY1YqKVUdSupovIQncmzZmWbDW2/ zT4gCAS1jezBMV4GroycMJTV/vf40vKsdGlEfxtCFIW8CQJJhUzjSCFyHiR4OVpXP4iETKeYmpa/ aTVeJcDy5VDztt+O5ds7euwuuQ2xXHli1TWNKib7HYreat2Ihx1cNjsujgW2IEQ5zkjOck5M+nW6 8YA4nQXXCqIINrqa9JRCzdaTcoaTQsgt2xiAEidXEekNJNvGuj846rTTS40awNpCZSSlMsElSAaN HQZCA0pNWVdIilLyOIc6D9dlShBbluOkEDg4yHiYdZb6jP3PsGAOGZvjDO3qNdec4yrZuQ3kMH7+ 83svxQ42JpseKLQv0j8v8kUmNJMHDrABDjQ4zGQiAcKmkDQfbWkv8BEiagpm2mYAjba9rVN5NWCU /rJCG6pecWV0EEUccQ5Ls8ClM8/pSm4o+1/G2gpHsrJaOipg4roHbhdUUrrKkE07gscuBxS1Uafa gEPqCT7I9eF6NGeJ87Z3oo+TxoMg6I2EFSrrBEqJvHE4gZpzvBcW5yghhLhMltFGYtSHz5lWavz7 9xbx8E3fEdAfBFiIQkQO8f9IpbrK8LvvbaFKFJTjqCa9kNRMA4qMC7izynKc/X7VhZ+vOp1S4I0l ZVO5sEW6NMe3xoToIZCTa65QGS6JmiI23LTXNawwOxWyd2IqbI48HLVbImLyo7N+ziNHLaqbRjmK c+hEw4eFpP61tYvRmZ26yh6NnrLhxIvxjQmb8uH69+iCUMjD19Fy++O8Vv1L6UQsDfRxgdCkSOy3 VHMzwjAxLN0KqmjxhwppGlhrScHDe71nHgvJ9YwknA7GFOWIauHKZZozpIwnKNzBwbHG/dwcSphA H605/qiTsBxxvDw0nTonEYiIKOkCHWkEk1Io20L5D2AZNDDmWCgpAYUXe1cxVVpbOlOeleVudj/S jGxqoSZkEI/PwJamn7fK6PbdD45ctKdmYXeqfLdURoBJPczDTMJeWYO0tiYrYswRy0hU1r0MOr0N SnacLllmbKSufZvpnXgq8vaaT9sBMJZYDURBErpDdTAOY2gokCb5Wkkic7uApREZBIilGvOlJsTa FmLtBCChz1TBQbpy2taw/Qja9svrLf2zNd5DiO1VUeUYG5LMhhZrBGMo/BhBjVUX/KyLKIa9dKJd IUS7MnckaKJmZW2hmx19DcYbmPULY3OyE+TIBAHhFoiIjO07HR0GCXRQpHEYslGiH4ooo8pledyU 5MzaOQUXPF6WxSOdNjW9Y5i0Wjp7A3tsDZNTcULeazKwnqSHVpmaQ4YkbsTM1jNaVGwxU40GENNv T7KsYmLIstmJyPpcN+qqXYazy666SF3y0DlvvzvE0le9IToclIzVli5TMqc+64uJaykntWMcusXq rM8LdNI2WmsKUfFoz2pCUqRmaT3hmwpoXvBpyoLjf/G+eJxhV/ZXfXbR7cQ1txU4fVdSG+L42tw7 UtjOhTKzgxqAIB9zsssEzMzXHlCMZGu1OUMEbvxFn3rp7cG5s3OxfF1cJrtOLveReEWxec66KVmU 5QfAzT2UjhPr3l/jp765PTqHu8Sn1qb7dUE+0fHHc+P8S7vr71nBeL+V61X1ro83o9j3Pq+Xgrz9 aVt0czipP1sVStMFIxgqPnd3qziur+OnnMfOZEYEwmV1iI+3igN3UTIQOak0hiTPzPXeeeeyBA9B hynYgEJRkkRk/FCKQIE4SQJndJWEhy+vi7delOO+vr3vXdgQnYJCQnLuMJIcMDSdjCYkCLANsAYy RSLFBRJbSIhph0gYCxRiIkgjIsgdkvIYEMkgnowNJFgTB2w2yAoaSLKyVNIeO6QwGKQ0MkkiQSYW WB2XDAOYhgkiJJODkUaTYkhpkQZNwoFAEOQsokoycWSi3B6zrdtpJDYhwhIXs6yZJIbIWQDGcrDc cGGyRK2a4Ea2HC6U1SazJkNAhANdXbuRNDIYdFhMElpQFgskJ320wQCdAyFMNOTrCyQnQwqcuLVJ 0q8P3796cPBz4tlTm7pnRw7uypz7v8fiPtSPNieU0vIry7w7LWFluGmcDEQXM9l3zHmKYk2keOjp ptaG3qavZlsANcMcy95yFvrKlhLnpHLxOqFUmLXicGts3S0Vo0tBJHEt1uFGxfV1CHfR2OIoLpiG eKHN1PNVu4Dm9dxjCMY1MSYG453UuNgUy5FQQTxNuW8jzu5Qge4IlISboNntsuytOksRAtCpuGe6 krsQztbW7GF9l7bDu9bM4XL61Jy01KeizZqpLfKfaijQo4LMJJLKNHLHDexxxDeDvNNkYbJ1opvY aGNTeefJvjpp1F/CspUQ53minSp/lSYt30vgXuDwyGnaMKJk1t3oJtjQcTFGuyt8EbBSwro0zEyr GuDrGG18kcRRE2iYY06TYMJFxM/GGZhOMWSP3bVnWGU4yZNBpDUIKVPBWkmUuVzQuTFE2P6oWyQm xNFMPWkORJAjGEqI3iSUO5GqlKyriVpVxBqGpziiaL2LvHkLhmueIJptcKjGvqex9g8w/HefhLs0 amkxVlkOmqDytXlTaq/ExMbt9EPpAjnJTxES9MdzwJE4Y8wJcPRZAXRxF5VqhBSJrt4qZgwc4h2J bJ7X0XHG90ObUKTVwbl0STOIKVTlSnlDFE4/IuzTrd9zJ7nedLWtIkSUqM6OC2rIujHx+vXNMd1R uKKpwpVES9G8UJ8NFzvIr7c9XunFu+t+kiEQ5pUw0eiZ6bcqq2NrckKMnJ0uyZInh9e4a3wRrSpV 5L5qU5qaUqke8IIYX5+5Y+o025wnO6kwZw6VPncHcMpPa97HGcRjGBy5aRiRZIVcOgRo8bcqm809 vtbGWKveVhyyO3eWZ002wmXe5/387apk9CnXlj8pYJ9JY+osTcWqmtQ+h/WwLDEXFlHQ9n2LVqzO zH8peSo7MSkhyBm4fPDGSEJ/k+f0mVuv0lKHDLf12kH9it3M/1MfCROfxm/bu3sLgRghL2QxYmVm IUkPC0RqyaRKVPsLh6FQMIU0Jh3YP4H6RjZ4gE3jQcHCbV+Uf9uywDtgsP1h6FJv6EpPUTR9KQon zZ6t+2jCVkwTj4JJydit1vaPt7G9XGt/hz76V3O3i68z8uHqvj6+fQb1nXhhObHDJym4IMJyr8JV iosjJ2YrrhOLC5eGh5Srg1axjoWao64cetaHHdqp4+Pi2nl7dTWtdWUeHj3cJ6ITy6GJ1RoNPcuT CdMnryTRgWjQUnXiwDYAMgwmjfGiYdd+dE92G6jKgVFJih3ofe2n24y9KfVxJ+uOc5Rr05cpLFek h4G/la81y57S45VXoyLTCDu2zLG+5OqpL2pwSMxKIxTGmScBecbtO6qZzR4M8YHRxpgwTtscZMy4 FeB6N6OcL9j8QCxIJ+P4BA07+rzFEFFRg1DkOJooW0c74EPlsHnnsNyBra3YITpDpA0k/N8emT5K IKokwKDE4UHE8BFAkoJbu00zCXPs0O7SulvJ28mrXm8nRO5R5Kws5U6M4G6KOytIp7JIbPN4uG6Z rGHyAzySSYHswk19aQHVSOSTsw5VOrmxDfVrC7Un6LHSsRfXzh2JzSzSewg6szRrrUH7QlAOmQRC e6Thk1aSppN6pDtCjIIwMkJKYotaKaUcKOjtx4VUtRbIVv3lG8LbcRfjXX7cIIgxrJdoHREZkAIK giMojKEE2daPEgkVZdVxhY9TOz1rFWUahDrLqcFOWMesAozNCqqz2rLwTtcNzLkpFeOC9dU8vkjo 5Jzq6rOmmLjLBNymnA1yWKdFSbt2ElshtZFpxZHXWTc6dk46GBTbhpmI3UlqeI5JnIu7CZrEy4aE 23OW5tYmalxNFbJszCdbZ7iKc9NzW2zdlMLVkUqZrsVE6LB0UPFYHgTyh3vvxonhCdn2s2KMDqhZ U90eME1qOim1thPJSO+pa148OvdYkLqAiqImRQUUCai3YtDbObHYzmirGg0JT0g0b52JtuWo9c91 cFCr5Zc1vWtIQjxSUtLRcuuYxw76yeFrwndpOs83hmzFnja7qywyRJUkl3eK1e2J6OsNTNZRmZRZ xq1aW01hSzx00rmMMTlNqtfSaSfFZLKTYvO1YPdbqEqUnpStpRhfDF62xGM6NfWrtaTydpT0iZaz 00d9CdddJ0Z5xrOFSMHhrWVKKmyiazpYXHimb7a1zfXKFjTTaB3YUZARNlEQHFEQZAzM1mftEfRR xk47SukmG9D2Z84JyxCKmfJ+dAemq43RHkVOUPr1DoTMly5oOE1KdDOp4dGePxAE7njf5tawsktL JTwVOc0xGbDnM4aFdTK6OPb4bQ31yVJzmmShyqMQ8oziwnhIiBwkK2lHBqaXpxnVurZ44pyoYXEy Hjlpe6OBOkd0BN0nF/ceu4E2QPKBPAlYHjqhrdhoSSMGSIgIybgz6oZqgUYHbCnrmVJ6dFn23zIA ZyMESHsz40UDpm1GMZ2IHY8PSP3/L5GsPT39efTH7U28G93+z1Pr4knuYWHzECT4HwhtNiVA6EOl Dq3iyWFCuz0PWFp3+07WQbhT/3tDEW5+PGR1pAiR7F5MCcjxLyU7iBHk2cJXmnDvxx37/eSfLD7/ c5+pJIzoYRGTnraWOd2BBnu3axNVVY2bhnqpjx7pJIk+5AoxGH0JJGp3wU8pfFCbGCcWUbRo90Kn k0Zhz93OQD0QfqeDt0H0SeI+UKNpSHyEPoikN5TrxZwetDhMLmEPdCeBO+qVDQk17WAeUAxM05nL ByVVkcljaVHide7Mk2UmMGZRC6iqA1GRCyga1tdptXJnbpOe0oLthCFafTOshpgIjEFgSIILIiCI rDQH2jPwvwrmfbAiQlAra6h3jSgj5ppF/3w61BqbkbJqNZkKx8yYTiGVrghnIqKotmFYWRKkFI79 RCh15YQA5VVhJ5YZTv6UdE46SdNSLYa07uTCWxOCWFVJSzcEG7Bp1YTt16t+2oONSWpupscUkIqn 2SaZv3sPIIT1ECjYqURJNlLMoQ6GQ+lLNJNniwA4YoiHKYk2IREnwnKHlk9kBToSUy4Zm6ihyjt0 z134zHilPftG+Dtox7V1VEQThQSCgZFREZUA4fPOSEolmNFSEh5jmtnKWHWcCVJg/sxqJXrmEB7C SLFB6xy6b5VNW76UqQiuSIDydlaU4dfQNT7Bg1C5YgUHVAF4iJk455ZGpUVSuZhp4s5a2ROipaYT 4RT4/CnYyAjJiKb+vUnjR7HHp+HexEh6UoW06yh2l+lH1s46slSob3Sfew2DwgpDeqb7ps7pntvD oRD2sh2y24JA74sMQ7VA+v4UvpfX19NaOgSIMPdPd2Qmm1NtfVOu8onuDkEu3GXFAAWjlaumkrE0 Bd4U3TjKb+Dkuuk3ZyxZvR9ns54tlFY6OaoJVCHHIBQiGRLJzKNqbmeMzlKceQg1wkoCWZWvb2nD SIlwXMB+OsQIiiLOEwYrnq9+/JNIlFKKUYVogKKOHxhiBiQUmhESc4U8ESuxgsU8N+Ac2uG8zvya FiUs6pTAk8I+hSaeViGJNsgoKAbRT14cEbObDTswm5LJVTrqXhhyo0UK3GE5Ibxo09rUhGvXbX4C IiZHMoxJRBE1VMgoATyap73QmxEQMk9z2+hzOKe2E8vWzpM9dne3DiHZG3xAmTIz114RTskmOYWR WEyij0Sy2GYoVh49RDUomUQqLgsMVRmOEvtGgWSMJGBfX82uD6+/MmodjJBVOucZ7iExo060QMqI SZWSikVwpAv1cSwohBZRheinv7WaDxzkgbY6Oufjg1wETVknRoxT6p3gIs2KGtaRJkkmKCipup4x 27rci/Lryefj5+lznfWKRM4YLR64hZPDhrr2q1M5cT4ywNvB6dG/c7+0YTlNHXgyYypQ7cbXoLwc uHFWA8smlNTHkz2cVBP8+z+xvMzbq1icXKxeEiTk0dTho4Jokri7dtZNFUjGIh1E7nJ5w9WVIFSX XcNaOk8CMHHTrqZEITGD3DnOzlRBxCNILhwntfto6NiJJ7ZZMh3QpaUSdopAPDJ7EYqZUwMDEM8j yejhx573Pwd/Pn8d8vY24df0vkbpM2eKVZBZFpN2c5xXls7KDnKMiHlX53nUh+Vgw8+GolesfK1L p4Hi5arTzvA43DgvRWDa6peE+B7bP+k9WsPLPqNfEnDnRfFzwnW0VakYz7+x9RaE5KUPhHly5hg2 50lut9bW5zzvdfUZtpOhKc51tTFJrCtc6PFyy0hOUfJrylrpeFDK0zq0laekNCi457KRhfNZRWz4 fZpytrfGvCjxxpelqP0ib67VlO13txrK7axxZF2lxFrrpoV3rxW+WtjiEN/UInGpdY6K2Hg6IIkd 200zsVGd4yFtvuInBSS3x3/inspE7QP9ndE8AKfj8Wm9+zGPnnQ+D5N3pzu/Dv9nDd5fu/+fe4PM qMFUsiQfD2yml9bEm7g0k2MUvdw0M+f6fDbZU6B7P435qcPLDtmlYqzj7WHow06SWsx2pKsX+RGP v0wFiPgIDyYwQMSIIsgeWQPRk0wCSKczd7Tx1pzbwzLSTsutkJLRqphYaLFWSMqM2VIYMwUKVmUk 9U6YLCaEA2JXYinYzRorqhAOBAlVUkFVZB8zFBpiCxiquLBxbTRkwRRZOeluBuw4tWG9Q5Gzfuzc poPEjhghpnSQLp2BOCYZhVAcScSInOXbZOBgoIk6GBMSIdGzjUJCmrJKNETt55TRwzRhYByzZhSQ YJ4SbzDJKdWsNaoQksEAJjIe4IA/0y/fIdi8bzNDU09fjPq8HoTz9UWSpg00kipJpVEm8UZuBtMO 0tV7JpRkkyVHJi2o2aptqalFuHFismSjTbEOtOkgutrNir044RqknS+OMwLsxzjjggki5Fb6Fprc kofCouahzJuHu+Mp5fPBfGOAjHMiHEwZL6kE+9Fxk5Tz6p5cW5kFFy9MiHjGNKLweIukKhY3Izea wLet6MKodi27dbjN3FZhCodbuWURlHO8Y+UuoRhxQiQswwLEUWSIpCE1IJ7ZbTOpzJq0UPlDqZA/ zs0Z1BfHeR5T4gQJOITSOloabUWbDlhxwmjDKyHdmwhnL7NuInd0psgxAZdNHNJsUTcibaIywfmi x7izCzi3LnOOfXnYGlurowy9DSBW7RUD6SSCGop4Wqosgdjn20782TMy4tyWzeYggkRSwc5rgco5 +MTw4qYdJSPOnQPb05uQV0GN213DXDbhzGQ8u3DvZna1izMT4h1Yjh3lbHJ3uOejJKnp6BanK24L klBVLYdro18ixxKUtaDjIp3hBDc8k4uIdm6Gd6g4kw3SbCjb54faH6seq4vMys11E2Y8RabTSJMd 01s29iVt3GbGE0jjdbl0mNTXZZjQufQUIrTSZtMQ9JkW5mOdLw1y4a88RdSI14OkhiVcrasVvWD8 KVCJWpW9RxRLThBF6ZT2cjdHL15IKH/YK7JdbDneKh+szIqsKvNz3inzHIUBgif7flcojVYvbSVK 6xuB3eRo6lc6vR6u/8t7F7kkmeWmMtw4FEdEzrl3BBVwl6X9dma6TrOKKnY/wfMbbWH4JhXwN6c0 cMRiFgkr/A/I+Z6xBOz5XWSpEYSTGfHyMOB0TcaqiaY3DmLnExU/IfW59+b+3pKhms7mST+0spAM 378He6gJEKHOkd5MgsRHwe4R8ZJGDyzDJMMRONI2VR4+iSsSv60hQV48uBweSXw0p54qCzg/13Ga ZTuj/WMVMew8i2UYSwX6zDVTq1VD5TC2iMqDJXktVQ/YsGyu3Uo2MmwmVDTI1KZA4GSmlJW/b2/n bbeTpyup59S2xmeDTyV5t3E4yn03kC24a8Ex++w4ygLLvfgoUdHX3/SGJMdxMD+GZs+/FB69gYkT NInMMG2l/nF+2A3EFtsn+wJkxm5ODodoQK4wYkcQi/HwkG+FGEyQa44ucd3OmT/KmXv337n2h+EB 82fWSQ05nBroEVEVUPBxuZuxFnvFlQUnnMHmqwSA5gsyMQeTq8YjTyLwo5WcS4WyejoIE8kDsvS5 Jw+PLNbk+YdCHpa1IeoYhIn37WsyJwutNECLYQtCl/wHlgwsI835jRMGh9Ibng345vjvkwJCYgYs Awm9EKxwLHf0zGhoy00waKiLkNBxkUwGcDeqGIq1yros59O7o366FkUUcstzKcKktcNGDlSb3Jha h08WKoqYwD0k+6SnQiRPRAlIm0M+Mz7Pft6bdWi417Xe26ePNsjgpLUWULetW3VqusGSinYwRJbs OqcSuJHHm6oCi5cdEAjtNZItpTyyU+uyuwOOcGKg3oFklmowYjE2KOvykHlwdrg5ZRBUhsFmqI9f U2TPNPt4s0Rgn1eHCk+9JKbQKHZPfKDfwTihmRwot55zcG9y1NlqydVcKzuujtLgCWO/nBEfcDME M1jgZGfmWASKyG/bniQhuGxhMnHrqSaQ5PSk8JJlpA1y+u7HgHaUr3Orx39N0QRPw7gwasdziOqC qIIvgIMnXoMQDRX6MksOo4k43iQG0jFlOhUxvHPFA9yjBMFZO5QuWVIuKOJwmWYFQO9K0xPxngMI viONyhKBHw/kxv4EUIv+fpiRYHolgMQJ4qwkdHzpwHwfhmd99A3RhL7UPBxQWRZ8Tsn4dfca998T GLDlct6nsKwhzcu3528jfzJNzm69UyUnIzYdMi+g/hneSHaSLOvS78e9zYonqhQ9AFUERU2WTb5n fb7NnW6J0FJ3Vo5BhERoMdhDfqSyD5Yzv+qo/ttm3baGH2+nt7JdA7lkCMPfcEMmVuzgwkzbjh3h 5JLsceXdCZcJDHxxMl8FuHHNiJbnGzgfsfiQvPO8lZJollkNfBExVppFQRahxU6OdJHakqN0jNIn hDhAy0p6U/H3IeezR7MJUrej1w0hpgNK+/zTITpkfR79DncoyBUPZN9d4dsiwmJ6/akOxhPVklGp D6dF0eWwmVAGUB7uLCA0kbsJtHlytW0NI303ZtNwEPZv7+5A5DpJ7aoOuq39Vu8Rd3BgmOst0nDn uSaGGwwqhMphyydRNx43vfFm3ZoeT7yxkCo4NogomAMnU8Ik4njHFgRRCN7LidZgsHEE0H5q6OoC qJklOGIpYUEswrPx2ubfqkcNPwZkNHR0OTSSnNWJVhipaiHIqd1LyJCIqoivDeAS27khxhidXw1q 3+huMgwgMEzCQ5mfzKo/lI7R2frb+yCERZh7uJiFdVXMTd8cEkf1uDuqSGgQMOc44CkSIbBzeQpa O3swHDiHAQ1o2MMHICkAWJGiFhhqmuwdgR0xLAIXUFFW+uTiYiucRoJGTBgWZ8UMweh7myDBvRE4 9Pj48+hycp0KMEweck0yLTRoO9UYBdDRyAoJp2ZAJk6OhIdmFQSjrxW+ZldKSvX6WVtT7M74MMch IZNuVnyKDEyTH2/xBqvranc7bJGPqqkCfPgta3ohke14Ec4kUJSmJtxKmuLKHwirUJEpsUvBK7Se TnPbrCJ2HaEaSQ4TzqiTSHSVm8b3uiE34wQSB/PPuppkXx7e3fv2e3meh2KsSct5mIjAoibTy4gK hD8RE4iRIqIiqRHzygiEAiyJEURnGUc2rpxtOc6z0a3dxE53vSq0qe/r68KkIerCMSEDtC+TVl3Z OvfnCmo+IPyKCAQgr7cjuVQ8pMDK4I4k6+KqrHMFCBwVF246Kcc1+bbkvDSOP5jEJyZPAvVBCjM1 CriTOh0rgrI5QHLGhykNFjh7PBUBZmUTo2xSRQ5cnkoujLuXZ3QUFXQsMa1LvIFIqhRmZw3NhoC5 YQWWRyDikFBxBUUUljm9LkMEFpDaGW12+lDJLmaOg6IiAyfJgLJ+bCXr0s+mj5/UsNDPUQM02r2x l1mnJxZyNd6G/OI2qWwlaTeyVIavG4bZXqZQx1mkPQayQ76JNieLsN8O6VK/POEc9FXVuTLd0sui 0tk7elzK50ae51wa2ciYSpjVSw4uieaEWpnOvPrWSqgQmDHNUEOkSBtAYuzCiGQXEICT8dc8krCs 2CHrTXPocnBANnFKMhKybXgShSQ1VQR0UGVVVWIp2VNOWLNpbSNXg1M42nNu+g/zfSVv3rXFtxKk k0gg+ptWjp2PrjtHaEewqfx+ETeIjXlrzmFWlRoCIIIe5BQQQQfnxg56c7y7/Cvasz1y51yQi1KY ez3pSzydvBjen4xL4oq18YVzh80yNnWunfmK5lc44gSnKb7K76Wls1dbX1m/tshKmmjPpCuIxL2y k7T0hJc2ettY1CW+CilWpGei520mtSNXru1HZqrOBd9h5avQ0prK0cTpm8n10jmsrT21JLmWWL4x KT6ZI1rea6aRzzD7cVpLTiEIl9CN6SjpTjXWdiK8QwWaypCDxJ0uvdPvnPO/H0pkrncPZz9/whB9 n49vzN9+vI06aiJ+fcfnocvu6IgieP1nHnslDM/uPzNfeBAU9ZYM0mFIWwyVEnix6nsVnVnp8Mrm nB8Bej9JOOLNMVeLZDHT2U7e/zKHA+fBIJ2WSLCbEKwgG2U2Xxp4MiICwJBNmjDNd4UY243dkhDW 6ImydUsN0SIoRjFF66wkwU6SwFBkcekw4pKQsgCFCCcjRkwlJubFpiYzWS5mRjE3wuVm+JJsQXnY aDQsBWAEQ1mfISawmknE00VWHDEMuCt6k3FN1NZJKaiDIBRATKSGji7dBshCqSE7TgZs1nLoPA8s MGFZRmxTgvSHAwxkIby4MNukOGGQkU0UgTWf39YQeIcCYzZEhugogtvgcXF2TJJWkTDQXHyzcIfH KshhINKktDwogjnsKEJ7FJocLtE9llVdkGaUW1mUJ8aTpc5/kcZlXXEPJLQnVbdRe74m4DjveFIp tQvG0/qjS5s47ZK4slaNcFOdOxC8gfwK49xCrRP3rwQaguCm9UwzYzahy5qWLC00Rb2TsQQQ93RR PqjXZWXeDvQ0q0GqfbbYpfJsJLRaHI2srat2j23xxb8Yny8iUQIg44osgok4gw4kg40Q5wJEGR0p 5QUYJn5PZbmcVLma1H2bEeTZoempQSvYY/gvwOd2y5NbBU8Qx8ijvXLjFvgoIOEQIJOzdlpBO1O4 px40a2ucHPGaDF8UI6oLu8uh5zkQJQ6p+z2zLkDVmVZpaIi2u5sfa0r1MM3bI5OHFsUiUYP5EMUq JtHdR25MtYUXLENLSpqDVHA70Q3CUGvr6RmVLyPHSLnGp3Q3YZj1EUqmTkREwOS+dpsgh7ljevOs vAweSJNW3Bw5WQxrXhlQNFwxK6+FjofeMnnunOiVsA/VlzextsiLmDi7LglNqpUyK55MqLeTnbX3 OoSI6VD5PO0Vp05XIdCSe9V71b4L9pTnHTsJouYmWe2tyoKRaKWkEFIf3p4cpGZ2J3XU9yEug6jE Uo67K3HnojItF0QU+Zg4+DdlrRnHZO1kF3jiibwohuLqyNZnqIO6deqFzdM5Njup6WqZzVFzrtQ7 0aIcIemwk57hzDKPX2lek9UmIhFlFaGGa3XOmG2vJnwekyMtmwVius4jhIQDEZDSSAcX5+HRYlRz Z3G/QDlTcRMIScROln8Mfcj4Uh1Zl7CsK0Rxgw4eN15EnHnkRTx1nDmIRYrH7JbqI9VrJDZeVAX7 MfiduzgmKjDwUQyni4UcM8clnYhsbjQezNSjllkk4TP0bp7wYuDBrYwEDhfvNRIKkBYHaHKTzJ+8 +OvYW7CjKklYYjQcJeMIyQ0P5cuBsfilIVu4BwYfjj824CZiI5JsiNZ3LM/acLO6KiIpUY0Kztdz wlSXiF+nvT2YGuoLRn8KdMOl0GypNSQ0GcUhUuzZspe9hjFgYAQheFMVKhCE4mo96S0/AjPtgAJK gKKiQUET+LMEG3byY1RGE/FjuZhEgpmb9vllwEhOcozkvKKIoQYOkiIFgy6N3AWyiVDw7jwqBEFQ U0F09q6Ujh+DIwq3bt1wbPwxDvscAKmwgn1TvfP10rbMYapImmi6ghnm/XIZkgnRQzkW/J889TId NpoXmgdQZ0noy3c75Ptq8LBE2J6zsAgHiYD3ZoEhtfpzraeeJ16dZByky9w8fzNEAiUSTl63HCqi IqjvTtudsbXfXV7Rw7Wv2D7/ie4gkESSImhtPFr0MnIkN+Sh4wsnMefkPJ+KcGKIbZRJUsOClKhO nUEaZLs/3DNUCLpY54/clHaGaHzvb/DzJw7vOy//RrDsPxtDVVN06eIjwavZA3PkwFPnE5pSkk9z DPf5fPNvzSbd71uw4rt8mvk0b44VLZiWcqS3flVm+ht5tUOJqFOWSLyGj81Jc2D6JQSBc4Pj238m ALaNxL+rn5wPx5xjBGuUO8AzjKxaSTAcU0iJ47czmczuERAQRQuYXSevHEoe0OWe4OzvPGbJN3Zy rYszYndIKmKiYRh0sHpIdbKOhm1ERjLEC6y0ZCzNHwUYHi4IP12wJAwSIZEuJz0GqNdODzk4TZh8 gnbaiZhbQU6EhdtzO6ZWRf9f70NzfZIzRSiiqIUPDAxKYmSBNSbMMAwpIUjlg7+zjWgqQWTwPInz /R8cahtCLJ5ORpbO2YIyehlONFkCtPO6a9O+JDuIKbSIKInvFNNKOiWkZjBEooiqLmLl5aZjupyO tu1PK2Mlb6WlWnDkvp2E9ScMCIhdARUQQCLSdhJmulT0pShJLyKgySEeckCuxjBGfajToTGhluS4 wkxrQkiaeYB2mau7Yfc+snI0ss/t+f0ZOJir4g+AMg4kb+zauuUMDqGMyeMn4bNwiMKm+vrkgdsm hhOFpY02aOfSRutpZIpvru+Bs0MJv1DLRi2Fp1cfBy5vPshuVpPJhM2HTYxWNN2WevdcCaCgogig cd2ddskju4nG2JT5x57TmMovtOfZ+n6Sfd8/zZDbpFIVlt05h5mT5uihff145SSS6LMy7LIKdrE1 XkNk28s6ZnFWFFmyzEnA2MRkwRqK0TeQ52U9WxYob8qBh7SF/Etddlf07+bg4XzM4AfNEhgdMFJT tPOSUQrvD7fh7d8HbIvKHt2TDzqeC2jJK+Tsk+l60Q6Pu8fhoKwFniDsPpMe8hkUUQGx2yWiIEHu 8xRCyoCqMRY1WqwFFFERsSvuhQMS67bPHNG33u8OzcLT6k+D6fdZU+gxQKI90lFPu0cw84X1NV4Y fk+PgjS+M/MsPkwHnbBs3AZNLJx7JHl6prmiKA9JLLFfUWrxR4/mfPjGjibAEOSoh1UiVw4yiMo6 7jSxBAiXRhEw5SyXivaKGzEp607zpk6Ysro9gaTEqAtXW0CBYy3kIQEiqAqoloDHaeOwVnesW2xf nLkHr0M6R2kRTdRKqiLlkB1QZUoCpwtDWEFTmKN0UkDn5JJa3HG/EJ8uHGzlK03CGSXv8W02GRhO TMgxVJM8idMziEx6Q7C2XrJREuSHz4dfa0mS/7/D5B2ZzGidDOKFZ8/Bx6HvueXp229ZDygtTVp+ H2Pp8b2SpBObIs6PXx515VJs8/XIdIRSfFfHrv7TiHCT1QrLrn13vyztJ7sG3DdLn68IcJFDKgjK gKqb52amt+O+rY+RTa1Jve0ucsplEAFZmdA/IQg+R6Hf8QaWBNFxJFGL7QZbG7yb1A6zg55h8zqW RDKFuUyCiNKWPNzaRsWFiwpZXpBO6NG2QjXhIVVUhKi4njwUA4ENCe+jh9rLoigdcmGHs+c1gSsC 56ZpUp7Ws6thWEvPyycMkVQ+IheZe/cErColBRLk2NWVhEG1GNNY2gCKzBuWQp0a9RqJtNW0zy5b 6qNaZPVNURNRkZhK0fZ+C4uvpDyLUZbtEEZNVsEDvCrXrI0u5RhtwSulhxUXsOQ43RRKkRrpxiGV dtBalaNdTWdZkkJmJJID0M9qN2Scpp48Ugsl+LCjJ5+vtknLCPpT0+fn79HogoCgos2gvjuh5ZJn 0+frvY+LBYQzjWMFMMCqmDLDWwTtcaGZRtFZZhS/1Pq43KjaaaTRfU7jpbnSckkI/ifK1FU4XhCJ ip2G5rTfMN+o5Rc81N1aUWescl44uy1ILKxOHKKvTqvTDZjfTQ1fShRm1lVr5xOEsrcabPDXVoTq RWkMQLrypB9nnaOusV0xBtTPjWSl7YxpSusrz1tW28td4XtKlJPVYZrWExTeWslJGtrR3j6zXfTS cJxqtPr4hxXL8R2obxJZixxR5E6aQ8frPgG/20p116tvxoVzt0vtYo1EbpTjS110zzhrCMpyvLx+ R7hESAnUudDc50z2+f1eRv7er7fv+KJfLiq8/pTuevyqr1/L8vJ2vV+R0TSTzdCcKlikh3PFOnXo 8Xkrz73X46cqWzkiE0JpZg+Wx6/ZoYzAiTiGYuR0maGUAqB4yycMm2G3TCBoXejAkNCAE1IChiNs YoGDWQUgKKIRiKAKAwIKSDhazGRZ06GBFAUtuosigwkYESInAhgkJ0yOgIWE42BSHOWRgnBCRJmy 5ytuSSF8mcvIdngOCSGznjBGHCqCQiiqKCqgyERFF8d0Jrum+B8YGxJDhCjJXWx0YQkwhC0wYVMQ gTFwbOkMZAmUP2fccbOD0OR68vmc/Us9jR8iajUW8YaOb9WaU5Z4bpnw1tklhmm7JsKaY72w0TMK A9DjouyYjFbXFNJ3gl2h+JfhPyNO7mTVpojnoim0OKKFONRvFnS+4acRqbGWvmkuFQCZJ87C6rOc jHJjqDciisLoxEm1EkMXzO+wqiWd3nIW7rbJkOTZb1GZpR23pix3aAzYgNUY+s7uxd3r9ciYx8SH 6sjB+TuTDymJVaEjvcS2lHbLReRcLIi7ldsXfZssQP7xh2Kuz3qmIx5VvFhZZZgihyhxyyjByQc0 8FIRxshdNaLHlnK2uJPcSeycqXM7T/csS9Hn82ua1bE1HzL+K4yU0iykFSxs1V3TNZy8Z2sY4zDB 5wcIa7wGPYczUSBa08P4d+jCG2N52dhbdRhmxw/sH9pGGzJ7ioRJdN53Hos5g2DSWo2JogUxlQc9 A5XoG9AckdNvyB6aucHLQyOOOSTCbp65uF4KclM5JTtaQPLyg4XeSScKUjsMZlqqi7My6b11Abx0 tTFU1vteANornK5UhxM6XMOIVLY9rPrFvD1OxJkuEN6JmSWro7Y5aKaEGwE203vWYVZtY8GD45b4 nkdreOJntu8NQp3XerxtqZ2pwqvAqI3kiBJveZeojPCyhIbyHNE85SNvYJKRaOSJd0jnyDJbA6ry pp4ZbM9OwvNRXBOo2ls1ogkrIbCnyCkxxmKC/U0zonT0O/TBnUZIyo2GhQ7TRBcek9d5BszMJ912 vjpMhdrV1YZd2bWi19gljoK3vDxLm1wYekRw8ioFhRIWQmjTHQHRPNASRHIGkDR0c5ejz8/acddc 8M1t96nN1VdzVcdoImgzFTgtkFZfHLaj7PlP6j90oiAf7ZNoicO87xe4TqnM8k62u69FuEkmJDBU dWGg/6n9AgtrOcHTUpU9/SJQalvNMigPyPLKEz+Ozwh9JEFtCKJYXKAxA6KW6iS3wXhJUgNkhiu3 bz8t7/QNbMyGpnDP8n9x2Gpygsnj9v7/YOzYcvqMqfx1PSe+uNWSKN6vjjifsJ0uMlFRGKsqvrdc QMqCqiaDsXYsZrrIS6oAq1EnZUctkdxMqiqhF2KswSzN3NZaTlU3ycbhIrP48zu6v0m8IN/d0uvH XylsvcIiLyi2RBF4Od4EDDcSeBFGZEzNRYuTeHUG3hhDJRlNVtqgocHE7SJMJr1h4aIHTuNkkMya 7mI0dSnMLge+DAJlqzEoAITSd358Uw6ZIYJEd/GkB/L4OVjhVQFVLwCoklBFGgNh7Xltztu2hraT UqTX2P47vt8e5CWIfXiU+nzfNwnzZ82oBZJIrnFL33hD5sgsCnPvgBVQD38Hxh6fLeSQyKggqTMb wANNGJswSPYgiBrcxyjxCCwvfGqrTJr4GghDJZUrDZYijI+/ESCKoTmzisw+T4uunYVseebE1xku TjjRcNOkNYtwskZJlxhiJqaSMBXmyIiHfXUOYA8+Bo21RyklEfn4ydKknx1JZp9FSV38bnnE0enx YeqEeKJaaE+qBhDVkD145w577zQyDEJnNnlikTZ74cpiciSD70h7ex8e30pnxyfHfzOi8eJRIAiO RRhgnuMnqSps6WuJhd67bNYJKDNk2TI6tmiyqOda2Gjp6OaKb1oqVNxkMNsbdmTDRoMojxTWO2no cjppxITEJjhDH6RmXAZbAWFScHdJ5QgeqeT3p4GRPFfBSTHThDeobct2ZBwrtrp1w5lE+anZXXXs IRSe6eEPT6UnYyKCw+EJpJCiTFFU44hPhZc9xY7WpWT8teVJQezZ2VBFgSaJFUX8XA1n7Icx4I+k 0INm6HVH2IRfYbhscvhLO3JinzHChvBbwrd6diJuLLKXTSsq2FcaLxNuPXIz8mmNYDeEA3keRaa3 ZVwYHbh3d2/nbp35VnWeHh14E78eUQ+PmlkVTpIHpzQRRh4V6TaKeqDiiOAg1KT25SU5X2Pi08qY FNbNEWCo+WoJ9PqctxPYPBh/KTKqGtkEJhbDooZS0wpuBxlBhcRiNU4LdHRp0fyHZoMDrAU4Enhg sKSXRYGB7MxF8J0l9S9HVilEDeB3gd2yjI/WnjkOs9XFYVOMKfTxt0a/EfKKeqeNyhxZ88Pmk8sW TRt8b+0ckhdURmYGmHRxGBUCinLGTJBA0VA1UWl3GmrKue5EAyGgoi0lz5FqRNTetJHbjoQ5lzxJ t1O/Iwl49Hc51jjUWXJQtbGRw6QOkw6YrZueeCCTBYUY5RDtKQriYnp44r3zeHo+jISbjOdycMUD 7GFD7IcsPKGj4plsmCREl+WT2EzvcgpBYTD0KURPt0YSHlIBoTlCeuVSHTAc7Pc0ZsPYwRAp7UqQ 8u2YCBfFPHnWz33pMW0J8049LDYow9kFnH1gT18d+3j119KJA3XClovyTmQyiQBRWG1kTNWg5J5Y 21IlUGzt/xOsrv1Dnh2e42yMTLB2eYHhJDk+nZayGtIiQdmW2vXQoDylZNayBcj0F6kT9VJ0VvWQ wSSSBt6qI4VFyQYXfhm3oU9aDlKWyYMRIHr5KEMh1dpW+nvxrg4tOSzHGdJFk+vl+hgTn4OsJ0MR QoqCqCd2uktH5YqPCU5tm+nctBExtrjmyEAFmIiQXQmIx5nNjDE9x0uulBwZiCs2aHGJP452NBD4 dEvzke2rooM85KFqhW7urLQWAxOAslpG1JJAoDtoFw8FussWCrMjKnF4mTlGSogqghDkmnM16SQq Rw4rsg92FaTmM7OiIb4KOhUsxZRFVBrBDpvFHBUBNJMKoifYBRowZGZhL1y6IJfjhKEDCoxZkV2I V1kR32131g+vHBAhva2rRTMYliQaoTA1GBGCCujnkw9DYUwRXjeScGwKzkiZhw7N/J4OAThk6wlJ 1yWsOLdQrboromeHebpx4pzVC7W/Y+A3MGI5Awqsb9fdAUmZMPi7hk8fnGyHsBDU9z20YrAET41h gnrSA2ih2kUDjxT0Zv4RpW2haUhwnvxTCTL8OGphIC9TpVcQkyO3PvPnz6xmccll1vKz0Wv7AwXX NyVwyAIB7CTms6IgkBFBD4BEBUERRTNoNt06cuHveTnKestpzt9OYEsuXnHWPOrhqrmGyt+rW6Cl K1tKe0I4lIrCDbQxjGvf5lbb20po1oX0kTxF91pLlOdGxDF56wob44nBc01rK8FlTPDRg86QXDab Wnteki9I7Sou0RszzMsXniLQ8nLLYjK1dJz02utYb3rael6Q2pjEJbsUs1h7bb25VnIpWBmGxXUt t+jUjrnZuDe2DhbjStPSf8USh8uvcInUew0amfUhDZdQs+yff8k+2QFzyqX6AIbN/dvJlPr07nQN 3R0u34OnPset7VaSetiST82MFFOPSI3s9QvPVqE+kfG6CqgkTA+FQVVgyoWH7N9/TtqYX0vvOl9b gRwIbIHE5bQMz99HR09cXbRHhLu7TFSGJUkNDUFgovp902DSxbGyJOCFtRCQkyOYGPDcSIJBhnwH ZxhsdtIBI2Arz1TAeQ32aOw1EFwNWs5ZbXA5JqEtgikUwE5SAdJJykOGSEWSQFFqQowmbKQhhqlo wsI1550TEQ6vlDOoQn4P5tG+1m66PnEc5MyZDCzOOl8BOqZtJd4EPkIC7HDgxyUzQ2tCBZhel2g9 KyZsfX5iOLwt4zjCYI1rfR6bdgs8HU10TsHpkn2k4yucPG89lFBJbbhZM9QzoiYbwqH0omZgoupH BshNU0L3vbxQaXDj0EQY4YqMAZsUVt8QRkZxqbC36D1OP3bJI3S9Nu5qN4sUXJStsxochPUqC7gu suPMtensPQ3CpkmLQsx17py4cE7EN2Vr9O8q7ey24kog0sRBpJxBBBhdu0HEWYK5c7tmqrmpL22W vyI9BK40r4/mdVEtKcdEoe4Ij57KK+HDrQRUQ7QUOdCNIfsbzJ3YeZMYhBYiuiJOpo5Ai3AUp6HC p1n7KwpGCo064xpDZCmkWA8wWnJqenQeKL2E/HvEtJkJDdwo0WpsyZwrymi4a7dNcDP5tNgcLTix ugNTO02O6uiikxiDSRA44Kh+tdNFNx0RJ2Wnssu+gy1zHSqUZJMeAvzQkjnYtHY/TJJRIe9EJ105 Ft1PUmIyQsUY8zg7cSc6hp2SYlBudHoxT44WIRmw0PGOeGhoko0Lrd8ResjVER108xdnmAG6N8xi FrLk0264ggQ8lxbmd7diecUlxj5HbnVIagnclzLyOzpROBmokmZC6K7MJ2tNZSXJJRGudc97pbUF YT6FE9pB7cn2NZClRlb1D1W6zqqePcw86OoKweWqn9wV42Ihbo9jlORU27+IQuiwwpQhGUcEhWUt cnEJmgiKolySDwGQoedVm/aOykdNrTMPn/d82xtOx9yynGu3vpU52Gjpz9WOhHnR9j4U3Nm0leFt tcpJvQoIMgKKBoIW7sBQcLAyDBw5yKKNr2piQWLSU4xXqwKIgwoccSLb+0vS6jSWXkNaJ11xsdMF K3jJibt1ScVTZqE6QU0PSaBbcewJbs/Y4A9bJxh/MCTB+BzCzSojNHJx/F42X9WfrPX351ysOqUr AWt8JYkUL3SH4qjCR0eTJz6gPtfnycLRtK3XAGRHqetLk4wIe389PODwc6DbDhRFWCCllI7Bj1Ig B8+19j464zaXmAIA8x+k9oHRgw0kxPcYfRhoyysKa3Ex5Pg+EhFNsD/xvEcmgQIIn6ytGxwwT3T5 dyCJHNNqouYWavc1ety4gZFQUHpWUOYEVZQQYU25sg5ndRpCpCikCPLXrXTTV7UK9I88V11jvsJl VVAmoFhQB+GSapA2XQdB1dxq7sDVYQyyJxpxckGFEFUiSEi46mFyKjKZFJipEVFQlads7XgS2jvM vxevzyHfTmNq6omzs36Ex9flw3A+obF9pms6elmZLWQWmnTqk7Yc9cYGKY8HZdS1NYWrDfI3S6N5 9J3AIBzkNjDr3p2yC5498OmIi7SKPd7fUJBKP3/TgFIY/ZchJjxLutf0JosDWz64bTXv7GBNE9Ck nKHCLDpJxXK4yEagqyz1ERE3hrtuPpT3dKQ6yh+R013CJPc5KJkDBwVM8J4wz0smi3jjWEB5RNiU l1IJTQfuipQnOy4pND4peCYcalkWCeC5l47paSf4fDBKeFVZ/EjNBKEhvAgR8LUMhMN4noJ9MDH9 mff6khGoZPwzQZPXzhA4+lk9GQHdk3rrIccNhLzQ9OKBRUBRRKdGAkKSFNFNjVclyAiVms6a4U4r P458a/W+PEmqUF+CmYLIPF2gejJmrDg2aMJ2cyoYivDlMHl0ZU4Nu4jF5Na3hm9cnzzebbyChpii Ml4KTbJy7YO7mnz85tA2Qdf3xF/umEhmcdXAzJ9cqQWL8g7Ka9DdyS2+j2yD8ceug+2/TrR4EGgx Ob2giKqAqhFSEtSm6pDVtnkbLyMGxdIKC4ek19D3MME3hxvU8j2w4ZPcGdMFFO26KDU7LxsCRiiY FyzUSyTWPSIIJG4SSDGWG3xx4OBDb7zD+Yh3Yf7cGUtuwgbqJBVUDY2eupEHBQuOInA2GaEWG0mz 1obSB8Q9PbOurIpflQ9u98a8DAnTLQlEZmZmQtvZwdVVENuKG8cXWzW2mR1nvtR7DXZ+RM1IRMhI TeEAnHLurguYQ1w4Yksl2sswcgoVu1wfxA4jVIiB1TFuoNchhUiUEEyv2pU9SOJCMd7jjCgK8TU0 IAlYwnARNoC6atmshVZUW7GjbYhlQRVRKY1vuw3EgmqKqPhhAzCbPNcigqispH0DBvIQNrO4iTfT iuIA2tJS13MW1pDblzOc+W6grt55IYPyfLKLLILYQi0vuMloQ1/s5qHgw+jWNtytNyWvRW8Olhbk kpnTJncQn53Tq8LQ7urRiZxaVPCM/TlEWLDIAXOHRJKJKSsNJhFdkDHGNabYmFVAVoRaAqiVG0dA jzfhIkUJColpsiFS2Gi0ATLlVlnBnNoL8tU15GQL7MI0EbRkFTVSHIckkRnbc+PasTNcJysZrQRb lMYpbT76bFgkgdMPHEEFtP4HMh2viiZ8aItRKBIIUf0c6ZA5TXNh2xQ19PQw9EgbTEIfP0vb2iMz HKjCG4hyhygRVVRExcYHswGBQTbOIcz0J5t1pxvmyqRU4/T2NetaG+i5VGZHsjG6Dgr4PI6HEzCU FHwcokrJoWAUY5tzBiQ4RTqJuESlLE7LEFg725MXVBYnCE3GIraOORgPJkfaSD/QBv9n1LEflZzy JBelKFSpfTnA4EB9bzzblME9fTdMVCVquQWlFZlJsyBNVFVUN72cxzeGvRoLpR+7N9vgGuyPF2Ds EkQB4FQJbcFFVVmIyojde4hxz5Vu3Dc+TridcaLyhtjnloYqos7xa1Y6bF8NbFuNGm0F2xWuaSm2 IbbaRrWhpFvVuQLVvB91tK0LwI20WMIq1YONV9oZaK0Wcb4bDQ0jG2FnSC11zpba6aTizTiVyOXz QtatdZ1v6HX5Y8iud6Lg3Yhq3Tn66H6FApuwcsXUwWOUOqw0nDoQ03ktkWUfpDrxch2lCKwjvYvN otKEWKYgG2usJQrreC73zr7OeQPp7/ovcEoHoIiJ0f37X38vo7vdIRPswSl6W9gwesRPkolkK76o RInn6k0NqHuCAonrPU3pRRzx6TVip20+RBkLdSj1qQ8vpFKaf4/0k/zNxvMzQIWOA/rPqK6z56S5 8jNQww/CZyE5Y4nORVD1r2SO09CRNginBaCwgh1tZTDi29cGgyhhG8YLcosLCM2TcNsG1vQXmpl3 SA8axYgSU3hhK6UQy98ZND0Me6GCiqAsyZFmIBeQfRAufAPnHHXNQdLWiZaBep7gkf5IY0WaQH3L THajHdoQ6XK2IH1CnZeo7HzsYxrsizSx9aWyoqCbMbG5r4eZOKJMgwkesu0RbKSauryGySJxjLtC +z2k8sudNz0vpGQxu4KpCtapNKFTu8FEaolyksfBpKmIL7z+lhy7mIWRRhrE37krrwXRKUR0jwNx iH1TUqWiShQeDCjcgrS+lZ011HDliDDCiBzRFjmFnGmEkk5JaL6bOI7zwQbm1oU/Z40kezUrb4zZ PxN6k3ZPcz+eYO2TceSxGM8sQ49pqHkxnHbtNg5AxWl1hRE6Rbc2j8uouAiJEEtSwc3ApsPjRDOI K4UiOEQJuk4bxJFewx3qGzTEHqa+geBSE2c5JaKOcOIMXQ8QyErLHbaIhyYC+kgRI2tTEnTezyjL 3Hb1QzbKKZa8mPB0keWIPHUOmIx2jqhIRdm07EmNY5mY8ydILAYmre7KjMljrJ3tc7N12XNHPsxM CB+HU5U4TnOOs5nLOIil1vNFqo0UI4ipRUmKBdFwOyyd6mbXJ06AhkLouXXJy4fKMMQUz8/SckbD 1o7nTjpTT3j6sHMhRaNZZEDpzE9uxVlqTVpqvpuLluvp3EXUyh+ioiNOju7px+8G+YVrVAuxEMd5 y7mAiioc9DTkkCE1HDKhHiRxAZckE958wpxBKK9RTOKjrNI4jBIfLHbxeGTvYh/NQ7Ye9paTHYQe hvgzMI1YoP9sFhICP7TLNmJ5WnaTtoNNcmjGGx7ON2UrTYQ6WGzg0TDc42EqQNmkFKexk9z+KKuj MlQSh9BazxRlYTZsxN7yqQRyQpRYE3jjsk139GD5jfZjg6YlQ2DJ4alBnUK6ggdh+hokMgpCtS5r szdOntstFt6Bl/gHz/xkXvyYySzj7Visu3HR1VdDoRE0PrNFXowv0S+cSdBZYmIRtp9DkSpIQGyg lizKm8YSGnmMhIFESy+cAgn2ta6mXV2B/IJIzjZeXYNnpn6dXNmIfVfaXPQZRlRhNGUKLAdWMEST igxCYMsoxLLMq5ao5GWEyCGdVi5LzRqokhCQpu5gTYyEJne0yK+OHiIyfEZ0j6FnVU3sOTFJNEFw BpEtiTMyYkLrON6V5R1prpGtI5yJ0xnnWZSYmyoiz22IGs5uisyJE6MJAgaQ0IgQkls23sTJCE7V VZU4KS0bbSlc7Q7vWW01Q5ruqgZBWGvBuZNpmCMaCFFkhlgd8UKU1b3MTfNNJroYJuF4May8Fkpx RTIpCSGN8iw8aFA5h3s/U35DodMOUbtd++B+MF4gFn5doQmFpRZqiCjw7fzpLKKS0lgVQoFJpm8A WQvR3FRInKqVJ6yAiS33rbcWXJp7dJG+M6PTZYMcziTF03TUWDAuz7z/KiPt3Kcb7seU38VTxSLT QXRxIWtOfrgvrTrVprcK0jeRUqVN2CaXtIvGzN1FHCP8vyoEhvv9+9+V3sCIZmb7IZCbJ5L6mBN2 OSUB/EDfB6g7LD8mcJvziUjuRO96UtzbR7NjCxWDcFLFxzLCxUWiUYg5NiLhLKvXLEr9W5aPsVQt PkQjp69YfIHlSz5djStcZytxunNbWZZuUo2vB7nUc58L7H1P8E2H9wUTuH0JyYSmHkZ6DCnFs+G3 rVVlNoiOTO6nERF36RgH3i81XPOVSJ0jp1Gj3SCmVYBoWTKbKSu9YFEZd4S7oFSZpsY3OR/zP8wP ea6htjr52aL9OW0+k035tx1QS4e4Dr06ojXpuxkF/a/8aImHdxka6T3TtGWIw/RZaLy4aIc4WbOq a3kFemGl4LN69tzrHcFEHkCnzjnz+qMFZ+5FmuA4n+l9QDu4fXzN21147vjuHwRaFgaiBdxZJh+f 2N3C0Jv3+3BrZQbjmPvG9XbW+kkRHsuVxVZT1gjWVoDK8CBpL3qmt8cEt6uzgTSY7cpYVu8mtNIr uSxFMQyminbVVu7GXjECYSG+HURqHTSOX2qhz5ztFJOZv8a3iH+xfBcLT9n8RJuiqudWoa7vvArr fBtSzmlBM64nAJIpeAxWCjtpa441heTnl4qvumjjy5gQjpQJbDZu0jNOtBqZp3kB0UvgdccBmyzE YoiXIX0550TnjXBbCuGzLtEhwyvAy7OGfrQSI2kkcVNpJc+clEIKcChxvXKoqikLK491hkiaOw2s JlIl2tygcfoKE9ahIbngkTAUYWnRddcNvptuAa926ZfeSlVBwZkD8wjKKwRXQt/or80pd/h81WUr fCKutZ5eXU+kO7iOc2JeAw++adlisHIhO7jFBy2x2pRXjC41t5BeaxLij/iFoaxLCm9uliAaaaui ipxCQ4jzmBzk0xXkgdwO0FWpeHE7a91RDNcdjGlMXhr1s07Q5AJoRGEmIaobe02ZUgMM1RjKoK2H BhsE1aXWUzQ6TdpsTejJPqzBfcwwlNdxAY1BTWLGoV44oZOUKXJdwmhIEhiadWVDJNeH4mQn8b+p G4jyW/y1QW422hyuDdM+4BYGVRWbbDA+Dm6Gp+DEVRVKco7ULwrIprjBx11gKE2W6KKOEUBMIAgD CfYCBrM+IpARJHWdsx5XVFOuj15SrrZ979VxyLw1loa2eWTGWlnWHcKpDWU+e9VbR0NdNdstGTT0 eMGjV6V23wtFlitsFSF3kyJF4wvvGmuqtTWLl3pXbSj2ZamIYlbWkiC6EHPwEa30lClONi65lKr1 0bX3co+Q/6H0lJl4pjpeGr8x487vJbLrN41Pw40WVa2m9GumdOWXu/KtZT2rfbMa0aFNPkhuQCB1 Sh+hBPv/A9qHwwGfyPavz/ieMfqQ8A3oB1gfDwLTDAoKKfafpOm8viAiGRUE8kRPMW+h5mF9elSi 0WBVVGlcSauqPfv8fzq9XVkebUUvFanIn4pi3KIKRqLQrconDiBdWMmMVY5KhPLg4gBAIp5ERI5h A4gZCGBMa/AQzisLO2CBjGtgvnpqLgoUlIHY4l7WFuMQ0bllNQ4hQc7qQZOOOJgfoOJcZFsLt2w9 zWaaw7s7jjkjf6/9DhqmsDfN8EpPlN9fVXXRBUGknG5PM0LQsnN3CTR7qZMY81LY1SPmE7FmNSsW XwiBXnZhNMcPGQbRjwVeCTa8ml1JJR3ZZBctla5hTDhYrKHCHLpPcxYeKrXKu/KiXOmvYyCtx4Lv LqDBP53NuXQSXk7erZaYdoCDlRc1ExWWU7lb0mkeOijTxcI9d9YOrmlFNaUtPJ/OxQkHDozqtWdv NBvXTVTvUaynO0mnbO3Tbq9gEYaIoJLHONEUcQQSIwtuLp+uvRcKKcgfzuOrs0L3z+z/BtdYVUF9 VMuS6oJF4nVGcmJrTbfiURopGhoV440SjLEUokcl2fjQg4TFS2hdtVEkXFhlW6d5QaxMhuGjkkTk RlmSQCSKpyJJMs4snmeJcqR1hRUlDt5i9NQ6CVUToUCW2khYkjGnFCOzqGuUdzs8tXIlOmzXpgSB LIkKHyJVRFjS2FT2nQonms2ycMp0KOu3YvYiSm7i8HyGLKLICOM2ucTJRpndAUVsExc5d5TPhrIm q10aIU1aCOReUEqbycChpKLypjdtt0QPFxCLVM+mNd2btVnK8FWTYhXcsjsjqYgvJbUmqyuiyk5j zxlzMj0OlzoVzDpCkdOi7d9mt5x/g3EY5JSjzjPSmA3z8P5zjrtuoQLuN56xtNDW4u363qjsVbEX ULuKEKGaQy6JydRvZeFeYw7jWTeebePCLMLKN8CO6q3xazNi29rlHREbRe307bn0GA1DFYexKcCT aA56N/Lt8NnTE52y7sOg6GjIiqsCdhv0hrsWQPqrSDCpXE2Kph0ig8Kzi8bHn5h+0mNbyQdDm1s2 bRpQ2M3RsyIE5rQoTRkDaClipJryHRc3UqZ6EzTpbVAJfQF3PbA+0UjeN2ZBlGwMKpHzYG1ix5qY +Eg301xMN/fB4lyaCmgCFKhwqrFAgTkKOE4Enx8czUNQQpv2KQ62SidZquaFGODdCU8nSP4ev08c 9fPr4342rKhZUdeVMJJb9kO006/ZcUbM/jn2xn52dEadCLCodM7jO7Fo6paMZBZBEUzvaV3zwmIW T1vRJcOji9eHAduZAkzJCNEnii0OBSA6o5DFZ5WW+kzRXtxpTfWSVwq6jqhWOdRCCikmBg0drqsN FWNtp7wkG78VNoi3Bie+ZGliM0EUmOCMODUpOt423fi2m/n7vcedN0OmRhlMmokeHUVEnpORDrIj Ekqg87iukwzBl1RNjrXJkTCwRB2hus057lmzRwIV4h4EGmuxK97u8eawOEI/Zxwoy1lHIsRFxEmr 02TJ3xG3pRFzHq+QCDMIiyjb0yWwVQZugpvqsRYjDtZ0NlBVzF5zO2lp6r25eup2BeYupEhIOpfq 7vsh2pHMSQdpDSKJkcSaElRpLzGWBJac0h5ECIVDBhbowT6d3s0R4+fJoOxJQ4ae3PqnmT02WSH4 cxkkwhv0V9WwfLJvUoCEfrnN9hB+EMrEm5OUVEnSZCAKxnDBSPF8kq2IW1i1FLDCBfgcB2S5w/BD izDLY+qZvTaIYrTD+Cr5PgJIH1NE3LVEhoFsvW6BQ8olaWwQoQw4jfaTT0lNfNymZJpb4T8PvP78 JR7e3WQnoJtPn7PnF9Im0+Pd9cNCcIO6aStoloGnGmG20pvrfQeer6vtTlqTFCkWSIKxAYQmxHeQ O7hiLmJkmiKGUNxSaisDwxlZdwvw4vzDU2jQgLwMMJAlj/SfbnYlSRXGZnCkQUnVhI6VEkKH4ETk pA0fyFIBZ+N2fJbyBs+uzCbTMKjKma+Xq335de/n24j+no51HjHPXmi/UVRmiTDRQ51YW4jUh1wx vnFvYDtjsz9pkplZ0Upx0knZMQ4iCHyh7bPsdiEwcgQiVtFkB7Q2HF/Z/L8QDNSFoNs0ezesEwuu 2mVJmQ5zHTsxFT5PFRErMKyy4haPcIlEsLY2260ltYyotOUarDnrX/u39T4b4EnNMtnkfjCtIf+X XkrhpwmpdNZBphXYza7sciWEmdtadcKrHuYUkM5zknKm2ReODOvEJ4EM4FA+iKF8Ko5g4pMUR7DF lKqKo/DENmMOKxHk1haPreBFRTYXRBCFbLGu76011zvG6TzSELQgiKRIuDqx+V+lNGD7JqZq/CHG 1rYgwcdXrk2nBNbiHExzagdYjvOJF1/L+N22HEBXOl9qIa42V1VDDTcoo2ywLYjIWyjfoFC8tB+V Gfasup9BviYogpy0s8XNVSKpzMSRhmdCQoTVPl5TZhzqmMEOP1NJdQJyEymSKHdqVNikKeRopFkj 0mgQiFLahtWUQj+c4JkYdDynImCeyNPps0fVD5HyoH11x8aizRQLTYZqkdRYhdDZgFps4TFEpBg1 1lOVNaPaNKPiN9DtilMLo40IL5lQBALeRDRMIIbTE0BFFD6e+t9scr05xlKD82nXOnO4sYwo6tOG /KsKtOlc8ozxm9mha2Xy04LfulPGk82upjJ6/doTvnGr30m1pEsY023xtHR6waN81pVlaWS5gzpz PpTV15Ru7NpjENtMQgOWrZYZk22LvBthEkc5uLvaRLiEttV1hU1Ku22KZvjXVCCoJZREZREFUPnW G87b3tPfDi7tBpb3tpadjZpUnn7AENq40ZtezwxrFtcwvWceKUNN1EuNr8aSlme/OGkMGV3daclN 67Gu8YCIiVIRNfrzyPS2Kb/MW8/DsgnZTQ7up3nPB8dkE86oFS5yETsvqQO4VE3liRE5zjGOsCDr Ci7ADJSNgabt5c+TwnUMBJmzbm9+TjefGYcFtDttSQUkxkpSiApILJh20Q5ZdpibLLve2dwgCE4D diwMEzjA2goaDdHmxnYl0EBNFFic4e9RUCDICbkKopmGNlmJZqGZQGFkFk2MMOPLTLJC2qglsdwC iyQkJTBiDD6liEwmQmbzDDf6NB/e70Gk34GM+QqIL+YaIfUUdSC6CqsLpuI7557XiCBWHpyrCCTx ftzdKO7awoumkunWZAeOHYdocrh5VevCSjYojch+VCbiep4wls8DntG4sV9zaWz5bmk8gWEdEe4e ijeOdorypzXK9affO5Hrv2W7Tj37HBQeveLmCG3osLqurRzifLiMKl62svc2ut2ufB4aXtxkG2n2 VWGWRIxKOp768W3t1qIOJKIKCTiDTSC5kyCCGQiyO53auqCTS4VTf+hE8HQ+YbBW43kQ45E3kvZU 7VMbQjSntoQoCxDZISzwa+6PDVuyV4+ejHeTtY0sr2WgnMqh2pEe2hoZvHHMs4hzc5Hsrx64wfU8 S43cTUaOwxreEDgtMFF0TKIakEFZrUuKWDwKieI2HGXA6ShPBLiNTVxqtqcQus7VYJ6yR1KCR6jS JW2rct5DB5WE2pmtjRElHVxGSdhEVBwRnRBtlZ7FJulUnRbUIgXb0bg2UT7AfXLI6EmvVU72kOo6 ES7oV1TwFiXHUcznJskfAofkI6jp9pumGkR4px46Sp1vZZepT1eqlx7K9D1NLCbbxsaojNOiGOjC Mbooc5Z5wSlXVP2V7r6yV0o1CviqqhMlkutdUYaF7MkFyIzFh3FNpGmmqCqhqNkmsLeGtpqzRTo5 W9gt5p5h+w0ygokkvuJMeDbkm4wk0eoI40WkF7ZmB7Rt6AQ5A7/gZkfQfuMbOBy4SoqVxN7QOBvY cT5PZPNebdnLF7pEGJkG7hhg+mCICW561WqsqpOmsHIxjMpyQlbkG1bDr96mjCy7KxIZIaxaTPNm aK+EVoYQyyIL6KxCGsULOEEbl/QUzR15dW5s45VXVu3fD08GzKbcZqi4NxZ0EEEJrR3kiSMRY6S9 Keq1hbQStYxKCiOkRiwomo6IiRcGNJDoLU0bEA9cPT2MzV2tLU2pDXWh5iiT0DIKG6oBSgRiQlJh JPCUQ3eTBMKTiryMGxO1tUs5Z+raZp958VI12a4ErGgbnOkeOp87jEO7irsYJHYZmdS5rmhfUITg TqUGYw6LAlWS67bGrLppGCmTSjyu2QYUDMzSrwBVCtWSqprdzQi0SMdXRC5FUxiWJA6Gs0SzqUq0 zXRo2ectvqHMKLdGzODSJSkmb4nTL34Py0H+KmHisJDT7uzrayCyyhTmEbqlUWrElaaHEZeHmM3T 3KNpgJwSdlSP3j0CfqP2jxFfpZQxQiM7IZiT+XOP37xX2vkQ+VRR+PL0CEWj6RIjjFx9yVJWGUoK mRfERFCWYc1u2NSD1x038d9Xs2JlTa3kB1I6cVGLL4KG8GpRAyStEswWaLrGX4zVwW1b+kE2xaTK XHJBAkpE1UieVSm5BhihMrZo2hCIYZFY5yCv3k0ixbVmKoym2lyBM6yJMwRLYsPvrIWSsNK9KFJE IOthjNV4lCl9t23lM3xXHsEL6IqbHA70BTQvsaZXfKiMTF5VpdxG23oY0pibjeijTKLth4DQXZwp 4wNYs5wlD0sOMZNXM2+JYzKKK5N5wC5azqpOvzVCnG8+U0YMKWuxDfD2BYKaIl72LYHKkXvPgrYV 9n5QKxyONikQlCIqi7sbV002ZfmjHVr6XFmyu2s48CRZUN4uu7vEzMDgx4fZm2slmPO8ESmpuX3h S4eZh0Tug9LDjaOPRqHcx9xZVkNAmy3PU7JNAPAjvauhYma2MCluIOFK35Yp0mGkNXAlzxpeevIz sV3ams7Xs3jNNF0BVNa8FthR+FbMloEBTibLEUfxmWsijBJLxZcsX+phDItDoeJhRI2zYNzg0zEx qqMHwI+6EkfmDcyHAoooxIcYUFIApQKBm9/rWCq6mZsJ14vaJ3b9w9AnTpWNZ9qFRQhrzDmKAoiW hKdrBTlfMu5SPTVjl9oSAU4zwGqjVbnz3i20whuPSQ8E4atPs0vk+o1IFrRsTTKWdSJpkdUmVMSh IOmJaOc1OcOnKIrUnfj9sk/MftWROFIShxSxSZezG8KSMZr30CHLTErGOL68KWpamNoRti1WPQqc jI2qCuwk3N9XIO0RlSEYKawaIUdQTWQ4DVU4E3BWJNGjA0a1lDJF1giDmr/cD45a85FFFTaUMQC1 UuZvYOa6X4hYPPd8Wc0w3RWa94PnXe28tpWdTgQkOm64Tc4EfqR2Sfx+JLPfiZCH6pJLJJsub79R aN80MrklSZBoyqQcUG+0omHqGSBV44lvQJMo31uwfZ/awRUgkH27n30Qk9OGPvm1XeQY0tF1cd7m mu8cwnUVTGuvGOtt4pMvZi8nyeRqppMwJJDf6McXhvybh3ksNSpyNrZvml5LuLLdlrSsy01ZSsmj GW5AummuuaLniOr7S2p7Ccaats+1dYyKxsUJ0+jaEzgXZ8dF0vvTfQrtSekvqaSrDN74oz4vG9LW 5cSlaGKzZ9Vvrs03hbW9ll8QA+g6lNZ7b5fjTR12Je7t6Q25dEV+7WJspnpv1g228oNeld5XyQ64 LNnSS8Sq9UpRF1crybR9pX1rqTGtjZWvE4coCpUKqVXCmjz/H8PzMOvxt/h5Zq8R2z1PJ9fj445o cFvmE5IiQPY1O47G9dHai0+pSuaSZHaxaiStZncR/anzDwgnnTyiTRc2PybUWsXOOMxpCFY28MyE gcl0QgnKUDnS5CBGEBnPWyYJAXEl0p0Q2mGBhyn+Cz0hYp4UMXTEpJyjWE0Mh4U8SWwgVsIcuICA 6HCikmPR4sdgyXEjmE1ob6+oYYLXu7qGgg5rGr6+s+ug7Jp/q9J9BeIggo7jGeJ4gRKIz2cPQQxE O7dHE1kjqWyNVlOZw20OiioyDthx+DCitm9eQw0ctk0jlNhhp1Ih8q2gd2roRg7kFwU5XWdz5w8x QqFJJXFv2z3q8ad5Rsij1ruozxWMPDw7ac9G5chSgT1t7UkFs72zyTcz2Dv3W8Pb28j9OSDrDTIh 6Brek0iAnOTiga5uiS5u4fTa3KKIMCwk4c0cwccwwwgscwrrOzuIOJiNeaWxpRt3h1GrCtFuXJJt QPpef4UHtZpTrxDb3IJFR7SPPrFbeDqwSUPHPnabVg8TTdFwcMmwfpiARxfKl1gnJtjmsNydHOjR BZeNnYxQ6mmym3eezo1zcFjKdIbCMLFo21CStNacph0gwwhYb0sDREQO9y7VXBQnJJiC7Kgd5WJo FZfYPBGO8LFZERbDqMvpMamKaHdMURtxZKSLfc059brKaCZxyMjefhHdrEBbyIybYrI2+nbswx6i GOnGx6IXDjPnPQklEu7omL2eaYjIYuoqKEKa13kqrp50xoiM3mguk0MhcQ/WZBWFvTDlcTCBJ+DD k2aFOQ8VDVcvNmck+upWTzRM9NXJ0w4lW1JKjYldjNNofnZquyXiUS1nGmOw4kSqLFlQXil8sHFM wQa9vFkRuaYVbu2DhUa0aSSGxBo9EJmwJlEp2jq6g7KauWHy49IivCh3Sbwm6p48xvSOe08U6OMW bMEE5gYX3uyJc/tA5jB95KeU50GJzNjl4tMVVtehiYdFCjMiYUDIrQyCR+qJqagglDOzNbQmzJvR yccPh82N0+vWJ9LHUnESOJ5Kby62lukghCPeeymeWQ3DuE8K39pBwq0JopggKxMiEwsHndwmQLRa Nojigs/DBa16FUE1qOeLFfSMZC4F9e2I42GQou1DDogiXFHRR0rpmJEo1Zx1jD13jkzZtS9sODrA w8pRW8CDOfoTYc5ZbIVOZYOGzDXYikCILghGJohbUXExGHbQCF+fADAWDIN/TjMzfU6lttikd3vp fVdcNqQMsqpqNdi+ot5lzFS7auLcYu2iuCzoXSaFDatPsNNsVzu0dc7YaWmzZCEr5H7I8JNR9wPs k/W51GSTBBxUpHH5rHF/EaEr0M7I9mkNLmmOQ0OhMkW8CuW6C0hEYeSN+Qe7wmPAc4JM2D4Jw/B9 uaWqhvesLCqgYkqwM5lbNBXJ8GZ6wLJppi4qmECnKGRYlStYwfGY3r2hXaqYBXTDaGYO8NqSPzGW q/L+IxH7jnUMOgHc8RQ7S4l5+mh0F/H+QxTXe69IeHpof5nVSb4IgC3Ej1zNR0JLra4gg5V3WbKs +N7RJBoSuuAKlLy1tuzpy3nD31w65+U4P1enUFjDioYV2OG9xW8nk+qnKKE6P09ghLU1rhNZtNY4 SIW5TiYpYBExsyoVYHXkYjUQ4Dg0Hn6Z4JPhyblemmjcsmouyWXXYChoWFOYtyxaYOKEs3ppELTV cF5Wa0mhVbXl6vjl6Z2BQdbioYI1gkGgopJnn8OkOaUVZkfyZG42lDskTMuECIYhTJMAJrGSySaq SYNKiFfbppEugKFG05QDrsb2LnTnCarPkxRQIbMNiNdFWazJEcz0aobUuxS2kTBCL22pKMVugc9F r0L0vC8Myb8caSYJnUQchJjzCUjBmQFtUk6rDLp5XPUYnSTD1kxUCROCiM4+MMUZwoAJyBiDERRN 7TcVTV5JXk0+MTycaW4wwqESVS8C2UGDQUUUV7mNL6kjuUqpSCIjZFsLJB5TW9dhlTXFUGxOBooY xz3PBZZIXswOOgf76mlmp4kcNSDJipPivFnyR4+GKPSlRUREWVFWxCaiIa0etFsMmmk4QCWNr76k pzVx33NVdGFT0UnMk6rvvpGCXkaxNts7MuMRfvxfWGvsOp1kLvyBUJ0r0IRJknOZBwhzcaSjHQ02 W/cPetSZBPhCzuhrwbaYjBihxkO5ARlQRZTusnhV7NjaJD9w0AR9OWFFJkQCZCfXEueCuKAqMwqi k88sxC70cVSgxmcAup2Ui4sq5raBfp21l2NacVttqam7GaqBSYPEl2uKpxUk0hGSV3yYGeYSaFCx BL2GQ3ccDvC76tRMu5dXgO9GaT1clWIpdGiw+hgL6CR8HKlSfug8B+/3GBxQE5p9JSwcfXVw6EyC mC9dfHZoGDJNiSEy4uAAjIBfjnj116e+fLjPTy0t5yKYXA+eYghCB2MzxbXdteBbQ3vbRo7WlO0O lo2pNafYRpj0BOxpzW+uj4kmvuvDZYVJakd+vwXTa1zSmIx053twtKRFzCGlVa+5W1J5xKNNiVqw xa1Obq03vqe+kqyHiuZ0ZbZmamwtY33trtnasXvC1nIFKvSw6UKNZqfN9GhWwu75rrjTQaK6sR68 XjWWvOQ78paLnHGjy2rSFptiFstGE+RXGF2XONJa6/T3nMlnmfWInT5unxE8r5ml8W6eRPHmfT82 7uf4PselEfaafJJHx+fAD9oIa/57AsLSIJfXLjS26J2YmfnDQ879L3p9M2/+Ef9UVGN7ifS6U/v9 54+f4s/F7vl0w2q+1jW54IcnR2idB40o8T4j8+yfyPkOKB5CIgL9H1wHydTzBDtz7fLp07QYkovY aKvWxsDveafj6eR+7eM+wh40+rzd55Oib5L/ngx8HSwenqI/QqcFT3KnFU8T3Hjw7jpt0312FanU e2I+bX2OZ3BPeionWjXVzv7G7XD2HwHsPaayE9D6G9hn1YxcfmSRP3vSww+tuNzytGimxh8jJH+L LCfsf3Jxamrcp6m5yfvNx/ApqdqlKYYfOYOSV+VT+t7Dyu53NT/e+dP3tX1fn6c/Xgxb6VmLUXrq YqScJPIGj9VJtPmnKTEHseU/b8b/rXUh55vNEr3fBp8/p9OTXHLj1f6ymaZJDSWqDcaqAcZvZ5l3 7gUR/gPURASCGXZUm00qri1xhRS2B+kjiK+jSvBlMz0PAaJCpY6VlL0WJgqqknifL7U0dvkT+uxw PNzmCcz1sOgp+hU+N6z/ey+92PoPMr8TeclNyfS9j1PxtGp5WHJOtgnoOpP3u8bIe+g1qqmpRwK5 RZW1T7sqc2KcVw4yjhu8XDgEP6bwCGnkc5Ll6whu6euqJjy7ONdp2/j8fd+dn/uqawFXK25s9X15 W+1ZejWSN03dfx37972XLHqm7eKn6s40qaP8zDu30Sz/ulXeWBEEmoggVUQT1qCT1QOkJRIHm0A2 8pAwQTql4ptJ6aPPTNOrGDXGG1LS1anD58Ih3VNJpNoBUheKBNfg4YeUkqEMQUEQUim0hYkRP30s AUgoZUdX4zUBSKLDEhbT4ZDEAJ80JwhMECocpiEikMQbRQIpJ0hP6/q4djcpx9DSrWLserR1wX2d fZrWbC689KfVgR+GN4fbP+UURLgoH06mu8266OmuBjVCaiMdKdVXZQmo8IwdlguUSacLdPdPoTXn tUIvhwt6vW/Ev1qnBUxF/Iqf95pU2VNlTZU2MVPUbqnwVNlVO9mvx6q1rb5J0mrTTvLKqTRpbaot 60rLrWpirBBJp1lNNiqKTEmMNasF1qwNIKCiITHED/xiBk06mG7cGjKFCmZRTMpbZjmFmMxxIaEE RGEUWRYpA0KaKWlpaiFtko0YBgoqiY4hkVYzHGYqIxwwwnPNIa1Qw3RBFEERNuZcyzGrN7XWgWb3 RN7yT/sirJBVkGIixYipFVcVVVkCyKIqIituLbbbzddu5HknocXkPBvy8Gjc632vomhyQsVMVPUq c3ijJK87we1dTdhXwsmIiSxlPeplSsmjCqivnb3qkrCHutVS8X6o+L8rgNq9ay/xf912Ol4keRtN GjqfGq1q/nfI+hodao2qbvJ5aqqqq+haqroPIHIkEYiQ5EMljC4UYXtUw9StValZVhWzs2x/omL+ g8d/xcQTLjiH4/n6NsOOVVZ/bV85unU6Bs+WV3Mo6VdDBgpR3Fasl2BjMGnvRpOjFTIvg04PymG7 Q08GNGLDvsDfgr4cFxVS2E8gh/yn83aqqIiKqsWBBEQZEFEiqJFkYojBUFRIjFUUBUZBGSKioorE jGYG5kkian1uDwfM0J3q+J9b+ww1YOx/cqmzmf2MtmhyZR5mZNmGHM7FSvhYbNFVFU3KmVIaqgaK YUYVCqRVSVRVKsiqpWVFP/0wcyqplxYYavYrc0QwpvUKqqhuVGVRVFUhVFKqpJVkmZJkwYw1lFpi jGDGKVUiqlVFUJVFVI6FdKohuUSdKp/4Nn/yZPVU4VZ2MJmjiSTEX4tQdx83zHwfB6P5n+aph9mo r8Spu/wZJI+t8/v9Mep69V/3yRO4fdFSYSKwYr98tNiRtF0vPmergr9/CX6nofS+d3NnF/Dr8rg8 DyFeVo9BvNH2t/D+b/FJHIqErBpoaYVT95lE0ZVNtGoSf0srmxUkW8xbsXDItszEsyEwf+MImgVS pJl/Sfrw7H/fuc3PtpuYx+2ZeXoPAnco4oywlczxJpI7vEPM1fwMjo6N51PK5hxkkfqe83796f1H ed/K8fz/250tujeAqm/I4Dj4jnG8522bSpy9B6DP4IDt4OxI8DWO86e8njdWEzi23c0frwcWxPjc nJh8Z9ymDDzNxzjoT8bequJ5T5UyaHM505sHR+IdH2PQ4ztdzUi7h1jUevh7fB/BYQg8FXqblhB4 CuCswKzHxPampuIiHMsUEYPINgOCSGqGNav7SYbngTnPBRVd3gq6tSHaqSck4HYdR+1q2c8dqMox HeR7XkdxKf1/7+B0PByYRsjqZfCG3sPQSQ3m+O97mHk7GHg4qr4WX+Zh/tGXgYOl5H/s8Xf8mipz VOYqaU/utnNhsfBs8zdU4HCqvO1eg8qp9bi4xOFpwe99rOo+o+ViIOg3mB3NvYrpaNFJwVoUkJp1 nuj3Rnu64w8rbT4o9keKNfcl5Ocoh8Dox8DB4DijkhyGRNhNhH2RFFQuxhG1c87MR9R60qh9v2MI tI+wppCvoJK9SqooskQ2XKlShYiX3WRP+Fm1umMyRP6T7n+PZ1TMaWI2/g/YZND0HBg9CUwbk1ZM f0kweIwYPtNnUiSAf1JP6Id2ktB/bf7BzSOXHWgxGMpmBgJLQsEZbS2iY1SRgjIikohMVg0xyuOr S5QzRkyGUsGMimgQC/G3DiFVQoKqKgsoFIOhCJFcbBBhSwctSpoQ0kuWQxuWGWa1YCM1dYxwlFlQ S2II0rcmFCIxTThKWEFlClgUtoVFIaw04ENRhBIwmkxmBqyGIYJJUIUQK0IIEWEiqH5TiIaPZuZg SqoQWQWTaSoxSLIijy4ittNZlmP0fjjlJkbKnCwolhiCjnKGJDCppUPuqsqi4Sumkjg6NVR/Mhd7 ZtGphxr5L+F7H/w4rpVPSqX+2qYkB/IyiXbYFUcLk0VThH/RGlTVSphUwSYqalf+NV+2VsUck6vz mjv/Jr/mcSpoqfncFNkh/GqJ3p5/Omn/GfrPPTMyVo1MMSspasxMP4tv+udf+D/BPSNH6H/g/7vi N/w9GC35h6zZOo/iBJi5X/kp+yecV9ifeLefke67qxgxRYqYWSzw/KJZmSaRX2Izr8N1jWLKiqix uERxTY8g8zeqwwbllf+a0VmRbVG7UxZJlTMkjtjxxJOhmMSM1f6T2PkGDzx6CWJVDKp+lhVPIVT5 jsJJ7TvP8jhAO0Scn/KyVOQ46ItGSp7cKXWKCb8HgH88fhR5151TSpipkqe+SXQ4ER2LonIesKNj ci3bSSzYtnll3p+/BPAvsvszMx7OH6bn92uwiN093Z93fJI79B1HaLSQ0TxRsf+5gk+a3bzw7BTz VL1v9hyVpjYceyA9vaNhlSmvz8ik6u1RmX4Y9iqW3GmdRJzJ0bH2Ho0/siv9b0FlEV+mXaJ+/42Z MifNRiT1JJnEj5pjsj4mqTXZfQrtLbXCyxOCs/v/wy+O7cvpOXRPM1S+j/pnCpxlGMoZZRmTGUGM VWSFmVMWE/h3+cWT9Afk0r84xXNo3iiMCSbSo3HEqc0Ucyn5n63kaEYU0ckk3ig53qfVMSbWx+T2 Gv9Sncmk9yWUer1/td0IYlBPeic+uSY0LitLjOG31GuXidIm481iQpE04tH8xqODZubNNPxOlBji 3aYwfP0nmkp8nh0d8V4Pxl/c2UtKXN9RjupH5Rz2NpDHpqVxUbmqJXePCPmi/530Xtv47xSvKWPy UsDzPAk8KBlUybMrrO8/5mhWjRhh8hRwbfrrYSfxfaU7WzmmMFlldKmIvEVhzTYTSWUkyUc1UMEn sU3djRWqvVjiP714VLFY8Gixi0pqpoyplqamiyYtKaqaMqZatLSmx6qu5GuF2ng7Vsdl0iONUsUd TtNml5RsHESc0uvBLwkjkMKIz2SmK6JMUehcybFmLFhZiq2pMgwWy1VYrEHrBTbSpfgPg8mH5S8U YG2o8UmojEmKmmJMTYYuWA9BZA4JOEiWJMVPnEm97n+j8XZHvGcH8pJTrp80J0CMCosfX/3+xJk/ Wgf7j9IMqgjPgglQYyMfa6g6J9OJOQm2P+3cSfP0jQRSzsG/+JjJ+2zclj0F8wPYevPnPUT9lSrA +C2Wl/AjQy2HjqlL1JJCOjRxtDCQgwALtm1jFTQ1yjjlhG+RMJDSNR/goh6b9PkzD8lmmvB20vAo ecZ9cn4vJ1PTKvqql9IyqW0Kb+iuok87zi4qSXzxyr+sxdI9DiVOTKQ77qJP1UodVC5iTwKna3tF T0Kqv5m7hi6vhVGGBiCxQLyDc/okJjqVPKeEVcm+I+Qf/DfIhu1ERifQdUdU6h0fAbP0+owPr49V WQhRtiKoqqGPCOr/fIQ+vgPn5kGy8fMSavNlnomrgEm5JqP46d0/jz+/7/8f3J982mTJpaTSdhxv HH3C4XW1TH9P9fzuEN02ptmfp9X8vyImv7flTojhPxKh8zDBdDE4RzoyfVGmvoYMWVUPyr5j3/qe JPi+B+RX4uOlxvtcqRipuqYkxJiTEmJMSYkxJiTEmJMSYkxJiTEmKmKmJMSYkxJiTEmJMSYkxJiT EmJMSYkxJiTEmJMSYkxJiTEmJMSYkxJhJhJiTEmJMSaaVNKmKmKn4Vcjc/kNh9Q6NlbabmxoTXbD KUVOKT3sqqm3FWGMcLhjU6xoUtYp/78uTrxO/knCwjI5uLj2oNLJLLKyMKRkZUSwUxJiTEmJMSYk xJiTEmJMSYkxJhSYkwkxJiTEmJMSYkxJiTEmJMSYkxJiTEmJMSYkxJiTEmEmEmJMSYKYqYqdGqp6 j8J1y3SllgpqcKfhC/EVzEnGt+8fwKHNQGlDYH9Wa8dpp3xVvq84SaPAJOV/NE7yU8Zgq8HBc2wk wU5KA6Rt3R/RdxxT8z9NyU3D0Md8fnSfnSYkxJiTEmJMSYkxJiTEmJMSYkxJiTEmJMSYkxJiTEmJ MSYkxJiTEmJMSdlen8tUv7apeqvk53oeai7B+e6pMSYkxJ3xpJpJiTEm3YRdzwU8GF4vPzYMVVLV lHESYFskxUxJ6rQWkmKmJMqm5O5sdNPBbHd6LiuJXqXB1O3r61TG4k8qTSTZJpJpJpJ1Kpsk2SbJ MSaSaSYO8bSryNL9GlNDaSmUZEyGvAqeZfX2AxYmTIxisymLBkyMypixZMrMpixZMr65rVTJlZlM WLFiyZRmUxYsmCzCxdxJthJ6BzLyNHy3YoWd28Wt+Ddqjt1eGKGeRO2nbMLc5iTy9gk7hO73MHp9 9LLGWQzAmMVVmUUzKhmKWZQzKhkyljKQzEWZVmKGRjMqKW2I6ZEyz1TpjvkdLmVSut2mCInlNCTw tvS9Imgk1gqrxVOaTik0qaSaSczlcGwkwSYJODo2CTBJwFaOCPK6ermJOAk4kXO0hJsJOC3ZVcnB U6JOCTSppJpJvgk6uKTilZSIjuTnJ3sB5/N+fH/j/8/y3fs1WtvHw+/90fVJ0CUj7hH1bnLfiZ+e hnrJhhCNSXf02rlWK9pL3GJ6lpo04NinuNw+IvfUqx8uR31GspQT+DHwKT4VU8L5lyTcbCTsq5nz mFJvmCSPSIjq+RKe1sslfCqrbahBRYIT5QIDJVVSQVYjIAGqpapNpLyxVk7TKm5hb5mZiqqqoqqq qqk1IAbCGAGSk3Q2pbC2I3FOGl1pPzva6fZz8Cc6pdGmBiLtTxjTl8H4GMeNzjzXettCTn5kc/1+ 9+u2P9T6PNU2n6GUoPoWRVkn3KlfiMRznbQ5xUYKWegsFM4ZSH0Gmh1f7u2EffP1Jtx3CTYdd3Gx I2HsHwfF88+dyRz6vgxeLGO1/2VLywi97gPMPCpSNJca1VMOJ+g5Heb+e2TWtdtXN7vM/vbLyU+a YrDfUanmdhOC/44/h/acvd6dXOuccrU0YP1jBW+D2JfZ7cMy+y5XAk5rkkmW/DXe4rFK0+I+0qOv 5I0M/kaU0KXAn5MpkyZWUYsWRgkVIwSJGQEiRgw80lJYkH7gpLDCUjBgkQCtIwssLCs0rS4szGWU ZjShzt4eL9EgnW+9iA8AaetalPKlKePV3MXa7xJ3tTZVk0n6PiJOilw7np59nu99LYSfnaHn+taS 40k2eKMnXrOyUdLcSP0mE9pU+phPS8GpqnBNEqaPzu5hhls60vm289XbuL7B7Eq8qTge6kZUxFWF T7G/Ejz6mhJ/sUkvJKvYoZVLImR3LLfmJOFyq7GUXQqnTZS9P2HaJNP1Gdg5wFlXnlTCL+OVPAi2 HYVTc480YuX2FWRO2p1InTSKaIiPq+wjVeZibpJyXr7dZnqF9DBruEneh9gwY7xdlJBw9doYtNF6 8lUcXvNPXgLkFk45KbGQxkl7PYfpGdHyK3JB4CkO05NGDKYYOZNLYU4GST+k+dPvFio8fD3yYr0s op9wv7HK2fnPo9u1dGUPpRj82qncKI9o7Bra4P3sftf8sLXnqTgZAfFVL3XoN0+yQnASeyQ+C5v5 saNiKfMPwNhJzpcscbq+D3vLPP9JXrzIjEQmmGWIZtp9bQNFwOXezHBxOetIt0WVLFRZrOXE5NWK +GQVVkVP90mQ0QQpSFZIsWzGUyypmGMhYxju919FAjvLbzi51PoHMdBJxH8RguCLqR8V72m1S2qs 2+tcH2uJ2r8MyVXasqVqpMI/G4tP0zqcjqykfQypjFSscBJui71UjyWRzefkC5FJ5iTASYSYqquU XR6SIPFyod01uTp/rdr7mCnodzRHlfQHOeB0gNWAGRVlBkMqGO3Hu7qSef5auyi/CVxyl8lahlLs iJEEIgMtChEEaqqqqqoqqqqqlEE2BCGcwh9Po+IQWZhiLrMRajILYavXt2jeiTRSwJOLifwGkx5Q 6+PkXaOJ0KqjnZKhOgk+ajcTxPGpeRSxWK5uXkPK/TvVNik+R6G11VQ5Pa9meBobpPSk0JNJNJNU k8BxTyNilwScEmkS0k0k0qrddTudBfv/V/ep+RXP9O/IM25E3x+QPsbQeQnWbipz7+pl7z8jUch5 xXoWHsVP2qmKmKna6sHtX71TjNm7ik4pMSYk1D2cB0vrqVa1dP7dsJ21UPiYPnirI412VeN+lcx5 jjpHho2yqjtqVe06HlPnOyqY2YnRjwopsvQbnB5qLTz8PSMNj6I0aFT9ow/cu+pV576C8TTSeZey VR5xJsewepTROJJgwk5JU9pi7Kwi61KtHc9dKsPUZXAonUylR1DJY+RU3P7lioPhLPOmXyz169v3 TSZMvoyaio1RWGkY/I/LOD3VAfbzjb2leVK2SK6o7xO1MStXz1iKVJnA+SFY0unuMYiS81o2Ak91 +phdGMXQ1ofKmMuqqONdJSMzJFYJPYy7ch2JPpSYkxJiTEmJMSdVtRccKp0ypdsHMaqk3tGpnA6b DDdi0EWRJz+rnYUJC1FUVVDw/uR1fMhD+P8YSEPEhO1OsfPxTeSvxjnPU7ztsg1ssti+fTWYWMry MwyinlSFwWFU7hhozUqTsDiHnTrBuRbK6Y35IuVdgSbCbr3ZP9s/Z77YfwWUvgWF8ox1PJlV9tF6 iecPIehEYgDOHuLd70c/XFLPRQ5JlxCJ9u52vp9QoOnwGJPwKqxJiqslMVViTFVbJJxbSbyqO4GQ Z5Fo/AlsLcUHISY7uI3ST5jkcC8rvNNJx0L9nSNDhsk596+DyOr8y6DvlsvvHOTtRvdg7irwedbN xsEnjbKehfj34C3OktCw8rRWkk/L5fc/wJoff+V6RbDHCtH9rK0fF08ne+s+W81SraFnqzPHjm65 w1fFtltr2NhxU2cGDRphCPPYEsqZcORrzt6MJ4DSHjt0N8ST5lHq5hqbK6qlw7szwE4i6GhJunat 1JLSyPyxfIJNVxW096qXY9yXn8Q6SqNxJ29LYSZR8yTEm6TSTSTSTSTSTSTSTSTSJfnHTuWzkql0 7z5Tq3NGmDJXYNhupOAiOByU8R3MKpyNHIyamphNTU1MnMb4fpJFHs+JmzGEy0zBpfW2tKMrFN03 MWxsUxYUxqSuSnU5d6SbEw76eRLRweRXa4cmwfF0eV5BJ5hJpU4JMSdqTFTSTEmkhnknoZEVVEwo G4lJIbIQSENJMYzBMpNJMinWr7JjrVn0fCfTTz0/np2VttttN91brdblpaXGc5ivtyntQYwksf2n /xh2S9XYmYnCPxY+B5F9T2D0bT9ok4SrUfs7I0+T257VtNabPhsuzbXVwMqm3qqGYsxTkyKlcNrT q3WNtGfV/x8OJ0fedf+zeN0+2EXN/Cp2ch3Poc/uKvAOBpxt6frT3lXb6m90Iu5lyXZeVtHFcuVl TxumR4JErD+QRfyAC0yzqJgwf2WU94HulGrBd/fd2D6UsHoeDnSvDoflOp1pcTFo6lRPGeUaKwcB uJOS8mTlWFayo17F3RJpU7VDl/gNnYU7hxKTMKIWwk62w21WqTnuKlylUYVV08z5cWDEsLFRYvou YPtU+nxeJliVhjBPyJJo8mI3WLnvzB0fYcd8TsE9vsPl74sLewsJSAsFIpQcIofmP4yk4wzgoX80 DjWkOSQBFIZBhYUtTeiEykhSGTRNCMQhrQAmpgQ0K5EsllxlRqbWUtNmJdrbg4r4G74VzOfE0IGw 6ZCSKligEwNUlEmkJClDJFOso3axm1UsKTTMUUUUYIoooooooo0ClpKVFFFFFFFFFFFGCKKKKKKK KKKKKJaUtKWlLSiIiIiIiiWlEREREREREUUUUWCSSQQgyEsCCQk2QyS0yoYtk1oVqYqcDSaY5Y4p XBgwHDyGjnbjgnq0ZVVTcnEzGHIpKqSfWzzJq5+gc48/nfQfHYlyw40HkOD1lVRjLzNNVITnT5Os GfOYEnxVgk78GCTdOAk8U5LaRVHNE6vIaRrn9E7Dat16QlqlhVwEnd2qmwjFDCPQu2/n2iTkewXd eESdW/0NCTVXfY3Lb4ZmZmYS/EJPUcFvPbZbbbbbMNUs/Kswh1mDwJ2jpGkinHiJNi3q8Z5tvJ6k a7m3RIWxyHOpTV5O3+3Mzf9eMJxels5KFvDXW+hD1jJJG/bdE5JuNPzLS22TrfztND5DUqTnS8o7 Tyl2nBV+dYfgX0DR813ryLxpVu9Y8Bp4GXr8mvl9Js7UnwSYkxJ+++arwIu8ef0OSTkkxJiT7kk+ 8LVHk+6xHqFiwT3sPbLEcFsFsVYlq2Kn/myRDyKjdRPXU2vIinf+bRmM32xXzGY6BHDfhM//6rD+ zKbsmTzp5VkxZMLub37vj+pI+Y7zbDojq1jToihpHu54zFlk61hYIgbbBggqFsLBjJSwskthYMZb CyDBgxlsLBjMH9BkLCynAXodN/XGU4K1bHXMXOBZPBL2JxmGxYtTlZ+zWDEbLMWpHQ9r0PPH2nqk In6efRJF7WZ9LDU0xojVoCv/KyT2DijhJZhQmYUnMyFayUbtafFtUvqV3J+lL9KWqp+Uqm7mpFsU bDVSnLdkPLH0wre/lbKIjJJlESVSNR1XcZQ+YY1389Lq+leC18ExyuP39SLVt2R4MZ6GqlZSrqc+ Pj9hxHefe7MRprReJefyvwnCXcj0lJkn5HexSDddgwXcN3ZOpnJ3U9Dy3MSnIohfNwU27c62Ximl obmarYmFVqaVZMTY07B2iT1h6TC9a4b1YOL+U7VdRyazgew6+HpC67HkJOiTCTEmcGZnApO/g0cy y4iTRunBKbJMJMFZgk4zYr6b9Yuxfyvw2W21XdlInxWIO5UmhTFm6K86nyKfnpSNUdOw85Xm8h6T FjFg+Y+PnVehVDrft18hVUZiRK1KTF2CTgvlvK5Wq4yrEmRzHz36DuDa+o8Ck1H3nxJfFp2DR/Y3 JPP535X4FsJPs8x+WDxHkTsdrgtyr1Oze+l+Hj5mi5RZUrrXJgxMGo96QdEkyO6DB9zvfBJ+xJiT EmmkmkmJMSb6SaSYkxJiTEmJMSYkxJiTEmJMSYkxJiTEmJMSbNJNJMSYkxJiTEmJMSYkxJiTRpJp JiTEmJMSYkxJiTEmJMSYkxJiTEmmkmkmJMSfZex4PY1SrKjyuwfcNrzjwHbL/8x5g207vtY1P1k0 qJrMV9mR/eiml1dIfid5CfO5MnjdBZu6vikkYfC8TV3pQyp2FI+IRH0iPAVJLRs9b2vzN3ue0RHo H6XifaPU/xOch2+qC89j3u6OhJE8DQpiSS89670KpeilJx/Qnwa9rKTGfTHfZJMHUYSdrDJnTKKY DJP9qVip8q0qcHD/M7l+Y99dVxXJVXyRPc2Wyg8U3akrY0PMJPoVqIpmQUxijVufdRekwKWj/Sag p6f2DJP61/qYjF8Du8q6FTyXgtED0yzw+Q/Ho28vTgaJmLwRW3euylXaqylylcnNk4iTTq+px7X6 37xs27M945Tyz1Pa86tx9eS/Cf6mn0vwKpYf0LBlxf1PWhk/zfQV+E3Hwc9ln/Y1MmGjcr7UN7CZ f6m5o3DeNxMCp80z3PrbzDCTUmsTWGhcFfQZf9xX16czsU7z/ayPgsTMWNmj5GWrzLTR7X+S/+Yy k/y/s/Ns08CdsTqy61Otgrw7zR67HTXmKn59kdhU7Uw/2rgkP/WK5tHvWytXoDew/rYfll1n6J6H MnQ87Y8D/cY4tZhdWpwPT1fqMbLtutjKf45ZTNT/qkkYkiUffgUv9mKVLWTMlVmShX+eRJeVMNVY v+tWEmkYjSLA/YqPAed/59Z2kfV9Dduu8imWIxbczMPVWpNL/6LGLFvsVqTBWMJE9IZZmQpkMI6y bn5Rls1epJohg0TytmGysNUpqlKKCtVg005VU+Zut18KNGUYZRutmyLVj1McGjZbIe50f8rdVN1u t3L+wqfUuFi4qpoqfQ4uOB/pzDKvtZnqMltxiRoW1JH1bP+7H/v5/9/+X4//H4aa4/978XS7dlSS J+8z9tbXef+jBTen/BwP+zwTsj/y6R5/2n627z5oWf/bH75L4Kp2OCM1os1rWqPJY/+1/y6/DUXs q/K5ksSInqP9Z+Zy/0X+5v7eFWJ/iHXuM3VdO3t/8Le9f+6UpaNfv2/6NW5sU3OL/g0cnteV9JiI J2HyzB8THUs2sipalMPG8unC7lepJ7386NB6XB8Kcps+9UMGzzTt1XD/P2+X2zwV68es8lehXneD 2NGHH5djMr/WYYf3/V8+jl/s7Ovi8o2PWfBs+X9he1q+dkx5DgVP4j+ZfqKn/e7b5+eE7h2qnSfC V0D+iantZHVs+V8BNs82zY5U+hOznTwNBglKKOk3P+76sNyGD85oqfxippf6mK2TGxi4W1UrDosj nKpRokqShWqSO01T939WUz46X/1HdfaZHZfenaV5F3P33+9wVGPs87ZSfpVhfwX9FMnGfeJOQXeS T6yauh4krCfWy1Nu0wIj/mbyVoqG11n+X/Ck/jS5OGP/Bs8hpzKv9GUsMqOycn47m6/5rMq3E+q8 wk4D9J39apcG47lduL9GUwwOFBtv5E4r820chEbm4uiZhEfcm2BEezjbS1bbbL2xvOqkJqIjtKIj t6hW7ojuqPO8qpxSYk0k8qTZJ3pPFJ5EnYqcEnJJxSfEk4JNJN0mJP80nRJwSckm6TZJpJsk5JOa p5lTKWlTikxJxSc0myTqk4JOqToqcEnJJxSdCTgk0k3SYk6pOiTgk5JN0myTSTZJySc1TqqfgWmr /LSTyLvi/axXhbP3n4SfUJfXjy2393Y/8XGjKkKUp4jaUpOEp1rOXqmnkoggh7SYJNsEn/pj+lHE pO6+Meo4PmeSivSctxJ3ruNCTbl6l2PW+e/jzM/IlYf+5kq5SpMfT9t6p9f20v+HdPOta0a6/4eP 9nPa8fNir2lD1RrGLSb8pQlp6pPvhZVrGlKPOj0LUo466aS0nV7FmhTDRv3ZWcGCWr6RimqghZUw oxHbfFkgpx/oTIQqqNiHKBy4Ymt2lry35TviXFautKT25Sc500xzBAidgEEPHmCod3oSEEA7wpts 1uWvLXka1nz89LfGKW9777mtZ330uPcB8p/N/+/Sf+F+mP6f6Eif+R+T+z8b4/3/9sT/rqxvn5Jn OeNq8bw029xJPVH45P4fW8Q1Q+NPgflJJH5TU+OfGfCJzBwnv91tLVtts1JxTZ7R8qtT43ufO4Pl TRT6nzm40aPnVMPkaPqaH1Odg3K5MNnO+p9T6m5ycxI3KlRxShQmbH2khw8ShoYPumIdvA8ABEz3 UqMP6T5Z7XEJNCTk8XFbl8mw+QXAi4XvyXV5X/o6Cn6DTDpcb5rLhe2drQqr/Ed/ESbJJh1Xsesj wvLw1xjPk81uuU2qveTplSzkIj84ieFXttrG9r0jP2CTMJNrCTEeovYfwPW42OvY9VXB6E6VTHVV zVYmj4Pq3e39rHrVPIkxJySe5Jsk+ZJ2JOKTmqcEnJJxSfSScEmkm6TEnVJ0ScEnJJukxJsk2Sck nNU7lTEGJZSysYsmLGLJixiyYsKsIRAjIKrEBEREJFRRCQVRSVUVasqRbVqkiqijuQeLCpbZe6Ch 1jmYSrDTmnQJgZJRDM4uMxGMRBjELbLFgVlcwxrccdXWnVLS4pFHZQYChugFRBRYiFQow3um8y60 qEmmDhmYa1rW6TSTmk4pNknVJzScEnQk5pOCTikxJ1Sc0nBJ0SbpMSbJNknNU51T7VvV3FcYk9Hy +Kf8m7ewecwwsGMa+CpeTnmbiTxWyTZJ3JOxJsk2SbJNkmyTZJsk2SbJNkmyTZJvcBJte/+e+p5n xODTR5DqjqnemT+1zzArCaDKghH/17cLj4j4D/FoeZrjZcZfIPjiThJZwR8XyDpJ+NE+sp/8Rt8Y weQsqqsrpKobikSiFKCIiJQ/9EhJx5+f9POvX/636d98Pjfveufef3q8eir3q7T3G+Tnhzx48ePH g8dDm6sbH+P7vz8h8pxnb3lpF0qmJVZVMlTunDP+Ky22cJ3lvJ+hexdE4RkNEhYMPEGDBERGMYxE REqqxvsXcRoljR40Byfd5PUbw50TmJhWKXlxI265mieZtxndyVcq5DDDNsvU75vMmTJkyZPB3FqT Ce4sXadmjglylOk5U5z1jjg7ougPPZJ3C4potEaR+kuRzqN4MVsTqkleFuTuuYqcBJ0kECTQT/UT 3JD6vNtraUpZKHjqR0htz6yu2ur0ch3B0i8rblSd83kIHzqqidE+QTohnKijJ6EMgSw9CJhKWE/q nOO0f4xyct5U5vVrSUsuHRGvDbsb1wm56eBN+S6fK/5D9696tlppKUk1SQ/pdRG+BO3qHkclUpVO ZB1GqimJH+aqpVR3zd1g35dZyG3F5Re0mVlcd+AXrCng5rgbo6DjO2JXyaK9gxF3Hp4JXuPMTqic nFpGE3DnRxI5hbbbbbbaqqqqqqqqqqqqqqqqiKqqqIqqqoiqqqjA/We5K8ek5Uzqp3cKb7dzx1X/ 36PHKHkqjiTl1nkB4vCPFOKzGRi3u5O3Tyzp2hbztmnR+ZtVOAksqngdSrbsUZ9nDTU1rXXXXDpX mI+BqSTkSdUJUO+STJPyQ9f5EzKz17cM+Pn+wN62QkC1VVY1V5D383cndeUsscSqb3tN7fLF0PZJ R3KqlVVV2JIcI8nTqnUTppcphw17sSdibzGmw5zuPK7qcW+hdZhS1tX4l8x/ejxf951fM3Gy/W+l tOSlV2PQywrKqVKVT2SySdcWUxyu+7Xyt2ncNQ+dU/irT0Ob/q02XQvGpUI50/+jsH+jZh6SpmGV GxH9xu3RclTCqc8jMMysyrMUzEWKCAiCqSQRBGMZFgiEzKzKrGUsyjMmYWYR4zKWHTo/mepgkjWB zHFwMqwr5zUZmVVMlSYwMZVL/omPuMeD0O8f/Li4SXJGGI5jUjVZHVNIwFCiUP3/r0LtrAUPhlmi yxkIvyS1vdpltf+Tc1TLC45rLIZMX0ZEUNpCiGMKCAUZCVkEZBYCwssWyy2g0/rMjc+Y0wfC2a8b JN5wc3/L2uApzMXYbP9Sum6VdV/0+39mv89bfZ63h/p9/69mn9jtOC/UtruVmvxr/31s3+zCWsQj UisMw9tsvE1y+g5TEcTMkOoAgD10ljUxJ5aSi35Pvo2zs76PXD3xqdQW+62zvpHadtHi0WhxNd9J 6U1sSzeKSvvLvG40mtWeEo0111qpvV6wzoxt7JPvae8LRhBrObQa0P/YU02teeur6CwLqX5Z3uxL aFNDYdJPxDADWu660jGA0WoWlHH3/MInBpNtNd6Fmnv4B2BTTiHcHcBWvPpLTbbqsW1brl+mvXPc 99Oc1022w0jpptF9GpfWG033d8jsQmutJUx9iCVOyBLey0rtXkZw0o7YNoXxKF+I23sZ4eU+zR25 CkmmzT43iu5po9crYjGbWkz0aG1K5ZZb1beTev7TzQ/6B6hkAE/qT9/0OgHuEPyERPj60Ne407tu 7iUIebnRvLrY7pLWNyr+qpPEfGtL7+HmuZfP0EPN6y2NcWzoLrvxEWXC8iuizOQ/H+07iXK+p4w+ oDjOea9gE2OR+wHEynwIH5v8WcePybVzuJQHe/lubrppj23Mnwz+Wqf9KplUyqZVMqmVTKpo+86y r4eXzZ8vty7PU+xx5e3NO7Likkfrc5U99SzHVnNSzOcv0n/BiY0/DMzMzMzMzMgDNykhhLKUjAkY yIkktaJWVju0YiKfB8HZ6rz6xPvVPZ8W76R65PYw7tNWdGqnvxGFrl+r3Fe/G0iH8ZJUtgegIsp/ Vw4B6uWcM2f4/FJqj+2LFixUUVZsbGz0kne0x3y1LfR5sM3W4ttq3BRYe86DNkODwsjM/hOrDmNP l5gKoquqJ0VQUFWoqI/w6e/Hl9kfX6o+kvg9fSq+zNfjw9Px98ZpPzWer8PRmWh+KtM4jevicOd5 dOUIiBjt2+qB4XCiJRD4rEFUQS/K3XJ357W8Ds/eQ4On7oYi0/K5S2FjdnwUjHTZrPBn1qef+tEN 0/XaOu2OWOFjLhfQrvOcN9rbym4+L149Nc18EOii2r2D4eAoCJjA/rDGF7tio2rFbn21dPnZhlMY 9tRg+WEPz4nzpi0rg+d0L89wWkHZBkmMqphMUZH2cjbyO32jcmnnR2TLBb/exhH5Fg5s4XZaLFhS z802iGLCnOfTqiGSwccV4SAHsH+MEP6/v/5Gx1bbK40xb/6QMAQSLIsUFIouTLppiougtmOsZrRs j0wPPiJJOM8i46bVtJ0qyp1TdaZExZBWSphjbHLXi949TO5DWpNL7f080mdjypGL34w48sSazQcN dI3vgPA7q/YfAMcZi/YGDITDb0UJgnHcyKMQ6dqilKggMBDD7igIuIzBFQRDGMLs8vLKNcC4ufv5 mjDK6kXS/QdL89llhbLHY8s2aNr5VmUiVSxz3CpYZN9FTWRMSyFIZrmtJkdg3A35tKo1YplZ3umm 3+Gj/R193ZTiT8gk/CPT/l/k/y3c7mOWHf1MHmyYvmx42c58eb078X1MUc16SrSvbScNU4z2Ukrt Mgmf+lRuyRds03KTVxvS/0sY1KaVP5ojFTJEsVMVMVMoqw9Tk2quBwCuGRmLMZhbC1LVpbEyiS+g ivIknyxvG9k3TX2aO54vhZcWHg2skH/EoMVVkWpEEYkWSiSBWIySVIT+xKJBwPMYFcGzk/NQdAn8 dyvcHCfTeu1OP26N8q9VONYmWqeTJZDZTfVao2GrZhpvEZuVjZjK3t6trc+pwTfNlUT69lVs83Hg bvtl1Hvyt3BebtaVvh6WVLRg5rJMZJ9ObYUMA2lMJCie0mj/q+WFpRKEIjQaPYjz82rqVtsY6DQP NFknMm5tJgk/dTU49Lbs1fsn+06hoPcZFPqyewkhiVg2bTfznsOPBoj9IswxGHBlGQlO9GCxjDcU +1x64ZEftORgjSTZbHBomxGhNIOHX/P0x4VNYKxidroxmi5GZhnH15M3PYzmZ9Cu3/0Tab5MCYcx I3ycY+ZZPxdJglKg9z+pzEknjvkT/o+y+j/rg0S6L/1XFvI38iJ0eedU8mBMxjDs0/GVDY588fZt f+jbSoZUsZLno1jDouuK0jTESQdeh9L0udlMmCsmGGGFGCmCpVKpMFYUqlUqv4KVp6I/NqVItplE +n0JrJH1HHLLkfP736NmvgcSn8x/Wy/S9jAeEkvy+7xOR1J1IHRUtstISlI7cKsWKMUxfP/MpHf6 JO7w9665aGr4awzGjS66GQ5Yi9X6WSfzaLMGDD6Fn/AzE2yh8rv91hRm9ZMxUNpjMMkKYwWmrCsR gYwxLobY1svgliySvzmmq9FIuOMYw/M0mUpYyg1kfHY54s3q36DsGHx2guk4cnlhPGbfLfJqrj8F J7GWLJie/Z9fK5cW/oLKuY2TDsUzGl7v3JJWd0P9Td4xu544clbnPGZXBYYlYGxhrQ2ghIMgyBtl SBu2FZUigqyxAmOwhgULFkh7ATkNZ5g9KxattiEqlsRJUWUgsgLIqjAWB/nPSaD1B5kfuDO/NT18 5vQIlT8Qym/NHZTK64bE1D9Wt/t0GzonIZTGUzWTRYtJ02bC6c04GwNFNWcQwuZ0CMIExjcw40J1 1ZjfGohwa1Sz72C+3yLcnIpzLHK37hwREQFxMAwgDrAgyckPdaZQYhFREVuYSRkkKGUHAWhc89F4 mt5/phkrzb0sIQE2IigoYbDNnEsfQLYkgigHskuZglzotQ3tDtant44cedskm8qE+1V1/5+t7u3T temjm5A4fgVPlwaD+//z1+/dAh7w8zmCcmhOP2JSZEbHVE/dV+ownXasqx9tmK9tJsWIk/E8nAmX cdnpkk0p8xq3h8WPYxcb2nzu/Gn409/JscAIUEAUD+CRdWIIhSlwzGJZEzVqKknbfurIukF2fRh5 58CSH8v62EH4MuqfEwOh60fzN5vap5mGVTdsmzQ6tCq0fEjkZwjBwaGiT9T+d8X9OeXkJw/p5SWb /0+ev+LSov+W5aza6VbSK1jH/LSU6ZjotpzLWUxVs5s8/rLl8VNFKaWprQplaR1vbECVplINOttJ 3eOk9b6QqxFfrneqrtia3hV/cWI6aYv4o2tqG6yfV9+F4Km2yzsy0vW6/fy1jU/ccJrCKxM6OnPl PHDGktWIqPJ46LLe+JaWppfh5msY1xPStxtFoxmA9GK0quGlZcaWxCc4DluIQrna0ZxwtCWla5rp ONrQKTfSguZY+PzZPbtaU2scuMwr213vS3D8n53Zzne3KxrO0WpGs5bY50SOxncrEzaVJXk7V1Wu lszs0rrHGtbO67Fo65vK3Ry5t7n6NMH/Dqbul6DzPOO88w9UiT4LatKkiCRBQQQkKU7crca9y8de vU606dezVssbLW13sdbV4THT2CipoC0bRuJWWiB9CHZCtfREAE/MBMmISYPkZnzp78Kr6HDDKpsk /nA86W6dO9eH8PB+6fT2eZ3dxKcn9EtiqerzguLeV4rSOxuIG93rvq2yxhCEImbrl9qpclHe+uuo hMQaSltK5Noa42hptl4Uw3qtO8Wvm0KIF4NRXzad/QENQIJ1RAA9YKigpTHLnxB/Ycqrv1+z+dKd u7rnljt0lmMrbPwEaXm27N3hqG7XEk4kWforB9A9z4LO++SswISBwQRBMb9tPicaeXNZ+bdI93WF KU5HXDyIzyulvHzus/WdHYePqTonm8GqeyfI8stKtqeYwolJ6BhMGLFBEUd5DQIqIDxV7VV1y/5Y izKmMsJkqr2K/uH0mWpOFe5hMQqpVQzIrLsNIzVxmC9/3tIPvwfuwVz76i7/wfYTrHibq6tpfkfP 1T6MU4p0r9TStm/6Ns9W6F5lMH5uBpR2CqcUvtPFp6zk95lo+Jo2YYamrEkwskv4MMKqqKRx7OVp dDqG7/N3uF9DhVS9A/RHweM3O52GK/Km9pTSI/bVMpF/fVMJB2cRNpBvnzdXk7fn5tndRMb0gWls Jw9W7XR9jVxTyag9jxO1hOjBl/YwZq2RHpJwoCIJ7aF2KOEKIwKCWdCzEZbGWNM2GWiNtdFapAVp KncKo+XKlKmYCswiGYVVmSIrMKkzFQMxFsjkdTo0cuUV0MgPAsoprEW1cjVIbQxR1oYmsmJlSbYs xTZo7GzcDFIxvFaE0YTBlWKsoYxSOOE1kmczg8XvMo13IYOTcyyca+NyRuFRRYpYpUUeZwcm5xbz jk5t7ZK9Duc43J8n7XE6lOc+33fFeznidKSrZYssqratlpzEkb3WUowlUiqlFSup7qofvr/msrBo ampkybp4uPWOewEAUZNbadvuWC/dp5HzPy9kI2W0T5hPi0/uv+j8FrrG+uef4X29m9tteGni2++k 9d9p7aV2NdVxnxCYE9mttpS5KbVhY4tqLXVkSc7X2exedswvoXhvnTMI4+tcu2Za5vrE1bFNry0r 5ZnLPBikVhXiErQwuayeGm+zvnOjHKMK3vpjfSDvtxWM9ZtrS0bNY1amsdpUT8Uvw9b3xnaVljDB Z9KrCvXv/cfE8Q1NOeloECHNottDqctYVjF13r0m7pWm9LXjLHJSZWPXV+a9Jr4gccZcO5QpKdOV OWuy8uDPErF5RvqcD22wSvuZ2trdVecMtiG1FiusYYdm1jDKarfkQpZ2xbea1JRo1h+AJ2qR9xK3 3YNZ43dxtH5t9KLi+3Kbm0JaQez8u8TTS98dMYxyzHMWzKvGk8JOl7ngwPb4EkeyOYpqyrLrItYY mGMqvpU0FX0i2aY6vw3JY7WpswI4MrBYTmWJtFMLRCgiEbiDAJAEQTy7+UOlesVvy5RncCee+qs3 bfr3btevl7heOLz12TKyYmJsvubn4wyYzmMTs8vLt9PL0dG7s9HwjyWS2LJKtR6Sc5NqYS09bSn7 WVuZuw/rPxL9RpixUkZSRhMGFPe+FlhqaGWWjTSWy23Q1MMNTCaP9rB9WrCxJ0Pk5RHlcUNzu3R7 pAie8sL+MMyQDEQSSLYaFQFRQVFFQ7Hp6eDetV6+vxn4uy28PZ5fiRzdfT3wbJ0eEdfq9t04Pdw8 3Z39no+JDi/GwJEj7FQT7FAAJqMMgBe+/Pu26S27u8VYQj2+CyrLmqtza73XwjTUOp6eAAd/Fv1+ nq1vpTdEPwFRQW3fqjof1AF2X/3n7kDuLaY09epbw8ot28eIYliZ6sSWFvCmCyuBX7EUT3KWCpil hgpikL4n+Loz974bKAghZUJVu7MkMo4YWCIKCqzMkBmVQEx7NONbtCBZqwjLfzlSi0+fwr8T7656 ctFwQ9+fBockDkh231haMk9aoeoWdpE4FBEFj9p/aAMjPFYflIybFiYeIziRCwU93q4M7TH0WBtB jvfzl49qfah9BvXG30qoegRTuGVFRgjVSiwiRP7UozD8DWJMyQhMr4neqnce4z0aGJKsY+pjH+tm E//d4o4yC18n65Gou5ttU2lhYvzWJmlXYnMFj6ByhT/suY3HgW21VfLXLm50t3bNSfroxaVN/pr+ ZHYww7zfouzOYRmykNg+5o3GUU3HeiEGhohopTQ3Gh49/knw8PJYltvvR1dbSo0kJxZY4riPoH7O 3YNZIWoOFxYjYKFKWUyJISoQqQlkSAWkEaT34abI0aap/I/G03cTKrsxV2L5h+KVWEqoxiwUihBZ 9MLn68yJtrWMri46O6uS/IbJyyZM3o3W6mjBsVorkNRwzDLRtbrKYMjZZTg2jZwzGKbobqbw02W7 UYChmGJksmYRcZgyiMzNqypVVGiGjRFIyNFRkjRoKmzZCwcsecc+qHgtbl8in0z1ant1ucTjo5jQ eTOsovwGJWUwZkmji+5kp4GWWSqYMvrVVKyjI0GEVVVhVNGjDVloYc4k+Z0yPQ73a/EkhHmTl/jo djj2dWY2jGKxqmg86a3hMM7k8LkcwpORfzDriUevKrzrKp+SIOckxwI/bxe5oaFFZElr1fFHcmmc Nc5tt0a/hokSalVUla1zXwMl5TRpeeWX4L/K0nBuvOtrBj1eU+Axs9VV9Hq24FwZavMY4rY1K65X nxVzSzRKn2pnEtOyv+yyapfKkfzMJHjpfBiTdUk9/Jg+GVX6iV7cx5JLG487tZdhEnjfAzUw2J69 HS+EwzbS1FviY2OQ0d01aZZVPEYxE9P2TkWM8JNzHz9neRvCx2O9sV0Ij9J1Gp3H5ud7zXBOZ6X5 +o2Ro52qtrP9r/ixCZ3eSyRuaNyvQvKR1KMHS2bPM97hvco4NT6YSwtkxTRkxjJsZaZVbZSPYlh2 U65ZMTMkYMOshzJ2FqdNeo53YSYjqlQGZtwYxT6zI0lP11NLJIzZDF2koU2aH+7em/+jTpL6HucK zA7HesGqEup+fvOnFOCz3sdCNp4xR3CfylF6fz37/kPDwyu5WF2m7k2nkfuO9s5Gz2GGHun1P7A5 BDU15EKceluHDg4WpjXOcZNDDeUypbDhFJzG9uGHMqkoqFJwNZBMbimrU5oaobOBqQnTiy3f+ON8 6b04biluuatEuwnEsWeQbDmnCZjIpKyIonMG40Cn9RhhxxYKpsNSuOWGD6homxmj73rIKQeMDJyV oYEHjVhBGEJFm3Si7osd26q1DmyqlkF0DQYBDLswCuBSBbQhiV2JK6sSwctwoewJd1ECpCt1SGCy +AcZiWCLbRDgYbB0KadN1ANYHRmrCmZqCmOwSYZRLSoXVtrcxFEoiVrkYNCctsc0DBBNKSiFLoqd ySpIzCgbdLOLJcjUFBygBxgy0NPEuGtOFHLENOsqplAlMJZEOSnZ/MdDM1aJzrvLo4muGqSbmMHA aH+iN5NGrxkOCcjpaHRYWbOZkjUpvro0RTuBA71PTZQ449Mk6GHG7FgLA1wf3csLJhqQOBIHA0Yd fwk1uGJkmQlhnkwL7BLDUzZDIeCGpPqwpDgJwX89aiVEklj6e38f4N/W30LRd+nn/L991r6LM/k3 3LPDo7ziNcpL8ftxHM/dvsYxppo89Yy8JYk0OMcHGWpZmjOeubazfDzWml9DW8bYpyNIKZ1tKsdN LKtNlNOl2tusTVSmDHF4m70nCsKReutvemkox7qEON+e1Mb7NLlPBaBkREBC1IHKcJY4zIXQxXDD bua6zezclpyua2pi+mbmxrs157VbZrbVthf6HmIhnNiivOjbRzejNTcltts0rU220lvo/Gk6ZlRa Xy1NLSsKyXoq6m4mm4xCl5C740e2xtfqgCAa72gZ302hC5i+pVXvpoKrZGtDGvBcWCxtW05PGuOw AgEJZnStcw1nDTGOXpMnis9c2ODeeFnbD0zKmu3Fb113aGIXniWLPPa67YW0rDZ2mbW1iqTlZ5LF ltLTTFqClIw0Z7P+edYeYiICjd3k5a51R/SkjyD1KPWVG9qRhoYTJVK/+Dwm9mpF1mDMsa+thZbK qmhcFJomTRg1g01NZMi0mppBVD2oIJ7gNdfCNu/lz7eJPupPujbxiQnJb+Me+enlY8+3K7sdPRz9 Hqd8k+j5SRlI+SH1lPaZMGn55vrar9uLaoYTx/0cM2/9c1WTgqmR3xzfX+T36zhuMcj2fPPosx1L ZIhuI7vX6unyez2ef0+n2T1kJ39cZTnekoK9Znrh/Y/tfGkhE4D6mR8tbXOW1l7l44jUtmENlrCU 1l61tKOWemI2OVsbIfEBOvkhKHvNkFTXPVsrM15RN11k3F3p1l0W/GgleUUpSWkS1wzWBMvXIEOW CrFvXcFLLJbCliolotlHvfi8CwkrVTEQLJFqRkEGhSaZLkLZElENDgmmSdiJEEYQYQZES9Y2U5Da MancSfu3c6PY51tIhrbvzz9u/dy4dLZSQOmJKlkUnVJZO/D1S+T3113mnmfeq+xD509wJ5kta9y+ rhNVZmVvRHgKjq97dvDw8udvFYWTBGDBjv5zrs632sJwH7/4mVid2DwYv8Fc6RpJbKpKSFn6s+PJ P/+dXUrQ0k9pF2g+exMHk4vd5PMjMieq1OCYmaYOPKvvSSvRQX7oryvXHSaD9ZvD7GSuBnw5v52X 0puVSVCKhhSJspSkU3vOrDnWNTzS9yfMll78Le23BnJDCwkMrRpjqFoaptiF3rPom2XptTgDuxXK lFJ6iICJ8Pp9/ze74EY/PD4e34ym68VpJ/lTy+jQREMfTPGmYV+n4m6kpaHWvJSoAgF+BOcEigSP uhDg/cKHqd3NF5ghyT52J8lY9rF+BzSfLs3VPfJOvTd1ryeqVqzPij8Z96leYVN6pJsaVNsqmVTK plUyqYVMVMKm7Bu0ximHkaad6/Mbt14lTdbLR8xN2krDFIxsaVxXpxF1OwoHYYkkoCFQ9WQ/JkqR GAVBKwtf0uExaJnurgEkMmNkLca3Zb5vS3Gt3E4qnA0aaJvkmZjGGKZYpmicjZUtWorRrFM0qYqY qdDtk6uwaJ2nEv3KmOY4rgXJec+x9Sp6N3M5N1TkmjRDwInRJCiGySHBs79GIrCKSERGRYMIIxIs WRVRYIwiqChCKoMkgySCARERVkgyMwswmx2pxO+cZKuYxV37E3Kuyelhpfj4o2vsMyN2TGFqYl6F pVdwVOD+rGXGHlMpmLPa6bacp+02lw/dq1jyJDFT5GS2sDcrBpYTMiyyZiWKssGkmpLIkBRggMER VYKxZFBEcxTDJmGYp3uWRViaPBTyPMrwYNgZCK9tSw6HkHcn7ez19YP3DIqr6BkQTRX2Xq6Tfz0a OrrorxXCXrDDPx5SZhzRp35Kq1av2sJMW+BhVWyLn/r+/P6/Zt1SJ1p8vzdUHsWE+N4/zeXx/V6P o2PlfvEzq3HYI8VTyi9qx6JlfpYLZutV9RMgsYpZlnQ7tlL6xXAwaV1yXKc3A0yvjaMo0T+1TAT8 PYeZHxtGjSTyfi6kmfG83w/Op/vgmFhDGJH852mPPoSG+vZq38T9RySk9ECHHRSVOrRcGB/WEOKE 5ZGaSfdNfISTxPGV3mSeJhoyTLJgGWhllhlWCYebCD6P9Pltu73n56SeP8vP9x4TcsiTkhhRX6WE hhVfR7/bHbp53saPa7vbtcFMk+LQjSmrNEX3N51WDppSTHD+Cfl3x4JwQeTn4PSlHuR1mWXJ9yud 7Gx8hR7VYUwwzlK3t7SaBP5amzmeCSaKJYFDAojKYJs/sqiHW5wIW0GLBQgZwUNmiTJKIb21AziG Ko0qRkUR5wrnD4hf7HlEKPm/OL1sxnLBOH9OFVnPi9a8WZ42O88WVVpMX0Ra+lgmItO5YIKECYQg Ysk/0FM0T0gNBA8XkqFknZ6iJSUGWBdMFMZPFFlrDpsVNW2Tcqd0gqGpU+VKmqmhRuVVEwShgKUK jnG5+1wOZSEbc5nljEdhs4I0BDFga2IRSbmFkkwuEyIjCQAUTLCuKOMCU4pS8xdOcw0VzNzE5Aeb xIxP5ngsxEDo+mlu+1zH25LDGJvikDBmQkATQnHZfPpcOaeSl6PbjNoera+7csRKvQgUaJCbkJ9Y Ph+anXdHkN0M8tUMu8yuGRvm2HFU43ZYFiwpxdrGxsnhouQPF0rmczDoWE6nuLD13nnWFzHMzYOF O8pfaru0O3PXBDtG6xDj58644/JjSmQyYSDUfgP8wRnteEqdfFMp4zR3s1LDi+nwcIcnvwLRNCNX nOquYquJrDh3VDh+ruQMrfjs12Qf9kkzBc8YSDgqUitQQc2yOXRgoO51BnO/2b8EvN9RV46LRX6q z4wU0MhDSTEpJ0O+62gdOknqgHezZh4OOPYNEwPQCxEciTQDgKogwIMEMlC2boTLMqSNlSbqY4UC 0USVwTs10krckHawyiKCOsbRkOR7AQiAccbyZtAkdl42/eqhZbwv3/ORyNYe07LVyupGpFQL6I9Y XrFDSU5YoMhpVqqOXDO4ECoFUrk4Es4IiIbKkZOiwhFohiLKtGNWUwJFAEHkMRyXhoX0FwzR0hKB sESptANiVVmspmUMYZhtBdAlAYeEy5QoGoJpJhzZ2kC/GZM5lns+Q0QpweTl6PbZ2GkDY/aGUJFy YEqi6HDgSUIMiLIWQX4rJEJLqugG+3GRYg5A3K6YnBBlHwOKM68NrMozUqjpIss46GSuR0+z1jQe QZInNQc85UBtmknPtfU6IG/Br1Tl7TSYLwWeKQsF28oFGX1p1FDE5zjs7yCJMTib+MEIKZIO6SBU dBBEoDDzBhA4ua7z1ohShG+q35aupwPBgk6+QMb6oOmqRuRfUz0zDDicRzMjqA4m/LCK6dYEy7Ok QyGp6c7wn0ytaVEVdjD0TPT1vRxZtvZ9DRo6pz2B8xxdmkqiZiekdLcch0t850Exv1o0YT2skqJ1 IhB7Zkj68sPJKKAouAyaKEka8TroQIcg+OzQJJO+OPJ9M4uz3Z2CTQGHJYpBTqRo78ldScy5MTwH XvSkQMOSk9itBnLZw26MmsGuKN6SP9DDubmhMk0Oc4Mm5TaVaJHBRVRz9GBJGdrdXO7hTUVWM29m zR2Fd7oMnDhOHfzsLtGmSIkYVHjLggdi5BQimneNCWtX5brpELBCmxPWPz+/64EpOQqxLU6T19B/ J/woir0fH0nH9+2ZKvrWKjzKwGdawIWeFWiIPqMGMwKFLGczCRYgKKTDmEAgE5MfMN0HInLJUdEy TG0e0dG7qTVHjvssUgR67mDQkERqMS5kQtpC9dClZ5Or2pcJrgkrztK1sdJnUmb6ac1ITBCgoGkn EPMLMIhMhkGToJ5hxDk4t5zIaYzYDYxLGAILT5ESfA+MAFVVp5GqOKQxG2N+o6rqXdWy5ldJvFEO CSGQ4HAoMQPVWlJZBwEG5AyDDMyBYK/Af5CJY0bwM4NaYgZ9NPjnbnHudvo6OciuTmTMLZzTqxnA IaBHPV/Lr6/t/hv+N3+aH7Jd7S8I9c+r8WSr400ai3W8v4TppGg2hOXvQT19AN+O5ue7Vi97cPvy jxC1icJUK7DX4rSLtDDradLD7wgagWxGGccuQv6zmQxiszO36UQRJaPqIM66Ynbh92Xly4rCQ9wP TedbXoab75maaTtXkOb6hXRxhb86saSlHGsYfw5WXaxyHyEIE4vwVs9L2fioutD4ImxgsyrZq2fP WcOa8NtLPJ2vo7xmzeYdvx91TPxbtinDQGd31cG8n/PpDvJq2bEHWre1k8FHH5fq05NR/lfbqnvu q2mP3X13q/XWl9db03Q4V1dWfeGvtnG06Kc1Q45RkXjV2oKM0V7aN25S1UoLeDTi05GrOvwh7tIO dZPRtYpBfm7P61gqyI+j004lNViKMrDauL8270ixIV/axwKRiyxbo9lc7pP2nHuj5e+cdli+nJ7Y 8NG7o8/fLv37iPD60aU/bnWWqtI3itWpGb3edj2xer2dZrQjTUoLTfNN9L6z1lu3kSxZaJiz5UpH G/YZ80lC6vbcrrluBpynnE3Vn3lxbNI8Z7xNsVXXZStR6M+qouqqQlobXjxKPIxxe08TZKcatCFc LOC6kIO7XHtxqKrtqZVcSYvPaxpKtizxnTTFI1va6X0mY4FwvQ+boIN5BA6ANwQHEPNUQJ+gEkn1 tCYU/Z0U0kkPzHJ5qqoqqiqqqqiqjEVERERxqtcW2qkatWgriZedlxhkezYiTebGRWOkjY0OEhg5 sVqlTjNJbMdkreVlccUyYdpXjhKsFz2k4XT38+dLZlJy3log4WnGsPA3uuN91qHSppyO42k5I8He 5ufTJsqk5Suxt1VWIQixEZgqCeNjYIN9EjjMlKsqyqq6psyehStYRqkyUqyrKqrzSMJxGmYojlBB ycM2JwW1Sxwrkt1NbYunGbqrikg6KKqRRJQDnnpsc/I7hvHw7o+9fGZFvPW9jtbPnbToxy187scy /EeEeIrTRMd+kxnGEtaYJ+EklYVGMWZf88g1UxJm4PP8/jm1I23YHBAJ5VTfIX1qW/2z1CSV7M9O fXxuvU3rMq4eXaraWD5zEuMyXqfbPqDQUFFDQ+kO/1HXXx639Iyh6Lx6/bedS1vZgpCzrL5+H18n DXf9Hd/wuNTqHpU45fcXrYqmFYERCAigh5iMI/Bvxd689t9VjSHzcVoXBDQURUJJVRO7r9bsOojP Tz7iCaa9HLBHsrtk7XbzHwetCfwfbg/MxlIEpkywYTN+mao3MC2P1piv4C2HArDixoUqSMarmI/Q rH6mwykjYVYSUMDBMGhJvUqplIyJjRVfpyNlYWGMVcWBoxYxfwvbQeL4hA6/Zk7leL4TCZqxSLZC 1FUITkP7C0fqH8dFwNMwwcNawkEUY2FIMKQYUgwpChRgIX96FnKz8WVmPbiOeTWN8cC/8FlK5XOS nTh0xKVVW2tZBE9KWPk5TGl6c82WLp53zmybWGWTc0qm3BGpCd+Ih9M/0yJTgqTmKc6Eg+xHW72p 9t8DxLpasXiFY1eYfZWZc7h9AmGBs0uBN+32N0sinhOiMGCI8CJ5QwlCSUv+FWRBadUkfMhfLDD8 5ZdZrDcAieugfNo6E4JElkcw8Ds6CJEWO/2hC+1f4pQ1s+Rhl7Y6MRbExo85T80IHIspzJmHPnL8 VTnGx5Oim4cJTUt4gRMWuSUQwJYaAGHO1MsNNzOami42jgrRJK9CHaCiM+wsiC2vJ6XmGLIs40mj Con3fSfN3fL6/ldx/qp9A3y+xoX11t1HA2ENxHWdhlrjUjKB44yH28ITMYzOfr5tebH06fTjq5+v r14VXUJ4eu9s855yifBHgRiI+Hh9QmjB6j8JoiIB7k7hBkVUYUOp6bcd/briXWmanm4CDQ7l8Iwa +L4dVjDKAnYFJX0jBEQ7m80QPMxNdmq92vK6edavzYWZ1CTu9SveP9liIQD3hzQQZRE9wqCb9OWn blH8iU+Xv9/fbyZ30WGfHMJuUlovSP0WUMgn0ioerx00mA94mt6SRLCgJPv+6Q4R7fbJU47Skylf Pp02zx0ptFjY9GPVgxPiaMF9bDW9FnD2iaiDWix68OX1XGdr4u0+LoTs5Zyr7E+ucMOinwHq8893 rdEnHn9L2OY0OtZPQXt0YTZs7UzoHc+1o81Xzi9p/k8Scj9Rxq6+nEvac9ttTosyuDzFvMNyan8c 1x72X6G1DkfMeZWxiJEvXZwk+pvcGFYP4sMn7H3fjNmsFKow/tf5tYTam0RI2rg/R0+d14npz8nX iaK0tV2RcV7WWG558M1HvRUYmNprXZ928VvkbtEdJx6Np1Z9e9HBp3a4lZlWmuODguPPF8afbRwh 1n/I4ao+lI+VlUvMbHdjHl00ffwkcGxzkE7qiJvttqEcqjFiDh8mIYfAyrCsISWMWJdGGIfXfN43 sLxPs589c0Z/E4OI4KQ07kxDo/OVzp0Idy7jvTkD7N/Jy77W2+eYWHJed2DVHO1l0v9XXWMVe5F9 b0H9O77vNIHnVE8e3yodTvBqAmQTWbATQ3OOdWNSTBEoShylFpIzxOLmCHDo0fjcDVqCCDEHY7SX 9+QNO+eOEmapM09E4g/EGwsKIGoWbk2bTa2y0m6brbcW6aZb1sG0KMWInBLJkgc79JIk6zU9CGuu vuGIkacN+OLhw1qU1YYts2CD17nwL+g/n/MYUyosfMdNsn5dJJ7+bEPB8w8WnX0odSlpYjx0mzXt 7UkrBquG1SGTKqtlg1hlkVZ8GWjNMRlLMmXgwcW5peEeyq9fxPcrhzOXzC7TfsylUVYtVEpatsqF sdqT0OJ5enbn5RPNc4Oc2QSisqCDMlzqlSIkKOzIMNBxyFsRSk6m9R8oLD+b/6Vujc8kN/lGrk0I p/yEWZBaJPVP9M+csblCZfZQ+BR+bq5hMvftTqHFdlnV6ZMF8/LjU0slCzzspr1POHh0aI+AyDRI ciC/Fligp1zNx9LXESyHs1z74Pv37DAFuLjm+10JJ3qdZqApPghkmGEwhs94OcUJkHMK1Agw0AUC wyG4NyWHBDghuGiBNg+l5wlAH34fjvB8vAYVzrykcqYh7KauRqDqUIhqMpIebCiSAcYrBYIksgGQ Z5cnAmVcURu2JpKzW0wOLyY6Fpyblp45KXmyePNkO2a69zy4jMgDGKH/GwhNekHT6o5dHj6kqEBN eJv9zVO+p3FDX0xsYdeTodWuq1ouLlcWN+w4U+5m8ZV78KnKtPImy0wemO50B0DzpwPUd86u5XyV fiyXP4fEGAWUlAqHnSR4vgS0TyM7HfirD+k5Asf+E+ZCRpqMAn9y7VGOrBmaAZDVuC/fjVYo551H lrYTp/kJ2iarhT4GRZJkZkzJmTaP4OfrzLMioozj0vC+M/zQikUD9R+JTjMt1x+HEM0HsGHjKmw/ uMBOxazqtLl0Eif2Em8jpl8488bDhcrF9jyNddb+QYuaL6Qh2ZLy3zQ8OizgiIKop8IOuMpBETWT jpKOL2lTESTtRyJrdOJSchCVZRnUiETAIyIXrfLQSrTH9parpGZfIWREHgw90eCLIiIIskdGuj6O IAHHSaXWLExSw4TyMhtas5KUSp+6+B7CIgwiGRMEgY544R5n2KelLh6n7NH0ZZxhqrDDVwf5Nt7F hsi0qY5c/wexO+n344Mqfj2XZ4oaSbIsNhYHjL43Zhmxiy1XPucxxKFahiCIBdAhSQKZv+eWvjXH itqzGC9ixaveeyUrpprMAE5/noGgXRQGygVCAiZi0kiCACcDogxIOSRSUhWQSwiVbIkEsqqlIACk gQEBkkCxNRMKUtKWUKFDIUIkEh4gTMdkvJK4bN99XGHDw3N7OGtSlZZImqDl7Z0Yw591j5TOBrS7 Gc5x7LsaJMTOsxQUZyX8XTNf+8KWJyIU4DoQzgTXNs0DaCdPJIcEkCGW7IByf9cNYotyaMPNeKxM TEymKlmzyOVtXBVex2FcKzflmzxZauh0XT1jdchjczJhx4R7EfftmxzPgdUdyznMViy4vP8bSTSX YbPHW3c4Idz0y9fA72UeWlMf1+B7X8mHrT2aMpk9yjDYiuDm87McZ9GG6rUpFPt/Y+/0HRctcK5y WjDEJ8593E4P6O1uieFqpPNJXinDCMdWN+p5d/Yel9nyazokeEyNf2v0PSvU1Q0yJMPlCrEsISo5 bpIavOw4HmXD86pNFRqh86owVDCoqohhQwqpSQrCjBhRWGAYSpJVJGrD1MphC0MwpIjcyYVVVWit VJKqKoRlQwqlRDCmDCphMKiKpVJVSRhRFVGAn5SuqO2MmGV/XWODHD9SNVGFZPvf4CWR/G/8em6J +VKEUiVGEiGv4nAdcV4LxzMYdlbqyZfk4DVdJonn918mUzJl8P9Oifkz6Kt6sovvcn7GDTHxI2ZZ j/6exs/Ob5WMmypGGRNKTJUxFpof7Gzg2Ues2qq9fL8bneU6PtXITe3ZXyneadMOE45Ns2VplpR/ PJMIUQwokDq0UUFgLNjo9JisxpmTR3bEYREAEYaOz7tdwASbtjDeblJGDJVLXDXpMs3RuJLplAZN MCmwjSBIHHIyQzSaGCoxGE2wiyjFIgi1IWICgUzCSYhaIzwWyhsDQbJosMPB5DUpSy40aRY4VyG+ ryOTqaMJ3MPr/loIIgSCliVqAh+n/MDu+r6P0N/RtKw/uZqupKH5/6ofxvWVvH+/OP9WbZg1rl+4 0p12kulK42psxNsXamsZvHRYZjm+uiiznLRVI7aUoVGhOa5dESUzVtNWfP99YVK6tWeL1xekGIPG MZkDXaVzW0KeoISM0rK+267wlW9DfYkuyWSBe2JurQzGw85xtHfeMJwu76YssnjNiJS8WWrVumlY yfoeWtr0M2beSrpsyveD6NvW911rbleTcZoJnBMpPJSWNIO1bTmpWWDHHDZqWWs9eQTjCldTDYtR tdJfLTSV3efFKLfQzJwRE24lKdnaUNMVpdMX4uzY3V1jPNMY01wz232Y1rDUhKTa0xbbDDk8ShY1 a+dM5zTae08Vm9JK8rMQfOp5MT/dSgiId6MvinUFE/zDyCIKJFOyJ4Ie8N+/K4fp3PA7+XHPvN/j e3x+F2159uO0k/Giyf4or74p+CWQxUHyQRBBE70QON7XXny20jxF+RX0eVeXKOEzGEMXOaJpaUYA XcouO7XGlsfdXtZtnKT0hvC20lpHdpAckQPtQrfGmOKbTg0XZns/srglss7XcvblKUcaImiIohVT 3gnqTbXI4FUI8m041WvD6L+zBjlOXLnnFt+rOZvHUgICAW/4HTTWJRSU/M0bHaxD1VOpZWHdWEYA UEFB0ZWGH9oexRacVrYl25TtyJ8Vzu73drNZqwphpWtPmY5Rk3GKHcAIBI0im5ARCV+p/x7Nk7Ig 7E7Nsw989Ceh+t+d6jMVU+9MNlCiRDBwUf9AzgSQgjJNCSbkuCbn7397/Nz3ZyXFyWqYb4bNnlVi pviPOUvW+rNjaGDwwar4CT54+tN68piQ/OqZBy3X6XAmMXBSYMJVTLKJIypk1TWyVX4kVhIaTJFe AQ3ScnFU0cnJC8F52LTwOTtNuG3E+rdNlTJYqYql2MpoqYqlr734tvvfrYxhqv4jwdzZc5SYTYZe ebNLIr8/1P6uxVb6fN0CTcqUlj2UGCoWVPxjHctPa+PRpW4f1uBBav/NhKv92MxVe6yHtYaWJ52U 1sqaVP51TIbN1VhIjRhjnJvcplMPUxPVMoxY7fWzm5ZHRZRtZLWTJ+O57S/z7de8861o0v97ip4/ JIcVSfQ9UeLLjZ5NNS4B/Xav+ww3wxkx+N7UmrX6dbDZ+f/O9SRudV6cxYnxeDgnNEeZ1rivtmfa fyNTKxSgyBP9/tSh1E/sScw2OD6xk8cH8UP1CUNT2DFN1MO1hWKsMCsO+aphGUosjesDDRAlKGo/ MEkrJ+CTTIYmxAxUWxDcmjBQsJrUSZMFMqyVJqoxWKRuZ1uo0ME/xfsbJI/1VMVMVN3Jyaf7nla6 zLFi7Ow0f2t2xs9Kxi2GpzmhqamnHdNTabNSaIZDtundCErGK3RmBBP/VOSfYkn7vsYT3bken9fy hBxfswn6ptwEavGjz9mHQbphxWsPVHmZuaDCxHEqNLh+UaBszY/EYbSaJ3u/RbbMphhgkk0SYje3 MnpTQa4ns9fPv8zzOg4HEPx7MM2CXKYAjglQUkSRjCKqSMktSy1fm0yZpYlgg0uX2JujmWBOAsnG EFvZW5E6FbcHGMllW1ZTDwqT81uq6ZO78Xb26Z28b+LfJ2z099Tz3n5sTvc/SRqNMREtJamjZ1Mp 6JXZHLqPYU6pJ8Xp2JJk8Eip892qet0uImXqc0H0TwLRPIMi/qzNr2P9LFTmwn2HanQyvwtXOInR wc1Pm1NQV1xYOjw0zRO5+U4t/0pyGzxb0Tkqf1JT+TlDz1Np7as9vyA8tC4YpZgGMJ4WvFskMVXp OGd1T4fO2Q6vk5nh5TFS45EWAlGXw+AAgFQT6PuRM6D+E+9DU7xERPkMfRm8zA5HzOxHvzljK2WI ZQxLvxMst9ZzYQ2gEhgDAMwyGQkhaRVYjlKUsLDLYYODiNkWBKMJYUskjBcwogmFBGqIRFFsAbSJ UgosBEWGM2Jgw9BoxNBQ3JAwMKzhhJnDNyT8/z92NoTRUkVSlki6pGzfWizRGglR2GcWsxJNB0dH iPk6nY5xy4tlPBXnnb58nGnep1vj8ePd1P09ru7+DC0y+3IzGZKwLIShPQZoK4JZNWD+LK2qjEW2 QexMBBTPpl2F0l1RommSZpqaSd0GZDai1GUwCpJ5L9L5Msvu+rHH+qy0CT+dlYVoDCsFAtsqUZUk lRaGGMSWMySNpl9v85yHgR/NhrB5v6+pHa5PnkdzdNbEdNFpMUxUqmFgVhBVFIRZArCoKqJFCFGF YKFYSjAhUoyDbJUCJGREkiKkFWBWS0osLQpKkgsBZFhFiypKhBYQEGAoEWVNMNMg1jWK0pfHFaWL MvSv1Y5ly/bjXGp7tPXevQ9x3eJ2yH+MxTLBRmZGFrBdE08hyX3CMr8zKyYuA4pZKR7bEjE/3jSs YpBtBKkUlkhJbKx+uUzY/7mST1SEnPyFCIwWFDhTiHIPRrDFKBbhjYFY3VF7hAsr/NsSZ0BBgIzh JoLJmTUxDRR8k11B9E+n62dIG93diE9I1Gsji9jIRgWrarWnMtGQWAoLCIqCDBSKIsiDGKqyWWlU q2VaFWCt7uNSPc/R99zFz4JPVnMV7pRoSq7TILhTQdrB17Lhexz5VTrXdpmZzM04+j97cjSmEMT8 UZb8rP9li2Emck7M5hd4PUzzo6X7XyPymo1Hxch1FtTmhDgTt7TTkpgsEYnytEWTVKy+5EF8E3Wy k/uPyskewyqxoih3foE+MxIe9TxPpK/mfo/V8ZPvYir3KIU/SFy/MqloTQ1PUeUNmh8yo2JE6JSP n+35J9uuf6b1LmfX5N08nwp7CbUwp9b8brxE0PW7TZp212Kn2POqcFUs7F540jh4/HitT/F8NKdL hSVuxisYkZy9MeWZ/TxI2je0mFWDkm3PgSU3vuxx1Wmct5o8x9ZNqiHG97/uFz3BycKxjybtmbFZ vpVeVkwIuuq9iY0qNDhN25uNzX7SbkkM5VVVVVVVVFFVVVVVVUUVVVVVVVRRVVVVVVVFPt+m2EXC w4tKDCHwdswhiQYIQSphRtwxgCwiikhn7YM5gBzf7tTbWl0TnOZB4pGD2msnOPnjWPtqPnqMxY3t nBxsk/5YzI6nZmJjcfcRmvbRSIrAKNaMLbBSsLSSf4kkgTba1KMrF16uZnyYapjntejScsHCTTUc d/aX0aHp/IxI1ndywmVxVpbcbsg/64/s1uU/RZWCCAT28cY/olOQwtlH15Cw+rA27Q0ZQjqWVkAF 2Q+ZlAnf8czM1a1qfFtp65K/sY43Bwbj/Y2LaqVNoP+MkZiplupvpii5aJ6cMRloLJsZGR/1tltE RgJ/nKE5QUh4OCUkglEu1QwwChhJMP9RQMisNBaqqqr0WqhhgkoJ0IehgH+kgM4UVQ0PQcmHRo0G ikoholBBP9ZxJoAVWQK07KauEyliJRELT8sm1e90DBzdKQh3DzHeIxJGRn2RFIFKb0XBMTSGphTX R0Q6D70XtObl0euRfkyHsdi/FlKxZV+AmxE0iVbf9cD3emyE7g85U4+1YJ9f3j0eYYt46/VepPLU 89jDKYssWJmPIfSfGXWslSNtdG8hgyMWU9TW2ELGGww1ixa1rJVHJkxiopviSZU3i0uUMGg1iovs TCbUomPB68PsubJZiYWLZHf/qy6d//jlolmfF2Hl1JO2STI/OZRcXmmsmWJqPTkWnK/l/Tzn6Mlx Pk+HK0SxU2e21gk7lkidVttJjvYCRmxswtVjoYVPFh7WC3YMydciV/VKmRtyWlrLIx+mxaxTMozK syRjWcm5ttcKjcyVMMbfRvT5ExGJicfz6LttqrjbGxG1c1vmYPVuefyyuXn8x1SvqkHhiZmaM8kr KPpZLteVj34yENv6cjvKzxr0JxosWLXVaY3kzHjw7cEsqLplA0kT5IqnDIKFQkDQUgBZRmp8/+H4 XzL+g+/X1kyrCr5sI0ZQZX49VIfxYQ6ojRESx3HUXx/TV9fV5wBKKDDC2hWFfdNZl0I6mUFOJWbI 10qlwkvzwEPyL8E/yCwBSQhole72Gt7DpO+9lUrW9G6982GeodVHz3BsiPKpyzkn9AWrnBY+3NFA 6IjRLTa2md2NMmCKNmw6GdzVgcxuqZRJtdNf8pJja67YmeomB2SYnmRfJlPIeR5ibO+RdDAprdnN e7pW20vodWzb7SfuItk+VJi/3sXiiYvWaDVWJkJgozfQxjVqyTCypiYoEBgAwFVa2oSFEJIkgkFO 1U1IaLEzFTExMozFiYmFMYlYjGGJiaVNjZQ2TRGhMixrFZWGDVSaJhJmpGiGqzBNLBZNVWqLUZIZ LExNlTRWkYUYsJpU2JpNkzMdBg1GVWpC0JTJh6gep7kn9I3jWIbKG6KhbEqKeUrFtmEljFgnAyrh 6Wq+hpVLTWLwYzrquUxPzZ2x4oNLimd4yuM4BqamHQ4TUbznt8tLzj00j4q5HyOx8pdSfK6LZlSV KpZVSWxYoVVkolqKskqoVasUWJIVYlUqwqrIsjIMrCypjKZgzLMoWwsjuG72To9lYqSPy0SypE8S vf04FTdyHBNhU7Wk8s1v6+3s2oeecxM9DAcik7USyJsdLqkCHvoqsMSzCZ+ezUpE0xMTLLKyzMFW GAU/gYUjksXV1n5pm0k0u5k9ObsGtbq9ExHa6tFT4ksSKKEkaPzyYH0PhblWrLbSwh8hKIsIiQWA xIkUIwVZEFgKQSMjFiyDCCRUEVgKJICICyIoIisVFjIqwSMgsBIyEYCiGFS4MhTA/EgmLuaYnHiW MLF3+3yb6Hn1nb/ByqvCQynoXe2m0euk6pujnPDF/zyMxfqTOSksjBVgmFgUZIYSWyBqDMmUYm4a mYsylLdKnE8NKlOuQTdyt+7Vw4OzZx46q3cU0/DhnY8rW1aExixiw24K0ig32lkyQnbDjD6jkXyg 0bjChh82YosOTVUTBoNhAojz3ywmQcfUGtDIgQaCx0Xr7ajGGHe0tYaZhpLTr0u3K8hNGnf/FYRb JI8yK0pNCY4TdvukcqdNGQQXiMdIKBKjMiooud2Qioh/aTAmXTXwODTSw41pXO585hrywwvRDnMR N0EbLHW47W+8S8mytKsMkZYEzCwYSWqTymEI8PCLhBDkAOCcoGbnCFM0tmpq4aTT9kfubnvPFJyp OhRxFdTJscTLUqctm8SLEbMQNzeptMLcuJldyq7efeORxMcv0Y3TIlzNydLuiSfwtfvvT8f9Cfht y5+KfJ1v534Ti/DgYbctCfXbqno56qVdkhj18XpPLp7meT0+v+YevXPyevVP6/SjjmG71dqSdUJO xJJzavb9PZiU5b3j9Gq8PI9DyS8ofPUmxXcxrFuvmydz7j7FhA41YEWF4SyPGBkCJkMTJTExlWSv FZWNTKzc3JpH2Lufc3TJ1nY4NjgOB1G3x/B8ecxeSbKEqe4xEaV0jtMrFlYllZlZVZn1K93pvpeb 5Nv7Hs+H1t31+f4K916/EeXy+5jDFaTF5oymGKWLVTRkrQsmVXq2b7y5eazccWZjHohU7nz84lyW KZlMxTfI7OLN9dd2njzHyLeSpx46xxXaJk+eNh97ZqeRpGpFycDB5PN4vxa30u6Oz0c/FzQQczt6 sIdbLbTRN6HyvAjxfs9Seno4HCnsGl5nkefqanFwS1hmKjgPevm7oQkSMIvPjlaQ4Igm3fyDOPEC qIelI1PeCaifzfQ/AU9zxIiJRXAQLKL893DQE2RNSbKLCxa0zWi0YtCxGNHoCJmjQI2g2wtvGGYX eUBJQA9jEkLA2FhgwNFAR44MkJuCarZPuQKbBDkIwyI0bBTpAqmQJjRMGNZqc04HLebqWTcWhs5K bJYYwWJt4Sbgwm92wiURSCdFqMELaGkOEMi8AhQhBMdatDRUT3sssJuYaOcVN0uZuVWGdDOhpjSp 0YYWfQwbm3IhuiKlIqVLCyUxDEi44Ap4GEFsmKsTBRxrOHDixtxrhOZqtTQoZAzkRBZFg4RZBFRS QRmMkE8TUvVtsbZxuc/wTbT5nMJlPe49cIOh5vZl81gHz6fB6fh4/B4SI6EkeEx39TKoz4MqryNE YTePOLNharj4Cb+kz1b8JcY3G/2OeLdHCVxuc0c9q3GXrNA0czoMgzG4jOIpmR+UYPhR2e6T56Hb uOlT/M7BbNes6/+PughqeZ/v9Tt4PUOdVup57++GXncNAt086x2jt9LEytnRrcUybmNSUSpVrqcp /UO2eZqx8Hx4SBPJDXos2HuZD1J9tzhkk07BhUS2EYlTsUzY0WSp5zLGDVllI3RWDN5S4G7UXjqg jgOwV2G3QzouHTgnUavtx4ZiDecxLpMj3GjLuN2sOBqEpNmzHkyakGJ4AwyYhssJJCiuWgWIBt5S VgaNFAvZSjpBD3P+h6inYapvKIhU5jDe6uGJlbjGHBuNHxtFWa1FoI3lkkgeJKzLlrSpwYbGCrvw psTYtzY0Wq76lsvL5kBezDMWZ7ua8KuEsBryVEEoipBRgsysIfUmwa85iV+NS1gsf0BExVtXPf58 OWx7M6+1OE4ML0ZrJKub0aqi0Ehp8HhcHDh1GNrO8pToTWWh1LS6cW7ifN3bKnFk7fWqvR3NrX4n Kd22+UYJvR+0lUwom4YPSoZQ5mXkMMNncJNWqYTB6TCrImjbxR3GFOi8zTZbnA//ljy+sg3FMJhR fy/pQaHcK7k6KbO66I4MPuwrGzCKqqkYFRhWqYGFiz9SZ2h1jSplFcmJNRsdAe5yHnz5O/XtZiaQ qynboa4QeyLEtVXt0GictzLCMySWL6WC4mHylP4JWhfd3GHpPe+d/oqT17cGuZ/DDS9hwqT2PW2+ TG9U4rmuUy5HtLrNmljFXoaNGMY1T6/X9P27kD7Mk5zVwNUOEzaH+r3fjba4mGOteCsTIxObX9GN WZz53Xa8AXiov95wjpeA89qwy8KPy/v+v6sflw5XhyUWyzCEQytKBSkI4WUiggsMEpBQSBEEMwyB gLIqgLDBhLGiYw2S3aXw2aqVQ4MW32+VcDZK0RRLCtpbbbaqsCGJHxjFwxVHPjoThMNDJxyiazhj h+1aNCyG1ksXuT71I64veN+seXzet9KD2Go1VZU0djVt6ewx+AX2mRycx7Cij+420li3d7v7v/4N NIj4vJmPXFkniO3CrG0leH9ho8sGk71dByX0TC4SQwzh6jcpe5zLXbpLzHHk+nF6jtc+Zy4T/E2C TXRf0ZMpLJkovgsgIwgCP7P2h0L/BvFyFxZWMYyBjEZYqYWKVlnNaQ7IttjbvyXb4qnQH5Oz9vJN TMzMzIDBpeyqkcP6n/ncNJQklCSUJv9F3Fttw224bbcDBhgUCBAj3hEAwPzjCiP0GTnchDjZYw4a ShJKEkoTe93Fttw224bbYgJPZ69oAPaEkfV4PARBC/BSyn92MIYuLE8bzk+/1ec8xfRK9CqIB9R7 fm91Guo/6Vq6OcIiRJJzirN0m6qhT3ykOkhmGTEqhNMkVDtNFxCkVstwxoDKi+NOaTTxOWlLspCq aioKhoOxZ30zGDaUVVm2krLESfHOxicVcWqAxxrYxq/LB/RP1fR6Nd2V6fG6iTxkTsHj8cJJ3WLZ VcLJZlXnZKepwNt9Gys6Il1MqsXz3Q0bguXOKOJiHJzuBcXhrg46sZOTRsUyW1ora4G+yW02aKSJ jxmpkql8dmAU0twJtjIaZFCHAQQwmophojY5KjYEa7/kYWjrvhE5uaSHIrlUv3yb/v3M2s5y2OoU 4MLgU9DyeISQ3Er8ZCW2S1bCW2TyhWMI/i9f6PG+5Jj9u7vdI7FHM7UaTl4vIfONz5piU+aV43+j Bo8Eng9ibx+ZX9BhhHW+s+t9rdXo09BSfKbr35fBbN7jVO5LCbG9ab0kT5TKrMxmMT1lY1NkFwYU /LJzvsEOKp2P7GhpIedT0a9DxWScuDb5YyaMp3WlUUqKhWyPyJsN4L+4Yv0n629bGGLH56Fh6c7v D+jfZFe3FXwBx8PajS0w9o/Cpa55oXHkG639WHdNg1h8zVU7kHWuhme291Rfxvxug5jf6/wP0inN j3k8MwySbyUSdJlaIWnbQYq0MUQiyMEggyLGAoKgeqKBXCNLSAjBEET2QlqCrIwYpbbjGKimJiny fOcWVKiyEqiLJwKmqinQMN+nC4YxPDjoJ9cRsfAnf0+D2TSamLNTX0amt8Wc3ndx2ZKq8xjLOOLm MEveTRKlSpQ56k0VxlYLvW4ZfU7HVpo3Ouy0LUdmITK9hOusrr8nK8i8OOnNlvQfOO26Lluqcr2N NVczJN/LyHB1T0uN+fgavAYH2qNk44eB8rcyaYUtSdWD04vYk0P4dR0b+d8yYPgYMGCsqwVGGEp5 VR4DQUeeIJh8SnpFOs1RhMtky+gxXE85+bz816DsGjyJU+wWKnnf1+pL05Xv9Jzew7z0OMvmSPi+ H4h1n1sf1+yHXZH3CeR+xUyjqYZViMMGDKq8qnUAaI0hsk0MUtkPEfF51W3BjD/bjFuxqnxp0PKL DhHXYfDEGMWW2Q8hYqW222JSoVLEqlhS8Ey1PA41bGUZj6jDkPK9bFNCphVUK0PG0kjMKkUqUeNH 3NONvpYNHCt6ZitjE4ZcFcFR+EIYV1OW9FT39ZnSx/wyZZmG8cFwWl1xzWcjT2pnU4KkhNNXJ7ms ivMPDlOn36GWXfbcY8T4uNPF6b5Jxa1OnBXicn0Oq4SPv9hx/Nu1dqx3TIehcuX+jdLtqMkriqrB 1HwL5D7V9Oxsdp6+87QOYxN9HYVu72T8SZYrJgqqqVFSqpVSnmyzlUzGDEKVFLJIqkqyQqlUipaM lEkPvZgpaMlpZEhQYYIBQSRIkDElMKFLSzDGn+FNaF0fquI4ooISlokSEKB8TNnJTJ+uUNk7Kloz 2mVoI5pYm7BjYaIyQfTU62UNiFDcNmU7mguikmBok4Myb1+WcDoBRGT/nBpJw3jZrAUkjKSKkjSJ KrgYrLEaKmmTLJmrEJT1ZLxbNs3W5EqWjUHVIGtTQhhoZIXi7MLKS7mBTEsgbHS4WHDTgDRgzASS QnFmsNMJIIjNaGXDO01rC4TKwIHJbgShsJsQwxDRNamCa0SFsISMg0TCfwQDTIqxI6LRJmB7TjfB rgwyFAuZmFwobNOrmubm6GxMkFk2wxFgpF0GqZaDqmMizEW6CguSYqIoJogLhP7jgN70ytLQzAsB Nh/0mZssPzz9hMGyirJhgrGDGGWv3K5NHbkw3WJIHTiertNs35vCmMkDkQ/3mEkP0fl/Dxo4uojo sRaWmLRQwxUmE1homFYKupppja0VN2l5cVphmTMXZjQcfsTVajA7o3rJkwyy0RkZKjJNJFXSx1Vj TFr+LBavLZrDH0BDlOvat10NezOxr8XdcAh+p+Z+66VP7v2dr9/s+x3d3ufUJ66rsYDL18fS7J21 isPJk3KbixqLEVuTGjKJiQz2JsklEmiGqbDMGKIGQpYIDIokySaDDQJEUYKcoyEg0BG6ZbI+cNA0 aG9CtA0DjrNFhsYYPEsMl8KxCyZT37bVob/5aMxNDkYxMOR7Jw5XWcm1x1LeYwfkQdVTv7532Kuz /jt8m/l8AdPjUjqp5xc4bn1h0/LJRwExITUNYTCyKKRJ9lvwqi5iyS8xP5uGNjnk2rzu4tn0Toac R2cqPCaFwMnBiW+UYxNDKyEokHLJMStcGSpJDERKZCG2tlOBtUjTafFW0i2bKuGUv7LDJE2YtWi0 tSVNCaqSxoaSX4ssNOfLYTmsNxRijmWKjJSzEsVbSUqxFsFWLVikqqpYskikpUqFVKSd+/CAfz/h wRk2cbIH3odDBZXMKuAWlLSqjCxjGJGFQNUh+QQV9q/rebDZi9plfmmU5rsDDsVS6mNaQd8gZsZm ZYNl/Q3VE25TlMmTQdT8pIvyfYH66VIUkqgSVIUklkwAoP6MGXCw+9Sqeyv4O1o4tG4ynxZ/nkp4 YPty9XI9EV5awSYYsFU+MyvDNmIzTHp+JhIju0JgoFqVQLSCqkWhPwdrBJkX1ThQjCrVfXMkm0Mk 7Mr8T+TlV2jn85xvmY+bFQUtSGnZCSQPsB8f5dk1wmrIS2B6nSYZjiP3bQkZoqi2RItQLbZTlmGL RS1xqr2PlbzgZV3tZVmKVJj/0k/6ea29P7to9CIoOY3/ZlgONlvJ7P5A8zE64j/2ajS9ArVuy9Ot Hebyj9px3PpqYyhn5nvJ+jwN3wMPryuWBOVUskeSryDlsxn5g95WlchcQepUltq2WyFUG+kmCopR +ZLOCUzGxjmKWCSnrDwT832D5Oj4Ol9+7yJzTzjzC9WnDGUwWqLVqqtFlZiwaUysT4A6RiSYDgWi zJsytbtDiZVzTca5t2+cpunHJYFUn24amVmcpwR+jJbbNMoIh1mQMRGpCjBkkhGRViwEQRrArUDr CxQFgVBZRBxsCsCwQjBIEYMYMJJiLLEqSBwBLDWViqCIaA/KFhMNyaQKGWbE80/ZhmtzZNkppUqW HExRlYa2laOVdOQcsri4a40sq0cz5nvejLKp9p54xukN0MFjZ+7hq06GeX0SaqJVIrnqqlsm1SIP URGWZLTupTfssT93GcOrkOnyjUU/VzXaw7RX3OZ71e3ZqN5jEeH6P92rBkwo/RyPEV6Ocub51vrD 3/zKiafE+Efb5LTHVhCh/gT/gMSmmBERRGMRiIoKrBQRkWOUqNpUWtRQLDR+9Ewqqam74Pfma3Nj DWFilRuTfNGfoUlNMlntg0iyVMXnqkZKneaKYaIaODibC3RwVVrVvG60uMclpuuZbzNV6MWYMxZi 21ExGUf8qY58LzcJpzGpyTXRCdEFpMMvXv2nIrDExpYjkrk7M1uadBoOb6j9ptsdm+kDNCoJyHOP EyFo7CyCM2CYPR3ySQyQ+Hk6KSgR8JPNQ6HFz35Jif7zsaOisb6Gmn+DsNNHNB3aYUoDMkSY+ePY 4A1EcYTycDczqZJjW7v9eboMtyatyF3FhKWLUSrvxjF4RY4bORsmkMpYzs6XaiJPAH0nzYiKLFFU BQIjFEYxYiLBiqKKQMhCTsmzQkSMGKlSlMR2dTjz1o1OLH7+vmndbVlWxBjLigk4uPEyI9xltdFY 1b0aiVHMZbmX8ySEajT+H6b9P5P4ev8OCb9vbu73fZ0zpR113Hk8F8c3WE+N5f0n7H7nGepw5eeN JMGhz81fs/26D/swt7I5/+ewnllX7Mv1qnkfkMRiwxWkU3C+/Bxl9noOPJj8zLtfXiTVyL2JsY/8 WjwS+RxMl6vmOkND0aE+DF66mFoxZmsNNaWmtNTRNKg8i2mys2TWRq/782dRbq5d9qLuWFeXwXrU 2Dl+F4VHkHxWDLJRZDuXx28WX4qodl3g8+Kskwj/wDIhqlzHjsNj8/N+AR83xpIzSWyXtR4EfC+m lsVOQdohw7/NZZEOmglolWInTSYsFpg7Hoc6VT9ipxc9G7uHRE3sHJ0JzUfVh0OnQ+QrjhpJipmR c4271Exv0K8j21iaUrirg7WjMayNMY6WhdWU73AHvwbmKdgxXPFVRpFW36U9Ctyy0nSpGFhVC1Vk tjJWFVQqoFL8VTEKjdr/u2mrI77wVgxq4ZJGDMy7sncVJhZJGeEwuMMFTNG1ROYseCp71xmq44G+ OmDaR1d/OdmF3sTsRsQ/vrSQYX/sEKDbw4MIjCKKKmJiTD9SF2SQsKgLNAk8FJJCdeXe54dIrqMZ ZDEyDMhlLCXcZUms4TsZlg51dVP48XkN5xU/s51pmdxPDJGMTBlO8W5i3aWSFEqJZaSUktj5e15V K9nVHV7WFwovd79HYYotsq02TNJNa1GkUmKfeSkqKMdW6TdUU88Za+lGN2hqFF1B9HHhD8QPveqv 5/M1k7J7+ovubdr3DVaFT+RzOmHLE6Vesl8vd+79xxe2zIbTFUtdmlrFMsRrI/2My0Csgqw9mFEK wCxWIyLpL6l0z2hrgckkAWTAolCuiwsBnDKIsKn5OBu0lElIzhCwYIyCqLCTaSkZxZZM6h9wZyBN H+/wH1EfpcE4T0GianItahDTqvLYmKv1GVYGLI5j9OqW1JmUcX26M5I28sxhSOtCWkpIgxkQEZAC toxkZVmj6E4N6nO/nw1xe5D2ZTrL/jkK5riY4sK0Osw7qjR7cJs5svrfEmp0+g3hfHS4HHUzK3Yo aZK4Xflra4TXYq5kd+HmfQx2tu8X40PiavxPgVX5VMvIatynWe5POo2b3M3an+xSSaNXW7Z6r1VM +RhouS2OR92jah8sh3VczKfImGm4+RtwdMjKr/JcJ+FYvy2Q7r0DfdZAbtJPxj+2Zz1HpN0QnV+X CHppJ8VM1KtkfvRJ25du+TNnmk0q0mFYWVYXhwExNZOkrsc/5/+0/OCJJ+c/Sb/adUf3FmMVSfot CtZGtjW1ILKlIytYBRPSH7g+TH+MkINnplkVReEkO30La6Dmn5ZQnBo1my/B2ujOkRrmNqmFpcfA ZjxkX8587Ej4x8y3VNj2Seg9suuLF8c0eDDViu71Onh4WrI54vZofuG7ic2ljPBGiZWQjrIvta2q Wpaq6Zs5duETks29DDNkkMg9HLftJ1Pl+1q/HffDcdMiT+bvYV8ydLv9xPLmZFtcz7PxKj3DiORl e9Gq6nlxMp494ZOUVSKTQpxNPMyxrN4xo0Kcx2mwk5Nj47OKb00MzqycmrkVXQhKDmMsPxSeVhxV Ey4q/1K50Wxq5O5hpXYbuTWu1t0MU7ERyajRZJirvMtYt+RxMffhzY68jnqUUVua73T5yLNGBjmd RikZjeixmo7EYwwjbM0Y48mm4atRgRiagIiFP4YPUEBiwB4uA5Y7a6fl/Z6ftQ/kgn2GtKLx9z/j /102etYYMGHimjBU//ZyU9iSV7EuDZKmoZIsnE6rfzZWJcVhKw0LI+nC0tK8UaQgmkh1Zwjma2TK 6Dam+zgJLbZxTjOGkmPYe4t/xU76fJD5tW7+v899tR/HOyf65cp412IWb7J/DH+QQ+810edjGMER ERERUREVURfa1URVqv2c39+Np8fl5uzSSPlT4UGHXGmyGampzA2bMeiaT4zEWTgn6n9Zxdlfn9JV X9PnHMVUqSpXOin1+JyV6E+Q2R6z5TBF5OLKqqqSpKpiJ0RviyPN8nx/wZjyqjkXklyZBiOYxpEx GszGZMxpMTE0mKm6qHaYr0n1VX9OLxXSfu+RVYMDGYrKzCPOW3m+xs6qjeJpONnqsJ0xYsXs6Dc3 j/gQsI6JmgxJiNla05CabVVg83GXfteVtHJs4V3ryvuT18ObuKnv65mZmT4d6uc5C6J5krsvX40V NyeDtTl5q7fdHZ9bufb+JwHNY4KstnSZ9KM+ZDJ2OvC9RhVUjVMSTJYfM4EwsSLO+46x3Nam61fl 0dpYtrDMqnsXmecnx8BDyf10pHkjn+3WtchseDk7MVdqV9Pw9w8B0VNc4GJIaD4JIdGFgRPXEtdt bfEOSq9CvlYZTDR7FN9OojoP7TvVoPfIk+ZtX1n4yU7WieclHiYO1mSTNtUJcudsdplKwwwyyy0j Yd8TmeHEw7VVO8rpU7TDRK0jRMvQ8zdbX0MOd87V65dqryn/fTd4TB936mkEnDvwfZzjlnmqRs9b mavUrCmWBwIc0kHD/AHCyQNICihyyzCAoocatWrLcINyTEWT4tMHH6PP5fWl+SjLInEHyJzeduo3 MrGSMIwmJum7h4+k945Kmw/Z13H/DE0ubsFTy8IiNZN8Wq1iYktjVU+wl3fSaNq0qVWVHc8Xj69u N4cCZkkkew+XxN3xaYh1HZlaYVcsfUPE759XEf+Ep0nKfvskdkbUvXhEn0J9Xz5+Q7nudbgZZZdC PO5FdbKz1tr9STed3nel2BB+aT282/r49CTbX0fd1Isn9XBM+wLfmiCfxPEgYTxfx9ICfeUYT9Jo fMUR4BW2iIInqOA5piZSqaEfqA+Ej5IR6pZT1CgiMiLIrGJ531Pj+RmRZUkyqxS3PgpG3q2RJ+Tz HPz+ZvSeT4Pc+Fvap1+xVYbXTNqVomYS/4tbIk+6JChSwpDRh7kMMENEkhK0shwKCsgONBFgxxOc aJVExNGDJiMACpvugtF6tkinC0UoiREKM6I3g9SmzUUUhFTTZKAno4gGmSoommoZTHJKXMhcVbO5 Dvcma3ApEUYmdmGiqJRbGiogsFVZhhpw0MYCI6BEURIaA1opobCjlkoK4NKwKKyGMKaoVIgzV1ga iYGFDWFmBaRREWMEGMEBZGERZMtBVVK0QWAosRiCKDBYUbC2k1bEcslZKksWIn/q6PacSKb4rJi4 V45LSyZZZUhyhLLYSEhLC7MDANhqqVD1Motm5srBh+h8nybW6xB6FniJYzxxcYjTNZR2MIYTK2rJ VllTVllgAZB/U4AhA1IUoS2rpgsVAy0GkHvxGB7TKmhixZBgsBSowok8NJvK+H4ed6zx6xg5vhHm aWGL6uirrzcFD6NO37ny7y7Hzex3zuQ/p+rYsqpCtywoiNCwkJYJA+1YktGNjJJW8LbYmQawzGKy xMzGBbi1Fjc1Kb5WYzFjFHpm5b0bluK2RrQrhgN5KsCbqxK0MbU0LU4mx6PYylV+AWRuk0/ln1R9 PKCDiH9rkbbQzo07pq9mruutxwf6TVcWU91jm4/WplknlLNqucEicFwZm0ydUlTSjRi0b/w05GYv rQ92hxn4b5OnqX33d9JuWFiMMSwok70enBZhfPvJTcnhWCGqSUsktVQtSPdYwkpUU5sJit2Bm5Sy J7D7lfqZhoFIApFJPoawOXTyqOUpiFwEVZJAOw06KDHAy2ZK2WtolYjUNFqxgY5gFZg2WlRYUcKV ykUdFbo0yl1bbGt0lw0UozSaNMrdCRHASY3KJEP4miomAQZ4k/zIKooAv87JWsqEUD31Do5hA+XU JUvXXX3fctjD86XuqfRibx5R2Ht2e/44kajST+KlVaMVbDkkdM5z5t0R4s2xeRlJfD15LFMzWlph lK4KqjEIH90MOvtUPgiGQ6WoGjTrqb2mwsuGyrHMqXcXRCdUWqbJQFhBqD4RE2WPpqh4el8Wss2i 1F/4NkScP0605d8/tbPHEu/VK7/FynCrhO/UeHre3nuH8Kl7r4Vpuw71SvFeQybSK9tkNydlHO4t WqYtK0EPiU9B5eU+/HXKmeTWf8T/QdE7TPRwJgoqGIM2kIVYQTOgIcg34FVNWck449tTULzE2yML KpirSJzVg/B/mzPL0/ty8isX+2j+Q5+k5D50Wepex6cdfRIaep5I8/7pf2VrPlnlEjoRYGarBpil +ttTz3nzN+37Pxc95yqZ5J9Xwtyh6MSR5knf5WT76jRptOL1MMFlSpRdVwuZAvKItfkInCajlocw 8jdwJbtcF1pjLDFSeyyRtSUhJqzlBBukimVfOYK+N2o+xvcN6LHVyQffIXTTLPNbaiyW1tE/Hrzq T4ujdEqhJd0k6dWj85rmK6MOuIk/g8zD+9hgeuVbdgP4fNIxDRTZXv4nNNTaRWNK0JSiqVyqRTVO Dk3JVbG02XzfuZiOjg4GzCbhgcjqjcVZFuTAfmfLhoJIUiIKIfUyHI4qUpDhAshvQ3z11mMmM9R4 F7St21TpYkrjg10PlUX6GKrmPd7lxHbN3z9KfI5FJzDpqadPy4lp9z8XsSGrk7ZDaNl6HZJDYHgC hvIqO/vhkZOxDB5P0aH+UXlwdYtubDnoNOGKxtqj/MmEEIIEKKkETN4GKTGFBkZFiREJRoyIIYgl CoUoWDUwlpFyXLmxGEUioyxJHUVJqRAQRYgk0qsBEoyT7bkgHRyaINyptQlwgaWDIMCkPUCw52wh KJJUQElSgtCkhhiLKplVwytpbRNay5mwnK2m+coy3+l9VlcWGSLkzKeQY1Mr1z5tr7Mua9xYKfK/ oci7aXY76nGPVl7gy78YAwQyOANMMMTIZMDBwWramYJMwwGFShjcpcP+7gYmikmiSpUWs2IpRhPz adg9StmPqMu7q/gsbM8f0Uf+El4l3fXqSmFaBiUe5LROhKXpS1F8GCRabJdbzMx+Tjqy3OCa3pum 33czWiTaS5KZ011VZFKM/h4RLg7HkwQNsangcN+lq9PlZcZbOXQR+8Tgk5Mmw0Wwq0uQgkOq24RI CyxQlbXVShB0NgAUKA8Gx3JuRv2JPfmdHRDdZHVZy1c2bZJqxzZm27Glvr5trvsJ4hnozl354a7I 7lqu4rmAnMmmdVyJ/4AwPCBqKDKZZoiMrCmhJxji/Tlll4wUpg7Sd5MQfgq1VSdp2xnGs+AaJM/m ntF78lTwLlSZnkMJk5H9bKawV+/Ee+po+9TSBXk33sCG77QhOI+XAdVxKGckN+5w/XZ6BG9TPWSC xm1Ftb3ERC44qAYqynB4qwaGwTEHKg1Nc/76zjbvr3kZxzRlbGA4preK1i63OHF+AkrXQkiphjlY UEuUfOZfQTPUJACMOCZ1UhBqs5ZY4WUbTZXbmNCdzRSamykItqcAITQcIhNpZccu7MoDqG6HQJ1d qyFw90+kFH804RrUTLDolpTg2qFKKP7CD0lzh+FZl+RpIw7aB+XHYZHKSxkQaWpGS7TV1xMffnfn XFKd26V85E1TZ19r6el77Li+x2ZQ2Gjc1ST3IIOtB1dTyGDqjFmxdLrXaRyYImOKxbW0lxH1kCdK olFggecIyxz1PYhW7H4GBN/cV++mr5+yOnxGRdkfBQGZj+uillSqCShQlNVOqhI99VCsMCw6uihx QebtjIiZPEvMeTuPksE1EEKj4+JIl+KYD8ld48dM8PKcMO0Rh7SSGFx4PFJKhrsTrMBOPOoGdwqj G877Ohm97ZWaZ0HxZ4tl+Ypu3u1hOaV3Ohiu5J4xXLg6FVlxTsO2IoyapI8zVidfZhvyw2MGE70Y hq0Lzl97FzLg1c3Y8jyPUvF+3nO9VLymjsuV5uPFMqOoqdbvZR2mrxcerq0alaR2VERRuZoVjMou kU0jGkmkdEV3wMyyVZtJmId0R3aBTD9F7RwOuBZka3qfrETqH+QAigiIfmmGCsmApVSVUng+rpX1 d/S/iSEw091eNB7FHlYiwwjPFpOtsmQiMIMIMIwISDmHBNFu017c+o7CpjAtug+hR9o1SfzeRDfg 4sDg37vEzLkHsyvqcDjV+zpsquVwU9n1fx2NTWNiYOsBREyRUEwZMmjuNpiZVmydtbTdqNTZbBgU fCK7iIiDR6VfYHMzvtS0XSuZxl3l1ns8uc1vcWWtTukN8keM+Jvs1xb3LireZTRopwMqcHzXMZe1 xcnI4m9aTT+f3dGw3MXvtOltaAZNWobuZaaIR4so5dydJ4Hq8Bqefwanp6H9bcT9HiOQ5R5fL+d/ J/LXgfb9fU6XUc6cvD8iZOlJFe3VyT2Htb54a6+zS73JVNUDeqpoweMjUw0Poe3GOM4LTZ5JrTqg 4OacXNU+y6ZWLl8p3uanN8q5qpd7PEdjYKYnIKcYc9mMnNUxFDLSlrE0smigGGkFKaQNE93wv6jM G5i2q0DCsqyqKwVzRskkZdiI56bg8yNhWRb7wXb3zmWyNTmqmy3Qm9bFU9Z5XUvFPjOfQqOJ82Oz eMsf6zDd5K56DhX3Tx/yPyo/Q/c9P2O85l7eYnwE52GaNU5jyJNX7GppWTtqL8ZfL5uB7JK6voaJ /J1+R8Gp8yW2TMpMyL2sr5aKxGBO/3G7eyuHDNlTTYiZtw9sv6j2pWHIS888LHc1ri3ANAi9NE4F 1vXMISOGbk5QKsTB0WuYoQXFHlOE0TVilksKDFAinRSGKCoja2ltqSUsClgUolKJUsWrYKRRYUop MbJhUFiSZKnmSJmLSi2lLFixZmeU+R4Gl3Mj15X9GJax1ZHd1962VT02KnR+IaP/0YC9Thqqj4q4 jUocVpocVZQ/11iysRsy53WuuzEPbWXfiRqitTvwHf2p0KlbTZHXU2jzHcme8ipp8COiTk+fHR0p 5N5KstW04LJ94dmfnIBSKVUFJRkRBUXMy0KxlFlNZkWC3X8FimYaJOwKcw/UlhFFgZBkB7HY+PGT WZqpTPVVtoKuoVU31IyR6yQ8H84V6BJ9B7SjCx00yojxor9xQ/Ogs9f9fVJOs6zh1nxv8Ejz++eD ZeFD1JHiZ5X1PK2dRkVskU6m9VmxG6e5qlcX4jCtJvFGpoqI2yegIMzipP5yKPr/Fg9dcBXMr5Qw wp6FaDl8RqehKjpV2ykP9ftXyO7R0gvNh9jOXSuUuG3FVmNoLjUNobGB3OEjP3FL+YpJZ+9ghBcL iV6Zd77ni8rguPIuaumtLWU0xGRZBkyu1ruzKyd95HvTbjw8NSJdNIPhx+rmwuceK79Mex+TfEH4 Okh0Uc6jFZmFYLJDGU5JzTpJ6HyseuIfsZAf4CdJxJ/L99wXqb9i12z3lt5UlHMk+jzmisZHgPns 7XeOPmFXrjcEHT9PN4emdMmcvFmaRWh/Uw9uZbh8sfLiqqyUqfzmDFVDxJxjD9eXkRpp7kp5k9Pl NHnm9L1MYLKc/QfUDaaps1CaqtWFn+ZUYhZ3Q6cjMmT4TB3KEeSL1En46DCOmKFWHW5+O4aeHDl1 RroJqKJR6PSZVhTCsKYVhTCsYEyN4O7E969sVr3yYwhF8iqxVdk8TJwmJtlWZMvUu56mMGObfNno btjKGw+boqmFTCpuOajSpipipiKxFiYYNBg+2yqWy0IqrJbaWRbYCgxjFkUGMGIKoBEkh9gkmxU0 VNFT+/+F5T6DFmetFliiDFiCsVAGMEZFQKUkoomjWqrWRiYaTQaLwwbDzzVWKGiH/FJJmBt9yKYE ymSSVhntkIrxyirGmiOGHZ2nHghsd+GxZzbzZy1uASH8pBAk6BDmaIqgUf484ZprSgACLDQ4bgNF KMPKRkECwQMjAGx0aEnEo7MIIYVAxcu7q6EQM4TeR2lxAYbl1tQoQLyEETApQMEIdEKQyB0ygGAk Oc5aW22SMlGawSUwwYsWQsWKLGUampizKsysrU1TSamppMkygMVSBwbJTTpQVOEtS2wqvCBcXBg0 ksMG9KpwRiqxko5G2lW6MmhUyHFGTTLisrR7+VKUmwcpTudxtHnOXFfQ5J6PS4NYrnalKUmJPEWT tlQ8jysGZ2pWeOrRin52GDJezfwVKeTzaxJK/4NdzEsDCqxGJhbcB4V4btl074kZPDnUrfBs4JKJ u21kZSTEs8bZrIDOsdcVHFlrqMyJRn0QQ4RxsrL16mmUxlZMqyZMmmoasmTBjJkyryNTUyZ5cmpl WWLFirLFixYaJLH6BycfDn8T0N2533hxvCHMuNhZ49vj9e5wHaVX0NBU8qHlamBXawMmx0tRzOHL K7GCeKn7DLC+Lgv3n4hzgHYfR+aP2EuNUkZCE7EGrx7mNNV7BvTrO5g285UldxOllG1HixPlR5us /e3OwrO1DiednRN+MWR0kWdt/yJyxVK9Bg7EYJ/Q7vBqjm4uzowSTiD2J+Dxngp3Pg15I8P2x5D0 r0ur4hjFXeVzOCpqLaYYsV5qjRX1KcL457Z9XoOa98w+aYtLMKWmIqck2G6T00ZDR+b3QkP3wr3i po0qelX6h/Evre5nuX0u9n9Hd87ZwBxxN+yMP9xEUI/wvxZJQwe1YryMlyR3z8JSlOPpRmj7HqkA mDEWPNEalRWwj6VRBEQ+wUToJSbNUwRaVEqiVU3U/kS3bk79GjfbV5GXdhtTJWmmkmMUY8DVJlhw VmlTKFcdoiuGRU1sdhsKtMFR0jhZlODN0buB57rWUh92pNCwWm8aA/MkCMiRDhVZ3dVEyRRKgRMz 0nOZu8Sw3BQ1W3jkM/dZSvCyXS/ZJNwvSBAX6aFs3DpPLtiECByNKIibDd8/Iu9feeB4PbWDwp8e T5PuREOP1LPWIZxAVDH4o/gyvpDl+IUfEaUw7LcCZeuNd6Cg3AsIBBZZmyyCUIXqDyxQGXAlKR1C AOXC45MUSgmtxC48fsuEjHwe5BC3JdDfXYTMfZ8XZ9fHvgUKgAZpfjihe/A1T8D6++JGqY8zm/tX izuPbLF9rWPGrd4aox1hq67Bms+gYGMDA+CyG630m/Twb8k4J1RpxSzzmI9553pMwzFnwizgNpn2 +IK22somKxyoENOunITRML95Pohd/EchX+fhxKRlNGeHqSLJIbjNsf4gypjz8uSErJ+X7K+gTbQ5 o8QzKI6PSYjjREfnv3mFoJn6IQmVHxvxrR4p1n0H8bF48syoW/RnYvBZhbpg56sUTIOQ4JCg/YPs MmhDWCIadhpREfWTgvm0pL3nSAefseN6NJZnJ37BA+9Dfwshd9WEo421+TRpqGwKSyzJCdgqwXEz NKDgpGhIECQ8NmhpNVToTnKpgjBXUkit1aKoqacdmVUmVUrkm5JGJJusb2wc3iHkK4LSlcJj+A9d ZFSyABwQp0dncSWOirjIi1d3cFWSYjVOa0s47aacmOZu38aau9Vfh8nDpn3NwwqTmo6bAu9hwPsp KWo42wyqWCjCoK8AiZ5jknVUJKapUnGbMypIiYZFgOBIhCgRDILgmCwYKwRIySkGDJGFgwSMgLLA 6DKcU4zjWybrNptanBOM8WptmQyrZMmVbDSbJkxZZyVE0V0lzjdarFtrabLUwOFM3Kyy3eUrjgzs EA1s+DCfoJJP2/U/P9Nn4emav7fk7LKdL638Mc3HxCeAp3HgdGvhY8y4leLjwy1szUuMQ4XVQTxE 4Kkb9EjgNWCq4NWRlURNodDBVGujCOJkVxmJb6aK5sKLZTG+E4uhpFjaDQG4sBoW7gbVHDMBmlis 5vUI4DFYKoMVWwlGEpvwMIWNiZgJRKDMUOBaoLQxZuuY4OSpwRwVWzU4VyadipytRxLdqtjiwzJl glsiRbagLFiotikslRRlZMpZksVL4PuG3N3dnsO1ftrpcjod5JD4T3qfSUaGiB0i1CwmEny2WVbF kGZglgqf4I4Omq7bivGtohlKjtbKq451sxIkSI2oR0XrL1rBkLediTXd2ds1dOyJyOnYzwYujEtY ypmKmWYQ7OssQ1tmYZipimVvb3YXm2VX8XDwLZhX3eQbsH1CZ5NpSn2k++cmzrkqob/msDme6s/d Q8FCgnoUmgTLKkzo0mQRhaYf1OppSDCjDYJEZZLSIYqMzMWC+fj473FKw5YTlWVMWByPcn21JxoF k2kWSBOTgb+32SiXVyp9zwMrWHLRXGTyDAzi65L063n1433zCas21TN40xEPYc0cZJkX1r2GZvT1 ggzIaxZ+4FAUNRwpptOAoOzKbRSj6HhsG2uharz7dNlenavI8A3kYpYsGThb2dHN5tU5Uq/iYP6H ztVFj+Rp8rLCYwn0mUTBSflVVVVVVVVVVVUwsRooUsiSoRuKYhcWJphbjJVoMPg8yr8pWxqiMozK iiZFYSR8KhnJatSQjP7UvFrBGDBknk/9ogcKwYMELFmioqiiaCpCjAwJgVoY5aGmFZYOerVZS3PR jmzKP7yQpIVIp7f5A4EuB43Wta1rWta1rWta1rWta1rWta1rWta1rWta1rW2rmg2JcIaS3A0JghR LmlEf2hwwFgLAWAsiyL2JKyLFVWlKkWAsiyLIsiyWyWzdO88ruN/jtBlJ40e95MfG9RnehrQ+gIf kyTVoLN7sIiTBJUAqRZZZmzcwxvqpaIwNappKxkqaTK0MZUsKydaE/C0G2yiu/IhZk8nbU0jxZLG D2MQGMBYxS1JXtaOVXYdvXTWHgS5T9zMGYz/ybJYGmRDmAU0RLA+cmQ3cr5uRx1pwhfwZIcdk49a pvNitCexhH8uZ1Zm43z3Tm/ZOjKaY5YsjUThJrY5mUrfjqY3kwuFjtrq5lysE3TyaYcoOx7WiMoO YPN4P1HM9o+sbeoPpDeCIx5lTHaf1SSO68Ky/CUghuaKiCFgEEXoqlEkTbALFKhgkhjAy2MCmZVm fF5zSKMMtFTikqSEB3xQyAobBwEjEGdwedSSxB5NnAzTdA3bVNJSG0IUQfqZA2JqaZVYyYZ0VX6F /NOzX6ObgcztTutFdeGVrLtzQyyNqB2mVOOcT8Qla5pOs/BKYIs7BSHsFRRSmFelssYmml6n9nUT oPKu3pO/KsyMMipmKYwlhjJ4fJXCj304YMy6dOyxwdUsUrOv1aHh63VfZVS6F+A2mmD5rx228Wmn uVNVTFT65Uaqn4FTKpsVNkRo2jMhhjEwmLMJlDMWY5vSVOhU+WvT4ZMRhCD6rZVoqrRbYkSUIvMx Gt6mpeo4U2qzKnVsz8bv8yvwKxMLrjURO47WGhvEemfJI/nCDu4I8Te+IzDnOtkyxtiTPoMKVpv5 jJ2MtTLeXoVE2NuTLdZDDwRWImlsWrEpVi2FkIGCiTgpTYJDywwYBP3kpJ2rBVklI/uO5ZyiRPSW ktkIJGDHufFOw/I1i6sv8juhnpoMDSprDMtw/D9cMwTcbN9QoP7iqvCGMJfogIg0iJ5+HdjAz+ol drndigZha5IwkJMZqmAEh3ogEOUbmoQcfMR5Udkbtzl9mB+lJz4XSl5Mn6lVuckOH1Ff8AsxVMyR ME9w6+uF2kxK9ceEjk4bc0LbML3VibtUMERzMjI1J6uwIZK9Oxlx+TwxJNnReTz/sua7UjLGU8cp qqWXLLRyN55+Z5mbSyyNzz5jPcqwtfAtxu9+IfPPm/h4kk5IPSR2vWR3Hco+d4kMzvaGo8rcwJVV UP+LpbzxNm9zeS3yHO4o55K+bX8v6b8zZ8429PuHx/D5U6t53exfUvxvYK+t2qnjL4+x46xprVf/ emvK9LbXlbuNZheRjSkeZlhIeP58Wp57H87OJs8fSnaeCDgsk5iRDQ2/u+XrhsqmxVXrYkxVsnKl Uqy8F+DI9cPNtJJirW8qlKjDk8OMkThN9q2ltl75GYg8IU/4uwQIz7904J7fz/UtX+BrObdjtaRn AIfqhqHC713PZ6nC/q9C/o8Yiv38ElGout8hrVLy/jbcNV4uj5KdzwlT5KV8jl8bi9yjNFKg/5gs jCf76mjkdNtW2JLJygVhX+Uk46Jv8Se97xh9iPOyyUwlVlWGWQ0frdO6XmOc8C1SlUxi38tSfupW o3d8muL1rvXV3MHzW3Kema85qMypHvRtPFUYvYLz63Az6MYIRBYMkFIKEWCrJBEJFkBSfwISFlFI MQFkWCipMxmRmVpUwmJlGrMWJmQRisjIyCCCKiiwZEAQGVmZGJjOr+zTjzn4o5i/axwfuaKNSdUX a7uAdMnmsac/0YXFuJ1Ib7DB60SYQ+3PiMs5lTyrleGuZJq8YxtMmUJt6Gz7n8zA/RUnWEhPw11y DdmFyHA5SZQRGhYxiEUlQPF0ahr/HqSeZD8xv5oZTJYuHJR5t0N0f31bDVZBE6Npny0uJiyRouMq uWZJH2x8ZMJyewV4ixOgq1Kv04GClspZV5S4nYpxqc1jSweNSUoqW2R6P5GDKV0sEYh20qmmf65q 0m6lV8r6YOxndSa+tiR0vw7unrH0p2GYj2/J04FqrItL7K8qJt+jLROdxvsNuPoLmM4MqZwVV/4M M1qFEEQS2xgq4TDAUYyQ/3IYfvKhNE+PXxOxvYfhTdzHirqViSDBCliWQWVJattJKqqJVIMZWWHl P0Xo9javgsK7Ov1d66nWxZUlKkipSrI/RmEPG7Iw6XmPssfb3Dz+cuzJ7VzPsPlN0rYxXAunrPbv 5rBt6KKv3Kj1V4v7XecBxfvcz8Jji595s3mzVr91/TfJcc0hhPyLwOCsSJH9GDmKaz1JH2UjRH4q 5lRr38x+Vw6fSmiT24E7qnU6m4d49uGqSQ7T5fM3A9RUkppL7eRi48GjsxT8TC9XQ4PVDcsba+El fW3+D5usPu087fIR1ccQVYRKW91iwmFyhYYSDQsJRhApSxpQCFlIlkjQaQESRSUwrgFEEiYsmb7X 1edlJskUNZFDBU2p1YxoglMLjLKj7BQJ/1EI7ijIn7bYJw1tqKNoUUIjIokkQp8kAyN8DlXcrhVj H6Rg0PMPWWTdvNWIh5vJx5bS27I43kqebmeYRv/l0eVIknLeXkypROzpdV5JLRDkV709BESHonzn kJ4iaAN/X2/JDz+QqMnrREVQnuUpaUShTIe/Z+vTqPLPZzV9g9lVe0ovs4BD3Pqvp4+YecfDlznQ b2uOfBhVlC1FeVYx0+W9ohFMgefw8EOpwCL9PwE+ELHbuEzrU4ENQ4+hBnmVG7n+ydzMmBYoeVvS 8h9TrioKqfEnqkjNk8lnvRSrrT8IsnTwazz42kvIejxchP6ct66rVeSTZlpZwJ0Yk/skzpZI+r3s t1iqE0uK6rIfJZJ8MtHF9hpPMZZlNGPxnfqk+V6JeGLyJvc8zzbMNzhPkN/K8fjxjpUXbr1ud3e7 /dPwdb0pnD6r/uJbfR9TRK+te37fTNyd+F1p/khH6B9wEfwVK1FbKR/y/5cnB8rCbCQle3RO9mJ4 nTJu8F59Q4dDE3VNH2IpUcdX3N58s5el99r8z8n+59g5e/2y/I+Gpo15VqdwcPgYfW11bWGp9iYN gUU87CkqcErvrwd7DerUnAwyUZd57zKfzNDDmPMVTc9DynFuRGW4wjma5sV59D8dz6e7rtzcx15N Qviq/P9U2qvxeVcsXR5tOOXlPEfOqVT9ij+MNW3tdyTsNnQ/2rIcjlwTaRpxLVRpfBw+++5+t1PS 5fsxhZixXx77pOu6KTuw+VwelXeWuxP0uaGG96MdGvHUlIhDzJ5vJ3b/QJ6WD5Pm2PSqNbpoXVVM FmTRqSczsPm7/Mv1+tvkjzcHKxEttRGTKvUrPNYiwlSHcpgsyWE+jqPR5TlsHyj3dSyPAd+0zHu+ +z6Ee6qiPaTPdprAUhjFEaX6pBO9uycCMkf5cFWKJFkVBQFgCAqqyKQUixVil4J1hTtTVLIeYNIP JiENZaYP2gfivcOUwwM4+sLFjOgYbROdZdIcZPACIG9P6f+8cHAPMr6Uw4OTs43gftBs2oJ6CGz0 3PTULgHEKfp3/scykkTGYeJt1ZNoUfTwdjcvHVEOAVRBSJ01rDvDM11mbb6fzZymMz5DOPEUvoE5 jX5m+b7H5e5iULh2cTNoLgd0wTBxvOYGyOw2XTOjgsNDEsUykAuSoELkhULtxERBFbXR0IwJRc94 U1Y6c1SzX+XpkM0HpsyBy0RbSlLzbggnt2ShKGQwjDMpJbyFtIegHcY2RqjU2kYxiNBmnJcyjwGR ERI0A+BftVNunw7b0O4RPWJk9Z130/R3HzHTuDgYlpxuFhi4U8XZlxE5JrGE/DEzJ4hzkZjvTJ4k 3upJxh28tTi+sZwnxXG9AXgeORJ6Hm0+aQYP+piPrT8buJqUrSumLmUNu7Jr9q9aQHXeXeFxPcB4 +phEPkfQjIgA6e07NgXz9FTSny4ntHA+b6l6lP2TyKHHx9T7fxfSS4Luynd/Eyka9mm2WGMUzGC8 b2Pj9iq8v1dHB5/y/nPpHlZub0Kyrt/APwd/d73mZtr0bdyom2vfjWs/a6PlpXd7untOPIkyQKzB N/0jCJodeED6sKY74CERQ+HZKskXl7s5SWe2FdHz/G5Nnlb+O+yeX268k9lknzVJm1Yi2S2MX4fW weI8bknf4r7/oR0d/P0ze9PfHZ53enGMuZJPS0h+R2H1ilSlfiY/tfXiyrLVfcUaMKymFZFWVCqf 4VS2qloJMYsYxiwxhiqlLb40ELQlqDvskDRZJ/5MSN0/yowyVMxSYWAxUcFCqSlQqUFUUqKoqqf7 UwcqRoqRVBMpUkUliHJKpUkpUpVTLCSiVSIwYKpVkjioYFkilUqSlFUKUpTOExIUpSpKqqFUAUWS CikKqqqoqoVSqSUUFVKwJNUk/mv9q6RX/VU3KnAwyK/ofYVPzFT/daMXI3cVT/3iuSppU4lSfzr/ 0LiroVPoP81eRReKYIxMK/4MpVjztHYi74rFTSf0Lg0aP6FRHeyeVwrD+NQ+gq1fQwwzgnQ1Mc6z SWblaZavqfew1D1sPrfe/O1nQqT/I17M8U/zPz/Ov9DUJJvO53mjwZf8WiNkaP6G5+12vpTqfP9z KR4nidrxPp8bQ/yOt1GDDDH5UOPpfI3f2/l0PYLlV53evuV/TQ8x1xOM0+Z7Wv2voWyqX9j/ad69 idQ00xFK5JIwhgO8VP+avjHonkfDo9aq7lK9mz+S7F+5q9hsW6vlT1mH3mLRRU/YP//MUFZJlNZK d1J3QEXZt+AWDB9////f/////////9ggN4PfQH16HkAevCTcCosAAd9MAAKAB3ld3x73odUo8Gg4 AG+D4PvYFsvHr12omGYe7DYGzt9qVC9u1fe2963aDp72CKu+98L3oB9K9AW1PRl164m94WN3rKQL WZVSoOe8L1NA9AUpAXvvvh7Q32qREKgPnB3r0ASQAq94b290kCgC9w3aYgFFF3vC48qgBSi3HadA Aqi931NYAJLSigAAJKJJKoq2NUAADRsJtzwCvZm8QO5QAWFgCKG8huBSJBu8s233j4oXQoR993NG 8AFF470AAarDGNLZXQ66EQqmgADRkND6UBnTGtNDXoaADdh1AlCAAQIgEBNKeTKn4hR5PSh6J6jT 1AaD1PUAMgamATQESSamlPJPNUep6mmjT1AAAAAAAAAlNAFJJM0RTantUNIeptT0EaYEHpAAAGCG hiBJpIiEBExDSeFMpptT1DQAADQ9QGhoZAACapIk0BDI0EaYImGp5GptVPTT0T0JgmIzUR6aj1M0 0gKkkBACAAATQJinoBT2op7UTT1A0jHqMUaNPKcEvzR4/F4ivJw58S+HKVajojFJkYg+SrEysR+2 y2rJTamSLKYTKZJzx5bErnLFTU1ZSstR5jJLUsKyfr8fDeeqam3JP58CuNYsrIyel3brcrfbXBcb Dawd6wNcms+q8MObZGWfl3SGoE8T9n6vKG/b/jPyIT2T5NllMqyn8pkwe/R1cXFzbv8ubm+W+JR1 SFJVKpVKpBQUQRBGIKKCJFIoKRRZAYiILIjD6S2KMYq0soKC0C44jIsBGBK1WEStASIoBRpO/pTQ mKJPZ6bWOXM4Px+qPDth0yonChhlrpFn5XiXRkKKrERRjNp1Th/IyQxJ5J+VCj/haT9PtctWH0PM Jq873nc+3SvkZ16bTA3MuUPncR9t6vXRSHlodsZ3Jv9eHPdH1+2ofHHRTXI8xGTIkSPOrKnhK/H6 Ph7zE+J6C5pLv/kb8PdN/Hab059PHihwKQDyT54e7+a8m3u/Ju8PxsAh+pV7Mfy8wO6iE/5/PA++ fMUnQQGCC8perVQMtt+W3LbNXTDHVqVqFtCsvCUy2MC7Y3IsBVgpABZBBJ81Kpp5yFcpBttsCoBY HaMwCfsQ/yYz1BMk98nTr3r4c8ubZWurjt0XUnKcyk22TwcXGsMOBhhvOJpLU7l5bOc3JThMlYYh smgJimkaB3VQpDlFmC7WkmJJWEqfVbEYVxRBEWSLIslEWKUYsUARiwFhwiwiwG21KBKIqokWSYgu MFnVFDECouxC4VE0IrlFEQMaIsFhkYCk2gNKQKUoFQTdAFJKwizTIcsmMsQlVjHwTSG2GHCU9DJw zhWcMMGJxQvjvIrsooc8FXTywm2aSTqk6MCbYQOvHbOVQk3lolzvXXRHffmyq0X6NSVpkwk1Fmhg 1CktnFlJuHFYp1NZ35rfGjiYwdjCdoTgxOhN5XVtxl0SRdz5MeVclp8mHh1NRioxuOxzrwHw4gww kIJHHJEMiSyCjTTB4h2kcsl6wRUFFHFlbvPbOTzzMoiO52MxwubeGpN40koSkbhqZoGQMjzwa+3M nIaObNw1esnY5Jd8WcWMMSrGTMY7usethcy2UtzfHG+HfNnIFsoHLxFwNZkzdg2azSkyNJZtaZ6W hqZrBM1wcLEBI1s3RgSzY1XQNUMYIjd1YMzs3jNdm+HExZ6FJaSoVJuSW2X2yzsXSvalaXyiKXtS 1iWPklaCbTL65bzR5u/z5mZWVu23S1ck1RtaNKwxXxWr78fRO/H9avRVsf3mJanCn86fmplNqtpi ckuFHIYeZzmGGHtph9JhuajiL7ZnVSuB/8No6asVcaap1U2OR1MY1F0xlOFb39i2PZWWWX1/j39t wvw/97rXdpMpF0k8Q3yR/8CUNh21VRhwj3tVOh55qruGwyjUr7/epW/L35WTtrujttJbHqNBKKSf g/HUXHHOqShP8BP9ol4mNOUcgoo927jk6+VYPw/Pz+T/9JxkolJ4NslCfzNcJyQ1eNV0dvrd+vIg hz/TlCMxK9uQleGazPxpJdnuvq93JrZ/d/dVUuy1MvuEs+5Vr9yNuMjxt6NuHDsXiUvKJM7bvH81 PtPVFFReYnqMN4mqtzeWJ36I0tPJkqYfjBbFErwZh2A8APv9xkzCZo8NPb2U9tXNKhzw9initVe2 3vtYYuXL8mu0E4uieqt9UvV1vduV2rLf1869CRlu3k+QeuuDKcnhkZZLWksRFiI1Z5L5zk1Ox1x6 nFsP3UXiMXW5TuciZctM+xDdmZLEzsBaNYK1nWy3IzHbZdI2HKp+52XO2y7ZrncOZD8mFQ8U6Q1o eunXucqn3Wc56d0mVHPDEudssZTzr4pQWjU2JqlxQ5fDnIWObbm3kNNeM3ktQiqx4BI23Cu6CPHH xzZyC5UwG1UGKFFOGohGqFyrnKXPcMZdwXzkCC1zvCFT0k7tcPXO6aodoROOqvpVD71yParHZzrc lYmm3Ohx3c5Gpn1ypeVKmc2sfTG1Nsvi1GJ00nGy1Od01l6OPPX2SB7CQnkHhISTnvO+C1QOmLWj vqKaHZb0h3mSsbPFMUIyi80LWtBtey9K8cgGJU+yE9RCc7OMJ3JMyk7+/od53ZgFbqmZe7Kba4mu tmXedHGu0efQR5vQyE1u+IjHKWr1DjrEeY+JupzVePKDVOPC5NU9Dc7uhI5ci1CUOOpTY+wO7mK6 dqsi+2ewbjSoNToH18521Frsd1qbliNpwnRZFIUvpmQ6EWnxGKaqBv1bfUch+uKl28XjuXiOPJZt JH13Op8T5K26aR4htTzQ8rsOebnk53A6a1CxGCbccS5N0uci1Kae2GrXn3+LBCGPJ5eZ6Xrz1afZ HjzWGfjVFYOQVA9z27VFR152xm6njZN5dvHgff9HZvb272eNk9EjehVT+K0elE57beVdXuynTotZ WwQkoWprRbvZvK52blQWZZu6pm1GoiFbvzzrlrU6hSpRylKnMRaLSTHLFSORSxajMLJkhCTrErmB 0SrV05KLSRnObzlw+JRskid7VY4lCK8AXeZEXj52gxDnlLJtsKK7FXj8Nm+HjVYq8KNXaZVP5Ey0 5tdz7Oai6XRnjM9qkeLxbDztb2WPrssuZPE3Q5VzDRV5LqnKKaSuMXEzfOZzx1Om5nFFFC6dpuYK x+WLU6addqWoyHS3XOV7GSGpLKcU1FW7Uhbdyw/O3IzHxkxaa06SY5GrklylSuhyac5N4xO1WKdM J1/CiiB3yjzlV5Ede9z5tb0LNnJ7FWzt9VJU7DUw21sWmlUsd2pPLypVqklKEc5ymnNXJtUiKEUq VJkIxXbtHOWc9pt7VBCOypliKdlLypVLZqHVK02rlaZ1ibEeMa9PiLNIau2qV1PbcihyVCC0GSna tclasvYLS82HEeDBsZbzknnhBwifBTscVdK3rwvHSlXGxqeXhNVvKMUrVKbUYn8d4iHRS2jSyyyi Czi/OpU1W9lRAQILvO6KPPNMnyNOecVK/4Wb6/62/4MgQfnZv02D/wMX2SslcI/0mVRiZR65lH1z JUTESiShGTw75AH5Pwmw+vw4d5POJfE0nlEznE0p7onpEsn9Gbfi0/44aNnhgk2+ml/dHTfafKYY cT1n/dK3m5zGirieETlXSfbl6dXy4vb9GzoyxmlJ7o03pfGluXpmuWO6lO+l6km86B0psR2SUsPD jDUIHVCHugHQgt2CBfNWprxo58y6lqXw1VQNx8z9v7AOUT88zJevENz9cMbBE/uoQ2+EF/S6N6fJ kE9orCXZyIl1PZEzlVgip4BgPJNigpceja57iujwjsvHG6aRFclSR6+u37VwfIqiQfRV42FVTdJq PJFi221mdy7Oa08qXVhz895ronfMOFMOjqyU/TwTATCTOI5+1JlCPAVRQooSgYSQVVVQggyQUFIC JFkbb2kh/oQ6fSxC32x1yZaJ1z6yeqcmU1xMNPbb8M/bX1u019+pmQ3ocsnZq5CTcPZ1kLt/X3Zd LmpcjTG1HaSpLRpUtE7xqWkujFSxNKLyx6yqldCfljHukpfKjglMi6MMQZD5iHzgOVCXc29kYbs/ pV7d+BeNxLtD5TNsnX9G6/bMdOWdZsUqfc23ROEgTfKJI2+KGGerb9rz5eptKSfRdUddARAH33sT VV6AY7ggLb2/s8OfQmoZPVy4X7ZJINalUbsicWFdCTpkokoUkrP3+X53cu62Ml3Xpqq5+fKLzfJ/ KTMcl/Ct+V5EREQDD/DDmPVElESk8a2dH7buWLMI24ifJlKlJeqWFV5zReurPhq3cOzX2uq1Nu/+ KGKFIfRm7+ST+Mm+TK4IrmRI070P75NjBFaUm8nqmKaZLifL3fK33ft6Xe6/2Mvnjnfjnjfdfb1v yufqqhyh80qLS2ngxaSryEdt3KfszFbw91r2b0curc3umByCed3IxU8ZU7GzV4bO5B0ldXbQtrCS JwSjdnnW0tyZ61S3qy4Tx2Y0xb85ymopddq51O/N8Ps/D1aXr07pLko5Lx/MiKUeoe/ZXl291D9G 7kJE1nY3Uk0SI6bzzRLhcQDskUkEcLN2KuIYe6EFZbtiPPWRttKEIeYeXc0oIEIEQOIQOIkkHOLI KEQOQSIRJIhyThGlHFDkEFFlhRpgKHUpkR0S1PEXz5dkcSQdb1L3LxLCBCJjRyCVLpnh0cOUU+gi 0RVTdEX3O+02q0ZePGZ0PMbNS/1/H+NVPH6vT/18szWZrNXWpmszWyicWlZDlmIJIDIZl6+y22Sa QWBp9YkDOGIVowdWUSLBfwNYLCKStQNQoClprK4WTwPHxKKVL5Zg5c9N0q61bla2UVKU9VBvpzUw aXXq0adHBmOXywrMUtq210lRu+NaZtCpvLymvVd5XdRBSxKPnbkWK3WZmXrl52ZlFm7nNNRcxzSS ujaFTp3U1qzteuSsOdXqmk244kd1el671OnBez93nh5fl+kEgsFiowFAURUUUiMVREVFUVBQFWRQ UgowZFFigpBQEYCJGIjBVBYCILCIkFWKKqgqoiqifZd8hxR88WtojdjDWoTi6EliRnXER4yod5wE ex3P8AxmmFWJv+uvNay988zrhIEECD1OtYXJIzRstcKglK+mujZxy+kLGFVrhxGNvq4YRhzwH5ps Ujwsyc7VNXddave5W3baqOTrEmaG1JN+TskxijLYIiFVvY5BEObOA3IWWJdncS0SzHgNOOXpIFXz W+anODYthJGX1d9tuAnfH2bcvTudcfFRkca0srFzz4gL2mGJI3PVMHnqfmObbq7H1OVIvMeyNSo6 MhmAVmIoyjIL3yWqffS/4pX/MfRF853zVXIYYbUw1Ro0lqdhwjesjV+quEsZWVkSKFSfzFiyTEoU KEpCXpRJLJDIhIJEEECdhkqHc7k+20MdRkdFW1WRlpX7jLjg/81vG5o5I2jY6qS/eo5KumrCVpSn 4atVcI/a0+v8mpXuNvxHnm47IyrDKus6TD99ch76OWLWFmZWWbVyUPg83l65VTfAxKySzIrCvHla KrN3V+D4/Z5/xJ+PwL9Ffpmq1WZlWZm78ZhvP0agn2yMhon+wShOsiHTmn9CoqivkkC5P/sWQtL0 qC80ibl8l1GdCa5LDhs7vsSvYVxUf0i4RqVqksRav9XL21/X5fP/ml+DY+3B5aS9vLL7ozhcne/K n5xP9ifqn2T94nU88/3q6vhEb4i0R/blUqlH2CcJuAKig8URNJn9+yO/izf/dbkqfw/z/w/g6RQ3 P7S53O480R+p0sv/O7sfr388S1zt+Z7fX/d69dtLb/D5wa39npbwhH9h5iwFX9Xh/e9/+n1/jbaz 6n5eMp1w7071hCjMqteK32xPOK3nVP2693fgLxDQiIm8RLpf0x5+oaIiQfBYrWY17R4IEIRIr4ve 4lNkaSDJM+Icnr8RhgBBTuUSQH2xmzRTCbMETcNaJs1KQ9wSI8cQVVRyIUPT3qq+Hpn0Vfbx7b+M TkkdHqClzzNja2dPV44m9s6/Hx2cpw7Rzxh2LH/GWcXdeuOuU+4fFww+k5KbE+AhgmCJspoTqJ6z RXIs0Vc1qWwWTpaI0vuXtKmVl7tUvUpDtsKMD6WGMDzRJo7FCmhO4TZioqhwlfMC1SfSEw8zsaDw OJ1ztnUmTsAcicZhhKG1idQ8c0OhE+Bhe4oe0S5SlKT359iUXM61W7JII6e91zrvrxqTipJKokqk lSjmZNDJzr3K5OPv2Metytbr8O7w8OTajTnK3I9jAOORPQMACHJ7nMWImC3G42j48T39NG6lxQ+g o5Td4unFzZjY553MaeiIFi0wGKKMOdzaNcFjbrm11VRRQLpDRMmc05pY4wbBKVnrhfJlpKZ1vKt4 UEiICJFvIp8fZmZhlLOkov3oU9e6TA0apvDU91wQ3PiHJhD6pKkYPEmLGInJOkyHSHTCWTIaiVJU pmWkbIDipySbdjcSXfv3EuzRNmfC5JL5P6yUkXwZuvG0NaHapTFmCkR0oxTPckW2vRcsySTp4KUT W1JV8kTsNDbjVNcTKYJey15pGpE8vDINUmxuu5JVyxf6SdXR8jq4hz3GGrV3araEaI8SIjghPa4a PWvkzN5DPVfMYb0Hg4dAgKvXSWKMWDFiwXOkxi5epLOJ706dscNByugJJaDTdgcDBoSaUmDOpuxR yw4OOLmkppnLaXMUOXcJcwRNLRDg9kT10VFOWJ7evPXWfXd/Q/3SX4+Gn+EVRRrhZx6N+9LVaybZ XYYdL2l76S+uOoq6e53+zs4eD4t/X8IHv8eF8Hrd35v99YQb6WfNYVVrvdaprNqlE07FXzH1tB78 ajBRXiCAh83Ab2VO7MlnTacz8nHyxhcJ721OFnr+iH4dqfY+sL9atPlVaGYKuVbx8GX+qZ981/f5 yfitfCDOneq7eVnD6f472ry6X5sPuZg5i8JzGB3XLOE8du0B9nSebeNWv4VJ48tFzxajt575jftP esbvw1h93Lqx51st4rSJO0aPVvNvB6xNLPLRaebs57uyggiJPBZpmQ+CIR2YMyqKx2w/ueOrpV/Q kue49ZyUwyovvbmo161dF9hze6e3z3nreazb28t35Urmj7Ev1Hsj9yXwd79n+UZqr491VVV+2SXP ua+4BatIZJ8SRJEk8wj8eXkn4yVI5r5LLqT1UikwthLixdgtyujHou4W5usApuYJHExMdDDQhs/e dsQCTBnFgpAKh0SQ7JFNsCbZyhDozSMJDQhg1NmVDFoC0AGEt3mSNQwgTgZtxhDoyoByk7JOzph0 SHVk0kFkUikOGQ7MDlkJ0Q7IDuyHbr21ze4zDcmh+1pAOQkyTHJhiUByYHhseE7dDfXkl4pOzCcI VJ2Ycs2wKw6sgchkhjRAocA8WEQWq62ZoTDHJg5MMeIGtBqMRiwlwNpwBxM1IDkBGjhyBI6shtoz jzunrvxZtxUq5l/KHKtxHExx0QkJkhJd+T89ERnjer9fsJ8/e2u5fms/N+RWE8IYZg5TzBJKIAXg 2FPMhsHD0BkRkQG21povHEIkbvTYeFCKIGqogVUM2/Zy3GAGrY9SzAfDz4xaGZg9DAjWreukSbKZ UiTTnJbThZEaDasgwohELCg7aQAscyWBEsPUlaD2fqUv2JT6ONVYlAv36r8MGtM0uzUYpIUtUTBA ugyb6QR5tAiDhBLvpFhI2Z6aiyBGG1dr3tcVQF3cXeJGMJDuPABahGCkJfLfLW3y+SkRPlFMBB4c Svdx5U6wm/vf2+mGEZIaQUos6vPPUhAMoPCjTEgoqVQ3SI9FOIODUC8mIGdlbBJUQhKykraPEwHM 8ZDi7BaS+/xAAtazZ6GBCfb4wlJ71NTC+EMM/lbIxaYCEMNbWmLGUYqhaSCMbtqJexhcoi5QSTDF S+ILJqQaCBglXgwY1MV8/S+M+mLMPPI9AOOeJT/IgJurJapxnO5CC9XWleD+NIxtfX4V9i+cDRq8 hETGklB5kbd1iMt7oJRAAcgE7ZjNUsWAJCZk+uzDeGiaJgcaPevl4H2PtYFt3ICz3xveERN652zN 33iCAUvPFQE/c22qYNoNN8RSf4EkSpafDK7mScyRPBTFGBrG70kpB5qbkREg9Aa6CoWIQQSQmYeM 06unUESZM1YUgLfaVZGIGlCfArP+uJNQCrMVi9v34cW8K3hd3FKm8KUKSnDQCYrXfd75Kuz3qZHC PEig3U4iXFVEaKjdRbK9Gtvs1QozusLlZGvdshhAAZLUJ0tDLauUwQSpONXQiQdag/ZixFiEL5WN 8CVAFNmaYoiogoJFDDFBdq1ig8M7YHKkQ46cyagd8pObYKWc7zvOtrPDl8sUgznGM37N+WrtD+1M cFnMZwDM42zDoUQLc2YBEEIUnNCCABqRaThIgYmXKRhNrxLG0gC6AOIDE3RlKUVfSqvdthKL6ZnO Q7c70rjDtRzWLIoqjCmt9qpuiUIDTJBZn2IoiCImnBJwAgpXVnwBwzgCgurm5PEiz9qldqyisIwx jYztSGINBoZVDSoEQUP6gQIZnopKZHFTUPjN+sOvjEq8jhBoIyZBq9xF++XEOEzyIt+kqHoe+2KE yWAiK0zlsFfmr3Spjsq0y0DMeLqgQ2MYU4eQUjPn8Ka9hluk93zSX8Xd/LjxNlsL3NryNV3e1IXx knhZPY0AIiMqwsRLxM2c98Mi7OOrgNSdY+LfWBsbOReuC55EvzgvCrmRgZ2IydmE57e2MqXoVTT2 HbDmpuplHJ+Wanp+sO4x9XZB97v2Hn+Cegd96bD/YcsBk5FyfbZc4/GQd5rLt8XRwUlcGZWLox4s Fqba3yrWHwNFkFhiSJNoFkSMhu2AaYT3rM0IBb9dh+0+VYAdpe29v5GyQ7rqPN7N581lsPXEuqM/ I7zLrMp+9Q55MFQ7ZmMNmFeW6TWklkkts36fydwiXdytK0XRqt8Nho7aKJlJPHg976dDZsvPkI8e F5Krzrp3zvFgHInIwmMFkhw6QXlDbCbtlZgHKiCKrlEeogOliPn6+/4XlImr8739Ks82v6i4pctJ tJweF3Fgl++7kkwpC6dSpfilcWACqCEdMOhxAHj2zK/SIKhegnYT5wIhqYgTC9bijqoADywgkx6X QcdpEkE4a4liiQL172O2+ghm9bIIkQBES0uyfxs4qRRFqgdCOARdJaFUEY33gZ1BpWWFKOEiIqCi kiW8BAQeQjieCJ8ud5TdDxK6i3Vd5RhTjrUVgqQ1yAHbkhEu4kzSQctJzJ1DkskXsbOAreVq2nUk LwsO9wSpbMaFL0LSQuVQ1AJhSMwBDfgxzMTeggnbrYHaMUxQZR0DdAIuMwThZPJOBREF1zv7WD9d aXG/GTvveCwoMS8Bg6lCxPy1p+CEnUqpu6w9yUAOWmFATCkS9AtCbWLBMjUc5ylHAJIIjhHSQLA5 47AW/7XuctV2SbSOoh6+xvFC2RocIdznikO/Mb2Xkl8uvtsHOAWPNxeeMZ0IBu2GorOxlB71gpLp +eiKzCSVLjGU9FfOwhq+2GI5i3GGAn5qgj4xO0D0+CBIKgyhA3e4Hq9Uo3HSPEteEXgw650k7zek 3IvLEFiQg1ERGN8DcNFz1HOeUmu7W46hsgXDewb3iBB6poQHbu0T05iTIoAhTiA8iAIKGxGJOsAo Tm4H8TOBAvAJ8MQVLkYOXhsqj1YVMws5FVHVGQHuYOTiDgIKGt3Zo0WzcvrMpbReuXmEQgXhVHKz Ixg6zvEl0aoFRNibBbiiReOqwgzwBES44MudV4kXtlQkqOBnuAPnXqAlB6ZhkN7owQWIIIcLhwjR gXU7KViDAsLPlZ9z83zbezPVroA8BWN9hArx7Kb04R2hTYIE2syQATir834dMfNEWQyqhDI4gsvN WFp0JjPtwvbkeNtbOnd/DdSsiLfbAZXgoQUGXi7JeU3vDKklM3nMU018QpmDxnjXZzlVjnmRcypb ewOnyMzaMvB2BoKUmyr56gFkvlSsDE7ET0JOu6KG8lPN09jxZGVyxvBbwhWGHATqyRMMJNQNILol zXJeF88b5+IAhdBCixGViTafi0VdB7i78obdVoDlTfFmbdWfYZkTDKiPi8OHF1ID0izmXiTRbIg5 ikvnsKgUYtgedXREBgXcOQDWijUgcmCgw7EDK1w6DEOocbexkRJn5PBevNpFC33tYul5ZzRVaW2H oZzZpo7vFAOJWRrCcG5ENEmAS2VI9U/N44JdNnhbx7RxjUg9Id3sgogHPb7GtxAGdpXXVGazuhAQ RVR41+YZ3sQSmdxcwf4arcqUqm/dGtKTCeVSqQNyCGxns17XINezu/Z3VfAOqkn9pr047VJ1aCtO EJdcgnsUlWLpKLhvfPQMjnsP0q5VexnzBfBqtzJPERepzMEt7sNbV0FFgO0w5YZt6xGnQIJ1s1I4 2uxcs84QZcau7FSZThw9cxlBoc6QZdczfEoo33stZ71tKNm1aIuo6g1Fxg0VWm1LYat9nv19Ygm+ ihZo5Vrue4SO7ZnjYoM6D4jV33EEfLt3PsT6jmWh4eLiXjgtoT7/b0a8NvV7cfrhEjoSoZRx2kJr qRLdNkHZmS68MhmoUiIRZtkk+jeu/jGnry7MuvxQ8O+XY8viX4Rh50x2Tzq4su83ZUT2R+o2eeeL lOYdkcQWy8L2DNhGy12JVePiW0leVaUY8A5m1JgtonZIxOLD9Y19qFT9VZuQVcxVtPlXMW/wBxHJ vSZmgR4IPBNivZk7CFyzEeden6Ot9/XPlW93udb7+31/e/kw8QEW4VYzbprCSaExxYOUmDCNdxMa aNFpVMXHhpycUMVSRCklQHctEskjUsFkRhYWQUKRKJQkRmuw3LUFr7Qc5hkEWfB3l7ZUIdH3XRFH wJMoIOdVxAW/VaIAFJhLUZxqkCQkm7FiAA81YQAEIG5GGIWCmtDtCIr9Qhh55K9XKhKpMONF7T2e 9dnjNi30V26HhCRhAhZDgF0G11aknxQbSPTSfZhtzWDt5bSN8pz2Pf3ug41ngYYBQmQL8SMt5z2i hHaPvEkycN+sSSwV6i/VOYZeK0EcZgv1q9HKjDHViO/R2u4mpOKZqjLnr18fncJDWhhgEyBaHXGf QbwZmAjxGIf2bfJb4Y8IpYIj05yLBGo77XHUy5ePSOV6kYAiMJRYqtGip2WIZ04zNu0IbVOnQz/S eOwmLJJlZzJvI226eHE0lQRlVUCOnTVVJb5iCUgpc6agEISm+oRgVwKlU6fVTkhaLxzAyoqoKpm3 PuCJeoggE1qyIdKPUoqTWC33GouFVdtotvHWbm3udVEqLHJGDzxVGVCENrzV8AmMFlVycpEMz44j xSC7vCwpx4ZEHFFBs7VHhK7FKaeRUfG4GS32iCl8oI8ygPH9pLoS2TIAy3OR34uGxjZnrd9AdxnS qZqaISBRdp+xCwcQejfRroEyXnuZ5I4wTZYVegoc9o35O/5VNuFk5VBTG46q2VEgr1QZQzvrYe9S DMynM6Pe57OsxvrZiO7rtS5W32vLCQuvvu9Camm1EV4DUgijGQnsDuS3K6wFHlq+yRSmmVyWXH7B kCWVBsbMLwc+qjrTnWBncPV8FDSy1EaAQnovDS6hO71aZAR+VFgxNXKAkbzD3pDpaYxfMLWIP9u2 fOHfYTHyGJiItzMwlHr7cYefNTa5ToWAyR73c9SLKpTTvARBCbRK7UOI0CsdlmW0aB+zUVunnoAH qqPXjeRrLiVAkeC+gRoqEl/HkJVfpaK1jl676+CDxH760S3i9RngKPerCqZdCNn9HKAgDxeBAnOp XNWeDEIuk+2777WBtmEfzUCOsArGBqhGcBha5DlIufpDKMZymDU845y2NyhNEJIITBEAWkolM1zH TG1M0kdS+2eB8GnO6UmJmkdICeoFHaYYUjBz60XpMXwDw43fXmnLT5Hnih4eMhekq8xHTruM5hP2 7xF9ke2vnAdwdPd97ctZGFxi45D90JIUfaeMFvccB0GpL28Mym5Qoylwj8SRyePThyjVMm9Nmbv3 bFmuGMZy7pvQa7i+JLe31nv8ndXgzQVsRaodtz5zcKKBF5frabadywSTvQtx+yaTDn7XWEk9736o x+bPk1cU65OZqccb05/h1YyZ+odXdHXzKsSVKoUREkUJ2QqFdGE9wYBSIFYFgj0IJ9y/RazCPwq6 tqr7Wx4IM+7Kqd3FPVDpTNYtXXVQsebiM/sVeX5uaYnfzBxCPKJfZbBalF7vNhVocrrL1PL5y1t6 IVOThw4+ieoFW2VVQdTy9urqI3dMVpGTCPYhROBnVNMBZjF9HU8+87/ceFhPCcB19Hr96vb1cfYb g84twDNcwIIA9IuEE7CGXn0hOMmxmZfL1Hbqbk5+7r2AGSXrEhs9m3eoBsPu1UQSRCEivWjRMITe OQ7qI67ijw7rsojkCgqmnICAgz1J3c6DjI6knEc/IK4CZlRzhemAhkGOu9VPyj3khUDN9iZj34Xu wHv6oGNWvM9ACKeWDi0SpuigCIlMqgmuaRdDiclUKezOK1osnC8G88wdfTuCccPbGp5EMoy5UZHW YXmun7zx3MjlMAMgAKxAa6DuHMgjpqiCAUwkXMEDSiBKA8VuKvIcZtGBWMCjAhQLccfvBEA5Jrdh +O2nv5pcvvDY2SkGMYeQIKPVZusqCkRBIDkeExpaWvGY71FJ1K2FYLM+eIRwP1idKovGBl96Jpbd uN4vyRBXF/M0958QZEfDbYQC2hZqR2fRVYXuk3SeEUJjxh4nXUIqqUBhlFKx2mTie5/DiKBNOIM8 UtXorA+viDiGxn6b9q988mjvvKFbRlzDnc1OYyi+xQMVRRhjQ5RZO4m9W77PygkCSR5FHMOxaLy2 RGHiCAZe4Hm9XCoZx05MYOGJ31Bi1g0olyFJZq4c+eW1qjn8NMz27Pt801w4FV7WHGCUO52u4Nkr 0pZaZMvfAVFYOm2HVgciwF4siMZew+FN/eIQM6zXkt7THzeev6AmgM+kZCAXQjH5hFNRyJFw2C07 LbU3rq45Ii9Hbo31aQ1Cz6QJ4OHFh3C1vHpElVUdGz+mvSQmLG10231Bp/EJazOVH7x4+rsGxai+ xCkTALwgpofncKQcCzj29whFaFght63Mk25qXG1EbhGGZ3MoBRpuMk2H3yXzKIsOsR0rWNhfgayr s75Op7uUaBa2wmk9CDaEaS736GJgX9ckMuDuEGvrMQ9/qhigNkMVkJgl983phjPV3Fwu7g107Whi fCztBYWAsPQuCSWWOBBwtaIdI0DshhbvoYfODKQpIHoQzaCMJ4XMnp872OJUFPHvoJnKQr6LGwSS atx4RpDFKZUYL5HQymkU3OMW8qfBr73chIxWaKc7xyNTzM48cx3w8U8y/7QtE2qpZBDph/HIOO4p uN+gJfvmzhLlPrhfZynph+SOuG0xjyUcRO1/rq2Sf3Pu08rXcakZa+wpQoQ3bbV4rrVX6fCMo2j8 fNAAcJ4h8DRzHRrPJ0G549wSTiRm5JsCOTJv9qerTJyQ7fNO3ntc/l1VWlhkwYyZM+FWZ26tTUUw jJjiCigtywGRhKycm9+NIPl+gTfj0VZyp8u62oikoVYopqdzfwdVM5Uy/QyqKmq3I3tlGGJrlapr Vlk6X1o4M1c9RAlsrTBdnZhFmkQSxky5Gxw5cVm6d22YJ1NTCdejBBAglEIY/UZCmBTHj43cOj0u PS7ozwsdVWdnoIolet3BoFAxN/dnSABs1YA7XUB3A7W6TL8DdNb+Rrr4z5SAM8kOM117RIJELHHX VEOz+xE91EMgVu9ZfOt81MiVnK5giTfaN5YKIWUAsrkqMPnaAgUJa6MtzvKWBmPZAAyiRFKwdpyo +zns5ZuNw2RMTkJu4cPnrgkDy6RBYPGUqxvFIqAyhUOhHwaSvjq+T4NRgAxBA2Brh8cPfuqzlhgY FBRX5lGbS35hbt1BZ4/VXINsVnhFehvuYsVaI9RmHQnCnYJgCGZJsQNydCjTbZmIbgCEC32wVMeq HQYf7EosOBRuwQpbE4w4bo+7nSlJ9JjCi6zgn3zgpy6O1y4j8rIw5iAKxQCYehzgWqPGUaoV4owN EYedLchAEZw1rjvyTdR579kD3FbULtUFs+chPr0dB35TXdPObl1S3GqKzNphWHYECAo8iZaKqQYp SynEOSiZlItRFVL7sOUUxOxgV+XoEBVKRc+dJbEeZKcW2DziwTnR7Zc6Aor9Y3NcvALhAogaq+UZ ZPE2Pi8QiGLF8fhMBvafPnUrCSF1NxcP7pvtpO9DwwwNbVZcKRmS5QwoFev8rGhbFvRkV75XoLI3 mGYgQLg9MKMQ0MAJHuq2wLWUUsSL4u4MbkOUUynDSnIvSOI3f7II83RaqUg64ozgN1y3BiZxQjxs zg7txtiAXKsBPFhwG+kOa8krmI9tzmJShEhm06O2JWzU71EEAteasiRZlq5tDmjjrx4kXs43eBUH bpzyW7OEGrjiodUHbEiAxge/W2GssRILRGFsoHe/EEg5+8DHndedVOe+BR+9a5YMqFR7OcK7T942 6MVASRFRuMONWYrQuNmoA1F0BGyaKPmPwayF9NGrpzIzrO1ahcuU9JJTFCwDGh3+fNUm/joMjU5j Uzj9G1DmN7BjUuQ4+6lUGT0WPDv50EYvVYiZVsu4uqn1c5zz6/EDysVudnS43mpDF4Uv8eJPK2zi OLLC4PxBn27FquYfKk879NlSJUtny/Y7iXGJbj3LrA9RqBQxGWNUutw150765RicBu4phidZVeTr Kv3gQXweAmNsO4vDiXUaW46L8Fd/LgyHlNF1OjtsaHla1sc8t2Xykz7kqp3Igzc2bX1xy7973+U1 nVpaOTDi2hgu4OR1HZM6UqTnhS1Rz0iWpdRgSZvoze0Hts/ZP4STtGd9dzxxGc5PhWESBPKKuYyt 51nEQnLxRM+STt91LNncaxaVMatVqINmy+zDaT5yh5NOqlBVG7Tm445ux4w1tDcV3medgOZu+Rqi XzYU2tKKt1sPk3yfMejefa+rR8cTBKaFibEzJMekzWVBHM58087du9Y930Xx25vh0ZS2pERvt8fU TkQegkQDuJ4hQw0Ph/C0ewb9hx06c2ypnszUS0WXfJqdYKge6xY8PAk5JAy35c9SSs0D8gR7Zx4w BA04yqhEmkOxDDuRbt+ZGhGFlUZHj/iB3kcPJjNc+T/IAREdIsPk8WLuFfgXSivj2QzxiggKAFFR EjpsKDFFvaKzZIc/Dm0ipSMGc8OKjkE38EoPB4jmiE0kK5B7sF6dqOI77SrM3tSAzbsqC850Kj38 laPAERIBMu4cZ4g56o7Kvc9VH77QNRCSmjUNDCUIAsIOCNoFuyIbtjWh2L8SdzDgh9gcvTKpxVWH TVwggG5wicimJYdQV3DPckmWUrahQQSY3Pbfm11SIz32g9FTD2Iig8EoZ2NLQgapIY407au7/NGz VFFbZkw8ksnDnxY0xG2p3FiEFCRxTZ5VJ103RAGLisCM1+NY1aRrnq506dMB0bYudfUfFB2Lw/Uc eljFc9NyVzJSYjGgjN9fceTNhLlYbWvadwQPo5dNkBBFw6vLUDSFsP20zlrDDXssE5mzk1ahWq0a mbELz0vGBsDK9RxZSteAdPgVMqAUYrudQu2GHjFvh3YcyPN5jE30XuBpM397JpZO6HYSg6bkTuF9 34M1eV37oZi0OcpoF9e4SHXUghY7UIPLKNgzEd1N+RY0qSJcGG+Ji11YYOj0x7MQTaoaxdSO8ZKx 60YLTr0AjWCRK+U9k759KLjvnheNoZpLJ5cdrzTZn4/nmxm5OYHms1kjI4clAYKDqeMOiCudzYrF Yhy7IG0YcU1wr1dGkh0dqsqm7WHDQsQmd9/gHM7zzw9HzaFlRF87La9z3RDQRjuQKMsdX6/DkUZ4 ug+3HCkbFzHJ1LweV7odJr3kwW/5odPAorQrLL4VRhSGVDVROrEd1ToJKVVybFJfla04EZ0aGvGb Gii6lRju+V5i3JYzhieJivLYoQrSm0kpb0PDXATu6NTZw/Ddc6pFSZAcX4S3hfQt/fBB4t8BzAfW A7IpM27ioNjdWMTtMgBrOYSfXN3rze3v6+UpAJ8gBDhva+IHLhCc/j0NDzOslyIPfQfCPlY65s73 Rbst1XzX2xnZnEOmZsIP05+efdt29C6887MydzsKOuEuJ3Ix3nejLeZVqtycyLznHCLhslyR8jVp b63HGW1Nm8bITxXLdKtcSXd9vS0rux7N07sqovfzM25SyN1avI7yHHzLjTW76M6NShMhVURWF9vc 68VWE+8auvOwnj7EBGRKA8TJxzoNQSzkGYPZ9Ch5e3qHv57dvJVZvsQYDfWDELPx37jQdb2NM+fK CWGsV+gG+keyvKkAAl49lbfstYr0D0iE1fMIMmMF6L8o29aYZRn9BCOpl32UyGPk+M9dVlxzkkb7 Ok1cHXI+RMRTHmfOxcCzhGVNHzHcwMdbInpmcSZkhfDMgTmShSW2el8D4px3GltkKDrph/jAC/FZ cEBJNJ/So9CigpDUXkFv0wcviilsbxidbv3ruLHpp7UibWvh09K9jGIRz0z3jinQenGqVttt2zB4 gBoJaVMi5d0Fre8HDVmtHRuE8qIn4e0ue8EoY2pA+rlJnY6nPo3K7oeMwYIPjdPuE7WQ0edGYLTH VYHlTG/eHhN58jka2e+8Htx4VJJqwIgRq1pIiZLIo7440LrtFcKS1TOcYYWyGfk8Elzwb41bQ+Y0 6UUq3Z6FR2MGfITC43SuPDFyBSewQ8LAXXT5k7jma085z2mTpWcchIve7ptSlXM9E6kpD3OGJWH8 oBF6l3k9zPvIPgu4ti2Z7XV87dLUc+9XQ8leljUnytbG6Hzdh8UeA0sgpECghMl9DXIe2L69ziz+ ifFcOmDHpAEWy9RtYkr4GMPUi7b8wc4VhYZsL+F3LKRmEEe+ir+audeZ4Cf1y0F999VSYc9w2mNF PA0abXKhFYPOLjzj1awCDqzrerFYhsdwt1esUm8dLPB0ZZH2OUj6GdG/Rvv7AH/aBYn8m9/WCikW Bzbd745q5xxwrsb3S9/PdlJPV6yLhcI52Fix7DQc94RtxkGEvXdylGVxhcvXJcKWwqD8hYA6gQ43 Ph0WYi6X0e6Lwyyt/IyydBt3COVFmEaBcIN6J73qEud7ZoxpnWdpKU0Sm1LWNYjVXTuZ+QPB5ukj 3oB8j7k9rl4vWOFer0NXZO2SbqjhRm5Fp0VgVJMKhJJ5h6d6hH3kff+L70L78JzJuMhT1cTG3p0y per1b0xM3NnXTs9ZF6bU7JgTWPZy7sERUQz67tNQi7ie3N6CLele4tq+W9VmYuVQhSjDCyPXaOWJ mzb+sd56ffX1PpL+0H0X31Ejz9KIBMyBEAUsYEV+5BOAc54sIj3tAz8KezBfnX1Nl0nIDz9DfJDD nU5oww38Z4jyCULEG7TAWIG+Px6RpYQcg7iWPjXwdRBRhJAt660dE8GRksQhW4gQEa2NZGna27Bg uIvizaiwtVh2hSrZzNuKCJaF83DKSGfB5tcN3ZJvTYvIQIBFATxN5ypWNcO3rjb7fQTjarMy2qqO ZXg1PDaKSurpxEgNDF5GtvGc94m4pK/WAZavteFJTidzvO1NL34/RsnV0LK5WUYGclX6hmNAhQiu /PE3eZe1vSsBxBbwLlrAaRhR7mLpv12dtYivayGm4Wv1iYsTeGxKNkw9DrnYgHmwwh2gKEoadBwl 3VWW4b3RLmy90WWSgaUd9eawfrjRd1WgkbQ9x4Tbsqn2yaaYYiPz992gYx770NUU+EHvpWhLjp2Z RXCBH2iOYJc1x7WUzwQEjIjPnW98xCbw+eQ5K9Y2hbRohcXuzi+tWZM0McWCXuiE8s66HRNQ3el4 gMXRe+LdFuWtMNgj3JLHE1Gs43gMBhZkc2YJgnUEl3x+EMWYm0XE7s3K0EDLrarSsqvuXHxXA/ac vgfA80NA/Ac8vGc4Zyq9mr59DC2+L9bcNZwVhwiXOAyOKw8PLwnWmU8asj6QWsD/f+n1zVdlrqnD i+e9wCZllCkJLbulzieCtdec6ijWq0mjhSxb7PGdxqsEM6gFX6dCcPs+DDzMnVeSvfNNs41F1HNC 2GKSoytHAWLmMxPQU+NiXnpOuEY+Lle7yqhBe9EuqEJzOUWQkD5HgLx3D+q+KHD41DgpD7qcZ30d 2LEbSo7eU7ZRSgumxr3FcqKHDecCdfwcrTmfMFkKy73o8XdmHakzsolio7VIxpLbd9H2Lrs5Z7Kb U0Ze4AQmCXtnK7XZzccHhiWPY5XwNm13QduUNLmRAQ9p6SfLJ193iIGjRSC1pLAqZdE7jpViX3fo Sa5Sc+P3EvFVaqWnJlQ/TJq3jp6p60SjeIqY55SiOeauu1qwdbEFURUHaULiXfeyFfVskmdeLn1o eFVvscWpvNsetfeUImvR07jvZHCzq4y9V3qyFRovYMCSslQIp0ZUA01bblNP0e36N78/bjXiF8uh KeSc9mb4+5BPRd2kONVyIjPIqI9N3P6R8XK95GG+HcRIJBOWhFRG3cg71JMAIIRq6CIEh69QlLp+ JvnOinA9lREAUrlxhkmYjhU5dTpmO+6fQ5K+dn7gELJ5WkNAnhIZkEBBTsgMJpLWcWRMXC2IMCAX eU21AVJwj4rfb2QkTWlGCIUnaNmPZ7JmJZyk6NM2y0NF5y+o+R0U31lGGcEly0WfBrVgE4chHHSg lAINLoBaEEdhTbDl9pCMDFi9j6CCAQdfHSvavRkg+iV77xy1Gt80Oe5pAZkRHZ02eQAPUOwAV2X4 g4gJrONySDShAsW/CTBsKLpyr6pVgiGOl6yzV/D48BxvF8/kLBW6XjeETID7ZeGe6m8Aa4l3vqQx eAAVeRNBAp3fg32rr4EAV0Qb1nOzL8GbRxAMdoFJoDaFM286ZImQxeUadfAuwy4CcR4v2BU/Wk9e 1h7nWH74NaF+nO4rFH+LUCInIFvyqNy3G65VdGCEPCvqXwFnhG5Qsa8jDeEG1oxmP4+3wXdoQQys pJCCttR72harhzO4uNXxzYaTGk7f1m6+daldTvpCoqMYVr4q5j843bOCHUQgZFredvgrV3Xm1PTi c4rCDOfN56n4ZPMoNzKarajvajscQgQozWis573t2ztvP5oC2UfIVrRbVnYXUDfTzq2d98Pvrnua nrWgTjtl1HcseU2FgmuOBhVYxucOXAT9MrzeBQgjK7mzPkKMW1tcwWeNtOPQ5eGnR7TblKKKZlQy VHynYsVt80k+RsLDZX53Wxm+9d4FfJjDwHQEuejGM3NL4bF8Y8w70ubxsIpljZOaX3Vys/6gJ3Oo 2XM5QtCSx3tiT3DDJCu68W4TW4Y2m+8aCeZFz1ty4+kvaZsXEF+nwcXsZ7VuiAeMVVnnsIp9fwTX p2Rx0kUHuKIUI/WAPMoieXhHXbROpMPWTCUYI92Sd/qLzz1blqdsc65syxXmFV9tatni1162Sn3B 2lbhN1quOl8RyqdzmxqzKRaiG3OosmYJiWWcD3dV1yTl7xxBaHzq2CXhqMbDL2aVbdQ2W8c+5j3K ESaBCAyBWkiOuz9sMuPvf7p3YsZECAK4KxkCHVCshDqkDxHoBPsk14aPOZujTpp5x1QwZXtb7nbC B1VAxQK+1JeNFYAYEgvDE9dB49TRAOWsSgAuEMasCAXCBBB7ZuMqj81P+/eZKt6IiCIjAIomygCE 5ZxrJvGcylRd1cppDlIxmNaWoHEfyXqjbGM0b81nHHX7EbB2jYQ9APotDKjUPbl69YhnVtLRX8Is tEXzmaAAjCO5VhJfo/H4JGS43lDJB0wFr96E2Wrz2/vbqFuTjwPWuXqBzCrLrU4U8gMQBjlx9Fb7 5PN9Lc9b1yRBwA2iHRQOSWZfE3EKUKaOUcs9vx/IxWa2QUjQEha4MeyuvOhy6Pfb+vQilllCUzm6 e8uqSd5RY4Yjp3KGKo7AwRWg4WyJ94R/A/iXAAsBczCGOxooVro/dTA7ikWBU8sG4lxSjNaED7kN CjFJtVQrgGdlLumvBBisAB4lNWppXxzYXpdFyX87ec1m+RtRfeN8H8YOGXWpTOeJ+0L8JW+FJA4D ua+AWt843WkiDgzes/aaSPgvDweImBfnzT+j0aue8b11UgzHi+fYNMCCEAxLddSefFeXODMiAgOF BAmoIkhwwR0xKWoZy7aLr3aO0PVyH5xWqnWz1wFS8xWWHAp8xE4X5hsTBT+0BpxjoXiucPtFM0dE y1SFCWDclvuZpW5mV4QzVA1jAmWBZVdXI8cFQ+stmeB6uuaqfEI4THB+/L3cIxaiTUHWoHB0E7Y8 rndduyYWqQKJuk0hEJEnoYTYiQXMjhRzGtA2LhhsUstzxwjDLczjmnP1SROFZtd9sNB89iuMLpc3 zHTz59HzDk+0BPn9idnQnpDXX1tXV/o/op2XbyfkZnX/XOPKTXJzSckmUn4BD5u/22k+Hwr79eh0 D7mpnv3k1BASIVqbSuKXGVyVV8XweJ97zec+4yfhMNGpP7iSyfmSUJPEFipX5mThAzKFLVtrWYbV ktttNmfbmfYtYxznjMPSclTmp0GStGUrmH8LMVmVmMlcjlj1jZt/tk4YzzkuSfi/B9g/dlSXypcK kRD+LJ/KOlRK8h1yvArMlysI1hmQgpAEh32AVICigLFAUWCwYDFJFUBAYqwRGJEQQYwPAlqiKLGA qixVAVYqsUQBYjFiqEYwWRkNxkgQskdCiwQYFjVYKqqoqksgxIWJGqtgwJUQQQYIJCgCJLS2wQQo wqssIIy0CyREBCqxRRQiwIKqoIEQQhIoogwkWLBVIqqsIqqqqqqsVT9YhIRgwgCFYpIQUUWSKqgg KxZIKoLFi5mSrLfhGH22X03XHJGxzUYeM2qrxOJE+tu0Ktm7adDq02bvXVP2ZmTFYsWREWKT7Tt+ iUxWhYYgs1SLBYIwRgU9cUEgEhSAwghqq9DKq54qO2qYl9jCv2xiPzRCP3BJ9dqP+RJ/am4biIok //A3qMiu9RtKfzpSdw/3MMOivuh9yWUylxq/yo5Y56PF4qtqOiMiGubCTdxMrRb/W0/4XWVp4IUR U/9p/6CP9qj0dcd1hjaj88d6PVRWS78ZXgo5rlM3qzKMPCllHaXJVlYW5lao/2rvVy1JzUcKug5z DDDJIlSVJyEnFkqvab/iv8vdbR1CcRDqk7U4t9p4J4zrjto5qNUlyUc1H/aW0XCjyUcyrjzxd+kv 5Q4x4qb8tHTPPOSOFRkfRz9/6e+tfBbnwnWYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY YYYYYZGRhhhhhhhhy7VMq0qm0YYYYYYYYYYYYYZRhkYYYYYYYYYYYYYYYYYYYYYZGRhhkYYbUru0 f2mqS9UdtOqo7ajxRz4Vc1JcH9uV2HYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYf1lf+5XKeMwwwww w8NNUllGHOYYYYYYVf2NH/00aNHco2NjYw0aNJdEeG40eTeLu8Yy7aNqOeo5aOarVFWxubmjRoq2 oyjKjro1RqirKOE4HA2NGjRF5Lr+K9NO50VO5Sk7Y8M7KOuO9R6jyMVYd43EqUlSWLi0uTMV7I7y StqJzEmtJu/5DFEeJJGJfz7D/XZTiJNnAeDwmVenOvFl90rlqOaj56OrVHl3o8VHVTpDjHwXLR/x RVzHy1hjhR4KONHOI7YmJPOJkTEiMN2BJ0mrmQRSF7qcnjTy9P/qbPiTrpXZDVHclV1Ueic5XxTD KXdvDbzdO2kvPRucU8BjXIGqNVbiW0dyjwxlUZFERpE5McwZkoliThJZNpJc2yGqpDMSUShJcWIR LElsZMR0DajtO7Ro0aqWjRoq0aNJe/xeXXl5j4DDDnvrO9ubmGGnxVP496jsko5l4mvVoTUhpTSS YicUkmZJpJNKSXieRLRE09jelApESk8bO4f4cOF43h6aKtVUemtJapWUdh1mGGGGGGlU8lG02nJR 8FHCFYiT20TjPEScB89jmTyJPJIMkJvj0pYYlhiWGJao9AffreU3JNpJcZiSxJ3e7SJeJfSbxaJN 6S7KOaPRXRyhy0ZR9BxNjRo0aNGjRo0VdUfPR+GG1O9R0110eCjlOUw5zDRhow0YajDSVJ29mXF1 L28T6MfT4knLoRE5kRoewnVFd6O7XnvJFW1Hko2jKoOyVOeJSI8NHt+1PT7qYXXdBMpNDelUuS0+ CXIvECfnyyUA0RRRJEELEMBIYYGW3mrlpSeakvio8NHXSk7ebhRnCMo4Ud/ej9dHf+/RtRyalNUf HtFnhj01vUfNTh1ndMMPBTRowyTpJOPopsf+KiYd3Xd5VTrqSZ9lvbpfK747hOROmp6K89eSjeU8 UZR2D6KNVOzI8tO8ljuJPFCdVwk0ERJ1uso2pQ5qOjqjcyMOqMo1GGRhV6fgvVny0Oa4pd2kj/9R tRnRHVR8Pq6Y6D2GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHjp w4d351ZTpo8kdVHDopK6aV8lRjVHVR66OatVeGnCjPTeelfkjtjEv2R4qkn+OV/hZG0bmrUe+Mja P+d/4UrZL+sbxkfqoxLD9Hqo8VJeWMq1Ro1SWUyo0egw+M8psfUeI8JxOBxOQ90cDRuYeY5jgcTc 2NGxxOU+E0chhyHKbHOchznMcDichzRwNG5hznMcDibmxo2OJynOb0lwjmpqo886axjVGJ+m/16q OE7lRqHJUfZR3KapLnoyo+qj0QamXdOBhwOJscp3TuHKcDich3o4Gjcw6zmOBxNzDY2OJynWZVOY 4Op0LbSoyhxOBBgyWRk6SakyTtJynA5o5jgchhznKcDnNzDY2OU2o+irKOU+M3OQ2NjY2NjY2NjY 2NjY3o/ulH6L33str6L8F/vfNa3/XrWrWtVlnSzkwSkFJUS9/3Xrii6PuETQSaPwnB0ODYkggwjG IEQBB60sgwRBREWDEYqMiKBBkRQBhJIkgooxEYIIRIIlApUQSBBkgjIgLBEEYooixZT9F8RcwaVl 7SvjYstGb5SGKzFZfNEs0KZsYP1qIkVUFVCJGDBpTGQycZtvwt6nPtyP3ZmVz3+dfyPZVo/IZANM EEgKQKSZJ9sIB6PNmeARvP40/H7f+Tl4HeMpkOSoCUPL4XVqXc/+X8vzmWdP+Tmm9dltJxSVhtq/ 21s344S1h8KFDNf+kKRnl+KvLl/UQHRpG2+E6Pp3P7p50+IeRYAWAVdkFrS515bHSvru27F9JZjY 18gvNRqBO6EaZrPjrl3TlJpQkPEJtRvdEO0jLrZjnFTdHdFY5QcU5X/CCGuViN6SBsGwwQ+ta980 ojxb4HgSzp6pXrVi7LMoNjkU7Z/ofqFhb5uN89kUb+56bN3xaxn4Vw6YP1U817r/Pxu7jfV7mVHm +sm7HircXsJ4iaCGFgty85/TYAXA+WATkz5gqcfBrJrfudhwfXxmV160+YG/UfQk26oINwJCHHjd Jz1pb5KgzQdOaSa8MTfRkYftz69vPyRIZH5jmdyUIcOLtxixqK1hco65zUm6FzFjFZ78QHtj2NX9 aJzsbBnrrAr9LozkoHQnVnIPdnntrranEg/dP3SkpKSkpKTjxyqbtlTj19CwIyyr+XHmInMDm2yx 6TnFZMddE2RPy+KfMqkVRA28jrtS+ZP41DaPDp7UWJxPtMsdqnl8Dp9h4JPif7AG1Gnw1o59/R1M 9DFczb5oPNE1zShLNnh0immrgdt+iO8p+V0jTpbH0IPYmYD9He6mboE3er/W7Zo4mimfYk6k5Yiy Q7tpM+j86hhEqSZ0Oy3jUySrBHy8M9H9LuVbVrenlflzM6raWrEsrKQuTXVdrV865EfnwozEspte e6LYrdT5D5DDBMMMMR/v2FNmQiH+cWjg6aVUqSkVJVAlDnlnfti1z86WML6lKY3YlP81llnJ7XE+ LJ9Co6da2cTEiQ+t3w8+xhPjKU/wu4v8G9Jun6O+OOePN7F21um5Zxyzh5iJWvQnQifsUY5ebeql SWgxzrFJbVR5QGv9d166dhvVJFkctSf3VLBzQmPFvatuxuUeFF7tMX09vP+BvtTy/L73fi9vp6AX NwUsPPxv+DFCwvYBLfjSawdz8lF/3IwWS8IeiqP97VHtiuzfMPE6a+ziERWcSQMYD3P65IfhS2cV lSBOTiDNzm/MYR+TzFDbUyes71VdsXW76O8zwRLEcaxddjapbYqbrN+7p8LIodoooynF2GD9Mab+ cOjZIpSM6S3zyfLEMNsxsuAlhaEcKetAfXKvx/EcdZpzHJF8BNl0Ug6OOOBsoNZ0WjfRcrfViGCC tKt984KeX0VxHKrd+YEvjDICvK8G21nBaH8q0s/QE4Oplb63mL9TSeUaDyq7Q3FMcteH5nybNwa6 BbYpxvEXjL0FQ+FflbijfBNQ1qsIjA+jD83l8YvmRramB/2fY/SGTuWw3uOc4QLk7506omoEV6YY ah7TYXGD4sF/Ut38gQnGOFdO9TcZ+qG9g/4YmGrPz1Ng9e3aAb77nuj6TKqqwzJMNjLGyduY1qRs GpC6zgcXWOLznwaVr6NqjDHjRilwt8+UjbzfSj9FrLa35SFz789VPZI+fLzmPm39Z8ZRMNp+69l/ 1DI/ULWtbyuY3P13ZHs/eOzjdaUqUyWc6JCWFxW5yqi33QPl6Hl+5T3L7HXyILn/1smF4S/o1lJD w5U7pD8Uok/FKkPB6ur2Tq0nn0ulmh6OZjttVIm1CEf1qJIWvXpUShSa6UfnUSePdbv2Zefjw5/H z0evuZ7eYIwOxUcKi5QyVI2Ie+Jgsor/dmOznMN5fXo3dAga5jKi1ge8Tu0uqd+60vC2sbfrUYxr gFeFMrzwNJdw70d7Y2Yig8HKm9xyuhuILTNUM8XAvIrS6wndbyrYGDPDbwgrRjR4neH1e36dQ+uj MsS36r0uS1d0XfeomujfEHjrWc81W1RO/tflRC8moo6HDnjdebV4cyKrGeRRMuRhL3Jb/y8KSkK5 Shshg3KCQhDTeZBcpsOyFtBXZE4DuHsl6isM++kIFN4fC65d3j2GePJ81svEGOHcUzVocCX3jwbB zr7Bu47kiSF2exts3Jy4y6Qzhl5vEXY/bZ2MeSVB3kyGBYI9SFWaGmniIDwnn71kqteQg2r7G2XC edHOZzkafWc602mPT10InilhAPv6OtXlmTGoLi0IbkdcTVm3fTYxAdxP4dhNTlp8cUSWOvQDn6v2 ImURwfaYOONm7dKyNfrifDmWW8Dtz9RHFl7+D5jsGSJCR3zt8viIBBRAIxpM8LTV30ESq2/xJ8vs iP4eEwXxp82/t2l/82bT6AvCFpKnNQpg35i2rHGYYSUJF4K6tZbFyq09UQQ4AUERQQUREE8At2xt mTPeZbD48G2ozms311mqyH9p2bW1tOpYrCbxx8tBM+s60Uw1VcYh983nEO0+uqwNSvn8MgJsn1SQ 9vmgKjh47keynvZBxEjyxOQkNHO1nR1bD79GaF88rJNR9zyWTOnvj0+PyT5MmfWTQZBcyZMJkyWY y01hMgkw0LTAyUMwSgGfinB6YknWBJ859RCEY9dT1e8faS5foGz633QVMXK29ODr21Vnw2W6s3xv kxdOtzKlX49Uwk6j9tDO8iKxsg+3xj4NtCzpjbzSVGWhSTsqRJ5asOm68L19qqrVfc9aezz+Phsu xt7q9cfja+r9DN6ufvWL1zdOqnhZsYj9v3fdB2zGOfTz4osuFkct8ZDOGy9HulAaxOOS7/sNQfJb jcFUbbM21GdViEykFPMfgO4asy5aUhncprVyJhkRwgaFXCUaIRgY7TDiTC3WWS/K8sKdm9WQ3nfe Xz1xv9HjX+VyIPLjosLAWGqUfLq+fnHBdG75MDjdb49qb0p9wOTOccHNZHR1jxHbn067esl/OGf4 bagUCJYk+trEmc+B+96b16L+ecj3iRuJ08lONHO6fIwwJFs4zci4J6El2BdrSXoaNW8xAztZ5Mzt raD4GLbFFwahhnNgar77blhVJqvUOjXz/BYWCvqJvfSoOQ2859Pd5nObjwdXBVOEnLzrnl8X101y uIz7aNYkMWx3RebLMZB+dgXrs9UlGrorBlrHOb1mKTg/LOq7J9mW2P6wT+aJ4oACBNUE9hOnYnTA 7rnOt+xaVpUhbtAfKK27Q6lnv3hVYtrN89veJ8BBF/T/i+XjFBL6K9/A7Z8B3hzPrwiKdw2c/g0T GZdfwC4kIx/c8bp7GUZqjzH3LvZFCKB4ZdlcU0XKLjpxDtAcK05ih3GT9/njV/TuTjHWMLaLbadP iPC21PZ6SlDECl5uEDwERAubL9iCfJVUQQpF8lNxrsYOxF3bXLVOKV2KEYi0c/ecrU0IJ2OnSvfM D7xYncayW2r/f/RE5FDyD4bfWAgjwIh7/EEh5fOh+CInooInhXw26Hx7P547Rk7zG29C1Zv91efP ZEz6pLMDbMKeexwpGOSIAiJsIH1GRBm7Dws7nZ7me9RNyUlJSVEqSkl5/zSaBJJQwFD5UFABQbAo RBJM4GWGGHPdF+E6cOF5zRxpxzFkZMmTDDoK3u2+O6srkqO77vq4nuzM9OTsUEDEMBlSCSkpRIwQ n8R6WBE2tJ2GyThsjPib0OjiflHf7PBnEaFXKHo7H2Vwa7fGZfSe3uVsjUoUqDDajTSoqqim0fDH xG20r6vB302rSdfeTvcxz0uZlY+J1sDukJIHFAPYne9zDqmwnbnOyR7pLpMjz6PT3cfn64V1XZde Okk1b72tZIdkcVc6Xr0UZ9P33YA0rEv7qcTxf319faMy3uJKvNBhmaSKiJYn2DnxO36Dbr9Dvj5W d3f8Y1aPnD7se3qwwtGvnLTWy2j6ynmExsko+9ANG2TfT5Qd5enhzYjkae1rwcz+HLiU+B2z3lLP dq3PIv3HI+1qSL6/UJHLlZcWjTxOmX298urhOeh5vUDXeuNZe8+hBvXQYBWrcmNO7Y2y9uW7joRE DKjwbzKcmAR/usLRGTIUD6EvT0M/LtOAe09jI74psFwqvBm31b85AwX3k/uoZcP4rXhsQ47qRz39 TqDrmKOlPrPhGavHROorRpwm6kih9mS+DKCkLPBAKfNT5vHI0OR4b54MHe2sJshLKNd/WNI1w8Lk kXIvzR8Bw8axCEadUP5WRpkD+b+hbuo7hMIpFcJJpwrFwiCvsdw3rtjyrvhztHS2q3wUKQ2FVEPA rzYInPY0RacxiOUNvepV0JTzecKWrZLZkX3FuvB3RPbsIIiJ7kVBAZAhcE50xRO9OPk76RSpME76 GV8lxxZFHoiIgEkEJkD08ji3NzfsL4+HVPVfGRBvPVqnlXHnXOWs8hX6cKiomfWy9kRBEegqS+Zb YnXFM7wi/da8dWkxQrXm5N9XLHiHtIg2erUT9yn1gGlEDxG0m3cm+vOtsbjRrDxQN60MiAc87i4r AETaeLd6p/lJJKk6Qfl83cWoiNKD0hC3v+nzQTdzDuj0d75+vvOeveent6eLh3nTyG9Js/bL5u5q 3o/2ak61hRTk29y7HuECniImQ5lTfWcRzPrg6On3jysYPa+L4cqwdTEeF7rPsuxLcQQEPgfv8HJO ubz30Q/aR3149pU7s51zcaGO0HycTjlZw79IpWrpPLPJf1xtq/X/GeEdcRBzcZSlR8lNNd6Ox8O8 7zespj7TSWni+Hq9shTV/PXbH7rr+566Rmw4XFuCSYOKybMpDimW49kfdIP+9eKIRqNJl79TZz2t t1FWW/TW8tua4E8rn79nMkbnesOsDsYYKgw+QhPVvx8+08gjDbPnHuxzAX6PB+IDKi7DJJBJD4V/ BRPpEBLJGoUeKbkLqX4RguTKk9zk2Toyz4rcIZ/HKZ5YfRBUiL02LJLJRD8JO0fo1uDtGNzdOpOM tsgH0DHkUVFSxVlENzKQ/CynNkDPduRCM+lVjv01JUlVdFrY997OXuI0o5r3FcRIad7/hbpiaWbt s80Hmkk0xE1SBDmmerbMhNoolJHO1yXJQ75fJ7elu/DX3O/Ccu6ye4rH+kE8e0vmRBEfgp99M2e5 Wph+fwHOopCFbi/uxd63+7Wf3arSnWBj4Ocv4j7m+ey6aggVXeSINzVptIuDWILiWsLPA7pNEWvx us8qYzi+cSphUZmgKOePgcpVErbMStc6XcBovi47wOXLghgbBONNuUI1dqCRDW4MP24V2lsIm84K zuFeDDicsZOd823dsCF9DPcxWfNkgPfDJaVNn2ZoGOXqAY8xJ8Gs4FtXEipfr64qHeoghd9DXmzo aoYKp4ULN9jJ5vQlN7QQ2eDAkmDNPbsWNDTpgELcsbvBaN+BkGrzi2cdkz3RITRU61vmaCKfemOX YNwMjnyr5x3QMIJ06yMDiZ3WozPYUdjN5RnJHowqa4CHBD2tKISJjaKOUL3rgvsOFS4w19j+mALC 050J1Ny3SW0jDobglEieMNRmibRf7yGmS5q0XgX4HFFu7V80s4/OmTezoGzwc9XxceOUtRxes37j cKbIZpKfLmKD7KKwgxXju2WEEKxcarj3WNvRXCi+zbfMuM314aDLMgFhfmdLkNzRYIduFx+IXbNA bzkTwRy+9ImEOjo6Pndo1rLYvtCLW/Vc2dU8BAmaffY+lANxN0BP0Xppxkw6en1CvWr+gKuCXnMw q6ElX4xo2hK8xlhlKyMpW6y67z1S9/RToUcBXsMPxGHqc13atoOacsf1owqq19a65R4O6onvO6fL +E2J8ZxfeeruM/CgDJ+KRkZNZDvvjluZiIH4NVczC10jdAe/8Fk4fjJ7eQJJm99kPdNOjB9EfhRf w+KTDgvtg5oSrRhInbEuSO3JkjuXF9Oc1cz29009dZOY1W6VtKN1z6rr3P7Bm4kk1qH/qfDtNZt/ kNUjD3BJM9J5bIQ6N1pPA850tequhUaVlkoUkJVSlT6PluuhL1GEikkWUUUsqJRQt85TjNDWTSud rrnL1dv4POvun37P/7dwXKiFJEh4ui7tqavwcjnXm40xdLjp0zxYAsvWVJG2Fe/6Jek/Tol/TPa0 Z49b12OOHzTWSGTS4ntOe/nc1k88Y0qhOVvmisaX+b/nswTpTf1PahRg9HOT8AEfdJ+5CmDXn6Wq 1zwTNF6gxQy/P1e36Tf5PuJrtB2KaZNUnUQ2uOOVHSbFSQmgskXO2WdKy6PM08k6zLHh21VJ1xSI R2wEKibKwW4Xa1ezQmuuTI/fovl5UZp5nqTnhOR2oY2Jp1QnVTCP5UZXfZhejlq0rpnXCvKbVFL+ OAq1lIldeGFTeqc7Vz1CHziVvq0kJLM1CntYL3n6WcjzVLHpS6/Xxuv+Hj1ldKauauKRO5wdVaq4 KVI0Xp/d1c9aWEGt/vJ2o9IPkEZIyQYVgpFIpIwRPskoSoCsERJGCJZKEwiRiGFJKCAUiSilECxk okiZJZQZBQsmBTDkLRJPsGQqIqGB3hA6QmfLZX5XM06rv3ee7saYmMzMVFZXOfkrJeNdmqNrKO27 rjtPAqqvksUPTYD5/m7zM1SK2ep8dXVtK82g0ofYVbJy11mpKcWS/RLJuJDjoefK8MGhbEIw/vyB DC9OJ9PKkfpz/2J9rGWt+T2zvYPq+uu+U3RbXNX8H4p+3VaGOfhAda28Itev0WiftrHsk7yHmz6x ge34jlCpEvz4aE0jScIVMqqulEGmc5zPzePWwT145qafhdrnjEZLwwnHaIgyPYpw15e7kdpsjOI1 bH4aOrujYzy9oE7pOQnklD0QUsLESMhT161oyhRtetl1XPcVwMyMmKissmWC1dfcurPO1Var8GGY tbxKQ/NMNKeJUhpOTUmuTVNTS/D3M2H6Yzfeoejq6NIa93yTRyJIYTIouXKUrw4alWQlbxHT0OJs xbnUzES1bMmLnCPPdOpuNu8ycSH8ARQUETDKIqAjxOo8KkuOwb/pRK6Etd1HPuv80n3pNfhxd/CI 20iqkJI5nJpQuExLeiXF0r1+MqodTeGz8BkHznGOTJ0fLXqp2zI7N7ijCopXJjIYIvY8n8ZfNzpH NjCTRM49MuRyyU3CVuiq8+7l8srlc5qSTURyRLSE0MhfVZIBYhKgFSTw9Y0ESLCUvPueXvV635HU ipMdg1Ig4g95MtcTOrNSjqV6DouHarLvvSxn4LWyZ8Mr8OJClJJSlKUpSiUobUj2F6c0mK2lPgyb WG60kIXFnU1T8p5S8X77ouW7iujMYzi275DEHy+rTujxc4eTmRNb+k5I2TbKkqlKdCrao1DB5FSk LfZCocsus4B96ZY+a7bLtWrJZNz1Wrpp008K6rnS49No0YbG2tVpjUphZk2prZm2STSZPj99oU2s qt6qY07mXmpa61CprCSdYYObTLBJPR8Zm8tn5N20YTb1bkELoqFEqUlPM3OPMpBC7Z/SJv1RRw0w k0uVhlFRfEZsuiJRdGQpUrDLoUqLyF4YRDlWlkQil0+vgK2Uf+Mo81vac9Zxrs99Y6gXXjBT22kl lOFuoTZL2h1wpScTicCdqFHsyvz9Hbl0V0FUdHTYbZQq2TfXZs3tjX1NiyouwLLQ88bU/6LRJzhU 0G7OHL4WL4fo9yV80Qj6tlJU3uckPoTVJJQT7ug7hFl98n6QyXBsjhB7Py/xJToBO9rpKlifrhya kq5phGfyRCNrQH3vp767otm1KYz9fF0e558zGGE6Gr9d/GiWt7mLFwyf2RND9lPn28rrejyUQ19n WukcsS1FckqSX8US1Q0plKC6uSlWtISHSyk2/SXEOaaIUqRSknxyWXVVTmejSicPC0ktbl18TBeu WkJOJaiWJOPi9OZ6F3eSSlbGUR9DeWQcl2CanRJhE6JUqMjkqwnIaJtx17kaZ8+na0fyiYI7N1+y L/723dpdjfDnTrk7yetkn2To2FpPn8pDlY1KPWfoyYpSlyzwfK1rrrpbG5fYk9eZZ43mfd7I+EHc 4R/b/XKbpqJNoibmqS9rSJRcpgovXLL4kl6zqU631v9ks/q9kJB/Gfxn7RGD3adGS9XdvFz75L4/ ZVoUqUlKUsqTJDg73cnQr3+/C5p1RzNKvkomFzm6I0JobIafk1S59SzFdcqW8700h+JJMNehvTW4 xHTOlKmF1V+vdqkunPUq0WqMMrLVtbHq7aMrn+B+Wp/DhfDbuuHh6f2TnaX8pSc8Pony433/FE+7 FxmYST4xMu9zfwvds5p829jMqT2qS6eWtxNGyKc6bZjMzdE9eWCIqKkWZ7iyJyZSdPS9MblEMVoQ z9SmphmGQhpU/+MJOEGQkIkkdUDgZISe37/tNK12YWkm/Y2pWRYsF1Mh69fFrXXQHyvfqEfFY6nZ B0HM2NslSoSOSwqty6Q8ntb4j9pczxyi1ROO1Olct1Ige1i16WK6y1olXi5KnNC5LkNhwIivzia5 EI2TDBUfy0fP7F4xnv1Y7KRXfcK5bs/FnVrbmu777stvll7n5mwKvwMF02S6rqk55udb9NzjEobB hyXJwIVCHgnFpPFjzOPVNxOlLYJUmpsgpJzKnYivn3/vxZnVKaVLFXKNlnGpNxEX4CTGS9dDBfZL Hhxtd8yj50xzqqWSsNqPRdlOWYs9XXoUNtOC8TSgLGX5Y+ZHsmjrARC0LwvuFfdssg2FrSVhaIYt P6Sf9Umh8nXmxZNLTI6JZRcwFzea43JGDUlllli23G9SSQmiP79Pc9mfTyIiSqqZrZfd6I+4sP1/ n8yTryVGn5LfWO3W5m2ThBvSpu3rELOolyiHO+eCS9PNv7G3C6eE9MWznwzSckm2iVe61ya9IhW+ 3pi+Ga1rVVpallovlpi1ve3Px7mK5/OdSlKYtqylTfH6oXoIYNd8ZXrrmdVrkecoqCQx3ER7s5JI PKP4GhlL1nIn4lSTVNX1JyJjNwSTO5VEcbjcOfusLvv1Jkvs+tl1Vj6zuXRJEodEKWllrQqwxC77 qp7kyOasMMMjKX3WX+OarJYemPtjUaj6mV2vNPLYxUUCh3AMsOhO836dm4AcRBCKCZlmZmZZRlMo yvpBTu2n7/TdHJI34qTRVmvDZV4crfoqaZXldqXcJ44d13F2wYCS6NKsZDaOhzGGXsaYt97VNPN3 wlMltfzSYEnbJzc2aTqrikpCuZCuXHThObqIZd9LUu/2553a5PoqTH2e9y46WszmC0kyifobsWPi QgQtfJOdF020rp7H1gEPmGnn98uPx4vzlFzr0yT8JzzpS5DfUpUgqEVd6usFWrAVbW8N7Kw5pVzR OIo7p/GlJS4poic2iSSEzqKu6/KaGjRiyyp+1XTsE+U4bsHZqskE7IvFcUtEa79ZlL3D9M4DWz0k nkgJD4lZBE+u2d5basGqZNK9JJBzTXG42vuLOeJFKhj0rWNBUNpLjou0NHBMsUxRwmw2PBMEx0pU 003M0nM1qs5AjuTRriZwmsVpr6g++NtxtyUpTO9etJK1uQHNzR2VWh7pNTD6UtT2mTaNktltZZWH rjyRqiO+qSUhnOgpOmcN/PByvgn0CScUZqLW1MiCAg9H8ibxcqqogIPDpiy6bKvHheYJ11EXJaeI R/xk6kdODtPbE4pzfky9htJolIVMW519rn/NNkBg0qcD2va8uTzDg37pPjB4e3nknN/j385shJrw aMx+MTRzzld91tl117Wnm3P08Tanz1oJGUkhTQlXm72T4/SfHVdV9E05E9PzYzIvojNYWaNVliWl IpVKjieS3Nqel2Y69JY6ZFsenOxEWnkzaGk/805174ss/762dPyi5Bsg+0iohs4qqnC4Pf6ew674 T0nWJ/oT4O3LzpVRc02llUXRrfDw8TFEHI6cW3q9kd0hLqkOmonopabbf2WqvGFX5Ovegu/swIkN 8Bl9nu4cMv2CNSHN2hJOac/Ri3Tdy8it+1eqmhOjwjlNLz9E6ZzsHzDV8WD1D0c73POc1PYnHE7L 5K8fiW1MVSR5vZF+9q4S3lH593F1zqOsNra5WzU2OETY1uxu6Dnnj48PO7x/HgvE7nZhVU3avLLo eJ0wHj1R5ci5q+cP0W2uQ7Z9V/RKQGGuF90hoQ18Dd7ydevrXzOqQIYVNCe88/QOChbcqqKgKpz7 PG+jIIwORfKjOfFMSd7uO0kA55ID++ExKJDnspmkrLIz9s7fncSbIapMDybkQcoaTnLzbNjTfVmy e1E54ar+CqTES3bJ4pzoPTHKZbnutGWzqeZUl+lvf3KTb2aLfD2eQRc82njk85PMvQ5J49+jgd83 WYYyQRfceVWtZbUdSaevoDjcibphU+l53etrAVe3UnprfWZ13byYd/43zW88zvR7pc9kXRmb4DVD jk+yHzQ9iRNvx1X8CzCxLJmZUYfkP7GR8kfZGjcw2Kto4K5bFZYbxlK/ZXutCf/xdyRThQkHGEh8 AA==