From 46994290c90d05d382f8dd2922dbbad2f0b29c01 Mon Sep 17 00:00:00 2001 From: Joseph Mearman Date: Sat, 14 Nov 2026 13:28:44 +0000 Subject: [PATCH 1/3] fix(pdf-codec): read a verified subset whose font dictionary names no encoding A typesetter's math italic subset draws a full stop at the glyph it names /colon and a comma at /semicolon, and its /ToUnicode reads each by its name. When the font dictionary carries no /Encoding, the code reaches its glyph through the program's own built-in encoding, which the verified lookup never asked, so a value such as 0.212 was read as 0:212. A code now selects its glyph by the name /Differences gives it, else the named base encoding, else, for a dictionary naming no base encoding, the program's built-in encoding (ISO 32000-1 9.6.6.1), and the program is only opened for a font whose subset has a verified table. BuiltinEncoding gains codeToGlyphName for that. The AdvP4C4E51 subset written this way is added, its five glyphs rendered from the program and checked on a sheet like the others. --- .../docs/verified-glyph-tables/README.md | 3 +- .../advp4c4e51-78448cb717.png | Bin 0 -> 23867 bytes packages/pdf-codec/src/builtin-encoding.ts | 10 +++ packages/pdf-codec/src/font-read.ts | 22 ++++-- .../src/verified-glyph-tables.test.ts | 73 ++++++++++++++++++ .../pdf-codec/src/verified-glyph-tables.ts | 13 ++++ 6 files changed, 114 insertions(+), 7 deletions(-) create mode 100644 packages/pdf-codec/docs/verified-glyph-tables/advp4c4e51-78448cb717.png diff --git a/packages/pdf-codec/docs/verified-glyph-tables/README.md b/packages/pdf-codec/docs/verified-glyph-tables/README.md index 5ff7842cd..881c17b73 100644 --- a/packages/pdf-codec/docs/verified-glyph-tables/README.md +++ b/packages/pdf-codec/docs/verified-glyph-tables/README.md @@ -4,7 +4,7 @@ The glyph sheets behind `src/verified-glyph-tables.ts`: one per verified font su A table is added only for a subset whose glyphs were rendered from the embedded program and checked against the symbol they stand for, so a reviewer can re-check a table by comparing its cells to the shapes. A glyph whose symbol could not be settled from its outline is left unmapped. A table lists glyphs by the program's own glyph name, because these producers share one program between many font dictionaries that assign its glyphs to different codes; the name a dictionary's `/Differences` gives a code selects the glyph. -Both families of subset are the ones a textbook typeset with the Advent 3B2 system embeds: a symbol font laid out like TeX's math symbol font (`AdvMT_SY`, `AdvP4C4E74`), a math italic font (`AdvMT_MI`, `AdvP4C4E51`), a delimiter and large-operator font laid out like TeX's extension font (`AdvP4C4E46`) and a roman font with Greek capitals (`AdvP4C4E59`). A one-glyph subset that names its glyph through `/Encoding /WinAnsiEncoding` instead of `/Differences` (the f483 sheet) is read by the name that base encoding gives its code. The producer writes each glyph's name and `/ToUnicode` entry as if the name were what the glyph draws, so an equals sign is `/onequarter`, a left parenthesis is `/eth` and a size-3 left parenthesis is `/C16`. +Both families of subset are the ones a textbook typeset with the Advent 3B2 system embeds: a symbol font laid out like TeX's math symbol font (`AdvMT_SY`, `AdvP4C4E74`), a math italic font (`AdvMT_MI`, `AdvP4C4E51`), a delimiter and large-operator font laid out like TeX's extension font (`AdvP4C4E46`) and a roman font with Greek capitals (`AdvP4C4E59`). A one-glyph subset that names its glyph through `/Encoding /WinAnsiEncoding` instead of `/Differences` (the f483 sheet) is read by the name that base encoding gives its code, and a subset whose font dictionaries carry no `/Encoding` at all (the 78448 sheet, whose program's built-in encoding is StandardEncoding) by the name the program's own encoding gives it. The producer writes each glyph's name and `/ToUnicode` entry as if the name were what the glyph draws, so an equals sign is `/onequarter`, a left parenthesis is `/eth` and a size-3 left parenthesis is `/C16`. In `AdvP4C4E46` a size variant of a delimiter is read as the character it enlarges (every `(` size as `(`), the corners of an assembled bracket as the Unicode bracket corners, and the large sum, integral, intersection and conjunction as their Unicode n-ary operators. The pieces a tall brace, radical or bracket is assembled from other than the bracket corners, and the short bar `/ffi`, are left unmapped: a piece has no character of its own that the outline alone can settle. @@ -18,6 +18,7 @@ In `AdvP4C4E46` a size variant of a delimiter is read as the character it enlarg | [advp4c4e46-a8442ad73a.png](advp4c4e46-a8442ad73a.png) | AdvP4C4E46 | `a8442ad73af43eb9abec5cb790fe053953caf2cba069038689c1091a8bf1da57` | 22 | /colon, /eight, /equal, /ffi, /greater, /less, /nine, /semicolon, /seven, /six, /t, /u, /v | | [advp4c4e46-f2c12f17af.png](advp4c4e46-f2c12f17af.png) | AdvP4C4E46 | `f2c12f17afd97014ccf6002befb9a7fa5c9156788bb9a616a5f9d31f8b5aaedd` | 17 | /ffi, /t, /u, /v | | [advp4c4e51-93463c42e9.png](advp4c4e51-93463c42e9.png) | AdvP4C4E51 | `93463c42e9491b79f82f761b522ae2de72b6217efccd186930df7237ef8002ef` | 5 | none | +| [advp4c4e51-78448cb717.png](advp4c4e51-78448cb717.png) | AdvP4C4E51 | `78448cb71772342dba968e5467a55b5df184815aabe509ccf2f4ec7b923aebe4` | 5 | none | | [advp4c4e59-967c167a73.png](advp4c4e59-967c167a73.png) | AdvP4C4E59 | `967c167a737966cddc29a62e6f0601efc797d1f9453d0f3df558306b2d8b91e2` | 2 | /C22, /ampersand, /asciitilde, /percent, /period, /underscore | | [advp4c4e74-38c8aa8cce.png](advp4c4e74-38c8aa8cce.png) | AdvP4C4E74 | `38c8aa8ccee56512b9816a6c93c2e2b166166b672560b5f827eef19c43626bd3` | 14 | none | | [advp4c4e74-4061cae07e.png](advp4c4e74-4061cae07e.png) | AdvP4C4E74 | `4061cae07e31ac6441fef12114942a58d0bae5f64a0789932ee703654990a769` | 22 | none | diff --git a/packages/pdf-codec/docs/verified-glyph-tables/advp4c4e51-78448cb717.png b/packages/pdf-codec/docs/verified-glyph-tables/advp4c4e51-78448cb717.png new file mode 100644 index 0000000000000000000000000000000000000000..394c8fc47d904f64a3e05a07f761ac8aadae60d7 GIT binary patch literal 23867 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 R!Hdi(8Y()<>53MY|3B&Cu4w=O literal 0 HcmV?d00001 diff --git a/packages/pdf-codec/src/builtin-encoding.ts b/packages/pdf-codec/src/builtin-encoding.ts index 95e788ed0..a6f92866b 100644 --- a/packages/pdf-codec/src/builtin-encoding.ts +++ b/packages/pdf-codec/src/builtin-encoding.ts @@ -43,6 +43,8 @@ export interface BuiltinEncoding { glyphIdToUnicode: (glyphId: number) => string | undefined; // The glyph the program itself names `name`, through its 'post' table or CFF charset: how a /Differences name the Adobe Glyph List does not know (a subsetter's "g27") still reaches a glyph whose identity the program can state another way. glyphIdOfName: (name: string) => number | undefined; + // The program's own name for the glyph its built-in encoding draws at a code: the name a CFF or Type 1 encoding states for the code, or the charset's or 'post' table's name for the glyph the code reaches. How a font dictionary that names no encoding of its own still selects a glyph by name. + codeToGlyphName: (code: number) => string | undefined; } // The private-use planes, which name no character: reversing a Unicode subtable that maps only these (what a symbol font's own (3, 1) subtable usually is) yields a code point that identifies the glyph within that one font and nothing beyond it, so it is treated as no answer rather than a wrong one. @@ -109,6 +111,14 @@ function encodingFromSources( codeToUnicode: codeUnicode, glyphIdToUnicode: glyphUnicode, glyphIdOfName: (name) => nameToGlyphId?.(name), + codeToGlyphName: (code) => { + const name = codeToName?.(code); + if (name !== undefined) { + return name; + } + const glyphId = codeToGlyphId?.(code); + return glyphId === undefined ? undefined : glyphIdToName?.(glyphId); + }, } : undefined; } diff --git a/packages/pdf-codec/src/font-read.ts b/packages/pdf-codec/src/font-read.ts index c7c6028e3..949ef9c6a 100644 --- a/packages/pdf-codec/src/font-read.ts +++ b/packages/pdf-codec/src/font-read.ts @@ -453,16 +453,26 @@ function buildSimpleFont(fontDict: PdfDict, context: FontReadContext): PdfFont { return undefined; }; + // The glyph a code selects, by name, in a font whose subset has a verified table: the name /Differences gives the code, else the name the named base encoding gives it, else, where the dictionary names no base encoding, the name the embedded program's own built-in encoding gives it, which is then the base encoding (ISO 32000-1 9.6.6.1). Asked only once the table exists, so no other font opens its program for this. + const verifiedTextOf = (code: number): string | undefined => { + const table = verifiedGlyphs(); + if (table === undefined) { + return undefined; + } + const glyphName = + differencesMap.get(code) ?? + (namedBaseGlyphName === undefined + ? programEncoding()?.codeToGlyphName(code) + : namedBaseGlyphName(code)); + return glyphName === undefined ? undefined : table.glyphs.get(glyphName); + }; + const decodeToUnicode = (codes: Uint8Array): string => { let out = ""; let unmapped = 0; for (const code of codes) { - // A glyph of a subset checked against its outlines is read as what it draws, by the name /Differences, or else the named base encoding, gives its code, before the font dictionary's own tables, which that subset's producer wrote wrong. - const glyphName = differencesMap.get(code) ?? namedBaseGlyphName?.(code); - const verified = - glyphName === undefined - ? undefined - : verifiedGlyphs()?.glyphs.get(glyphName); + // A glyph of a subset checked against its outlines is read as what it draws, before the font dictionary's own tables, which that subset's producer wrote wrong. + const verified = verifiedTextOf(code); if (verified !== undefined) { out += verified; continue; diff --git a/packages/pdf-codec/src/verified-glyph-tables.test.ts b/packages/pdf-codec/src/verified-glyph-tables.test.ts index 8e13749b8..c7f3f577d 100644 --- a/packages/pdf-codec/src/verified-glyph-tables.test.ts +++ b/packages/pdf-codec/src/verified-glyph-tables.test.ts @@ -13,6 +13,7 @@ import { pdfRef, pdfStream, } from "./objects"; +import { cffFontWithBuiltinEncoding } from "./test-support/cff"; import { VERIFIED_GLYPH_FAMILIES, VERIFIED_SOURCES, @@ -163,6 +164,78 @@ describe("a font subset with a verified glyph table", () => { }); }); +describe("a verified subset whose font dictionary names no encoding", () => { + // The math italic subset's shape: the program's own encoding puts its glyphs `colon` and `semicolon` at 0x3A and 0x3B, where they draw a full stop and a comma, the font dictionary carries no /Encoding, and /ToUnicode reads each code as the character the glyph's name spells. + const MATH_ITALIC = cffFontWithBuiltinEncoding({ + name: "ABCDEF+AdvP4C4E51", + glyphNames: ["colon", "semicolon"], + encoding: new Map([ + [0x3a, 1], + [0x3b, 2], + ]), + }); + const COLON_AND_SEMICOLON = [0x3a, 0x3b]; + + function readThroughBuiltinEncoding( + tables: ReadonlyMap, + ): string | undefined { + const objects = new Map([ + [ + 9, + pdfStream( + pdfDict({}), + new TextEncoder().encode( + "beginbfchar\n<3A> <003A>\n<3B> <003B>\nendbfchar", + ), + ), + ], + [ + 10, + pdfDict({ + Type: pdfName("FontDescriptor"), + FontName: pdfName("ABCDEF+AdvP4C4E51"), + Flags: pdfNum(4), + FontFile3: pdfRef(11, 0), + }), + ], + [11, pdfStream(pdfDict({ Subtype: pdfName("Type1C") }), MATH_ITALIC)], + ]); + const fontDict = pdfDict({ + Type: pdfName("Font"), + Subtype: pdfName("Type1"), + BaseFont: pdfName("ABCDEF+AdvP4C4E51"), + FirstChar: pdfNum(0x3a), + LastChar: pdfNum(0x3b), + Widths: pdfArray([pdfNum(278), pdfNum(278)]), + FontDescriptor: pdfRef(10, 0), + ToUnicode: pdfRef(9, 0), + }); + const { resolve } = createFontResolver({ + resolver: makeResolver(objects), + sink: NO_DIAGNOSTICS, + verifiedGlyphTables: tables, + }); + return resolve( + "F1", + pdfDict({ Font: pdfDict({ F1: fontDict }) }), + )?.decodeToUnicode(new Uint8Array(COLON_AND_SEMICOLON)); + } + + it("selects the glyph by the name the program's own encoding gives the code", () => { + const tables = new Map([ + [ + sha256Of(MATH_ITALIC), + { family: "AdvP4C4E51", glyphs: { colon: ".", semicolon: "," } }, + ], + ]); + expect(readThroughBuiltinEncoding(tables)).toBe(".,"); + }); + + it("reads the same program through /ToUnicode when no table lists it", () => { + expect(readThroughBuiltinEncoding(new Map())).toBe(":;"); + }); +}); + describe("many font dictionaries sharing one embedded program", () => { const SHARING_FONTS = 30; diff --git a/packages/pdf-codec/src/verified-glyph-tables.ts b/packages/pdf-codec/src/verified-glyph-tables.ts index cdecf4bde..e3a64d361 100644 --- a/packages/pdf-codec/src/verified-glyph-tables.ts +++ b/packages/pdf-codec/src/verified-glyph-tables.ts @@ -268,6 +268,19 @@ export const VERIFIED_SOURCES: ReadonlyMap = }, }, ], + [ + "78448cb71772342dba968e5467a55b5df184815aabe509ccf2f4ec7b923aebe4", + { + family: "AdvP4C4E51", + glyphs: { + colon: ".", + equal: "/", + greater: ">", + less: "<", + semicolon: ",", + }, + }, + ], [ "967c167a737966cddc29a62e6f0601efc797d1f9453d0f3df558306b2d8b91e2", { From dc0461209831b0dbe63535657a625c0f7ecbc622 Mon Sep 17 00:00:00 2001 From: Joseph Mearman Date: Sat, 14 Nov 2026 13:29:03 +0000 Subject: [PATCH 2/3] fix(pdf-codec): read a Century Schoolbook subset Distiller numbers g Acrobat Distiller converts a TrueType Century Schoolbook to a CFF subset naming each glyph g followed by its glyph id in the face, the lower-case spelling of the G names the optimiser writes. Neither the face nor the spelling was known, so every code of such a subset with no /ToUnicode read as U+FFFD. The numbered-glyph name now matches either case, and the generated glyph orders carry the four Century Schoolbook faces, taken from Microsoft's release; the twelve faces already carried regenerate byte for byte. The width agreement check still decides whether a subset is the face. The package README also states how a verified subset whose dictionary names no encoding selects its glyph. --- packages/pdf-codec/README.md | 4 +- .../generate-core-font-glyph-orders.mjs | 6 +- .../pdf-codec/src/core-font-glyph-orders.ts | 12 ++-- .../src/core-font-numbered-glyphs.test.ts | 58 +++++++++++++++++++ packages/pdf-codec/src/font-read.ts | 2 +- .../src/glyph-data/core-font-glyph-orders.ts | 2 +- 6 files changed, 75 insertions(+), 9 deletions(-) diff --git a/packages/pdf-codec/README.md b/packages/pdf-codec/README.md index 670742843..78a967458 100644 --- a/packages/pdf-codec/README.md +++ b/packages/pdf-codec/README.md @@ -334,9 +334,9 @@ A TrueType subset can lose its glyph names and its `cmap` both and keep nothing A `/ToUnicode` CMap that a producer writes for the Symbol font or one of the Windows dingbat fonts (Word does, for a bullet, a tick or an arrow it draws in them) gives each glyph the private-use code point its 8-bit code makes in the 0xF000 range, which identifies the glyph in that one font and nothing else: 0xFC is a check mark in Wingdings and a piece of a right brace in Symbol. `symbol-font-private-use.ts` reads such a code point as the character the named font draws at that code, applied to the text a `/ToUnicode` CMap gave for a Symbol, Wingdings, Wingdings 2, Wingdings 3 or Webdings font, by name (`Wingdings 2` and `Wingdings2` alike), and to no other font. Symbol is recognised as `Symbol`, `SymbolMT`, `SymbolOOEnc` and MathType's `EuclidSymbol` (read in Symbol's encoding on the evidence of three checked glyphs, the rest of its layout assumed), each also with an `-OV-` variant tag at the end (`SymbolMT-OV-JQGJHA`) or a mixed-case pseudo subset tag run straight onto the front with no `+` or separator (`SmmfqrSymbol`), which is looked past only when what follows it is one of those names, so `SymbolicSans`, `SegoeUISymbol` or `Lucida Symbol` is not taken for Symbol. A font whose `/BaseFont` names no symbol font is identified by its embedded program's own PostScript name instead, read only for text that holds a private-use code point. Every `/BaseFont` spelling of Symbol also gets Symbol's built-in encoding for a code no `/ToUnicode` covers; a font recognised only through its program's name does not, since that name is read only for `/ToUnicode` text. Symbol is read through its published encoding, and the four dingbat fonts through `wingdings-characters.ts` and `dingbat-characters.ts`, tables of Unicode's own Wingdings and Webdings document (WG2 N4384), whose source-reference list is vendored under `assets/unicode-wingdings/` and checked against every table entry. A code the font has no character at, and ZapfDingbats, stay as the producer wrote them. The pieces a tall bracket, parenthesis or brace is assembled from, the integral and arrow extensions and the serif and sans-serif copyright, registered and trade mark signs are glyphs the Adobe Glyph List gives private-use code points (`parenlefttp` is U+F8EB) although Unicode encodes them (U+239B): `glyph-names.ts` resolves those names to the Unicode characters on every route a glyph name takes (Symbol's built-in encoding, `/Differences`, an embedded program's glyph names), and a Symbol font's `/ToUnicode` value at one of the list's private-use code points is read as the same character. `radicalex`, which Unicode does not encode, keeps its private-use code point. -Two ways a producer names a core face other than the PostScript name the face's own tables carry are read through the same carried glyph order. A TrueType program Windows-era producers embed under the face's Windows name (`TimesNewRoman`, `Arial,Bold`) is the face `TimesNewRomanPSMT` or `Arial-BoldMT`, still accepted glyph by glyph against the program's own advance widths. And Adobe Acrobat's optimiser rewrites a TrueType face as a CFF subset that names each glyph `G` followed by its glyph id in the face (`G36` is the capital A of Times New Roman) under a font name carrying a size suffix (`Times.New.Roman092`, `Arial.Bold0133`): `coreFaceTextsOfNumberedGlyphs` reads those names through the face's order, but only for a font whose dictionary widths agree with the face's advances over at least five numbered glyphs and nine in ten of them, so a subset of another face, or one too small to tell, is read as before. The Symbol face and the Type 3 fonts such producers also write are not covered: the first has no carried order, and a Type 3 glyph is a drawing procedure with no character. +Two ways a producer names a core face other than the PostScript name the face's own tables carry are read through the same carried glyph order. A TrueType program Windows-era producers embed under the face's Windows name (`TimesNewRoman`, `Arial,Bold`) is the face `TimesNewRomanPSMT` or `Arial-BoldMT`, still accepted glyph by glyph against the program's own advance widths. And Adobe Acrobat's optimiser rewrites a TrueType face as a CFF subset that names each glyph `G` followed by its glyph id in the face (`G36` is the capital A of Times New Roman) under a font name carrying a size suffix (`Times.New.Roman092`, `Arial.Bold0133`), as Acrobat Distiller does with a lower-case `g` for Century Schoolbook, the face of many standards documents written in Word (`g36` under `CenturySchoolbook-Bold`), whose order is carried too: `coreFaceTextsOfNumberedGlyphs` reads those names through the face's order, but only for a font whose dictionary widths agree with the face's advances over at least five numbered glyphs and nine in ten of them, so a subset of another face, or one too small to tell, is read as before. The Symbol face and the Type 3 fonts such producers also write are not covered: the first has no carried order, and a Type 3 glyph is a drawing procedure with no character. -Some producers write the font dictionary's own tables wrong for a symbol subset: a typesetter's Type 1C math fonts give each glyph an arbitrary name, assign the names to codes with `/Differences`, and have a `/ToUnicode` CMap read each name as the character it spells, so an equals sign is read as `¼` and an omega as `!`, from tables that are valid and wrong. `verified-glyph-tables.ts` holds tables for the exact subsets whose glyphs were rendered from the embedded program and checked one by one (`docs/verified-glyph-tables/`), each keyed by the SHA-256 of the decoded font program; a glyph of such a subset is read as what it draws, before the font dictionary's tables, and every other subset, family and code is read as before. +Some producers write the font dictionary's own tables wrong for a symbol subset: a typesetter's Type 1C math fonts give each glyph an arbitrary name, assign the names to codes with `/Differences`, and have a `/ToUnicode` CMap read each name as the character it spells, so an equals sign is read as `¼` and an omega as `!`, from tables that are valid and wrong. `verified-glyph-tables.ts` holds tables for the exact subsets whose glyphs were rendered from the embedded program and checked one by one (`docs/verified-glyph-tables/`), each keyed by the SHA-256 of the decoded font program; a glyph of such a subset is read as what it draws, before the font dictionary's tables, and every other subset, family and code is read as before. The glyph a code selects is named by `/Differences`, else by the named base encoding, else, for a dictionary that names no base encoding, by the program's own built-in encoding, which is then the base encoding. **Where nothing states an answer, the answer is the replacement character plus a `text/unmapped-encoding` diagnostic, never a guess.** Cases that reach it in practice: a symbolic font with no embedded program and no `/ToUnicode`; a subsetted font that both strips its glyph names and maps its glyphs only from private-use code points; a nameless, `cmap`-less subset of a face whose glyph order this package does not carry, or of a carried face at a glyph its recorded releases do not number; and a composite font whose `/Encoding` is a CMap other than Identity-H or Identity-V, whose codes reach CIDs this reader does not map. A private-use code point identifies a glyph inside one font and says nothing about the character it draws, so it is treated as no answer rather than a wrong one. diff --git a/packages/pdf-codec/scripts/generate-core-font-glyph-orders.mjs b/packages/pdf-codec/scripts/generate-core-font-glyph-orders.mjs index b4ff009bb..11e4ed0cc 100644 --- a/packages/pdf-codec/scripts/generate-core-font-glyph-orders.mjs +++ b/packages/pdf-codec/scripts/generate-core-font-glyph-orders.mjs @@ -20,7 +20,7 @@ const { readCmapSubtables } = await load('cmap-table'); const { parseHmtx } = await load('hmtx-table'); const { parseHead, parseName } = await load('font-tables'); -// The faces producers commonly embed as composite subsets that keep the face's own glyph numbering while dropping 'cmap' and 'post'. A reader applies a face's order to a glyph only where the embedded program's advance width for that glyph equals the one recorded here (see src/core-font-glyph-orders.ts). +// The faces producers commonly embed as composite subsets that keep the face's own glyph numbering while dropping 'cmap' and 'post', or convert to CFF subsets naming each glyph by its id in the face (Century Schoolbook, the face of many standards documents distilled from Word). A reader applies a face's order to a glyph only where the embedded program's advance width for that glyph equals the one recorded here (see src/core-font-glyph-orders.ts). const FACES = [ 'ArialMT', 'Arial-BoldMT', @@ -34,6 +34,10 @@ const FACES = [ 'CourierNewPS-BoldMT', 'CourierNewPS-ItalicMT', 'CourierNewPS-BoldItalicMT', + 'CenturySchoolbook', + 'CenturySchoolbook-Bold', + 'CenturySchoolbook-Italic', + 'CenturySchoolbook-BoldItalic', ]; const directories = process.argv.slice(2); diff --git a/packages/pdf-codec/src/core-font-glyph-orders.ts b/packages/pdf-codec/src/core-font-glyph-orders.ts index 6aa1ef909..825b5bf49 100644 --- a/packages/pdf-codec/src/core-font-glyph-orders.ts +++ b/packages/pdf-codec/src/core-font-glyph-orders.ts @@ -2,7 +2,7 @@ import { inflateSync } from "fflate"; import { base64ToBytes } from "byte-codec"; import { CORE_FONT_GLYPH_ORDERS_DEFLATED_BASE64 } from "./glyph-data/core-font-glyph-orders"; -// The glyph order of the core faces producers most often embed (the Arial, Times New Roman and Courier New families), for a program that keeps a face's own glyph numbering but carries nothing that says what any glyph draws: no 'cmap', no glyph names. A composite font's CIDs then address glyphs whose characters only the face's published order states, and readers such as Acrobat carry the same knowledge for the same reason. +// The glyph order of the core faces producers most often embed (the Arial, Times New Roman and Courier New families, and Century Schoolbook), for a program that keeps a face's own glyph numbering but carries nothing that says what any glyph draws: no 'cmap', no glyph names. A composite font's CIDs then address glyphs whose characters only the face's published order states, and readers such as Acrobat carry the same knowledge for the same reason. // // Knowing the order by the face's name alone would be a guess the first time a subsetter renumbered the glyphs, a producer embedded another face under that name, or a release of the face moved one glyph. So each glyph is accepted only where the program's own advance width for it equals the face's (in the same units per em), which every one of those cases breaks: a renumbered or foreign program puts other widths at those glyph ids, and a glyph a release redrew to a different width stops matching. Compared across two releases of each of these faces, a few glyph ids per face changed advance width and every other glyph kept both its id and its width, so the check refuses those few and costs nothing else. // @@ -114,6 +114,10 @@ const CORE_FACE_BY_SPELLING: ReadonlyMap = new Map([ ["couriernewpsitalicmt", "CourierNewPS-ItalicMT"], ["couriernewbolditalic", "CourierNewPS-BoldItalicMT"], ["couriernewpsbolditalicmt", "CourierNewPS-BoldItalicMT"], + ["centuryschoolbook", "CenturySchoolbook"], + ["centuryschoolbookbold", "CenturySchoolbook-Bold"], + ["centuryschoolbookitalic", "CenturySchoolbook-Italic"], + ["centuryschoolbookbolditalic", "CenturySchoolbook-BoldItalic"], ]); const ZERO_CODE = 48; // "0" @@ -166,8 +170,8 @@ export function coreFaceNameOfFontName(fontName: string): string | undefined { return CORE_FACE_BY_SPELLING.get(spelled); } -// Adobe Acrobat's optimiser converts a TrueType face to a CFF subset and names each glyph G followed by its glyph id in the face: G36 is the glyph the face numbers 36. -const NUMBERED_GLYPH_NAME = /^G(\d+)$/u; +// Adobe Acrobat's optimiser converts a TrueType face to a CFF subset and names each glyph G followed by its glyph id in the face: G36 is the glyph the face numbers 36. Acrobat Distiller does the same with a lower-case g (g36). +const NUMBERED_GLYPH_NAME = /^[Gg](\d+)$/u; // How far, in thousandths of an em, a font dictionary's width for a glyph may be from the face's advance for it and still agree: the dictionary's widths are the converted program's, which this producer rounds and hints, and measured against the face they differ by up to 22 (a 489 for a 500, a 507 for a 500); two core faces differ by far more on most letters (a capital G is 722 in Times New Roman and 778 in Arial). const WIDTH_AGREEMENT_TOLERANCE = 25; @@ -177,7 +181,7 @@ const MIN_AGREEING_SHARE = 0.9; const MIN_NUMBERED_GLYPHS = 5; /** - * What a core face draws at the glyphs of a CFF subset that names each `G`, accepted for the whole font only when the font dictionary's widths agree with the face's advances over at least `MIN_NUMBERED_GLYPHS` glyphs and `MIN_AGREEING_SHARE` of them, so a subset of any other face, or of another release of this one, is read as before. + * What a core face draws at the glyphs of a CFF subset that names each `G` or `g`, accepted for the whole font only when the font dictionary's widths agree with the face's advances over at least `MIN_NUMBERED_GLYPHS` glyphs and `MIN_AGREEING_SHARE` of them, so a subset of any other face, or of another release of this one, is read as before. * @param fontName - The font's `/BaseFont`. * @param glyphs - Each glyph of the font a `/Differences` array names, with the width, in thousandths of an em, the dictionary gives its code. * @returns The character each numbered glyph name draws, or `undefined` when the font is not taken for a core face. diff --git a/packages/pdf-codec/src/core-font-numbered-glyphs.test.ts b/packages/pdf-codec/src/core-font-numbered-glyphs.test.ts index 3b912a2e7..6abb35693 100644 --- a/packages/pdf-codec/src/core-font-numbered-glyphs.test.ts +++ b/packages/pdf-codec/src/core-font-numbered-glyphs.test.ts @@ -32,6 +32,8 @@ describe("coreFaceNameOfFontName", () => { ["EBLKKG+Arial086.75", "ArialMT"], ["ArialMT", "ArialMT"], ["CourierNewPS-BoldItalicMT", "CourierNewPS-BoldItalicMT"], + ["LHMEIK+CenturySchoolbook-Bold", "CenturySchoolbook-Bold"], + ["CenturySchoolbook,Italic", "CenturySchoolbook-Italic"], ])("reads %s as %s", (fontName, face) => { expect(coreFaceNameOfFontName(fontName)).toBe(face); }); @@ -117,3 +119,59 @@ describe("a CFF subset that numbers its glyphs after a core face", () => { ); }); }); + +describe("a CFF subset Acrobat Distiller numbers after Century Schoolbook", () => { + // Distiller names each glyph g, lower case. The glyphs of a made-up line in Century Schoolbook Bold, with the widths the face gives them: B, R, I, D, G, E, the space, T and S. + const DISTILLED = [ + { name: "g37", width: 778 }, + { name: "g53", width: 815 }, + { name: "g44", width: 444 }, + { name: "g39", width: 833 }, + { name: "g42", width: 833 }, + { name: "g40", width: 759 }, + { name: "g3", width: 287 }, + { name: "g55", width: 722 }, + { name: "g54", width: 667 }, + ] as const; + + function read( + baseFont: string, + codes: readonly number[], + ): string | undefined { + const fontDict = pdfDict({ + Type: pdfName("Font"), + Subtype: pdfName("Type1"), + BaseFont: pdfName(baseFont), + FirstChar: pdfNum(1), + LastChar: pdfNum(DISTILLED.length), + Widths: pdfArray(DISTILLED.map(({ width }) => pdfNum(width))), + Encoding: pdfDict({ + Differences: pdfArray([ + pdfNum(1), + ...DISTILLED.map(({ name }) => pdfName(name)), + ]), + }), + }); + const { resolve } = createFontResolver({ + resolver: makeResolver(new Map()), + sink: NO_DIAGNOSTICS, + }); + return resolve( + "F1", + pdfDict({ Font: pdfDict({ F1: fontDict }) }), + )?.decodeToUnicode(new Uint8Array(codes)); + } + + // Codes 1 to 9 are the glyphs in the order above. + const LINE = [1, 2, 3, 4, 5, 6, 7, 8, 6, 9, 8]; + + it("is read through the face's glyph order", () => { + expect(read("LHMEIK+CenturySchoolbook-Bold", LINE)).toBe("BRIDGE TEST"); + }); + + it("is refused under another face's name, whose advances disagree", () => { + expect(read("LHMEIK+CenturySchoolbook-Italic", LINE)).toBe( + "\uFFFD".repeat(LINE.length), + ); + }); +}); diff --git a/packages/pdf-codec/src/font-read.ts b/packages/pdf-codec/src/font-read.ts index 949ef9c6a..703759aa0 100644 --- a/packages/pdf-codec/src/font-read.ts +++ b/packages/pdf-codec/src/font-read.ts @@ -384,7 +384,7 @@ function buildSimpleFont(fontDict: PdfDict, context: FontReadContext): PdfFont { const programEncoding = lazyFontProgram(descriptor, baseFont, context); // A code /Differences names is drawn with the glyph of that name, so only the name can say what it is: through the Adobe Glyph List, or, for a name the list does not know (a subsetter's "g27"), through the embedded program's own glyph of that name and whatever the program states about that glyph. The base encoding and the program's built-in encoding describe the glyph the code reached before /Differences replaced it, so neither is consulted for such a code; reading the code through them anyway would report the character the producer overrode. - // What the core face a CFF subset numbers its glyphs after draws at each of them, read once and only for a font that names glyphs `G`. + // What the core face a CFF subset numbers its glyphs after draws at each of them, read once and only for a font that names glyphs `G` or `g`. let numberedTexts: ReadonlyMap | undefined; const numberedCoreFaceTexts = (): ReadonlyMap => { numberedTexts ??= diff --git a/packages/pdf-codec/src/glyph-data/core-font-glyph-orders.ts b/packages/pdf-codec/src/glyph-data/core-font-glyph-orders.ts index 0d82f77c0..731e78e30 100644 --- a/packages/pdf-codec/src/glyph-data/core-font-glyph-orders.ts +++ b/packages/pdf-codec/src/glyph-data/core-font-glyph-orders.ts @@ -3,4 +3,4 @@ // // Each face's glyph id -> text order and advance widths, DEFLATE-compressed (fflate's raw deflateSync) and base64-encoded; see the generator's header comment for the binary layout and src/core-font-glyph-orders.ts for the reader. export const CORE_FONT_GLYPH_ORDERS_DEFLATED_BASE64 = - '7J0FuFXVorb3mrU2dh17rb1Bxdo2FmJ3F3YLqCB2gIpid4sJdqDYipSI3d3diq3YsXH7f9+71pju6YFjnHPvf+995FnPxzfHHHPMMcfMUe9umKq88r69d+q7fvfGhmkHNWQN/hctW2poaEY7op2iF6VzJftJ50bnKVekndPNpfOWjpPOFw2Tzo8uEHvtgsl10hZSWIjwhfGLoIuSzmLo4ugSaBd0SXQpdGl0GXRZtCspLId2Yy/LoyugKxJnpcYm6crkcBV01fRB6Wro6oSskbwrXTNzOmsRvjZprpM0SNclznqktn7m/G9AnA2JvxFrN8ZvQvimhHQnzc0I2ZyQLcqnSLfEb4VuTZxt2Ne26Hbo9vHd0h3Y446U2E74ndEe5Konvhe6C1vtit8N7V3yfvuguxO/L34P8r8ncfZC90b3QfdlX/sRf3/SPIDwAwnpx7H0xx+EHoweErm0B0QzSQ/FH0b538cx3o8+yLYP45/Gv0CJvYZ/m728hb6Dvoe+i76PfsC+PsJ/iH6MfoJ+Rm4/RT9Hv0C/ZO3X6FfoN+h36LfoT+iPaCs60drcjL8pXkJ6Gf5ydChrO0WPy49I1pO+yXm8IX1feo21Y6dG53Y45Xm1tdOOSU/5Bwh/ycfeqZoOl7/Z4Z16or2IcyV7uS0ZopAo/kY6vWN2mjY7p4FoC0aLKcKw6DvpmOhT7a5zNo/8eG7GH8jMneilZOA6n45Os3vb0plOvNNapJMlzvC17O52Dqoz2buL03Qv+ryzWtrE4aVNfQE3z0jMmRzSPKfTb66gs/oCa56Ny+x7pz/PI858wy8+caX+Tq15tZL1OlJYlq26WltLjtMaWZs7ksPZfPqaZyfNKjEXJW/3kKtH0LvRR9GH0Mc56U+gT6KPoc9ysT2HPoO+woX3KvqytbSYY0YPeF/Ra+jD6Evoy+grlOco/Ovoq+iD1tLKznlpFee5tKPzU9qJYz/U56J0GBfwVdwmT7HfCZT86+T8Z9a+gW+jBGbgJnoRHc1+b0FvRe/IHD4WHWdt5uIsVTlfTfhFfUSl7cnJDuQk40jL+KnwU+OnJyc3JrtLR3IsEVvFpJPgU/w0bDVt8ol0OvysrJ2NtbPj58DziC51pTSWx68QbSblsVxayQ+KEo/i0mqErIlfC78RR7Exvjvhm5GrLfFb4bdmX9uQ/50p4R4cb098r9jhexKfB11pbzwPutJBxOHxVToEP8A+PivZTXqe9x5fle0svTm5RDo82V96W3yG9N5kgvS+eH7pA+miKvlZXG7N3bh6B0YqmeahjXfprjzdV2zHMxze8Uz8WfhB+LPxV1s7NZWfl86faqtOOyXXlhrmihKFzDWdz/5czfiO1nkaUq2dJ0q11TxT4adDZ0JnRedE50Zb0C5oN3QjdGN0E3RTtDu6Gbo5ugW6JboVujW6Dbotuh26PboDuiO6E7oz2gPtifZCd0F3RXdDe6N90N3Rvujh6NHo8ejJ6OnoGeiZ6Fmpy+cSSuk6l/A8t5R1LuYZg45F70MfJc5L6MvWzl0bF5Qu16jz2LlbWVdp55UypdB5FXTHZCVpj9TaK9E56rxL8g9pH5+7zrs7Tmnx9G3pErGekKW1nWbz4qXDpUtE8h3TsuJ3nDE6R3u8lP0Oi16QXos+Sch4+1IDV3WJq7SRK7YDV+kU+CnxMxCH53BpJvw/8DPjZ8HPyR1UwTfjea6WOuH5hCvNTZrz4Dvj58XPx300P7oAuiDKJ1xpIZRPuNIi3N1dyNWS+KXIw9KELIMuR5rdWLs6e1mDkHXSh6Xr4tcjV+vjN8BviN+c+Ftwv29LytuR5i7cs7uSh92I05v4ffC74/vi98Dvi98Pv7/fYqUDCDmQNPuR5kBy+BMhfAaUJvLW+9lv1VIbufrF+42P836rhzud6hFOp3ok/ij80fhj8F85terXPBnm4F22Au+yK5x+x4UTfUJ03MZP747botuh22fXNUTD9NO+jkaPQY9Nt5Aen60hPSHTJ0F8YjyD9ORscemp2UvS07JUerr3FZ/hvcdnooPSLaVn48/hKM51DuPzfSzxBYQPJs4QfyLGF7L2olQfP/HFPA8vIeRSYl6efCW9gnSuJGQoenV2o/SatFU6jJSvJfw6nqLX8/y8wcce30gOb0p2lN6SXCC9lSfwiFiViHgkcUaho4k5hrW3o2P9aRTfgR8Xny29k5h3Jyr5+J74Ven9pPxg4vw/5M+n+OFsRekjpPYoax9jq8fxT3htUnJukyjTUyKJEz0HksTP5CQlPPMRJWW00XtPOjQeIJ2iUXd3MmWmuziZKrlGOk3qkGnZdjq2nd5Pj4Q7N5mRlGdK9bRJ/kHIzOUe0ln8HEhmZavZ0NlJbQ62ndPnJan4LCS85ZMm4jSTQkfCO/mMJHOx97kz6zys7Zz6iOZNvd/5/HxL5i/r6ZQskNkv6KdT0sJeFiLNhTmiRUiTClqyWKJyThb3kzBZwu+4pIvfUwkVtGSpdGvp0rFDlkn6S5dFu8bey3LE7JbaL+93ZbICW61IOayEX5nyXCX2Ma6KXy3zHlfHr8He10z0lE7WypzC2qxdx+/BZF3yvB5r1/eTOdnAz+RkQ9LnKyLZBN2UnHcnzmakvLmvh2QLzumW+K3KPsatM+d2G7balqPYnvg7kP/T44+kZ8Tr6F7+B2/zmRt9Hd6VHqMn+E0Nfo7fjN6C3ooOR29DR6Aj0VHoaPR2dCx6Bzounk56J/6uSNdzejf+HvRe5zx9KjlC+rSOpiF9JlbtIH02mV76XPK09PnSj9IX4mmlLyaPSF9KRklfJvyVZEbpq/FN0tdi3Snp68R5I3lS+iZx3oqekb6dnCd9J+kmfTc5XvpesoP0/fhm6fj4OekHyS7SD0nzo/RU6cfp3NIJsZ4Y6ZfoV+jXJV2r6TexawTDsmMbSj9GyoxKL5mxZkZhXlPJxMNjzFi8agrNyVrSBZx+64JoC7oQurBLo3URdFF0MZdM6+IumdYlXDKtXVwyrUtG60qX8nlsXcZl0rosIV2d/9blXCat3djjCi6N1pVcDq0ruxxaV3UJtK7mEmhdw8feuqaPvXUttl2bnKzjY29d12XYuh55WJ80N2CrDZPBOvapfB6bp0anQae1ZlNFepplc6BN0SvSjvH60pVKV0vXJc566ProBuiG6Eboxugm6I7JktKd0J3RHmhPtBe6C7oruhvaG+2D7k5O9kiWdOuQ76/s+WiVmvmGCN+i34UIv/707zch+S+dI/fa9rD0NhXLFuiWJVUeW7cqfdM+vuIcywk9xPtqHZAsLz3Ump3nW7L1JGt2TTZQ/rTygdLT43mlZyRVhd9I+FmEDyL8bMIfS+eQ/zm5rSGefFYn9Ss1TNzexTtxB3RHdCd053DUOqELcFoXRBdCF0Zb0D3RvdA+6O5oX3QPyq/9P9XR+H74Rd8nfyq3f/igfl7B5/rnFaNTHJJ8XmpoO5xrr5OvvbYjS/pSzebCH42fO9Z7sO1Yq1oiHH484Z1dsG0nJjqhbSf5hLadbM3mJc6pxJnPp7vtdPQM4pxJnPmjVeQHuR6XLcDac9BziXMecRYk5AJ0MOFDCG/xRdJ2kS+Stot9ebRdwkWyEOGXEX454VcQzhOj7SrChxJ+NeGLRLfKD7Nmi+Kvwy/my6ztBi62xfE34ZfIzpS/Bb010RdF23Br1oWQEehIwkcRvmSjvoHbxqC3Z/dLx1qzpQgZh95J+F2EL50Mlb8HvRe9z5otg38AfRB9iPBlE72X2x6J9X3V9ihH95gv+6wr4U8Q/iThTxG+crah/DPos5GeXW3PRbMrfBXSfAF9kfCXCF/VT8W2V9BXnULba6SzWjK1/Bvom5zrt3hqrR7pWdr2Dvou8d8j/hrkYTz6AefxQ87jmr4GWq/lGhjn3LZeT/y1uN4+53pbm2tsgq+xbB38V/atbTxAfiG1bzne75InpN/jf8D/iP8J34qfmDzx61Or/YOr/eIkV7X/989x/sf+dI/Xfv+pBPV40nNpOledLslek16a6lIv3ejP49JN6Tb/XFr6cOowqUA9jNstNl+b6OR23JQqUndVkf78P6VZU+WxZub6Exu7QncJFbpL/fitXoan2a16BZ6W2+pVeFqJq1fjr8EPw9PcWr0Ofz3+BvyN+JvwN+Nvwd+KH46/DT8CTxWpOgo/Gj8GT0NudSz+Dvw4PFWkKk271bvxNKVW78XTVl+9H/8A/kH8Q1R1H+bYH8E/in/MFZDq48R5Av8k/in803gaWqvP4ml6rT6Pp+W/+iKelvDqy/hXfLVUX/XVUn0N/zr+Dfyb+Lfwb+Pfwb+Lf4/qNj0F1fH4D/Af+qqrfpRuI/0Y/wn+U/xn+M/xX+An4L/Ef0M5fOvP/up3+O/xP+B/pNHgcZoLnqC5gAbn0lM0IzxNc8EzhD9LU8Nz+OfxL+BfxL+ErzVBv4KnUbr0WrJf8dJNzqQ6cxZVmHOoMJ5LtesCKomDqaQMwV+Iv4zq2+VUWKh0JzdShbkJfzOeayyh6p2Mono4mmrUGDzXUokmhWgrtvqQiie9MNmefKfpQd0Qzd3A62AvvyBab+XBexs6Eh2NjkNv58H+j2je+oHVGzqyTflM7Y5uhu6N7uMXR+vGfCrsW7pahSezXzAHBHNgfEADr4N+wfTXtyUvhYPI567obuShN3k4mJAd0B0J34nwQwjZFO1O+GaED1DVTT8dL4uHFhcHEr8H2pOtehF+OCHboNsSvh3hRyRHqPasCrF+WjyyuHgUX7n9+Mrtz1fuQYQfTfh+hO9P+AGEH1Pc/DiiDSTa4UQ7gvDj/fXSegLfMNIGzInBnBTMyUQ7Bn8K/ij8qfjj8KeFyKcHcwZf4KfwIXRm/FED5qxgBgVzdjDnBHNuMOcHc0F2ptJQC4F+WhxcXBxSXLyw8eEG/bL79dPiRcXFi5OhDXwLXZJsrYYulxKfEJf6Iye7TBUm/cIFfHlx8QrHad0d7evPntY9CL+yGO0qIuyF7k20fQgfGnZ9dTDDOqzQoF95Jf20eG02sKF8oPKjFh0tXpc82aCfFsnh9VQ5n0Ofp7byAuE3FKPdVEzkZuo4g6njDGGrCwm/pRjtVqKdS7TziHY+4cOL0W5Lpm7Qz3eZv99GFBdHFhdHFRdH+4JcMr9BxnA1Xkwl8Xb8pfixxWh3sChzZ/GSvotPwSv5FLw7dvHeg96L3hfu+vutrW/jH8C/gn8Q/xL+Ifxr+Ifx7+IfCYk8SuCb+MfDY+QJTJ7PJ0Pkp6g8vs8353hucL5gs6fDhs9Q1NQ9s2fxnKPsOUrpBZ5yL6IvoS+jr6Cvoq+hrzdOlL7ReL30TULeQt9G30HfRd9D3y+5wj7e3cTZB4R8iH7kZufsY/wn6GfoT8XbqrV4H00s3j4/Ux9s85d861Wcmqs59mui02tF9OuPK0qrKjSDVP3MHyvTFH+lZrYGfW//IfVVEak2oXdBsrXMWzb6bi8dzkvqiEytOqUj3YZZOoqQo/HH4I/llXocejwv7hPwJ2YHS08i5snEPMU9faVTea2f7vbY0hn0NZzFC31Q0iY9uzyV9Bxe9Ofy0j+P+OeT8gWED8YPKTdLaUsvXUT6tKWXLsvUAla63O35pSuyDlI+HUt8OpZoSy/RM1i6xi3tpWHxlNJr2dd15Od6/A34m93eXrqFvdyaLSwdzra3sXYEfiR+FDo62VY6Bq294seid7j9tjQu1qiAEp+LpbvcW126O95Aeo/7Iku0N5bum8I9Mvd38B4faPS4ggcbdUmXHnIbdenhWO3zpUdY+2hZ7WClxzJ9VJReJ036uEtv8nkj8xaLjAApvUOHy7t0uLxHQfFFVxqP54uu9CHxP+KgPiacESClT/Gf4T/nML/gACdwOr4kw1+Rpa/J8DfEZwRI6btGdamUvqeof6AYGQ2i1kftK6IzLqJDPKJDPKJDPKJDPMrwZXwjQwg6oFOgU6JTeV/R1MSZBj8tng70aHqGEMyAnxE/E55OvWhmPJ16EV3t0Ww+9mh2H2M0B+nP6SONKvFh0irxGQAQNadXSTsl+kCK5kqOlc7NVvOQAqO2Irr8ovnw8+MXIIcL1k9Q1MLiQqxaGL8IflE8A7eixdl8CZLdiBBa3SNa3aNN0e6spdU92pyQLdAt0a1TvfejbXwFRtui26VqPYi2T9RqHe3AYe5ITIZCRTu7fyHqkUTSnskXUoZCRbugDIWKdvOpjxgKFfWJXpbuHl0k7RvtKd2D8D2Ts6R7+bqN9kb3QfclBXoMo/2TvlKGQkUHZptK+7m3KOrv9t7oIE7Zwegh6AD0UPQwdCB6uD/goyPQIymHo8jD0b7LomPwx0aPSulhjI5HT2C/JyYnS09yX1V0Mtuewok+FX9aMp/0dPwZSXfpmVwSZ6GDCGe8QXQOei7KOIfofPfpRBdQzoMp1SGuMkQXxnqSRBcR8+J4Oekl5ORSQi5DLy+PlF7hj5noykY9o6KrUn0KRkPjvaRXu18muiabUzosVRt7dG3qvVwXvyO9PllGelOs53Z0M3pLSbehPiVVwdF7xXobOiL6WDoy9hkcFakPMRrtoYbRGA9HjG6n3Maid6DjKO070bsi9WVEd6M8waJ70fvQ+9GHiPkI+ij6GPo4+gT6JPoUZ+Rp9BlCnkWfQ59HX0BfRN9A30TfigZJ39b4oIbonUh9DdG7kXpFo/fI2/vu5YnGox+gH6IfoR+Twifop+hn6OfRsFjb8hufbJH7D9r5D9v5j4IfL23n823l823l823ltW1U8/F0tcAP2iUinycinycinycinyeiY6wFftguEfk8Efk8Efk8Efk8ERVRLfCjdonI54nI54nI54nI54mohBXoAgmJ1HwtkZqvJVLztURqvpaIfUgkL9iazzfMC7PmayfCEdrFz8uw5vNt8zKs+XyntTJ0yu0Sycuw5vNE8jKs+TyRWhk6S+0Sycuw5vNE8jKs+TyRWhn6WEIiNV9LpOZridR8LZGaryViHxLJy7Dm80Ty8qz5PJH84rQPieQFW/N5Inlh1nztRDiwXfy8DGs+32lehjWf77RWhk6tXSJ5GdZ8nkhehjWfJ1IrQ2cjJFLztURqvpZIzdcSqflaIvYhkbwMaz5PJC/Dms8TycvQPiSSl2HN54nkF2fN54nkF6d9SCQv2JrPE8kLtuZrJ8KmXfy8DGs+j5+XYc3nO62VoVMIidR8LZGaryVS87VEar6WiH1IJC/Dms8Tycuw5vNE8jK0D4nkZVjzeSJ5GdZ8nkhehvYhkbwMaz5PJC/Dms8TyS9O+5BIXrA1nyeSF2zNKxE1jEc0jydoitK0H5dRNfBLp0CnROnFjunFjunFjunFjqdDp0dnQGdEZ0L/gc6MzoLOis6Gzo7Ogc6JVlBVIaVNaDPaEe2Ezo3Og3ZG1dQonQ+dH6VDNqZDNqYTNqZbNqZbNl4EXRRdDF0cXQLtgi6JLoUujS6DLot2RZdDu6HLoyugK6IroSujq6Croquhq6NroGuia6Fro+ugjAGIGQMQMwYgZgxAzBiAmM7omM7oWJ3R0h5oT7QXugu6K7ob2hulGzqmGzqmGzpWN7SUruqYrup4f8akHYDy9Rs/xTiupxlP9YzrofGzZYc/h38+OUT6AqOwXnSjVkzjf0zjf8x47PhVxnS9xriy1/3NGb+R/CJ902NO4rcy1Qjit5MLpe+4Zh2/y1i199JeUqqK8fhUlbuYyQIxVcX4I/Tj5C3pJ4maMuJPPUQ//ixRLSD+PB4h/SJeUzqBXH3psUbxV6TwNaPFqCrG38YnSL+zJlQMk6kZd0R9J9mO8U47TqH2kGQntxIkO9NU3iP5QNqzfL60lxuBk108yi7ZlSb33coqmaR3erq0T3apdPdUpZT0bdxDukemkcbJnowK24uxVXtnGjeS7JMeKd2X9KmhJPtnjn9AqnaJ5EB8P3z/Ro1USQ4qt0gPZvzYIcl46YAO+n5ODs2eqvUsHEa2B5Ltw+k1OILsHZmUpUcR52j0GPRY9Hj0BPREiuIkCuFkBpKdQj8CDSnJaWRyULqd9GxPDUjO46DO56Auos/iYvosLklVlUsuTdaWXlFWw0hyZbqI9KoOs0qHZmrLSq7OMuk1pD+M3F5LbmkYSa5nCNnw8q7S21If5gj6MkYSf2z2nvSOVFWkZBz+TvxdDAC7m16Ve+hVudeNM8l9HhCe3M8RPcAwNmayJA/Rq/Iw/hH8o+zlMfbyOEX9RHo4XRvJUxQCnWLJM3g6xZLn3NyRPO/mjuQFwukUS15xh0vyKv41svQ6WXqDQnuTQnsL/7brd8k7FP67FP57+PfxNJskNJskNJUkNJUknxLnM0bBfc5YwS8owAn4L/Ff4Rm5mnzDoX3Lof3AWMEfnULa4GJJaR5Jo/Kd0risrtU0KavZIU0zNTikWap2wrTMeLDG8r3SDmXda+kUbnJJpyzrAktpHkmndp7TaVKPN5s2VS07PYMRbmeiZ6GD0LPRc9Bz0fPQ89EL0MHoEPRC9CL0YvQS9FL0cvQK9Er0KnQoejV6DToMvRZV97P0evQG9Eb0vsl2PVd5aFQpriqtSVVak6q0JlVpTarSmlSlNanK8O8qw7+rDP+uTkk4EzeqtCZVmY5RpTWpSmtSlakcVVqTqgwRrzJEvEprUpUh4lVak6q0JlWZuFFl4kaViRvVOfEMHa9WfU9Vm+j5ZRh5lWHk1U6kzzDyKsPIqwwjrzKMvEqbUnU+PG1K1QXwalOSMoy8uhD9yAwjrzITsLoo+12M46VBqUqDUrULfkk8MwGrS7MtMwGry+K74pfDd8Mvj1/Bd2J1RXQldGV0FXRVlJmA1dXZag38mnhmAlbXxq+DZ7B6lcHqVQarVxmsXmWwepVJK1Uavqqb4Gn4qnYn/5vhmQlYpeGrymSWKpNZqlvjt8Fvi98Ovz1+BzxTiqpMKarujGcmYLUnvhd+Fzwvl+pu+N74PpzH3Snnvvg98Hvi98Lvjd8Hz4D5Ki+X6v54mr+qB+L74fvjD8IfjD8EP4D9Hsp+D8MPxB/LwHga4avH42mEr55InJOIczL+FDzvjupp+NPJG1NpqmfimUpTHYSnaat6DnunQb56HinTIF+9gPDBvh6a9IaRltAIjdEETdEMLaONzkNTB3SKTK/dpinRqdCp0WnQadHpPMS9aXp0BnRGdCb0H+ismXrWmmZDZy+rabFpDnROtIIy97CJe62pE8q91sSs2ybutabOKPda03zZadL50QU847VpQbQFXQhdGF0EXZTSWAxdHF0C7YIylaNpKZR7rWmZuCRdFu2a+CiWQ7uhy6MroCuiDOpuYkJc0yroqihTvZq415rWyvQh17Q2uk7jQtJ10fXKGvbWtD66kT8mmzZGN0E3Rbujm6Gbo1ugW3EWtinfIN2uUZMjmnbA7+jPzqad0J3RHmhPtBe6C7orups/tJp6o33K+iZp2h3tWz5Juge6J7oXujdXyz7ovpzl/dD9OVLunaYDKcl+aH9CuHeaDibnh6AD2Puh6OGkdgR6JHoUejR6DHosehx6PFfpCeiJlMNJ6MnoKeip6Gno6ez9DJRpoU1noYPQs1HuqaZz0fO4us5HL+AqGowOQS9EL0IvRi/hKC5FL0MvR69Ar0SvQoeiV1Pa16DDKO1r0eso4evRG9Ab0Zs4aiboNd2C3ooOR0egI1FGSTWNRhkl1XQ7yiippjv8dG2i0biJRuOmu9C70Xs4dkZJNd2HPoAyPqrpIUryYfSR7Gvpo+hjfv400YDcRANyEw3ITYwOanoafQZ9Fn0BfRF9yU+wppfRV2JVbZpeRZlw2kSTchNNyk1vcc28jb6Dvou+54kwTe+j4wn5AKVC1ESFqOnjTBWBpk/K+q5u+pRnEU3KTWpSln6BfsV5+Rr9Bv0O/R79oexc/cj9+1NZncJNrZy7ie6ObPqZFNqY7kTHQfOlLpNmRiU1X+k3b/NV+Ks7bCS9hsnF1zNNmG7N5hv9edx5Lz/D53ks0Yz4Nir7bVT226jst3n8Hm3+PKaab/I3avPN9EZ1TNWTG3WhP2XJVP280VKR6lPRDal6KqMbUQ4zmoB+iX6Ffo1+g36Lfod+j/5A+/+P+J/QVnQi+jP9Jm3oL9SLGY0fMxo/ZjR+zGCnmMFOMYOd4s3RLdDtUAaWxwwsj7+nDvuDi7Gi/6UlF3Ilct2hErsHp5K4oCpp0luaoeVYvSeVRtcXKh1cPpUp4p2kzCKsTBUvJZ3as3Iq0/jbu8JnZGU61k6fvCGdAZ0RncknqPKPWIMWKjMTk8/Iyqwu88ps7tWqzI7O4SpYZU5fcpVK8oC0mjqFJnwz6TNfqdIJPxc5nDtWNaoyT6LZW5XOHuRWmZe185Hm/OxlAc/kqizoililJdatXVko1aibysLxxtJF0EVj1Xkri8WaIVJZHF2CEusSq75fWdIz0CtLRUdLl47Vf1dZJnpKuqxrQ5Wu8T7S5dx7VemW6NaoLO9ZM5UV4q2kK7pfu7JSrMEMlZWJs0ris7Bq9JN0NXT1OJGukTwmXTNWPa6yFrp2pHpNZR103Uh9eZX10PWJv4F7hSobRmqLqGzk9ofKxux3E7bd1HNIK93xm6Gbx6oCV7Yo3SPdkphbxU5ha7bdJtI488q2sVpIKtvFPq7tCdmBrXaMNUepslOk+lplZ/bbw71slZ6k04uYu7DVrvjdYlXDK73Zqo+3yhrKh0pLU6j0sig+ShpPoUp6Nk26snTqkkdwTevR1BmtfxmtfxmtfxmtfxmtfxnXfMY1n21ZryVln4fhZF+EwWC/aNiJBztZNW6kY6oBMK2dUo9qmyv9WTp3ooGgrfO4hae1c6omgtZ5PSi0db5MD5bW+ZPr1JF/M9OpZG4J5tb6BKvmGXg6NfGk6hI9Xxu/FEYx/fxVpuaanyd2UMNRsxp+pCXQBzVYgVpCpUmkC7I5jeyzki7XZmpwzYwHaO6gISENzVM0OA6NpR1noQHqR5q8fqIJq5XbcPfyanpoLONncrQs2pVH2XJ09TLBPGIqfbQC/fgrErISunJypdJRMUq3QrdGNd5aui06kQmSP7PfNvQXWjC+Y2Tp977p0suoxo5B70cfYPLXg5ydKRnYVo1UsBl7ydhLxl4y9pLx+Mr0+OKEljcqjJMsb1xc3KS4qFGX7Re7Fxc3Ky5uXlzcojBgrLxlcXGr+nVV3jqYbeoXWHnbwsCn8naFkU7l7YuLOxQXdywMBSzvVFzcuTCartyjuNizuNgrGq5+7zCur7xLcVHTstoNkytrflb7RU3Uar/YpzASr7x7ONK+wexROORKX57kzJWu7OmLtsKIiApwmArMhApwmMp+6P48mQ8gJnCYClXCSn+PU6oc5DFUlYMzNeJVDuG9MwA9lDiH8V4Y6PEMFcZuVY5AjyS1o3jCH02ajIioHEtOjiPO8egJ5OFE4pwU+ynNiIgK1cYKIyIqNDlW+MSt8Ilb4RO3chbvmkHo2WkXKeO4KoyIqJyHP5+YF7htrTKY5/MQnsAXRqqSVC6KNAyvcjFP70tKDr8UvYyYl3skQ+UKnqtXolehQ9GrowWk1+CHodd6RmflOo9CqVyP3sBz+Eb0pnga6c0882/x0MfKrR45UBnOtrfx/B9BzJEeBlkZxRN+dKTZiJUxPL1vj/zmHYvegY6LdIVU7vSYispdvkMrzCetMJ+0ci+PxO15cJ3uN1rzGX5nNZ/pPDSf5RELzYMIucVNHM238sE2nMfdbX6YLDxLNCwRN8OdR+rriVXjbr+oqne+OFNxrRbztVlx29pi+7Xtt60t1taOzvdberD9YqndorctLuZr6/stLrZf237b+n5ZvP/X492x/WKp3SJ5Lizma8PxFhbbr22/bTheLyobjaSW56q2mOdZi4rffq0W8zzXtw0p17dtt+hti4taWxuTqZfOKv4Gi1blJUUzWrS6ezeiNQihGS1ai9fT2nylr5Oq0hHRjBatR/z1+WbegPgb0udyCFrjsdCIpF4Zv6R+4iXVyvSHibSWw8xJ2vBQhtLp3CqeTu+7O52B1ukZ+VZUq6yU11nlAZTXWeUh9GH0EbQN/YXX9PquZnbcwF/RHXkitTACrWUn56cFGFdLD++9paePpYURaC3AuFp2JQQYV0tv4kALadndL+6Wvnieoi0HJBqT1nJgrA6Lln7myQylJ3QoPaFD6QkdSk/oUKo/Q1X90dlsSB/2O1n6OzOekuN4ic9OGzsNvOmc/pJPIQlUL0ov1p07wXFa9kj1HdWyj7/SW/ZtFNiqZb9sjPZ4go9o6InuoBl6kkdeDT0ZncP5HzonWiFOFaW5eOjxPrMT1ec4mYw1Mxi1WXOX1IvlzuFkI030t7c5VLgC/EGsnQ2f/w4TnABziD9S0mcb0h8aOqxjVcd1urImPqp/zKUU/6CRmI4ZKc3+9c0VR4Fam+zj/qvkXnWSqIdNUIeGVMlO0MDShlgxTxBqwoWcfNqQLqbuOPRVm2Q69cmo+84fQd6wr5APmgChAf5somgKVJpKWbv4zU+BWht+2lf+q+2o/c97yX/aS/tE8p92VMt/u58OJP/piJKvCjvSL13112PMf8pA/fdtuzzokGs/HXj7nwqh9pummE9+Kpn855zXfopZ++3j4nLinIL4BoxyrlUTHO7S0KnZul7+Ot2OPJ79zsNO+zakulp0pKuGdLQ5586LWltLRDtVnBvZhZLao374OvZMQ9NHmDSQzKx+WhJXIseG/PT2hpqQlKjR+H1+itab/JDDemZU/spMD/VfkYHXfOlm8+kbuSEdIByCOBPqOdTUcxegphsy3WlyP90OB6KMKW3eW4G+vP/1Txf/v/798Id+uikm99OB5143jn+9Nd7TZnKb6B7UDTi5X35jtk9Kd6h+mqBZv1Xznz85GGzQzGCD5n5ofxWOZ6ZnWfKZtIw2Zvr+zDr4LZBNkb6rMc5/4jfVOQ3TaBhLQ8M0zxSfVOU9i1WJvYqLexerD/uEb+x9i9HCnLXy/sEcUJhRUj6wuNivuNi/Pt+kfFAwB6v64Ikk5UOCGVDc46HFjB1WXBzYbhqROszVnatphepAVm33m7I+fX/+SbdGWd+fP7em6r39+ecpNdY3Y6xOxhsq4w2V8YbKeENlzcU5MssVJxN1Ky4uX4y8QnFxxeJirR1sb78r431iTWCJ92WUyH5ua4oPdH903M+jeeMn+SKlmpwlbqNoHsHX6UiHpzO5OyD9h9k46cyZ5jWks6TjpLOWNQghnS0TZyOtErOJL4rmRn3npx3L7r/u1EGlkc6V6csnpdMzncffJGnn9HLpvIlahKpD6H66EL3Y9aDqT6ImNFRbY7WQVCcmep9Wfya8LVWbUvUXM0Ba9nQdp2UvvhP25i3c32NCWngOtBzMV8Qh/g5pGeAx0i2H+tu+hc61loGJrvNlVboNU27e0LhOw5RT6QLWm/crV/0mfo1+Q1NGN191Py/PfPy9USZXtmlapXS/SK1nbbo4pQei/dD+6EHowegh6AD0UPQwdCBTNW9hHtBwdAQ6Ch2Djo3ULtp6B/7OkkbFtN7lNqXWu63NY5L9poJDu9Aqe/XtOXkYrQmInWK17E4SRmu24rwljbv5b4bROrXl0EnBaM3jXKlsaOjK5HAV9M/AaL2XdQlZjzj/NTBapxlgtPbbk/9JwWgdvwce5mIOo3WcXQnZDe1Nan1Q2GwNffF7cL7oghaM1koXtGC01n05X3RBC0brNA8g/EBC+nGMdKMJRmutw2jZakCk51/DofgAo/Wx34/+J2C01j8Po3X+v0a/Qr9Bv0O/RX9Cf0Rb0Yl8Jv8xGK1D/s/BaH1S7kV/B0ZLi2wFnZUGDCCyv4HRer7X78FolVvBaF3sBRgtWiX9AKN1rgKM1v5/EozWc+BWYbpegNH62IswWt8mAUbrcxRgtD4LAUar8H8TRus9FmG0XhtgtPYBRms/PTkpwmi9NsBo7QswWr/8fxdG6zzACxeM1n4Fd3EIRmu/UuyJngFG65AAo7UPMFr7OozWD5YAo8UHGK33FWC0znmA0Tr9AKN1SIDR2k8eRuvhqAFGa3TizcbuCkarjxTBaNXFFN+bHgSMVp8DgtGObgejNYJ0YOzu0L8Ko1UO/4bR/u+E0WYaYlni06W0tvMjGK2xxEv4OgwwWtdRfhdG66u0CKO1DzBa+z8Do/W1HWC09gFGax9gtPYBRmv/J2C0KJ9qpSXxS5EOn2qC0VqXI81urA0wWocEGK19gNHaBxitfR1Gy/0eYLROM8Bofb8HGK1DAozWPsBo7QOM1r4Oo2UvAUbrNAeSw5+I+XswWo8NrMNoGXVYh9Hi6zBafIDR+n3HvOG/CqON1QUhGK37D4/PnjWMtuxB/ScKrmoYrT7q41PLunoFozV49XRAsGcQ/0x0ENW1ycNo7Qeztgij7TwZGK2rg5OC0frZeE3W559gtH6KXs/zk5Em8Y2svSlR9UUwWk1OFYzWkwlGCFNrGK3jjEo0JDkeTcwxiYYACEbrOGP93SIYrf04gXcNo3X8uxONA4rvSYwJv5+UH3RVL34o05BnwWjVdRNDVBKM1msfY6vH8U94bYDRMuA69rtAMFqBNicJo/Ww7g5+zgtG63H0U5bd9DuVjyWZJlE3Tg6jdVP69HjGCAtG6wkNM3nabg6j1cSLZJZUQ7l/A6N1anOkGu/zZ2C07H1u0S5+hdEKVCwYrRqek/kapzCMtlE9nILRfguM1gPbW0htIY534UaPvl+EkACj/RIYrbsClojdLdAl1RTqHEar61YwWu93GeIsi3ZNNHoxWY6B7d0A4i7PIHr60gWjtV8Jz7hFwWgdh3GLyWqUJ+MWBaN1+JrubxeM1oPx186ct3X8zE/WBQO8HnHWZ2bABoRsyOyBAKP1XjYl592Jw+jgZHPOZh1Gi25Vdspbg6Tdhq225Si2J/4O5Pl0AxsEo1XnYQ6j9RV+V6YBIP9xGK32ksNoNf7rNzBaXRWC0bop5Wlf7YLRCnsjGK2hsM8l6nJMn4/UECIYrZteXnSjXfqSr7T0ZcJfSTRVRTBah7/mYTuC0RoT+0aq6yR9kzhvxTMDo/0QGK0aUQSj9XSE95JbgNFqwlA63oN3BKPVcBjBaJ3mR6mRtx+nmk6RTki2N4wW/Qr9OtJgqPSbRENdBKM9SYyDAKNtCTBaG2C0P7SD0SqHgtHqOSMYrfGxC6It6ELowi4NwWiti6KLuWQEo70MGK2RsV1cMoLRKreC0RrdtIzLRDBah3R1/gWjVZkIRus9ruDSaF3J5SAYrcpBMFqVgGC0KoHWNXzsgtF627XYdm1yso6PvXVdl6FgtM7D+qS5AVtt6IFXfwpGqz0KRiuk/V+A0YpUIRitdWe0B9oT7YXugu6K7ob2RicPox0XYLSO9i36nXqK/jiMVi36BRitqOqC0Vq3jFyMW0Ut/wSjVXukYLQaPScYrfruBKOVCkZr4M1JVsFo1WooGG2jYbSRHqGC0eoxKBitw88ifBDhZxP+WCqWg2C0e3mw4N8w2t/AaFP1BghG62uvU0lXftuRkd6ngtEKKSQYrYaACUarxgrBaKVqiXD48YR3dsEKRqtT1naST2jbyVbBaB3nVOLM59MtGK31DOKcSZz5IzUSC0a7CTBarz0HPZc45xFnQUIuQAcTPoTwFvZ4kS8SwWh1eQhG64tkIcIvI/xywq8gfGHCryJ8KOFXE74IeRhmFYzW/jr8Yr7MBKP1xbY4/ib8EmXn5Bb0Vg/hFIxWmnUhZAQ6kvBRhC/pLwfBaK23Z87/WKtgtA4Zh95J+F2EL03e7kHvRe8jn8vgH0AfRB8ifFmDSQSj1bkTjNb+MV/2gtHaP0H4k/inCF85E/pCMFrrs9HewGg1tFMwWg0iEIzW+iLhLxG+Ktu+gr7qFNpeI53VuB7eQN/0WRaM1ud6deK8g77rMysYrc/vGqQwHv2A8/gh53FNl7ZgtI4zzrkVjNbX2Fqk/Dl+ba6xCe4KEIzW/iseEW08QH4htW9J+bvkPsNoY/W3CEbrkB/xP+Fb8ROT7n/DaP+N1MYVYbSqqghGK/66YLTqsRGM9tH/rTBa+peoBOUwWvsAo7UPMFr7AKO1DzBa+wCjtQ8wWvsAo7UPMFr7AKO1DzBa+/9WGC1ah9GiAUbrqWABRmsfYLT2AUZrH2C09gFGax9gtPav+GoRjFZXi2C09q/j38C/iX8L/zb+Hfy7+ACjdToBRmv/oa86wWjVbyUYrf0n+E/xn+E/x3+Bn4D/Eh9gtC6HAKO1DzBaNxE8TnNBAUaLBhitGxwCjNY+wGjtA4zWPsBo7QOMVmDB38BoXW08iyrMOVQYz6XadQGVxMFUUobgL8QHGK0rLAFGaw0wWmuA0dqPono4mkrWGPzt5Oe0VBXh38BoFS4Yrb/T9KAWxktkK2C0ekG03sqD9zZ0JDoaHYfezoNdFIo/DKM1uXBjXh/7lsaKXgeMtm4OCObAeIiaLoDR1k3/dD4NDwFG63zuiu5GHnqTh4MJ2QHdkfCdCD+EkE3R7oRvRviAdPEG/Xy8Xjy0uDiQ+D3QnmzVi/DDCdkG3Zbw7Qg/IrmIoRaL6geMtrB4FK+wfnzl9ucr9yDCjyZ8P8L3J/wAwo8pbn4c0QYS7XCiHUH48bxPT+AbRqrHNTDaujkpmJOJdgz+FPxR+FPxx+FPC5FPD+YMvsBP4UPozFiDDmzOCmZQMGcHc04w5wZzfjAXlBdv0C95Qz/DaIuLQ4qLFzYe3qBfppqCC/ai4qI+/2plcone7PFdqv2LBQaMVh85gtFO5ykT4QK+vLh4heMIRmvt688ewWgdfmUx2lVE2Avdm2j7ED7U45V0RwhGWzf/BKOdpqHcqPz4j+IYRquhT85eLYfX+7NEMFrr89RWXiD8hmK0m4qJ3EwdZzB1nCFsdSHhtxSj3Uq0c4l2HtHOJ3x4Mdpt3E26xWp32Yji4sji4qji4uh6Pus3yBgO5GKrYLT2l+LHFqPdwSIw2sIlfRfX3pV8Ck4KRlu/6++3CkZr/wD+FfyD+JfwD+FfwwPOFIzW/pGQyKMEvol/PDxGnsDk+XwyRH6KyuP7jtM6nhucL1jBaOsb/v+D0aopWDDa7/8ojLZ4W7UW7yN/GLe7fX6mPtjGlXMVp+Zqjn1SMFpfUYbR0gxiGG3sSUJNyfbiyDjBP6Ief3pYHUYbvxdgtLpOBKP1S+qITO2WgtG6X/IoQo7GH4Mvwmj9sg4wWrXBCkbrmCcT8xT39AUYrVuEijDaVO08gtHuaxgtL/oAo3VqTGIoXUDIYPwQz6bNYbROpw6j9UwjwWjVXi0YraZwCUbrtUUYrVO4xierNEwQQ8No3d8RYLT2dRit29tzGK1avwWj9baTh9Gq5U0wWmsRRqv229K4RK1kgtE65l3urRaM1rDbexJdeILRer9FGK1jPtjBeX6oLPBk6eHE5fPIFF0No6UP5THCA4zWW7WD0Xpx8jBaJx5gtPYfEp9xIDmM1uEBRmsfYLQ+wAmcjiKM1msDjNb+u8ZVDaNN9WzJYbSe7EVnXA6jtf/3YLROM8Bo7eswWndvBRgtPsBoHSfAaO0DjNb7CjBaDz+Y06/7qOKOjxxG67XN/oqLOplLFM2FFmG0jjl5GK2/P9vBaL1hgNHaBxitfYDRevMAo3U4re6C0Vq7E06ru2C0DtkCrcNofRcIRqsrUDBa63YmCQlGeyIwWh/mjsTfCd050We/YLTeticTI3oRTs+gYLTW3Sh8hkJFfeIVgNHqkSsYrbGm0DgEo1UvSbSXL7lob3QflKGOgtFa93fPgmC09ge690EwWvUWRf1TtXtHB3HKDkYZChUNQBkKFR2GDkQPd3+EYLTWI8n5URwXfXwRf3AyOjbRkEDBaO0Zzi8Yrfd7YqJWaMFonX+w2dEplP+p+NNMgAgw2lRfIILR6uIXjNYKXUAwWit0AcForQFG66O7gHIeTKkOcZVBMFrnE4S2YLS+wC4hJ1R+BaO1Xt5oKO8VZVVMois7qOcuusrz8qOhibGyV2f6ChKMVqOAomGZ2pAFo/VerktWB0brmDdF6leKbkZvKQlcHd0aaVJXNBy9DR3haVjRyESvD8FoDbId7aGG0RgPR4xu5zyORe9ACzBatr0b/U/AaK1Po38eRquWfz3HOxpGGxui/G6kwdTRe+TtL8JoPZPobxjt3zDav2G0f8No/4bR/g2j/RtG+zeM9v8jjNbjuJ5mPNUzrofGzzbqO0cwWvvn/bUsGK1HYb2YCpaTw2g9CivAaD2mK8BoPfHojUx18BxGq+YUwWi9l3dcs46pKgpGq2qOYLTeajz+g0R/pqAIo/WfBRaMVl/7gtGqNi0Yrf9A+ueJ2sEEoxWcJp5Arr70SCfBaJ2TrxktFmC03vY76yRhtB59tOMUqi8nO2Wq+QpGq+/epAcN6T3LqqEkvTKNexGM1tvy5zIEozXrtHdmcmofj51LdvdYNcFodezJHmWP2tqTUWF7MbZqb+LsQ5wAo/UIpf0zoWIEozV09kB8P3z/RtNbDyrrO1kwWh1jckiq5rJkAPk8tKyruAaj9eJAsh1gtM7ekf48/lMwWhfCyfhT8AFG60wOoijOTjTsMzmPgzqfg7qIPouL6bO4JJsFGK1aunIYrQg9gtHqQkqGls3ipU9NMFqnFmC0zm2A0Xq/wzPNxxKMVqQcwWgdcyT9GmM920wwWvN6x+HvxAcYrXtV7qFX5V4G3d2XPASM1v4BhrEFGK17VQKM1v5R9vIYewkw2k8CjNbRAozW/ndgtO5wyWG0ztLrZOkNCu1NCu0t/Nuu3+UwWh94gNHaBxitiyXAaO0/ZYzfZ4yC+5yxgl+wrwn4L/Ff4Rm5KhitD+1bDu0Hxgr+6PF1gtF6DBhzN9KoUfVrwWgF/RKMVi1FgtGqt10wWjWtCEarP0WSNjbq2hOMVukIRuvwKcsepRZgtP5z6NMwgm7a1CPZ/s/BaN0vGWC09jF9lEyvEIzWngkagtHaBxit4wcYrcMDjNY+wGjtA4zWPsBo7f8TMFoPeA4wWocEGK19gNHaBxitfYDR2gcYrX0dRosWYbSOw0xAwWjtaVASjNaegaaC0TqFpYm/DH5ZfFf8cvhu+OXxdRitb7EAo8XXYbT4AKP1VgFGax9gtPYBRmsfYLT2AUZrH2C09gFGax9gtPYBRmtfh9G6aSjAaPF1GC2+DqPFBxityyHAaO0DjNY+wGjtA4zWPsBofdQBRmsfYLT2AUZrH2C0DgkwWvsAo7UPMFr7AKO1DzBa7zfAaO3rMFpKpg6jxQcYreMEGK19gNHa/zEYrf255J+mLcFovW0dRgvcUY9AYLTWCI3RBE3RDC2j3IOC0VqnADM5JToVOjU6DTotOp2HuAtGa50BnRGdCf0HWoTRGpU6BzonWkGbfSyC0VoZ1C0YrZX2W8ForZ1R7rU/D6OlNJjy1rQ4ugTaBWUqR9NSKPfaX4DROldMiBOM1roqylQvwWitRRitRjUIRmstwmj1MSkYrXUTdFO0O7oZujm6BRpgtMLqC0a7czsYrT47BaO17oz2QHuivdBd0F3R3TzjXDBaa59GUdWbdkf7lvVaFIzWuie6F7o3V8s+6L6c5f3Q/TlS7p2mAynJfmh/Qrh3BKN1zg9BB7D3Q9HDSe0I9Ej0KPRo9Bj0WPQ49HiuUjq2BKP11XgSejJ6CnoqehrKPSUYrZV7SjBaK/eUYLRW7inBaK1/Hkbro7gUvQy9HL0CvRK9Ch2KXk1pX4MOo7SvRa+jhK9Hb0BvRG/iqJmgJxit9VZ0ODoCHYmOokxGo2PQ29Gx6O/BaH3s96L3oQ+gD6IPgXR9GH2krIpz06PoZGG0nH3+mlnTM+iz6Avoi2gRRuu74FV0UjBaXzNvo++g76LveSKMYLTW8YR8gE4KRqsPswCj9SSjps/RAKP1efka/Qb9Dv0eLcJoNShdMFqfu4nujvw9GK3fvDmMVl2cOYzWIQFGqw/CPwCjpc2fx5RgtN5RHUbrvt2oS6xHQbQkvTZLJe4CuyH132a8Ef2rMFrr/w8YrYqlwl+4rZTcn5LDaA0TTUDopYnmgglGay27SiUYrSGpdEpWpvCfHBSM1jjVqVy/FozW205DCnxGCkbrdKZ3LVgwWuuMaB1GmxhxNzMx6ZQUjFazGgWjNfRrdnQOILhz+pITjNZxqplq34LRaliIYLROv6Nf0DmM9k1gtPpboILRaj57pbMHuQlG65jzuXolGK33soBrvpUFXRETjNYpL5TqdSMYrfqsBaO1LhprCJ9gtE5hcXSJRHUlwWgHAKNV37RgtMbyLR3rAqssE+viF4xWyBDBaPsBozWat1uiuW+C0apGIxit/jq9YLSqhQlG6zgrx/qjMZVVPAeqsiqwwNXQ1WP17whGa6zsmvi10LXd41NZB103Uv1OMFrr+iBjN3CvkGC0ms0nGK1BuRtHLo1NgOluGmvuiWC0hjtuhm7OVlt4aFxlS2IGGK233SZyWW0bCycmGK0GzQpG65AdYtW5BKNVtbeyU6whGYLRer893MtW6Uk6vYi5C1vtit+NlHuzVR9vlcNoPcYpivxHtuMpVGK/gdF6DM9fgtHWh5N9EQaD/aJhJx5sYwVGqyq5YLS6DlvnyjwfZ+50NsNo3cLT2jnTFS4YrZB4gtHqVfWHYbRABrrEgtF6/FIYxSQYrVjFgtGqYP9LYbS+ZXYv+2+NLlPWXyUSjNbalT76AKN1lytT6XMYrUPqMNrUjWy/B6P1BMlJwWg9svR73yyTgtEy+SvAaH3Sq7H/PPgfhtG2HycpGG1hcZPiokZdtl/sXlzcrLi4eXFxi8KAMcFoC4tb1a8rwWjrZpv6BVbetjDwSTDa9iOdBKMtLO5QXNyxMBRQMNrC4s6F0XSC0RYWexYXezGiz68ID3ITjLawuGthmJxgtIXF3sXFPoWReILR1o+0bzB7FA5ZMFo/S5krLRitUa+MiBCM1iEwEyrAYSr7ofyNBcFoHTPAaB2nv3HvgtEKpyQYrUHdh/DeGYDCwRCM1u+FgR7PIBitQ45AjyS1o0wyEYzW6R/DVseSk+OIczx6Ank4kTgnxcI7CUZrT7XxNzBax+cTN4fR+m04CD07VZtVhXFcgtF67Xnk4XziX+C2NcFo/YQcwhP4QvQinskX8/S+RH/r2jBa62U8ky/3SAbBaI3jvZKn61XoUEKujvzmvcbjHASj1Sg4wWj9PL+O5/b16A2xGjkFo7XeBOD8ZvZ4C2+xW3mDDCfPt/H8HxEbRT8yVttyZRSI2dHoGJ7et0ea1SIYrfWOWJd9ZRxHcWekmVz/Akbrz7bTAdCe4T0KRqs8CEarEQvNgwgJMFp/sA2H7jIZGO0nRRjtr4sAVguL+doAZy0stl/bftsAZ/XirzDaaNkCbra4mK+tp1xcbL/tb9b+Zts85XYwWiE92sNof10kz4XFfG043sJi+7Xttw3H68VfYbQhV3WgbLtFA2WLi3meA4y2nnKA0f66CIy2sKi1tTGZwGj15SYYrV9PAUbrb+8ijNYKUCtaJxNMSTBav7zqMFpGRgUYrftc+ItGgtFaaURKmFghGK1fUq1MfwgwWq8NMFpjVqdjXvP0vrsFo1XFJJ2Rb8W/CKNlZvcG/ooWjNZAOEagtewEbhbmzCRhtAbIBRit4/TG92FtEUbrkANckoLR6utUMFrxZP4AjFbwub8Io3VbfR1GSxPZRRBs6jDaTF99gtFqdJxgtPriFYxWbwfBaHVEgtFqDKdgtBp5JRittQijdZwqSnPxn4LRXt4QCzp7vCboO7/JDupKEmYAduxpHnQdC7JY+w1GhSldjrUnuv3exM2XGzosYFVnsnoDDKMVok91Jb2I++FFuHw3wGhndqDKMHlKHSAwSr+EQjp/Q7q8LhygmFr1jaAIBoumUzWk66hfqyFV9r4zATcRHPcTzcjxHOvkMnVPedvsMY159ybpWur+cprptOziNz/tTvsKvxqDs/ar7aj9z3vJf9pL+0R09kWdVM5rmW/381FolSLMUD+cwl5e+vXo8p93Xftpwm++dx1s7adDzn869vzXPnv8VCD5zxmu/eYPv6dcSi6fWsnPgqmVvLK6NqdJGTu4XuxJV3KieeInC3rBHq9qSI9ymadCzG5b37x2jM6w1m5LItqpwp9nF48423XW6VMN5ZaG8roN6Ykci0ixE0nks5Cft71hdr4+yeoF4mi3kR/lMM+Myl+Z2czdSs5MWR2JmpHg4fzpXZpsoblT6hL02HyVnrrc/zSDVlf1v/79LoP25T/0070wuV+y/q/e90s/j/7QkAqbyWyiW8932WR++f3YPqn6eTk43KH57wVK3hf5ZGG0npn+Gxit+g3bw2hVO/jDv6l7NUyjgR4NDdN67n4RRluoSuxVXNy7WH3YJ3xj71uMFuasCUZbNwcUZpQIRltY7Fdc7F+fbyIYbd1MCkZb2OOhxYwdVlwc2G4akc91cqW4LLqYgdHqpSAY7RcN5bmA0apTXjBazwr5PRhtYY7McsXJRN2Ki8sXI69QXFyxuBhgtHpXCkarlr0Ao03UvB9gtIbmCkbrL1KqyTmMVqcjwGgb1aojGK2+jQWj9Z8/nSVTP7hgtP4jqLMRzhB6wWi1lWC0qssIRjsIGK2+h9O5yv5DqXPT9z0P8PvO7h8XjNbdT0PofroQvdhzSQSjVWFWWxP1fVcnur1IMFqHtxlhW/0lXaYdjNbfCXvzFu6fqtGghbHlgtH6m+EQf4cIRqu6g2C0ymcRRls+q2HK5Rsan2mYck1dwMBo1SQrGK31G6tgtG7QKMJoFf4vYLReG2C09gFGax9gtPYBRiv/b8Jo752mBqNde/+d+vbuYRztlCdMCkdr7RRplM8kcbSmKM5rYP5/M47WKdAJPUkcreOs5K4R4Widw1XQP4Oj9eT6dYmzHqn91+BovW3A0Vq3j9X4PkkcrZW/iCocrX3A0XorOqGFo7X29p9vaOiD7k78vvg9yP+exNkL5c/fCEdr5c/fCEfr+PuTJn/VUThah/TjWPrjD0LrONrIpT0g0p3WcCg+4Gh9jPej/wkcrff153G0XsuoGuFord+g36FMNReO1sr0cuForRNpTPxjOFq1+f7fw9H6NN2L/g6Oli8DqiLNs/LXCWfjMiviaL3t7+FoFUc4WqdZwNGSJpWcHEfrXAUcrfV/Eo7Wc+RWcZ5zHK2PvYij9W0ScLQu+YCj9dqAo3UJ/Hs4WvsijtY5CTha+4CjtecPav8GR+utAo7Wvoij9Va/h6O1dqU0INWXVojUcCYcrf1Kvq1yHK1DAo7WPuBo7es4WnJVx9HiA47WOQk4Wm9Vx9H6r1nlOFqnE3C09pPH0RpuGHC0QoYJR+uQ4Z5gKRytB63emxgHeV+kbk7haPUxkeNoffUO9N/u+cs4Wm0lHK0RtH/jaP+X4Wj91z9LS8RGna7tzl3haAWTal7C12HA0Ub6XPtdHK2v6iKO1ukHHK39n8HR2gccrX3A0doHHK19wNHa13G03Ll1HC2+jqPF13G0+C7kij+oLRyt87A0Icugy5FmN9YGHK1DAo7WPuBo7QOO1r6Oo+V+DzhapxlwtI4ZcLSOH3C09gFHax9wtPZ1HC0hAUfrNAeSw58I+T0crRvy6jhaxuHVcbT4Oo4WH3C0fjLMwbvsL+Jo0WMZlHB8pr8GG5+Q6Y91CkerJkLhaPV3SONTM30JCEer56oQre5rPIP4Z6KDUnVX/AscrcMnhaNVtTbH0RomG3C09pPC0foPdF7jTuLf4Gj9FL2e5+cNif7+rKCzTv8moyGFozXa+1aewCNiDbYQjtZxRjExZjQxx7D29lgdP8LRqrolHK1DgHUKR+vG67uNg4zvMVZMOFqn/KDBl/FDqcamC0ergd3C9zq1R1n7GFs9jn/CawOONlO3jXC0KlXhaIWznCSO1k29HRpV5UmmKKvKmkyZ6aNdOFr9BZlkmtRDzKdNNbxAOFpvO32q4SPC0drPSMozpar55zha6yweciEcraqvwtFaZye1OVI1VU8SR6uzMCkcLXufO9MfuMlxtE+DoxUcM5mvvJ1xtGWVoXC0KmfhaD0HoIUcLpTq6hWOVpVG4WjVhZbjaI3cXTzRH68XjlYDF5Iuif6If46jFdBTOFqNZBKO1iG8/ZOusXO1XOJZAd04iuUTT71YgbUr4vkz+sLRujwZJSwcrf1qmaY3C0drv4b/aqRwtBpwIBztFeBoPWR/HXdqJuumPur1DM1M1o81TUU4Wg2wEI5Wk6JzHK11U//tyKR7LEKHcLROeXP+7t4W6JboVmV1vCVbZx6CD+w+2Zaj2J74VMqEo9V1mJwR6ezkOFrfNXelKvP/OI5WE5JzHK3u7t/gaN3N8FSi8heO1g0uz8SqHQhHq7/RKRytzrvei25qecF/Q1M4Wl2T6UuJQbEvE/5K4r/786qH5ghHq4qGcLSO84ZxzOmbxHmLP4/7dqIuduFoNTVIONrjwdGq01Q4Wk1vSMd7oo5wtJ5g8CFpfpSq6UQ4Wp21dIKvmfRL9Cv065K7Rr6JXSMYlh0rBETA0c4YcLQ24GiHt8PRKofC0eocCUer9IWjtbagC6ELuzSEo7Uuii7mkhGOViUjHK1KRjhalYxwtOuCo9WYvNZlXCbC0Tqkq/MvHK3KRDha73EFl0brSi4H4WhVDsLRqgSEo1UJtK7hYxeO1qDbtdh2bXKyDkNk1nUZCkfrPKxPmhuw1YYG1E4OR/tfyDAFFCh0bOnSxJ8cN2biCwsUqPFC/ztBgb5tBQr0qzaAAu0DKNA+gALtAyjQPoAC7QMo0D6AAu0DKNA+gALtAyjQPoAC7f9bQYEcex0UiA+gQMcJoED7AAq0D6BA+wAKtA+gQPsACrR/xVdL9VVfLQIF2r+OfwP/Jv4t/Nv4d/Dv4gMo0OkEUKD9h77qBAqcAVCg/Sf4T/Gf4T/Hf4GfgP8SH0CBnoQQQIH2ARToK/xxPuQKoEA+8AIo0OEBFGgfQIH2ARRoH0CB9gEUaJJOERToF/pZvFzO4VV+Li/EC3h9D+b1MQR/IT6AAv36C6BApxNAgfYBFGg/ihf3aF5/Y/A1itBp8ESKoED51goPHIOfIrP8mvy8FbbJmxxhML2wTXpXCtvkkKPxx+CL2CYXY8A26U0qbJNjMvRH2CYjh+rYJn+3FLFNsTIgbJPmE6qJ2ikEbJPjn0/KFxA+2G/S0hB/zebYJqdfxzZlzvnlqb4DS1eQc27k32CbnNo1/iIVtsk1hWvZV8A22Qdsk75LA7YpvQNsk7edPLbJIXx55tgm/0GdO4wvF7bJ4dy8wjapVUfYJgHfhW3SY1DYJu+3iG1yzAfRhzzzs/RwrHdE6RHWPlq2f4zwgG3y0bXDNnlx8tgmhwdskz1Dz4VtcsyAbXJ4wDbZB2yT40zgdBSxTY4TsE323zX6Mvjeo5NzbJPHmlBpzbFN9v8etslxArbJvo5toqmtjm3CB2yT4wRsk33ANnmYZsA2ObU5/efOo0qsp1OObXL85lT3b9TJz6toLrSIbXJqk8c21U5Qjm3yqoBtsg/YJvuAbXL8gG2y8nUqbJO1O2v5OhW2ySFboHVsk2sNwjapJiVsk75You3cEStskx6MwjZ5X/wFZ2GbrP+PvfMAt6I62/bZ0/YGayyfGt2Hs+0FsWHvvffeBUQRGyhNAbE3xIoduwJ2Y8Nu7CaaZqLm01gxxti7xo0n//PcZ9bmDDlIiUm+Pxf7muu53lmzZmbN2lNWede9evolI2yT8TcHJiobC9vk8INQugyiPsxbTZdB1BdU06HYdBlEh6NHAA9ixvyoH9ofPYojULMWtkl1JWGbbA/ysFJhm1SripjBLqKvPWLgejQUHYYOR49DR6DHAzM6AT2RfDgpUhegsE2qrQjbZGDTqZGckoVt8vWejp7BWc50eU/YJpXEhG3yvqP4o3FSFLZJrucB25T0ANtkm3Y5YZustMsJ22RlxvwGtkkIOWGbnM+Xk6tj0CsizwZ+JTGvilUDFbbJKbmGkGvR6zxVjLBNRmLdUHZ6xro+Ho1zaTAa7/YrYZv8H92Uyi0+ujlR51x0S2z00q2J2hiFbZITvLBN1jubjOu6q6T6ZnQ3eg96byQHLGGb9C4StkmtK8I2Gen1gLvtogf5Hx9CH0YL2Cb+98fQHwPb5Bxj1M1MYJuMx3qrSXXw6O1IHZbCNql+Eb1D2mYS2xTdNAvbNAvbNAvbNAvbNAvbNAvbNAvbNAvb9B/FNmlAiLBN7nd4IdVwmvj3noM+/gM2TTHCNrm34mWXuhvYJocHbJOPHLBNanaIX08MewrYpjnANqk0GL9NP9FE+nTecdOBsE0+zrvYf0k0kK+IbfKQUWGbvNeHqdrJhW06wtgmj4mKP/EwzvhTUvWZPReFbXJKvqBXJWCbVOYUtsk9IwHb5L6MgG2yHtBZI5aTHomnAOyZeVq7XvS/HFh2I0Zvt50K26RytbBNbgDpU3bTyiGp2hyEbdI4veTQVMNBhW1Si25yeKaSYXIEvSdH0gfRz/1QSX/3+zSwTT7vAM410C29wjbZHow9pKLrErZJTUzCNrnlf6jbE4Rt0lBMYZv0lLdhm5zsESQ7YJscDlt2OrFNzgrQG8I2ucNiFN0WAdvk8NHmmwvb1N3YJi7qUi7qSlqQrqIF6erUswNeY4assE0a7yRskxqTk7EVz3E4LnPMgG3yeQO2yXaObaKr5e6yO3ruoXvlXlqWJtDK9FCmrklhm5xFj2A/ih2wTU7t47RxPZG6q+XJxGl+ii6ep+nuCdgmt3EFbJPt5zjL85wlYJuGBWyTDxuwTbangW3inw3YJoe/RpJeJ9PeINPexH6LC3+bzMepTNgm2zwLDWyT7YBtsv0hfWEf0aP0MX1qNJUkn2J/hv05Nj28wjb50r7i0r6lT+1v7pkStsn9MjSPpFHZg2RiD48Xtkk+xMI2qQ83zZzOtOw0pxVjyNJO4Jw6g3CazfdzA9ukbEznTO0mO1fF0w3+12Gb3IobsE22aU0Stsk2rUnCNtmmNamBbfK+Advk8IBtsh2wTbYDtsl2wDbZ/jGwTW4zD9gmhwdsk+2AbbIdsE22A7bJdsA22c6xTbTqF7FNPu9KXC8NSsI22e6OvSo2HrPNq7MvHbLNa2Kvhb02NsObm9fFzrFNaI5tQnNsExqwTd4rYJtsB2yT7YBtsh2wTbYDtsl2wDbZDtgm2wHbZDtgm2zn2CY8vHNsE3aObcLOsU3YAdvkfAjYJtsB22Q7YJtsB2yT7YBtcqoCtsl2wDbZDtgm2wHb5HQGbJPtgG2yHbBNtgO2yXbANvm8AdtkO8c2ETPHNmEHbJPjBGyT7YBtsj192CafnQb5ZuZRELbJ4Tm2yfeDsE1y2BC2yRqhMZqgKZqhZbQC4qQT2hkk0Gzo7Ogc6JzoXOjcbsAUtsk6DzovOh86Pzp92CY1CQrbZF0UXQxdHF0CXRJdCp1hbBO5sRK6MroK2h3F5anLaijP2kxgm5TnwjZZN0KZi1fYJivP2hTYJjlgCNtkLWKbVJgUtsm6E7ozugu6K7obujsasE3Ow30ratJsYJtUDBO2ydoTpWAmbJO1N3oQejDaJxOtQ9gma1/Pcyxsk/Ww8liwTdYj0CPRftwt/dGj+JePRgfw7wxEB5GTg1GajoVtsh5Lyoeiwzj7cPR4jnYCeiJ6Enoyegp6Knoaejp36RnomeTDSPQsdBR6NnoOei6pOg89H70AHY1eiF6EXozOOLbJV3ENei16HXo9egM6Fh2Hjie3b0RvIrdvRm8hh29Fb0NvR+/gqnFkFbbJehd6N3ovOgGlz1rYJit91sI2Wemznia2ydf+BPok+jT6DPosOfkL9JfAsJ5Dp4pt4t//HfoC+nv0JfRltIhtMhrpVbQjbJPvmbfQt9GJ6Dt2GBO2yfouIbivTIFtcpo/AN6UY5s4ppqU22Gb/L98gX6Jfo1+gxaxTapQCNvk/26SuyOnhW3yl7eBbdK/3MA22W0mYJvshjptbBNt/rymhG2Sv2vANqWqW0XdI3eBrZoKNxOtRt/Kban8YIVtss4stsnt//8JbJPREmKtGNuUGtkQsE3GMyXgKlLflsI2WcuxarvCNqnsXe3k/Kl29oRJwjY55uzu0xG2yTCjOY1MFbbJx5+brRQjhW2yDf0zYJtiQzf+h60UI4VtMlRiIfdqCdtkXThxqhbxLSdsk+M0pz4XnZLCNvmY+PU1sE1O4eLoEp7KWtgm/XfCNnnr0q4XCNvksyzrmm91OVfEhG0SQkLYJvV3C9ukurOwTdYVY3F2hG3SbSlsk3UVMFLdY4M2Vi0Zk7Gah/MI22S41RqAMNb0DFvCNumjI2yTMMfVddzXL2yTQVfruWdc2CYhioRt0jBCYZucGxulRnVsDARqE3TTSB5TwjY5VZtH6pAVtsnxt4zVIiFsk3XryP/CNui2sXFR2zX5P90+EqWuugP/747RQLBNqn5Wd3Y/l7BNtndFd4tUdxO2SS83YZt8xj1j3w97udItbJOxKfvE8uMStkmersI2GSyyfyxsmbBNvpYe2D05by/3pgnb5OP0Zt+D2Otg9uoTy9tB2Cbv1dd7CZwkLK/ASRpPW18s/d7gJINa6ku4jaW+ZKrxOwInaUIXgZM8Qdf0gpN4V3S3Y/m/FJDkG/7Q8rYAkuQyJ0CSaW5r8dIIgCR3bjK4owFIckgOSDK/eJqAJLvsdgRIskcNXj0dAZJwR2wjShzGw4Kbt0g6prTQSS2SjkMY7lFlXFv1aHQAD8tAYgaSjuMMiWeDpGNqzLGZunqrQ3kVDEPhYoik40d1hLuYRdJxCNhukXR8tJNSfSlE0vExT2GvU0nJacRhFrQqZAeRdBxnZOyz0Ektko61SNKxnocGko5pNaN5/C+Eg4ZrjUg63usSd5GLpOOYl9nPQSQd35BjPJN99Qr0yljIKpF0/EBdXdK/I5KO9Voerus8AKF6Pbf6DehYdBw6viSGe/VG7JvQm+UaIJIOj+Gt6G08jLejd/g/EknHj+Gd6F2Rhk5U7+YhuodH8l5iTohXh6Rj+370AR6uByM1xImkY32YR+wRuzNVH+Uqpk7S8R1+rl8yIunoNSKSjs7ecoEfSZF0HBJIOv6G/iBJR54C7Uk6k1ehwxRWG1sDWaaw2n5r+30DWcark0k6pWcKNJx2q963uNrYmp+3uNp+a/t98/Oy2o6kc1CRpDN5lTQXVhtbw/UWVttvbb9vuF6vTibphFTlNJx2q6bhFFcbaQ4knfzIgaQzeRWSTmFVW2HoiGIgho7fY1Nn6PgNtiVFpq0ylbvE0HF4ztChABMYOn6PDUXbBpFRo5e7sN9j3/Eeq+MZGBg63hoYOn6bzU3TH3VhMXT01k3nheo4kwyd8kgzdPwpF0PHlBncgbr2cHrE0LHdEUPHhJ3A0HHIIcRhiNMUDB3rwESFBzF0VMAQQ0cOKtPB0ClBz5kZho4bTnOGDu0VV6YavNBg6OjfEUPH6TmqotG4YuioG0UMHe0rho6GLYiho3eOGDrWIkPHcZpR2u7aGDrtQTmC18yjvgsNQYBlI0O6FCqAjrYKSkK0fNGsmStgDPXHKhPQ5NumTiKbfOuuwnRDQDlHOyvib+X7ZtsYjrC74ihQW5P+MHeeULO0oQxJpSnVYT+VK58IDN4Uyxde0T5sSldSBwj6qo1kbrWCq8PEtEDveJgGo2imYM2Eyy6KpkAdU0fWKaZYFKitYdG5GkvbidovPktj0VnaH6Sx6ERt6W+36EIai64o+bxwIi3pxpOvsbEoAfnyVbs06JLbFl14+0WZ0LbMWUwni3KmsTjlbYtiti39nV0+OH9BfBuGUq5NnzrcuaG/Zq88//V3O7LmG9Z5l+CkhzWlult0pRuH42h3/juvamvbQXRSxbmdU+hQh+eXr2vPNIfrvR4DkQgK04uD6yCi9rSl5xDvqJm7EzXT/ZlF0U4nPaQwT4zyX4nppR4DEvAndWSZqpOpgf0QDdSAxfN0U3a7M1Du9jNMzHlqGotu/h9e9FBMz6KHYqrLK5NtPThedpeHnY2p7aJnsPDAFpfGg+nlkPxQOTFHZfF2j6oXfUc6BuVATtEbSeQUOfIFckrs8EHueIoHs/U3lD0oP4uZYs2ZKWW9wcRMUWVczBRV1tIFXI0VM8WzdCxU1mB/MVMcE4iqmClnmZmSPW1mSkW9delidBgt7gFiYqa4w2hJd06JmeI23jG0/V6BXuUSr5gp6kNsrsea8bF5krEAYqbYh7/VtN/mvydmpQVmir8L/XjrDvH8PV25JcRM8VdjqL87XYfZQVHMFJXiCswUgCNHz9MGHNnoyMMOnBZ0xCPdF3Uts0PoiMfQL2Uw2r8ZOuKjrY12BB0xd2GDsuEQG5LCjdAZgY74LFsTsg1x/jXQER8zQEds70f6O4KOOD4zXwg6YjtARxyHiV8FHbEy8WtTX5QxuE2HYR/O/0UXiqAjVrpQBB2xgjkVdMTxeZgEHXH4IEIGc400Aws6Ys2hI+w1zNMlNzHxawM64mt/Cv0xoCPWGYeOOP1foJ+jX6Jfo8yALOiIlVmPBR2xTqLQMX3QEYf810FH/Kc8gU4DOkI7RxVdkJcKsJApoCMerzAt6IhSK+iIs70AHUGbOX6AjjhVATpi+/8SdMRjODZiuEmAjvjai9ARPyYBOuL/KEBH/C8E6IjC/0noiM9YhI54a4CO2A7QEdtMnDQFdMRbA3TEdhE6om/LNKEjTgNcKEFHbK8Xq6lb0BHbG8SGggToiEMCdMR2gI7YzqEjfrEE6Ah2gI74XAE64pTn0BGOH6AjDgnQEdtTh454drwAHRH3TNARPWWCjnjevXuYBe+J1IP+n4w1j7OgIyoRNKAjbgUc4WsUdMSoiRmHjiiFgo6oxjkLOvL/G3QkU29SiaJLaUunR9ARo0dW8X0YoCOJSnbThI74Li1CR2wH6IjtGYGO+N4O0BHbATpiO0BHbAfoiO0cOoLm0BE0h46gOXQEpahWYuIkQUd8HIpqgo5Y1+aY67A1QEccEqAjtgN0xHaAjtjOoSM87wE64mMG6Iif9wAdcUiAjtgO0BHbATpiO4eOcJYAHfExR5DC74g5LeiIfVty6AheMzl0BDuHjmAH6Ii/d4x7+yehI26VP93zD8ZnlNVZIeiI8lDQEfU0xmeXDeo4J3OccwF+nEf889HRqYa5/wB0xHZH0BHd1Q3oiIYBNaAjrjl1BB3R+1DQEaetCB3xW/RW3p/0lMa3s/WO5EGgI3ZuZQy3oCOe25Shn4KOiEIZ30/MBxK7slJKEXTE2CfGbQs6og4xQUcc/7FEznrx44nT/BRHfsYTZcbPZqpLCTqiLqCY8dmCjnjr8+z1K+xfe2uAjpTVGyzoiN0VE+aU7Ag6YrfEThWDRjpXvHW2zLOjzs7sk3Omnl9yrtRb+UoKOmK3SnzcBB3xkRkx2YCOOP4CRhQIOuK9FkJ/ytEWTuWc2CF0xHE6go74aIv7X2hARzxz5VKkYWlmsVym7DQs63spWQ6nzq5sXZ7r7cYVrcBeATriGV1XZrrPVRJ9+wQdMXokQEcEeklW91tR0BGnga9/spZnmBV0xPNpruMyg6AjPgI9VIKOWJkuTdARH2cjHEvxu0k2KdvLFb+bZLNU72dBR5zCLYizZdlOx1ul6tpNtuYqtvGbOdk2sV/wdpnPtb1nomlAR3yWnU1zTHZxr5GgIw7fjX9zd3QPdM+y4+zl50vQEe+1D1exH/H3J+TcRL12yXnuwAzQkU5KoaAjApX96NAReQQ3oCPyX5gCOqI8EXREwz0FHXGbxAvu8hV0xPCPPyR2Sn0x0v0v6IiGRAs6oiGq6R9hxf8v4a8k6uwVdMThf4oFcRF0xK6yr6dqV0jfIM6bTIPyVqJ5EwQdkWu2oCNmwL6T+Hr/7B6n9F0PyhR0RL2Igo74mH9N7UL7Pq0dnxr/k36Gfo5+EWmOifTLRD1jgo6M1BjdAB3pGqAjNoCOfNsOOqIUCjqiuYAFHTEmZDm0K7o82s25IeiIdUV0JeeMoCNykxd0xGiQ7s4ZQUeUWkFHDCZZw3ki6IhD1nL6BR1Rngg64jOu59yob+B8EHRE+SDoiHJA0BHlQH0zX7ugI953C/bdkpRs5Wuvb+08FHTEadiWY27HXtvbceA/BR2Rc3rpGn8UBB0RCljQEd2S/39CR2g8u5ruiAAdsR2gI7YDdMR2gI7YDtAR2wE6YjtAR2wH6IjtAB2xHaAjtgN0xPa/FTqC5tARNEBH7GQaoCO2A3TEdoCO2A7QEdsBOmI7QEdsv+K7pflV3y2Cjth+Dft17Dew38R+C/tt7InYATri4wToiO33fNcJOqJXtKAjtj/A/hD7I+yPsT/B/hT7M+wAHXE+BOiI7QAdceHtVxTkCtARNEBHXBQM0BHbATpiO0BHbAfoiO0AHZn4D9ARf0wv4ONyEZ/yi/kgXsbn+3I+H2Owr8AO0BF/tgJ0xBqgI9YAHbF9H5/m+/n8PYD9IOk5J9U0Q1NAR9yQUuWFY+iInafqXfy+FXTEu5zgedgFHXHJ+SRCTsY+BbsIHXHWBeiIsR8jKS2fRcxRrhEH6IjLLUXoiEt0go74xcIcQw3oiI+GZ0TpMkIuxx5TlotTAzri4+TQEc8ALuiIgY7Xp2rpEnTEW4vQER/hRpdIBR1R/V3QEV9RgI7YDtARfdMb0BG16ws64n2nDh3RF0rQEWuAjlgf9hwrgo7YfjQxNOXnbtURdER/h6AjKkkKOuLzFqEjPuYznZzmZ8saaFL6BeCWX3Y2aOQ5XsvPEx6gI96rHXTEq1OHjvjgATpi+z3i017agI44PEBHbAfoiC/wU/6OInTEWwN0xPbXFXm0lb6xc00DOmJXIyqtDeiI7X8OOuJjBuiI7Rw6wnQ5OXQEO0BHHCdAR2wH6IjPFaAjbqZbJNG0j1E1kdNKAzrirS1+BKJFUztVLYYWoSOOOXXoiN8G7aAj3jFAR2wH6IjtAB3x7gE64nBKp4KOWHchnNKpoCMOYcrsBnRET4GgI6prRPu4vB3ta9CdoCMqJQo64gthph5BR6w9PXxQ0BHve2CiKUoFHXE4NWhBR6x9yHy6DKK+scEYjLqIDouMNmHUhaAjTxg64lsu6of2R+lPE3TEOsCISkFHbA/KBHUTdETPQjTE8xJG8PyjY1G6DKJhKF0G0XHoCPR4l9sFHbEynk/QEQ1DFHTESl04OhUkCTVxQUesZ3DeM40hFHREdTpBR7zvKPL/bOxzPIAyQEc8i6KgI7r5BR2xjgbNciF6EcrMaA3oiOqwgo44ny8nV8f4BR5d4TkiBR1xzKti1QsEHXFKruEI16LX+YEVdET1uOiGTj7C2OwUQ0eSiw0d8RhBQUe8102e2zS6ORUGL7rF9SxBR4x7uSM2euRn6J0l9TFGd0UaYBrdjd6D3uuuCkFH+hk64mkKBR1Rl1z0gLvtogf5Hx9CH0YL0JFYs4tGj6E/BnTE+jt0hqEj3IFvleTcKuiI8SoT7doZvUPaZhI6wiRhs6Ajs6Ajs6Ajs6Ajs6Ajs6Ajs6Ajs6Aj/znoiHx1BR1xv8MLHowi6IgYEoKO2H7RpWVBR9xb8bK9uhrQEfdWBOiI+z4CdMS9P69najprQEdUdhJ0xH3Wb7tmHVNVFHREuHFBR7zXu67yCDqiYTpF6Ijr8oKOuKfmw9S94R/Zty7+2A0X8Sdg4z8lVZ+ZPSnoiFPyBb0qATri/qmvrQ3oiBtGAnTE7ecHdDb4vIcRm4KOmHjRy/1Wgo6olpH0ztTKLeiI9wWLKOhIH0NHMlMr+mZq+00O9Wz4go64MeTwsvqDkiPoPTmSPoh+gEn6u9+nAR3xeQcYniroiJtrBmEPxh7SyYiIY8oamSHoiGHwQ12XEXTE6Rxe1n3XBh3x6giSHaAjKt4LOqLi8XRCR5wVI0nMWbTkjKLbIkBHHD7a4/wEHTH75BIu6lIu6kpakK6iBenqTMNVBR3RUMjkek82LeiIBrkKOmJCxriyyNmCjhgWcmOiikYDOuLMzKEjdKPcnblr5h66V+4lPRNoZXoo07goQUecCY9gP4odoCNu43qcNq4nUmfjk25mF3TEHVVP090ToCO+DQJ0xPZznOV5zhKgIx8E6IijBeiI7WlAR9z81YCOOEmvkaTXybQ3yLQ3udi3XL8TdMSZP5GQd7B5FhrQEdsBOmL7Q/rCPqJH6WP61D7hXJ9iM5+VoCO26eEVdMRX8RWX9i1p/pt7phrQEfeqRGX18qdxWWNrBB0RLEfQESPeM9DsZac5rXgMcdqp7FEInSvutZmtrDQ0oCOqe6ZzenKJdK5Omkfvvw864lbiAB2xHdNijBuSoCO2cWQSdMR2gI44foCOODxAR2wH6IjtAB2xHaAjtn8M6IgdAwJ0xCEBOmI7QEdsB+iI7QAdsR2gI7Zz6AhahI44Dh6zgo7YpkFJ0BHbdMgKOuIjrE58OmSb18ReC5tp+gQdsb0udg4d8SMWoCPYOXQEO0BHvFeAjtgO0BHbATpiO0BHbAfoiO0AHbEdoCO2A3TEdoCO2M6hI24aCtAR7Bw6gp1DR7ADdMT5EKAjtgN0xHaAjtgO0BHbATriqw7QEdsBOmI7QEdsB+iIQwJ0xHaAjtgO0BHbATpiO0BHfN4AHbGdQ0fImRw6gh2gI44ToCO2A3TE9vRBR2xfTPpp2hJ0xPvm0BEG8WvYJ9ARa4TGaIKmaIaWUZ5BQUesncEJzIbOjs6BzonOhc7tBkxBR6zzoPOi86Hzo9MHHdG1CDpixflB0BEr7beCjliXRHnWZhw6Qm7gGtplZXQVtDuKy1OX1VCetZmAjjhVOI4KOmLdGMUlUtARaxE64r22RovQERUmBR2x7oTujO6C7oruhu6OFqEjcrNpQEdU7BR0xNoT7YUeiPZGD0IPRvtk+gAJOmLtW1FjpqAj1sPKGrku6Ij1CPRItB93S3/0KP7lo9EBXCnPTpdB5ORgdAghPDuCjjjlQ9FhnH04ejxHOwE9ET0JPRk9BT0VPQ09nbuUji1BR3w3jkTPQkehZ6PnoDxTgo5YeaYEHbHyTAk6YuWZEnTEOuPQEV/FNei16HXo9egN6Fh0HDqe3L4RvYncvhm9hRy+Fb0NvR29g6vGkVXQEetd6N3ovegE9D7y5H70AfRB9CF0WtARX/sT6JPo0+gzaICOGN2RQ0fKqj5PHTrCvw+1ussL6O/Rl9CX0Y6gI34WOoKO+J55C30bnYi+Y4cxQUes7xLyF7QIHXGaPyirQf4HoCP+X75Av0S/Rr9Bi9ARFRcFHfF/N8ndkdOCjvjL24COqIuzAR1xSICOiIQxHdAR2vx5TQk64hPl0JFM80pH3WN3ja2aqYMvWs3T5gg6onFLgo5YZxY6Yv1PQEcM/1AlxtCRTCX/BnREN56gIx6XnyYqews6Yi3H8uepVlz2rtIpWe3MOP7Z7HMo6IhH289h7zVBR3xMipGCjvg4FCMFHbFdgI64q1HQEYfQKSnoiFEcC7lXS9AR68KxxxYv4ltO0BHHaU7NBqBTUtARH7PmD3SAjrgWI+iI/O4EHVE/oKAj+rsFHXHMpdlrGc6yrGu+go6oIlbtagi9oCOvAR2ZBHTEumJiysJKsW5+QUesqySq2Ao64q2rlgR6r64GaGR1T9Mk6Ij8vgQdMZ5kLU/bJeiIY65jeL+gI6qLCTqiamB1/WRDoCOaHEDQER95o1T19+rGse6r6ibopu7lEXRE9bXq5gaaCjpi3RKMx1bo1pHJBNug28ZmKmxXkvdCdftYVeDqDmZ/VneMnT87xaofVXeO1foh6IjtXdHdYlXYBR1RL1h1D/edCTpi3Yt9946dn/vE6oUXdMQp3C+WI5OgI3pIBR1xDveAcNCT8/ZyL1v1QI7Qm30PYq+D2asP6T+Evfp6r3rNs5kLOqJ+xvpiJgzVF0/FPKgvkQokKeiI5/5eymhVQUdUAZ9u6AjDYbq7geVfCh3xDX+oneEFHVFziqAjntNgLXrDA3TEnZ4M7mhARxySQ0dSZcI0oSN22e0IOuJmGbx6OoKO4I4YoCO+7XHzFnTESA86qQUdcQjDPaqMa6sejQ7gYaE5rgEdcZwhsSCvgo74tjy27Ft0KK+CYShDeAQd8aM6wl3Mgo445AT0RI52UmqKz8kc/xT2OpWUnEac09EzSMOZxBkZazp+QUdsU5KfAjri+JQ6GtAR025G85q6kBcIrjWCjnjrJe4cF3TE8S/jRXE5j9gYHoor0CtjIz2u4oG6uqTZHQUdsV7Lw3Udj9L13Oo3oGPRcej4yJyeG7FvQm/2bBvVW3iUbkVv4wi3o3fE6oYWdMSP4Z2k565I7UiCjjjl9/BI3sujNCGWm1D1Puz70Qd4uB6M/Ap9CH3YnydBR/yifjQ2wWjq0BF/Sc/1S0bQEb1GBB1RGgQd0d0o6IhDAnTE39AfhI58XYSOTF4FpFFYbWwNEI7Cavut7fcNEA6vToaORGsWoCPtVr1vcbWxNT9vcbX91vb75udltR105MEidGTyKmkurDa2hustrLbf2n7fcL1enQwdCanKwSHtVg0OKa420hygI/mRA3Rk8irQkcKqtgIdeQPoiN9gU4eOWBkFLOiIymmCjvj9lkNHcFMJ0BE3gIMRFXTESo0+wedQ0BG/x+p4BgboiLcG6Ijfb3PT9EddWNARc4jn5cM9k9AR3NG3M19N0BEPBMcdqGsPsCIMlOsQOuKB4wE64jiHYPdlaxE64pCBiYBDgo7I4VnQEX0dpgM6Eq05s9ARN5zm0BHaK670wP0GdERvDEFHlHuCjuwNdETugoKO6IoEHZFDnaAjetsIOmItQkcchzntBR2x/gN05LqmWHCR0zV0wIlK9lfjvQZAgBw4B0yIIBBToAvWzg21mKaT5GXf1Gn9pvQ5d9+p/dXQEY2/Fxmin9yjsEUymBigI//jQGVU8ls1OcOi+AzaxDJN6bq6O4AfaNOXGq5hgEQqcsNW6kloSpW8r006SQRB+UAeqU3ZjvIzVYeA982eb8ru9y7pFupw8DHTuTjFFItOp3OFpY210La0naj94rM0Fp2l/UH0F69LytsS327xVWiTIsyTX07hLH+cfHWNxaduW5ranV0X27bokhuLrr2xtE8eizKksTjBbcsyYfmtc8n505bzC2C05bySuhV/kxJ2bJ7tyVqkpMmZnzRzxrFN6UnO81QokX3y3duu0QnW1n04iE6q8Bc5xS+d7Jxp8dumctem8tZN6Zlci4ggkzjIRyE9b3nH7FKNWckzxNHuIT2kME+M8l+J2dUN+U5MWV03TdnjTdlLGj7SlN2pV6I6YZoyHe1rd3LOMGtEd/UPL7rnf3j533bLc1Nd9CxMbdE93LD9vAx2f3v8IsZUdtGj56dsKkvjeWx/qPx/OS88oY3l9+S8b/IfhI7oDSnoiIiMATqSqHIn6Ii7awe74iPoiEsglJ+L0JGKSoaCjhhG9T8ujacLZB7as2BFA0gFHfF8wvivCjqiKqqgI2pdSWtltSYJOuLuocXcJyjoiM4l6Ijfn0u6c0rQEbf9jqHt94pIFR9BRzR4R9ARvVGb68liho4YaCfoiFLY3JrpXM1/T+WI2ICO+LvQj7fukFT1iK44dgo64m/EUFeluw6zg2LX4S7F/SN05Imf7HLI4b2P3q734J2OPLzHETvsbObIPNv6zeiPhEeqtKCBObIJzBGHLI4uAYNjSYbxL1XSoMcic4Q48DbFHLEdmCO2A3PENth2MUesYNvFHLGCbRdzxMrs+WKOWFXugDniI9CDIuaIz7Iuuh66vhmbYo6ofNxgjnhIP4izwBxhsD0z7zcx6L3BHHE6t4KgUWCOgHXImSMoXelNO2LvxJHBtk/BHLEG5ojtPdGpMkdcRhFzxNeYM0e4lp6E9MI+ELs3dmCOOKQPWmSOOCRnjvBPHUEIrVRijlj7owAhm6ibiTnimAMJp27WNJg0D8E+Bj2Wsw+N5bjQNMz1WDFHbB+XqBlrCuaIc+YXXG/OHEFz5gjHeRN9G30HnYj+Gf0L+lf0PfR99AN06swRp5N5KMQcsX6JqowPc8T6Hcr0uGKOWCdRe4c022CO2L4OHcfWnDliaJ6YIw6/zTOnNN1orS1adj50wBzh/vkjcIGpM0d8tOlgjqgSKOaIxl4G5giZ/C27P0q2BOaIHocGc8SMgyJzxPFVNu+YOcLQgp0Y3rAzr8h5iZkzR3yWliq6IC/chThjkTniARJ0vDWYI963yBzx/LwRr90aKVyI5pKfEqeZ4xeYI9xIOXME+1mUxmsxR6w0Xos5YmVwUdMfULwZ/vXMEQZ79GC0fM4c4R8Zy2MSmCO+otew4R82vc6ro5UcmIeX2Mvo/ZHGSYo5Yr0LfdikAzFHrI9YxRxxPvMpEnPE9oqkirGyJbpjxRzxiJeyUyLmiO05sH/C2ZltucgcYWvOHMEOzBGNqwzMEa5uIbYywKO0MHZHzBFRGwJzxNTTBnPEqQ3MEds7YO+ITVd0aVdSBbCpxJwXpb24LrqfG8wRnyswR9Ru2GCO+DiBOWI7Z46Qzpw5YlvMEftXMTIqHpuqPVrMET1rmmjfEz/dE2t0R/xEonFcYo6Izho/7ZZlMUec/+t4xGnLiEguPi3jyrq6mWaO6B8Xc0SvFzFHbHfEHLHOYo78H2KOOA1ijviu2xL6zMolxRRzREcTS15ba/O6mXj6mCPcmcweUuqE3Rl7Nux5uGPnxZ4Pe35sejhKC2AvwnGgQZVasHmvlnCCEXPEdmCO2A7MEdsU4RrMEduBOWI7MEds58wRnsEic8THoajWIXPE4VulasIubR1/ZeYI4dsSTuFKzBHbuJ6Ududc+/C842LSYI74mIE54viBOWI7MEdsB+aI7Zw5QgiuIWKOOLzAHCEPJ/HV+5400CAu5ogbypleOTBHcCLJmSPYOXME+3OU4oeYI/6WBeaIn/3AHLG9D7ovup/cln+AOeLpt+IzMk15LOaIukLjswg/OzOV45xUPVJijizVjjnifrjRqUoIMR3kUzBHfOTAHFF64jH4pwbmiPe6CptB3TGDusUcEeuhwRxx+Dh0fKpmnfhG0sCk82KOOPwW3qK38v68LTEB5HZSeEdsFsmdnjw6vis+A+aI364TiHMf3qv3E/OBRNTH+EH3/4k54qumGVrMEblfiDni/+WxuNXMEVOf4qc48jO81Z9N1XMW/yJV5UXMER/tObY+z16/wv61tyb4BSZR5rnbYn8LxBxRL2zCsEkxR+xNWEYrvg+TTrhsdkZnSzWhQMJXVcwRx5mL7pOcOZJcAnPEW+flyPOl6gBIGDAp5oidPhfAgXVB4i+E4uIm5oiqr8ki+FzmzBG0C0rfpJgjjhmYIz774pn6wMQccRyebjFHVJRNlva8Nsky6LKpZkJJliP9XUnh8lxvt4obTFfgmCs6D8UccfyVmWVvldhxuhOyKltXSz2t4epu1hdzxFvXRNeKnZ61/b+IOaJRYWKOOHw9aM/rY9NBlTAhQrJRbKfVjQnZJLXH8KbYmxFz88S86C0yn2VLdCtXkpOt0wPMHIl9LdvG8rdOtkt9RdvHcqNJduTIO8XqcxVzxMfZhThQzDpijqQaLZnsZSKSmCM++z5cxX7Y+5OScz22MDkvkktHYI6UPe3jzz2F5Y/NHPEE3w3miCpWUzBH3Cz721jNGenv4uvNHIluN3MkFmE7/YPLLWKOaOR2+lKkpyZ92dNbpH+MNfpUzBHx7dNX/ByJOSLHIzFHRD0Vc0Re7+nrnmZdzJGVzRyJ1IGUvhWbofq2yR3pRPSdWFNOiDniSffedW6nf4ntQftebCLJX+31nr4Pi/XTxF62nyXqAxZzRM9a+kVJjtrpl5EaZcQcWU39mHrfsAzQYrAIiJBlfZD6cmhXdHm0my+5vgK6IrqSL7++si+/voovv97dly+wiC6/vlpkTMkavnCBRXTh9bV84QKL6MIFFvEZ1/Ml1zfwxdY39MXWNyYNm/gy65v5Auub+wLrW/gC61uSkq18gQKL+CzbkIZtOeZ27LV9opfJ1MAi2eyRbs5sYbSLJyPIarGmlsg2KOkFmzFYImOwRMZgiYzBEhmDJTJcNNSAasVFIzvA83dkPdCeaC/0QLQ3ehB6MNoHPQTtix5KSg5PVjV21h+j7MVoozbjSyJ8hX4dIkxe9JsipLGkCzds7Xtcqm7O+u7oHiXVEOt7lgR2nhxfcU41Fag+1OeqD0s8Uchwa3ZJrGa4+khrdmOmd0X9nLKz+txYb/X6eYlcgrLbCb+A8NGEX0j486k9AL5XK63wJlNLakdLqWkSfi2T8GuZxBiVSYxRmaQxKiFOy7LocujyaDe0K3oEeiTaF6Xc2HIYengHJxUjRmpGzAyldrov6vv1/F9/v340yiGGRLQez723qO+91hNLKo5mi2GfjL24e6xbT7WqucHhpxO+pDO29cxEf2jrSP+hrWdZs6WIczZxlvbf3Xoueh5xzifOMpEGbLeO1mwGTdmybL0IvZg4lxBnOUIuQy8nfAzhXX2TtF7pm6T1Kt8erVdzkyxP+LWEX0f49YR3I3ws4eMIH0/4CpEIKa03WbMVsW/BXsm3Wett3GwrY9+BvUomJ5LWO9G7EvVHtt5tzboTci86gfD7CF+1ok9J6wPog553uPUha7YaIY+gjxL+c8JXt9tQ6+PoE+iT1mwN7KfRZ9BnCV/Tkym0/tKfpNbnuLrnfdtnaxH+a8J/Q/hvCd8wEzSz9QX095H6O1v/EMkJJtuIY76Evkz4HwnfWJM2NLW+gr7qI7T+ieNskmg+5dbX0Tf4r9/krbVppNaq1rfRicR/h/ibkYZ30b/wP77H/7i574H6zdwDjzi19VuJvwX328fcb1tyj33qeyzbCvtz2/VWXiB/52hfcb1fG6zQ+g32t9h/w/4Ou449Kfn15LdW+xdX+9UON7X//WOc/7OLnvG25cc6oF5Pei/NDb6KmtE1iekwt5uYULpDvWIzj6/SLSd8lctUu3SY7f82fJXLjQFfhZ3jq7BzfBV2jq/CzvFV2Dm+CjvHV2Hn+CrsHF+FneOrsHN8FTZd4M33Yz+A/SD2Q9gPYz+CTatv88+xH8PGFbj5CWxcgZufwsYhuJn6kfBV7oIK+CrbOb6KNPyKgQq/xv4NNq2XwlfZpjVV+CrbtK8KX2Wb5n3hq2zT3C18lW3aXZtf9d3STON/82vYEHaa38AGr9P8Fvbb2BOxA77Kxwn4Ktvv+a5r/mvioRfvY3+A/SH2R9gfY3+C/Sn2Z9hfchw6AoSvss3sWsJX2aZTIOCraBOgVTngqwh/gTgBX2U74KtsB3yV7YCvsh3wVVM6W5xP3fAC6ikXUSu8mLrVZdTFLqcmMgb7CuyAr3J87jHhq3wc7jHhq2xzjwlfZfs+6oD3U5N6AJuWf+Gr7EyzJ3UlcEXCV/mFfATlNL2oxeERwEchR/oDUb+LF+896AT0fvQR9EFe7PNHGsWsqxofWjMyfIjl4+zPBD7EWT+0v0PqO1JUOErxMY4OxsBgDIoHavSujMHBGKKyJR+FY0jnwWgf0nAIaTiWkP3RAwjvQfhQQnZGdyF8V8KHqX6mRdfL6vDi6gji90IPZK/ehB9PyN7oPoTvS/gJyQmqIqvWq0WrJxZXT6KUO5hS7hBKuccQfjLhRxM+gPCBhJ9S3P00oo0g2vFEO4Hw0116qZ9BGUYqOo2MM4MxMhhnEe0U7FHYJ2GfjX0a9jkh8rnBOI8S+CgKQufHf9VQZRkXBGN0MC4MxkXBuDgYlwbjskyeMeerGUCLVi8vro4prl5R+UWTlkzzp7iMdGVx9apknEbayrhaE9DElzmXKEJc40JOdq0qTFrCDXxdcfV6x6kfih7mYk/9cMJvKEYbS4Qj0X5E60/4uHDq8cG4qdN6TVrKG2jR6s3ZiKbyII/opxpyS/IbOaR5lRTe6mJV/Q/oi9RWXiL8tmK0O4oH+Rl1nMup44xhrysIv7MY7S6iXUy0S4h2KeF3F6Pdk2gqnDn8nPJg3ltcnVBcva+4er9vyFUbD8gD3I1XUUl8EPsa7IeK0R5mVcajxVv65xQFb6Ao+Fjs7H0cfQJ9Mjz1T1nrb2E/jf0K9jPYf8R+FvtP2L/Anoj9y3CQ5wh8A/tX4TXya4xGOn8TIv+WyuOfKXO+ywNOCTb7XdjxBbKaumf2e2z+I3GInUsv8ZZ7Gf0j+r/oK+ir6J/Q1yry489er2iwSvYGIW+ib6Fvo4KcSd9B/1xyhf1dzz+R/YWQ99C/um05ex/7A/Qj9LviY1UvPkeTio/P99QHW12Sr4/lrxnPtd8YnduWRZMX7ihwh25aMe7QkxIKd7iJ54RSeXu61HdFpNqEvgXJXjLetKFyu4CJ/kid4L710oluqBQw0SEnY5+CfSoN9aehp/OxDsBEdcmVRhKTaSVLo9wuVDqbToRz3egqYKI7Fy4g/mj0QjcwCpgotIGAif7oB2Cij5ADE90cXRqTaabUBjDRW2kwFzBRHbUCJnrr9f7UCpjorWM5F+TT0ni6M250c7qAie4SvZkjB2Ci7RyY6Eb1AEwEnng3R8uBiVzvBHdNCphopbhYegBt+8Q/hD4cyx+o9EisJlMBEx3yc3dJlx6LfMzHS2qqnQKYqCbH0tN0mjwD67AATKzIMykAE6ETvsYZc2BiPKoATGTT2/SqTORvokQnYKLjUKITMNF2ACbafh/7A+wPsT/C/pjL/IRjFoGJTvAXJJjSnYCJjv91WXTy0jeJ/CUawEQPjciBiT5OACZiJzgZ0+utDgHb9JsLmOge/wBMtJ0DE9l3Do5JL7mAibbnxjX5J8Sk/T+aFzsAEx0nABNtL4i780K4NQdgoo+/iD/3UdVt7A1gouO3+NaKFrXTbUS/XgAmktocmIjNqKRoGWwGtwuY2FbsjLqyujy7d8NeAZvx7QIm2mZ8u4CJtnfgIDu6m0bAROvOhO9C+K7oboTsju5ByF6p2kIFTDQkcR9030Tvlmi/WJMzNoCJjt8D7cmUlL2wD+QIvbE1eyXARGsAJup9FeHv1AAmWgMwUfyO6EjQgf3Q/uhRHIFuwWiAQaICJtoeZMB0NNhdQtEQ+w5G+FxGIGOioegwdDh6HDoCPT425u8E9ET+xJMIpyMvOiUebmAiNt2IAiZaz+C8Z9ptJhoZa/yGgIkOGUWeMxYlOicW5CU6l3w4z4O+ovOxL0BHoxeiF6EXo7y1okvdcRNdRj5fTq6OcZUhYrIzARN9/Ks8SkTARNtUfqNr0esydWpH12dO1Q2Z8C7RWHNMonFuD4/Gp+raEzDREyLfZA/I6OZE07gLmOhrvzVW50V0R2S848/QO0tGCt5V0gzX+q5Y70HvjTSkLZoQO7fvi/R2EjBR78OISZUETHSOPYQy9rUITCzpoxk9hj5ulwkBE61Pok+hMwJMdJ4w3nVGgIkeCBe96XE4AiZ6GOfbJRWYo4meVjh6h7TNJDAxHjULmDgLmDgLmDgLmDgLmDgLmDgLmDgLmPgfBSbaWet3OE3R+C9gosa6CJho+0WPLo5fwtXqZVe1Yhr/BUz00V7BFe1V3MD+hCPZa55QJ37d07HEb8TyeI/fNHZBwETBweO3M7vjTgRl+I4nyxEw0c5d7xrJHTMiIH7Pzfgxjf8CJqrBTcBEOQIJmKj6voCJTu3H9uUQMFEj1eNPSdVnhH/OEXJgIun8yqhuAROlicYXAUx0Yzj1HQET3cx+QCdBFpIeqUbjJD1TjS5JeiUq9QmYqEm5kt5A6A5ir4MTTTyT9KlsDDDRXMK+NOkfSpP+YZ3kFCpgoidPOgLXryNxoOpnJ7qkv53WEhwXBUx00/0Ac1sETPRESoOwB2MPqRjUeExZdRYBE9VQlgx1OTwZ1kl1q2R45s44AxNJ9giSfTw9CCdwUSdG0w9MdGJGkgln4S02Kvap4bkLmOg4o1N1BwuYaCTiJVzUpVzUlZzxKvosrs7EwRQw8SKAiWreSW5IVDwWMFFNTMm4TAVmARMdnz41ARNt06cWgIn4id2d2e/rHs9AJmCi+zIm0K/xUNk8yocTTXmSPIL9KDaIHAET/Rc8zl/wBEd+ktQ+hZfd0/iqBWCirzQAE20/x1me5yy/wh/v16kmE/emHJhIInNgIvYfiPYiJ2JGk+RlwukIS17F/hNJeo0kvU6mvUGmvYlNs4mAiY4/kXPRbCJgom2aTQRMdObTVCJgou0PceT7CFe3j3EI/ITwT7EZFyNgom3cUwVM9KV9xaV9i0Pg3+xWl+pvBJhoJ64o01OZxtmyBia6VpimRtKkmdH5aTlWLTutlAUcSTvZhTLt7CaXdDbXDVOaR9I5XPdM5/T02elcnuz7vxSYSL9qBAxO31eAibZTbEZhCJhoGx/vZny8G8BEhwdgou0ATLQdgIm2AzDRNn7gzfiBN+MH3owfeDOjM5oZndFMa1IzozOaF8Fm5I6AiYbN5cBEjomveAOYaDsAE20HYKLtAEy0HYCJtvEVbwATbReBiY4TgIm2AzDR9gwDE0Eirs9w9A2wN8RmBrvmjbEDMNHHD8BE2wGYaDsAE23jkS5gom080gVMtM3IFAETbTPFuICJtpkpRMBE27th0/AlYKL/X0asCJhom+F+AibaZrifgIm2af5qZtxQM+OGmnti98I+ELs39kHYB2P3wT4EOwATfb0BmGg7ABNtB2Ci7QBMdDoDMNF2ACbaDsBE2wGYaHsY9nDs47BHYOfAREJyYCI23w4BEx0Hf3UBE22fjc23IwATuSdzYCJ2DkzEvoiYzGDUTNOWgIkOuYytAZioJikBE60RGqMJmqIZWkaLwEQ13QiYaJ0dnQOdE50LndsFGAETrfOg86LzofOjC6b6onVZCP1pWcAXAROti6BVtMUNpwImWhdFF0MXR5dAl0SXQpc2/FfAROuyFYFXBEy0dkWXR7uhK6ArulFUwETryugqaHd0VXQ1dHV0DX/NBUy0ruUZ+Lqsja6Drouuh66P4rktYKJ1IxTPbQETrTxrAiY6x7ZEtyoL1tNla3SbsuAvAiZad3BhssuO6E7ozugu6K7obuju6J7kwN4VfYYETLTujx7gYmeXHmhPtBd6INobPQg9GO3jHjoBE619yxqk3eVQ9LCyPpoCJlqPQI9E+3G39EeP4l8+Gh3AvzMQHURODkYZKitgovVYUj4UHcbZh6PHc7QT0BPRk9CT0VPQU9HT0CIw0bk6Ej0LHYWejZ6DnkuqzkPPRy9AR6MXohehF6OXkLeXopdxF12OjkGvQK9Er0Kv5iquQa9Fr0OvR29Ax6Lj0PHkNr67XW4it29GbyGHb0VvQ29H7+CqGYUnYKL1LvRu9F50AvrPARN97U+gT6JPo8+gz/IU/yITxkjARHX5dXkuU/P7DwAT/e//Dn0B/T36EvoyyqhSAROtr8RPAkxUxacjYCL3zFvo2+hE9B2XVLv8GX2XkL+g9J0JmGh9v6wZPQVMVNGuy4epOv46Aibyv3yBfol+jX6Dfpup6iRgovPhu0ydfQImakRAl0nujpwCmCjcuYCJHuF7LXoDaKccmFhRYa9DYKLH0M0gMNGOgszMF1FQiSDARhQeotUiDSOKbjNJIbrddcaZBib6mP9WYCI1YoZvC5iYGphoaluVYmQ1jlWXrCaxKjsCJuovEDDRWo7NGquAxsuBiZEqOwImGvk3eyzyqYCJ6l8QMFE1AgETffy5Oc5PEg1OFDBR5XMBE23TKVmdPz4OYKJj0ilZXdCDa6oLucen+lN0YVfBBEzcBmCi6p4CJqrWLGCibjkBE70XEyFXF/WnuboYKVzcOSZgorxoBEx0eihGCphoexnOsizow+V8Y1e7up+6unwi8LqAiZrYVcBE64oQzVay20N1ZXQVj7kQMFFjLgRMVL2julpJQ0uqq8fmwa0RmRO3ZmIs4Fqx+mUETDRQcp3Y3LR1I1E7q+tFxjWuH29uYGIk0qiAiaqtVDdyW0R148gYxE3QTSP1KFU3i1VtrG4eqberukWkfr3qlpEqv9Wt0K1Lehyq26DbRkYTblfyVW8fOYU72AOqumNkOONOka9u50hz3VV3wd4V3Y1j7l6S/0B1j0h1q+qepoRU92LfvSN5Mlf3sQ9/dV/7ZlT3i5ye/SPVJasHRHIgqfYgvCfn7WUPuuqBHKc3+x7E1oPZq09kitwh7NXX4VlTWWfPSp3lw5BFsa43izvrJZDNmSrN2Rwle3DNZW/qjNa/jNa/jNa/jNa/jNY/tz5Iuecz8QepJWUfB3eyT3AGs88JDid/z426Rswa15h4BM1intyivnjikThL2D1SuEaPtVnK2M360h6KLlyjGjAmexHPwyuiC9yA7nr48FYKPkvff57pT/9+Uic5gcwQtNF2hZB/gDYK1+gGqO8YO1nncTvUlMlojczdo2tmflEEXKN9ANbhZVXANdJZvAFdrht6trlp4RoZ7cjoVOEarX+nkeFrPEi/8cPVEa6RkVzAy7LZcGBrdgdlxlkyzpJxloyzZLymMr2myNjyDgV/yPKOxdWdiqvyrmy/uktxddfi6m7F1d0LjmHlPYqre+b3T3mvYOydexWW9yk4OJX3LXg0lfcrru5fXD2g4PJX7lFc7Vnwmiv3Kq4eWFztHd2t/u3gv1c+qLiq4Vft3OHKGofVflUDstqv9i143JUPDVd6WDAOL1yyKJx+ozLwOVA4AddCehGF0wrppXo0OgAO5kC+HYN4V1P1qw6J1EBXPca+UtVjM9GOGhROXYIonI5zHO//EfZbEIXTISegOYUzeRoKp0NyCicpOY2Q01HYcNUzScNIk6NF4XQ41cPq2aTnHJSirCicDsfzQRROFb+ro1Gqh4HCiX2JJ8gRhdPxqR5WL+e9PYY37RXolZG/fVfxlr66ZATwNei1ka/3OnssiMLp9+cNJfM6x5b8VR2Hji/Jm0IUTm+9Cb05UjWkeotJfNVbeUvfxvv2dvSOSG3d1Z/xbr8zUgtY9S57CIjCKd6TKJx+z99LzAkuw1Tvi/SSqd4fmQf6AG/sBw1+EYXT+nDkr9Ijkfmbj0ZL/yCF06Wmc/3lajnP36aW852GlgsifQ1bRhOCX1mgcIJhuccvk3+kcKrlpj2Fc/IqZMnCamNroFIWVttvbb9voFJ6tR2FU8WE9hTOyauQNAurja2BwllYbb+1/b6BwunVyRTO2DDQyRTOdqvet7ja2Jqft7jafmv7ffPzstqOwpmnKlA4J69C4SysNtKc7xuOnO/bbtX7Fle1tc33EhanP1LQsRosThX+o834PG3Oh2kLPlI5izM1ppzmMrE4vde2lI1pLhOL0x+pofSwtMFVhtOOHVic/kjVGeYwiVZrADhicdoGs5DO7dZvsThVbhSLU43z6byUCWeSxVmWf05tO3AcJzslHbE44WkyN0lXyFpicXprYHGacRlYnLZzFicxB8R613Ud6BmYug5yGbjrYMNhppPFeQUsTrVhTx+Lk7Z06JmBxUlT2JUegBBYnB7ALhanU3VUWRVYsTjVSi8Wp65o3JmR8OticYrYJhandTpYnJPUtziVhDUwnZrm/C1RkYRhaIpPUA+hGBUqYqmzTv2BNpI15ahFyH2o0IfB1uK01dVbIo09CVk9ycark1o9mH2TgzSsS4btTNzGRcVyEBJAPUiCW7gKldxlO5pfjnLqK1MXpfLJIcnx4lJQcmhWbY9knCxCgwejOHAea3qURqt4F0e+SWNowIwu+g/L5pwrLD5XWNpOVFh0lsais7Q7yORFe91eOKYWX0hjUYS2iyqeq3GNjaUtppdj26VBNEwWXXj7RZnQWArpZFHONBanvG1x0YtlUWeXD85foJyPf0WytUlnX5cUDhB3Ic//+BMiyxjPBeqMOtog4t8M1lPH0e5cpmMqRKRO2fMQfjN/7rKkvC0HzjECIX3BjvrJngIzcF4dROUr0iOfc+0oZIK6/fM8UbQNJt8PbYnxv6nEaPe2xGjTKhrK40Vx0nN9QJ03O8AZqMNGu838klyv21hNAX0qYoCq7SjL3DSRldFKJvp/1sm3fdY5FZxxyRlYZr+oaU75ZTQ1zflC8ZEsH1EsMx9ZXO1XLCf3D4XJo4rRwiCs8oBgDCwMkSgPKq4OLq4OyQdQlI8JxrEqJ7v1rzw0GMOKZxxeTNhxxdUR7cbFqAcY0KqweGqY+v7LssqB33+XvtLkV/339VTtdd9/P5sAxBnOJxmv4oxXccarOONVnLUUB32sXRwds05xdd1i5PWKq+sXV/d3iV34UUHPhR9VETHgR914IvyoXQ4G44rzG3fXtqzrT0mWuNItCKnfqxN4yc9XkdNsOn+quckFIfULf4HUM9ItWD7eENJUMz0IQmpcaRc3+6QtniQgrXmKlHRRt7cLQqqitSCk/nAs4cYWQUg9a11bL16AkFqvcoFfEFIBDAUhFeWseZJxjs3fG5/a3Jp67OTfXeDveoRruwFCyudmSKICc1ecpQUh9WdoqJunBCFV+rtSZeh6HB/ZNghpU6c9mjqv2zTbvU2dV9QNrE/M586xSV+gX1JbX8d33ffrMsC8H8powVaNE5QeHel6W3VzSgehg9Eh6DHosehQdBg6HD0OHcHYwzsZ2HI3ei96H/oA+lCkolH9YexH3bhU/3nkGSMes4qj6v9opczsl5Xp2l4lVV6l3d0CkK6ajpaulqpxKV09VeNVukaqoTHpmmUXbNbKNNtlunYq34x0nUQu0Om6zEe4nmlm6fpAYzdI3I2+YaoxYulGqf/NjQnfxI9PumlqBstmhGxuF4J0C8+VmG6ZqrqRbpXpf0m3TlXRSLfRSMqmdFu2bse9sb0ZO+kOnH1HjrNTomafdGcPMEl3yXx37ZoKI5vu5oFv6Z6+9nQvDxJJ97aTszjKeptpLlPloVxhPpXuD+mlh6G0ac9YzbBpLzctpgcmw6S97cCTHpQ4Zw72CyHt4xlu0kMAr/dN1OafHmrX8fSwkog96eGZesrSI9zCnx5JeL9ElZ20P0c4yu+E9GjPtJoOMKUtHRipZyod5Ec1HRwb0TuE8GMiFczSY92OnQ6NdZemwxI19KXDE/8jx6EjQJwfT3pOMNYgPdGziaQnZXoK0pMTVXvTUxL/a6emcoBPT0vNxqFAlZ4Z6d5IR5XVGJiejZ7DLCPzVtSwVp/PZLn6/BXRb+r/U5GLVH2BzsqN+vvR+9IP0A99/PpH6McMN/sE/RT9DP0c/QL9Ev0K/TrRP1X/Bv02FtWz/jfs79C6QypXFxpYKtcW3rqV6xi92LZoVYMi2zV9VG5o2xRWxxZaJCrjCo0blfGFd2DlxuLqTfEE8b1k3Jx/ESq3yAfNtMYKI9oqf0bfRRnRVmFEW+WvKCPaKoxoq3yIMq6t8jH6CUoBuPIZ+jn6Bfol+hX6NfoN+i36N/Q7tI5OQr9HVZXIB6m5xK4ymxqOnnKRNecGQFfwYDflZ3vdNBgeGXqY4iiXohXFntQq6W95WAdxg2S2iBseM33Q+HxXrin+X7d6no/KbXl7V+X2wsC9SnF8aOVngvaU9PhX7sw/6xUqQfEIV9/SpVNNvZAuk6hROl12Nj8Ry1WsXVM1NaTL2wUo7UaFawVXuFoeTNW03vJQ+oDupdTvonqW6ulumZt+H0Y2tSxmHG7L4thLpHoztCxFS+nStKYug67UWfu2rAoXcTVXxFpWR9eI9B5rWZs465eVUS0boBtGcghs2aisRpuWjTnypuhm6OaZe5S2SPVda9lSb6Omlq086KZlazfat2yDbotux5d0e5pBduDI+G+07ITu7K9byy6E47/RshtXvTvNIHu4kbllz9RTf+1FE8reZbXutuxDyL6E7F9yswmumC09uIqeaC/0QPQg9GC0D3oI+kgmR8TKXYV2yMrdhcG/FcZ7CvjuUkF/2qIHYA9EB6GD0SHoMeixGljT1DIUHYYO99u75Tj0eOKcgJ6InoSejJ6Cnoqehp6OnoGeydFGomehozjm2eiFxLkIvZjUXhLre9dyKSGXoZeXVCprGeOtNY2QlpYyvQ9rdHXV4ore9jXG39WysjrCamU3BdTwlap1KqvxqtbZM2nVZivr/V+bvaz/vYajZm1OyIp0ctXmTjVirvYTD+CqzWNXt9p8fsPX5icm0yzVFkz1/9aYULZGtbq2sOf3rS2SqTBZq3JGSla1LmiL3dtqtU76ptcWIz6j7WqMtqst5V7R2tKpGk5ry7iZtIZPVG05tCtHXt4TPNdWiJ3+FX131VYinSuThlUqDuke+7pWTTQwqraah1PVVvdQ3Noa9lSsrRmJnFlbq6yntbZ2p8Ok67g8VlvXBMXaem5aqa3PGTcwOLqGN1RtI46/MboJ1wKNswaNs0bzTm0LPyM1mndqW6VinNa2Zt9t/AWsbV9x+neAzbIjulNFT0FtV+zd0N3RPdA90b3Q/f3OrwEzr/Vwl02tZ1mdTbVeFc1fXmP6k1rvisohtYM6C6pWO3iOXtI+FV8dTS61vpWe0kM7O7fxbqodzlXA+K0x0VStHynv747R2lGex6t2dKpva20A1zjQZa3aoIqe39rgzmqiqQ1xs3YND43asX4Sa0MrqovVmGiqRoNV7Ti2UjaoHd/JNszP2onYJ5GGU1IR8GqnpnLKreH7VDudrWf42rvBvuhWQiM0RhM0RbNYzbndymjFDdrdOqGd0dncIdttdnQOdM5Mz1033O+70QHXjQ64bvOU5LnRDZ/AbvMlKrn9P/bOA9yK6l77Z++Z2fuAMc0SjR4OB0SRcmwIKoIlNhB7LzFKERAUBUWMCthiL7EXBCsjbjGKBVuMsUeN3tzkRhMTY9SYHpNobBjzve/vrLU5Qw4BUfPd3Ifn2c/7/Pfs2TNr+pq1/uv9ta6CrupBcK2reYtaV+dXvLVb1/Ddr3VNv4+0NqFdmNKMdmUezP9bu6HdUe7zrT3QtTM9nlrXQXvaF7d1XbSXz+3W3mgf3y1b+6KtlGE9/ru+PW9bNyDe0M+L1o3QfiiOsq2Y/7fiKNuKo2wr5v+tm/n+2cpTo3Vz5icbsHUwugXN11uy5K34dWuO5lkcTeWh8ZDNu3l8d969pAdivhZxD2JSHHNejvKezsfO17VFQ97LN6K8N9onUeZ23hdttZtBvh66fqL+93wDVwjzDTuJ/p5v5Gp53q+TehzyjSv+b/9GFSYf4Be3fJOqLt5801S3jnwz4oHEmxMPIh7szckhGuRbUjbSrvKtiUm7ymmzzUm7yrfLRLXMty+LrpTv4Isl56LOh1ZUech3NBY9H+auyXynVMSvfOfOqvTmu1T0iM8hGuQ8IvPdU9nz5nukOr3zPSu6bPO9Krp8cogGOSmO+b4VjfHM97OZfL6/EXq5OuOkB/plJ/9qqnpLDhM6h2iQH+wWy/wQpgxPdRPLR9jcNSfFMWeEb06KY84I33wMSxibeG8c5jbqfBw63q9L+eEoRIOcNJL8yLL31VF6gWjIJ5pnlk+qypUxPzrT7Ss/JlEfTT6Zch6b6fLPpyS6lPLjKA8vrfnxvpHmjPDNT/TrcD4VnYZCm8tPYn+e7Ep+fkrqFtRT+RdWvfk3Mllo5qcbZ5gzhjc/z86Q+QXE9GHlGPPmpDjmjN7NsQTPL82Uz5Bflok7kl/OfsCkN78y81quSvXans8w7SO/2q8q+Uy30uez2JNYV+XXshysgXJs4XOsq3L8B/LZrDdnmTex/DmuFuY3V/Rozmuc27f4dT6fm+mmkWMllN/OVs9jTvqJcmht+V0eSZHfXfXemO+UofwdP1Lzd52Jkb9nCmz+vm+e+QLW9QH6d9+ucxKH8n900qtlbX2/4tU2yOTDWdvQ4y9qG3mf1PqlymCpbew5a9wKagOcQVHbxCy62qZlVXdrm3n5tYH8Ssd6bZAfoLXB6BZM2TJTH0cNDkiNq6b2FZ/ttW3QbT0wobadK8+17cte4w6mp9SGJDqOtaHOkKnt6EdwbZhvaDV6OmpULGv0dNQgqdd2Q3dPlUFR24PyMyK+tpfHNdf2ZjpXTW1f4v2I97f7aI3E4NqB7nOsfbU0T3oQ+jX3CdYO9hVdO8RuErXhlH9ERVdEbaR7RWujnCnR9TscERKrGu8uvj7ML369p+2rxmYlulc33htfE+4rvqzdX3wNfKD4Gtjm4hIMQBY2PDb+CP0fFOeTRpxPGnE+acT5pBHnk0acTxpxPmn8OfoSivNJI84njTifNL6SvNTQeLQ+qy5CrOm79YTxI5eArfHlWcTWwJJYG3jNOoBCOsLW6DT4lLA1XtpAdHPWMggdjHK6ClvjMhexNY4DtoYpdMw1bA/SZQd0COgWDGkbqLk10DEnbI3ZEwFbw/Rd+S+nq7A1nh6wNcxfwNawrwrYGubpAFvjgVdFbA0xeex1bI3jjrA1nh6xNZ4+jikRW+MpRzAlYmscH4VOZGkRW+M5j2H6krA1qp8LW6NsZ2FrHE91284i2Brr99jegK1hjwVsDUt7GX0FfQ19FcXVZJmxNS7/krA1nuc9lFursDV+Y10qbI0T4YSt8b9utVd2wxxrSzeOdQfYGqa/4G3/+Nga40vuK+tpWMfWeGcGbA0asTW6HJYVW4MXze740nSArSEGjvBpYmuYv4Ct4UQK2BriJ9Hvc+o+iz6HPoP+kJPtR+h/o58KtgYrng6wNUyP2BpfJovH1vhm8qH/K2yNb2LPox8BW8PxCtga1l7E1nhLI7bGccTW+ASO2BoDOAK2huUEbA1xxNao2SFia9i6gK0hDtga4oCtIR5sr+8SLxSlLV17rGNrXMKIrXFMHaCOrfF0nHCErXGMuWIRW8MyR3AUyDoo0Txex9Z4zoitcXwc8wRsDXHA1mR6sU0uZ5zs7IqN6G9PjYe4043JwtaocVXYGmUQCVujTFdha9zAFbE1hpVMKz/5MbA1+pewNTridWyN4+XYmv8AbE1FuWoRW+OSdN2wrPm7MkVJuG6uWcl2fEuHreHMZzhVHVvjOGBrOGMDtoY4YGuIA7aGKyhga4gDtoY4YGuIe3BFQB4UtsZxT66pgK0hDtga4oCtIQ7YGpbGm0WpP8sZwHI2QUnTXQRb4+lD5WsubA3xMP4VsDXEEVvj+fdhiwrYGpY5mjVGbI1/jdgaxxFb4zhiaxwfzbNsCdgapsgxHmyNp3xIqSK2xt270/1rxNYQB2wN8aeIrfHbSnJmVd1wyVlpX2NruF+dV9G5nZxfUWeEsDUem1/E1mgccXIJ8aXoZfzrCu/P5Eriq9ydKmyN74QRW+M73ix+vQa9lm736503ntzAcgrYmopH/c+hDDez5Iit8V10LvfPW1Nlewpb4xLexn11njvHha3RqH9ha9QoLWyN57mHrbuXOe/zq4ewNULDCFtjwM23cTwoYGvcHS9sjUY6JI+x5CcSvfcJW6NmYWFrjCF7iqU9za8BW0P8rH9NSyR+l/3+niZ+Fghb48HsAVsD6KSKNpJl16nRo7w7NxpzswL/+ozbEIStUXtR+jnvsYitsdNCxNaw5JVdqnQVpqxaNVH7S6nnX41/rY5+maWt4XYMYWuc9QcrOuUpnzajXRkLzwiRtBtL687a16pYA7aGOddhek/75AtbY+1V8YD93tUXja2hhH3Z3tZOHi+/Hv/lBc1ZpMbWuLorbI2ejMLWqBWujq1xOQcY5SZsjSquwtZYN0MHuitc2Brvw0FMidgax1uybyO2xuifiK3RUa5jazzn9m56FbbG3PEh6FC3v6U7upM9HWZra2FrDAPaueJjtIubXiO2xvnVwta45HsyT0fYGi9tP5/D6f5YIhxA2Q5k7RFb4/gCv+Ck3/QSIramUUkLwtaoaf0Tx9Y4bSBia8y7LWJrPOW/fAUJW2MQzH+XlYMtbI1TXH6Urg62Rl0AwtacZWyNMyqzF+jo/0nZiQQ/TZz08iJd+T9zG6ywNU6leAm4zC/KZvS+XHY6xC891il7BajNq/bQE7bG6Qq/Sp1C8zqpAr82HkjYGvlpZL91M76wNXo3EbZG+ZPC1ugMFLbGqRdvltVBkL3lMVDC1nxe9oS6c/A5Xh9ja7yiBb28kAW90T5oX7TVm7xgPXR9dANvvrA12nxha7T5C/p584Wt0eYLW2O37U284cLWOGdgM2+4sDXacGFrvMbB3mRha7SxwtZoY4Wt8ZCZbbyZC2jUErZGGyhsjTZwwRBKMtQbKGyN1zKMMuzEMnfmX7u4bB8JW6MKhrA16vlaBmyNejSErbEOR0egI9FR6KHoaHQMOhZdPLbmwYit8Wx/Q99Op34EbE36ehFbo04lYWus+5Y95mi/srjvi2BrTBQ63i3qwtaoa1jYGqmwNbbGPdsqbI2S04StUYv3ggvkEWhsje5+wtZ4+kVMv5jplzD9mUzpLsLWTPCwwuXYmkWwNZn6OoWt8bnXraQbzocnuxNH2BpVCYStUV+YsDW69QlbI1Vzg6efwfS1vWOFrdEh+/BsH9APz7Gqeud5zmOenj7cwtZYv8k8FzLPumU99IWt0WNF2Br/eil6GfNczjy9mXIlehXTZzC9D2uc6ZNE2BqdHsLW+CTpy/TrmH49029geivTZzM9Z/pNTF+PMtxsFbbG8S3EG/g0E7bGJ9uGxLcRb1R1Seahd6R6ERa2xrmR/ZhyNzqf6fcwfeNG5Q4JW2O9310/wta4/P2Z8iD6HaY/xPQBlO1h9BH0Ucq5CfHj6BPok0zf1I85YWt07IStcfyMT3thaxw/y/TniP+L6Vu540nYGusPPYpN2BpZ0whbo6GawtZYn2f6C0z/Cv/9Kfqil/Dhz1jONpwPL6G/8FEWtsbHelvmeQV91UdW2Bof3+1YwuvorzmOv+E4bu+9LWyN53kQHNhczrEdWPKfiIdwjv3ZWW3C1jj+K7eID7mB/IOl/Y0lv51qDPiH7yRKZBW2xlPeI36feAGx8jCXY2s+xtIeLGBreDO61mN7ha1RD6OwNd//v4CtIaE3YGuIA7aGOGBriAO2hjhga4gDtoY4YGuIA7aGOGBriAO2hjhga4jvwdYmYGuIA7aGOGBriAO2hjhga4gDtoY4YGuIA7YG05uArSEO2BoMfwK2hjhga4gDtoY4YGuIA7aGOGBriAO2hvhFny1dfkb8c+KXiH9B/DIxznVdXiF+lThia2zUE7E1jn/js07YGr2DCFvj+PfEfyD+I/GfiN8g/jPxX4g/AraGmFbliK3hzC9ia9zCELE1jiO2xnHE1jiO2JpJi2JreDe8iPeUS3krvIx3qyvRq3j7mEF8NfF1vNldT7x02Bq/A97Lm9R9xPdTnvMzrStia1hmxNa4nqYbtQy/5YENtkYPiAV3cOO9C52P3os+iN7PjV1+lYvB1qhisAi2xoyD3Xh8TCw9IJ97sDUhOCYGk5MZap8AWxOCKVlPuf2BrXE5R6NjKMNYyvB1pnwNPZjphzD9eKbsge7J9L2YfkK2oXLP5eOuD9iawtdpzD8CHcm/RjF9OlMOQA9k+leZflI6U7aCeofWB2xN4espPMKOpZY7hVrucUw/lemTmH40049h+mnFv5/ObNOYbTqzncT0M3ienkkdRqrbNdiaEJwdg3OY7TTic4lPIT6P+HTi8+PMF8Tgm9TAz6UidGGiRFkHF8Xg4hhcEoNLY3BZDK6IwZXVDRv0SV/Sx9ia4tcZxa9XN05v0KeiNwXv2JnFr6r+te2Ta/RkTx7SK75dw42tUSVH2JrP21whnsDXF7/e4HmErbGOh1h6ONNvLM42mxkmoEcy21FMz/V24ytC2JoQ/BO25rMN1UaVR40NYGv2bCteWwnnuloibI31f3hb+THTby3OdltxIbfzjnMV7zgz+NfVTJ9XnO0OZruM2S5ntiuYfmdxtru4mnSJtV1ldxe/zi9+vaf49d5QznCB3MeGzLIKW+P4WuIHirN9m69gawqn9EOcezdSFewIWxOu+seswtY4fpz4p8RPEL9A/CTxz4i/R/wq8VNxIU8zEa9UYWvCbeRZgno5n4sz/xcvj7/yPAte5wKnBitsTfjj/z9sjbqGha3xULilwtYUL6sFxevIFeN2l8/feR/8kDNnNofmJra9I2yNzyiwNW5aaYeteVeOs17g0qhaFdKpAVuTvBaxNaaQTOchdZJHBpVOdkOlsDWecirxacQ0jwtbYy1iawyOOZs5z2HOc93kWzqPToQL3OgqbI3hLxfxQI/YGuUnC1ujhKLSZTz06RYUtsZLiNgaNVeWZlSVMlTH1vhXGsxL1zU6vt4mn8LWaPSWsDWeMpt1FbA1bk4v3eyqr7A17tS4hbLNJb6V+HY3qgtbo9YkYWuUohaxNfwasTVq4xK2xnpv4m7c+5y3X8fWqOlP2Bqjf/DvErbG+J6H3CUtbI2xPg+X1T4WsTUruGwBW0NXyBOdvK4nib/HVjzVyVv9dKMa50vPwKMpYGtCdmjE1lCMV/j7q0x5jR0VsDXEAVtD/Ft20e+IA7aGOGJrvJlvsJl4UpX+QoEDtoa1vMX8EVvjzXwn8+GI2Bo7XwVsDaPvA7aGGKPRiK0hDtgaRu4HbA1xwNZAQgnYGuKIrfEyv8B/MRot03NXx9a4DBFb47iArWG99BwJW6M6cLmprB7nMu3/wtZ4zq6uxZW7ZUr/FrZGbz3ltfhXAVtDSXoyPWBrWMJCbA1fA7aGOGBriDvA1qC7eQyLsDVWsp4WwdZ4CqM/FsHWGINyIPrVVHcVYWt0k6xja7whh6DDU6UQR2xNqnFtwtZ4aSS1Cltjjdgatd8KW2N4SkfYGnVwCFvj5R+JHoVOZAl0C5apaEVsjR3qhK0xcoXElfJxlJ+EgTJWDGUSBspktpenJmo7LU9Dp7M3TkIjtsZbGrA1Jt0LW6O7gbA1noIhgLA1LsNZqcb9lc+mJB1ga9w6HbE1qUarCVujk1/YGmtH2Br5AZa5a5WvcMeNsDXez1exV2f4lUHYGq+du1Z5VmrwyjXERWyNbStusJVx+UZn05Vne7RjOU+Vki1sjVrRha15GmyNRmsKW6MWGGFr1PZex9YoyVbYGuu8klJ5y3eUdS8q34neZYsYYWvUISVsjbpmhK0xvuded6CX70vUWbAkbI3HKpa/iz7slAlha6yPoo+h/y5sjUZRCVvjI/4KOJ5Xy3rulF+jbMuIrcHHZDm2Zjm2Zjm2Zjm2Zjm2Zjm2Zjm2Zjm2ZrHYGg/aSkaWjWUZ5XpIcmhZ9bRktGtfyZiyarbJWI8HTw5jyrhE+RLJeNfENLTG6VJHuA6TTHC9pUNsjZO1fpCqvlfH1ijzoY6tsZfmj0m1ej7VQJuExv86tsbzvEiC1s9IJPu5eSLC1ujVTNgap9S+XFFNSdgaNaoIW2M4zquuqyevudFb2BrP83rmVLeArcm85N+mt4Ot0du6sDUvgK15BmyNbP2SP7n2K2yNt/fPlApsRx1b4+XzqihsjboGhK0xjEZeHcbW0BgesTVuZj+4c8nYmlTGX+nwihCuwta4QX5ko/JVhK3RIKw6tsZN7mNItRpbUa1e2Bo36Y+jAX98ZzlgC1vzd7A1XssEEqiOJAHpKNLDJrL2iK1RO4OwNfKTEbbG8bHEUzopL0XYGo1vFbZG1mTC1nwLbI36OoWtmRywNRR7GsWeTvEitsZ0m6XC1lCYs9kJ55Atdi45V/B/ha1xrtTFmfJ8hK3RwGphazz/FWwUY+vSWfz3mopMddJrM+X/pDdUDZS5kV09u1GHVdgaNToJW6Ns2HSO7VuFrXFpA7aGOeeSJ3ZnRa9Lwta4F+Nu+jLm06/xQNVL/jbxg8TfIX6IjK/vcggepjyPZGqwFbZG5jPC1jjL7nFy1Z5gS5+ktN8jfor4adbyDEv7Pvl4z2aT6NqI2BqOVMDWEP/IDRHC1njKjyl8xNa4GBFb4/jnFOkldtov2GkvE//S73cpHWHC1rgYNJsIW+OYZpOIrSGO2Bon8v2RVLc/UeyIrXEcsTWOI7bG8d/YtHdJCHwP7xo534Ct0cEVtuYHYGvsA5M6QU7YGrtbVFIhTYWt0VknbI2TyjrhNtPZTS7C1tiNh+aRbEW/ewpbo6GCwtY4hez/JraGPsSIrXEfZcTWOI7YGsfkeC+CrfH0iK1xHLE1jiO2xnHE1jgmDzxia4gDtoY4YGuIA7aGOGJrjAUJ2Br6WwO2hrg7yydXXNgax2STClvjuCfxusS0KQlb45hc8YitIQ7YGubZgHk2JN6IuB/xxsT9KVvA1hAHbA1xwNYQR2yNt2ILPyaErXG8FfHWxF8hjtgaLz9iaxxHbI3jiK1xTEZ6xNYQB2wNccDWEEdsjffhXvx3b2IavoSt8TLpVxW2xvEBxAcSf5WYMd1dvkb8sbA17JNxHMfxxIcTH0E8gfhI4qOII7bGS4jYGscRW+M4YmscR2yN48Via8h+D9ga4o+AraFsAVtDHLA1xBFb47XDkS9ia9CIrVG2ubA11jKaoCmaoRW0ihaxNaPB1lg/Y/Ox5hVRrsHmz6Gfd9OlsDXWL6IroSujq6CrVdSA2bw6+uWqrDOErbGuiTahXZ3lLmyNtRvaHV0L7YGuja6D9qwqh7l5XbRXo3ESvdE+aF+0FV0PXd+NosLWWDdEN0L7oRuj/dEBKAlmzZuim2WqUAlbY90cHYQORrdAlwpbU1Wto3kIOrRRz9bmHdFhtpoRtsa6q7tjmndDd0f3QPdE90L3RvdB96vo6S9sjayKhK2xfg092NVOYWusw9ER6Eh0FHooOhodU1WuRfNY9LBGdX80j0PHN8qLoPlw9Ah0AnokZ8tR6ESO8iT0aI7OMehk9uSxaAFbQ8mPR09g7Sei01naSejJ6Cnoqehp6DfQ09EitsZn6dnoOZyl56JcU83noxdQqm+iF6IXoRejl6CXopehl3N2XYFeyVl0FToDvRqdic5Cr2ErrkWvQ69Hb0BvRGejOXoTe3sOejN7u4bewh6ei96Kfgu9ja1mFJ6wNdY70DvRu9H56MfD1njbH0EfRR9Hn0CfdI1U2JofGVtT1etD89NVjT5oJj+qQ2yNj/4P0P9Gf4j+GH0efcF37OafoD81ZbL5xVQEwI6wNZwzv0RfQV9FX/Nol2bYhc2vM+XXaBFbo+qZsDXeP39w/bZDbI2Py5voW+jb6Dvou1WfXe9V9DLS/H5VSenC1qja2fyBuyOL2Bq7lAhb43G+ZM0JW+PpAVvTyfZWcxg1PBecDd2awtaoDr/02BovMGJr3CvRQm9FxNY47l/29FszDeIrfwtdVmyN9d+LrfEb8bveCmFrZFoibI2xKXRKNiUgV1LfnIWtUeaPsDXWaqLBg8LW6H0hYmsS2/uvYLciYWtUqxe2xsv8rN8XIraG5VCNFLbGSjUyYmvcjVjE1vhFr2l198U3fRldw69gwtYYkdMEhqaLTbOFrXHcEbZGno3C1nieHh5CK2yNktya1rGnorA1Ltu6rKWX2xaaevtFTNgaWc0IW2P8QWtiIMt6aMDWAI7ZEN0osfl/v8Rr3LjkZfZ3L5uwNXpnadok0VAyYWsMFNgMtM3ARJezsDVe76BEfYvC1uhhJGyN/7Wl3TyErdH4DmFr9HYjbI3hQdug29o5UNgab8X27jcXtsbLGeJWF2FrrDuWDR4ahu4EFGZnt8YIW6NHp7A1BiXs5uwCYWvUPiNsjVpmhK3R25awNda9PfRG2Bq1yQhbY4TBfoBs9ue/B7iVRtga+acJW+NSHeT+MmFr9CgUtkZvcMLWaJCgsDVe7wi38Ahb4+WM4r+H8q/R/GsMZRjLvw7zv+rYGuc4lT12RtgaZZotgq1xDs8yYWtCOtkbJIM554Q0m3+EQNgaj6bp5itiQfdMjQDC1jj/pIc7/YWtEQhY2BrnpfTM5FsrbM35HWBr0H7puLZspZizJGyNDA+FrdGopU8QW+OmrfcZO7mAy22c/amErdEpJ2yNNWJrrAFbQ488nlSLYGvkabMkbA2jHRmdKmyN9R80MrxNBuk7vrg6xNZ4JFfE1vjgdrFH0NJja9rnQwpbU/i6e/Grsivbf92z+HWv4te9i1/3KSSGCVtT+LpfOH+ErQnBASGrsHpgIcFJ2Jr2GU3C1hS+fq349eBCyp+wNYWvwwtZc8LWFL6OLH4dReaeHwVOZhO2pvB1dCEdTtiawtexxa+HFTLuhK0JWzo+BocXNlnYGp9+DHyuY2usOL0IW2PF6aVpkjMW6tgaz1PE1njKca5UCFujlhxhawx5OcEVGGFrvJyp3P+nOW9B2BpPOQmN2Bo/fU5lSsTWePrpTDkDPZM1RmyNcgk6wtYQX+CcCmFr/K+IrfGd7WK0A2wN6DHytYStMYzmKu7bM7jTXo3O5L43i7v0NaULwNZYrwPpdT13yxu4f95Y8t14NnGO3gQIbA7xzWgNPNkt3J/noreyhG+ht4EBup01zkt8l77DGQLC1vi/d3Gfv5s553skYB1bcxzYGt+x7y8bDPcA+u2yKITC1sgPXNgaP4kWj61xrekC3+2FrdGzSdgalUHYGj1lhK3xlHlUyYrYGsX/jK3RqdEeW7PwK+iZwtf6rxFbU/ja/tf2/43YGn9th60RLLc9tmbhV9Azha/1XyO2pvC1/a/t/xuxNf66EFuTFig2pXZfKXPha/3XuL2Fr+1/bf/fuL0FTk29VBFbs/Ar2JrC13qZw3/jksN/2331f4tf9Wtb7iXYGrXKLoKtUQ5neTumBGwNj60h1IGHVpzjRHOZsDWefyfmWSpsDQ+pBQxzWDy2xi3GX3DNVtgavbxkK1EnXFZsjYwKha1RbTlia8DTBGwN8QgwNHio9sE+UdgaO/CP9tUhbI399scSH0Y8jn9FbI2ud2FrVM/sMznRfVjYGvWFLR22prKOn8nSpcTW0Ja+Bm3ymF1HbI2z0yO2pqK7jbA1qgn3mdgo5KWwNap5Cltjq8CzyvKTz8/GevEc9ONia3ibC9iaZAz6XVVM1NEXsTVvLTW2Rn18wta4BphWpkRszXHtsDUXeDlpBUtwIUgeaUjkGS7siPrV9UDfWl1Jnpgdp64w9XKormRVL1ZyEYSXU2wkXukuVwM+MtW5oSF7238JM2tRV7OKRT7ioWhd8aN11T9tKyp8tJb6R2tpt5CFH6Aq7ZfpMtQBNGxR20a1/6i3pL6NC/+lArR9HmhXhjPDxxve/tOed9O+nHy0Z+qfsIvYS+EjypIKpoVzCLTnE0rin1Tav7I3xBXSbOx/OSJ6Zp0AH0Co1Bo3EFoB1UGX9/um/J3N9JyasgHxBhxEVuE9f1HYfG17ZQt//HetYoy61yjMyqE8ItHoj/Iw1Mu3f9JHs11KeShhW2G8TBVmTChMKoTN8U7SV26+9mHlMzLbkNtEg+r93oEaPqlxTMv6SU+K2JpHGWq9CLZGVYv22BpVg5f6s+Kohs8qc6Gh4XMejF7E1hTqzBOKX48s1pOPipXJicXZ4iAsYWtCcExhiISwNYWvxxa/TgkDKIStCUFH2JrCGk8sFmxq8eu0duNi5PahrmO5iWgYHNgatQAIW/NGQ7U72Bo9YoStUQfoErE1hUEfA4ujYzYvfh1UnHlw8esWxa8RWyPLCGFrVF1MJmayhkgm4WwzmZSDY1M5+CXPUQEbxJi7iK1Rqq2wNb7Jr9xoN49VjM/OVnWLXPYlul9Xa1QzhbA19uUgJ1zYGruFdG1Ueo+wNWqrzLo1qi9e2Br1cWf04glbowMhbI29ONp68QrYGlf4u7xfVWmFrVH/hbA1Mk5fBFsj1KmwNX7wBWwNj5spqYZa9CFZWtgaDZkRtkZntbA1SvotYmsy4Zw2beicNHReoWGF5xo6va8TGGyNliNsjfUtq7A1fmcvYms0/V9ga/xrxNY4jtgaxxFb4zhiaxR/Itgaox9Iks82osu7X8X4ko0z7/n+bhyrY2s8z6ZVo082AwczMFM7s7A1crwRtsYOKoOdmSBsjdzkhK1RikjE1lQMbYnYGiNpts2MKNqu4iVvT7xD5m76iK1RK72wNU+BrbE/zE78ujPL2cXQB2Fr1D5cx9bolSTbo6omF2FrjLjdiyXvXVXT3BKxNXptqWNrlHSdDU99ro5I7SEz0hepsDUG0xzKlNF2Bha2xlPGcjYeltqLZhxTxrtxTNgaHR1ha1zOCfbmFbbGelRqkNNEljnJIyOErfH0Y/C6mUx8bOKjMIX4uLITFb7O0o53oruwNd57J/LrVLfzC1tjDNB0o16ErZHPibA1Bt+cwvRTU+/b09xEmX3D49OFrdG1sCRsjb3Kha2R+7ewNbqDLVi10xeMrVlBiUPC1ii5Xdga6x9SV3j+iP4p07UgbI31z+hf0L+ib6JvoX9D307l0S1sjfVdU7+FrXH8PrrAU4Stad/AImxN+7uusDUO6l81KLJd04ewNR7bWP86u9AiIWxN+8YNYWt0D5xZX9Gc4teblT2XaI8JW9P2RPjPwda0DVJzjf0NWZTJo8t1ngK2RhWMxX08MnTx2Bo1SP4ztqZwvObaOlXYmrb2LmFr2g/cE7am/UNK2Jq5Gj4FtqbtsR6xNdypyNkQtsZPgV4r6KEpbI3aJ4Wt8TXY188dYWv8wrWeX7iErVFHQ9cHKjq4wtbo7iFsje7nHWJr3CLaw90uHWJrjIbZGF/E/h7W0XWA3RH/BbbGy9y6qkb4jrA1qpIIW2PkX9chFfUvR2yNO0qErVGem7A11oit8b+K2Brdo4St0V2iiK1JlUTXdR9jTbrum/m5vB+6P0s4oFGNLcLWeAp2zR8PW2Pcg7A17dshha1pP/h3mbE11uPRE9BPDltjPRs9By1ia9w2fqm7OYSt8fG93K/Gwtb43LjSnRrC1ugpI2yNmryErbE3Zgmlq0vYGh2LltSQPmFrNIxI2BqtRdgaQ0w6VYW36whbA1jks2BZyJXqEFtj3EnE1tioOWJrPJ3X6kWwNZ6zC9qMdq1qG4Wt0RURsTWAS3q4gbFlHfeKClujZ72wNWombSEnaimxNS5DAVvjYVbC1qifQtgaXa3C1qj2WMfWGCUzsJMuc2FrjHQZZAfFlsGu97ZswXq3dBZlHVvj5X8FXTpsjdeyI8dlWNVIl106656wzNga1T1aDnYzb8shRua1DO9kBM+IRiWp1rE1uv+0HLqCniktoz+r5Fhha3TbrGNrHI9bwcea7CZhazw9Ymtc/oitUX1A2BrVflsmAaOJ2Br/OrnRvx7b2b9OcVJuHVujkaHC1qhBexFsjc+laeyH6b5PRmwNMZ6fLaexjQVsDb9+FGyNak3C1lg7wtaoVMLWWFdEF4utAdGykv23W8kJbMVhUtga3etaVwP4UsTWeM41WWYT2oUpzehHx9YIPCRsjbWX75CtvdE+aF+0lbUXsTW6djrE1nieZcXWuPm6gK3hKP8TtkbefcLWaMSisDWOexCT4ihsjREbPSuqCubrZobO9HKbpLA11j7uuRa2xtrqCqSwNdb1QZBsYHvSOrbG8Jd+rvjlGxP399jwfIA5SsLWGPyxaaZ+B2FrHA8k3px4EPFgQCEBW0PZtqJsWxPDosq3ISbFMd/OSRr59olejvIdgFlEbI2q68LWqO9A2Bq37O3kjF9ha1TVF7ZmCNgaA0p2Yzm7m46a7+GcdmFrlFcvbI0xPXuzLlIc832r4j/m+/m2JmyNKur5ASYh1rE1qn4UsTU+ZHVsjbIChK1RvoGwNV4vI3yFrXHMCF9ha4zbHmu0h7A13q5x6PjU6JbD0SK2RpUWYWu8/Im+LeeTGr18UhyFrTGkZjLAoGMz3WqErTF25zi2KGBrwA/Rap2faA5sPhWdhk5nf0ZsjV6Wha1RJSo/lX+dxr++wTwBW8OSz0uU8lfH1ni7LiQuYms8/VLfNISt8XG/nP0QsDUVvfIIW2OIzwwb/gtbY5DQzIqBOLNclcox44rYGuLrWWbE1jgmISfPWWMRW+MS1ji3b/GLkrA1SsjPb2M5t7NF81jyHSax1rE1egwJW2Mc0nynDAlb4yP1rjMx6tgal38B2/IB+nfQRR+y3oit0UuosDV6vxC2Ro+eOrZGR7+OrVFpawOSbu2wNeodE7bGvw5M9RgVtkalqg3yaPHaYDRia4ybKWJrdLYLW2PdNlVWg7A1egGvbZ/o1bi2g8d0CFujM6Q2NNMoEmFrVGWtDcuUpiVsjfa2sDUuzy7orpRhN3R3v8YKW2PozJ7oXujelCRia6wBW4MWsTXKjRe2xhqwNU4lFbbG2zjcjUjC1ni9I9lvo+zkELE1VmFrCq8P84tf72n7qjFYiepXwtaE14T7ii9r9xdfAx8ovga2ubi0zfzpY2s+aOh0sj6rLYqtGXL0IePHjjC4ZsX3Fwuu8VO0CK4BhMJtvmGdksxcOwLXZCYtfOrgGtYyCB2MRnCNy7wVRAjqbgLXmHERwDVMCeAappDJ3kDXXMNQWBM7Mv8w2A47sb07M2UX5gzgGuLdiclkb9iT+QO4hun78N99iffjV9gLDbAXIriG+CAP7eoQXGON4BrHEVzj/0ZwjTWCa6zjmCeAaygPt/k6uMZ6FDqRtUdwjefHyKGBdAaBa7zVU4hpmxS4xnMeD9rlhLL1ROKp7ghteJQtfQx9gv9idiJwjeMfU5JPH1zj/y4JXGPFo049ZdYPeH9dOnCN3i0ErvH0Wyt6F2mYY23pVtWQso7ANTZ3aXjBW/3xwTV6Tgpc49ejCK7xji2AazhAt/hyWDpwDcV7iMP0CNpmwre7nzMC17hzMoBrPKfANc5xaEIXC67ByWYK8yweXKMpAtd4OoNmhE9pD67xfwO4hlI9hX4XfRp9EiWJuIEk4gaSiBtwp2jAVrCBsZUNjCr7dMA1GO1EcI3NcgK4hulTORazuUwK4BpuAn/nNI7gGh+jL3ITex79COAatiWAaygVhut1cI2dhyK4xnEE13g5sjyU7YipNZgSBWoNcYFa4x6kSK3h10CtIQ7UGjY5UGuIB5f1hl3agnjLsikf3IdFrfGStycmLaK0K0sO1BqWicd8iTunqDWOedRHag3LHMG6GN9TGsW6IrXGc0ZqjWNG4Yha4/8yCkfUGjMWLkqdXsFoGFFrTLC53WzD5M5E3f6i1phv8Egi+mXyaNk9UY+7RaROrdEWiVqjvghRa1TdWwZqje8Jh/hwR2oNcQfUGvd2LqfW/K+i1lg3StV6WhridPKuGwIV38g4cVFr3Ka1kuMlUWs4wyO1xldEpNY4DtQa5gnUGuJArSEO1BrO9kCtIQ7UGuJArSHuQYy7lag1jqm/RWoNcaDWEAdqDXGg1rBG0LglRhyWBjBlE3Qg11ek1vhX2slKQ131Lu2YKFG6RNJTpNYQB2oNW7QP1+mBTAnUGpY5uqzemDq1xr9Gao3jSK1xHKk1jo92HUzUGpdkMss5lnIGag1rDNQabNj+zpykUxWpNYyGPIkRdScTA17ucirxacR/pU/4TS//k6DWMKzhjMwD+s+s2JzgLKd0JYwCTM7LnMV8vvs2Ra1xfzhWfMmF6MWpDQkuIWbkX3IZ/+KFOLkS/sxVPg+TGZgEXM2UmcYjJ7OYEy/nSK3x+JLkBpbDq3CSM/0mZ2Qkc0xqTW5myTV+vYW76Fzun7f65U/UGpfwNrdlJvMS9caLWuNf73YOdTKfee6BUXMvc96XqDYlao3pNw+kJvDg1ixqje7AkVrDPA+7xTd5jCU/kehunDxpSoaoNUJBilrjpT3Nr4FaQ/xsprt3WmL8fRliSeJngag16qMQtcZXZoXh6VW0kRS8TlXdMdLOVZscrGCakKg16s8XtUatyCljHNPPs8wvpHqCpFy56UoseWUS91ZhyqpV81W+lHjc/Gr8a3X0yyxtDbOD0jV9XFLa0VMe8Snt6HVqjQfEd8M5oDtrX6ui8yTtwa9c3aLWeEh6z0al74laY+2VqZU97W1DsrQPJeyb2TKhtVFJu6LWWCO1xnyeDRM1EohaY9ZNgVpjMzNRazydtzNRa6ybuR09HZi0UWtktJYO8pGtU2usjH2M1BrK+RXibTLxTNJtibljpNt7AIqoNbKuFLXGOtQZFumO7J9hphmLWqOs/HTnzPEufmpHao2zJ0StMV9oT8rTEbXGup+vr3T/TNeLqDVe74FsxUEshzey9AKfV+k3edYHak3VnKWHTCr+xKk1zgtYArUGnswPDEsXtUYcJ1FrnLfyo0SEYVFr1EMuao1cRbPnEzXKZi8w/09K5tv8NHEv/YuJGm9ErXGews8T50q8lNhy4BewZV62maWoNeqJyl5JdBaJWqMGOVFrnC/wq0QNbNnriZqXRK3RoB9Ra9wL+luTurPfJRqEJGrNJlBrvLS/Oqkze7PkfIG3ymqYEbVmmGwZG5LpfI7Ux9Qar2hBLy9kQW+0D9oXbYUqsx66PrqBN1/UGm2+qDXa/AX9vPmi1jhBoL/bpBdswpybesNFrdGGi1qjDRe1xmsc7E0WtcZkm628saLWaDNFrdFmLtjOGyhqjTZQ1Bpt4IIhlGSoN1DUGq9lGGXYiWXuzL928eCSxVFrFpJJbP/PI+ZaG3XI/l8HS/b/GjTyn2z/z/D9YP9PHOz/iYP9P3Gw/ycO9v/Ewf6fONj/Ewf7f+Jg/08c7P+Jg/0/cbD/Jw72/8TB/p842P8TB/t/4mD/Txzs/4mD/T9xsP+nYhDs/4mD/T85xcH+nzjY/xMH+3/iYP9PHOz/iYP9P3Gw/yd+0WdLF5pQZP/vGL9Y2f87xixW9v+OXyF+lTja/3s50f7f8W981sn+Xz0Jsv93/HviPxD/kfhPxG8Q/5n4L8RvUdX5G/vhbeJ3iBmF2eU9qljfp3IV7P+pQAb7f878ov2/42j/7zja/zuO9v+Oo/3/ovndF/KQvYhH0qU8Xi/jIXUlj9SruKXPIL6amIG26fU8nm7lMRrs/4mD/T8P0zt4ENzDw/ReHkn3Ebd5A5+f2SMz2P+zTOz/FzRxz7Gdc9Lfds6+B8qM2X85KVPXVulkP39lxuwppxKfRkwHiMyYrUUzZj2pS2czJwN9Suf6eVfCQ6h0gesS0YyZ+S82rV1mzMrYkhmzdzveD6XLWfIVLDmaMauWVZpR8Y2IemBppndLiXpg6bqq3klL17vmIDNmDWOSGbPXHs2YHQczZtcSSzeX1ckgM2Yv+Rbq23OJ2cml211XlBmznrmlO+x1JDNmZXuV7uLXu1nO/NQmzfegXLwyY7YGM2Z3CMiMWV2CMmNWZ4vMmJVjqLcvdWfJjFm1wdLDzrOLZsyd/dbwmHvLS7TFlZ7g9vukc/pkxqwbfukp95CXnq7qUJYYmx7NmNnGhWbMfA1mzCzqVXYX11c0YyYOZsz8SgNm6XdMD2bMxNGM2Zv5BvP8mR31Fwr8Vwr8JmsBtVE3Y1YPUumd1FPeZfk0Y5Z5kYxmzMTBjJk4mDETBzNmWrGCGTNxMGNmDEowYyYOZsz89wsMtaRaKzNmx9GM2fNEM2bHdJhHM2ZGuqzB8tdM1ZxSbnJ6YJlqrcyYPWfXTGNny93cPikzZvUWltfiXz1YwtqsMZgxEwczZpaw0IyZr8GMmTiYMRMHM2YWSxdZeddE3VYyY/b03VFa8hcxY/YUup6iGbMzPWXGrLqozJh1w5EZs7I1ZcasfFWZMXszaQyUGbN1eKJqQ3lEYgPjkYkydGTG7OmHorTh182YrYeVNYS9QzNmm+OSNVymdatMV63MmL0E3nZlxiwrtWjG7KHAMmPWe1B5ijv3ZMbsnUk7mMyYrbSDyYzZOrVsP+xp6HRXe8onOfO6bsZs0+JT0dPKtqP+BvHplO0M9EzWe5YZj+WzE7W9lM9hj53LQCiGJJbPTzRkUGbMXiYcSJkxezrduTJjtunvJeil6GUcI9royle42iYzZu/nq9irM1J1lcuM2WufyRJmJcqRkRmzS3ItS7gOvb6i9xeZMatvqHyj3ybKs1NbX+eu2smM2SWZ47dpDdzzPFSoZMbs6dGMWXdImTFb55V8it7h/DW5wFnvQu8uq0tfZsz+1z1lr+Ve95HJjNnLXJIZs3LbZcZsfdgtgeVH0EfRx9B/lxmzqtMyY9Ybq/LoNKhIZsx6N5QZs8u2rGbMk5abMS83Y15uxrzcjHm5GfNyM+blZszLzZj/lRkzOhIdhWr4ss2Y0THoWPQwdBw6Hj0cPQKdgHZgxkwfxA8S9avKjNk9vz90vrPMmB3/j9PfZMbsHoTnUzXxJTTF1M2Y3VfyomvI0YzZqZEyY9abr8yYbRH9snPAZcbs0Yqv+M06gduTvGavMpkxu+/jdedQy4xZSbLJb1w/lxmz9XepzZt/n4qJJzNmZf0nf3RdN/mT0/eSN8qqT8qM2aX6i2v7MmM2yf9Nejp4VZQZs+O3rRqD60aMFWmaiGbMbtw4uJPeu9ND6JUY7rplOoI+hZFVt4SPyty7cahHwsmM2dPHNLrtfawtbNPDKmb+j8u8hPGdbLd8eFU5MOkR9GhMoBHmSPcNpUe5LyalPy6aMWe2Wz7GY2XSycTHEk9pVA+7zJjda/D1insijsem9wTKudCMma/TKDb5pHUzZrXiLp0ZM4XBUDM9h06Qc+lKiGbMnn4xm3aJD3F6ORt1BRs1kxakWbQgXZPJCSC91g3d6Q0VvdWmN6buWJndqMOU5pk7Jm6ihHMo4c3EwYyZVqa5lAR4qcyYvd67aVmaTyvTAxVlEMuM2TbPDxJ/h5hOAZkxu43rYdq4HqFUj1Kqx+gceZwujydY8pO0cX2P+Cnip1nLM6zl+3QzPZutoZ4WmzGzE4IZM3EwY3ZDhMyYvQk/Zno0Y1abSd2M2UX6OUV6iZ32C3bay8S/ZB6aJWXG7GXSbCIzZsc0m0QzZuJoxuz+qT/Sy8PYvpSmEpkxO/4LMWP7UnpdZcbsTfsbm/Yu/VzveYdkasDDjNl9KGUnhGZJ5hGQacUmGZnNJ2TG7JGdVZdZZsxqhMk6ZXoTlxmzmlyyFZxWnNE8kq3o61FmzO4N+VxVPYb/58yYaeUOZszEtCZ1oTVJZsyOaU2SGbNjUhcWMWP29GjG7DiaMTuOZsyOoxmzY9IbohkzcTBjJg5mzMTBjJm4aMbsFnhSIKIZMzEpEF1IgZAZs2M6SWXG7Lgn8brEtCnJjNkxKRDRjJk4mDGzvRuw3g2JaVDq0o+YTtIu5FxHM2biYMZMHMyYiYMZM4kEDL/osiUxOdddtib+CjHDj2TG7LLhLiMzZseMVJAZs+OhxDsSk2gRzZiJgxkzcTBjJi6aMTuOZsyOScSSGbPNkvcnJhGry4HEJGl0OYiYrDOZMftf0YzZcTRjdhzNmB1HM2bHwYyZfULzVxccuWTG7PgI4gnEOHLJjNlxNGP2EqIZs+Noxuw4mjE7jmbMjk+gzAxX6jKVeBoxblsyY/aePIP4TOKzmOds5jmH+Fzi8yjP+cQXENO01eVC4ouILya+hPhS1n4Z5adBvgsN8ouYMSuJQmbM1jKaoCmaoRW0ija6PM2d0M6ZmqGaV0A/w5QV0c+in0M/7wZMmTFbv4iuhK6MroKSYNa8OvrlitItmtdA10Sb0K5+pjS3oN3Q7uhaaA90bXQdtKcHuDevi/aqytW+uTfaB+2LtqLroeuzN8jVlBmzdSMU71KZMVv7o1xrzZu4D7d5U3Qzp2Y1D0Q3Rwehg9Et0KUyY6a0Q9ChlGpHdFhFw2Sbd0J3dWJJ827o7uge6J7oXuje6D7ofmZXNh9g/lvzV9GvoQe72ikzZutwdAQ6Eh2FHoqORsdUVP1rHoseVlXTdPM4dHxFD6nmw9Ej0AnokZwtR6ETOcqT0KM5Osegk9mTx6IFM2ZKfjx6Ams/EZ3O0k5CT0ZPQU9FT0O/gZ6OnsEZeCZ6Fmfp2SjXVPO5KPWx5vPRCyjVN9EL0YvQi9FL0EvRy9DLOVJXoFdypK5CZ6BXozPRWeg1bMW16HXo9egN6I3obDRHb2Jvz0FvZm/X0FvYw3PRW9Fvobex1SSXyozZegd6J3o3Oh+lz7r5XpQ+6+b7Ufqsl2TGzLY/gj6KPo4+gT5Z0cuCzJitT3HGPo3SW92hGbOPPg3IMmO2/hD9Mfo8SqZ0M5nSzT91Z0Hzi2gHZsycM79EX0FfRV9zElfzr9DXmfJr9De+WzYDMm3+nck2zb9H/8C9qCMzZh+XN9G30LfRd9B32VKsRpvf54gscEdk8wdowYw59ZDra8l7vw69EW+/2cQ3mdfadQ72zHOZQremzJidGrrUZsweAV80Y3ZvRTRjdswNrXxr6p6Lb6H/aWbMNpBTy4TNmFNdJjJjtmluksiAtin1MDWZMasPV2bMVmrdMmO2RjPmqs2YsZ/8TKJ34aYVU4GJZMasnKJoxuzMJZkxa/yxzJitK3nQm8yYva5VnLXVtCp2y19CV0ts67s6BpNfxvh5jUR9NE1rJhriJjNmHVyZMdsqr9mnQVNX44yaWrCL7sb83cs2RV7LffoyY9Zbs8yYbZC8TqIBGjJjtv3zuqyll996mnpj1dwnsfFz39SWw60YWK6HBfL6vlhkxqwhdDJjtm7kV9GmftgJb1zWS67MmG3PPMBZ6DJj9n7Y1F5BMmPWZSIzZp3YMmNWZmnTIPVKyYyZfbhFYqvRLRMvYatEveEyY1bGWtNXOCLboNui23nQnsyYbVa6AwalQ8oa2SYzZuuOJXVDNw1DdyorzUlmzIKpyozZ5se7Jt7Pu5W953fn1z3KageQGbPjvdC9yz7i+5SUfygzZut+ZZdkfz+gZcZsS84Dy2pPkBmz99tBJQ2WlRmzDa0PLvuIHELZhrPeESXdymTG7OWM4r+H8q/R/GsM8Vj+dZj/JTtkmTfLDtmpZd39ei47ZI0Ulx2yzZLXTu1LtI5tsxf0TJV3JztkNSH8sx2yr/F+7sL7BG2P3dTD+M5kASf2ODofN6m4e3RTZ9qUN+PmMJDO02B7TOf1YDTaHlu38ljqJdkeky5LerNsj63/4HX+bTJn3uG1tyPbY6cItvlEjueiI8Va/ri+SOmMlj+upzDUQv649qOd5E7kuj+u55xMHP1xffiOSzTysunrmb1aj3eXt/xxPSdmV01TuSSnuStZ/riechJ6stPm5Y+rp3YTbpTRH5eSnM48Z6Bnssbgj8tlS2d0EzV2+eN6evTHtTJwo+6P61PuYi6ljvxx7UQLPkX+uJ5yFZfSjLK6jOWPa51Ztuv8LC6ca0pqTJM/rvW6si/e69kDN3BK34jORnP0JnQOejNaK3lf3YKD+1z0Vi66b6G3obdzuc3jEr6jpHNJ/rhe411cenezxvllNZXIH9fxveh9XET3O1up6QH022U1wTU9SPwdlrkkf1w1wssfV7cL+eNqfvnj6jKUP66nzOPpeYfPZPnj+l9w1//ZH1djQNv74y78iudr4Wv91+gXW/ja/tf2/41+sf7azh9Xmcvt/XEXfsXjtvC1/mv0xy18bf9r+/9Gf1x/XeiPqxz59v647b76v8Wv9V/Deotf2//a/r9hvXxt548bShX9cRd+xR+38LVe5vDfuOTw33Zf/d/iV/2KM64epmWsU6IzrgcdlBl+G51xUVwWykNtNiNnXN/rhjHPTtzfGC9e3oUhAMfT3H0CeqI1OuNyH1tAkyNj5VNG2KUfEjMmMfu8H8pyxlWp5IzrhsGVHC+zM66SJeSMazuWU12SPkCoojMucXDGRaMzrn8djfkf7R59xuKGexjmf+P413hvtZxxPeUYPx3kjKtOBDnjavjD0jnjqjFSToFuklw6Z1waNvGyzRh6IGdct0vMzDQEIDrjZmphljOuXAr6TPQ8csa1a0VwxvVQjvxsp7vk56BL4Yzb9R6erba/9VBEmcj+QpaOWNveqrERwd3WgczPZKqq6bNQeT79s/2tnvuyv3Wqdlq5MNrfbtzO/vYsjQtRh4xGM6htXiNX3GWUTlZLuTK8lGSknhANspELofJGPT25g187uyctkRfpVfiqypc3U++KVQao+qq/hJk1z6GsovjR6ryu+PG64qdtRYXPVQs/Wkv7hSz8aEVt5S9+Fi7kCfSWwrq8unkLN7P+cRnaPlPbLaFz+Hjb23+03rbPvEJR2z7aG/WPC89HO6rto62wZaz2FUdBbxLJ8xRbv1Jgl3C4/WjbDkHyKiWRHfIdfLRSLW0a88tJV55wWo7+zuHznJrytmOvV9Mf9irSAS522AOXuxE9e1I5vBpNouEs6h5hIU+H8qQH+o8a0qFKU/o4H812AOVp26UUxgdUh0B//waF0dEZ1lA5t6FysYaJeCxI8ozXKziE1y7Dzo/xSZ9rqH67g0/lTt29/KkOaajMLX5GNmRPN1RVmNOLn/Pk8KruC386Pd9QfcAf9R4s8qn05jMRa20ZVwzyR3XDyu+Lny82NH6hoTJJHVnxIwPgnwgysbCQbSVcXDlVyPpHpf3XBW77tJW5fbFVwrZPWznbbggqbf2zaLF/72LXP4WSdw9mw9WjGxrV4yYDWr0cyYBWYz2SiQxtm5TKIjehbVkGtHoJSp7L9PrcZkAr61krow+ylc0ClfWs8ntlPSssWPYld5Zlq1XVYSrrWQ/b6eJ7bNbsmnnWtapXvKwlU2qlrGc9f3fsRemzkPWsl7m2u7dkPetW4hm0HpP62GWWU8G7vF9R3VLWs+qRlPWsnm6yntWgqi4f2ga1yz8S1Zn7HMF9ewLPoyO5n09JVcOX9ayfOLj4yHpWTzRZzyrFsc+JfgWW9aynT0uFbHXbRfBtzVQplW+r+8U2ygQFyvpplI99W72B/TOPPBrgdy75tuoNWr6t6hiVb6veSeXbavfWzVP1ucu31a8YgzOPEtrCrwPybbVrb/BtZTnRt9XOr9u6kpBtR//d9u5mlW+re/eib6veoOXbatfYYRWPitqJX3c2Nla+rfaa3TXzGqNvqysDe4Bs3dNj6LK9Mrur7l3Rg++j+La6KSkb7ixf+bbK9iYb6ffubBRerYc6y12+rfaPHJN4n4x1F7N8W9XTnY1L7FM7vqQO5exw21xlRzg/IZvAyKwj7c6YHcVJMpE5JxnBJN9WZbRmx5Q8tmtyYtfbYz0KPpvC8o/DXfXr7IfjnWMg31aPyTqRX6e6STCbZhunbDpTTnKfaXYylJtTOLKnukVFvq0r2rdV65Fvq2HRS/Jt9Wm8YOWq36xXafTb96pVu7d+SQ0trpl8001HybO+5ca3bBl52mKTGho9cdm6FK9XZ6+od6MaEGSx6eFmfW1eKItN19zWc81NFptqiun6gIcuymJTTTSy2NRmdmixuQCLTe20Diw2e6G90T5oX7Q1GHCqEabrxgzx7u9h3V0H0BqweANOT9+6qqs1GnD6+uq6Hbq9XUu77uCkCxlw6t7SdSj3jR1tLSIDTiVOyIDTGg049da2iAGndQ+brixiwGndJ/VAxX1tkSgDTq8xGHBWTTk4kCkf34DzMHQcOh49HD0CndBm0umkmroBp9tL/3cbcKqOLQNO26xe5uRnGXC6zFcw/Uo3ZMmAU+nQMuA0E6PBNzQZcOoClAGnjRWTqhqyWugllwGn3qNlwKkhojLgVN1YBpz9OjbgxPjwswwSp2GzIwNOAyqjASeGM9GA0yaL1N4XMeB0eXi+tDRTnq5VNTC2tDTqUm3pzpS10B6YNa6T6bKVAacG1MiAU60fLb34b2/mWZIBp8tQMOD0EAkZcHpdAxINGpIBp9+SogGnTLVbBjbqJiYDTrVRyIBTSf4tg1Od8y30gMuAUwY4dQNOLx+vvqU04JRdgww4HQ9zgkfLLo0uf8GA04TtpTTgtJkDpkwth2Te9uFV3U5bRlQ1Dq6FN7uWUbbUbTm0k250LaM7q/WjZYyRjy1j+fWwqrdrXGfdAVvo0ZYBp7ciGHBikBkNONXAKwNO7+dJmeh5LbwDthxjJn/L5Kpuyy3HdrJZ6RQzz1swZWr5eqYGzJbjq3pQLmLA6fJPYy3TG9VCWDfgdIx9Qctp2c8w4PR2RQNO//pRDDiVBiMDTmtHBpzaVzLgtK6ILtaA05bYMuB0vLLN+FtXQVf1fbJDA07d/WTA6WU2oV2Y0ox29Z22tQXthnZH10IZVbSIAaeuVhlwWnv5DikDTmsftK/P9g4NOD3lkzbgdPtY0YDT50zdgBP3TXWOyH1TNTq5bzruQUxOS76OeUR5z0z3lnzdVBWSnM6IvDfax10Dct+0tuK8uB66fiKTYLlv6h6Vb+jeTLlv7mz3zUa/42/saljev6p7XT7Aw/fyTSqydc83TTUYJ9+MeCDx5sSDiAH0RfdNYgb+51sTM/A/54rOGfifb5epdp1vbyv6fAccFqP7pioSct/0tg+rqKtF7pvKhct37iR+mtw3Vb2su296nt3dm5zvYf6k3DdFX8z38lHO92b/kNOS71vRePB8v3Qu7pu6n+cHJKo+RfdNXBjJackBjOcH48V4CKUd7lF7ct9UK33dfdPLjO6bjsfgNzk20f1N7puq1ct90zrepvJy37QW3Te95KMy+1NO5ChMwlfy6EzvIHLftEvlZGf6yX1TzxS5b9qP8zi2KLhv+i6an0DryoluXc+notNQKHPRfTNTZqPcN/2vU/kXliNy31TvcHTfZMnnuUNK7psuGy3kct90XHTf9PRLPUQ0vyw1Hym6b3pdVxrRIPdNpdTmM1jm1cw/k+mzmM5Y+Oi+yfKvZ8k3EDPgNGfAqdw37XyJjVLdfdNnb41z+xa/0eRzKcNt/Pd2tnoeS6MVOme0eH6XK9hy33QJ57uPWO6busblvqmXgui+SakK7pucA/QU5/9oFONL7ps6G+W+qexTuW+qLld339T5KfdNLb/W31X32oCyliz3TU8hE6y2mS0vagPtmVbbPJFtc22QB6/VBqPRfVPXndw37c3JVSP3Tft3boNu63c6uW/qyVLbvqy3S7lvqgtS7pt64tSGGtEg9009TWrDUt0T5L6pngu5b3rJZILVyASrYWYo901P2cPdpnLftO5lu5Xa3mzRPihDIGuMd67tjxbdN+3WeRD6Nfd01A52XV3um7oK5L6pfSj3TV07ct/0uka5zbbrd9i36klfc1GLyq0njB+5BJtKPNa6uelv8TaVGAN2YFNpa+dP36aStQxCB6PBprKiV8gGjmwDR7ZoU0lMjl+0qWRbhrC9vC/UbSrtILcTPn7k+HVkU8mce+A7R45ftKlk+j78d1/i/fiVHL8Gjmy0qSQ+iPJ/FJtKzxNtKr32gk0l04NNJVtHjt9S2lR6zoJNJXMWbCrLuoobTiipptdwIvFUyv8o8z+GBptKFF+Cf5tNpcu/JJtKz/MeugD9gNbypbOp9JRgU2nD/oY52PZ3w1OxI5tKl/YTsqnU4G7ZVJo8EG0qvTM7sKlM9bq0dDaVFPshDtMjaNGm0q+xwaaSF086HWRTaV2STaW7JhdvU6kdLptK7/aObCodB5tKSvUU+l30afRJ9Pts77Poc+gz6L/LptLGBdGm0k4L0abS04NNJZdJ0abSN4EObCp91Bqe51JaRptK1n4QJfloNpX8FGwqiQs2lZkax6JNJb8Gm0riaFPpTY42lY4Hp3o+yqbS8ZaJl0autWwqXTzuvbKpdFywqWSZwaaSONpUes5oU+llRptKx6PcYly3qfSc0abS8XHME20qHUebShu1XV7Ru4lsKlUDlE2lbdDuTNXDLptKG8E9YrBY8ig9pI+nqldEm0r7KsimUg2JsqlU+9Uy2FTqX90O8eGONpXEy20q/xNsKm27upH7AkpDfBy7bkjrFlPqNpWKl2RTyRm+BJtK4mBTSRxsKok/gk0lBiw9uCKov8mm0nFProtgU0kcbCqJg00lcbCpZGkFm0qmUE+TTaWvr2hT6bVvx1qGYoOzI64si7WpZGnRptL/ijaVXuZolhltKv1rtKl0HG0qHUebSsdH4/QSbSr/X3tnAi1LVZ/7W7V37XMuiTjgrNX7HLCRGVFUBkWDEWQQVMQ8o8YBUQQUAUUcQcEhoqKJgAKCUfEoV0XBeYziFDW+mBdNHGKMU3DWaOJQTfm+71ddh+7LwQuIUbJqrV7f2t2nT3UN/2nvXftX3k6PqXQA/xWf95hKf87j69fCVHo7PaaS9hRTSbvHVHrlwnWGqeReshd4nC385YLu1wov9MSEMJVKE+El/t9wenKMmmIq+T69yPByz3aFM2ifyY2jZ/Fox1cS96aYSvRc778wlZ53O88xrcdU8v0eU6m0Lkyl2xegK/zvG5ISkzCVxkJeyJY38Nc3EUXfTPx8iwuDVUyl/DFcTHS9xLduClOpaZHwLr7zbhZvTjGVfl6HMJWOuu9nfrDHVArz32MqPfIpTKXvV/kYW/4EeOFPesxBmErDM3tMpf/aYyrd/qz/Ggvu0yuT+svCVBpsGEE1VqwiTIANF9BFFs2tX9A9Y8JUauRHmEqvBPzjSkcqTKXvlrmhz1i8Edu8sUdKI54rTKW3fFPPOUYefSNMpaGRt/AkXbwl/3Ur9NZs7Ta+UTbeloWBNZ9PMZW05zGVbm/Fr9/Oj1WMYz7Hu4WpVE88brNeYxpxW3S75L3afkFTfnGHyr++ox8YKEylj3dnlvhNMZWeYhOm0stU7+QJqbgrKxx7TKX6yKuYSv8vkOq4hx9jGPf0WJ8wlRoHi3dnCWqPqfR35jCV7GePqVQ/OrIqRJhKf3Nf37cvTKXXUe6H7u95KGEq/f0Dg3p5wlTqbkBhKjUOEA+2PfSYSs/4CFOpIlmYSn/nqjGVsnlhKlVvC1Pp330oR9FjKv3JS80zFKZS52EVU6ltClOpkajrGlPpSmlTmEqP7QhT6Qdj/qOxP8JUev76n+xZwlRqXE6YSk/a/rMxPtW/MG36RT+ZX5hKL7r8skdjhKnUU3eEqfRk61c9VilMpSdwv+YxB2EqNXpTfT1qbkuYSk+VfjP4gZPfihqPEqZSXQlhKv3JZUEZsPpOpbmA6rtRo6bCVGr8UJhK3a1U/Wd8BphKT6f+zM/0EKbyJiInKUrxeqVCmjGV/qFmO2+k2R7dAd0R3cmH3OyM3gHdxYff3NGHL0yl70Pe1YcvTKUOX5hKHX6zmw+82d0HLkylDlyYSh24MJX+xb18yMJU6mCFqdTBClOpwxSmUgclTKUOUJhKt+/jA2z2Y0/29wEKU+lfOZB9uC/bPIhvHhw9iXlNMJVm1l2UZOrCVE6nbq+vmEqS4BRTSXuKqaQ9xVTSnmIqaU8xlbSnmEraU0wl7SmmkvYUU0l7iqmkPcVU0p5iKmlPMZW0p5hK2lNMJe0pppL2FFNJe4qppD3FVNKeYipZcjjFVNL+3WMqZS2rmEq3e0yl2z2m0u0eU+l2j6n0MskeU+n2ZbY6YSo1ySVMpdvfo/192j+g/UPaP6L9Y9o/of0zSp0eU+l2j6l0e4qppLiaYiop5K4aU+lSrcdUut1jKt3uMZVu95jK46+EqXSS/WtS1Zmk17NIUmeTUs8hpJ9L+1W0eRRVfC3pCRTqKqbS7SmmkmSKjQlT6WT6HlLSe2m/j/05nZtv18BUEnPAVOoGkiY7Bq5iKo2XfI4rhB5T6Vy8SUylAYyn8c0pptLhrngJ33ypa4mCCnAjTKXyVI+p5BJMMZVsocdU+lfOTcpxwlT6f89j4GiKqVzUzJEwlZonFaZS81YbYSp9EnpMpU6+MJWaW1nFVPo7PabS7be5VhSm0qjJSyrzGN/uECpMpf+6FqZSMyzCVFp7TKXCsjCVPt4PGnosTKVG6XUHiff/w6VG9YWp1AUqLmVrH93Mdf48ptK/9ckFzSn0mMr1PtJPE5Y/A75yiqnkXF2BqeRtj6n0F2CPbApTSXtTmEofYI+p9A5fNaZSNI/i55UmEYSp9OcMY5Z0JHtMJe0pppL2FFNJe4qp5PbvKaaS9iYwlfzvFFNJex5T6X3oMZVu3xLtMZW+4bzHVOqGH2EqlZ1Lng8vTKW/uVTpUpZbVvKaVUyl/2uKqeQXp5hK2r8FptKb7TGVmuW5FphKVZ7CVKp3I0yl9WF+vKQwlXrG2lqYSvSwoAfnrmIqfcg8fEGYSus8plLY/DUxleqzlMdw0p6IHoty/6QwldYn+b7KVUylFsQJU+lfPLEySHMTmErPqJYnQRA92TfXCVPpi9JjKr2dU9HngjF8Hu15TKX34YWcjavGVBreOI+plPELU2l9eTD68gz0TPSsYMxjj6n0Xp3NeT6HYzzXj0DvMZV8cr4f+LWKqfQWXoO+1qP0wlTqyXXlBZXuWBOm0ismVowSEqZSy+LKN/que62f+TiYSp+HN7mAXMVUKvoJU2m9uNB9EcJUXgSm0voO9J1+RLwwlYrMwlRqlKmkP1u+14lmk5hK3aMiTKX1Ix4JLC9FP4p+DL0mmErr59BrjqlUr1yYStvP1wv7yzdK5SxhKr1v1xZT6WUwA6ZywFQOmMoBUzlgKgdM5YCpHDCVvzdMJXMQn/PCDWEq1bcVplLjz8JUuv15V5XhC0kLNISp9AzFWphKAyS/QnstTKXGk1cxleqZhm8wn/LNyg/JYigmfNvDCMJU+puXGaMnTKX1u15uI0yl7vIK309eJ/WD6Edx/dB3DIYf+S5xYSq9Vz/xvXDCVHpmZB5TqWpTmEoPbtAxjDdguKPHVHpM+xHrVd/GR0YtMhKm0nMBU0zloh/t1GMqHwym0ozEIxZVDQpTqdGMeCQDLEdV6jvHozfTUKowlbpDOz6BGY0pptJzQ/FYz8XMYyp9V6EwlYYinkD7KbRPdIdXmErPUDwtqWchTKVGBoSp9K88Mz2px1R6t09it+cwlX5g0NXDVHIqTuMkvIgDfzFTCfOYSmMnz+DJXK/goHpMpUeQzmcE6dWGFAlTqQUO8XULJjFeUOm21fj69dYVLz8RplK3BwhT6fGieUylf+vN7MnbUZ7TIUylvwmwSJhKtz/A5x+k/SHaf8tExoe5BB9hjOtS9uqj7NXHmDz6OFMwn2DLn2SM6+9of4r2p/mVz/Arf88002erpzP/GP+BnZxiKmn3mErvNgN08Qt83mMq/UmPqfQu/Su79FVO2hRT6SEOYSrVv4tfZze+wYF8kza+8BswlbaQHzCD80PmuXpMpds9ptLtHlPpQ/svDu0XzHP90rNFWkmqE76KqZTXCFPpRWQxGUdZea5KmEoN3a9iKq3rvTVhKjXkIkyl7iPtMZVsZ3OWgN1wQb3R/3WYSka5p5hK2lNMJe0pppL2dYypZDtTTCXtKaaS9hRTSXuKqaQ9xVTSZgn8PKbSZiZMpUe8uQVCmEq3mSQVptLtbWhvS3s72tvT5haIHlNJew5TyfanmEraU0wl7bswEt5jKt3uMZVu95hKt6eYSm4kuAe/fk/aLNIZ7U37XrS5hVWYSu/bPrT3pc2T1oWpdHt/2gfQvs4wlRzXFFNJe4qppD3FVNLuMZX+9R5T6XaPqXS7x1S63WMq3e4xlf7dHlPpdo+pdLvHVLo9j6n0FnpMpds9ptLtHlPpdo+pdPsZ7PMUU0l7iqnknE8xlbSnmEqUpSKjF9F+MW1yxyqm0u0eU+l2j6l0u8dU+tevGlNpbJqSKphKa4kGNKIVmtAFFB/M69HNPJkuTKWVu/7yDdDN0RuiN/LQpTCV1pugW6A3RW+G3jLphvl8K/TWC7r5Ld8GvS1ao0ueLMjL6JboVujt0DG6NXp7dJsFPds3b4tu5+XYeXt0B3RHdCd0Z/SaYyo1QSBMpXUPr67Ne6J3Q++O7oXeA73GmMpFpYZ8AHrggjog+b7o/TzgKUyl9QHoIegD0UPRB6F/hj4YYOBDFgyrfBj6cPQRoPNY9SxMpfUw9NHo4ehj0MeiRyTNTQtTaT1yUTcr5qPQoxdUQObHo09Aj0GfiLUcix7HVT4efRJX58noVWMqvedPR5/Brz8TPZmtPRt9DnoKeir6XPR56PPRF2CB+JQwlbbS01B8KjNcnJnYyqejL2WvXob+FfrX6MvRM9Az0bPQV2Bdr0TPxorOQc9FX4Weh56Pvpqj+Bv0Nehr0dehF6CvR1fQN3C234heyNnegL6JM/xm9C3oRehbOWpuLhWm0noJ+nb0nei7UOas83tQ5qzz+1DmrDeFqeTYL0U/in4c/QT6yfQcMJXWTy1ooDt/GuW5bNcWU+lolr+IfikKUZW/7GVfa2IqbTP/jn4d/Qb6Td+0k7+FfptP/gO9DCznd9Dvgqb8HnrVmEpfl5+iP0P/G/05+gs89Jf476+4Ig3XbuLpyI0wlZqmmcdU+vwIU+k74d+wqDp/6Y3OCKuYSt/lftF6dY6uK0yl51B6TKXbF6HXT0yleW5F1MpuYSrNkQueDRemUv1cYSr914QuBGMG5zGV6nzVfxS1PlGYSjPfblAJ11lvbirIKqbSAMkbB4Ej6pugW6BMSvaYSr7JPdvCVGrtpDCVmtUSplJzScJUmlZ3W9+FWNeGPwhTaeJcZj+Xgvq/wlQqNNVblrrtod6KPZzHVOoeM2EqDWzcJmqlrTCV/pXtvOK43t4dMWEq1bMQplIjBsJUGmW5M3qHoJ6IMJW6R0uYSuudgtY+17sGrQOt71xoLluYSt1tJUylwlS9WynXEKbS7Lg9fAuTMJW6bUmYSt1VVd89aG1mvRffuQe/eM/SlLw/CcZC7u2Z7vpepVy+/lP03ug+cPb2LTXlKkylf2u/0ke3P3oA/MAD0R5TaczmwX5kvDCVxo3en/96ANS7QyDmPZD2oeiDSt00JUyl1rMLU6n1p8JUvhBMpQKRMJVbgKmUywhT6S3/hWEdwlRqDlGYSlvOI0sf+6P43cMKrXAXptLbOZz/fQz/9Vj+64jS5+Rx/NeR/i9hKhWWhanU3FyzVaU7kIWp1L0HwlTKAputKz2MW5hKrU9stqnUZxSm8vS1MJXWXd13vq4xldx822DYR5kZUu5WCW5T7u7OZrkH06bzmEqHi73QOUylu9ubwlRyu+xamErfOfNzqCNrYSp9K+BamEqFi5rJaGEqFaDmMZWeSr5qTGXQaa+f6iG4+mm+rUWYSk3aboSptEue5KnkeUwlLn+Kp8LrU/lkiqlkT57PnqyBqQy6W6/HVPLXTWEqVREJU2ldC1Op4SlhKv1bZwPbPAdXOtcLxoWptJ6Hs5yP47y60N2JwlRaX1M6fL3Wk8jCVNrZL0Bfj66gb0DfiF6IbjAnR5hKLSQXptL6FrZwEfpWT8cLU2l3uzjoxldhKmU/wlT6F9+BvhOXeZeXygpT6fZ70PfiRO8rdLtm/X629gH0g+iH2OamMJU6dmEqjYv5K39fmEo5lzCV/mSKqSRXvp3VXleBqZRZzWIqr3gLanLu7epfe0zl3NvZv87+b4+p9Ns/AEylxrdmMZVXvAU1Ofd29a89pnLu7exfZ/+3x1T67XWEqZxuucdUXvEWTOXcW/0VTKVSZ8ny2x5TSZvltz2mksg2xVQmP+VziqnkOz2m0hGvx1Ran4HSc1/FVDqONdwBOCGyXc4QIrEuspSjuhFcrBubOC1MpflUW5Cgry2m0uCRg1y6CFNppOQjwH/1mEq3p5hKQJRzmErHK2EqDaWcYir561F8fw5T6buOhakUlUuYSvW4rx6mMt0bypwmZ645ptJZaRVTqcjQYyqTvFuYSkXFHY4zbE2YSuMUppjK0nCA00ATvAi9ephK18/GVIavaFWlLqmnfcIKBMWfaumJiX/hS0AptzLB0pDAVUylWIWzmEolBWEqZXLCVL63x1QeNIOpPMO4y7hoqGC80MzJ8GIN2GvYWHdvQSY8RUtPhOby7EGcaAEHeqRWt4DEPE2LG9Yl0TJ34fUAgbvWJRm7mIfdly/05IN/YqPXgfxW/9Jvrb6mPzT70q+svvQrMxu54qUf6vZ//uVj6V4/u+K4Zl+VAJX9Ya6+vA/d63Mzu3Hk9OVjn329+4rX3K7y0slZfU3PEidq+hI9VexBbZyroJMfTme39Sft8IQTcopPcncJwnf4sv50E02m8Yu7GBRn1XUXWlDwUv07h+lv6pNdaO/C5y3XVzBMra7i8HXs6Zbr0u01HaH5KE2I0dDO6NqxP1G2d+m6lD3fGP+Nl772SvaHPex2xhdUO3O/6c5E4TSPXZc+55dOe9qL79xnXfqlpqeEM9T9X9f+FT+0bnFpjVcSC1TYzwetWzhyXZrMv+6hdRvrFsTY/MDcq6rWLWgq5Cd+bXbIusUf+yXyw9qvU7RMZN3CIVNjs6l/df61uG7ha+uSqJ5/3r/28GvhzCt20nvYv668n9rJ1Zf29jfvcCWL+sl0n2d3W3vYvbr99PU63nu7+tp4t7/q3V59ze256ncwlYu76SfAVKraFKZS44TCVPqZhsczpXsCk7lPcVdUmEp1wTbCVCqqC1OpbqYwlbp1sLp5MrLyFp4wFabyEjCVnpaaYiq92K1aWvRCnuXKlMUtFzVlLEylYX3MWQhT6W1uzYRUN2dxLjMdr0LPdy09+tWCKjphKoUjE6bSyMrL/RyEUetJNGEqNVG1wxMc23c4hozzROL5if7mRphKZTRhKnWLozCV6gILU+k8dZLsfA5T6XmxO1Z68GJ1Jz8EvNrVoEJhKo06vEvl1Ul3NfdGmEqjLHdf0NStMJW6K1KYSq+culsUKUiYSu2kMJVK38JUameEqdQgkjCV3vLebLPHVHo90b3BS+6TzPPsMZVeqbQfn++f3GE5oPIWDkxeeXRf/nqQ17ALU6mhbGEq1ZUTptKPmZtiKhf8iLoHMjN4aDKe8UFe4bURptKwzYcWYgb2mMpSpXiPqUy+iI+K5oseFmUY1aNZ93S47woQptKwx8eaeFYdwS8+zkQ4YSq9P0dFr9g6ulQ3sHp8UpenegIruY7xCvrqiX4IfnVsNK3xuKhiuzo+ioojTKW382T3xKsTPBYhTKVBlydGY0Kf6o5G9bTkNV9PD1oLIEylqafP9MPZq2dFdbiqk5JMpTqZ7TzbIycV9/pWp/D5qRzLc/2kAGEqfS2eH2UYm8JU+u765qaLuo7CVBpQefNF3U8rTKVKKqVswYoV4W+lhZUbYyoxKmbiqm3d1xamUgMmwlR6wdoOWP6OcQcwld7hnV25CVOpiyVMpR6LIEylhhSEqTROcC1Mpdvjyn3za46pFDd16c4s8b6Ll3gv3ZXRgE1hKrU/PaYS3Qfdd8Egzfv4jndhKu1Q+/sCCVPp7RyIMme3iqk0UHEtTKXGM9fCVCYNJQlT6faDo24mEaZSN7QsPSSJRLqKqfQnv3NMpW+nWcVUqif7B46p9PjMmXx+FmM4rwhCUQlT6c/P5vNzCpm0MJX66/K6pIWTwlQa/sDw5nJYNL4yVrIWYSrltsJUmtay6AgsTKWhlGtgKgEqbg6M7oboGpjKpFDTYyoBzvSYSoMQb80W5jGV/iYLh5czQMKlBR3j8vJ6hcflrfjkdujYIxjLt08axBOmUrc0CFOpENFjKtFNYCodzOcxlaYBC1OpG4eEqdQNUcJU+nd7TKUSx/Ke61WoC1OpcCpMpdGLe/nhs8vMgAtTqaSwiqn0MfKwg6uJqfSvHAD+8cAF9fiWDzZmdiNMpcYoriamUrdsLT/CgVGYSp/5Ry1qufHyYYsiLS/Ts1s+fBFM5Wa60UWYSu/bEYtKbcv07JaPXJSvCVOp2T1hKn0Uc5hKZ+RVTKURl8cZ5LURptLfPGHBYM+nrNfYzvKJSSlgmVm55aclb/npi+qXrYWp5ByejGX2mEq3TzFaTZhKX5fnOY0uP983vC2/YL2eA3WNMJVKf8JUWtfCVCqlClNpvQF6lZhKkIxbeK5qJ+4D2YnF8jvd3FFuTUylP78t26zREZ9kdInvLKNboluhZIGdxug8plJpV5hK63aOmTttj+6A7hgF8/w9Yip9HecxlYYZbuUJAmEq3R7T5p6WFerDlW2S6reVbY1lXtnO4x4r26M7GGEnTKV1Jz+7SphK6x1A+e0S3De/oxF8wlSKmC1MpbKwMJVu32VRRcXKXU0aX9ltQSOcK7u7tFvZg/aetO9G++6018BUsv9TTCXtKaaS9j6eE1/ZN2jUVJhKw+ummEqAgT2m0hDF+0ajLA9ar0pAmEpDKecxlRrzFKZS3ipMpbx15dBkLOc8plIlkDCVit7CVBrF+RA/C2zlodHH/jCQldzT0mMq7aermEpFOWEqNYnzGzCVAmsLU6nIIEyl9+co9OiouQBhKq3zmEofy7FetCVMpRjpK8d7flaYSuV3YSqNuzyhEnZGmErNFAhTqZ7FPKYS3ChLulaeaS76yrN8B+PKSejJ7NsUU+knpAtTaTs5lf96Lv/1vErLnYSpNAzzxdjSS4JRmS/lV17G99fCVPrzM8E8nmUg8wr3tAhTaVs6Oxl2eg7QznMdP4WpVEm5ch6fn+9qai1MJe3X8fkFbJ+V46uYSn/SYyrFTl/ZgG2/yT2alTf7dr5VTKWP+mK2dkmlSnKF1eIr73CBLUylbftdniMWptJX6hfgSaeYSs5Aw/enmEpsoOV3f71eK+6FqVRRLUylsCTCVKqMX8VUahJKmEojHIkDG+7qp8wLU2m85O6lru+GPXxz74Y9XdhvuJvhJ8JU6vwIU2mdYiqT7mEQptIYyb3Re9naham03tt9PWEqBRoVplJXSphKQyn3C4ZG7u+rKUylbEaYSnV/hKmULQlTqbMnTKX1fj7GDfdHH8Anh3hyVphKoyYPRakqN+A1G6gqNzwYXQtTqZpWmErrw0sttROm0t95ZOX2oypNwwlTKcSEMJXKnsJUyoaXPsQZ1kz65vc65snHPe7w4wSqvN8hBlP+8cG6Q9W9BKNzNMlmXUa3RLdCb4eO0a3R26PboNui26HbozugO6JAedbtjN4B3QW9I3ondFf0zuhd0Luiu6G7o3uge6J3Q++O7oXeA70n+ifo3ui90D9F743ug+6L3gfdD90fPQA9EL0vehB6MHo/9P7oA9BD0Aeih6IPQv8M/T/og9E/Rx+CPhR9GPoX6MPRR6CPRB+FHoY+Gj0cfQz6WPQI9HHokehR6NHo49EnoMegT0SPRY9Dj0efhD4ZPQF9Cnoi+lT0aejT0Wegz0SfhX4U/Rj6CfTv0M+hX0C/gv47+jX06+g30W+g30L/A/0Oehn6XfR76A/Q76M/RH+E/gT9Kfqf6M/Q/0b/C/0V+ku0QSdWgSndfiv6GvS16Ap/7Xzhnei/oW9B3whwqvvr29E3WAWmdPvj6L/wyYj222hzNQWm9CcXoO/gExB1W94YvaG8kkbnUBei7+XnOgf8NvoL9EPo36Bv4r9ubRWY0m2MXGBK/3UD+j4OqtvO36KXop/nvzDsAsMWmNJ6U/S2aI3eEr0V//Vz6/hTtH/N/2I2SzidwJRWXHgJFxaY0srBCkzpfWM7S+yzwJTWLlB8BO22/GH00+gn0b9HP4v+X/Qz6P9D/wn9R/RL6JfRL7KHhKCSC1RiliXmWnKxSr5Tdv/1btr/irKFEvMWmNJKkBGY0orbCkxp7Zzi9eg/oD9G2c66y9Gvoi1n4Ca0/xl9D3oxegn6AfT96Ac5PxhnwbkSmNLKGROY0kowKbjixQL6x+gNUAxMYErru/iEayE2pTWiFbo5KlM0mxLluhdcr6KzsdugXN+C6ys2pZWwLDallbBcEIrFprQSfsWmtBJUxaa0EkgLAmlB8CwInmJTWgmeYlNaCYxiU1pxpYJAJzallUAnNqWV8FUQvsSmtBK+xKa0vgLlSolNacWRAy4pNqWV4CY2pc/8LVAS0NJJKCFi+aXoy1D8TmxK68vRM9AuOHC9tiRpik1pKmXPprQSiMSmtE8RAcSmtHIFx3xnjD+OuRZjvHJMgh6Tdsck0zF7OObcjjm3Y/x6jF+POc9jzvOYhDUmYY0552PO+ZhzPuacj0lYYxLWGBsbY2NjLH/MUYy5LmOuy5jrMua6jElYYxLWmIQ1JmGNSVhjEtaYhDU+GT0VfQH6IpRzO+bcjjm3Y86t2JRWIswYfxkTIcd4ypirJjalFb8Wm1K6NVa6NYXE1pylrbHPrfFlsSmtHIXYlFb2X2xKK3tbULqITWmleFjiE7EpfZXxnWUip9iUVqL3mNgrNqWV6O3FQbAprYvoenQz9I9QIkPB1gque3Ez9OYo1lhgA2JTWrEfsSmtJCaxKa1YiNiUViK/2JRWSrgCaywo4QoyToEtFZRwBSVcQQknNqWVUq2gVBOb0kqpJjallbNaUG6JTWmluBKb0kpxJTalleJKbEordlhgh2JTWrE3sSmt2E+B/YhNaeWKiE1pxX7EprRS2IhNaaWwKShsxKa0UtgUeG5BMSA2pZUyoCAyF8RksSnt9c+3jrDM0bPR56CnoNjq6LkoJceI8mOJqLhEDBSb0vYwZVOiHN0yR7csb3IFzm+xtcDWwvNQvCD8JfpCFI8IL0FPR/GOgHcEvCMQcwIxR2xK61noK9Gz0XPQc9FXoeeh56N4ltiUVnKN2JRWypVAxAtEs0AJFLBwsSmt+GN4M0qZFMg1geJKbEoreS1QUIlNaSXPBnKf2JRWqhSxKa1kwEDuE5vSSj0QqBACZWcgLwdqg0A2D1QOgQggNqWVmiFQM0T8LhJdxaa0kvvEprSSPSPZU2xKK74Z8c2Ib0ZiciRLRrJkJD5HMmzEc8WmtOK5Ec+NeK7YlFZieCSfRvJpxHIiHh3x6EiWj2QNsSmteLfYlFa8O+LdEe+OeHfEuyPeHfHuiHdHvDvi3RHvjlhmxLvFprRSHUVimp45bMXrI14f8fqI14tNaSX7i01pJQJEIoDYlFa8QGxKK5E2UjtF4m2kKohUBWJTWokYYlNaqRAiMVZsSisxJBJDIjEkEkPEprSS6cSmtJLpIpkukukiESYSYSKZLpLpIplObEorvhnJcWJTWvGviH8tcQWXuYJiU0orrLqicqiw7QrbrqgiKqqICjuvsPMKO6+w8woLr7DwCguvsPAKC6+67WPnFXZeUY2ITWmlY1VR31ZUvGJTWqnhKzpcYlNayX0Vua+ipq2oYyvq3oqKVGxKK12biq5ZRTdNbEorXbOKbprYlFbyV0U3raKDVtFZE5vSSq0rNqWVqFgRFSu6Y0uKFYJpfV53wdL4Euewa+jkqKHbLnR+Ag09LZNzJXilFRtusOEGG26wYcErrdiw4JVWbLjBhhtsWPBKKzbcYMOCV1qx3qbrm2C9DdYreKUVi22w2AZbbbDVBittsNIGK22wUsErrVhpg5U2WGmDlQpe6TNA3FiiGl8ieiwRPRKfJyJAwt8Tnp7Yh8Q2E9tMbDOxzcQ2E5Vewv4T9p+oZBK1WaI2S1Q1idosUdskcmsityZyayK3JnJrIrcmsmqiok54U8LGEvaQuKaJznVSR7vPZRNZYNfmbZIDllL2s2voENR4IEfRNXSAXUP73zV0aF1DR726Kar6pjtS+lkNHt3g0Q0enchWDfvfUBs03VGQVRt6AQ29gIb+WqIX0JxGm4zWkFsbfL/B9xNZrKHybMiwDRk2kVkaKocJmWJCpphwZSdkgQnWOMEaJ0TCCdd0gl1NiIQTrGuCdU24shOu7ITjmnBcE+LShLg04fpOuL4Tru+EqzbhSCf0hib0hiZcuwkV0YSKaEJFNKGKmHCkE45xwnFNqAomVAUTqoIJVcGEqmBCVTBhkGRCbTDhbE+oDSb0pCbUBhOqggn1wIQ4OSEvT8jLE/LyhLM3IS9PyMsTKuQJUW5ClJsQ5SZEuQlRboIFTohsE2LahJg2IaZNiGmXEwcux5cvJxNdjkdfzvm/nMrqcqJTS3WXyKct1V0iq7bUY4nc2mI5iQzb8r+JPNtSlbVYTkttlsi8Lec2kX9brKjlDLdUaImM3HK2EzGtpU5rqdNarDER5VqqtZZqreW6JOJey3VpuS4t1yURCVuuS8t1abkuidjYcl1aKreWq5OIli3XKHGuWq5UwlZbKreExbZcu0QUbclxLTmuJccl4mpLjmvJcS05LhFpW2q5lkzXkukSsbcl07VkupZMl6goWjJdS6Zr6cElonRL77ulxmup8RJxu8WWWmypxZYSkbzFllpsqcWWEr7WYkstttRiSwnva8mYLRmzxa4S/thiXS3W1WJdCQ9tyZgtGbMlYyaql5aM2ZIx2y5CkilaMmZLxmzJmKnLHdTMibPRUDMnsknLwGYip7Tk00RmabHYhh5KQw+lJfa2DHK2jMW1jAq2DHK29HFa+jgtfZxW/7UamTd66VdUNV3VX/8XvHSACow0Gq5Co7rlt9iaeNPSX3edR9xQvGkryUK86TX/KyhBXPlD9UFm3oo37VKTInZZafda7Z7WZljV0+kaCmtX+39HHI5g01aiimDTVg5ZsGkrUUWwaStRRbBpK1FFsGkrUUWwaStRRbBpK1FFsGkrUUWwaStRRbBpK1FFsGkrUWVENTgiqoyIKiOiyoj6eYQfjYgqI6LKiPp5RFQZEVVGRJURfcYRUWVEVBkRVUZkqBFRZURUGRFVBJu2ElUEm7YSVQSbthJVBJu2ElUEm7YSVQSbthJVBJu2ElUEm7YSVQSbthJVBJu2ElUEm7YSVQSbthJVBJu2ElUEm7Ziz4JNW6nDBZu2MlEi2LSVqCLYtJWoIti0lSpuRCQRbNpKJBFs2kokKTgDgk1bOQMFZ6DgDAg2beUMCDZt7WYTOAMFZ0CwaWs3As8ZKDgDgk1vZHuCTVuptSKZMZIZI9lQsGkr2VCwaSv2Kdi0FRsTbNqKjQk2bcXGBJu2YkuCTVuxJcGmvSfUQmXXK+R8CjZ9RehQ7282kmigqWuosuoaKqu6hsaauoaGm7qG5kS6BsPRDSV3Q8nddCU3A9QNpV1Dadd0pXtXrBIHGsrvhs5sUvk6uzOqY2ffMsDVUPA3FPxNV/BT6jR0dRu6ug3DUElDW7P/ripo9i2DXQ1DZw2TOw1HkSiQGgrLhsKyobBMGsKa/XfG0Jpul7odYCQtUUc1jG4lafdlFVRdQzVV16CsahgWSy+mzf4kSqyGjSdduO7LqrW6BuVWw/eTzKn7UBbVNVR6dQ3V8F1DZtY1ZGldQ8NlXUNWN3s4Mr/Zt7LD2bcyyNm3qtNm36pgm32rGDv7VsF29q2sevatzHv2rSLw7FtCcUPB31DwN3SUkj7pvqAo3TUUqLuGovTsFhSuZ98qbs++JYA3uHaDaze4dpK7zX5tNuXpLa7X4LANDtvgsEnOOPs1vLLBx5uuL8ZYZVIumP2aksLsW2WH2bdKE7Nv5eOzb+Xss2/x+mb1cugTIkBDvmuIJw3xJCm/zP6jEs3sW+Wa2bcknYbkmEg9TXddSI4NyTEpGXVfVj7qGkpJXYOs1BDzE7mpIU4mMlTT1aXkqaarRclWDXkhKWd1GyFtNSSRpKDdfai4PbufCuBdgxjekE0asklDNkmK6t0XCOwN4TQR3huuaZIldF/ozIAIn7o9JMKnbs+J8KnbW3JcIselbve6yrk7XnJc6o6F/UnsT+r2p6uZyW6J7JbIbonslshuSbXu7DGq6J19qyJt9i0d9qRC+pqXVQ0Ds40GZru3Gqu58tdK9Q4YplDja9PxCsEvrNjYEja2hKksYSRLGMkSRrKEuwl+YeXki2dh5eTrOQdWomhBj1XPObASkPWcAys91oLwWBBpCyJtQY+1oMeq5xxYCZIF4VTPObASPAvyb0EvtWCsoyAXF/hpgZ/qOQdW8nKBmxe4eYGb6zkHVnqpBcdbdDPX1JB6zoGVY9dzDqycAT3nwEoNWVBD6jkHVs6JnnNg7c4DOb0gehTUjXrOgZW6Uc85sJLrC3J9gdfrOQdW6saCurGgbtRzDqy4cIHzFtSNBXVjQd1Y4KEFvll0dwLgj3rOgZW6scABC+rGApsvsHk956AzmAKz13MOrJh9gdkXlHZ6zoG1myLE+AuMX885sGL8es6BFePXcw6slHYFpV1BaVdQ2hV0GAsGYAvKPD3nwEqZV1DmFZR5es6Bix/2UM85sDI5ouccWJkcKZkcKZkcKZkcKRnyKhnyKpkcKZkcKRnM1HMOrAyF6TkHVqZISqZISgbHSqZISqZI9JwDKwPses6BlSmSkikSPefAygCpnnNgxRNLpkj0nAMrA8Ulgzl6zoGVAZySoZuSQRs958DK4EzJUEzJIIyec9BdoJIxFj3nwMr4iZ5zYGWcRM85sDI2UjIqUjL6quccWBl91XMOrBRsJQWbnnNgZayyZExPzzmwUoyVFGN6zoGVUb6SUlDPObBSCuo5B1aKupKiTs85sDKKq+ccWCkpS0rKkvHAklHQklHQkrFBPefASqlQUiqUlAp6zoGVck7PObBSzpXMnJaUfyXlX0n5V1KylhSoJaOpJaOpJaOyJfVeSaQqiVQlkaokUpVEqpJIVRKpSiJVSaTScw6sRKqSSFUSqUoiVUmkKrtanXhVEq9Keg0lUaskapVErZKoVRK1SqJWSdQqiVp6zoGVqFUStfScAytRS885sBKxSyJYSQQriWAlEUzPObASwUoiWEkEE4DBSgTTcw6sRLCSSF4SwUoiWEkEK4lgJRGsJIKVRLCyuweJCKbnHFiJYCURrCSClUSwkghWEsFKIpiec2Alguk5B1YiWEnUKolXJfGqJF6V9PJKenklvbySCqGkl1dSDJSUASWlYEkpWFIDlNQAJbGuJL+XBLqSQFcS6EoCXUmgKwlfJeFLTy/wAAUBJxBqAqEmEGoCoSYQagJBJhBkAkEmEGQCQSYQZAJBJhBkAkEmEGQCQSYQZEI3i0eQCQSZQJAJBJlAkAkEmUCQCQSZQJAJBJnA7Ewg1ASCTCDIBIJMIMgEgkwgyASCTGBcNxBhAhEmEGECESYQYQIRJhBhAhEmMMoaGFMNjKAGxksDo6OBsdDAyGdgDisw7h0Y9w6MewfGvQPzDoGx0MDIZ2CcMzCqGRjDDIxYBsYnA6ORgXHIwAhkYB4qMA8VmIcKzFYEZisC8SoQrwLxKhCvAvEqEK8C8SoQrwLxKhCvAvEqEK8C8SoQrwLxKhCvAnEpEJcC8UekaSv2GbDPgH0G7FOkaSv2KdK0lRpVpGkrNWqgRg3UqIF8LdK0FRsO2LBI01ZsOGDDARsWadpKsg4ka5GmrSTrQLIWt8OKtYs0be2snWQt0rSVZB1I1oFkHUjWgWQdSNaxGxvB2iMZR6RpK+dcpGkr5zxyziPnPHLOI+dcpGkr5zxyziPnPHLOI+dc+BYr5zxyziM5IpIjIjlCpGkr10KkaSs5QqRpKzkikiMi10ikaSs5InYjFSZNo6SJSJqIpIlImoikiUiaiKSJSJqIJIhIgogkCJGmrSSISIIQadpKgogkApGmrQT/SPCPBHmRpq0EeZGmrQT2SGCPBPZIYI8E9khgjwT2SGAXadpKYI8EcJGmrQRwkaatBGqRpq0EapGmrQTqSKCOBOpIoBZp2kqgFmnaSqkp0rSVUlOkaSuhW6RpK6E7dh09k6ZR/CLiFyJNW/GLiF9E/CLiFxFfiPhCxBciviDStBVfEGnaii9EfEGkaSu+INK0FV8QadqK/Ys0bcX+I/Yfsf+I/UfsP2L/EfuP2H/E/kWatlKgRgpU0QqsFKgV+aKiQK3IGhVZQ6RpK1mjImtUFKgVuaMid1TkDpGmreSOitxRUUtU1BIVtUSFCVWYUEUtUVFLVJhThTlV1BIVtURFLVFRS1SYWYWZVZhZhZlVVBEVxlZhbBXGVmFsFcZWYWwVxlZhbBXGVmFsFf2gir5h1Q0grDmM3ymna8TpEmnayukSadrK6RJp2srpGnG6RpwukaatnC6Rpq2cLpGmraRakaatpFqRpq2k2hGpdkSqHZFqR6TaEal2RKodkWpHpNoRqXZEqh2RakekWpGmraRakaatJFyRpq0kXJGmrSRckaatJFyRpq0k3BEJd0TCHZFwRyRckaatJFyRpq0kXJGmrSTcEQlXpGkrCVekaSsJV6RpKwl3RMIdkXBHJNwRCXdEwh2RcEckXJGmrSRckaatJFyRpq0kXJGmrSRckaatJFyRpq0kApGmrXQ9RJq20vUQadpK10OkaStdjxFD3CM6ICM6ICM6ICMSyogOyIgOiEjTVpKLSNNWkotI01aSi0jTVpKLSNNWkotI01aSi0jTVpKLSNNWkotI01aSy4jkItK0leQi0rSV5CLStJXkItK0leQi0rSV5DKiAzIis4zILCOyxqi7jZPcMSJ3jMgdIk1byR0iTVvJHSNyh0jTVgKCSNNWAoJI09Z+6HhENBgRDUZEA2GmrUQDYaatOKAw01YcUJhpKw4ozLQVB8w4YMYBMw6YccCMA2YcMOOAGQfMOGDGATMOmHHAjANmHDDjdBmnyzhdxukyTpdxOmGmrTiaMNNWHE2YaSuOJsy0FUfLOFrG0TKOlnG0jKNlHC3jaBlHyzhaxtEyjpZxtIyjZRwt42gZR8s4WsbRMo6WcbSMo2UcLeNoGUcTZtqKowkzbcXRhJm24mgZ58o4V8a5Ms6Vca6Mc2UcKuNQGYfKOFTGoTIOlXGojENlXCnjRBn3yThOxnEyjpNxnIzjZBwn4zgZx8k4TsZxMo6TcZyM42QcJ+M4GcfJOI4w01YcJ+M4GccRZtqK42QcJ+M4wkxbcZyM42QcJ+M4GccRZtpKGSbMtJUyTJhpK2WYMNNWHCrjUBmHyjhUxqEyDpVxqIxDZRxKmGkrDiXMtBWHEmbaSoYVZtqKT2V8KuNTGZ/KnU+RYTMZNpNhMxk2k2EzGTbTW8/k2UyezeTZTJ7N5NlMns3k2UyezeTZTJ7N5NlMns3kWWGmrfTchZm20nMXZtpKySfMtJU+e6bPnumzZ/rsmVIwUwpmSsFMKZgpBTOloDDTVkpBYaatFIHCTFspAjNFYKYIzBSBmSIwUwRm+u+Z/numDszUgZk6MFMHZmq/TO2X6RNl+kTCTFupAzMVYKYCzFSAmQowUwFmKsBMBSjMtJUKMFMBZipAYaat9IYy1WCmGsxUg5lqMFMNZqrBTAWYqQAzFWCm75MZqMzUgZk6MHNnS+bOlswNGJkh/cy9MUJFe50F56QlsrVEtra7y2v1RgjY0FaikNjQVqKQ2NBWrnvJvpVUqiWVasl+luxnyX6WVKole1uytyV7W3bDquxtyd6W7G3J3pbsbdmtNSDyBCJPIPIEIk8g8gQiTyDyBCJPINoEknUg5ogNbeV3a45ObGgreacm79TkHbGhreSdmrxTk3dq8k5N3hEb2kreqck7NXlHbGgreacm79TknZq8U5N3avKO2NBWCr+aHFSTg2pyUE0OqslBNTmopvCrKfxqrprY0FauWk0+qslHYkNbyUc1+UhsaCv5SGxoK/moJh+JDW0lH9Xko5p8VJOPavJRTT6qsYQaS6ixhJp8VJOPxIa2ko9q8lFNPqrJRzX5qCYf1eSjmnwkNrSVfFSTj2ryUU3hV1P41eSmmtxUk5tqclNNbqrJTTWFX03hV2MtNdZSYy011lJjLTXWUmMtNdZSU/jVZKuawq8mZ9UUfjW2VGNLNbZUk79q8ldN/qrJXzX5qyZ/1eSvmvxVk79q8lfd3T/cTbRhgQkLTFhgwooSFpW6O5+xpYQtJWwpYUsJW0ocReIoko6i26yCRteQb87O63W3t5lMjWI5DZYjMrUVy2mwHJGprViOyNS++fxt3IqvxsV945LpzfliVVsxTrGqr9zVuhy/Dvh7wN8D/l53I/DYj4CvVuynxH4EnrZiPwJPW7GfEvsReNrb4doFrl3g2gWuXeDaCTxtJZ4E4kkgngg8bSUmVGRD33Jv8DRKTqnIKQlPT3hf6u6g5lcSv5L4ldTdKNKtVyrWLcj8Zo59QXY4+1YGOft29q5CvZ29n01vZauzb3W5Z9/qus++7Qxg9a32tmtoh7uG9rlraLdnv6n9n327uvCqeyubn30r4599Ky+YfSt3mH0rv5h9KweZfStPmX0rl5l9K9+ZfSsnmn0rb5p9K7eafSu76hoqEbuGqsSZL4gnbqV0rCkda9KieOJWSsea0rGmdKwpHWtKx5rSUTxxK6WjeOJWSsea0rGmdBRP3EqfSzxxK2WkeOJWykjxxK2UkTVlZE0ZKZ64lTKypoysKSNrysiaMlI8cStlpHjiVspI8cStlJE1ZWRNGVlTRtaUkTVlZE0ZKZ64lTKypoysKSNrysiaMrKmjKwpI2vKyBrHqSkja8rImjKypoysKSNrysiaMrKmjKwpI2vKyJoysqacqCknasrImjKypoysKSNrysia8cOaYrKmmKwpJmuKyRoXrikma4rJmuhUU0zWFJM1xWRNMVlTTNYUk0uE9yXO3lK3oImzt8TZW+LsLbE/S+yPeOJW9mcnJfH/sdt0t5jFlOy49zFHP3pglQyskoFVMrBKBlbJwCoZWCUDq2RglQyskoFVMrBKBlbJwCoZWCUDq+R3xyphKcdAKRkoJQOlZKCUDJSSgVIyUEoGSslAKRkoJQOlZKCUDJSSgVIyUEoGSslAKRkoJQOlZKCUDJSSgVIyUEoGSslAKRkoJQOlZKCUDJSSgVIyUEoGSslAKRkoJQOlZKCUDJSSgVIyUEoGSslAKRkoJQOlZKCUDJSSgVIyUErmKCVdx3lAlAyIkgFRMiBK/mARJTebQ5Ts96RHHv24wwwpWbxsgJQMkJIBUjJASn5/kJIOlTFASv6nISXdbVMDoWQglAyEkoFQMhBKBkLJQCgZCCUDoeRqEkp6zx04JQOn5LfnlAyLnodFz8Oi5+t40fMf5tLnNde6DevYhnVswzq2YR3bsI5tWMc2rGMb1rEN69iGdWzDOrZhHduwjm1YxzasYxvWsQ3r2K5369ikBIRhKduwlG1YyjYsZRuWsg1L2YalbMNStmEpW7eU7Xe+mOx6uG5sWGA0LDC6ni0wutWVnn48s7zoW8PyomF50bC8aFheNCwvGpYXDcuLhuVFw/KiYXnRsLxoWF40LC8alhcNy4uGByAPC4uGhUXDwqJhYdH1bmHRsKpoWFU0rCoaVhUNq4qGVUXDqqJhVdGwqmhYVTSsKhpWFQ2rioZVRcOqomFV0bCqaFhVNKwqGlYVDauKhlVFw6qiYVXRsKpoWFU0rCoaVhUNq4qGVUXDqqJNvv4/'; + '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'; From 2ff98e563a2d087e32d34957d66b527d9c66e01f Mon Sep 17 00:00:00 2001 From: Joseph Mearman Date: Sat, 14 Nov 2026 13:51:03 +0000 Subject: [PATCH 3/3] fix(documents.js): read a ruled table whose row is left open at a page break A table breaking across pages leaves its last row open at the foot of a page: the rule under it is drawn under some of its columns or none, with the side borders running down to it. Since a border drawn in pieces is joined into one boundary, that open row became the grid's bottom boundary, the outer rectangle did not close, and the whole table was read as prose with its rows written as tab-separated lines. When the cluster's grid does not close, its top or bottom row boundary that does not span the grid is taken off, and the grid tested again. Nothing else is taken off, so a gap in a side border, or strokes closing no rectangle, still leave the grid unclosed. --- packages/documents.js/README.md | 2 +- .../src/layout/lattice-multiple.test.ts | 69 +++++++++++++++++++ packages/documents.js/src/layout/lattice.ts | 60 +++++++++++++--- 3 files changed, 121 insertions(+), 10 deletions(-) diff --git a/packages/documents.js/README.md b/packages/documents.js/README.md index 699dfccf4..d98b24362 100644 --- a/packages/documents.js/README.md +++ b/packages/documents.js/README.md @@ -959,7 +959,7 @@ To run a single test file: `pnpm vitest run src/path/to/file.test.ts`. - **Font resolution uses a real registry, standard 14 as last resort.** A family with no embedded/caller/vendored face (Aptos, third-party typefaces) renders through the nearest standard-14 face with a width-correction factor — expect a visual approximation, not line-identical output. MathML formula rendering is separate: it embeds STIX Two Math, not registry-resolvable. - **Justified paragraphs stretch inter-word gaps** in all three layout engines (`engine.ts`, `slides.ts`, `sheets.ts`). `justifyLineGapsPt` divides slack evenly across detected word gaps; final lines stay left-aligned. - **Encrypted PDFs and CCITT/JBIG2/JPX images are real capabilities** in pdf-codec — not scope boundaries. The permanent boundary is adversarial/malformed-input robustness. -- **PDF → docx/pptx/odt/odp table recovery requires drawn rules**: never text alignment alone (which would invent structure). Either a real gridline lattice, or a table ruled between its rows (`src/layout/ruled-rows.ts`): at least three horizontal rules of one span, with the columns taken from the gutters every row holding text in more than one place leaves, a heading row above the first rule read when its lines keep to the columns, a row crossing a gutter read as a spanning cell, a band whose every line fills its columns split into a row per line, and a band whose first line sets a group heading over sub-headings on the lines under it (two or more of them starting under the heading) read as two rows: the heading one cell from its own column up to where the first line's next run starts, over the sub-headings, and every other column one cell down both rows. Such a grid is refused when every column reads as running prose, when anything other than horizontal strokes and full-width shading is drawn inside it (a diagram), or when one row runs across a gap another row leaves between two places other than as such a group heading, since the columns would then read the text either side of that gap as one cell. A lattice with no text inside is rejected. A page that draws several tables reads each as a table of its own (`detectGridLattices`, `recoverTables` in `src/layout/reconstruct-tables.ts`): every ruled grid that closes into a rectangle, where a grid is the largest of them for the callers that read one grid per page (a worksheet, a slide: `detectGridLattice`). +- **PDF → docx/pptx/odt/odp table recovery requires drawn rules**: never text alignment alone (which would invent structure). Either a real gridline lattice, or a table ruled between its rows (`src/layout/ruled-rows.ts`): at least three horizontal rules of one span, with the columns taken from the gutters every row holding text in more than one place leaves, a heading row above the first rule read when its lines keep to the columns, a row crossing a gutter read as a spanning cell, a band whose every line fills its columns split into a row per line, and a band whose first line sets a group heading over sub-headings on the lines under it (two or more of them starting under the heading) read as two rows: the heading one cell from its own column up to where the first line's next run starts, over the sub-headings, and every other column one cell down both rows. Such a grid is refused when every column reads as running prose, when anything other than horizontal strokes and full-width shading is drawn inside it (a diagram), or when one row runs across a gap another row leaves between two places other than as such a group heading, since the columns would then read the text either side of that gap as one cell. A lattice with no text inside is rejected. A page that draws several tables reads each as a table of its own (`detectGridLattices`, `recoverTables` in `src/layout/reconstruct-tables.ts`): every ruled grid that closes into a rectangle, where a grid is the largest of them for the callers that read one grid per page (a worksheet, a slide: `detectGridLattice`). A table breaking across pages leaves a row open at the page's edge, its rule drawn under some columns or none and the side borders running on to it; a grid that does not close loses its top or bottom row boundary when that boundary does not span it, and is tested again, so the rows the page closes are still read as the table. - **Merged table cells round-trip as merged.** docx: horizontal merge collapses to one `w:tc` with `w:gridSpan`; vertical merge needs one `w:tc` per covered row with `w:vMerge`. ODF: one entry per grid position, covered cells get `table:covered-table-cell`. - **docx headers/footers/comments/footnotes/numbering are readable via `readDocxExtras`** — `readDocxContent` still drops them (`ContentDocument` has nowhere to put them). `PAGE`/`NUMPAGES` field substitution is never read (it's a render-time value). - **A docx inline image reads as a real `ContentImageBlock`** — `buildDocxPackage` recognises the flat docx reader's two-block pattern (empty-text paragraph + image) and writes it back as one paragraph, avoiding spurious blank paragraphs on round trip. diff --git a/packages/documents.js/src/layout/lattice-multiple.test.ts b/packages/documents.js/src/layout/lattice-multiple.test.ts index 4ef990984..00d33f93f 100644 --- a/packages/documents.js/src/layout/lattice-multiple.test.ts +++ b/packages/documents.js/src/layout/lattice-multiple.test.ts @@ -99,6 +99,75 @@ describe("detectGridLattices: a boundary drawn in pieces", () => { }); }); +describe("detectGridLattices: a table continuing onto the next page", () => { + // Three rows by three columns drawn cell by cell, the side borders one piece per row. The table's next row starts at the foot of the page: its first cell's top is the grid's bottom rule, its left border runs on below the grid as one more piece, and a rule under that first cell alone closes it there. + const table: LayoutItem[] = [100, 70, 40, 10].flatMap((y) => [ + line(0, y, 100, y), + line(100, y, 200, y), + line(200, y, 300, y), + ]); + for (const x of [0, 100, 200, 300]) { + for (const [low, high] of [ + [70, 100], + [40, 70], + [10, 40], + ] as const) { + table.push(line(x, low, x, high)); + } + } + const stub = [line(0, -5, 0, 10), line(0, -5, 100, -5)]; + + it("reads the grid the table closes, leaving out the stub under one cell", () => { + const [lattice] = detectGridLattices([...table, ...stub]); + + expect(lattice?.rowBoundariesDescPt).toEqual([100, 70, 40, 10]); + expect(lattice?.columnBoundariesAscPt).toEqual([0, 100, 200, 300]); + }); + + it("reads the stub's rule as no boundary of the table", () => { + const [lattice] = detectGridLattices([...table, ...stub]); + + expect(lattice?.sourceItems.has(stub[1]!)).toBe(false); + }); + + it("reads the grid above an open last row whose rule is drawn under its last cell alone", () => { + // Every border runs on down to the foot of the page and a rule closes only the last column there, as a table whose last column ends on this page and whose other cells continue on the next. + const open = [ + line(0, -5, 0, 10), + line(100, -5, 100, 10), + line(200, -5, 200, 10), + line(300, -5, 300, 10), + line(200, -5, 300, -5), + ]; + + const [lattice] = detectGridLattices([...table, ...open]); + + expect(lattice?.rowBoundariesDescPt).toEqual([100, 70, 40, 10]); + expect(lattice?.columnBoundariesAscPt).toEqual([0, 100, 200, 300]); + }); + + it("reads the grid below a first row the previous page opened, its rule drawn over one cell alone", () => { + const opened = [ + line(0, 100, 0, 115), + line(200, 100, 200, 115), + line(0, 115, 100, 115), + ]; + + const [lattice] = detectGridLattices([...table, ...opened]); + + expect(lattice?.rowBoundariesDescPt).toEqual([100, 70, 40, 10]); + }); + + it("takes off no column boundary, so a side border that stops short leaves the grid unclosed", () => { + const shortRight = table.filter( + (item) => + !(item.kind === "line" && item.x1Pt === 300 && item.y1Pt === 10), + ); + + expect(detectGridLattices(shortRight)).toHaveLength(0); + }); +}); + describe("a page drawing more strokes on one axis than clustering reads", () => { it("is read as having no lattice, rather than spending a pair test on every pair of its strokes", () => { const grid: LayoutItem[] = [ diff --git a/packages/documents.js/src/layout/lattice.ts b/packages/documents.js/src/layout/lattice.ts index 5c22b6a55..8d3acb279 100644 --- a/packages/documents.js/src/layout/lattice.ts +++ b/packages/documents.js/src/layout/lattice.ts @@ -237,6 +237,51 @@ function hasClosedOuterRectangle( ); } +interface ClosedGrid { + readonly rowLines: readonly AxisLine[]; + readonly columnLines: readonly AxisLine[]; +} + +/** + * The closed grid a cluster of boundaries draws: the cluster itself when its outer rectangle closes, else the grid without its top or its bottom row boundary, or both, when that one closes, or undefined. + * + * A table breaking across pages leaves a row open at the page's edge: its last row at the foot of a page is closed by a rule drawn under some of its columns or none, the side borders running down to it, and its first row at the head of the next is opened the same way. Joined to the borders as one boundary (`segmentsTouchCollinearly`), that open row would otherwise leave the whole table unclosed and read as prose, every row of it. So an outer row boundary that does not span the grid is taken off, once at the top and once at the bottom, and the grid tested again; nothing else is, so a grid with a gap in a side border, or a drawing whose strokes close no rectangle, stays unclosed. + * @param rowLines - the cluster's row boundaries, top first + * @param columnLines - the cluster's column boundaries, left first + * @returns the boundaries of the closed grid, or undefined + */ +function closedGrid( + rowLines: readonly AxisLine[], + columnLines: readonly AxisLine[], +): ClosedGrid | undefined { + if (columnLines.length < MIN_GRIDLINE_COUNT_PER_AXIS) { + return undefined; + } + const leftXPt = columnLines[0]!.position; + const rightXPt = columnLines[columnLines.length - 1]!.position; + const spans = (line: AxisLine): boolean => + unionCoverageRatio(line.ranges, leftXPt, rightXPt) >= EDGE_COVERAGE_RATIO; + const openTop = rowLines[0] !== undefined && !spans(rowLines[0]); + const openBottom = + rowLines[rowLines.length - 1] !== undefined && + !spans(rowLines[rowLines.length - 1]!); + const candidates = [ + rowLines, + ...(openTop ? [rowLines.slice(1)] : []), + ...(openBottom ? [rowLines.slice(0, -1)] : []), + ...(openTop && openBottom ? [rowLines.slice(1, -1)] : []), + ]; + for (const rows of candidates) { + if ( + rows.length >= MIN_GRIDLINE_COUNT_PER_AXIS && + hasClosedOuterRectangle(rows, columnLines) + ) { + return { rowLines: rows, columnLines }; + } + } + return undefined; +} + // A rectangular region of the atomic grid (the finest grid the detected boundaries admit) that drawn strokes never actually divided — one real ContentTableCell, spanning more than one atomic row/column exactly when colSpan/rowSpan would (see reconstruct.ts's own recoverTable, which anchors one real cell at [rowStart, colStart] and a rowSpan continuation placeholder at the same column position in every row up to rowEnd, matching how ooxml.js's own docx/pptx table writers already expect a ContentTable to be shaped). export interface TableRegion { readonly rowStart: number; @@ -488,17 +533,14 @@ function latticeCandidates(items: readonly LayoutItem[]): LatticeCandidate[] { for (const cluster of clusterSegments(horizontal, vertical)) { const clusterHorizontal = cluster.filter((s) => s.axis === "horizontal"); const clusterVertical = cluster.filter((s) => s.axis === "vertical"); - const rowLines = dedupeAxisLines(clusterHorizontal, true); - const columnLines = dedupeAxisLines(clusterVertical, false); - if ( - rowLines.length < MIN_GRIDLINE_COUNT_PER_AXIS || - columnLines.length < MIN_GRIDLINE_COUNT_PER_AXIS - ) { - continue; - } - if (!hasClosedOuterRectangle(rowLines, columnLines)) { + const grid = closedGrid( + dedupeAxisLines(clusterHorizontal, true), + dedupeAxisLines(clusterVertical, false), + ); + if (grid === undefined) { continue; } + const { rowLines, columnLines } = grid; const regions = findCellRegions(rowLines, columnLines); if (regions === undefined) { continue;