diff --git a/android/app/src/main/assets/fonts/AtkinsonHyperlegibleNext.ttf b/android/app/src/main/assets/fonts/AtkinsonHyperlegibleNext.ttf new file mode 100644 index 00000000..8c79ccd1 Binary files /dev/null and b/android/app/src/main/assets/fonts/AtkinsonHyperlegibleNext.ttf differ diff --git a/android/app/src/main/assets/fonts/AtkinsonHyperlegibleNext_bold.ttf b/android/app/src/main/assets/fonts/AtkinsonHyperlegibleNext_bold.ttf new file mode 100644 index 00000000..da32902a Binary files /dev/null and b/android/app/src/main/assets/fonts/AtkinsonHyperlegibleNext_bold.ttf differ diff --git a/android/app/src/main/assets/fonts/Lexend.ttf b/android/app/src/main/assets/fonts/Lexend.ttf new file mode 100644 index 00000000..24383287 Binary files /dev/null and b/android/app/src/main/assets/fonts/Lexend.ttf differ diff --git a/android/app/src/main/assets/fonts/Lexend_bold.ttf b/android/app/src/main/assets/fonts/Lexend_bold.ttf new file mode 100644 index 00000000..3ff5666c Binary files /dev/null and b/android/app/src/main/assets/fonts/Lexend_bold.ttf differ diff --git a/android/app/src/main/assets/fonts/OFL.txt b/android/app/src/main/assets/fonts/OFL.txt new file mode 100644 index 00000000..772e4a49 --- /dev/null +++ b/android/app/src/main/assets/fonts/OFL.txt @@ -0,0 +1,107 @@ +The reading fonts in this folder (Settings > Accessibility > Font) are +licensed under the SIL Open Font License, Version 1.1, copied below. + +AtkinsonHyperlegibleNext*.ttf: +Copyright 2020-2024 The Atkinson Hyperlegible Next Project Authors +(https://github.com/googlefonts/atkinson-hyperlegible-next) + +Lexend*.ttf: +Copyright 2018 The Lexend Project Authors (https://github.com/googlefonts/lexend), +with Reserved Font Name "RevReading Lexend". + +OpenDyslexic*.ttf: +Copyright (c) 2019-07-29, Abbie Gonzalez (https://abbiecod.es|support@abbiecod.es), +with Reserved Font Name OpenDyslexic. +Copyright (c) 12/2012 - 2019 + +The files are built by scripts/build-reading-fonts.py from the woff2 files +the webmail bundles (from Fontsource, https://fontsource.org): the variable +Atkinson Hyperlegible Next and Lexend fonts as static regular and bold +instances, OpenDyslexic unchanged apart from the woff2 decompression. + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/android/app/src/main/assets/fonts/OpenDyslexic.ttf b/android/app/src/main/assets/fonts/OpenDyslexic.ttf new file mode 100644 index 00000000..cea9a5a7 Binary files /dev/null and b/android/app/src/main/assets/fonts/OpenDyslexic.ttf differ diff --git a/android/app/src/main/assets/fonts/OpenDyslexic_bold.ttf b/android/app/src/main/assets/fonts/OpenDyslexic_bold.ttf new file mode 100644 index 00000000..7e8ed7c6 Binary files /dev/null and b/android/app/src/main/assets/fonts/OpenDyslexic_bold.ttf differ diff --git a/index.ts b/index.ts index 5ad23c22..cf5677d1 100644 --- a/index.ts +++ b/index.ts @@ -1,3 +1,6 @@ +// First: wraps react-native's Text for the reading font before any module +// copies it (src/theme/reading-font-text). +import './src/theme/reading-font-install'; import { createElement } from 'react'; import { AppRegistry } from 'react-native'; import { registerRootComponent } from 'expo'; diff --git a/locales/rn/de.json b/locales/rn/de.json index dbbff9a7..e786da10 100644 --- a/locales/rn/de.json +++ b/locales/rn/de.json @@ -1384,6 +1384,16 @@ "appearance": "Darstellung", "general": "Allgemein", "privacy": "Datenschutz & Sicherheit" + }, + "accessibility": { + "presets": { + "dyslexia": { + "description_mobile": "Atkinson Hyperlegible als Schrift, auch für Nachrichten als reiner Text." + } + }, + "font": { + "description_ios": "Atkinson Hyperlegible und Lexend sind so gestaltet, dass sich die Buchstaben gut unterscheiden; OpenDyslexic hilft manchen Menschen mit Legasthenie. Auf diesem Gerät gilt die Schrift für Nachrichten als reiner Text." + } } }, "sharing": { diff --git a/locales/rn/en.json b/locales/rn/en.json index 14c685e0..c57a6c76 100644 --- a/locales/rn/en.json +++ b/locales/rn/en.json @@ -963,10 +963,16 @@ "updates": "Updates" }, "accessibility": { + "font": { + "description_ios": "Atkinson Hyperlegible and Lexend are designed to be easy to tell apart; OpenDyslexic helps some people with dyslexia. On this device the font is used for plain-text messages." + }, "presets": { "applied_mobile": "{name} changed {count, plural, one {# setting} other {# settings}}", "apply": "Apply", "apply_named": "Apply {name}", + "dyslexia": { + "description_mobile": "Atkinson Hyperlegible as the font, also for plain-text messages." + }, "low-vision": { "description_mobile": "Text at 150% and labels under the toolbar icons." }, @@ -1016,7 +1022,6 @@ "accessibility_link": { "description_mobile": "Text size, reduced motion and the accessibility presets are on the Accessibility page." }, - "description_mobile": "Customize how the app looks", "cross_all": { "label_mobile": "All mail" }, @@ -1026,6 +1031,7 @@ "cross_unread": { "label_mobile": "All unread" }, + "description_mobile": "Customize how the app looks", "language": { "restart_for_direction": "Restart the app to apply the new text direction.", "system_default": "System default" diff --git a/scripts/build-reading-fonts.py b/scripts/build-reading-fonts.py new file mode 100644 index 00000000..28e41b3b --- /dev/null +++ b/scripts/build-reading-fonts.py @@ -0,0 +1,158 @@ +"""Build the reading fonts the app bundles, from the webmail's copies. + +Settings > Accessibility > Font offers the webmail's three reading fonts +(app/accessibility.css): Atkinson Hyperlegible Next, Lexend and OpenDyslexic, +all under the SIL Open Font License. The webmail ships them as woff2 subsets +(latin and latin-ext). The app needs them twice: + +- Android draws UI text with fonts from android/app/src/main/assets/fonts, + looked up by family name, with a `_bold` file for bold text. Android can't + read woff2 or variable weights there, so each family becomes a static + Regular (400) and Bold (700) TTF, latin and latin-ext merged. +- A plain-text mail body renders in a WebView, which reads the woff2 files + directly; they go into src/theme/reading-fonts-data.ts as base64 so the + sandboxed page (CSP font-src data:) can load them without file access. + +Run from the app root with the webmail checked out two levels up (or +WEBMAIL_DIR set to it): + python scripts/build-reading-fonts.py +Needs fontTools with brotli (pip install fonttools brotli). +""" +import base64 +import io +import os +import re +import sys + +from fontTools.merge import Merger +from fontTools.ttLib import TTFont +from fontTools.varLib.instancer import instantiateVariableFont + +ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +# The webmail checkout (the app lives in its repos/react-native); WEBMAIL_DIR +# points elsewhere, e.g. from a separate worktree. +WEBMAIL_FONTS = os.path.join(os.environ.get('WEBMAIL_DIR') or os.path.join(ROOT, '..', '..'), 'app', 'fonts') +ASSETS = os.path.join(ROOT, 'android', 'app', 'src', 'main', 'assets', 'fonts') +DATA = os.path.join(ROOT, 'src', 'theme', 'reading-fonts-data.ts') + +# Android family name -> the webmail's woff2 subsets (latin first). +FAMILIES = { + 'AtkinsonHyperlegibleNext': { + 'variable': ['atkinson-hyperlegible-next-latin-wght-normal.woff2', + 'atkinson-hyperlegible-next-latin-ext-wght-normal.woff2'], + }, + 'Lexend': { + 'variable': ['lexend-latin-wght-normal.woff2', 'lexend-latin-ext-wght-normal.woff2'], + }, + 'OpenDyslexic': { + 400: ['opendyslexic-latin-400-normal.woff2'], + 700: ['opendyslexic-latin-700-normal.woff2'], + }, +} + +# The woff2 files a mail body loads: (export name, css family, weight range, files). +WEB_FACES = [ + ('ATKINSON', 'Atkinson Hyperlegible Next', '200 800', FAMILIES['AtkinsonHyperlegibleNext']['variable']), + ('LEXEND', 'Lexend', '100 900', FAMILIES['Lexend']['variable']), + ('OPENDYSLEXIC', 'OpenDyslexic', '400', FAMILIES['OpenDyslexic'][400]), +] + + +def load(name): + return TTFont(os.path.join(WEBMAIL_FONTS, name)) + + +def static_instance(name, weight): + font = load(name) + if 'fvar' in font: + font = instantiateVariableFont(font, {'wght': weight}, updateFontNames=False) + font.flavor = None + return font + + +def merge(fonts, out_path): + paths = [] + for i, font in enumerate(fonts): + tmp = out_path + f'.part{i}.ttf' + font.save(tmp) + paths.append(tmp) + if len(paths) == 1: + os.replace(paths[0], out_path) + return + merged = Merger().merge(paths) + merged.save(out_path) + for p in paths: + os.remove(p) + + +def build_assets(): + os.makedirs(ASSETS, exist_ok=True) + for family, spec in FAMILIES.items(): + for weight, suffix in ((400, ''), (700, '_bold')): + files = spec.get('variable') or spec[weight] + fonts = [static_instance(f, weight) for f in files] + out = os.path.join(ASSETS, family + suffix + '.ttf') + merge(fonts, out) + print('wrote', os.path.relpath(out, ROOT), os.path.getsize(out)) + + +def unicode_ranges(): + """woff2 file name -> its unicode-range in the webmail's app/accessibility.css.""" + css_path = os.path.join(WEBMAIL_FONTS, '..', 'accessibility.css') + with open(css_path, encoding='utf-8') as fh: + css = fh.read() + out = {} + for block in re.findall(r'@font-face\s*\{([^}]*)\}', css): + src = re.search(r"fonts/([^\"')]+\.woff2)", block) + rng = re.search(r'unicode-range:\s*([^;]+);', block) + if src: + out[src.group(1)] = rng.group(1).strip() if rng else '' + return out + + +def build_data(): + ranges = unicode_ranges() + lines = [ + "// Generated by scripts/build-reading-fonts.py from the webmail's", + '// app/fonts (SIL Open Font License 1.1, see', + '// android/app/src/main/assets/fonts/OFL.txt). Do not edit by hand. The', + '// woff2 files a plain-text mail body loads as data: URIs, with the', + "// unicode ranges of the webmail's app/accessibility.css.", + '', + 'export interface ReadingFontFace {', + ' /** CSS font-family name, as the webmail uses it. */', + ' family: string;', + ' /** font-weight descriptor (a range for variable fonts). */', + ' weight: string;', + ' /** One per unicode subset: base64 woff2 and its unicode-range ("" = all). */', + ' subsets: Array<{ woff2: string; unicodeRange: string }>;', + '}', + '', + ] + for export, family, weight, files in WEB_FACES: + lines.append(f'export const {export}: ReadingFontFace = {{') + lines.append(f" family: '{family}',") + lines.append(f" weight: '{weight}',") + lines.append(' subsets: [') + for name in files: + if name not in ranges: + sys.exit(f"{name} is not in the webmail's accessibility.css") + with open(os.path.join(WEBMAIL_FONTS, name), 'rb') as fh: + blob = base64.b64encode(fh.read()).decode('ascii') + lines.append(' {') + lines.append(f" unicodeRange: '{ranges[name]}',") + lines.append(f" woff2: '{blob}',") + lines.append(' },') + lines.append(' ],') + lines.append('};') + lines.append('') + with open(DATA, 'w', encoding='utf-8', newline='\n') as fh: + fh.write('\n'.join(lines)) + print('wrote', os.path.relpath(DATA, ROOT), os.path.getsize(DATA)) + + +if __name__ == '__main__': + if not os.path.isdir(WEBMAIL_FONTS): + sys.exit(f'No webmail fonts at {WEBMAIL_FONTS}') + build_assets() + build_data() diff --git a/scripts/generate-licences.mjs b/scripts/generate-licences.mjs index b6698ecf..0a9e7aec 100644 --- a/scripts/generate-licences.mjs +++ b/scripts/generate-licences.mjs @@ -17,6 +17,10 @@ const pkg = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8')); // Code that isn't an npm dependency but ships in the app. const VENDORED = [ { name: 'Tabler Icons', version: '', license: 'MIT', url: 'https://tabler.io/icons' }, + // Reading fonts (scripts/build-reading-fonts.py). + { name: 'Atkinson Hyperlegible Next', version: '', license: 'OFL-1.1', url: 'https://github.com/googlefonts/atkinson-hyperlegible-next' }, + { name: 'Lexend', version: '', license: 'OFL-1.1', url: 'https://github.com/googlefonts/lexend' }, + { name: 'OpenDyslexic', version: '', license: 'OFL-1.1', url: 'https://opendyslexic.org' }, ]; function repoUrl(meta) { diff --git a/src/components/EmailBodyView.tsx b/src/components/EmailBodyView.tsx index da8ebdc2..7acac418 100644 --- a/src/components/EmailBodyView.tsx +++ b/src/components/EmailBodyView.tsx @@ -444,6 +444,9 @@ export default function EmailBodyView({ const syncTrustedSenders = isTrustedSendersSyncOn(trustedSendersAddressBook, hasContacts); const emailAlwaysLightMode = useSettingsStore((s) => s.emailAlwaysLightMode); const plainTextFont = useSettingsStore((s) => s.plainTextFont); + // The reading font reaches a plain-text body ("Same as above"), as in the + // webmail; HTML mail keeps the sender's fonts. + const appFont = useSettingsStore((s) => s.appFont); const messageSpacing = useSettingsStore((s) => s.messageSpacing); const plainTextMode = useSettingsStore((s) => s.plainTextMode); // Body text follows the app's text size and the system font scale (webmail @@ -611,9 +614,10 @@ export default function EmailBodyView({ quoteLabels, textFactor, plainDarkColors, + appFont, }), [ jmapAccountId, email.id, rawHtml, text, email.preview, emptyLabel, shouldBlock, cidMap, renderAsDark, - messageSpacing, plainTextFont, quoteLabels, textFactor, plainDarkColors, + messageSpacing, plainTextFont, quoteLabels, textFactor, plainDarkColors, appFont, ]); const source = React.useMemo( diff --git a/src/components/settings/AccessibilitySettings.tsx b/src/components/settings/AccessibilitySettings.tsx index cce54933..374bad8b 100644 --- a/src/components/settings/AccessibilitySettings.tsx +++ b/src/components/settings/AccessibilitySettings.tsx @@ -1,10 +1,11 @@ import React from 'react'; -import { View } from 'react-native'; +import { Platform, View } from 'react-native'; import { SettingsSection, SettingItem, Select, ToggleSwitch } from './settings-section'; import Button from '../Button'; import { spacing } from '../../theme/tokens'; import { useLocaleStore } from '../../stores/locale-store'; -import { FONT_SIZES, useSettingsStore, type FontSize } from '../../stores/settings-store'; +import { APP_FONTS, FONT_SIZES, useSettingsStore, type AppFont, type FontSize } from '../../stores/settings-store'; +import { uiFontsBundled } from '../../theme/reading-fonts'; import { toast } from '../../stores/toast-store'; import { ACCESSIBILITY_PRESET_IDS, @@ -15,6 +16,14 @@ import { } from '../../lib/accessibility-presets'; import { TOAST_DURATION_CHOICES } from '../../lib/toast-duration'; +// Font names are names: the same in every language (webmail +// accessibility-settings.tsx). +const FONT_NAMES: Record, string> = { + atkinson: 'Atkinson Hyperlegible', + lexend: 'Lexend', + opendyslexic: 'OpenDyslexic', +}; + // Percentages read the same in every language the app has. const TEXT_SIZE_LABELS: Record = { small: '87.5%', @@ -41,6 +50,11 @@ function presetCopy(id: AccessibilityPresetId, t: Translate): { label: string; d label: t('settings.accessibility.presets.low-vision.label', 'Low vision'), description: t('settings.accessibility.presets.low-vision.description_mobile', 'Text at 150% and labels under the toolbar icons.'), }; + case 'dyslexia': + return { + label: t('settings.accessibility.presets.dyslexia.label', 'Dyslexia'), + description: t('settings.accessibility.presets.dyslexia.description_mobile', 'Atkinson Hyperlegible as the font, also for plain-text messages.'), + }; case 'motion': return { label: t('settings.accessibility.presets.motion.label', 'Motion and seizure safe'), @@ -61,6 +75,7 @@ export function AccessibilitySettings() { const hydrate = useSettingsStore((s) => s.hydrate); const update = useSettingsStore((s) => s.updateSetting); const fontSize = useSettingsStore((s) => s.fontSize); + const appFont = useSettingsStore((s) => s.appFont); const animationsEnabled = useSettingsStore((s) => s.animationsEnabled); const toastDuration = useSettingsStore((s) => s.toastDuration); const sendConfirmation = useSettingsStore((s) => s.sendConfirmation); @@ -130,7 +145,6 @@ export function AccessibilitySettings() { update('appFont', v as AppFont)} + options={APP_FONTS.map((font) => ({ + value: font, + label: font === 'default' ? t('settings.accessibility.font.default', 'Theme font') : FONT_NAMES[font], + }))} + /> + diff --git a/src/lib/__tests__/email-body-document.test.ts b/src/lib/__tests__/email-body-document.test.ts index b685819e..2a80daa9 100644 --- a/src/lib/__tests__/email-body-document.test.ts +++ b/src/lib/__tests__/email-body-document.test.ts @@ -50,6 +50,15 @@ describe('bodyDocument', () => { expect(bodyDocument(input({ cidMap: { a: 'data:image/png;base64,AA' } }))).not.toBe(first); }); + it('draws a plain-text body in the reading font and rebuilds when it changes', () => { + const text = input({ rawHtml: null, text: 'Hello' }); + const plain = bodyDocument(text); + const lexend = bodyDocument({ ...text, appFont: 'lexend' }); + expect(lexend).not.toBe(plain); + expect(lexend.html).toContain('font-family: "Lexend"'); + expect(plain.html).not.toContain('Lexend'); + }); + it('keeps messages apart by key', () => { const a = bodyDocument(input({ key: '|e1' })); const b = bodyDocument(input({ key: 'group|e1' })); diff --git a/src/lib/__tests__/email-html.test.ts b/src/lib/__tests__/email-html.test.ts index 1cd2e39c..da127f9b 100644 --- a/src/lib/__tests__/email-html.test.ts +++ b/src/lib/__tests__/email-html.test.ts @@ -388,6 +388,22 @@ describe('wrapPlainTextEmail', () => { it('lets the content pick its text direction', () => { expect(wrapPlainTextEmail('مرحبا بالعالم.')).toContain(''); }); + + // Settings > Accessibility > Font: a plain body sits in the app document in + // the webmail, so it is drawn in the reading font ("Same as above"). + it('draws the body in the reading font, which the page loads from data:', () => { + const html = wrapPlainTextEmail('x', { font: 'sans', readingFont: 'opendyslexic' }); + expect(html).toContain('font-family: "OpenDyslexic", -apple-system'); + expect(html).toMatch(/@font-face \{ font-family: "OpenDyslexic";[^}]*src: url\("data:font\/woff2;base64,/); + expect(html).toContain('font-src data:'); + }); + + it('keeps monospace and the theme font as they were', () => { + const mono = wrapPlainTextEmail('x', { font: 'mono', readingFont: 'opendyslexic' }); + expect(mono).toContain('font-family: ui-monospace'); + expect(mono).not.toContain('OpenDyslexic'); + expect(wrapPlainTextEmail('x', { font: 'sans', readingFont: 'default' })).not.toContain('@font-face'); + }); }); describe('hasNativeDarkMode', () => { diff --git a/src/lib/accessibility-presets.ts b/src/lib/accessibility-presets.ts index ca63da8a..7303d020 100644 --- a/src/lib/accessibility-presets.ts +++ b/src/lib/accessibility-presets.ts @@ -6,14 +6,15 @@ // // The phone takes the presets whose settings it has: screen reader (no // conversation grouping), low vision (150% text, labels under the toolbar -// icons) and motion (no animations). The webmail's others need settings the -// app doesn't have (reading fonts, spacing, focus outlines, hover, sounds). +// icons), dyslexia (the reading font, also for plain-text mail) and motion +// (no animations). The webmail's others need settings the app doesn't have +// (spacing, focus outlines, hover, sounds). import type { PersistedSettings } from '../stores/settings-store'; -export type AccessibilityPresetId = 'screen-reader' | 'low-vision' | 'motion'; +export type AccessibilityPresetId = 'screen-reader' | 'low-vision' | 'dyslexia' | 'motion'; -export const ACCESSIBILITY_PRESET_IDS: readonly AccessibilityPresetId[] = ['screen-reader', 'low-vision', 'motion']; +export const ACCESSIBILITY_PRESET_IDS: readonly AccessibilityPresetId[] = ['screen-reader', 'low-vision', 'dyslexia', 'motion']; type PresetValues = Partial; @@ -27,6 +28,12 @@ export const ACCESSIBILITY_PRESETS: Record fontSize: 'xx-large', showToolbarLabels: true, }, + // The webmail's font part (its spacing, reading width and mail style + // options have no phone counterpart yet). + dyslexia: { + appFont: 'atkinson', + plainTextFont: 'sans', + }, motion: { animationsEnabled: false, }, diff --git a/src/lib/email-body-document.ts b/src/lib/email-body-document.ts index c01cd088..697a86f7 100644 --- a/src/lib/email-body-document.ts +++ b/src/lib/email-body-document.ts @@ -10,6 +10,7 @@ import { } from './email-html'; import { collapsePlainTextQuotes, type QuoteCollapseLabels } from './quote-collapse'; import { mailBaseFontPx } from './mail-reading'; +import type { AppFont } from '../theme/reading-fonts'; export interface BodyDocumentInput { /** The message (account and id); the sources below are compared as well. */ @@ -33,6 +34,8 @@ export interface BodyDocumentInput { textFactor?: number; /** The app theme's colours for a plain-text body in dark mode. */ plainDarkColors?: PlainTextColors; + /** The reading font (Settings > Accessibility > Font) for a plain-text body. */ + appFont?: AppFont; } export interface BodyDocument { @@ -68,6 +71,7 @@ export function buildBodyDocument(input: BodyDocumentInput): BodyDocument { font: input.plainTextFont, fontPx: mailBaseFontPx(input.textFactor ?? 1), darkColors: input.plainDarkColors, + readingFont: input.appFont, }), recolorDark: false, hasNativeDark: false, @@ -97,7 +101,7 @@ export function bodyDocument(input: BodyDocumentInput): BodyDocument { const key = JSON.stringify([ input.key, input.blockRemoteImages, input.isDark, input.messageSpacing, input.plainTextFont, input.quoteLabels.show, input.quoteLabels.hide, input.emptyLabel, input.textFactor ?? 1, - input.plainDarkColors ?? null, + input.plainDarkColors ?? null, input.appFont ?? 'default', ]); const hit = documents.get(key); if (hit && sameSources(hit.input, input)) { diff --git a/src/lib/email-html.ts b/src/lib/email-html.ts index 8b026a1a..c62fef49 100644 --- a/src/lib/email-html.ts +++ b/src/lib/email-html.ts @@ -22,6 +22,7 @@ // sheet is scrubbed of url()/@import/@font-face references instead. import { DARK_PENDING_CLASS, emailColorScheme, emailDarkModeCss, resolveColorSchemeMedia } from './email-dark-mode'; +import { mailFontStack, readingFontFaceCss, type AppFont } from '../theme/reading-fonts'; const FORBIDDEN_TAGS = [ 'script', 'iframe', 'object', 'embed', 'form', @@ -935,10 +936,22 @@ function cssColor(value: string, fallback: string): string { export function wrapPlainTextEmail( innerHtml: string, - options: { isDark?: boolean; font?: PlainTextFont; fontPx?: number; darkColors?: PlainTextColors } = {}, + options: { + isDark?: boolean; + font?: PlainTextFont; + fontPx?: number; + darkColors?: PlainTextColors; + /** + * The app's reading font (Settings > Accessibility > Font). "Same as + * above" (sans) draws the body in it, as the webmail does for a plain + * body in the app document; monospace stays monospace. + */ + readingFont?: AppFont; + } = {}, ): string { - const { isDark = true, font = 'sans', fontPx = 14, darkColors } = options; + const { isDark = true, font = 'sans', fontPx = 14, darkColors, readingFont } = options; const cleaned = stripDangerousTags(innerHtml); + const reading = font === 'sans' ? readingFont : undefined; // In dark mode the body takes the app theme's ground, text and link colours // when they are given (a built-in dark theme isn't #0a0a0a); light mode @@ -948,9 +961,9 @@ export function wrapPlainTextEmail( const link = isDark ? cssColor(darkColors?.link ?? '', '#60a5fa') : '#1a73e8'; const fontFamily = font === 'mono' ? 'ui-monospace, Menlo, Consolas, "SF Mono", monospace' - : '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif'; + : mailFontStack(reading); - const styles = ` + const styles = `${readingFontFaceCss(reading)} html, body { background: ${bg}; } /* Pinch-zoomed content overflows sideways; it is panned via the injected transform, never via native horizontal scrolling. */ diff --git a/src/lib/licences.json b/src/lib/licences.json index fbf386c7..0108c0ed 100644 --- a/src/lib/licences.json +++ b/src/lib/licences.json @@ -213,6 +213,24 @@ "version": "", "license": "MIT", "url": "https://tabler.io/icons" + }, + { + "name": "Atkinson Hyperlegible Next", + "version": "", + "license": "OFL-1.1", + "url": "https://github.com/googlefonts/atkinson-hyperlegible-next" + }, + { + "name": "Lexend", + "version": "", + "license": "OFL-1.1", + "url": "https://github.com/googlefonts/lexend" + }, + { + "name": "OpenDyslexic", + "version": "", + "license": "OFL-1.1", + "url": "https://opendyslexic.org" } ] } diff --git a/src/lib/settings-search.ts b/src/lib/settings-search.ts index c3511d69..48389ac5 100644 --- a/src/lib/settings-search.ts +++ b/src/lib/settings-search.ts @@ -63,8 +63,10 @@ export const SETTINGS_SEARCH_PATHS: Record = { accessibility: [ 'settings.accessibility.presets.screen-reader', 'settings.accessibility.presets.low-vision', + 'settings.accessibility.presets.dyslexia', 'settings.accessibility.presets.motion', 'settings.accessibility.text_size', + 'settings.accessibility.font', 'settings.accessibility.reduce_motion', 'settings.accessibility.toast_duration', 'settings.accessibility.confirm_send', @@ -267,7 +269,7 @@ export const SETTINGS_SEARCH_KEYWORDS: Record = { recovery: 'recover restore undelete deleted trash emptied lost messages', language: 'locale region date time format translation', notifications: 'alert push badge unifiedpush relay device reminder', - accessibility: 'a11y screen reader talkback voiceover low vision text size font bigger larger motion animation preset undo timeout duration confirm', + accessibility: 'a11y screen reader talkback voiceover low vision text size font bigger larger motion animation preset undo timeout duration confirm dyslexia dyslexic typeface atkinson lexend opendyslexic', appearance: 'theme dark light font size text color animation density', layout: 'swipe gesture quick actions toolbar order sort unified folder count avatar', reading: 'mark read preview thread conversation archive delete attachment open monospace mono font plain text receipt', diff --git a/src/stores/settings-store.ts b/src/stores/settings-store.ts index 4403619e..8a23d545 100644 --- a/src/stores/settings-store.ts +++ b/src/stores/settings-store.ts @@ -17,6 +17,9 @@ export type MailAttachmentAction = 'preview' | 'download'; export type AttachmentPosition = 'beside-sender' | 'below-header'; export type PlainTextFont = 'sans' | 'mono'; export type MessageSpacing = 'auto' | 'always' | 'edge'; +// a11y-reading: the webmail's reading fonts (lib/accessibility-settings.ts AppFont). +export type AppFont = 'default' | 'atkinson' | 'lexend' | 'opendyslexic'; +export const APP_FONTS: readonly AppFont[] = ['default', 'atkinson', 'lexend', 'opendyslexic']; export type ReadReceiptResponse = 'ask' | 'always' | 'never'; export type PostExportAction = 'keep' | 'archive' | 'trash'; export type SwipeAction = @@ -159,6 +162,11 @@ export interface PersistedSettings { emailAlwaysLightMode: boolean; activeThemeId: string | null; + // a11y-reading: Settings > Accessibility (webmail lib/accessibility- + // settings.ts, same keys for export/import). The reading font for the + // app's text and plain-text mail (theme/reading-fonts). + appFont: AppFont; + // Composing autoSelectReplyIdentity: boolean; replyIdentityMatch: ReplyIdentityMatch; @@ -359,6 +367,8 @@ const DEFAULT_PERSISTED: PersistedSettings = { animationsEnabled: true, emailAlwaysLightMode: false, activeThemeId: null, + // a11y-reading: + appFont: 'default', autoSelectReplyIdentity: false, replyIdentityMatch: 'domain', @@ -617,6 +627,8 @@ const VALIDATORS: Partial boolea // Levels are sanitized by the consumer (lib/message-list-order sanitizeSortLevels). messageListOrder: (v) => Array.isArray(v), fontSize: oneOf(FONT_SIZES), + // a11y-reading: + appFont: oneOf(APP_FONTS), density: oneOf(['extra-compact', 'compact', 'regular', 'comfortable']), attachmentReminderKeywords: stringArray, // Same set the webmail accepts (stores/settings-store.ts importSettings). diff --git a/src/theme/__tests__/reading-fonts.test.ts b/src/theme/__tests__/reading-fonts.test.ts new file mode 100644 index 00000000..09090162 --- /dev/null +++ b/src/theme/__tests__/reading-fonts.test.ts @@ -0,0 +1,141 @@ +// Reading fonts (Settings > Accessibility > Font, webmail +// lib/accessibility-settings.ts AppFont, app/accessibility.css): the names, +// the bundled Android files, the @font-face rules a mail body gets, and the +// wrapper that puts the font on the app's Text. +import { describe, it, expect, vi } from 'vitest'; +import { existsSync } from 'node:fs'; +import { join } from 'node:path'; + +// The wrapper subscribes with useSyncExternalStore; outside a React render +// the test reads the snapshot directly. +vi.mock('react', async (importOriginal) => ({ + ...(await importOriginal>()), + useSyncExternalStore: (_subscribe: unknown, getSnapshot: () => unknown) => getSnapshot(), +})); + +import { + appFontAssetFamily, + appFontFamilyName, + mailFontStack, + readingFontFaceCss, + uiFontFamily, + uiFontsBundled, +} from '../reading-fonts'; +import { + getUiFontFamily, + setUiFontFamily, + withFontFamily, + wrapModuleDefaults, + wrapWithReadingFont, +} from '../reading-font-text'; +import { APP_FONTS, mergeWithDefaults } from '../../stores/settings-store'; +import { presetChanges } from '../../lib/accessibility-presets'; + +const ASSETS = join(__dirname, '..', '..', '..', 'android', 'app', 'src', 'main', 'assets', 'fonts'); + +describe('reading fonts', () => { + it('offers the webmail fonts under its names and keys', () => { + expect(APP_FONTS).toEqual(['default', 'atkinson', 'lexend', 'opendyslexic']); + expect(appFontFamilyName('atkinson')).toBe('Atkinson Hyperlegible Next'); + expect(appFontFamilyName('lexend')).toBe('Lexend'); + expect(appFontFamilyName('opendyslexic')).toBe('OpenDyslexic'); + expect(appFontFamilyName('default')).toBeNull(); + }); + + it('bundles a regular and a bold file on Android for every font', () => { + for (const font of APP_FONTS) { + const family = appFontAssetFamily(font); + if (font === 'default') { + expect(family).toBeNull(); + continue; + } + expect(existsSync(join(ASSETS, `${family}.ttf`))).toBe(true); + expect(existsSync(join(ASSETS, `${family}_bold.ttf`))).toBe(true); + } + expect(existsSync(join(ASSETS, 'OFL.txt'))).toBe(true); + }); + + it('names a family for the app text only where the fonts are bundled', () => { + expect(uiFontsBundled('android')).toBe(true); + expect(uiFontFamily('opendyslexic', 'android')).toBe('OpenDyslexic'); + expect(uiFontFamily('default', 'android')).toBeNull(); + // iOS reports an unknown family as an error. + expect(uiFontFamily('opendyslexic', 'ios')).toBeNull(); + }); + + it('puts the font first in a mail body and keeps the system stack behind it', () => { + expect(mailFontStack('lexend')).toMatch(/^"Lexend", -apple-system, /); + expect(mailFontStack('default')).toMatch(/^-apple-system, /); + }); + + it('gives a mail document the font as data: woff2 with the webmail unicode ranges', () => { + const css = readingFontFaceCss('atkinson'); + const faces = css.split('\n'); + expect(faces).toHaveLength(2); + for (const face of faces) { + expect(face).toContain('font-family: "Atkinson Hyperlegible Next";'); + expect(face).toContain('font-weight: 200 800;'); + // "wOF2", the woff2 signature, in base64. + expect(face).toMatch(/src: url\("data:font\/woff2;base64,d09GMg[A-Za-z0-9+/=]+"\) format\("woff2"\);/); + expect(face).toMatch(/unicode-range: U\+/); + } + expect(readingFontFaceCss('opendyslexic')).toContain('font-family: "OpenDyslexic";'); + expect(readingFontFaceCss('default')).toBe(''); + }); + + it('keeps a stored font and drops one the app does not know', () => { + expect(mergeWithDefaults({ appFont: 'lexend' }).appFont).toBe('lexend'); + expect(mergeWithDefaults({ appFont: 'comic-sans' as never }).appFont).toBe('default'); + }); + + it('has a dyslexia preset that picks the readable font for the app and plain-text mail', () => { + expect(presetChanges('dyslexia', { appFont: 'default', plainTextFont: 'mono' })).toEqual([ + { key: 'appFont', from: 'default', to: 'atkinson' }, + { key: 'plainTextFont', from: 'mono', to: 'sans' }, + ]); + }); +}); + +describe('the reading font on the app text', () => { + it('puts the family under the caller style, which still wins', () => { + const own = { color: 'red' }; + expect(withFontFamily({ style: own }, 'Lexend')).toEqual({ style: [{ fontFamily: 'Lexend' }, own] }); + expect(withFontFamily({}, 'Lexend')).toEqual({ style: { fontFamily: 'Lexend' } }); + const props = { style: own }; + expect(withFontFamily(props, null)).toBe(props); + }); + + it('renders the original component with the current family', () => { + const seen: unknown[] = []; + const Original = Object.assign((props: Record) => { seen.push(props); return null; }, { + displayName: 'TextInput', + State: { currentlyFocusedInput: () => null }, + }); + const Wrapped = wrapWithReadingFont(Original); + // Statics such as TextInput.State stay reachable. + expect((Wrapped as unknown as typeof Original).State).toBe(Original.State); + expect(Wrapped.displayName).toBe('TextInput'); + + setUiFontFamily(null); + Wrapped({ style: { color: 'red' }, children: 'x' }); + expect(seen.pop()).toEqual({ style: { color: 'red' }, children: 'x' }); + + setUiFontFamily('OpenDyslexic'); + expect(getUiFontFamily()).toBe('OpenDyslexic'); + Wrapped({ style: { color: 'red' }, children: 'x' }); + expect(seen.pop()).toEqual({ style: [{ fontFamily: 'OpenDyslexic' }, { color: 'red' }], children: 'x' }); + setUiFontFamily(null); + }); + + it('wraps each module default once and leaves non-functions alone', () => { + const text = { default: () => null }; + const memo = { default: { $$typeof: Symbol.for('react.memo') } }; + const original = text.default; + expect(wrapModuleDefaults([text, memo])).toBe(1); + expect(text.default).not.toBe(original); + const wrapped = text.default; + expect(wrapModuleDefaults([text])).toBe(0); + expect(text.default).toBe(wrapped); + expect(memo.default).toEqual({ $$typeof: Symbol.for('react.memo') }); + }); +}); diff --git a/src/theme/reading-font-install.ts b/src/theme/reading-font-install.ts new file mode 100644 index 00000000..d6d57ec7 --- /dev/null +++ b/src/theme/reading-font-install.ts @@ -0,0 +1,22 @@ +// Installs the reading font for the app's text (./reading-font-text). Imported +// first thing by index.ts, before any screen module copies `Text` out of +// react-native. Android only: iOS has no bundled reading fonts yet +// (./reading-fonts). The settings store is required after the wrapping, so +// nothing it loads can copy the plain Text first. + +/* eslint-disable @typescript-eslint/no-require-imports */ +import { Platform } from 'react-native'; +import { setUiFontFamily, wrapModuleDefaults } from './reading-font-text'; +import { uiFontFamily, uiFontsBundled } from './reading-fonts'; + +if (uiFontsBundled(Platform.OS)) { + wrapModuleDefaults([ + require('react-native/Libraries/Text/Text'), + require('react-native/Libraries/Components/TextInput/TextInput'), + ]); + const { useSettingsStore } = require('../stores/settings-store') as typeof import('../stores/settings-store'); + setUiFontFamily(uiFontFamily(useSettingsStore.getState().appFont, Platform.OS)); + useSettingsStore.subscribe((state, prev) => { + if (state.appFont !== prev.appFont) setUiFontFamily(uiFontFamily(state.appFont, Platform.OS)); + }); +} diff --git a/src/theme/reading-font-text.ts b/src/theme/reading-font-text.ts new file mode 100644 index 00000000..adbbd1ee --- /dev/null +++ b/src/theme/reading-font-text.ts @@ -0,0 +1,88 @@ +// The reading font for the app's own text (Settings > Accessibility > Font). +// +// The webmail sets one CSS variable on and every piece of text follows +// (app/accessibility.css data-app-font). React Native has no inherited font: +// each Text takes its family from its own style, the app's styles name none, +// and Text.defaultProps is gone on the new architecture. So the app's Text +// and TextInput components are wrapped once at startup: the wrapper puts the +// chosen family under the caller's own style (an explicit fontFamily still +// wins) and re-renders when the setting changes. +// +// Wrapping happens before any screen module loads (index.ts imports +// ./reading-font-install first): with Metro's import support every module +// copies `Text` out of react-native when it is evaluated, so a module loaded +// earlier keeps the plain component. The wrapper stays installed for the +// whole run, also while the theme font is chosen; swapping the component +// later would remount every text field. + +import { useSyncExternalStore } from 'react'; + +type Props = { style?: unknown } & Record; +type FunctionComponent = ((props: Props) => unknown) & { displayName?: string }; + +let family: string | null = null; +const listeners = new Set<() => void>(); + +const subscribe = (listener: () => void) => { + listeners.add(listener); + return () => { listeners.delete(listener); }; +}; + +/** The family the app's text is drawn in right now, or null for the theme font. */ +export function getUiFontFamily(): string | null { + return family; +} + +/** Changes the family; every wrapped Text re-renders. */ +export function setUiFontFamily(next: string | null): void { + if (next === family) return; + family = next; + for (const listener of [...listeners]) listener(); +} + +/** `props` with the family under the caller's own style; unchanged for null. */ +export function withFontFamily

(props: P, fontFamily: string | null): P { + if (!fontFamily) return props; + return { ...props, style: props.style == null ? { fontFamily } : [{ fontFamily }, props.style] }; +} + +const WRAPPED = Symbol.for('bulwark.readingFont'); + +/** + * A component that renders `Original` with the reading font. `Original` is + * called as a function, not rendered as a child, so no extra component is + * added per text: its hooks run as part of the wrapper, always in the same + * order. Statics (TextInput.State) and the display name are kept. + */ +export function wrapWithReadingFont(Original: FunctionComponent): FunctionComponent { + const Wrapped = function ReadingFontText(props: Props) { + const current = useSyncExternalStore(subscribe, getUiFontFamily, getUiFontFamily); + return Original(withFontFamily(props, current)); + } as FunctionComponent; + Object.assign(Wrapped, Original); + Wrapped.displayName = Original.displayName ?? Original.name; + (Wrapped as unknown as Record)[WRAPPED] = true; + return Wrapped; +} + +/** + * Wraps the default export of each module (react-native's Text and + * TextInput) in place. Only plain function components are wrapped; anything + * else (a future memo or forwardRef object) is left alone. Returns how many + * were wrapped; a second call wraps nothing. + */ +export function wrapModuleDefaults(modules: Array<{ default?: unknown }>): number { + let wrapped = 0; + for (const mod of modules) { + const component = mod?.default; + if (typeof component !== 'function') continue; + if ((component as unknown as Record)[WRAPPED]) continue; + try { + mod.default = wrapWithReadingFont(component as FunctionComponent); + wrapped++; + } catch { + // A read-only export: leave the component as it is. + } + } + return wrapped; +} diff --git a/src/theme/reading-fonts-data.ts b/src/theme/reading-fonts-data.ts new file mode 100644 index 00000000..83e81be0 --- /dev/null +++ b/src/theme/reading-fonts-data.ts @@ -0,0 +1,55 @@ +// Generated by scripts/build-reading-fonts.py from the webmail's +// app/fonts (SIL Open Font License 1.1, see +// android/app/src/main/assets/fonts/OFL.txt). Do not edit by hand. The +// woff2 files a plain-text mail body loads as data: URIs, with the +// unicode ranges of the webmail's app/accessibility.css. + +export interface ReadingFontFace { + /** CSS font-family name, as the webmail uses it. */ + family: string; + /** font-weight descriptor (a range for variable fonts). */ + weight: string; + /** One per unicode subset: base64 woff2 and its unicode-range ("" = all). */ + subsets: Array<{ woff2: string; unicodeRange: string }>; +} + +export const ATKINSON: ReadingFontFace = { + family: 'Atkinson Hyperlegible Next', + weight: '200 800', + subsets: [ + { + unicodeRange: 'U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD', + woff2: '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', + }, + { + unicodeRange: 'U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF', + woff2: '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', + }, + ], +}; + +export const LEXEND: ReadingFontFace = { + family: 'Lexend', + weight: '100 900', + subsets: [ + { + unicodeRange: 'U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD', + woff2: 'd09GMgABAAAAAJswABQAAAABNRwAAJq+AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGoZiG/F+HIoeP0hWQVKJHwZgP1NUQVSBHicuAIUiL34RCAqBiTTsNguERgAwgqY8ATYCJAOJCAQgBYgIB4wCDAdb9SJxQRG5Zh+g2xCAePs0p+l/SIkM78VEbxaBYq1/7mQcM4GNA4MG/9uR/f9/WtIhQwO6BGjbqercd9AjCNEoKBMZyUAkMpEgCqHIFuqCciCSNZqk3kWQiIow5JQsSdB7U7TcJILkTpHIrUYhDhAytakcQjKaUIQOTUhqC6JcdpwdQggNfQ8VU4pF05DIRhMlTXfUdJtTBMkGmoaJa2wInbZwTzMvU36SC/uN8O4Pvc84djQz1+cK7fk6f6//wwDtff4gZy6+1k+rZ//miWH6OxPpjAit3b2o5eSgSzqPlfcPrrMKjF0eI9oVJ16ef/7/lP8x105Spr2w8MVHsBfiGZ6fW+/Xtv/XwaLZxjaiRvREQBxVivQhRlHah5XX6FUp50VjVSFRBkzY8PzcetBDptIDlsHyr+r/v/9XwdjY2FjCBi2loljYl3qtF2XUlZVXXnTqZcj/f3/Ab+1zP0UWSPxFEgw8bDwg+jOl7win9j+7rNWKbI4TJ0V4RNwPxCc7fYj824Me5+4KGG5ilC1c6OHH3EMSHgqhkclLiMe4m7WMpZlJwuUP/06tngPUlKYpwQBlqEsMf/t5hBl1ZgH5roAhMsUsS7YFBJbNsdk244dyao3AGKQSZHvI8HhXto/4tUh05bixYxbNSAM8pNP+G4NsC3gENAK2jDJgYJNNdvOBqKj/Hec5R01zRUM9AD+iRQzhT+9U3+kktiw75Dhgh6DoUYfJEL/4E+hr/HknuU45TTuiAJs4ADwCkm+v02FfPaUw/7HnqYCoAr0CKb2YVDCgDEdz2tnO+Gkz56pDVKbQBYA++T+76v+9rOqgnhUVHnvqALzcSbJWjySTNSXtqRGCRO0a49XHs4u5MstJClLcHsykQPA6ILCkTLKIvyOwv5l3gfl1gA3wD4gxsFv8fBx7nnujp/MaOGi4lvWENgN8wqxutob//1/r0/at3bXu1Oc3LCdAxv0gyShX1KlUna68Aeqp6RB1JgQOEJaPijAoCVSMiRExKlLm/zfdZ/uu5s8yAnwsEfyFo3AUm2IrHGVXmzpXdlG5fHpvBmnmMcr4Ky5Cn/WRxIYR2iDYxID+8RzhFDaFMOI7CPj/fMSGmIrGIeTK22/nUBSFq5SLpndR+/TeXCp93Z/TScEnG8JsZfnciYNoVb3OPutHsmEJooHFZSWMHQd4hHNPnvBBcBhxyITzsgWMt//Vq+p1F8QLQYvJgHA08+i0TX902rrkrp56zNmX8ydA2iDoAn5KySfosvoUkw/STpZQmPmC3BiRmVIqUyudUh8geWZZPFlS8QykNMlJv9zaqZVjP5fTIbdbDudKsDygAAPrQSzpohkMBjZ4YvmzeUO+rbHYqUWLGBEIh+vuztfPJ7tr5EbILROEEaowwqhGNcbkbrd/hSqYbvc+6ZafIR0bRuRvTH0fJulYdkw7FjHWcHxKqBKChCgC8f6xn/ohle5lF0UkiAgnEDjn25/P/99PzcXMTTxkISHmVZG+dK3PsdD+cwLxIWA2wB+A9AADZq5cYYxEYJAWiwGBQhKPBEW+JOI24q7CQZqX63eD8wKFm3E6QMiLNBkW4wx8PRwkBWSCPDIFmjU4YUNeTfbGWwhvOLeGAXEgEUQBAYEBKwEmwTBiC+hEAMYxgJuAgl57QW2DIm9ksDosjEasToBdYB3nMmAQhbFl/wBAIYZ8XCzWPZYw+upjYNm7BIoBVL86Wxb7JVemx9lX4tyNlmoBGzg2AEr+c/ax9rd/32k5sdZ8dl71zBHJK/ey33g6+vZpyTvH/3tvP/X2Gcn7nmYPs7tn2b3987lzbOUtd6sTHPKm+4WjPP4Az00J8ISAPyBlH5SQF0uVtzyWpX/hfqV3zehcc2aXK71l8sNdo7NsPP2QHK6Sjz1iLz2uPvqYfsVj9tIT9vQT+4GnxPzTEf8Z/v4Q/2RIzD/jjj4zjj7PP/i8OnOdf/i58uBz5ZUvqo+9wB56uR+nG0Evme633grbo/3udD984evw1bsbp3e7J3f7Z3f7z+wOzuwOP43Qrr3uyb10aT85OIKzB9H8QXL6AK0cZAuHz72XPP/U4fChw/Cxw/CFh3DmkMwf0pWjI3NHcPoILh9lrzsiy0fLhckyNc0mp1X/xLz+dHM2yccTh2X9wxlaOxdL53Lhgh26dNxi3L8yxqDc0j2FZApV5CJC2NpdkjOVbKZi76niGq6iitKWvTbtLhAqqqrJRIljgoupu5kjD1/JU7rybA6hZ4+tf/JCdAgEAAADAPBk8XjxrJBWC8csliAohM8E3XHzp05rc2gQ+v1lkFtpfQL40NXV+zm4XJ8CAeKW2kQsfoeMM/KAt9jKEwaMEw6dGgUMKEDX/ZpJkOOPnBgF2j/dLJD9GrrkAA/AKEktV0OW3p/ubqW1rBA0JCwQAgQqws0LoHyMRlZr+hMJLlpj9BGEdM96rRucPooeOq3TTu22WKXRKg0qZEsUAeFtnmnm8CkkKPIcYRlU828Amv4TzOZyYDQNHEZ/xdSq4SOQEZiff9nUXtG2I8MNDgPNYx2u4BeQAHOD9WH8XAQSAOGgJcYCgHbraWHkpnxD83VZdQKO2B80fUqPQAbyhcVTVkQ7Zyl6m2AqOfXlOqdicZMGUUJZHZ1S4onCURICHqm24Y+cFY1QbgoCq1oxExMd/kGArPwCwNSkWYcfwFvwFPwNfqb+YIMvqG9R+LfgZ8b7AlwH58Ep7kfBXu67vJ9bjTyfYxBw0NNbKZMQVPlLOicAy1GGJl8YkQizSnPQMNVl8MQ4Gsw3WmWzx+XAA8tAjYeAFBkAcwAfeuDHCNYzFpe7Kdh4C8/Gq6PWESVg6279x/2bKhQSYUDaJgqJkkyqD4TNdvZ/4+Lkt3uVSIUH51WByr2sv62/piVDzZDhasqMC/Qq7JmsmCgFUenGbFx6OkPPpMx9Ha6qP7mt97w8n6giiok0wsUr9USN0H2srLI5TfMI7M5/W/pB+lhaJTXiDXgpno0nCh8B5uYkuJJJuVe+OAVPbU8tit+J7eIW6V0mNlJq+FLISEVTHghzaSkzFCWB3CstU5ogX51MTS4K3wkfCm3CfHI9uVh5D8TP7yTvJzfILi+Ko+LVCXIiK/VX+d0AACB9kF/DzxWog2xIVSPSembSDElxwHqFi9Q7M749vsh9x33ItQm0Qj2UN+fB3FgYth9rYC4t/JF/dYwcywpsw034C/xq/m+xrWg9Wo56UDcahh5F261yhV5KEm8dLsIZ9Nshn8a75+sh2xdtU2tr89twS7RQQ5qiqRunwfDbel7X63jtrQ7gG9gGaxo313ilK1J4GctSsqKJNe9y3Xlo2a0ZdIXDYNFdev9ACRuMXU80pReh3J0Lsz0Jpo3rAGRAD+WMaI0IrheLLkdspejiJpRNlojE/fAzM4wNaenFDPm1C9CQtZNoy/RGCfJusPPj5FqoAiPa7cRwxH7d0wnpammFIsDTkrSsfZW4jhhhMU39uVOWAQjkrWgYLA1EGCNFiTS3clF34TLbuRcZjwIbs5rjFeD0QClxKIPkGZBOaVsGn0iCuppEApAEHYHvRNttMCMNKsGI7RftQHIL2aDcoW1THH6GM209yeQVi8rrZiRKFV0apVEimK+4UpYSojVyJiLzrBXwRUCFPm0b7zsc0IlZTToc5jLeKIHOofbHeGJdsgIj2n5svlZr6bZEoTrd7OYkaD1JU3tayVk9AX4kHhm9L4HasgKRC7XBKIOdSqg085awGOUvk0+as884KD0qRmkkdcN4hZb1puAfjSKUYbA/XrHOqQ2QHg+yKOagNVtJWfSk34EQ1OD3cFPpRdAGlOi2i2CxxeQQVyIft4LGHNGvVFUv7hjlciEEUmKq1h2ppZ13hoyN7BbKeqTXVkEiNuahngfHB30Qild5FfSupmTWNlDTzk5ntluEWqPNHS9pwGczz5R1HDObHGJPI8rTUHsxrCQ6W+GIV070Str52oxokrZW8HrBKqT7Ul+qJugWVpvVMqZ0K23INlubg9WMWxvwlcxu1zcdUyz6usn7eqbG3ajvptwsdUx4R3ySIzA2sLwBvscleev5KVm03xP1Wb5LSPv11bWlD5eMZFmX6Nf0reuDHRcW9oXk+2JqfasaolvdSqmiwBhKgDYlnQUZv9vk3NkwcyywjsTHFBEq43x5n0/1vLGjdSsLme6NzI1tDGbFHCnPITs+YSVJq/X+tgF4XtoSpVj8Eml3Z7RQVVql8aymphJJeCwt7aWmGAryBAyAlAfnkgPZwGwFW8rmGg0yb/WvbP0M3m8AWgrbuBNBb78VFi8sawP22uZnzLeZ6PEHZGcd1jCA+uG0nh0JrpC5B9UH1/YFKK7KiNrik3TDWxEgotMQ1BTCP9T0n7wvfRC1Z9oQMwaIv9O/rs5gNzD+2R6kpSzT/+kcioiZ3yVj5mYWcH42K1rMctCU5h0ws4tnDofMsy1NxlvvAkB9N7PiXrra9z6TUDDC4i3enk1+MMNEn83bU8wOHPOnYORymeXDfOJhMFdzHS6TxDyN4Nn/QDhGcJNI2GkN1qk9pLIx0La3S8u3y1XWCxeMnCPKBKaL3CKam/nIT7yIGXqDWE1ArllOu6SpIfamaX3Ln+2lpQoI5YpmY99ZJtsk0+V/+X8mO32azmb0F7HmXZMsDhdSB8DbAZMwaOSBrCQX3MNNtIcdZHz3143zr2FmFtfN6bxT+Vi5rHkrzcuj14Lp0YBjGzLrYeBorzZZmapYNk4udAOT+GkGm5LNOkydQs7ZCo3m8FyUl7dw2E+0sxhbH7dXQwmqiw/8XASZbBK+s7iTOGiOZxc2eTnagiJm1uruUWQGfFv4EYEjp+5uhFXtj2klryW0LTGPTOjxlV21HnpVemaulucdOY8NXsaVeK77X+SyJ5tuv3ke57um8VpIaWw/H5O9al3HIJiOyTPMrt5uR2eGQJZ5M2Wj/hrSWm998VQGj4QmrIpbkrq+lOyMQ3uOmIXeKS6FknI802yPWLsmRlmZpk4rt1ifjugP/iGQ0nDOM8NWoR0Imme2dKut/kwdu/xtNif+KFSM8nIZPPZaPyqZtaSPBTPcc78fMm+3IOkZ7KGwni8JBs1GY1+0Q1ZdQclxBCqzVQ+IIIeaPliIiT2d1WKuWRv2oS65nbUjz1lRhegIPRFw7ALceICNMRHq3Dn5/ECPdvLaZj65umXJf5yjXtS8p5OMlq1KLAsKJvI4s9b5nCcpP0ZxWWkYY8U3x+OD0+KTkZ7mkxRLxfYfYhsnlZzzzclHCF7Dk2l0xUMoLeYYR317mMIdg8u6c3P9V6tsubI5eJjO91XRPG71ZZ/LHz78rEkWfub30slm3UqrQcxTM51x3KxgQHj0rgqQ1H0b7F+5QgCG+AgyClxq8QQSLRZqp13mOOyoeU46qdFpZzRBLbsE6Fm6nhWtBIFQoPALEeIFo6JB0PHA+AIhAJMtm5wqppoJwsx/LEBYwWxwAclkF4QkmFQIjtCUCROOKiK5XOJBEpciSTqTAZpJWDIbRb4CPIWK6MVKkZWpAqmGQg2KWpA6ZO8h1KOZngwNZsPMoTSXwLxUma8RXVNZif9GrxnNToKfXZKbh3AmdoogcTqInVlIwKJtAwH9IR06BggTF4qH9FGCYESuQUnRsvVuI4gJoRaiAoIDFSEYBqQYYcxEIhEBBt+dTCyFIOd+OGSCdCRT0SA5gZssz1qj5Rr8FIlpsOF3V4JVMSOpBhgTXOjA8CDjjwxLymqbCTQtQaM10CwMTIsCxWIxvYsahWlzpLX83zODPJQIWHL96hY4aYU6k575RBdtML40m5j9Vnwa/A7abJqMGo2dPbCuNFIrqMVUt1yTdv3A68/QE6sz/EdSM8tJnn9aqNMfIT4qb5LzCSWhrc1pHErGD0zD03vTq9Jv0jdSu1SR/P2X49qi8rdTt8Ud4odiPhlg58cTY9ujf8L1iA1+OazWX6pkNyfzV77Kp2AK0JFwoKL4SYSHZjRCJ3q/G6M16sLMSuSS75MJFk4uUnw+JEpcuGXyb+vDgxSrE9ysXBdzNElqwZPTLLNSutWXkGWtss3/Kzl+87c8//pPiQMOKmvHbKpT7skVLrui2iP3w7Ve6lYHsryzA1qwhK4YlcO1XXGvZQNOl4OuWu+eFPD+H61J1Fo5wWpBujU4fEST3zQFzLCUZXp8rJ5UKtg3GqZ9eiCAxFQaKKOcCiqpolrkQ0zL6uHPMlBGORVUUkV1jrXLqFqmgBkLVmAQMHDsOHDiwo0Hr/xGKHWrdCBDlhx5+uhnYKgBMUWucZD62q2m3f6T5lgibe164MvJWvFhvh8T32jipAGiTmrRVviSYajRoJUO0GPAiMksz11B1QAiIgAAAABiPQAAwKuzZeGPYkNgMAAAgP+7msOkDvkGX3CBgQnVhDYTQ1ygVL20QnUTRnvcgmGfCZtkWcmngkqqqKaGWuqo73f5lf2XYqwwXYYX+AswDAAAYMQHgMOqbpANAAAAKlXg/uGhVxmicqRZdyzbmPYD4n4xKxgWDh7BxLIDYTMAAAAAAASv8S4AAAAAA8BLDToAAIAyDiXqsWkkdFZJz2D03ulj+zqEKWPpGysP/rpzwiMG9yBnVXCKYMn8KuOF673+qAkfenkhAKBq16RcHwarojAOsZ4yCHUu6BHWdT6eTjt/ZiExCm1CcEx0ZJWfqYCIMqBvTTyOZCqasHR4LREcfFtn2KI9hdEeLMAsQ0Y7Ng2cq6a5EpX2mQ5QlZs29EsKJlldoyEmVbwdN6bMoSkr89GJAo4ekZs+Vmw/JC8nJKi9a6qWfqaieUpLsh5qyohJtYQygwUjUIMat2xHuvLa7JnnrAA0mdo3Ogq1dHFKo4iQPsSps1hDJ7mna+1R8R43TeNrv9O6POmncaZZNR4U0Xo+EjNXS2XKRrKiIcsE62v7Wy2qt21vudn2NULQ2Mp4jp2IrbvMsc9+Gec8R8WbcU7ZCatHNLtKh7oJEfiRqJbuJUsOSM1EgUt4u/+XsiJVjU3xINIGjzlW5hq+3kLu1U0NvfCPEHkWG7u3m1W1acmqWsOcwWCh1C0LkE8FlVRRTQ211FHPri/DHGUGvgpn6tPtPAmbUtOSGq2sYoglxeSVhHohqIxarlorUP3j46z7+HVd8Dc27ZDwTeMYHexG4TB9N6IhXOeG4zie7vfg8z6PDXs9fm/4fDiPnuyQW0r6J1Ij/6fIT6Ki7c6ZOGf8nCnnTD5nUortYKANGnTy0cHD6YfnRsbB/etX35wfHRsB1/9/+j8BNg4PFDJgzfBYbhjMnphilCJZEg+PNEyPTICAgWIDNKjQIcBhQNEkJmqiccVPjaP+Pox7ScjIwd63gniPa9vFllsdW8jxfJUN9aeEHUEooN9DZ6+JNo2wIPsYdMFCtmYwegoiHDSLwYosmuyTtfRmWAhJFWkF52QQyIsK+JnoF1k8pkdAtGYgNu/Ic7tyyDofADjIeA43l/1Dn0OMXwumSJ25d//3MDxE1oEHdlhm7VTs0Frk5DUCJCTxAhhjkD/BuA2ikL7bgVm6i0B7A9NQXkYBLp5ANUeW/wEiQXZamEiWMjsGGp4M3jOCAJwkbJHJ1FIGfwiicRkeiFh6NAgeBkqo9jcB9qHAgbeo1XiHzwdtxsphNCSvPrA3doeEIIZ4+ZTdflg3RhgQE2KFHU4EEUYUcSSRRhZ5FK3kZaDl96f6kGu1o8UJoOcY/JZnDhixEhe+HotHQZkCDDP5Ygf2YdDbqTkYsDEEkJEKnP96HmYMd3HVDYl050BmQf6VVtLPXM0EyyDgDwVFmRrEDzYIiTJtXj4qxyarPC2gDnjC3jZXXwbeR9CJsz7nFTUHUy09m8+alzlaR5xPiwnj0rIuv22FlIDTYf9eXad7M0T0+4cCuZt3DD+or3dYyNDrBo0Oveuqe73oJc9UHvOyI06KZDFv9aShDUlpMYerOgz8l/HBJg1HnXLorn3uURjTGFeX1qd7HQm+joZ3tVq13GmxVrYJllrzzXP6LO5fWBI/1EPvCJoJtguQmLxGsHzijtxhBWO4bsbY+rstm/zagrsX8lszAszC8S2/dmzd6QUL/03zDgJH2rWbnFB3H6qfFMa3y8PItZzPih2dLQ3dldFx9fFhj1e86q2u0Lb+O1Sm0aSFXBzaDa0Ks3RhBIC8aPBf9Eerz8F1sBtsoK4ivF6EV1ZMgwno5w66XXV8uvukn76EGuvil3vTNz+j7XsPW/PTv/n0V5R/n6x6/wXGtjehjz9kHnx7a4+6wcIBT04nAT4WxvfuL07faSZevc3YOq4yI5G/zd7JSvMfY1fprpgYS/pay4Pnr9zpbfvnx88c+PGA5cAvK37xu3PFpv1XNy+L/+n23VPn7kT6VXvfvjV5tfT0X3+/6W7uTeinzyfefvHv11fW99++0Vz76d21Gzc1rl3cyvzDDeRB6kf3d7JvvX39qt7/397LjjL5EbbwoHD14VFqgrvkPiF9VFr3XIFfquAffio8rVGfecae1sQHdfoZg32BWbtsyj4k2rxdeXu39IDtvMC5VnedRnzhC+nyC+2TsXP5pXTppXLuZav08nKxt/n4a3f/3u2No4dO7fe8afEHKD50Ql53ev49CV07G5s5d1oX8n0XauZSz7KU1xXSNxbQzjJPCn4fO/Bwwno8rn9IYHXcKV2ff63xXkWkhzn1F3Xmav20iZdOpd3QPB0QttR6CPBym/D72/qIQSbK8xcgP7vrT9jjv36PBqIKJjlTfCJAwCMU9mwiqUxpdThDIlzJdmcg3JsvDk8ACCBsxbp7lZbrYUBdV/mA7e/PPQdxFinb7iXA0YDtEJX437zvF7AffbE5kecdB3pfSNsiALodoIZwJ2ARCGiouv+BOeCABcBnH12cKgGA2SiYhUjmUarOfBBAClQA5coGjtt7kAWas4JBm6gGkT08gIa3K0fgfOMof+UYonzROLIiJ3A4Qld+zs7nPv3sNYub/O0QF99HesztZ++FAoNzYMpQujNzQOx5tqK1AbARJZQCXYBwi/hSkCNZdaaO1s263SAERXBEswiunFDOoZQoFUq1Uq8MVEYoE+k7GWo1R833GQwp2UX4QrbbU6dfA5CGUF4zu1KklPUPV+/b01116e4HJn20+bisCMjflFv78NH7D8z8bubqvTjzd+YbM3+f+enM5+6HfHTif9X//QEE2ACwj/sAuS/tAJuVd+Vj/23zrK7/OfUJv7roHw8MuuKSgw7521O77LHTvzr8oluXl353GYRARcfEwycgJCOn4EdJzczCyiaAXbAQocJEOOo/x/Q7EBm4JEqSYoIMk2SaLF+hIsVKlKlWq857pmswx1zzzNfksDuO6PWj39zzyH2P3XUtErhuibP67HUjGrilx5e+CgUMuOrP0MEXljrnW9/4zh9IYCgKDBmOhouFjUNKREyCQUVPQ8tI5zmDIA5OgcL5qxcrSrR4MeIkSJYu1URp8mTJlsOt1DRTTFWp3AsVZpthplkWqNHoT25ZR+XSyLwvw878RkxQWEQIYhYl5jBmPMlyjiBNaKyXi5Txue8EVQ2/yEwS/tEvPaRIsCdTFLu+QaYpoXiQmIX4Dt/pOyulRlskPRtZtZHMTld38XT0Xcygtvg5LmvM+gcw939BfxfaJ0BT3bU4eAhdOvYQwtILiFp0hLyjN8HG8wn7lOov2rvOp69GGOROJ7RGWn24PWtdiEc+oheXZA4d7ZOhHc3eXevUBRFqml65ZADqTTmiW/3NABkoB8zxwZBu+mZInzMD7SYYbrCMFrdKn4F1WvvE8yl2TmvRDBLTWSqdzz9JrkCt5uzCB/jA8MIJNumiEDdatVqhpO69C+420cM9uZFP46+8tPVXN/9omM8PlVd1rLUPgXiJ5NJXBexHm9rStjY+N8B1WBnIpRFUHMKYrmU5Ul6o9tiUd4MZYp72JR2KDATSEEb643XaAmnOssXC2kaDjXT9Z3O7te2qNqyVCnHWA53ASGZU4CrmuOpCqAw9EHkRZr4t4b5XQciln++oq3S7TOsr9a8o9Y44bVA3gNHmJ4u/rjtLw3zot0CKplaxmPjfR+ay87zBiubTNInV/ldeLdq0/vCakpKp48zuzuTm7tpArpRsmKCZ66IchGEB7j01SmaJUDdXYLTCBGEF0FQEB5vR2zBOMq2u6PRCFSbNgA0C8pJNtPN5QndFKfZxIkXuW3bKFDCO6TzBRTU6U/K8fXGTWxPGAMeXUlrBDFr75dc6JTQIbQS3j944lK/1qQtkCwSUoDZCS4abLG4v0wvz4kS8B6QvSXcLTMbpq/qiG9NRepLNpO28M04pJk7DVpSkWjWHwWZyk63DK1NkyF/21KJT6GBnA2z7pK75xYulYMwbenbwX3zLE2KGKyLBhX3m/yFbSOUoJTUs6WixcBC0iQY0GF/miHPDZOjIw8DZMTumo0O69Yr3cJV2xlTEvHAgRLvU55+PAyMjmMNDf5/uIUUeGqHEOszBm0KDf0mpIGyou5W07hgmZIPvWOE1O2SvTLlGh547O6Xrt9aa6ppOUN+TsI8PcRuHxFZxXaAFufaXJ417sGqX16ox6owuGOeylueES9Z8+jfe5h5RSzC9JAdnJpZGDylokYu5Sjf22xhsOuhEbY5gPBQLxlcKvRNjmVsMx70wSzRQmQ5tnA64jRSa5VPNx7hesl5N2UQ5Syl5CvEk6I+kO0ShK6KCptcTt5dtAszIFkfsRKRnpidTTdy9129WRHTxcdtZOtjQAevbLlC4cK+lnjCp/WB3dMfzS/pXrELnZT4R/VDZP1fnTORqll8WF0Rp1oJ82upXd/nsZh3Sa2zxZD8dG9OT1OfRUWgfbMCiguWhySTj1mM/f6TsE+3lNCO7/kTfaAOwmMRXeKBJrFKwq7x4o037GgujPedMCMb7EpZursHbscOQ/cXWsQpMlCb+YiQJ7bUhsx76rKuyKHco4mus1Ux8pUWlwlW1aQAonSfb684ItSfPCi/TXPJ18ofqxBugj1f3EkQvb8700XdEXZukmvaVkSnu77XQSqebLttUVEd3Zi7Z8+pp9HUSVDVItKHMMua1NrMyuuVCQZNYlWC5JzulMjQssJdsYfzbrw/9fdthIa2omnyrF3T9ttDneB320dw+bfAvrZeWpqDXya4vL5JpMsaXOz8EF6C+XG0EfB+M5Q9rQ6ErXeYPfwAaLYKMKyg2Bg4FJomePNpkc0l2fU17gqL4QMsFsdpQXpGlFeUtnas1+3AZYeWpfzokzyjicdETjJs8IowUHXVTQSIEaydkx1aFR1Q8Qvq9k3CQHj5/8dTj8vld7CbQj3a9iBqs5LwhBMSy571YKfXgDN1GrtgezTFk3qtwVohGvJxTOp0dvq2ruCJ+rQydQ7XnS3iF4x9twy6/JQe3oxQ+oNSylPq5rmQbSpEzuYwT9ibn9Ld48rZbvfiIcUSevpG3fYQhoCLxjRKabqVtrxzOpUIkdiTQZqWmStwsBaCmaBvjieNLezsSw4tPdfmulQfkpMaGpSelTSVJxw2SWeRE42boaUocRAghlx6iRc1fNKLB8CPyfqkr1eOfWKp6Wo/AjfHOZhpfEE45nyx5T6yEIjgoB/rBO2jUlk+27Eh1NJXFUcQXTw40sl705sl3YfC9+eb2XtaIQOyLA+SLZbUQnOBbMigraTNs6BBYgqFyqiZrenOlRqjhlb2rwW2+7QiEUxX+7HvJsGLa+NqqbFD6tTN9s2NOdK57rmV+gHCkUC9BoD1l86TMjdEebp3mNdJG71ZCnTcUOrcdBRFw+odqTHaKGRoFvnmyIY85OUY/UCkgOi3HmaYJxsz4K098tEzZZQYjuFZNlbKy07McUvNDa7zg+KenUA4Mdihar58Y4eyTyYPcotjrw+GhR/bUYjI74B9KSmLlH/luYpRu+/g93amfh9Wyd6YwrOx7saFR1lTu9iul1ebRp0petCXzXMi9mUJ5D/yatPlKP/UMwUIzEKBaK/9I3w3+QN8rOHNHPnthg0ESZZ9nrhTPX2SyqPjLkNG+/nu7GjWdMIRAD3qUKg3fTZTA+YUWiv+AD8/QIIsfgGYzstz+/8YJL/uQ+thU23g0SAbvNhcL8XOdwUVpQYaBWtncdGxO3ejqlPj+Nr9sLCAcuUs0BPXpK09qjCcR6E1GmYB+7Bcx+0RbcodNXVOZG3macaYp9vOxxfIl2zMUEnvxyt2sOXKQnu5SO6eZN+ci4xwciXE+XX2ExRi5+Tyoe02WiuC51XtUPlXp5dVJUKWTni5bKbfyK/UEGuXPqiw3iR+pp5ODH6bJjnSd06WYrcE30+G1DyDwzueQrOp29RBAHKE1NXJOzcmjZLh0tKkNEZdkzE2ymyyfVc9btmQOsg65IMw8356CAXu2+tPTKTb4Q6kCS5PZHk5xBz9WZ5kuioufWnPD276YvMsIcZvHTQaK2LPHuCuOXyJGXMHB5lFQrtgRqPZ4NlIgs5E5BSElJn4uzeE2uc/en+EZX92HsCpZCWSW1wqjepWFh6IsriarlljK4NCgn6NPddgJzPrb4+VlPEzY1pIQtKcNQ41eWOvNpRia+TjxvoFBc2emcuB+hJHZ3S0bBtA+1elXPSsr2yOlh3LAeCffjE375clxYkAsQ+Q7mGuVvGfIMk83eVdltySJSfLmBhKyZNLw2JejAzL+efmN881JwHiW0O7xAsLh/Ml75akMSfyFZNgM6aAZHoJhHoBBFowoQ64niJ/cL59iYgTjHAb7LLfve6K36FzG/x/Bn7Ahh4W2rqmD1aaSz8iGpwnMQc28Its+6gQPFmWhbBEg6uzVOKS8MDekhK6P5+I9z/gVY42kdH/pTo8j/kSZHf4qqfyGaV9Ryi8JVYIK6n2YO/Ql2DcCFL82O9FlqztK5CjCnTu+UMp5/WH9Jd48vI/84dUS0RwmwZmcyT4QRXfr7GcwssUXSIyHnJ+GtWfK51tCONw+u4GAc49P863txhaMsp4USv1fPX9MwSxTZ+bXXuU9W5SdfntdRneVbpgXgV3O204Wh5Kbzt9MEt/GfcRZEZ3PkvEXnN8QiMCXmd3PulmsmW/2SGexhyl3lDXU3Rmpl5VHKo6qG+GKHc//jwRoZZxuqD09565d3IomuJmXDpQJ6gN33kM4ZCiYxQVQ8fT/25KOF9pL299yJA/dVmnueUq3cikHZDvZaA9P4tPpzP5Vjd9gCq5brqB6Hu9q0zxaOCPYdFnlt+CY6XjxEepX+9rF57W7wULcuRyKpWXzfrdyTTKzQuWA0lSfep3d9fzux/0cYbYZZsXVOmbCAncz1YyfZvWrooM+UZoEsp317mXyrqR4tc8nXhNOLJe7dyWE96tCjGspPTodJX5XkKHa0w1k9nht/F2ZZf1s58mi93tvcZOiGCwmFcNnDILiQLH4c9ffXAQ7CJ55dS6jXudxq9dm0/MqjypPCaq2Y473v4AbGOo4x4Zy4molL4FjCd58c7Dm2Js03qU3h9RtjaWEJOl4ODjeAUSdw2dUy9qN/OKzReCoWPLrkryvdTeCK5b3Cnzndwm4l/XL61l24B1O05p8d354XkYPPBdigNOvYY2jo9cGTh8dn1/Q57ch+92LhB351A7+f6ey5I6Kx2Zo8errCPz1zzPIB8m9NUj11VNp7+7CzAHjn2HxcqTUVRLs+HL4TO5+3iFPZdjVWEXQgI0E10pVIq1Y5/Mp1gUcFdcmyli9XpQxcxahMMdkYyY0GsMOOxlyFWaUkdBqGEnFfJUFs8rPPS+jEvw8ycOxdOIyeTghXuPzyVbHk6vlfnHRe7K52Pyctyi/p1dH7rk2yFBu+H6WrpvxEa0QZDspuoPxjNFoCyb0uodrpx5sP3cvjXbP2fYHmXn36oeTbNmEzvOa377KVkyvjnfrK6IQx+Hf87OdQmNeb8hbdIZMTm86V6V82DBKerLr2NjTlNvbaazyQ7qDIBzXpSk+4/fOsAyLqczct3TS+vNb+mRNcT+rq9UmErLtVmWUDKlj7Zi64HbJyMeYvFtqKE0/E1OFoS72w5e0CabMEiX4KvxE8e/is2GwBAuuxh0r/Q8N74GkAZ9UqghIpQFoT+Ehv2PlahzIhKdX7N57jvH24eD1hV+8X+7Yu6r1NHhz9//JjUdTO1b0iS58TtgRMWfILDfccnnvwM0uH6S4Zvn6R6Y+PO0+cXT+4YcB7R/h/LVbXguWbJirWYn4XhQPJsLux4WLAbUk3XbdureClz3mbF24g4H2AeOka5s+Xl/8x3d1848/1IA6HB60W1b4/NbZUQwToC3CKkthc5FYnJuJI5tsLTW9UruYH1BCfH9wSCW42AEp+YHfZeAtQqCfJ8Flwo9ORRv1P3xMUnbewVTYeCyfXiUPhMUqHtKakbtmUJa7gRNcjqDL/CZOH+KK85UoGIozTTgXdFG/rRxvag4EW9lWkuhdUXwWhfyUJTW5etoXK5s7cNYTCHIB6XA3C6TOBtsx9hzowZlIU94TuWNN4ZOC/0+8DXmdnjKCWWb9fvOKEbwrKbFLBI5CwC81HLFixXsTwMWdE3ZkhdcLDjfFiU9oX9Ym/d403SZzSURBCBIH3FJJO+OXCZm79t8ZHWDijnEcnvX7rbNjuJ3nIO0obXslVfi8MNdI+j/F1tLULbVL+SGVSrEapeohBVQSNmaHl7vVnBTsDAskCp9IGdhNpTS6Etf6OBaB91BO6wtqBsirnF3mtWMOe0qIinleuZTnwS/E30FIJk+x3qfdx2qt17Nz2+h18HjrGuDCgytt+FKfmdeHu7J8PRTlWlFmonLBLkFwiHeH2snnbEwjDnSKNE8ZyLHUxvI0grUOMQ/DeBL60jKm77nLC/nPv9vgVhLb0ventCmgeKJtYLZz/ObIGYrGyeJgyr7dvmKQJXJP4eis34/MurvCSV31d2pSGl1RuGTRpjEkx9Tr5W6xwK9UCgMusVzmkkgEgsS9DByPC2j79h1+ttDol/BSTmtBJ55tg6n1sKfNDBHbQIxeICrXMOQ0CkrvhwG++74Ayk/0GTzhjbzaAgfq8AZE5a8lm41VSSBuEuy6r3zs7z//dpf2uPrzf2aeOhAgAK74fB7g9OK4aLmUvYsmRimnb/8lvbtIW9Ju8Ei5GaehqBIX32PLSuXGdn1RI1j2AUP2s93YZgQOemE4z5UQ7l2GY7N+v+HwIV5PVOlOSp0SQaC0TItOsVTqAirF7ispGFTD0ica4mX/jhw3XUb3LRShYfoC/VZU10mTqWIcGGUlKhd8hQRzz4t0BSuVx950TaNVAPFDQanpvNtmbOxvMY46QbXrCj8WMF2EJu/OZb/1TXHZn8mZAFN0N3Iu9/vMs2aYpIt9cvSO1E65RMoEfgji++5OSofChvH2dF0o+q8Wqm4e4mBlDa174OJ7sUbS/3lwC8s+hltn/X7L7CiO8/DWLaVtr2wpfFtqf8DJ+JXKu7Ag4dO783++gINe3HXLLq+Nxan7Yr5t7MhFhrTcFqAwwe84MiDuwAyv4lRx/deZE4vapDffTbrTydF8+n676iI/sYnHcTS84dRbmc9/1MBvGTu+qPa7j/Y83EK2UlmKn/zECryLB3YRZHb6Peo9r4lsalTF815AGd/Bz+048yFLt0WhQ7zW3zO/4OqBvB4zdfNldmn7Dd/0NLz332XRRJEJSsU0j9yR3JQEW24o3PDaD3lfHlyxxiGoIwnbCnwJGcnxKD+rLGRjgVgYbT9ylZcJfr1Dm3HXZv7+bYNf14ITj9QWwOpVma0K81XQPWs2Fx+qtW/zZje5wK597z98n7xs9zvYDRn3RaLLse2Jw/8dsK+52Azu+qL2VxDE/MvuW+t8G71p6pv85tnZt2rzvwCK3IUDtYsKVodr8sqmGLh2I28H1QNJWPavBQ4lYv4KTeqTzi+ozxQQ0lwlokimWHVPE8T0y0+DBzeJMT4fF0v4DkwgFuNCgUMs5uN2fgfe9EWluL3qSz7/zSppa+UXQIIHJqKmu8fGTHdPRAOBSYWD1p9x+jfPzZnqxO/B4LoszL3FQU6eyilves9e4yuCpDL4xo/IV2dtpl/9lUq+5IOnQxDBFkqLdIYeGRTRtdwVav7u5TsPmrqL4G/cNYxK/Z3K9QtVFNYjJh7vWIJTh9++heJ765JPmN+m+fy/w3Pw2g4PfSvdJ7ZZB0dMIB204QtR5OHc7+JY5L7OMwBUbjlmdhmQzzCOQACzRrh83+s8buNP5VoPnz+bVyP0D66+7eeDUmtery+gGDy6xArag7rZVpgdU7cvRKh+UfdL8dsGdCMnXrUV0QLjLf2Sc9LVVH3arC+Y3capIRTL8Z5gxos4LOtxjuC3GJ6QhbwJxlVLz2fzDxNtzTOADsODakuPllYpbloYvu3qN16SgvVdWchkAmOuIn13+NB++nsVMRyKruEmD6rgHOcAjcaoP8Th3FHPoNJuZxvpvKfbpc/wlXT+M/xn5mke+Fx37mRpiHKIHiDrUgZdzmC3jI/CmCLKgq2csKz11macEz8dOoRFeK8KdTzq4zztRK2AtWAKHCN02KS8kErN7bRJxGJUwulUq7ghm1TobPq2RKXw0OnDCkUPmIPqgzQmnNFpE5yaegBT8Gx2022yusX1dXWbPdFvjikpDMIZOfnV2UWIVbsDBfcTGormdyr9a+rIHa2NX7fRv/zD0RflrLOdqoSzwYvILxXKvTIW9xwg3ZFu8+5i/LSes+NZK8fd/9jOxbY9L8SDHdWtR83O772NVG9r83+SuuPX8ZrvfS7p/vsXrvz491mlgnhYyYujNLCnyoIlHUZWzCoX0TFa1UlqA+1G9W0/faVXkx+gcIV3+5sukwTnm1s/ahJ9BML4JtO5w7a379nMAQ/VcM7KKORRv/AZkpRCHGIxVxApdd8f19QQZ5IpsrPmFmJzY00L6W9eM7H57sZjdXXHG5t219cdA59UZTLaVCVhN4QHyZGHWPmwGVjxKP1CVqwl20UB7+Lp3GunwSyCoWYzYrTFcwpEf0uyDjfUbO9XnFxEIre3Xp1lUDWW30Ckf7RmIzYfiQ/j5opNxPpa+j/HfOxX05Puvwuvtq4bePv5V75sll+KMfku9T0usxCeccCWHKSPaRkPtCCiucWxse3WJDq6gSh+dBMPvqW75OVwTa9z9a97uRzva+DOpVUTFf0Y2zqmajxnUwUMTnPu6lVLOy7j6gVjaj+6Jw/GFpyOa/m+g51o578H1dKWP9GJdIK65a2PW3Oth63g7CDpM95UUcYDyq5+ev+1pzt3a86W/zvf6HOfwwcY/y53r/7s6qvWfB60I3344BMTE4Y5NHD9uxGYMy8NjB8jJFFf8AtBb4TC+rEoTfzxosho6umKZRvrbIcWKQQlL/NKN7WU/lNHV9IrkC96AJiOZd/mlbnQj3uWamjWB/x7Zkv8+6M/7uzwA3hPfOtKZsHWj2SntzPagkPyt5MZSh2xc1PwK6KIDHQ319vCG/3tFa3bmKZgn/zOF+Htl7pn9td8p0G1YyV//2LdYPhfYcmUv6RWUDITKAHaf+XfW7bfE92qTKcVm0LToVPb1z2WOBZY3dHTKZvAbdxZrDehVrMc79GYmbrXLiviUAZfhIg5QbWUkbL4o3IVjfiFprl1X58CYu7tIVI1HLypB3JbBpdpu/p3aaeGzTtzGHfQ6R7h4lK09t0sNnKok2pfQBUzv+2IRxm62jYl2sr7U9ctFVmBpTD908H9a981JZMgZSAhNom99K0X0+XiAQFte2d78/quuY+37nhpw87tBPuk0ZY3+iOTnVSL5z+TVSNc7WIpxS7meW5sY2Ilv2Ds9OlTVPB7xARTHVbJEkZYk8orbV1nhm+8klWuBvGLz0JvpOpbLgmWcNbNH/tPzL1L4mqVc+C6/JAWLtl8S2xezqwjao4n2jxNDi+fLoVD9GIVN9Ds4O+T+xRxoUCxnlWna+ifZmGNqEcn4tu8Ag0By7LFjaTwgd42J8p7QAKJfbEOsLnSvUadyajXuN2GwTHkdqma3YRspeZGY1qlTRp13NVpjZEJNz/JThX/+Deds62axSHcpWv5eZnW/TrapHQZ+kUej6jfYBT1ebz9QgN+YcAxZDTscQ7nG4PSii0YTH0WKSv4fYgpk9rIJVamNEHvV/xvcwk7nGIx+3CJJFK3SN1lbqG/g53zipYc+aGBsYlO30uzkwprfpfX9dYSrfVqHshmFbHtf2g/7hV3sZMnXvE2svbj8AB1wBM4SHE1uADhJgvO52OiDj6O8cWP/CGRSM1xvghp0URJpKi6pWWTW8NPVADZvyuzCySfuD5zfZp6XeY6oE9/U7XUpd7h/L2DvZlU+sHMEGhukgek0qBCYVj98ohknLzBRV4y1pPBccfhTA+Gqbnx3dYUR3u7095Ksjt11GE/uHRvMv4MdtDlx4AOj6xDJegr9s3bib0aSZcuG1xmFk1v9+UQBFVsDVxM03fx7v95qO/LgIME5woo1iufD3rla3rSs0oHZdY2KgutuZ6ijHKsGLNXZ2SmzViUrW6KWmrkndeGZ098VbqtJLlt+/QrDCgBTyhTG7+afo3CEIWeu+PIeXgxqsnn1Ria7Sg4NT8o17Rw1v7NpTU6br+jwUalVjc/3d+C1EUe14UupLsW+3h4IUWSU/7qSP6/mTz+KBT7XYRyINp1a9fb+fwfscjOEpRrOqWgua5tPhWyuxp0dMV/i0svfDbwGZC/Lvg4BtZ4kz3/JBO9sN7akzwPHFfjP8X/e4pzgcypp7wswsvEkdpX2BVPiI1eQa8ssY78CpCnxl+Nv3Im9moMjCNSV/8LqMO/JcUXg2BH2YBV2n0qALks/mn8E0rxpwnWdZuKm8C0+4v+/+XzK6Ln1Rwx2WUzOw21X3a9e//r1OMUtr7RWSq8VQxKz3hW9DijpwHyjFf78zyCkzuqFXcuAJPa92ek0lVX9sor1AhVmiFmJkYO//i1mn/tt5nD74G1L/5feO00wyG2ybhhjYYbwWRi1UxEo+J1YXKhq+m7Ug2r7DsB/9+QLf3npfbC8cl5YbUV3sdETmPx36bmfxB5aJBc+prT+LU6NLhptmXci8tesQ0KbouYwF9vaE0tJYeS1uC1K8HhZP0V37VgbW9gYjxyNg9sdFDBX0Vk8g9k+UfioJI/otxc8s2mkw38Z5r4pxobngXiqsYHv1NaqokuI0pYrLfLH11i5NULrYYLZ9Hf/aDpEcXBj33maKo1Il2C4xao52qPFgwtdZPdoPq5uUsf8FP45Q8T/AULYtdMJD4nPgsMTBAI347WPEfGyXRWrOp/9z+NKg+9dfhNEq0G5ZeCkTNM3At3/pInWbS1C/1uWfhMyhLDNCxzUqufRmJoRmrBlP+sslws1CyMA+pzBdTDbz/8tVOOFnz/VGP8GVow6euZVHtBOQVfvWalBYu+kJa883tJyBbrHBh5yYSwT89va+/9+0Xatb1h/OR/4rRg5GOsx6l97WNC2kf9k5/VbMu1xsbVy12Q+IQv2UlLx4kwd0d1kt7CX8i7smeMMTSdtuCclwC2++wT/VECj/4VvMb2otpNSQSL8HOBlwIBBuGcrTx4R3hwDzcydB7s/Yx8MxMIjtrqdxHH9OAc4sHdwYOR3srenBN6cEY9uG94MF61sp8H5biRCGzR4tQ75vhix1zrdswA63fMtlwVWHH2DMdaUAcMZ6t2RiOF5aTBMIe7DgdAWcr5fYClybpL01ZfWlyH8nZz5T7iPuTxZmWP0c04ryWpI5jVMmFH3q7nPuI+1PpmKfCcy4i33SKt/iP9h/q/7nzT1Q2WOGLZ0ViWuRi5j/BDEnxo9a7LNXi8XdN9xH2o9c2i3HyPt8uiIQTAw5b2iMh0gSEPBcsRLmM4oy0b/NI4s0uTr76liJoJfJGlyFEjYF04hwRYD8fCBjhA3aiDTXAQbIZDYQscBlvhCHWbjfEDCv7z/IOJjzFoHXJq6X19IIDCcXIC6Lc12X/bpnx28saO2pTxkfrkiprtBCVn2gnkBtt2vQ/gbNnJlj7QSdybJqDsutHNW7vEQuRo5EFFAnuAabRr2VI2ogcb4TTvntPOvXS3M0CBThOH864MA+fFtguu6wLN6OKoGDrJh2/e7u1AYVTyoTR2V1/V9Q2hWvCWEUbxTn13DQNZGE8YiaQz7pJ0AtJqdyJGdnBwn2Z1dgmSObuL0KTJytVFApd8QKfv943//JgetGTZSz510eDhPPg+0Dr3VswHhlCAXi3/IOhuA8wL1EPtY8kv5VtqNZn45nqz2J9dy+ugcoH5RfAtwSYdcq/KXcAOJQi53yeIDfs6VTxyF0nyLRi9zosz/41aJ0V8S7BJFAigrqPX/V6/DelfytEY7TXwgobyjBUBJtXF+OyMl0i8pDWNgfYaWNVQ5FmAGTQ+MpC5Sn26c4EsutVAwHcb4uuj3xAfV9c03JUGYmgkUXExOp29i1vhRyRqr4FVDRV7Y92ZigWml/UekSflVqBNw4/Q+VhDOn5cj2O176a11mteUW589ZSAqp3YIeaKw68jwrUgqL2sNBuuxzjLj6L+o6kwwjouuIqWiZ0s5URVRxXycbipAe1y4nBg7qsYGxWE1x5TQ0EIUK/WIel5hT7gKT3UJS/q7xLS+SzXnWN2a0PGnGm2dsH8tfRodwyh+0EdwV6WkyBna/KOebB2bqvGbmVn9eHBB3EqpxNyzQvcTen674sJzSdvXb5ubfJXyE6kTXUtdoiCLVWabFs4f/FSubUGrK/iFJtUQU/v7dWl/vasqjM+7g6khEjG/sh3bdjEA9AnekyssOEcLgnX4EXOdvLnSCAuWf12fYzdd2fDIEAgQO33zjF0yD8YzGeGNtv94ZSHRsLK1FyqmbWpultZW+oq/Dn+C58ZlccO0K+wt8YPsb3Yo7EXYw3YhYkRPk/6Z9K1CXfy38ibhO+FvcKVqa9QlomvK8/Bd8tuYqdSTl2hXD/gzo7rWdoDaP9BG5rYT38xfTr9G/XQoQ8y6hlt1i+s/1kvH3KPjPhbTiHqyuva63bXp+q/boAa2hqgBk/Dvsb+xqebaE2CJrQp2bS0aVvTgWZCM9q8tHlbi67ljpbjJAEJIYVIWdIE6SdxSeuvkrn2qvab278j/0TJU9ZTPqeMK0hUBdVDnaGepP7v56TlaHO0o7Q3ac/pgC6iS+kY/RxDxLiR8RwznvkC06dpYpPZDo6Y8ziXzXVwD/MEvHHeJX4Lf7cgKbgkGDb9Yy4VEoSLhS1CqpAj7BBCQr0QFjqEKeFy4Q3Cg5fOw8JT/4v9yd8pSolWiG4W/WzxdXwobhBPi3dLyiSwJCdZI7lVclDyjOSCpEdKlnKlcek2WYPsJtl52deyd44GuVAOy2+V/+isVtQpzIpBxfWKQ9BTyg3KF1T31N9ohjTPahVaSOvTTugqdTfoQ/ovDUeNDCPXGDSOGHeayCbENG660/SUOcIcN8+bv7fstbZa11hvtr5g/R5eACvhnfCVDw+i7agExdA4ugF9yMa0ddvmzf21ewxj2AnYGuxj2E+x1WT/5Gvxvp1sXyBFnuKw99jH7OvsI0eyI+4YfafzHJuAJQE0kk+wUZik0iBEZXh0Qgj17QT2MBp59WZcnDV429u7brqkARHbZ8kFQBDTPa0Egy2Zy7ut78XcRNDXXX9N4jhBoFKNi53z4BRe26O/EdD3P+vSz7fcRqDb9h6GHCm/xs89llVNIAqFTDKZ/usXaXcPfN/Y+PkhVLfy1WDA4/Z1gQMr2stlybczpx/8W3/VqMfEQVw78iHPBswHr+VWMOu6XrjYrDan0bqjzWZOXPHsKydh9TNl1XByygdkIGfIFvMMnOLgb+Ey+D7/BLxerNj5aZd3abTZK/vu3d6MZu9kT+wDzovnisvH9hD8wZazL6SpKR+ahQLL2plT1QX0LLuAoVPgCbrg7/8q3SZ7u7rA6fXn6uP4+vw04bhUCkUlCOb48Y+ucrD4RajWnUZKyqfi/PyfZSiOiTnhHwIH4eteCxUggscVJKIV7U061LfmvlJqBa1X8V7QfDTfUXH2g+D77WedgxzIyeXINiuVxLrp67LES1pIG3Y9eaGLqyqqUmkLxh5e9+fKZ0A3huoVwHwSTKgETJAw75QS3G5CZYd4qhrclw21RYPWoz5L1xN3g5O1kBZ1Xbr39cx8IHpEjG5N/ErmHf5y6TsgYaijugQDb3E0Rkh5OMz7qpBJ1h60neKWCpw561e0+YYtd/a4ul7vdFvNjLQrUfrptNdHUlTx9oapl9RKBymp9XRQERrquCOQAfMPuGLIhHmPh2h8qTroiyOq3O+VN4du9jAJJskMy1DlCYZxm8JWoQHeY3EpPNqAM+KBSC2imiqriJgHXqgMyf0BIciQMG933J1oXZeC1yM4yWbLFeBz1gasLYW4KWFSca4fHw/ptdHL62HZ7MiWbybm/Ds45j6ghnp5oZXDqFBuWU90d8Y1j4I7D0tL/bw/kvgn1o3agzZlpsKpYtMQ+mnvtDIXTP9zvUU2nfLrW5krMY9xDVpAEtIyjClTniu0prD+L7mausAM1cTVoM90zQbcJW3AwCsgnbihWxAg4LUOBRSoeS2QjAIgEiJzkZCSKzVJI3/suTT0Jy8kW+nEgk2cDpPSR2HwBoMftx1gwdB6OKtV1BZYLcuQmS9Kte53Rc0VThPU4Luhn6bzjg1pkkvH8MYkNI4LmACEUt0dRBt9MwLnYEKoHMbeco/M2VkOlyHIfUfLnTeLKfk0Rb7vh30HNGRYNWai2ZUSeJlbCV/+5hUPiZAoE8dUMUvx5APFghfGieKMla/oUor0gWL1HeYBvz6Y8lX93Wm+faD42enTDws4Cg1gAUuwpgRHeOzN1SosB8vS/3IhJ8GzTUDS9y5u6xicKk8HkFt06/WTQ+yvqFf23yvlPAfAA2NhDFwpDIIzeQxClmiZHdob2fO+o90bSXYo+6zbCUxgPi+ThZZnOhvtbW+BfXoOhAzWd7/cMQrKI954Anjo1id1cWibhxg3gt1DqIBpsmLSQTGVGxVKSuOiPSYDy7NmOeM1mItIxTJbH4BXUwhGTowJvIPuKqTUAIFPaGHt3cd7e6i1HCKPqWLGF1UG7kGE7iuWpapuK2/sHxPpCXHjjGBOiHpTHuDjbm41LFp6XgjL868mZjpLEMWDNQgtAAppYy6EcigozvmbZ5+Pai4Fd97LLgY2OWU98jl3OHzlCi25iVo5uZ+M43AqTl2umI6fvGhbZd5f6ymKFofZMr6F5Qbg/WyHhdYyZRLWQlprDGbKcWskgG/ndre0RbbJSo01v+bs84exFXcY9xGHo20GRmiRv17BiSAMQQpvtVR+j+r8k+1HbqNtiHly9gN6+Ors4peT0ulcexzQf5t64QtfuJ8sXMxzHFCGLfjq/Pw7EJQLYhBF8oXiqgsiwrMWD33KTcKdfSFw3nzxJdb311d7s13sbzfohkv60ZGYOOQJwIB/s8/6eXbin3DvWoSvCy/cB3v7LoJvLGQFsfJtl4ibvbR3ic97r+y9i89ezR7bsRAiIExGOGWOW+KKwm7kp2W3Yeq16vf3Mu22zYIeqObLDbgwwEoZGqtW5/7ObXTt4zOLJbeWKwQnXu/ti82hQpupKP1KIOSKDc+DXdRQIXI6u5UIYCe3m8/2reU04PcXtsRloQlKnEtz5WliVJd6UujulmcE52CsLJUp8+aEYCSsjbD4P/ZTbjgMul+yARSACERS5Em/CZ1NzMycgY91n8uBAyDslueRYrZL7Zw8+kcL7btJ5+jWEPxuKifozNlGYvOz5JNiZL0hXXwTsJgbWj3w5HTpgAMu8BolCAVy3M7/QhZM++7K5k1cx95PRvP7308hsEKQCOBAqNQZc+rBLvOh1pGmv5igqRrcAgyjo6tVSImVOFSOPveeW+/Q+ltvzzx1k7ysntruR4f30pvJMdAqfU9loUvmADihJXxxaxnyH8WrYDA7NzLfbLmvfe2mNj//z+kD4NnZJ3oGgMLwEF5lNZtRdDJ7Hp14MUwfhECMCGVBrNTdR4+rlusHpT0xzxM0jsJDZJ4RYf+NV3qnaD4HoYJqBJyEXwPE5AUNdpxa/8Lt5q6wbJu/k2AP78U3MqklFrvrM1/0P3+ZmTA9ptjMmFb3yriR3CDQeq6b2q/f/2tvue99nEomSqTU/Py/z37wiiDpf4j1y0Tgp/AX+Cv8lFlUk58XDv4qvslhyy95FVPBC0aFB+DgdhqIIAeyZda4CTfMpdsaoSSjlGB3d9C8sR8wODqNbAg2801gIa02OeSUjJQx10hZ0ymYDfLKnDnPmnWzlsMmnIHqpeBciJvzSUspy0pkK/JrabWwwahFr26G9dGdJvgh5ce9LYQ6xYhgk2sDvhLIrDpDzvEbnbjsUv7qemklYNS3BCxjaKpQkvjt8Vwbt30dv04WNdKZPuN/o6d/nR67CASFugpRJiyVuCQnndzXpII6FRu8uDLI5zqzHrBGxJdT8+wroIAVKMDKoxC0RMwsvjfS50XK3RtxdjQ71u2AUiiReR8a62ResM/NT5wgxMiWb37TD83uyV7N7u/6iTIbYuaqMcPbcPdshmIl55oulqVBZ7KkTTqBQWxRJY1yZ85abiYK/6oSjg4Qi4+/3RJwg1vGWBpk2QLLUBxH9eEJKugPjOdlMrg1IFX+PS1VM6AXysPxAp8pakJIyEPt/Pl/zy4ob7qVLOKlTMPAu5Us4DMCRom4H/SfLbhuGMu6GZ6VAWWXJjP47k3Qyrg/JTD+r3k875JPPvmnQTN8dDNY4hYGFdJdUlFIzngolwb8a8f5fI9DbIki3o7tzoPbOSr8m3G174hvS1mrcOwbAcRDVw+tu+YABELg5YHyzyQklIN2M3kBxw825JFKM5kXGLlMO8r2zMGNGWXfa1lNYHRqvV6uiKxuLuLPfN5/jl0Z3AZsvSXLAkFUzIEjM1i/Zrpu4EpneNam9zUZ1MsLI1+ysNSus+pHwf56K4U9MpvoHOCR8nWJ2Lk5RCyEQZgMq0hVnmGpSjFYoRgYWS82yUBvHwaX0As2IUEKmFfJgYfEbIOsKcJFsUo0i6m1qDg0k1nERXFIzIHH6UVY7xls63X6VXA6hI4gONAPUlSZtya8Oy4/GaTcaiJTeNzlciCA2LUiP5l7xRDU2EzxJXN0hQbBLiFGcty5ZPblT0XhXzJK4SPvQ0TNox7fJpXfB2GkafKmeY/YsY3vbLg5y5K1djCyCsMXHvi4Cos+9Yh4NFJ02gJiaSsQS7bVAeRcIfa+VTUPi2DO4allHbMYs5gsXfjXu8m3rJHDRJYZK/7PFoiGQlFNybbaS8eyU+zoeYu4ytLotL6uI1KpZ6adHWk89LmP6VIKq+a2nwksZQsQhv6pKEIK5D+jMo6FnOUFZsEsOYsPGwqA6XnCMjverLpEoinVLsHOgqcjSyTp0VhOYqWS4fxFUvPXZYkzwAN0T6GeQcp4sA3iVMW66fgWX2EUxn6YYZTvUhHZmU2hJEssTbPDwbBRNA6MM4T5g4uvm/2mv7rDph1GNh3baaoCy9by+clx09ssXX0WrT08PDadR2o8oYBj0EKT4BuGEnQwK7eJV5f5aZZYPGUx1HEwr5Ed8LjpTGfgWcgTNbRGc7TVWzxgj0+V80NQZoOXNtEzyeENTcDKRSeu1qOpeVWwmyLpV2xLaNdxuSybYcabFLBD6mGSPyohgIclVEVsOuIZXlYNKwKhoJZyL1Z2lzdYUBr5VNuS94c9j6vIbqBeRTV7z4UZZaiJnk8mR14KQjh5uH+7v4/xgFtAzPTDoBX+Q0eY3XCTFgcn2IQtBiGVEqT8QROxQcv6tjihygV6mG96ChtuVU2E/e7wpdV1FL5Xi/hbktcGFceKeOEKE0BD3WbAGFgOXSecUJ+mjNNR29ZV/nmITygXzqbEi5/adIAFM6o9/Evu18uwCKXWhRUoQM/DgL7xOjypWwzjSWSQF0V4liVn4b3hZ8ezb7qtoAGL1GyB03N+upzP5uEKSnK8OLo20QTz8pFkOrE8MDi6sJd7/ncPdfaHZGlve21+dyXY89d7OuD7+F1qdOZpZp85hz/s7mm7xIyablMzz+cc+6oxCuN/BjOK8VPnLwAvtysvWDC3eunA4MpV00utgb0pFkiTKf/2tRuxVCqTyxdgTZLc7vp6KjuRzfO8KOum6d6cxmGBAL9SvfC2eDyfXUkPdGbeuBPbyCbWQsloYnQRrUJIKNkpudT/RN/AYCCaXihinMx+67BBT/XGM6Pju/FE4fW+Jdy6keT4bXi9GaF64Y8CoVS8o/3l7tRUMhkvMYmfvdrVP+CPpA0UFbe+6rfsmxgsNmvLKmkq/HP3D1xSUDdnGOfo/pL7vxnx+4FR9ML/HErGwk7dudF3lyv7vzLQ5XaHUCRUXLZ0Hh1KmwwgB6XknmWmvRVbHN+O9Y+tjX02sQ0OQODcIjuyD9CvPafhy4N3Bl7+P3r4l+2bYDv88g33YAg6bO9lID27L19u8d5Lbw6BirCtEuCDTLLH6J7e/7RVr10+S+ARXnQV/ZqKEKo+uULN3Y4FArBOCTRt6MAmRdStK+pDCd+feR34QQJP2ArWsMJd0LkdASfIQCZkHCxF8fFrhW77//xxgi4IvvWalw63se5QNntlOpebZR6K33jWMfAMPPE+T6g/9PdgMHf9YaPTfR44BsygC3zX87YOg4wT8xnoguEBS9j7m6vgZ9pC0MU/NZsVJCPBBw6eeizwoXTQrOB6qCDkQY7MT8wcvN/tq7RWQPh81bqvnD0LecqWAzXVgnAXqFNO6bAMnkKt46pLjnF6cwYYC6g01C6hrJ9X54yyFpGjJgo1VCiK8WVCSF/sBoPRXeklL4l821RPSjudxF510tr4uvGECB5ALWMC/Fg2EGgo/1iGaAJ/p+a1fuBYh5Vzp73MktEwhDnDF4W2xpGUVC5fvvyfeYHh9KAEHuQgAuDsWoscD2EBW2hDCCCqC/iqpltFvkmoMJ+nXBjnKXYIlsdHE87DG7TSu6E/PT/Cfp8jFo52EcIo68ZSY0lcKr16Z+qtgsLPDvfZ8i4H+6j2nCare2UvGy/kCHo7muGP3C644gO8LPM98648H45C2kqidlgRNiX/WPiSqJIE5RnteiytiYTTsnnC7SK3bnIcXr9c0ClzhV4Xh71gkKaRocjooA+vM6cIqtiJ/IQgGuCpiheKDwB1zkCYCgZSKotxBcpTFPAW2ZK36gFJYJf0jaBj0jHORPgoQXO0upAwOrIgI/lNYB7+PHr/rem/4hgkXhXWmmtOv+jmBO3xaL6G6UBhK2LVDwb9p1xuK0WrZWfoHVx1ClOXLaxjVZp4dpqYVdISkre00uB46HVOhhIfJQrDQwgRUWaUXean4/3Mdq6EcxAcJVylZqnKY8WotMkvya19Bg5zdrM5X2dM1Xg/yNEMjfSD3Qtz1UoL1py+ZzaVYdu02prFUZcFKg4PgvZZHBk4rCAGVgkKgtHY7M7ARjBdgg+ifujIt3C6XS68A3kx81tZMx+MCAH8z404JSobjyopUutUwtVAYlOeE2HMLFuBslmahdRPyyUry/mQq2z6U9DPaoNA80lIGRsfYeqjynxEW5Dk2SnPb1MVWRIrZWOxG/OFMs5qnuOFkjRu0rqSSMVoiBUMboEuV+VhWfUr5Doo7R8R/KkkrZS27qhyodVZg2XTfLpR8TtbK6Z3d64N/l9cG4hnJvZQihFlCUfbsfsdxAFd3Z3bZoIGj23gsUA3CBZp/W5tRYl0wCSh1G2U1PfTC8ag1FnTkgvn/cxyaU/D7W6fv9fH/SSH2x0YZrdZZpKVTQq1iRHrwFz7C7n2PilwhKKxKcEsO7neUKm1QcKBNU9+skIsjf6/m09bi0g535yHbjRIyCTUMsGAlzZOIkegGHarOfwQ0amDVP2oBdvQkkIZUEiIy/ekSURMsoAb1WYMJ9rTBmNzU+t0uE0nar+t0mh97148MasBoun5p6QCdP7EAFSIEN95PIbCRC6BrtQKlx3K/ogb5X4tIzhU2Rc091nA6mr9ZoL1Ma4i1aLwkqECTqgXI9bysuroDpZclayFvLX05Q/cqc1ehFbFwgboKxCg233AgWzIkrnJoTGhTCME42e3o+rKHfG0BEmU8bht1yVUHIulRFgUtnZcoxhjxvooHF3BqsHSULuHEMOi0vTireFF3iYgRHC3ilBMmFXSut1b/JCOTIGUI3euKbGKg43NQNPo++Ah1FIsqvQXDLew9VRP7qXuHVk29v3mUllNNh0UNjQXFK+pLxxqIlYqY3t7TzU/LogMxfCHslMZCNN3F1bD1EoHmtBqAjPcz1dNg+3mx2kcxPYZz1BL5eHLGx62VafV4Wfr0N1h7vPMMfcmY0JE5Ev5jvYVYzRs2ALpTHmaL7VCYlTjYS2/xZrZR8e4/QhwYSA4O9dSO5ThJejEbRczvxw0oitTaIEhkfr5EhWgIO7qjrhC/0Tp5JUu1ILiLRi0aJM1j0EykJNu9tUulzY0HQBhghEo35x9jhi0wtreYtt5YyrYol0iZxbAPzdASEdIwiZu9VhM7Bqvaq8gjiIbhom+OTZjxJqTrXhp1cJa8s4eUimho63Z4kCpHBP8pOdWoCTDf0xkK2IEKkBJK4c0bFhaxffro9JqjpVzSKbKtGRhPaRyzkgO440NkqAiw4mlijNSh9JaEvj4DgRBT26V211xAO8Bm5ecqAt5rYQsyJKe/jOuWXVPnA4105A5li3r5yRJVQrLUiXtlnI1WXRa5zjdAhehsnEoygWG1yYoCPjnjm3XvX0SREPWrHzvELxvTlY2g6RWmZHI0GWeoeltbL7Zzr3CJhu/FY6MbYveGBxtSA64Bq1CjBMjOdRSy2oZn47yakV0bIvyR3ZT06jVQAl+jHFHeQHH6fq/JhJpMswXx1usr/c17nhwH0bsLq0i0rYSXgBFee6ggg3RJKTWqcRrgRXAlKeYN3SEu5G3bSP5HNx92yBwgAOFnV3eR2u7urZvGfDLumogRAZVV0XxeaKqLOvqDF6rlHHWIycibQk8gmh7tEpGvzH7W2wWBwv8oDJ90KLIhs97OF0uSmwtUDa9vcKRn7mxAL5aBac6QrPp04PaeVaORn5TGtuD489fXninPBuY0ZpWEKwg7Y1JVbeqPH/hwuLFXGAaXCWt321G7VgqY8AW3Q6LI8yB+XKBzei7t8zOdGDsTBD5Tl3ArxkS+mPGZUkwohIw6SxBCVrRfaMI6veZQoLP0+AG1Iqh2SNq3FwalNhdUqWjNZyW4LBDetdKQ8cfDwolW7PIAvi8IS6ITce0w9HE7t6cp7MsUaZWgXIuAdcBDKI3hWCK2w0cIpyGxHrAMfI2uIgtItzpmv9mMxHm5vOBekBURHVUycpQ1EETpYW8MfVwcntqXt8P1sIhf9YKaHeezjbQcBRrOt9HqFGTFU0xAlnL9SRJ4BiayVbnm0ZIpNPjqTrVc9oxpx4LStGzmfW4eMyhZmr6TMAoi4lAWLatLKfMlzj2yldYNQwTDzVqNToSdx7eEvXQzzIdwiBChlUUuotBUIxMjsDELOUpHNJI/kRqiOAWutSnR2uh9rIm0OcMaepK1de7Nk5SyVR2bCaRykacpdS4QyTuBeo7fANO9SRDWivhqnYgQ4m5I2QVQbTt9vT3NuZ7SRtms9ntbp/iWxqpWf/r0WxdplyCJzNFKMfZ+XtC1RFe5Hfi8QITvZ580INa6lNsIW5D3A4rnMYStoYMbkOsXglGr0MeW2fM8EbU5YhNvWE+K77A4tfDzoAOaigCQXmwWYTnQ1xbbu+lXw2z2Qic2h3+FZcOuCFWQsGbj1JNM2A6lPEJG3tpJ4CSoy2MIr0/NmBnqsALxb+E4AZtgX2+TaJvB4AcrlK2jV/d3gN+yR3MXIp4dnOf3djlxj/DAR0lcmzkkiGxeAugY2r5lFeoLNhtHAm1LMXAcRz4/KcVpF7a93rYo5bzzmiCU8T5KjgXr9lYjd94IRWBb1MO+f9MzUdPL2i35SbxsuVs7BoQq/ie6lRn8gUu+q/GfnZWcCuO9Ze/PB9u1hDH8Oum13sVjwVFTgEWHZWFsoD4+KNobTiHYqrdVe8PYfAirnpadgv8bFIG211VPGSTIL5vurSgsG+B7mF9IAFRRh7fhPS/lbhbnOFX5sFRMOXuXtpAAewdtSP22xsj3Ve+9Mtu+BNFzJ/5kAtfZKop6GMBlc6pH2erZVOHwd0HcBAo9UbxQnf+yiEETH0rcIYWjsP5ux1w6UbeqR+mwZ0lcaiBalnDBhJyGsZwmpV04aeFwDA0xaj+murFOSqTLBkJlDhKKXhzx6AFHnRDClIZ9RBBuehO3A8HGRVas+lIaKBpNAcqQUMJLuvKzhQcL56RyssHgunJ+M7O1ngimdnL5gtwBalgiMdnjNJogK/nyiehxOA0uhXu56CCnr/ZY/LsRt6JDko++Blxa2rdXUBfijdwjJgxq6QK11fHMzsMcrlx/Vp5ONGdyiX8K68yIJBSazBolAaHT8V39FeBxDEF4oKkP6hTUbc3Y7kiagiHtTdimukUel3jO5ZjiJSubC+U0OtIysB8i8YCvF25mmti+CECIkYjEPoE6FSJommGp/BNnqVZd/mzJIpX8gIxR/LqJzYz+iQoKff8KzmiHPtoKZiwbYvafgacvMfuZEiCOJlUU03pmimk9KTC7rdcavs3MlSd9pFkIonooB8KQ3jf73kOaXupfU3dB/acYSeiYHCgIWjc1FhzAkI69vWD6JFf6QwZVfA8ej0QnNah2h1CCLp67jQB1w5BV768ThfEu5iJurozuu4dTyldRVBEHj1p/kxPvMclBNaQliLyO7wGlmAEQdqRTsP6L25x3psha4Z/bh6S14u1ol4a5rqHrTXraxjAAlKKBDBTmVaqlsdN3pQqVyPGDGaQIZBKhHSdVd36zNww6GcNU0eg7vqLgHf/lk85L4D7zxr2X3RaPjjL1XUljv1w1NCM7ouZgeHiljr/Md8OnwQ/AEozrhdQNVrXHRepAs9fqnfc9C563+bLCS6suy45dU4wbFVkfJkucSX4jCRlWOhyYVy6gSCM78SkCRxLrZ7hmE3vI3IlcniSXjlFvUAvNDObDHHIW175YMPJPad7zTzutVstyvpDBKy7+cXc/Q8Rh8FjEEKlev9aJCSsD1aWu37cc5sN6I8oMLWLbS5Ltrb/1jP66W1gzdYzOp48vrfGJ/IRvQK1gsa1eMza4rVgk8ea4HGhLJbGql2fMErf2/kj7zr2ntXQOzvXBZXGCQ13Ns1wyD1BKbNLvjUeoOhZYPdlSS3t9xP5NrD069Go98p+8ux+1VumV0qtIOoytNJIyFrZeQpuYDDZvfK6zP8Xyzinh72MNJ/DRJcFKpdr85kAopanIZZP4zbohVSn8tPVajOHnLE8DewyvFRmgrw6X8cLkUV6CoHqCnOVP5adLpG0IMGzFFXJ7G5f9X8DlMch9tUatX3LMU6BRwAJKn+3tuVnxNrYorwZa8cgOLRHmGEZ2kgDJF709xYR8+WkDUMxN26Zyi+toTZ30J/NksmNGsScmW19PuvwSoA9JBaltA44ijVtyXAXpaKmPRlXQCxqa3wMRJNV8k1m7Jgrzth2Ovem9FE+HderZktDop67xh8fXcQ1RTOdtk1VwgqpzTI/lvZPJVG5t7EVjMdZ0AOq6nScCIegeHIen2m7Bb0fKIVw0UuL+m0/zr4pDsQ4PaAr6auiFdpVrsw/+tCCo/NVkrOsKtWa1abkG85TKzJlugSC4X41G1a0zZtnxbzB0q67dRqcPmYc9RMBTjuTHjJqeKpAcYo6pZQzrryGPZo8ULtyV6+JX5tuJe4cPi2DHrjIjvfkjtv8rHDr3isYmrZnu4abi5rAiqpmBmeugSKxOMGibF5f9CJYvFJqIo3M6TfjrXEucISklk8xVo70EybVOiWZ75u4BSm7kISNTcuXarIuqCscAAHSMSqsP2w5u1cqFWCaZITKo5zrVuAoJDeVr0VNKkrptwR1O6gjnlp0FOaqwdBge3c0Go7NxeOplcCAHwb+RHX73nNKBEqpr3WFYru21fmux5d7DUurrlBnOG5a6Ubt9a6MLLgdkqtUDrmvULb9wZfaDw1mV2r6FcyH+bKRD1eWlHNwsWc3UMVJ1GWWM6WkYCE27PTlcl7kq1PUIVEUQWu0EVxjebsnY0ydni2gM6XZmFf9ie9VFFVjtaJgc24kckm3PTs2+QpoyVAael0wKeWmcS5CpnCmqHWDxmQFPUG0qGiKQG1Z4sLmBOU7TamWjCrxtaHsyFReMGtIOZLRXpeeTeHl0g4b52m35c54cexrIk9KjjokE77eGk7kOi5XwXE+kgR5kY9XH2LZOJ/3jxPTdr1SxDyhTjMcX8942j4luyd1I+jO2IBndC0dLi3NZ/Pp5JpxFTEK21GBLKRnC3woH7J2J4Qk0DxxDYHhrXrqC4htu/4nRA0zoZUodz/98CVZEFjtNV0FXwQbMDTL6dy77kMSibuReSZQ0em0g+NivfBwNEDWxNdEVySOwhtT//diZ2aDZLOLb0bHCPAA6tR6km3qCjGmwivtx5bXo37EYVyhU2hyKdGh228yarTt+CPMDVgYoF31luX1Pw71dB9s6cy+O6aeJkylQpktg2vEVp/4hQxJOLuVZNuNi82kOa1ujQxlaZiIB/1n8sJrFyHfb//4ni50OO7rpnxvIDtD2lw0F/CPAmfqoaRT4/VOcU5jQxR0z2og/ZvkLHSuLPv5w5jIWrvoW3PCoEhP5HaRjkox4m1Cme1sWqkhVRAU5EdOm7/F9zPAQ+ocbr05O4dLKZeWS/EdmUNTG9lwO1/mZud1CpTCPrK9+duIGbeL/xcpP5JaQAXiuWjuP38ovHuH3doC430TQGdOtK+xz6IMwN7zmvqauGwD8WtjXUbYMM1ULf900TxKSXUQztuQ6bEpFxrcDrUl0j9MDNkahjWieORqzDAzjWKBAVJ8nWbXOLXFXc+fjNhcxriAPZQyb7AKpPuFzWGYOQROQJiKMF5g4jzLFd+kLqnJTLq07+tjLwmNiDHwWHKMyQFVKp4J+QzGKlNqVeNrCtlxo429vAual3cMgp9cvoVYreFfYczdc1y9oOd9geb38h8L7BwfmvHt8CdvVPun0n1FEs4r74wPHg2pt/OppbL76xj8hOpo28u+GRf0vuhgbn3HBHDAEIo6DklE0IFa6n4w7Al6hCGiO1xjolockfzfgWMQ7BX3jlC8d/SfNEAT0tbbTXzlW0L3tORdKKaG3fI3eMr73tXGwO98ykD5Rbu/ylXvc5b2+VuJ4Pa7k39ZC+YgMiQSYb2qjGz+KFVDhOingNe69zhA6+FOffv3TKk0cmg7WdBPEOAiESekbNlOK+TxowC50EvrM9wbLfGpVCD4N1v6Td/O4Tvwd84AUvO20dMoZOFHAvLtz9mXXtWd/E/+dxzlLNcvDeSlj4Dr/elwPwqE+kt8Ke8YA0urM6pLBBik3YuDY4/8nJFUS1MEfnw7kwaH1nkVbqSaKFzg8FzCzf0hJ0ek+qV32CoicURt8i/dvXCTfzhG37tU6OibrdbyS34KdUfOPdEY/OWGomu2YdofvTmwBRIhOCmphngKeFvHtQ824Bb8Fa7CIiLUSUHZth7f3g129+xMXDx+L7rYfb17R6/8sSDPySChj/IF/dDJ/2vXuz7kwQ2IdP3Jh4Izufswhl1RB+C6nlN7JPHt41soOAHBh9+RgK7FYX+NjHgp4vG2hQofF4vgEb5H6lfxTEfgKbs8BwZQJWurS9hXg/3rZb9dekl5eS+3tp7P3yb2FVqd5pp3mQOxfnqdJwDx+gvwumcDa48c3SmbP+XDUVOgwLjEjljSHv3MV5deVZXcJfYl3qPLuU9LwO3emqmFYiDvMFYiQe4TCV4qTc6Hu3EvBLlbVGXHDIohHnaUqbH2klsX6bZt2vZqQWLbz+yhIXEt46zooJ1QGWzhvSnB7x5mUrDpyOljBS6PjSa4BVauAR2KUNUOW2H1KkkS2653ug+1y526Z9klb1cLJZT7/0+dJl7v8ratmDG202l0zx2EMb1q9O2zNOdzl0/WZwzr01BNol0m4lwUTCr3+kNwtSzeYEma8bFGT1Y7soA1ZIz5LtBaXJ3Miaiy+/k2Q7ZxhX8or7YTdQXBkCSSLTjsIkKFCAKaE8I0UK2AGATgDsOrzW6rdkkwmmA1bFgVBzIQoHKqfAjhCGooIsSSIBmRhCtFG3DINtapdim1tFuSdIistig8m+N6enZ8E1ZrUmmzAJXv9zQI0bykOZqTUSt2JJbU3HhDtyfLqXETZOJGSCOkZVvcbGQIaoolRtEYaqijnH8OSxVwgUvGJXKGMc0kxmyDMxGSzYeLNrZR5i2Ah5R9pwClHfswAnfrTFEHouNhVPC8CJUKQjiEEGEroZQtjhegrHrh3sQHgN6nRgXgPKgRcNa3428D/TOL4YKb14YcqS6NafJ2Rn5tEgF0amlzsg1NS2zOtmKv1wke/2HruWcccN/t+/8Q6J47Lykykk6uO6zdOX87+l9+UQfcoOyjx15SvwjwI3AyjeMmuZpZv2YY25WvtsBXf1HXXvMJ7B+8BjqCd/o1IZtC8+Xxt/F/bQQPQpn2dm45ysw8hSRIybij/NKsctPJXZDRBKvFiMIATJBRusYXlvr6v+DPEfttACKWLyGXn6NGbeOK0o7Scez0mmnvf9LpKwX98ZdGotHunCFrG5a0CulxwY0Qqibmxq94fxj9ndSJ/Udgc8+bCZe/QGcBRHDFWUehTpmjS1Zv/VQw6K34TeJOPDM2hQtWw2whsN+mzGZsxhsozUQ2ciTJghZfEmVVEXK3evg1pDeo1sSxlcUKJi3GKKQUPJAtc/l1y0JwrG/vs3KcW7OxuH3iLDxeD+EDFaEVyavH2soR0aUFBla6FRTC+UlhvnsGOoF88MZ+/w0mg7zGFZJhYRrIccKSn+9xHTFfQjFfwlen4SyntPTXeVR0DG+Zqkr7IQcZxqkqzdwdW045YMWLHQv9YntEevjODN9aC2u028CJh0ltFhse06DYU+MtS7O2RuEM5EHSHCx1bs2eFH4m2W1B3fREMgU+6QIPQatZKXrNHYBYPKG8JbaVZGXy/xNjMnHVm0vmCRytBGEICEEo5Z2hDw7p/GWCMj7/4O8QNsvzRKm0AIKL9Xjsu3t/6ns4/jo1r+V4LPZ1rftUr/w9zvp6V+Oz8S9XgKshEqqWWpMbwn9qQxADaXJSern2lO0h3zgs/6aGm4tVDZJOoXmY0uqpMn82tAdECSL0dc3UdyS2/wYfHJxj1+tZHcG+luYiuJYJUSPqK3SIsLmru+PlfRxKhzaiExUlLIy9Ji/X1i2Jm5CF0J4J+0x7few/WNAyMuyXCbVpCxLWpXW97rB+kQEfsm1PPO7qGakay+3mpXu4oa5ay8tO0hnMV2H1OXCEtACRR20FITBXxtYIRwWpNJT62RgV+qricUAzN1uogio51XpTwAsC1I8nSTGX1Nt0TfQ3Wb+XYaEdLiBM2nXrlLQU3FwXPJwYUIZ7I4IJ4ySWcTiixQhI2+wdVZzhhedo2Wv+Kl7itIYscVYqgy5TiEP7dSDSTdOQKJwfuFTenEiXCcu0nGDIbURxbyHmK8RKp7NmfoobwPEKtAyhPJGQNMdTUZn1/5ciRrM6eJaU/eiKvqE39cGsBUs76VRW+kzKLM+IfjSPtfqzfYxkPG+7PG+32t3BEJIZCjEekIZV1c633MYIGEKaRyxtt/zYSTjA82mq78DhrBCdhFioJSer9Vq8UeQGpiUawVYi4D8PXzdnImupGd9ZhQKUMQcPtuFIi0EfDkf/P/As3H2Rj8rwiRe0Ob/574p25FgL+DDB1c8f9N2krMawATbLzeO7UKYzK5AkkXFsIikqBOUIShwnmOpaJaISrK5WwhcGx3ISIkTujiZxGTTarFpCBCjUP1CMMGWUrkaVLWmHpdJWLBToCwdBGIXum4tUWJQbThxqrYAniroeYKee5DQmCk36fYiQMla3Sm7ay5DEEYqhnGZHxRIOY5zXgbA+79NQ0wprO+KtWTtWG9woopIL14vr4aoTtEA0teGmYAmkGLNdGwTR3pckkWJMMWlbyMhMfTM6q9T5rrwcfmW4lbr9uRq5862b3fAOSWmeHXehpgAbDmj0OjKoknQpLFkJtLit3oxdg9eSfELaJl9YJYkxEriTG0Tn8uVtiXpjAao+YGXLPQTUoV5GrXqYBujceNKrqCqEN56sRQq1w8/qOk5D9yNmHVuqjfo6Ilm1O7Ms8yWKjCNMg+jqjGH1D8VQKvNbv+7+eZa308BSBEopEYQYxfVY0ZvRWD0bk7qEJ014U1wXioCy5y8pBOmIRLqKFOIOWEOaqLig3VxkmtQPurTzaTI8UYR2H2y0wuckkWdAXspwVHCM9FAzwrumWtMvEJ1WGTy30no1hDwgDek9OZpiIdTyCVx4AIyLvG8CMfwRX/TGm+PPcZIaWFxP3zWEc0zQbtS18km3rKJgyFt61Btd09j8yUjS9uaS2WbF2C1j6wX7ET4JJcFEaF86GMpFHylrC9r+xKzOrSIJ5yF6m7USNoEf6GRM8m9Ft2NRAL0tzoVaLecYtQH+Lpwc6D8FEWTsmzyCmcMz0ABPYiNahX1jngqh/kAZFbzIQq79tkBAApR0VzaJuZv4OkQn6czZDsiEFlHbq+iIYIpjbQpvul+qsRD5gQHmfHfhQ+E3XpWM84nWXuZLH4wFLD6UaMeMYPJdy07mVaX+3Jl0Z8C7aUWOrwlPihC42S13ZIvav3/O4VMQhDLecZIc3OEWGWYCREO0jLO3U9izP3LlhVqKUEUJSkAJbN91zzIT/Ji2np8pQdapOfpD7tKaToqZ8Jq2dUdRrpQqvz+f5vAajTK9yxIJbjhhbiGgbskPTWfD7dMVU5P/XkkzoSU2xbSvRqn7ZmlX3NOUOILzTpmt+yee8hW3PcArxsfj8tHLQBmS4topwAXPE4gSOFXDPIHM6ElPFmb3JxINkiFJusO9HEgCGC8HZfHF6RL3oeGpWBAvo1bhGt+BjHe9tg0N60W1eXxd2ttpWdvSbGEoTFL4g8siI2A57YFuchgZ+Y9oFlYtns8JQc5qCIuu13ZfRdDc92M+0F+9vt3elg6+HnYMzkybP1RXsemI8q+H41DAx/TccNt6oX1fOe9djlW82LDgVQhEIXXmGuw/3AQdkTAbIaLmDsl264JgWQfXOAQd6KSZBeRQFSOzw/c9MHDxiTuzo12VR/D22tN56aiIcxeffw7GQtUe2GOqgQPkulfO4R3trtoYXdeHfdG4iCc+vem53If1+xNN86rtfthjY/oyU38YUIb2kvDUug/r2BgXs8c1w3qLKMEEmCjTuFkplUoBk9UwW4QVNBEuCcUrIml7wYjrGsZM7sSaAatDO0Ovx/ZEFc8CdT1rchhKM4eyi4XWnheZor1jSic2bhDxWChexmBFstxGXsNEgg7sBoR7q2U0BtWsVWCdBNZjbV8oZOIhBRfadmei6InNzJPZiHJjwpk0rxhnjYs1TEkK5SqSVxmYDSuMAbo3bdBvQ7Jo47k7vXO1hylTFdyAKUaG6heU4080ut5uS9leVajigB4ZM5BGM4FzKltZJio+8ljad/a6XK5D3Wl33IS3XA912jxJZ6zIUyx1WwrSYgW9msE2VEedoKGGRYGwRZ/pMUQ3SmGaUZV0aL2LsDg8Xqm7p3F92el03JY61slV1avHiIJVBFFlXkbtvrsPnUlHKNRwwCycjFroj2+GLNP+Um/YV42omS8N44iaiSNGjf6sTQ+4wrpcW89vDSeBDWBjjKysIP85liult1siSWKnfVWy2AI84En+KZYbsqNVuMiyOmXKlrUNy4virNYJccuOW/v8bKv1Ze5blJdwrLeizbRsQA51dtN+0K/VcJgJs+Sc5O2GSF2KIcbtWGAj1VE9p1yzkBBpZS2Im6yHDSOrWDOkn252KWsAQvgwEFNOcYfjGEFhKUYILMw09dRzUyXpIiscmJI3I8NVC1Q/2zCnRD9tBxwhiOHpqG6adrgdEj+29g6RNhGFvtELNdKkedxVEQpCc3xggHGLk0414ZZHRAWGmdtoCTciVG2mMBrglrWvGnUYjchH0IGWiGUoX2uWO/ySEfam08mwXa93p6g8MGQOFdON0DY1iJrpBKwDQkJ6JuZWTeNPiVvXLFsvS1M4QvJAk3GOYbkhMErC2G5JlWUoCBzTvABl/kEe5MpCr8N1SKrcteRc6Dhl2ynxlHCcgfNT4lCs50UKYLM/6ubn+S5HkWbNuOvGQiIlP2sLpEKsB0YT6Rn9KTwZQPV5scROlcsrXpIRbkWEPI2yMNBMKRcHdeRBT6XZ76qFwfnzRd3de3TmadRhsdACd2w1ncOKI5hPypknKxR7R6BGVyWpJ7Xluo57MDYljnmm4jeuqbSezAj0qrrHmsAV1uea6W26BTE10VHIGbdmOw7DGNqm+V5fFQjjr9MKNH9BEJShAC4E8EW8L3ae2XnXC7v88c6zO79359ILfjvW0itenA9KS68sPLagFrzgvk/84hL+WFICIIAiKTXHSZaWA/MHlnxlEEb4rmg8+NQLB/gP5zvZEHSdd1MNXL0vkvDG3VLqCRcgaapPrn4Vzld1MFsGVVcBRe99GD6O8WJYm9rNibllAQ5ByBw38LpJQt5rCITOlZrU0Q1yOUYe9LR0D1I43ybT1/UZ0p3oqk0yxfFmPGIi4Ayp6DSDnEOhxiwicIJTOpOlqErGImceVlFsMtUtsEYE58mfrbEJl4pHurJbi+fdZjYx4ywcxRoZizlxieptkcmVZJaqw02z+YcpKsU1iwcsWdzRhvUGbvdXNEnYyEUjSaxGAtVLE18uw175s64VDGAWmY2iWne+UENpLNJ1GjDAJCX5AzKvmz/dTvGReR3eHCJzFA8IICTBeB6CCAKv6977EnBWfqQvBfd/JY7ZeSlp5DDe/0Xgv+zegm9bwGEyXPmFAIA/uGTo+MpsU1Z+1SRnrFrzUSIK2MaCDo8qCI36/POj9TrqOvdk/cl0ek9RzHo8tWMgOmwxcA2hFBJ0McG/uNhETXN48cCal1u//AwgZJvO3ZNZoN1RqLBtihTiX8lYfx7TxDje6Mz9JkKgWYQqYj7FWIWHybJE4/5iSZ6YsnwpSuH9pnk+RHiJZMtndEPTbROotNEVZ0NFll/5ikk/C9l8IA68heBRG6iyCgb9sOvQpL6zlknB2N+MdvBZjSYQLjR/OTy9UlFPNC9YD2YwgKrCy4fAPrMaqQzt3jRWNcxQjy56DaWFAPmQL/MazIEfBCHwiKsWiXrwADFxYsDpuqY6ly4J1TTGpy/KSjBEXdTTDDfKgG6bUHW/ZJJbSgOyT8ol4UogM6o3xDNM1/PZtK5skXs3I1/XcqXc9pIw6URk/MiR4w6yis+W0vHB37TuZ++QrBYRuxn6OaZQ/oFSHIxNc6ns97e3/yqObjNlxJh1qIHGfayCUfDe0bB7zVISgWJGGVxosqJSxGWntczaTUcowmvCqvu7Jl/JMGq5vdQmN0BfuLkkwAcMhr+Qo+9gBya6rJm5hiJIOeNx1WsL/7FVn+iSA+e6no/fVZO9niROEqkGoWq6YSQU8hYWVWP2Eb8lw+BLSzDF/agNxuiyP3/y1OlTbSfT+sXYHBH0bl+qITXBFMaw/Uvfb+sfXtOIi+t9bcA9jhN5GpXjXuauakT+bx6gpk3OsPIYRY/rcEKfQDqUfblW9sHBZjQe7SzeYuFF5D0RW4pQI3BWyY71RsNgICV23NkGcDdzstel2p2ff15lXgd/45szDWTdT5P/Fpwgz5MpP/nmYscZ6EGfsI3VcJtouCF9zqE3AYXarAnLKWqTVKQYJba5sJuS7JpEJlxdh7fCdQcj9fBpSsbdzJLzFtSOfWAqUSAYgmUIt+Jz4pWzM2DNwv3/z16eVtO+3lfjLAMqJFJbh6eFrLytkQvSmh7YCMezmrXjnFWti4XeULncqZqPXf1QdJJueb3IAMyQSEcS76CQTV4l0gvSeVI9WiKjXXG249T1BrZ6RHgycVzBn21Tf2PSbp/oMl4PgiSOpf7k1Kzmpeut4vKyY202EZZ9XzeToaAClVS1n2kZu3lJGFtpfOrcp4GHBm4dkrVNylnVD3bthxvrphll7DztQwqNgfUWD71wn8Da+8SJthi/oodibWAE6w+zMAayTC89lrx3urBLFBiS0aJQ4faIn7aBh3D63KrLhRs+cgAewsMSfCK9jVd3g0tGPIZJBxwYEt8MNmVPZcFzWrgBfE0P0MAsqS53Hn7FK0DAT4tQApLEwqvgPDDTZe6Bw1dxYZoGbuQRkACV6ASgdxtHvE2vD3p2H7zgOgRIAZhcjvvfzrLUWTrweHwROzeeG8l/1FtqugW0hqHK3xEFNXjl5lgL9kqs6LYvQJdZ2wPhaWihPwlAfhzwwbcZ7UNQZCe6CMg+MweLv5pdqlkWePwE18vwJwgGC/oQBUWYK0I4hJbmJGtHu+7u48e2EknBfuZmmkfSGxvPIaAfHy/n4/DmRoI0XpJ/imcPohZ4kOetOgH0D1DIJ0ZlDHnQZwKmzMx1JQJtKTt2FRlZSNuBPCdTVM4G1UX4R1YLrKr8D7QzTavuuUz0bOBgnl6iXMDa0TSmbmoz575jPz4GTNzIKKVgeIZ/vSJIh3SZOceQ+baj1dCsyMfibI6T5bEqaqxbln7vVN0IEliKEJyEAiVQvNx6O+THBFvisaIDQyceSUcGVLvcFP7OB6uazXFPiwnGOdVlEivnXVwhyCpyljESvIFlaEuQUKA1FQ+PE4W8l6F9epNcEL5qE3R9kg0EigY9nFDUf5zjtarqfEysPXNO37tyTwLSEL+mQteEwVcUT/7eZTo8Rf1wdEWwFzAxGanSkK34088G5umvF0WnqhILrFdKj4AUL0jiuJhmkedjcTbq0O+5ZgdxDZyTovAl5ZhzoQNhmpQ4mtRCRLj1wHLijNhHlnfvjmyLL/R6qqoofrol7/cJxlE/nTpLyo0FXcCei4JdTHl11GtxukyZY7K+uxIPJeKRY63i/RFGm+9O8ukqDVAaBGnvrOMOIA256OMIZMNtTFWkAnGTTd0Ny4qTjuAeVrw1HXaA0d/LOQHCHGeh2L8sR4iP2mTsvf9FC7cWlFQ+V7yVSMTPFthJde5hJf7liivfIjfgJw/ilMkP3R2WB2xgCHZecFTysfOniBCM6VmL3pyPXbz0Bn++N2Ebt/z47dpXTN747LO/+84b563Cn+zUNedh9Sdm7W5wypwRmsW6cBSu+0uuyeTtiaaLXLjuSq3dR2dvvFElZuGuW4VPbMtb1B7bNOkqgCMyk82mjIExqXRwEFwVIxeM6Xm0FciMRlOipnlNkmXOsN24hRk6zUQqX7SI9XUdBRWvRBrwehqvTHhViVkeJu0ZxXJRlI6vof7EPOOqrn7LnQ17rUbQThtdLwtEhflf9keGJvOc100HJktx2xVk4OSK3zCkjLdLLQcrVNNQrIBkWvMGmlD+gY6tGLrmSDxrYW094wXt8VSzcyUTRV3yYwVraQutKYMm8H9gWTOOZ3nHVWUilx/f1V36ev/gvKNBeAGIIE9NLrR7gTLDtrus/NcnV85OAc7n4SKlhiYrkyQGl1+PRsGUFAW6AVuBCDAWvDps1sFrSfEMfTUSsZN0oZ0MBFLAkudkJqr2knFIgLuTfGbM3YYkg9xKzp9I9yBFEFK9wSzJm0wwMp+Ze47T4QNXQ6+11B5s/b5nU+pOPO1yx2eftWXZQrZHBzPj8aoL18deHo7dI0mQwNjq9itrjf4LYxkFKH1dqgtcyaPd6tV6px/HI6DvyPpbjG+3T2EHTz5rwCWOon/WX+9bitc3PvGbBbhKj0pWw69MEikvzQIPA03QaxJA0+4tmGGUyhgZMYCr/hcD9JbmzNx8JRAAx+G4XBvHCOXs9ErRNA29tuk1JdypSBuTFtN13KaJLE1khdeS2bP2pTU9lksm6RxDfDtRk86SYPdLU/FxOoRh34BYS614c43hfDaFNCBmRlSbNrgh5RGhPCRMhQ8Z6oKI18SMJG4kaly1U26tPME6mOL4ddv7hyGHFyU4p0sboSaVTYUMOrQtqhIgM5hupN2RDEPw52IjGfQfhZqULwpsNDLYErXIcMryLksKf7jZwhMJBVAoC01ZysK709sb6+qOVr/jQ2uftpxrauzTnvQQXUN82ACLdM7i1hYUZM2y0RmLdkEwZiU+mT79CKoh5RHplsYRrfFjHOdDu9ER38GO2RI+nTt1RMKT12aM5uHFhf29zeHy9m6abdkHIkoLGVEjr6EpjzxcGAgOB0I599iEiZ1dMTSPTPAsBD1VmZiNjCQ0RjnGaU/wPMUwtePRwpMXkCFTDbka+WexUpt/2mu13qYo8BJ7wMvpWIsWrVIhKamwaEGjsx5bghuiApgbczh7JMcVuNevwICDiS6M3mp/YD8QWElQ1Be4vq4Cry9oMANWysVbKpJZDQxD2mAKB4U5u13aJEN/XPGdnd1279EZXDQsl4i9bJ2K8mIN+f42h5lUcATiumoAhkd820p+awYaO6OUzfhhZhx4NP8sk5liR9nrlFLYROUJpfHGgnOT6q69VAFn3Uopn09uTQ2iZn7x9BVm9dR7zKRM2ixB98Rfb6ewhYpawSb5l+CAHU4oHWtXbz4/pNoTCq6lxHVHKea5KBJScIh2zAHlqr+IiEmhIoAtA7o91ZVp4h9yLkRvbwmf8Yq3gBE4aLFYHr11aNz3ehjXz7PYW5KCv/ftnYE3gm4qMQoDAl/lhCXL2Eq1U5DJd7lfnaJNjCQSxdk3IgFcm4E4iOvOk5gL4IybgkJZ4j5kw3+2JmkyVcq9W/CGw1AbILgz9FnZMueHGXdChDQOJ4skwj4YdQ3AQBEIS0+EiViA8XvWKPW3BuZFWoCqALL4fuDXT+gDAqOqeKyvD/+f/P/c630TBAw7q/CEuICP8cG3ieM3Q1VkTfEJwl/0gxhUiPgYqJDKviVyF3RkOpIhjLtSyqZZGBRjLsWSNI29wKfwFPZZNieIXPsCRjKSPUlkIJ4qM+7UREF+f8HVYBhYrno5qNPoeXYS/K0WxEHTfAG8kp90RqsojsiQVMmZlOrivO0nTk8TaFul1m9Bnt3rtb9Ep6ZoOtCctN1dM6Q/dCLIbDAa9SNVh3APc8+ZyXqLpnkFVxUpxkc9q++6NBm0JcWyj3PFQZ9I4Eplcvtr6WyBG9XKrUqLjJqoNSUNT73SBzRoXbZdT6oRtjrNBu0tay2Igqb9J6pQi4araDieDJsSh0WEBuLB9nTVD/IsSFnbPmpEvc6WE9H2j5RPp7UoG607YjGnIhEUEX096FDFKhSPsBpvhrMtk8NnEYVKCfGZ2qqou4yA1es3YnExEiSrfhM/nw/TdJqd3iA/7ZMkc9Qikk4KspmIf2ub2tzLdvGmfLJMus7BtB8ZnwNWfcS+0OQIPBWj/YpliLSUlpQU9k6GpaNIqgmnCUmpypAcoAzjWXanIZvvkrvzcTsTdHYv55ui2cgKNVmvZSwjGKkXKIPFcutr/88zRVrZZ/E0YRHKuG0srakC3KvpmsxykHCoMmaQ1l/V9rpuANFqQHv0FIE/m/vhpZj9HAbiAGSJelq8bQK0eCaCjHiwTwiSeW2sIhSG3cIGXVHqWOmhAvZco6c1LBJwC81fj4qNLj/31ea10YP1pvCw3mCWASkD6EiSTzybezqHCg1Q7ayPK0ME4E00BzURQ1GCFk4sEV5FOR9khQGYB4uZGuuSD5OtHtJOPiTSrCrwn7rceYwghpUL3j7I0Llpe1EGqA6C0U2pPLHLSJvuKhePba8kmixYw6pmq26ZlDGuFo0+ov08RxGBh6Q2LIYW2Tz1AQR6YOMcB2HKuCMEIVm1iFRDSaxybrdFpxUhptoFcxY3MB5R5SqJxynQYYXEnkCYqZMSBLaQcku22yArBjqsAQvlKyJDDEZiIPcIGt8uD9QWxIbAPhAhcPAUCht1j6gCBZgTmzXhFZwTd3Ms5ojH2EJ2vYFGUQw4AaErFvpOtszRhXkZ5epGz0cZ5g1qogAtGjmmAEQ0YPu+v0d9RBYXoqhNaJzZQaKk29Tgq0jWEJFraNKlOLWF8Wz7sbHPAxDLl3mUL/LBGvV8hV9UL+FSA6y61/Cso9SADVicIOQG2LMR1HjI2wToflrkM45hBpIGnxAYDtcJsEKIjD8bJdu+Zo2K+6gFbdifQKv6OfPSjNlKwVPoCOMulnxFr4UdIezoOm37dmqAf52IoavYWPwC/HD40vsmnoBw3IS6OORi67UcZ+5PBRMKgkJ4cRcFBq6C48yMGUEYtMPvUXH1o1Sr4yuP5jPuBdRnMYjVC5o3j5KT10rddh48HIPD1896AXUnFiBhd56QiZObrOSVJqnC2xupD1qdbqvW7Q7IyisJo1sZ+kPE2BdcsxENg233t0FNXUL5CPQOW47nUjA8RCEilCtFcbZGgU4SMwywp1GsNkH5t35qney6I8INcEEP15M/bqXddx0jsOcWYWZ2kTJ3ymvekWa4no4uIqhuKNSVByoYC1q4He67GHh7S7Oz5q+vBFbdul2owwO9h78Ql8U74nUVvHJGaqM3UaiCgbfhoV5NpPHrpF+3ghvTy1XFUAjFsiB+natVxjsBifi8JpJk2mNwyGHq+6pZhom9keMMeES1fiUBiuNXPAg84wGzaRzqMmzTvrI7IBmllNkBnoIDuyyh2ntmJZ1ZdCZ8FMWXYvJwIwwLbwu6fgB4w/v155zzyIZa+ykyCF4/kQCvFR+phFjM/r95ZfdRXyR0lP1WZ7RCeLvyFzzcSI3jSFhVvQgSjw4fNptf8A349S7D7FUB+8L+JR0BGoLp1wNdi2MgQJascmwsX54ZnACcbRYwdtt7KmBgYN8MWw5mrWTs75UeAStsdTcOm6MPsF8Or9YE7QFtU5oi79oRcOf+Yr87BbWWnz8ROzV64VkB8B+8FaKWwMvUYqcL1oOvqW6CkJ1PAD3UGR+gLoYQ+HDPPkwPQ07zhntH11ywBd4D9BY287JHuRf1N5Tu2GI/G56AQ6g6qzfHx2sqpdsyrV+Ss9OCB4RFLVOBpCdP6PbnzcuU/UjACfeum16PB5aHJxIqaWKSB4sn54oPXKMiheaAYzZoAHfq6P9TPQZvOnRSG2E2NMrmUzrQe4dGeeerUiD3/SpcNaPGnfjZVYwmk00WarK/qcrrPSE/UHfDwUPgAXRvPliO5n5Qu6yoOnIUfDJqJh5Yn201pXli6Jbfq/v3C7b3i8LvtymlVR8qApUy0jikGxR4KAuF7KSc9PGNAFuJT1ZFjsSqS+Ee8N7FbvwtrofHoHsHG7+MJFhoXuuwQENRa9KSWc1Wu7ya/YLluj9jlY4DTSQCrXEiafZCnC0D+WsvsMenScV3AroPsejkAui5fJoQs69PtQvVh2M9CUoh3TNqXd4I6p4RVW1y/O3oo8Is2+ErcEmw5KPG5/BFUKbsCwMqW4/P5gCBhXqpBqRDoi6P1FqGek2zRFD+N1qGEGgDsDSA4OC+plsKtWpOeiSyvCpOjuFQqD0yT0qPjBOLKiU5SZJUqIZ+/OFQIuITqd3ccaanXiJxFpCQjAZFrksWRp3JbCVun4hwy36mx6fBIjpLaruLnolY9FemwZ5z3CPO++T9i4h77hfBisHJS7ru7Ga4l2s5VverI7OsOdIFWbbjJd/w2fQY++MKxIPzQtqAmWBSO67Es+mX42FteCtkLddXezfq6clUQQaOOd5xxnX3sIDCetgiV10XE81DXhRhUeNjXrJZJjN4OhQ9RxC/KWbdE0YKC4zAGXV5TSiTVAFpeTaB4nWfKhWROmu2pk/mE24pmhAJpZNNG62jcQRn3XIE1rYte2kT2xmMDFFTJXVVXe1Tu/LSm1s0XTljIEcECi1LE+Bx4F37IZ3lgE6VrSEoxr3viXCCdkBGejC2ZEE9hWEDpC8LtOJX9QnP68M6m+SY6RrY8Estx2MTKMnQtmw0tloGazN4xg2d+mSaowMBSipR/LSKIlzMF0+ukOtyH33KXVjgTTtMa+cnCJLEAUrtsJ3fNrp2xZ9ugpblVb1qUQckxgQMp+e4x31F32mVLJEXhm1nG7cRcIRUoAJNaLHE7djoah0zuDf7i/06xinbXuCmpiwke31+Qj6EB7JnrqGwceewvAMDWKXmecbiplsL6ObiAh6G46e3vSLsPDf7IgDvX+RHUhefyhyLf4KX96JbR1QXchpEpvp9GxXiKX9cEFo9/ovvdtOfM+AMjwoPd7y5WaTtxVhrTZ7WA1RvwePWBJf53IXaq1aAVFX3Mk+ARHIv3YvY3wXRtvux/tq25Hm99IPCv8OAL8TBB+o8iP3f/tvN6ArEUXAJxpSx5UcIeuVxLAWdcweIhU60O2DcxsuHwVW6VrznXDy2Q3OF458WeUECm6VfJSus8nosboInCD7eY6tncGrLYPcCisUmz4DraG3xQbhnr3uSqWOP+qK5UP0yCPNodxgPCx8eC59DBmTItPR+Ske5y7xaE5ZhgxPSMIT7CuEqBEjqQR0QQeWDSPtBa4ghb6WOjsOpt3qztXYDkpIkGU7hS10xFtWcb3sAb0UQAwfaoV6O0nrpobZhElQ+pYw8pVjs9dn0iaMjmV739xbFTV8kIJ6xmguIit9cVI7yCYdH7Y4ZuclrqSfD85FTZ6osKq89kd3fGJlEeKtLypHHfDW5YfOlsL/yhQjPEkSUicqNugknnu8JX/vLuG2qkXdxuGLny6rXf9G8m4+8vFxub65svvyRh2O/BlxiLvcGSLYIAtxBq760TorPQ5+5vbVutm4vFsFJtIXH0iX9rnqeGbxyO7od7nABgnb51ZRceqF6vshyo9Snq0nLEoFyu9Ex5anXIjaGvyqKVXBaqPVAOuPcNVosvIa7ln+UNgNYbvt+I39vSj9y5NHBC7Pz2ZGKOePKoT+WrXqWzAPunKrE77t60mTdO2hvMG5Wv6y/8l9ls6NP2RNIgESZfJd42pYkVDEGLcSyivUTf6JrIhGW0ltuhLvuGd01ssqzrQJZBi+oaTuuF46sLCNuSX/ahuTKodwSRvX3KfMTa1HGFUVEA+3eS/JB8UnTQnJZuGPgoTc8QzPbQe563ep5M4vyY43B0mQ8XzXNJpNdVNwbB45lGSIHoaL8oDdsAdm4l3AURivD8JJSNts97DnNtujcMF/HGa86+3vpJ4AICVhhJKpgVD7mXHf/ISBPNC4bPHL+GpCfaf2pG5jTc89mwN6JbQdwn76FyD5tAg+96HHmHamafui9rZTeD4U19wzHb9WVcHfvDvrGtwBhKIyqapTPC/seBxAhY82OmD/VtESp3tApb/mefJxTKOBsSGbX5zPgGURNZSTFZDWUYNhj6wDrOoU7mFZiY6ezfF3R7LbVEFWT/7/yBTW0WJycXu3pmirFHDVnCvH1MNMlRoTwTALLi9B5yM8EUUR+KI2iyojJYAff6SmdFKfcTksHN5yRNEhinVYVrDz8MxhTQqXjHYTKiuenbmFidHdySg3Mhlr5y8f4gTlnDxdQPnCSKYfDEpNypLt7bo4mGS995eKxNJTHr8p2D1R4WptlGU1kN1CaVALIQFpA9pvgt+IHsplRWsgQPtS8LT+PjSOLZ+MdXiZNHvRV4/mKF5P4KnQfBc0VSUss9P+fbF8LYBqc1k5l8QB8T+ZnSlmAR7M/Ep7OfSAPZBLPHISe5oTBbXAmsx+RkTtO1TL0rnuLoFBs8zgJ/JLO8kY7U+eHYEb/w9/gN9PBMLKSzl7QQ71EEw90ntk9cB3+AhPXYYPZs7qtRzBzS2etzXtZsC8kUrkBtx08ozgG+/FYJopIxuEOVM3QuTKIW47PweJoiyHz7IZIwvNor1QH9B3+QBAEySBjaFzKSuXCSgY7EyHz1bAsidV7Xce2p1BI2pQp2Xsfl8k9f6RIyYUcK10/eNJDN3HndGMNRRrW00tdR1Uq9U8XlnEBqubJwrFbwsRa0FtHxcfFTVxj7L4+ghxX5aao1Zdp1ekWLMavW7rMGvVaQYbGEXbTYgmxNN3ig2hsdAoq7qVdGt2jCaEVvw97TJsohTJq8P8rgeknC4hdQIVpzWrvx1Jq2q3u9rKK2lS5+f2NY5lUzm5nNKu01SscPgjLWPXztUSOb/VasW4tSxGpu6wy6pTz6cnqNKDk+ZAjFfYAUksHHLAQ/YFAaNc38gZ4s8tJeFi2lYUEDKdMN7tKzBOFLrdOKW6nS+RyigLobjw/Nw6vIfIGIlqAf1SXFsp1Z183s2sNyugXQAOapLFePvM6reOpvVeGxvzaIwWZd5uA3j36o+/wPY3Zq4IFGnD5LXJYIC01fwk53Nc/duo+S4PWPnCAJzmdFGSJGsXtkwKKI6eDmtpCsPdYd6mGjF+cbtJRuu4Od8GtJNvyEdqMz+nG1J6wtjGCBSY+XITIVs2rEZgR7SLAvUYOHJZFNQ4QTBzbsMJztuMFgw1Wc6IsSR5pLLQsojqQUBRUFqswBVYVcSDDcstS4K9IIKqxCEExg+gwwSi+6087TOlAAq1fyi2LIl2hBUqFK7V0SnqWNwYix1okJWsGh6Npr5infGMB8UvPyqqjSeJRYBCOexZY6hCqtOeMEPO7RRizgBD0S5wOeljZEglOa+NfOvE0MoIxktR3udQwt3jsWcrTZxl9n6gk6EoJVf7yNBK4xFg4KVijJTuZ82BFUkbAPUfxquB0t9u5Bvke30PEozyKPD6SRu64raBvxeHTDZGRGY+hDupknXlzUgjEcpJI6BN3BmkyDV/oDm0vlKdhWjTNL5RHZvn5NAbJOU3zfR49woBEvrJ/YM+xxqDrmdAOunujl02gUitfNIuMZ44rJSxZysKk97CsSMh+fkaSi4FcU1wwTC8woi55/b6wBpt9nMBZeCrQTvNllvVTF+ZLZCnEQ7yMf2F3sG5FcR1fg1xsWtFL5V0aconIio5WqLsgF/0r+ubqS9OQS1RW9OqqdnThomt6wf+8gjZAARHIcIM5OFxthXUMIAHpKSTo+7jByiQSsXPxeOH2pwrzu5iLkMKvdQNUJy/4iy4jGZ5G5y6ScZZK7RK9W55c0SY1ufdVe1LEPHW1em3p+C3++F2bdo+Ib6JPNX8CD2xmNLs77d06lFgszZg57JpFKHGgIoDhO/gPqwjmXu7ajkUwZC/bbhE+gDNGP8bntXmZOLradRQKfLuQIynjhAtLobhtSm2HClOsFgSMFMIAKlVK9WKHq6fGx5RRYUkjpySLLjICTsCYJXwK4VFCn6l7Y36vyMlc2JQR7dsllaI+16UL1FNLECUsMEpFbj+VWDaJbChUanXHMyn2Hd+AoNghItIhnHDbdlSWONwYnqiN+BpGU8YZ1eVfNKlK/JGy+xMEyQ5WFSuZWE9A5TaT1sGJ+fY61bWiaADh/cuK8SWhTv1e3r9UHm9C/3eItFnznldV5NI1VRSrU4ZhigK7m+cm6pMxDqO6t9xwZHzCtdfNqyhWmNKYxbZNr/KqxeHnE9284Hm4FYB0tMG39prXAyNL8iJvmBieMWm9E8XGUcrn8weYBFqX872+xjgWp1SFAtcEGGZap4vyakUk8rSLPvF15EpRWG5ar8AayL98G9it8yDR1Z7bmGyVVnHtXG8TFWZ1MIi14JBJWHGZ0RULeZBoBywGa25rFTtuoTtY5Z3hINaElmaaSy5r6dVJvmi0zKkfjwhdQEGQd2wDz3iEv1ext7NwgeAFlAT1jl3a6PuWgvcqPlfsScIXUBTUO/OE6WVOSgAFVKCj6GQEmmy9sB/XkXC8VFtDKi8HONx7dR6tyv8q6F31zuGQr4eLLNiva0fDfL81VaR/kPw1eK5/0D5ibd+fnAAXeJJ7lotIsQQbu5goIASoNloI7j75MR6IuC54cVfteAvOgu+fDNxdTM1Nin2tVnBZscoDLWil9jQOW5lbhge5BkTbm3aY1DWlSG7o6Ta+1Sq0p7rPXaJioSdGC2RDviPZbVK2jSfZgCz1HNKoT1ybteJQEucEAkhsXzBhNbGcmTRNepaTy3U6bQv/sTS9g8jYjpnXW1lpxIGE57W7xfrJtn0yq6fM1yFlr6XoVMO7P0lA59vq2T0JwCmlWM7z0KjQjnr4WFekIHZ9TSmG7SdXoM5Kg3Q7iUIUShBKR3gVoeFNWV1BMRA4BClDdiAV0irviFdREcqEdZIqx/gEg5SrenHCuJFCaY8uq0aIZduO5wQqRmuTI0r8TcupD7Fjmwz0eFrcevEsO1Sv9nOC7QSLqr6rRqpaPkdUebUU5PnTNjI0RlikKJqAJbi7gNk1nnVd7TjXFGN/kvRhQkmWrRmQ6FJHahHWCQ6q9ezTvO3v3o6ERy4aNy1k6EOL5OzJwGM6PG/FKlg/fX3DdvKJdgwoJBxoxY/943YNYPH6o1h/ErVvxy7MFVZPFY6XklqIVsGh424AeBhay1h9zQYK45pCnNeDDDqLQl3vLfWcUwwVo/xllXF5O6Xcsq1UECv/iGEmePp6zRbDVOBJzjFKM25ZnMq+SNW2ovmRllrbNQbTDdOtx9JI4xGmE5l97NZXkljGQfA0hWmiMi101xGr8lUVRXW33Egch1njTaNqiI7SsKiVRneSmPdRgZBqUdVu65bcEsOXqsSxaItE73sIZ7IAAZJTE+//fvlgz/gmBUGeA/zrx2AaAP77/c2sL6Cz+7U9LWAABhAATceB/v1PhI9MhwXJvoSzWLkZ10l8vdY7AasflW8Pe2LvVv7OHatSDnH5f3fuI8r7kBsgodS9dZy7DYqGLw3fuvMLgT0Jg4DiW+gDwbFm5TTiCH9/occ5F0uzx/KD8zmie2zdrs5tiC+lrVwfU7i3nP4UvuXI88upFsYAzRD9BlKdrWYd5oBZ3DVLNgSIZe1uyuciBJq9G+4TR/YJwlpceKXebYRO464qMAo3EtoCKPhnotDWb3gfMe5j1paQrYQbnCaCU25vTsxKgs2Tx5yNYh2H9cMoiG7d52jFb600HTPleCtja1je2ALHxls9xcIYZmWcgmsJgmegqJ4isYAKmcsVXhtrVZzl0ZQsuKkspdNQdPk6K8U7tpAT67aFePGBzGP1W1D+BGtU4Nz8JISVtOt+cT4wF43zFdK1nGLf8ZsVh7nt6t9AoFs5awSfhMHhq3Dot5EaGOnl9RlLr6itMpX4MuG6kfeX0J6QgSAYqNNT1LxkjC3AzbfTOaO3+o4w7hHnjrNPJ+A4tHnJT0I+ngZK+TMJ+qT4K6Xn9HF5G2aVU/h0fgPhJrEukbPHNMspySFmp4E4m3PJ4cb7YMfXmkC+VJlnZwTsCvBV/jY4AG5k+0Zxg33gBH5XEtR7OYV7Mmwy/BYohvWFgvaqd/LHatwpwFVwNeyn7lMGdjBuD+qeNLYHiFG52y5q5xcOArKYCmT1KCOK9dIffecvFQLq4TEfLBkIrVhgjIIhnJ2HkvUHjKRPh5SLRcUQkvuCAJiMC8CAkiAI4KWEAiKCDyt5IFJfEMiAZRQFUAzCAcd9BCBcRQUC+9GA2g50INK2DL0NmECiHotCBjaBMBxKIrgpLlFLEpUa7RvVoIJVvHpTTfMeJifFwlyzTS3KM+YaFd+qQeQsjsx0tR8gHSoOb57pqJzmzlS1GnMVVJdNZKtxhoYaZlItbdMq02vxSc9YzldgOE/lnlzgyXWmOSIEeENhmtlqd/LcaLeZI9erPCMjV5dOb5JkacoTHpV5Nu9bYrZc2GyOPKP0+So52NjZhX57PcqphEKkDJPsyCeJLKFP9Le0YglBKA03me3h2pSc7BzCKRk4vEpKR1hm6EpyXcqm2abizGOGzfDj8JWMLKWq1RpxS6GczbSZTdfgIM+YivUqVXlPOVQCNn0ZDZvAfxH6ozmN75csBljCiWBwTLldpumwiY5eBYMXjCoDadqQiZk/i9POOOtcMFI33qGK03kXVLtks1/sFqhHUJhS9S+7osZV4SJEysSXokJAototUa9uXny6LyRJNkOKLm4zecjMMiEMqA1dM9d8CyoH86RXEeDU/dnIo0mLVs2+tNCvsvTKliPXannyLbLEUosVhEKV7/afktMGITJEgXCw3wHb7cANuUoMV+pzlZJFQFSIBtH/gN0ZcMML/2/Y/Ukbvyh1GvbK66ggUUcTLTYmOYWfob6m9pVDVqIj4YhJFz1WBr/5XTwqmlJTRIt12BF/+NNf/vajn+y1D4aggVulzVprrLM8RmWeW2EPckze92HMGPr0+4eSip+tpvpGXCKUWGKNLQGxxxFnAhOU4IQkNGEJT0Qi40pUom2QYL3r7rjhprvFJDZwkKCxBQseexxxxhV3PPHGF38CCYbTUCWcneib6VvszOSmp/pSLsnwWG7Y57ERBuJPHQ65q6ZHB2QKSLN4IHmjwUJZf6q/wqKpgVZkmFDK4SR4xNHqsdG+VWxq6Q6rKT8g2lII1QouxkMDMzZdkwPLaCWK0x4tFXHa6xodGBXpSZCJBHRFQCGCDihoTEFBQLsS6ICCgoLGtLAZGaKTvGIUKkVDnQgsg18xqjrEkOYKEFJzJV9E2TkRKBxu30f++SDpNDFbZbUKKeUl90hPlVHIVZmJ8mWQTLvAa0a5aldWnbeGUJjIzPT9l0KMcPWQvqRXFbIMJkwNDOf73AI6WaVt0ARTqXwmiZxIfgGxn6rcZQeWE4tjY0OZ7JgTq2vzY1PVPjSl06XQ1DKt98bFHk27xSmDCwdin+bPB7XWO12/n5qDgwt7ugsAiNPWIBV/ZitOqdYOdAbKxrRbr1fGyY31l47e/TaFxlKVUSConIScKLny/nT5NQA=', + }, + { + unicodeRange: 'U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF', + woff2: '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', + }, + ], +}; + +export const OPENDYSLEXIC: ReadingFontFace = { + family: 'OpenDyslexic', + weight: '400', + subsets: [ + { + unicodeRange: '', + woff2: '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', + }, + ], +}; diff --git a/src/theme/reading-fonts.ts b/src/theme/reading-fonts.ts new file mode 100644 index 00000000..7c2f4c73 --- /dev/null +++ b/src/theme/reading-fonts.ts @@ -0,0 +1,97 @@ +// The reading fonts on Settings > Accessibility > Font (webmail +// lib/accessibility-settings.ts AppFont, app/accessibility.css, +// lib/mail-reading.ts appFontFamilyName): Atkinson Hyperlegible Next, Lexend +// and OpenDyslexic. As in the webmail the font is the app's text font, and a +// plain-text mail body (which the webmail draws in the app document) uses it +// too; HTML mail keeps the sender's fonts. +// +// The app's text: Android finds the fonts in android/app/src/main/assets/ +// fonts by family name (scripts/build-reading-fonts.py), and the Text patch in +// ./reading-font-text applies the family. iOS needs them registered in the +// app bundle (expo-font's config plugin), which the app doesn't have yet, so +// there the setting only reaches mail bodies. +// +// A mail body renders in a sandboxed WebView, which gets the woff2 files as +// data: URIs (./reading-fonts-data: a few hundred KB of base64 string +// constants, which Hermes keeps in the bytecode's string table rather than +// parsing them at startup). + +import type { AppFont } from '../stores/settings-store'; +import { ATKINSON, LEXEND, OPENDYSLEXIC, type ReadingFontFace } from './reading-fonts-data'; + +export type { AppFont }; + +/** The CSS family name a font is bundled under (webmail appFontFamilyName), or null for the default. */ +export function appFontFamilyName(font: AppFont | null | undefined): string | null { + switch (font) { + case 'atkinson': return 'Atkinson Hyperlegible Next'; + case 'lexend': return 'Lexend'; + case 'opendyslexic': return 'OpenDyslexic'; + default: return null; + } +} + +/** The Android asset family (assets/fonts/.ttf and _bold.ttf). */ +export function appFontAssetFamily(font: AppFont | null | undefined): string | null { + switch (font) { + case 'atkinson': return 'AtkinsonHyperlegibleNext'; + case 'lexend': return 'Lexend'; + case 'opendyslexic': return 'OpenDyslexic'; + default: return null; + } +} + +/** Whether the platform has the fonts for the app's own text. */ +export function uiFontsBundled(platform: string): boolean { + return platform === 'android'; +} + +/** + * The fontFamily the app's text is drawn in: null for the theme font, and + * where the fonts aren't bundled (an unknown family is an error on iOS). + */ +export function uiFontFamily(font: AppFont | null | undefined, platform: string): string | null { + return uiFontsBundled(platform) ? appFontAssetFamily(font) : null; +} + +/** The mail body's own font stack (lib/email-html). */ +export const MAIL_SYSTEM_FONT_STACK = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif'; + +/** + * font-family for a mail body: the reading font first (it covers Latin + * script; other scripts fall through to the system stack, as in the webmail). + */ +export function mailFontStack(font: AppFont | null | undefined): string { + const family = appFontFamilyName(font); + return family ? `"${family}", ${MAIL_SYSTEM_FONT_STACK}` : MAIL_SYSTEM_FONT_STACK; +} + +function faceFor(font: AppFont): ReadingFontFace | null { + switch (font) { + case 'atkinson': return ATKINSON; + case 'lexend': return LEXEND; + case 'opendyslexic': return OPENDYSLEXIC; + default: return null; + } +} + +/** + * The @font-face rules a mail document needs for the font, with the fonts as + * data: URIs (the page's CSP allows font-src data: in every mode). Empty for + * the default font. + */ +export function readingFontFaceCss(font: AppFont | null | undefined): string { + if (!font || font === 'default') return ''; + const face = faceFor(font); + if (!face) return ''; + return face.subsets.map((subset) => [ + '@font-face {', + `font-family: "${face.family}";`, + 'font-style: normal;', + 'font-display: swap;', + `font-weight: ${face.weight};`, + `src: url("data:font/woff2;base64,${subset.woff2}") format("woff2");`, + subset.unicodeRange ? `unicode-range: ${subset.unicodeRange};` : '', + '}', + ].filter(Boolean).join(' ')).join('\n'); +}