diff --git a/.github/workflows/composer-normalize.yml b/.github/workflows/composer-normalize.yml
new file mode 100644
index 0000000..fb8b369
--- /dev/null
+++ b/.github/workflows/composer-normalize.yml
@@ -0,0 +1,26 @@
+name: normalize composer.json
+
+on:
+  push:
+    paths:
+      - 'composer.json'
+
+jobs:
+  normalize:
+    timeout-minutes: 1
+    runs-on: ubuntu-latest
+    steps:
+      - name: Git checkout
+        uses: actions/checkout@v2
+
+      - name: Validate Composer configuration
+        run: composer validate --strict
+
+      - name: Normalize composer.json
+        run: |
+          composer global require ergebnis/composer-normalize
+          composer normalize --indent-style=space --indent-size=4 --no-check-lock --no-update-lock --no-interaction --ansi
+
+      - uses: stefanzweifel/git-auto-commit-action@v4.0.0
+        with:
+          commit_message: normalize composer.json
diff --git a/.github/workflows/markdown-normalize.yml b/.github/workflows/markdown-normalize.yml
new file mode 100644
index 0000000..95e9fa4
--- /dev/null
+++ b/.github/workflows/markdown-normalize.yml
@@ -0,0 +1,19 @@
+name: normalize markdown
+
+on:
+  push:
+    paths:
+      - '*.md'
+
+jobs:
+  normalize:
+    timeout-minutes: 1
+    runs-on: ubuntu-latest
+    steps:
+      - name: Git checkout
+        uses: actions/checkout@v2
+
+      - name: Prettify markdown
+        uses: creyD/prettier_action@v3.0
+        with:
+            prettier_options: --write **/*.md
diff --git a/.github/workflows/run-tests.yml b/.github/workflows/run-tests.yml
new file mode 100644
index 0000000..0867f58
--- /dev/null
+++ b/.github/workflows/run-tests.yml
@@ -0,0 +1,52 @@
+name: run-tests
+
+on:
+  push:
+  schedule:
+    - cron: '0 0 * * *'
+
+jobs:
+  test:
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: true
+      matrix:
+        php: [8.0]
+        laravel: [8.*]
+        dependency-version: [prefer-lowest, prefer-stable]
+        include:
+          - laravel: 8.*
+            testbench: 6.*
+
+    name: P${{ matrix.php }} - L${{ matrix.laravel }} - ${{ matrix.dependency-version }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Cache dependencies
+        uses: actions/cache@v2
+        with:
+          path: ~/.composer/cache/files
+          key: dependencies-laravel-${{ matrix.laravel }}-php-${{ matrix.php }}-composer-${{ hashFiles('composer.json') }}
+          keys: |
+            dependencies-laravel-${{ matrix.laravel }}-php-${{ matrix.php }}-composer-
+            dependencies-laravel-${{ matrix.laravel }}-php-
+            dependencies-laravel-
+
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: ${{ matrix.php }}
+          extensions: dom, curl, libxml, mbstring, zip
+
+      - name: Install dependencies
+        run: |
+          composer require "laravel/framework:${{ matrix.laravel }}" "orchestra/testbench:${{ matrix.testbench }}" --no-interaction --no-update
+          composer update --${{ matrix.dependency-version }} --prefer-dist --no-interaction --no-suggest
+
+      - name: Execute tests
+        run: vendor/bin/phpunit
diff --git a/.github/workflows/stale-issues.yml b/.github/workflows/stale-issues.yml
new file mode 100644
index 0000000..bdc7d06
--- /dev/null
+++ b/.github/workflows/stale-issues.yml
@@ -0,0 +1,57 @@
+name: "Close stale issues"
+on:
+  schedule:
+  - cron: "0 0 * * *"
+
+jobs:
+  default:
+    timeout-minutes: 1
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/stale@v2.0.0
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-message: 'This issue is stale because it has been open 21 days with no activity. Remove stale label or comment or this will be closed in 7 days'
+        stale-issue-label: 'stale'
+        exempt-issue-labels: 'bug,enhancement,documentation,help wanted,next release,next major release'
+        days-before-stale: 21
+        days-before-close: 7
+
+  invalid:
+    timeout-minutes: 1
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/stale@v2.0.0
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-message: 'This issue is stale because it has been labeled as invalid.'
+        stale-issue-label: 'stale'
+        only-labels: 'invalid'
+        days-before-stale: 1
+        days-before-close: 2
+
+  duplicate:
+    timeout-minutes: 1
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/stale@v2.0.0
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-message: 'This issue is stale because it has been labeled as duplicate.'
+        stale-issue-label: 'stale'
+        only-labels: 'duplicate'
+        days-before-stale: 1
+        days-before-close: 2
+
+  wontfix:
+    timeout-minutes: 1
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/stale@v2.0.0
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-message: 'This issue is stale because it has been labeled as wontfix.'
+        stale-issue-label: 'stale'
+        only-labels: 'wontfix'
+        days-before-stale: 1
+        days-before-close: 2
diff --git a/README.md b/README.md
index 902a01a..eb6f483 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,34 @@
 # Laravel vCard
+
+## Usage
+
+```php 
+Vcard::make()
+    ->fullName('John Adam Smith')
+    ->name('Smith', 'John', 'Adam')
+    ->email('john.smith@mail.com')
+    ->email('john.smith@company.com', [Email::WORK, Email::INTERNET])
+    ->tel('+1234567890', [Tel::HOME, Tel::VOICE])
+    ->tel('+0987654321', [Tel::WORK, Tel::VOICE])
+    ->tel('+0123456789', [Tel::CELL, Tel::VOICE])
+    ->url('https://johnsmith.com')
+    ->url('https://company.com')
+    ->bday(Carbon::parse('1990-06-24'));
+```
+
+```vcard
+BEGIN:VCARD
+VERSION:4.0
+FN;CHARSET=UTF-8:John Adam Smith
+N;CHARSET=UTF-8:Smith;John;Adam;;
+EMAIL;TYPE=INTERNET:john.smith@mail.com
+EMAIL;TYPE=WORK;TYPE=INTERNET:john.smith@company.com
+TEL;TYPE=HOME;TYPE=VOICE:+1234567890
+TEL;TYPE=WORK;TYPE=VOICE:+0987654321
+TEL;TYPE=CELL;TYPE=VOICE:+0123456789
+URL:https://johnsmith.com
+URL:https://company.com
+BDAY:1990-06-24
+REV:2021-02-25T10:30:45.000000Z
+END:VCARD
+```
diff --git a/composer.json b/composer.json
index 98fbb2f..830c957 100644
--- a/composer.json
+++ b/composer.json
@@ -15,12 +15,14 @@
     ],
     "require": {
         "php": "^8.0",
-        "illuminate/contracts": "^7.0 || ^8.0",
-        "illuminate/http": "^7.0 || ^8.0",
-        "illuminate/support": "^7.0 || ^8.0",
-        "illuminate/database": "^7.0 || ^8.0"
+        "illuminate/contracts": "^8.0",
+        "illuminate/http": "^8.0",
+        "illuminate/support": "^8.0"
     },
     "require-dev": {
+        "orchestra/testbench": "^6.0",
+        "phpunit/phpunit": "^9.3",
+        "spatie/phpunit-snapshot-assertions": "^4.2"
     },
     "config": {
         "sort-packages": true
diff --git a/phpunit.xml.dist b/phpunit.xml.dist
new file mode 100644
index 0000000..8f2f4fe
--- /dev/null
+++ b/phpunit.xml.dist
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd"
+    bootstrap="vendor/autoload.php" backupGlobals="false"
+    backupStaticAttributes="false"
+    colors="true"
+    verbose="true"
+    convertErrorsToExceptions="true"
+    convertNoticesToExceptions="true"
+    convertWarningsToExceptions="true"
+    processIsolation="false"
+    stopOnFailure="false"
+>
+    <testsuites>
+        <testsuite name="Test Suite">
+            <directory suffix="Test.php">./tests/</directory>
+        </testsuite>
+    </testsuites>
+    <coverage>
+        <include>
+            <directory suffix=".php">./src/</directory>
+        </include>
+    </coverage>
+    <php>
+        <env name="APP_ENV" value="testing" force="true"/>
+    </php>
+</phpunit>
diff --git a/src/Properties/Bday.php b/src/Properties/Bday.php
new file mode 100644
index 0000000..d933415
--- /dev/null
+++ b/src/Properties/Bday.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Astrotomic\Vcard\Properties;
+
+use DateTimeInterface;
+
+class Bday extends Property
+{
+    protected DateTimeInterface $bday;
+
+    public function __construct(DateTimeInterface $bday)
+    {
+        $this->bday = $bday;
+    }
+
+    public function __toString(): string
+    {
+        return "BDAY:{$this->bday->format('Y-m-d')}";
+    }
+}
diff --git a/src/Properties/Email.php b/src/Properties/Email.php
new file mode 100644
index 0000000..851accf
--- /dev/null
+++ b/src/Properties/Email.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Astrotomic\Vcard\Properties;
+
+class Email extends Property
+{
+    public const INTERNET = 'INTERNET';
+    public const WORK = 'WORK';
+
+    protected string $email;
+
+    /** @var string[] */
+    protected array $types;
+
+    public function __construct(string $email, array $types)
+    {
+        $this->email = $email;
+        $this->types = $types;
+    }
+
+    public function __toString(): string
+    {
+        $types = implode(';', array_map(
+            fn(string $type): string => "TYPE={$type}",
+            $this->types
+        ));
+
+        return "EMAIL;{$types}:{$this->email}";
+    }
+}
diff --git a/src/Properties/Gender.php b/src/Properties/Gender.php
new file mode 100644
index 0000000..6f9b20a
--- /dev/null
+++ b/src/Properties/Gender.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Astrotomic\Vcard\Properties;
+
+class Gender extends Property
+{
+    public const FEMALE = 'F';
+    public const MALE = 'M';
+
+    protected string $gender;
+
+    public function __construct(string $gender)
+    {
+        $this->gender = $gender;
+    }
+
+    public function __toString(): string
+    {
+        return "GENDER:{$this->gender}";
+    }
+}
diff --git a/src/Properties/Kind.php b/src/Properties/Kind.php
new file mode 100644
index 0000000..c551e0e
--- /dev/null
+++ b/src/Properties/Kind.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace Astrotomic\Vcard\Properties;
+
+class Kind extends Property
+{
+    public const INDIVIDUAL = 'individual';
+    public const ORGANIZATION = 'organization';
+    public const GROUP = 'group';
+
+    protected string $kind;
+
+    public function __construct(string $kind)
+    {
+        $this->kind = $kind;
+    }
+
+    public function __toString(): string
+    {
+        return "KIND:{$this->kind}";
+    }
+}
diff --git a/src/Properties/Photo.php b/src/Properties/Photo.php
new file mode 100644
index 0000000..304269a
--- /dev/null
+++ b/src/Properties/Photo.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace Astrotomic\Vcard\Properties;
+
+use Illuminate\Support\Str;
+use InvalidArgumentException;
+
+class Photo extends Property
+{
+    protected string $photo;
+
+    public function __construct(string $photo)
+    {
+        if(!Str::startsWith($photo, 'data:image/jpeg;base64,')) {
+            throw new InvalidArgumentException('Photo property has to be a jpeg base64 data-uri.');
+        }
+
+        $this->photo = $photo;
+    }
+
+    public function __toString(): string
+    {
+        return "PHOTO:{$this->photo}";
+    }
+}
diff --git a/src/Properties/Property.php b/src/Properties/Property.php
new file mode 100644
index 0000000..856a574
--- /dev/null
+++ b/src/Properties/Property.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Astrotomic\Vcard\Properties;
+
+abstract class Property
+{
+    abstract public function __toString(): string;
+}
diff --git a/src/Properties/Tel.php b/src/Properties/Tel.php
new file mode 100644
index 0000000..7d91643
--- /dev/null
+++ b/src/Properties/Tel.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Astrotomic\Vcard\Properties;
+
+class Tel extends Property
+{
+    public const VOICE = 'VOICE';
+    public const WORK = 'WORK';
+    public const HOME = 'HOME';
+    public const CELL = 'CELL';
+
+    protected string $number;
+
+    /** @var string[] */
+    protected array $types;
+
+    public function __construct(string $number, array $types)
+    {
+        $this->number = $number;
+        $this->types = $types;
+    }
+
+    public function __toString(): string
+    {
+        $types = implode(';', array_map(
+            fn(string $type): string => "TYPE={$type}",
+            $this->types
+        ));
+
+        return "TEL;{$types}:{$this->number}";
+    }
+}
diff --git a/src/Properties/Url.php b/src/Properties/Url.php
new file mode 100644
index 0000000..84e2a7e
--- /dev/null
+++ b/src/Properties/Url.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Astrotomic\Vcard\Properties;
+
+class Url extends Property
+{
+    protected string $url;
+
+    public function __construct(string $url)
+    {
+        $this->url = $url;
+    }
+
+    public function __toString(): string
+    {
+        return "URL:{$this->url}";
+    }
+}
diff --git a/src/Vcard.php b/src/Vcard.php
index f07614b..76b12a8 100644
--- a/src/Vcard.php
+++ b/src/Vcard.php
@@ -2,42 +2,124 @@
 
 namespace Astrotomic\Vcard;
 
+use Astrotomic\Vcard\Properties\Bday;
+use Astrotomic\Vcard\Properties\Email;
+use Astrotomic\Vcard\Properties\Gender;
+use Astrotomic\Vcard\Properties\Kind;
+use Astrotomic\Vcard\Properties\Photo;
+use Astrotomic\Vcard\Properties\Tel;
+use Astrotomic\Vcard\Properties\Url;
+use Carbon\Carbon;
+use DateTimeInterface;
 use Illuminate\Contracts\Support\Responsable;
 use Illuminate\Http\Response;
 use Illuminate\Support\Str;
 use Stringable;
 use Symfony\Component\HttpFoundation\HeaderUtils;
 
-class Vcard implements Stringable, Responsable
+class Vcard implements Responsable, Stringable
 {
-    protected string $name;
-    protected ?string $email = null;
-    protected ?string $phone = null;
+    protected ?string $fullName = null;
+    protected ?string $namePrefix = null;
+    protected ?string $firstName = null;
+    protected ?string $middleName = null;
+    protected ?string $lastName = null;
+    protected ?string $nameSuffix = null;
 
-    public static function make(string $name): self
+    protected array $properties = [];
+
+    public static function make(): self
     {
-        return new static($name);
+        return new static();
     }
 
-    public function __construct(string $name)
+    public function fullName(?string $fullName): self
     {
-        $this->name = $name;
+        $this->fullName = $fullName;
+
+        return $this;
+    }
+
+    public function name(
+        ?string $lastName = null,
+        ?string $firstName = null,
+        ?string $middleName = null,
+        ?string $prefix = null,
+        ?string $suffix = null
+    ): self
+    {
+        $this->namePrefix = $prefix;
+        $this->firstName = $firstName;
+        $this->middleName = $middleName;
+        $this->lastName = $lastName;
+        $this->nameSuffix = $suffix;
+
+        return $this;
+    }
+
+    public function email(string $email, array $types = [Email::INTERNET]): self
+    {
+        $this->properties[] = new Email($email, $types);
+
+        return $this;
     }
 
-    public function email(?string $email): self
+    public function tel(string $number, array $types = [Tel::VOICE]): self
     {
-        $this->email = $email;
+        $this->properties[] = new Tel($number, $types);
 
         return $this;
     }
 
-    public function phone(?string $phone): self
+    public function url(string $url): self
     {
-        $this->phone = $phone;
+        $this->properties[] = new Url($url);
 
         return $this;
     }
 
+    public function photo(string $photo): self
+    {
+        $this->properties[] = new Photo($photo);
+
+        return $this;
+    }
+
+    public function bday(DateTimeInterface $bday): self
+    {
+        $this->properties[] = new Bday($bday);
+
+        return $this;
+    }
+
+    public function kind(string $kind): self
+    {
+        $this->properties[] = new Kind($kind);
+
+        return $this;
+    }
+
+    public function gender(string $gender): self
+    {
+        $this->properties[] = new Gender($gender);
+
+        return $this;
+    }
+
+    public function __toString(): string
+    {
+        return collect([
+            'BEGIN:VCARD',
+            'VERSION:4.0',
+            "FN;CHARSET=UTF-8:{$this->getFullName()}",
+            $this->hasNameParts() ? "N;CHARSET=UTF-8:{$this->lastName};{$this->firstName};{$this->middleName};{$this->namePrefix};{$this->nameSuffix}" : null,
+            array_map('strval', $this->properties),
+            sprintf('REV:%s', Carbon::now()->toISOString()),
+            'PRODID:-//Astrotomic vCard',
+            'END:VCARD',
+        ])->flatten()->filter()->implode(PHP_EOL);
+    }
+
     public function toResponse($request)
     {
         $content = strval($this);
@@ -56,15 +138,25 @@ public function toResponse($request)
         ]);
     }
 
-    public function __toString(): string
+    protected function getFullName(): string
     {
-        return collect([
-            'BEGIN:VCARD',
-            'VERSION:4.0',
-            sprintf('FN:%s', $this->name),
-            $this->email ? sprintf('EMAIL:%s', $this->email) : null,
-            $this->phone ? sprintf('TEL;TYPE=VOICE:%s', $this->phone) : null,
-            'END:VCARD',
-        ])->filter()->implode(PHP_EOL);
+        return $this->fullName ?? collect([
+            $this->namePrefix,
+            $this->firstName,
+            $this->middleName,
+            $this->lastName,
+            $this->nameSuffix,
+        ])->filter()->implode(' ');
+    }
+
+    protected function hasNameParts(): bool
+    {
+        return !empty(array_filter([
+            $this->namePrefix,
+            $this->firstName,
+            $this->middleName,
+            $this->lastName,
+            $this->nameSuffix,
+        ]));
     }
 }
diff --git a/tests/TestCase.php b/tests/TestCase.php
new file mode 100644
index 0000000..e6adab4
--- /dev/null
+++ b/tests/TestCase.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Astrotomic\Vcard\Tests;
+
+use Astrotomic\Vcard\Tests\Utils\VcardDriver;
+use Astrotomic\Vcard\Vcard;
+use Carbon\Carbon;
+use Orchestra\Testbench\TestCase as OrchestraTestCase;
+use Spatie\Snapshots\MatchesSnapshots;
+
+abstract class TestCase extends OrchestraTestCase
+{
+    use MatchesSnapshots;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        Carbon::setTestNow(Carbon::parse('2021-02-25 10:30:45'));
+    }
+
+    public function assertMatchesVcardSnapshot(Vcard $actual): void
+    {
+        $vcard = strval($actual);
+
+        $this->assertStringStartsWith('BEGIN:VCARD', $vcard);
+        $this->assertStringEndsWith('END:VCARD', $vcard);
+
+        $this->assertMatchesSnapshot($actual, new VcardDriver());
+    }
+}
diff --git a/tests/Utils/VcardDriver.php b/tests/Utils/VcardDriver.php
new file mode 100644
index 0000000..47e772a
--- /dev/null
+++ b/tests/Utils/VcardDriver.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Astrotomic\Vcard\Tests\Utils;
+
+use Spatie\Snapshots\Drivers\TextDriver;
+
+class VcardDriver extends TextDriver
+{
+    public function extension(): string
+    {
+        return 'vcf';
+    }
+}
diff --git a/tests/VcardTest.php b/tests/VcardTest.php
new file mode 100644
index 0000000..e8a0b1f
--- /dev/null
+++ b/tests/VcardTest.php
@@ -0,0 +1,136 @@
+<?php
+
+namespace Astrotomic\Vcard\Tests;
+
+use Astrotomic\Vcard\Properties\Email;
+use Astrotomic\Vcard\Properties\Gender;
+use Astrotomic\Vcard\Properties\Kind;
+use Astrotomic\Vcard\Properties\Tel;
+use Astrotomic\Vcard\Vcard;
+use Carbon\Carbon;
+
+final class VcardTest extends TestCase
+{
+    /** @test */
+    public function vcard_full(): void
+    {
+        $this->assertMatchesVcardSnapshot(
+            Vcard::make()
+                ->kind(Kind::INDIVIDUAL)
+                ->gender(Gender::MALE)
+                ->fullName('John Adam Smith')
+                ->name('Smith', 'John', 'Adam')
+                ->email('john.smith@mail.com')
+                ->email('john.smith@company.com', [Email::WORK, Email::INTERNET])
+                ->tel('+1234567890', [Tel::HOME, Tel::VOICE])
+                ->tel('+0987654321', [Tel::WORK, Tel::VOICE])
+                ->tel('+0123456789', [Tel::CELL, Tel::VOICE])
+                ->url('https://johnsmith.com')
+                ->url('https://company.com')
+                ->bday(Carbon::parse('1990-06-24'))
+                ->photo('data:image/jpeg;base64,'.base64_encode(file_get_contents(__DIR__.'/stubs/photo.jpg')))
+        );
+    }
+
+    /** @test */
+    public function vcard_with_fn(): void
+    {
+        $this->assertMatchesVcardSnapshot(
+            Vcard::make()
+                ->fullName('John Adam Smith')
+        );
+    }
+
+    /** @test */
+    public function vcard_with_fn_n(): void
+    {
+        $this->assertMatchesVcardSnapshot(
+            Vcard::make()
+                ->fullName('John Adam Smith')
+                ->name('Smith', 'John', 'Adam')
+        );
+    }
+
+    /** @test */
+    public function vcard_with_fn_email(): void
+    {
+        $this->assertMatchesVcardSnapshot(
+            Vcard::make()
+                ->fullName('John Adam Smith')
+                ->email('john.smith@mail.com')
+        );
+    }
+
+    /** @test */
+    public function vcard_with_fn_email_workEmail(): void
+    {
+        $this->assertMatchesVcardSnapshot(
+            Vcard::make()
+                ->fullName('John Adam Smith')
+                ->email('john.smith@mail.com')
+                ->email('john.smith@company.com', [Email::WORK, Email::INTERNET])
+        );
+    }
+
+    /** @test */
+    public function vcard_with_fn_tel(): void
+    {
+        $this->assertMatchesVcardSnapshot(
+            Vcard::make()
+                ->fullName('John Adam Smith')
+                ->tel('+1234567890')
+        );
+    }
+
+    /** @test */
+    public function vcard_with_fn_tel_workTel(): void
+    {
+        $this->assertMatchesVcardSnapshot(
+            Vcard::make()
+                ->fullName('John Adam Smith')
+                ->tel('+1234567890')
+                ->tel('+0987654321', [Tel::WORK, Tel::VOICE])
+        );
+    }
+
+    /** @test */
+    public function vcard_with_fn_url(): void
+    {
+        $this->assertMatchesVcardSnapshot(
+            Vcard::make()
+                ->fullName('John Adam Smith')
+                ->url('https://johnsmith.com')
+        );
+    }
+
+    /** @test */
+    public function vcard_with_fn_urls(): void
+    {
+        $this->assertMatchesVcardSnapshot(
+            Vcard::make()
+                ->fullName('John Adam Smith')
+                ->url('https://johnsmith.com')
+                ->url('https://company.com')
+        );
+    }
+
+    /** @test */
+    public function vcard_with_fn_bday(): void
+    {
+        $this->assertMatchesVcardSnapshot(
+            Vcard::make()
+                ->fullName('John Adam Smith')
+                ->bday(Carbon::parse('1990-06-24'))
+        );
+    }
+
+    /** @test */
+    public function vcard_with_fn_photo(): void
+    {
+        $this->assertMatchesVcardSnapshot(
+            Vcard::make()
+                ->fullName('John Adam Smith')
+                ->photo('data:image/jpeg;base64,'.base64_encode(file_get_contents(__DIR__.'/stubs/photo.jpg')))
+        );
+    }
+}
diff --git a/tests/stubs/photo.jpg b/tests/stubs/photo.jpg
new file mode 100644
index 0000000..33c192f
Binary files /dev/null and b/tests/stubs/photo.jpg differ
diff --git a/tests/vcards/manuela_kuster.vcf b/tests/vcards/manuela_kuster.vcf
new file mode 100644
index 0000000..1264b2e
--- /dev/null
+++ b/tests/vcards/manuela_kuster.vcf
@@ -0,0 +1,10 @@
+BEGIN:VCARD
+VERSION:4.0
+N;CHARSET=UTF-8:Kuster;Manuela;;Dr.;
+FN;CHARSET=UTF-8:Dr. Manuela Kuster
+ORG;CHARSET=UTF-8:Crown Auto Parts
+TITLE;CHARSET=UTF-8:Mechanical inspector
+URL;PRIVATE:https://HalloweenHomes.de
+TEL;type=VOICE;HOME:08137 23 86 93
+ADR;CHARSET=UTF-8;HOME:;;Büsingstrasse 48;Reichertshausen;;85291;Deutschland
+END:VCARD
diff --git a/tests/vcards/martina_ebersbach.vcf b/tests/vcards/martina_ebersbach.vcf
new file mode 100644
index 0000000..11b824c
--- /dev/null
+++ b/tests/vcards/martina_ebersbach.vcf
@@ -0,0 +1,9 @@
+BEGIN:VCARD
+VERSION:4.0
+FN:Martina Ebersbach
+N:Ebersbach;Martina;;;
+EMAIL;TYPE=INTERNET;TYPE=WORK:MartinaEbersbach@gmail.com
+TEL;TYPE=CELL:+4940118212
+URL:https\://twitter.com/Wele1983
+URL:https\://linkedin.com/in/Wele1983
+END:VCARD
diff --git a/tests/vcards/michelle_kastner.vcf b/tests/vcards/michelle_kastner.vcf
new file mode 100644
index 0000000..3390763
--- /dev/null
+++ b/tests/vcards/michelle_kastner.vcf
@@ -0,0 +1,10 @@
+BEGIN:VCARD
+VERSION:4.0
+FN:Michelle Kastner
+N:Kastner;Michelle;;;
+EMAIL;TYPE=INTERNET;TYPE=WORK:MichelleKastner@web.de
+EMAIL;TYPE=INTERNET;TYPE=WORK:Renturem@example.de
+TEL;TYPE=CELL:+497733141496
+BDAY:1965-09-04
+PHOTO:data:image/jpeg;base64,/9j/4AAQSkZJRgABAgAAAQABAAD//gARTGF2YzU4LjExNy4xMDEA/9sAQwAIBAQEBAQFBQUFBQUGBgYGBgYGBgYGBgYGBwcHCAgIBwcHBgYHBwgICAgJCQkICAgICQkKCgoMDAsLDg4OEREU/8QAqgAAAQUBAQEAAAAAAAAAAAAAAwUGAAQCAQcIAQEBAQEBAQEAAAAAAAAAAAAAAQIDBAUGEAABAwIEAwUGBAQFBAIBBAMBAgMRBAAhMQUSQWFRBoFxIhOR8KGxBzJC0cEU4VLxIzNiFQhyFiSigkOSNKW11NVElUURAAICAgEDAgUDAwQDAQEBAAABAhEhAzFBBBJRYTJxIhOBkQWhsRRC0TPwI1Lh8cEVYv/AABEIAgACAAMBEgACEgADEgD/2gAMAwEAAhEDEQA/APf7lgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS+KUEpJPCwAED6ldr2ex3Zetrtw/cempFMjipw4DuTmb8b/wBw/a6tre0rmnep/wBvTAAIBw3Rn32ZGyrksVwecdotXrdZ1Oorat5bzrzilrKiTBJyH6XUqapDe5JhcxyI77gLZSq+4oK2ziJnne32GxtWN3mxxzHKwMloqOKUFyoKjocPjcq3XHVBIyHARHtuk4IVuyDa8VbHADwCsMORysfkbREDd1BuggNqStRQjKMDjnzvKXHHiE/E3AAWqYssr+0LXHiPne6dpLcDaZIErOZ/4jgLMjt/IseTSVGmzUPDziEpnITie+yOLLaYiBjABxPj+d2yEp37FI6pQY3HypScE8VTkcPlfErC9vqIwyw/K6A/Ujf5AQp0BUcZ42ZSm8kgDn/SwJVlwwXqebypwy8L2lwtrkEYZp25g87BjN4Qr3K6A84VK+2DZVtNqWpfnTxESZ+QsCUw0V1oWkboJg+/GzOK2t72grElKxz64ZSDdIQANy5ClJME+GF99ZWwhJcIOaTdIAQ05ncncOMHIg3xKFrO4b45nL22sAU2TZ/bVuJkGYF8eWsKxkEDMZK7roABLBgKBUUk94N9BjA4oVn1FgAdO88ykA+MXo72nARiCnuUDx8bAAJTvoWP7ww6jP8ApYWCNpBkEZDqbhS36kLdVSNpQHWF7yIJTmbG08hKsF7VCMDx+Fxe4K0ugVI59yMTxgzmDwNkCNziliSCZUIwmxG6CyipdTQpw4WgcD9pHUxgSbuUdOlxZKskyek5Rbyoy3QcTSRSqqUMkhKsE5n8ru1TClKWCAAE8RmSb2pWYi6MeJtrkSkqWFQkHGc+nC7wp0tglaZX+ED8I4bvyvZLzRg0U9pDkHgMeVmqFNtg/wA3QYm6DBptEDjTaRDZVhmcSLrBwrJAJSBw62BE6IZd9Qk4/inO9kZACSOJ43SAAgpYBTBn4912VBaEBflJIGSRKbpAASNqxPnScPDxvodwEkx+ID53QAEL2yELggjPiLCpvYqQsRw3QbhS3ggVtG4zJ2zjjfAN4kKyHn4YZA3LABx915TxVt8qRASOA/O4tXpqHl80Z5gzYBuwFonNi8sVTG78J6GwoCY3HcDgcevHCzBY8gPVbCv1FTwnbj8eFiUpwlP4kdE9D1sr4BWlyR3/APDaitxC17YSAE7Qchw8fGxqeLBGBE5g4g2Bfisl/g4z6p2+nJJUAPc4XtLQWQUkokynHDOzAV9CpY5DpCXikkFKhgvpIy/jfWoTLa4QrHjJJ7srAUrKjbp9FSUASJlWPXmLw7sDx2qWSUiJ4YXOcgews6VlDagBhzOMcrCp/cZXhBOYz/hbktVwKJfrg6vbuC0E4cOIMXumU0UOKUsR8R8LEeQ0FWS/pGoP03nZWUuDHckkL9oxIPEXRbUphQKVBQnMZRd4HIWUOMnuv0Z+o2vKXS0tUpNVRDaHHd25xpKjASrIpIVmDMgYX5JoHaOt0ypTUUrvpqEbkSdi4M4gEcRI6HK5GWeR4/8A0Tjjgqkj7DQoLQlQMhQBB5G2P9F/qcx210w0NSsJ1GkQkqScPVby3J6xxvZIyvD5ORqcKyuGPm5dBkEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWAAh/UDtZTdjuzlVqLpSVhOxlsmPUcUPKnw4k9L8h/3J9s33+0H+kMvA09K0AUj+dX3z4GLMy+SpWagkl8zzjtXrr+uanUVta5KnllalZhMnAJzwHS0Kud9RU74TxGZ+NgXoHx6HKhUL3oIXtJ84MiwpPpEhPSJ5nh0mwF/kmPmYeeUobSsnHwzvK0FKcRCpy42BCtUQpKk+RPfZWXNpA27kgY87pCCgQpVoIUrFXS7iENnFIiwBpIGw1jKhjicMvG7LbSkJUc4GMicTlYnIiuoMFJTBGPTpc34+YFWOV0nGC8A4Sn71GTnjwvK17l7sNpBPPAfpdAJJs0HFstleavwp4CeJugp5S1LVuiesn4WAboyFdqXDhPmxywvLZea+0QFfjIk/wHhYFshpluqWoFG4QMZxF7QpPmJUpRwOBKQOoi2AXIRYIfCIUcug42LBRKlLW2FQFQJSCOIFgWN0TPJ3a5BUk/biRy/OxrDgIUHStPWQPaLWCtEphFrplthxLgSsGFJ2kZ3WUjH7seEcRbIH0igjgUUDaZ8LClDqJxjpjIsA/mQ2ULGElQ55g/lZGlpKN+BM44YeywBpL3/gC40SYVCT8O+7aW21SVRBPT5XTLbMmvFFZLSlN4TKMSOXK7yWkpCVpIPBSSPw3TLbM0bKKqfzY4CTj0N3fSAlJRMqjKZnnwvVmW3RmmaKrFIt1WGIzk3dZDbJg4Rhyx5fK9N0jLyZUcmlg5TAGERlh4gH53c0+iS84VNrHlJwMggRPSMeHOzTJJ0iosY2Ep6N1ZQhI8qUlRJwnhjxtRiWE7M1DDkAnElUcT7bjM+RUjXiJdafMYG6JAGQgDE+BN41GN5Skn5TzvSETDRZFJx5W4+aSc/G+KbV+Hnje4oiaMNloCqXSY+6bi6dwyNxvRE0zDyVxOrZZAClOJ3QZgcRw7utjSyEDdugnCLoIPE6HUiBlhGUmOt5DzbaT5dyifKSMIHKwIXB1TfqCd6hwjgbyX3HT5sMcsBA7rAdCZIUNt5SnkrjewHNpjafGCqeFgAVlNqzAMD2i7CAr7SoE8fyukAoAkKGKhiRhdhW0+JH4ch7bpAUCnekhWfI8LIpTzjexDm4DGCQMvEWBAaaAUratUYTjiI+c87BFSid4OHvhYAZCJMOFIUqJwgRPxvrEu8YiD4RYFshKtKikDzQJIxvbrkgYYiZ5g2BWG7RWZqfMAohSRhgLyhspX9oxxHLwtRSWA6akhwpWNyZwV+JJ6zeXRs2rJBn7gPf23AW8kLQh4FScYz6mLCzWKZVsQYQrEyAQe/O3Aas1aZE6NFClKKY6HLh08RZPUU+d4wjOM7CqK1YuwBhgqR5gIHeOPsuw4z67eKYUn8UYY8DbkXROGWrBsLCEkAiB+WBvKWyYj7k4EcbAljxx7lmlqG0qAXKTwUOHjyuoniDI28f0sAmiD3+nPbB/sr2io9TZX/hOJ9QTgts4LSeRFtfTKhSHU/hN5laaa6GjokmnFmY8H2fpGqUutaZS6hSrDjNS0lxBBnMZeIOF+T/7cu3dSXl9mqt3ewpBdoio4tLT9zYn8KhiByvSdqzEXUvEw1To3sjcfLr1PYbl7BzBLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YACL2+7X0nYrs3V6o+obwkopkcXHlA7Uj5k8Bfjf8AuW7djVddOiUjwXT6YkBwJUNqqlf3nDMoTCeWNxukRu2WK8maiqS9zzXtbrr+sanVVlSpbjlQ6p1alHHcozn0tHefcdkglO044yD7bmbKXCDwY9NpSt+4kTkeN4W4laI5wnrPGwFogX0EwXN4w+wTOPM8rwB6Dckg44DPGwLWQsI76RXipJzwkxN9aK1S44icfKjGVc7EYasKybADgQOOP5dbIkKehW0AD7Ry/K1jjrkoNAGNx8o/DJxPcLh2JWSpW7/KDIjwFhn5AGA6pJUQVeOPDkL2hTQkiCcMJwHI87DkAE5UKdG4gAjjlJyys7jTPprUt1IkiABkT1OWV0zm+CNspWWvc63J3QJAbECVZ/0vUJmQo8vLib0TpkjqxWbsCpDaHTCTiZGIwn4XYU2kBMgJ8M49uF0y8kxZowxRuuq2rWloYkb+nKPhfUuolWzcmTkQTl15XbRKa9DPiaNekhuR6iVDlE+N7IaUB5UqIOKgqJ5DnN220S2RJItGGm0L/HPLL230Ib3YJWkEcRM+J+V22uhLfqTrdmkvYIinVs+1o4ZRM+Bm9NUxCyElZiBngeY8LOS90Ry+RKNKICrYkgJSUHkMD1tTZoHD92IGG5XA9OfK6mY80ZaZ0WtiMimUNpO+ZOByMWvM6WlxQIHUlJPSZ25YnpfTyRycqOXidlCxHLAQowDBzEflbjY0OQQW1IU5kFpwk/aEq6nqDfS79Di9lHKjutNiE1RqdAAwIjZP4scsbX/9BWyptt5taCPwqSYg8QRkT0vs5Vg4/cXKOPjZ3+y1yIiUuFfpEQoeHDwtxHs8wgJWAdxBMhQUP8vl/lyniL62qOP3mcKZ6PsxXqISmFpcQYkk7SBjlxFrP+krajcOJ44knD2joYvsmcvupnCjs9NCFVU+1S9qFI3RIEqgj3m1o6ej1iysEKOAJwCj8vjfVSx0Oang4eObOv23ZV01n0AiFLhSDv8AKJgAkTx8YxFqdHpYAAIG8AkSYEA48Tj8Ol6k7OUtnyMxVHWOtAI2N+oylRJMxPl2xxTBGJ4yDdmpo3Cr06dCkgkGT+EDib3+hhTXLOf6nV630EZ/1KhxS1JShW77U4j5WrN6QWwkLISFFRKyDtIP82WPS+vBye041Z2WoR10e9sbR4mAAnqOs2rVOkMJSnbujpuwJ4CJ9vG+qlk5x2NnFxwdXrQ3Kin9KSASZzHxEc7WndPWPNsCQDtHkw5nu632TOamedxOz1jdDC1q3KbO0ccsbWn9PdhKgkkf+JPAjL4318klSOamjhR2ep0IvoEn/DCccDmRag/p7u0hS4O6CiIj9TfXyOakcaNuAluUqRC1LExJAyu2vTXUoyG2SDMCffpfRO+hnzOderNuDKaVU+wwTIGB6nlZ/wBlElBEDicu6b3kypnPHuacSqVJKd0rnj1uwaQHjB9pvRPIz05K4oremCJEzOGNn9FO3jIOEZXQZ6FaRWLYOKd3MeGdnMoXgkd9gQvDoAoqJ2yU9MZ+dlUomYSmOIjEdLAhbwBbUQ7xnphFzckjzJg8DkLAgCgjOQFTlmCOX5WAgEwN6ePX2RYABd7aVjfjhmkYA9bwkfznA5GxQDjjitpTmAruizLZSDCVKWcIwgH+NwWBRVVgJTOWZxB9+FlCEmUrITHDOD3WAAakqEBsSdqpgQPmcrr+ZBSQMIzH62dg1EyKjThbd2ygpcEKByI/Q3XQ4lTQViAjMjPx7rmWU2RO0GDQKiPT3eYn7jMXxt6YCpxyWPak+3C3QFBWqkIlK29yeCkngRdpt1LilpW0FeGYI4d9ienQzJGuStSveYTxwi8Ay6YlIk4dLoMp8EH39NtTr9P1nTtQpQVGmeTJ3ACOIVjMRxts6NXVVK4h2mdLaxnBwPI3iWJYNNJ8nWOYtP0MKTSPsfRNSRqunMVSY86EqMGRJHK/Kv8Abh211Cur6rQ6x1bqP2/rsbjO0pPmgnhByvSdozF1OulGJKnRvYvKHl6Oj2C5ewcwS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAIX1I7Up7Idj9T1MEB5LXp0wJjc855Ux/wAZ3d1+bf7o+1CUnTtDbV9qVVLuOEkEJSfnck6RJclgrZYLB4jrmqP1da/UPLLi3VrUtSjJUpZkqJ6zdWsI+0Ele7H+UfnYF8qZWiqtK0Enao/yxMG7SKZWwEyDwAOfUkcBYjkiPJUgDTDjqSRASZJMRjy/W7BqQtQQEiEiOl1tErBEmaAYIIBBKRkMcVdb0p30k+qpGMkJTn3910BYI3gK2kq87g3q6HJNgZqFlXqBfpqPAjcPZeX8zVFM2w7u6Uw4BkCMAEixH0nFScZJmMB8bys9DRolepsUjhUrafLxUMQoeI4XtLoba8vOccrloeLsrBPRap0kYAqxk5Dwj5WNKt5xkpGJJwB9tihV0JdndyloiSuFAgwAMoF9cVCcIj4Tcpchqy/MAHWlEwDJSZO3geZ43ttK6l0JkBIOM/wsmhiKASs63RxJccVgJMGST7+N3qakC3TtSXuEJnbHjcb9DEmEvU3CIBhHrCNqo6xbi07QwAlx5KRiJRxN1s47NvREUbPRr09WJFNoynEkkScYAMe3DG3dTaY3ISmnwjMAnHkT+d9Xs9zyym/U4x1N9D2Q0+w3aXRfUgPNLaiAlUkd6uvwt2o0xe4eScSRukj4zhfeW3HKZ5/uL1PNHTk9a010EOl0JAhQTv67SCTjGYOBtxppVNHdg0rbkPtV7IHffV7mcfJM4R0I9Pg1gTW9Kp9iklOBlJGIMR0UMTav6DytpCEqjarEmRHSb6fcfqcvJepxWr2O6g6ElvSaNJJSlxlQHl3QZHQhWHfa0qlQ4nctJJ6iInnl7b6/cl62cfuP1OH2lfB6PtoTGaFa0gTCY4glPUJ6k/K1tLDIgQCBhH8eI8RfVzVnBydnGOqXqehRSSEN+lq1ACFKGZ2qO7DxtcNKhRwQBhHSfDL4X3Uo0efz9zzPXO/U9S1q7oRmqZx1v7MZ3Y4qA/5JOA62tCgQJ8uP+W+7lT5OP3GeZQbi8HpepegnNUaXB5m0FZEFzYSkkmcAcceNqjVGB5YI7z/Tvxvq50zi5tnBa8fI7rWkIjugJcWDhHXb8ADPHpa+KZIJmcMsZvut9KkcLPO+3V2z0uIhDSijAcDCT+Md9rS21JHkTlyvs9iOKaPMtTPR4WI7lOUI2pCSoEQZmYHttXbZEYtieuBk9ZN9vO8nFv3OH22lR3UMCOaB91Q3+UKO4kDACMtvTjaw4yUkeUzhGPH3632WxdMnDyOD1N5ePY9HghHTpLQJMhQjCRgccwBkedq5aVsPDunuwyvv9xnGzz/ainwehxEdWktuH7YgRluknrxtUUCCD3YZ8pyvt91rqcbPP9mL/wATvQiL0lZBR6YicwAI7j08LWICwUrHsn4533W1c2cU6PM9D4rHqehxbwxsVegLa3FLXqTJgwT4zxm3EunSvDbMezwj8r9MN6bzKjz+bPJs7ZpYVnq+2Mep096SFJQg4HbB3Drjlbuq9JYekhPXCNw+M37VOPTJ5YbZetHz3qk3nB7dmiPpYw39Jqc20LVH+XA/xt2r0xTB8vl6Ag/P9Jv1rZH5Hm+5fueCWmS9z2PTXsMmo0+rnetDiecR+VuyroEuSFKP/Pik+EYDuv1x2I88Z0eGWqR6p6hkLpzP+I6k9IwtwV2hoVkpRUck5JV34e2/UpfI4w2nicX6s9E9KyN4074Vg4CeX8bsVOnvUypI65Kk5+EG+/l7MzGeDzePublBoq7XgT6g8SLMVnEZ4eCgb38iI50+porvsyjd9w4kcPGyLEgj39nG6DBppFQgiFJCsMCLOprZJ3mMjxx4d1gZK0V0b+BJgzt6X0uIlSSDv/CRgLpCA0t9agEr4YAj9bEHED7kEn/ln3RYosByzuUlW5KTGZyN5bqEBMEKjhlFwAGvSLa1IWoY5DnfXVlZG8hJAgcx/CwLRLCM/wBtBBKv5TGM3hLpAIGRAHC51KbWEZUjbfqIAjzIBxBwI7rwyvNO4hXPI99gaM2zYKmyqVFJUZnpjnc9dwAgpSoHqJNgX80S7MlKw5M7juz63pJ3YqHsw+NgWhEvac2Qs9AAqeAB63qgO1SIGAjPJXjcsP0LVhHqn+34IotbTqK17Qghn/kFnaruxF0vps+3SvMtAqQHnEz5RtEiM56xBuL47CLJ/wDXQZ9G2HT3FO0NMtWClNNlXjtE30C4OIfIa5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABDlYNSrmdOonql47UNIKleAsGAj5x/3FVL1T29r2jiEhtKeXlFpX1a1v/X+1epVzQcLTjvlWUxAA28JvMnRHk6RWEFSWBnKaCDuKvUUPw9DzPHuvTvrIUDwyBwM2X6C0UA3HVAZzI80fLwvLoJJ8uXMWw2RAAkq2qBI2j4k3za44YSASOEjD23pAEeWdnfKyrE5p/W+BCcZVujpYDpkOjMLSRGP5X119LAASBu4g4x4iwIuRa6BWkgkQCSTgAMSfl32AOriVOEFQwSMPhw5TYUa+Zm2WKlspKkf4YGBxnxxuuf7QKiAVHLdJ281c7WCsjpe5ryJSBuUr/Lw+N43l9Q8qUjAeXDdzPjYFx8wrs03vfdAHWAOAtb0HRfUcCtmWZ9+HXM3G6Rz27MFq2ddOu2TSNGXUbUrITjx9/jbmoNLQ27tX5gQTCMxym5s2UcJzsa9Vnp168gKPs8tA/tqKRkRw9zbipKJSUDy8Jxzw69L1LcjhKaMw7d/L3PTDWJ9PQrZIlG78Mjzd/KLXG6MmOuUcO+9ykmcXP3OcNbR6FrK9IAIEeIMk5dP0u6mi2kGOfv8AwuzeTDkZhE6KJlLAWMJx48vl7LtsMHCcMZx94u+TMtk8TSRVNClRAWCocJtR9HdlxyN686MZM+NnTBRFBBG1Sh4KN3/RAyF7+57IwY+2vVmykKAFMyTwi7hT1EXrz9jJjwNFVNGAMevK7aUFXARzvVkM+JoA2wBPMYeaIjjdsNgHFI6CzZCJFAhpIJyyHvNm2Ek2AAP00gcPZnZfTKgcB87oFAAW54TlFmLWHssQMFctJJEcD7552RaI65eN1MEooJTQj9Y5+2ywSIBPv78bWCUUrKSSIxzyP8bsKbSlU+FgQpVDW7r05XYSlOGHE5WISilRbOcdJi7K2wd2R53bISilX0kqjDLDldhTY4fG7ZLJRaKjjIx2gZWdSP48B8b0mZMuJooqRhiIOOV2nG5j9Bne7MpmGsGmhPfRKTIOMxHHu63bWzKeHfn7b6KRiznKGDbQjVTCVJwKioCYgYR143eqaMKSpQT45yL7RkzEZnCUEzpKFiG7RtK+5BIOJg4fDIeN2qhBQCJGJwN9lJmYuzzSgjpJVYhV1AlSSEpSBjnnhzu5VBQJ3CCOKRHtyvvCb6mI0ebZqT9jcrGzXUjaVHcCk/zBOHgeVqz6XFhY3JUjiFRMcifjfohJ+pzWODyzj+DtJJ8jaWys5QCDhjIV3Xer9NbC1FtUAxHUGMR7b7ppmITPM8ZNzhXAmeYk/wDkniOviL696iJV+IHHDPxF9CWjlzZWq4AOtJOJjA8BjBvYUhYBBhXhhN0GQVVBIXgSBzxmyqSlZI+1XwN0gAG9LQtH3RB43QARJUYGBF9RtBz8cPlYABQnDPwn9bylSUmIUU90WIAZdLgUMRh8bOGkrQRHlJ8quI/U2FgqSYNiqx8wmeHO8lhtt2YXtTjwxjh7bpCFZfO30k7gIKZMYHOwN1CXAFGQDgR/KLBlVKIXyL9E5tUlIiCDtw98bEyNraVAyUr+H8RckOv4Ksg9f+kNEzqrDBSNqwUoWT55IUJUJHlAwtC+kvaZ7Rq1DSRvQ44PLMEE8Rcj6Bc2J8WHxR9KacIo2R0QLxpDvraewuZ3ISfaL6ILg5PkPks3LAAlywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAA4TAuKEiwAG/2y1CnZoXv3ST6QScydp67o+Auh9UXUjSHG+BAKjExjA+PC48km6RY4ZYco8H7bN9nlVr66cOp8yj6aVkJwP4ieHQYm0ftJUepqNRuIPnViOOOBvLcrHNI6KqsjEeo+8rAHRMZC8vrSFbZGHSxUgALja5GcHleK99SU+XBWU8YtEqQJJg3ShjKJJ8SLrFSggziTjjwHSwI6Iacq1boAB6EZiel8pGd6wVcThOViiwaZCkD1VYn8IVj7fC7SmEhGEpxIMiQbEBawCG1Pn2CYwkzj3/rY3kKWtLYUCOJyA5mwIOCeopwwRuzMdSbuUVMkq2AbimMR18bEm2Xk1CKLekaR6hQ4tsAHFPmieuBte0amaYQN6d6iiE+J/F+V52Txg5bJG9cMrB01RQpaTQtMNA+mIjCDIPUiDMXeo2UtICIkYbMgepw6C+eyWeTE5HbVDjDOmqLot6bTBxClFAEKO3y8OI9l39PSG0kqA3ZgeI4Zd/O8TlRiefU6a9a6G9WArLYawMKiAkjocceOF2EidnIYnoY43HKzL6mowo0lgyhsYwn+tnabVtxEcTzPKzZGEioiWjh3dP1su2CBiMBhnawCmUIxmBiLKERGQxnG4ADCTkkZ9cYFkQmfNF0AHEpk5TZdoj3AsAAfpA4x7zZkonr3DnYAgL0xHXpxs+z3H652BSAfS4RiIs0DKPy9++wABhAxnPre8hnh0GHysUpDBTh0ve2f4+/wsAAXlE4e3CyemD0J9+H62AAAo3T8OGVmKOosAAOwAYdT7+5shTYAAS3uOZ5GLIR75R7LgAA7IiLIU/1sAASmwQYyI42SLAFAlGYiQfZZVIw62ABXU2eIzEYWRaYwx77DqAV1N/5YxmfDhZVpwwHPnYEKV3EYRE4cfGyLSZnE87pCAqPNxlE/MHhZ1NSkyMef53pMhlo0xLqqFtxJkDxu660qCIwvcdjTMpnKetM20NzUNMWPtJ8Yw9trL1OMZG7qOF+iGxHFM82zT+DvJYY0KyhcScpPX+P8LcFZRMqB8uPWMO+P6X64bF1OEJs8M9crPTs1r0GZWUjySdw2zMDha3qGllSCdu4e0DwEiPC/XGUXwcdeymeGcJLk9G3VjgaFShczMWo12nel6gHmAJI4Ep8Dn7cL9MWYjOzxSVHXZqob9Sz6ayrOMx1HAi7NaxKZGBGX5G+ydmYs87RqUSmVIcT0N5IQTBlHym9AwDDhIVEyOE8b7tJO04H4HwugA62UnDHdNwoUlcKGPTKwAChogSkz/MnPC8oWpvdhB8Mcf0uFACtDyExEEd3KyUx3MROMk94uDqVPBYmXkpWgBXkPA8CT1vlSYQMMDiOoP5WBnJp4QNCFM+XMFQOWMHC9tq9UZZbRzwsCZsRuy22ClhAGBkyO6+JcUpg/2zhhPwuctis8mgOf6aVjSO0mloqI9NVQ0lzmJANpfZxw01Q1UR9jiD7CD8rj6fMSfQq6/IR5PsPTEtIomktRsCQEx0jC6XYuq/e9mdNqYI9ZhDgnoRfRcEh8KOL5LPEmKty6CAlywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAA4owL46j1EFMkSIkWAAzfqdXtsaFU1Ep8k7UnIwCBPgYgW0PrdWatorL1KoOOUyyHEuDJJzz6jhxBxF5nwJI3r5Gs8W1Z1blU8VeU+oornrMxYK1Y2qUcdxJJ3Y9/O88Behp8gpOvolS1YqGQ4WCocTtIG3E9McOZvSAeDMmCffW4ZVibwFwok+5sikuwZ2mce+9BUk+WTIzOA9lgAWGEncjAbTFymDp3HGUjy4ZeHM3ACoJUPGCMiMhfGmgELUrFWEHiOvfYBvoVHGaZTiwpeJz8PGztqDQUkypauHBI6nna6J8XASsqVFqgb3OpbT/bRKQokzMZqUf0F3NGp2ztU4B0AnLqoj5TeZPBnYyx5N6o8C5pNOYCwPVVhsnJIH4jwx4DpdrSVJfUlLbXpNJwBAlSo5nM3y2szPnLyd9MTev0oWKGlW23J86486vLA6AdPCLs0TJAG0QnPE4m+Wx5M7Gup21rBqCssU7ZbMEJKlZx7eN2WGhtx4dYm8tmJM3FGooKgQkTnuB8AL2hMRAGU8bjeQaSB1Oe4AAd9k9OR8eAHzsQFIgfpJvu0jHmLAA6IM88ut6AI7/CwANJTN6T+GwAOhE9ffjekiVd3vhdIAdSiE8fnZG0DHG6VEDsz6eX64fpwso2yPH3zsUWRgfTM/0N2AnMxhlkPbahQshX9Mzx9+6bsKbEZfAx8zlagWyFUtwMPZjE+2zlGc+/djcKUAPSOZJ8BZVAkxj4fmbAWLQFTQIMfLLxsikH4XGCksCpuAcI5mylEkn8/zFgUWA25d/OyFB63CgASMMvfvsikdTlcAAIpxwk/xshHKwKQCU+/vjZCjwmwKAK0zeloxjCwAALAE5T7917WmediAADAGXjhZHEXQQoBRk++V7UjAxhhYEKBU3uGfG9lJ49OlrBKBSeYkkAfldp1oqBMnlF6TIjLRpia+xuBwIu0+ieF7jKjKOc42aYiVVOPMCD0jpztQqGEqTJA4jC+0Wc4yaZwnE6SVjR1WjMLTsyyUMgevjatqlNtKinEHvv1a5HOEjx7YWdd0Rj1zI3qEbbv6rTN7leWDkTnPdfrgzGqWDw7I0zpujkblYxtIUBE59LPWsrCynNPDpPTC+6ZmLPNJGpRKAgKEjjzyvSmjtJxEfO9IGAccWZ+4xwnMXlSSU5H87oBDZcUv7jj1/S8IURAn2/xsCgvUypDYOEzyxmwtvq8pPA+HvNxgsX0Igy2ySUHERIOW2b4/iNxSehx4GwLKyvPCO06IMJAJknO+tSgbkqxMQDnFmBEJUiy0uG3MCCpJ8O/87rpeUpKgM0/d4XMclKyXkUtJUpQSkH7l48sIvGnKLZYIwMknoccLzLkrXU1EyuPQ+sfpNVqrPp/oS1fcmlS2rxbO39LS/oHXJq+wNKgKBLLi0FMyR+L4zd1/Ahqf0mdvxsu5fUPe5egYBLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEvLrqGW1OLUEpSCpROQA42AAHU9To9Jo3aurdQy00kqUpRjITfi/1o+qburPu6Xpq9tM0SCoHd+4I4JjgIkxjYx5eUq6BKzaj4x9xN+t31QY7UtmjpGkIQhUBS8HCjqIzHjMG/LqypdqXTLhUo57jie83JSbfsWSNQh4x9yRYCvdDqRuORgxnj+thq1KA3dcFGIgjjcVlSorYKdSuVbYiMIGQvqmipY4DGZGE/rdBl8lcfcCQQRndhpkOuK3naERCuGHDndJZkqjkw2wuAkY7vMesfpF2aRpLtRiokEwTlhwn8rEfBEjSWQ4b9OnbTA3RuKvgPheXnjKzOAO1M9B+d27IuS1QZFKbbEJGPAdZ4njnYEvgSv8RzPjkBdA4Mp5yHbbWXBuxcJ+wAwnmb1p8rdMd/heXwJ4RpFhli7olKyVoDqyqcwMO7rZ9EYUFJgTPHrfLYybMpnXSjelVkcmm0m5SAAEISPKBjn1yxPQXY0oOJCDGzp5c74TdWTZwejVG6LpsU6dsAAYeHSyUiSrlxM8b4ydiR3iqLFFlpMDgeV7aTtGHv8AC8sM0ggqU9fZe0Ai4DRCbcTPxyN6A/qfc2BQQARkL6k5XCgGkjuvqcTyuFANIBw53pJgd9wAGkjnekxdCBDaUe4H62RsT069bqKkRkkyJaWYzGXEWZIBwzM+A/PC6kVZDaRlggkiMMp4z+dmgxxA/wDYfpco0WzFgg2OPm8OGPdFk2QRmeIk/n+lyi0bszYMo5/pHt/S9mPHHr+d5orNWRAlNnn7+FlEY4ewe4uUUtksrqbw95sy445ZR7m80VmrMorlHvHtysihn+lygasgBQP9PebKQJg+/dcLRogBSQD+mdlUkT+X9LhTROgApngbIUiZAvJSkAqAjr8LIRcBQV1Ijhje1iBYFIVygmZsqgbhSgApPH+t7WDj+mViAASJkRnelDhdAICI9872Ux4/OwAK6gmeOPWYva04dPZdABWeHLhyvbiYHvxuoGWGU3m58enOyOjH43UERhiXqFLvQcDzi7b6AqRfSEjMWctkLNTGbrenLTuWkTOJjpa3qdKFIUmOOF+rVPocoOjx79bydtkbQw6lKhA4TxtQ1igW0tflgceUHA364sxqnaPBJHTdrp2N2rb9NwhQI4mPndiubnMSeCwcDPW+8XZmNo88lTNSVie4RHlKjHWBhenWomcL2QwAEmb0QYH6WKAHYUlRM4yMUn9LGzPH+PdYAF5ahtaOPmFxJ3tI3jBCePjcDNLgLgikbQZywII6crwhwKKj+DLHhzsBwLt+xHN5cgkRE4QPlffSO+QoGY42BH7lS9y5QOEbJwzPK9UTe8wBlGdicB8Fo+h/9tIP/Ta3MYcWo58QYyu9/t20tVF2MbfXILyiUoP4U8vHO2vl/MurqTbxEm7lL2PQrl6BgEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLhsABp/VnX3tL0I0dN5qis/toQPuUOIEcs7T+2FG/r/AGjR5F7KFtWxxCw3tdcPEqlPlbEkEG87G0sElmRrVG2WL8Y/M8S1vRdXNQqpRROrbQ8tpssv7VBwfemQMeI6X6JV9n9dpKZ/0qUinQ4sLWr04cacM+qkQDMeaQONyNKPPzwRpqzUl9WFfpksXFtZPEdTo3KSseadbdZcSdy0uxuTOOacO/jdrtc2tnUqouqUpx11Zxx8oMDHjle7TMxfBlKjU1liYhK3gokw1lJAz5czfTgyETn8IP63XRSEafQE62pToEeVMfDhZFHd9uaRM2I+fmHb+RQToQKYRgVEnwAzPtsdWUqDSRMjA458bvUEfBHk7RnagmJJOFwAttzyw4QLMFjwLpGKhzzEkZYJFiWS4uSsDxmxSSZGdZ87o3ZX1oALnhh33AxyWPIp6U0pThAEkn23Y0ZKQokrLcRwmQc8eF4nLBnZhHTWsmtKtjs7O04KRHkiCowSTyEXY0moR6SAM4hE4BKR+JUdP5cb47pL3M7ctnp7eL4x+TWnAtsDcMJKd0DOeZvtOpOwR9wBk5fD43xk38hI7wihFl2njdA7j0vlOQQQMQITPHneGGdEIltoZG+sCOOfcLywzSAdsSMsL02nC4Cg7t5Te49+NgAYERe49vssCkIMBjwvsZnhxOdgUhoAKP8AC+pBwxsCkCIHT231kcOdkVBkYZmZnG9t9czdRUSRGFRhw3EieN9SmBjPhxvUf1EcGHn26BuzuHEAdZInx8b7t8Byu/8AGUj+ZDMAg5j4YXpQ4AXKspVghjaIGHhx9t9yuVjgvBbHJn04OOfD+nS++0nlhEXlxooTBhSMccPC9KTHEXlorVGkyRBqSOHSPZeiD/E3AzSbCAlEwc72vPr78LgLYBKF9UMf1uApECUnAj3N7KQD+ZNwpogJUC9ETwxuAoAkT5jeinH3iLgKASkiDfVA9M+twoAFzI+F9WOFgUgJUC+qFgACJPx8ZvSssPD3FgACUMD7ZvqvfhdBCgXIxOf8L0tOB4d+dkEZZWV3gDHvhelCPc3pEMsMput4qxwiyPJ9l6QRmWSvgTK1jeFHgRBGHtuw8jAiPDhje4PAicpqysbGr0QeQqRjGCuGHA8rUNRbTMxHWMjfbXOjMTzbdaZ02oZNZTFnclScJNqur0oVuG3wVN+qEk0c9bao8OyFM67ooa1VsQTCT87s1tItO7gRxzv0IzGR5pcmpREtQUc5+V7WhRkGD8/ZeyGARqCdpEiM+IvTTa9yZSB4/rjdAAR14hgJBjIGel5qVkgCBAnhFwFvFEOoUFQkQDBkjI+PO8tFJ2jbt4TYMAOhHm3SQBx6+F5SrzgbpAw/jZugaX9AhZ0VPq1DaYBxT8wLt9j2m3NTpUYStaQkqykGQD4xF5x+oldfkpYn0/8ASylepuytEHWw2fTTgMOEA99qnZMH/p/TyRtKqdskZQSkXrWqRY/CjntdyJP4mKNy6CAlywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAlywAOLMIV4G4oSkiwAGv6K/TcdKQovPVCgMCZM7cVD+URHfNqjzCKZGAwHfF5KaIeZ9u9Y7S1CX6WjbWl0NDc2fIspmE7Iw/5HM5zb01LRNOcp1uOht4oWXt+AdmCSkLGMY7Y6ReJN9cGmsHWEY46nOLdnzL2pp65NasVqFoeRgpKs5xy642qfU59TnavUIQptCFJZbB4JTjnxxkzeY0EsHSQk8jZZb9XhKW0SrgZJwuzHpMhakYrwmMVDhdbpkzdEQK6GR6Kt2GeFkeUdsQftV7bPktCgJpQkueadoJI/QXp0qbRjh0uiieId0BecUpeMhI4WNTxKjnjzuoGW7BFd953E8TYAFmlKdgxjkL5So3EQrDjeZFkagSHIr6V6zLiFN448ccRxPIWTSPUMISYC4So5SOl8p+5Nh21X0Lquxy6QurcWiIJVhh7ZnLG1ns9pyWacTtxCZ4nr4C+M6Rz3TbZ6Nfk6o66IUrFDTqdZRucw69btsoCRlMYXznPlIyzrrhi2ajgIwiAnCccvlZmxtAjvs2QqRQrIyGHS9N4HDC4CgOgCBfWvfrYAGwMZHxvQGGNwFITb4+F6iwKQwE54dbIlOVgWyHAmyJTYpSGmhB5XttFkVIMjYVuJvaE4D5cbqKjMiSNpkic8PZfUJ63peoX/AOGWHRDIHjetmZHcLvIILMH+g/jeiFAc47vZYoJyY2mcSf0xsiQkg4XClsjsConIf08bKQk5CTGN5lfBcGl7kQNWV92k44jleWVp36GkRMwU4X1Q63llNJhAlJwzvax4XllZSLPt/oBVelJzF5KaAIpwvak+3GbgKiAVC9keFxhmiASL2pJuBmiWAWAL0pMWBRYBXQXtaY4WAABYzvq05+HCwABKwGPjfViwABHh7biomf43QQA1Y4Y/lfVe82RUGQC4DA7weVxeUdcu6wDIV3Jw6Xx2QnDhwywuoEaD4Kr48x6Tn1vq4UBOIPwF7iRIxKId9RO1BjcCJGN2KluUkRIjO+kWSLOexFmkxr6m1GCjlKYn5+F2tYp0YrGHKPf2331u0Z1M82xcm9tDYrWjEJUZHCMRyniLsVjYB3SrLhiMsu6+8WSLPLNGp8sb9YHAspjLExea1frPriMDEzHzvtHgRWDhLkSdswwsJC5mTly/reBIwkYdDYpAaUreMTjIMD43EFKFScbgANA+XDIGRcPmTIEY4xYAG2jucE9JNxAJKYPQc7MMsSxFzQqpVJU07w/+NxCh3Gbr6coqIExtIIN4abs10NJ00TNn2D2IrUah2W0uoQdyV0zRB/8AUWl/RqoTVdgNJcSCB6UQfwxgR7b1H4UTX8KOc8SZdvxsdVy9AyCXLAAlywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAlywAK9XSJqElJyN2DYADF7Z9k+0IYdd0msUEEHe2owUpAMwR8MJt7PJSptQIkEXmUX6mjcZR6owfJXbDTtTZr31VilOKLhO48pwx5W/wD636EzTKqqgspCU1BShSCEzuid0jzbY7jfNJ8dSy5VHZ5M63g8rJ9QMN44bSfAHOyFsNq8mJCQfHpeeAVgrPLBcc6pMD9OljrFBBdx3ErmRerwiLkAoV6wSE5R0PzsVWFbStSvuwAvSBmQafUCuMYM431pIVgR8boIDG6DhlZPSSVQFAR/N/CwADUapUlI442XT2f7icjHl68bkuCTeCw5Na1kdHZTTBUPtqUncBiY9+tq3ZFsHahrBMDcuP1+V8N86RjuD0dtr8mjp2q4HPRMpYbSIjaPKj/N/MfC7NMx5R3Hxjrfm2Ntkk3Z6taSpFggrUlsGOIJ59bIjrlMxeWDaQQRGc+y+t48+6wKAzfX3N9R06WAAdrLh+t5QuIiOdyigFlPCxodHX23C0wRtIOE8r4h1vDzeNyjSiy2ZcjaUYXtCm1ZGefC80a8cmrMKVkbTjlZmxjI63EjahZpsw5HW2srM3HER43lI6KJpyObbIlEJ/j0siY/reVHBuit5M2ZSJ95PzvZGB4cbiKVslmRgqOeN9AATy69bDoByQwZgXkrAwBumfJLqQ1V9CAAkgEi+binx9+l18k8sE6FohGwYe2+bjxtwiNvqTk1S6EPUn35XlR7/wA+tn8zNhFX6EIHfcnG7glkzZqjCk3ojrxsAgsdAe3r+t6OZ53KKUgPbunvvRnaRcKW6Iv/AGBKc8PZzshGN5KbRAKheyBj+V5aKUhWcHxsjibhaNEKyxhe1DH8ryWi2SyuUmfGyHORBsWitkuyutJyzNlXHgedwtFJZWW3tHxm+urCc4HvyucFopLALHhfFuIUTwsWgSwDxgYey+PKx4WCDI3QB1WHvjcWZuloXRlyK72cjiL05xwymyKgyFdYzvUXoGWgxH1VkFKjH4SThldyuQChWExl3m962SHJy2xou3gZupJLDLqjkG1K7712oP7eke4SNkX6NeWi6fiR5duEx3DwxoFZUoztzOYvJQVKvsXqeYEKzEQB+XK4oEYYXAAROJIzwJvqEDcJ6E/CwANSUeXpj33nEq6kmwALDBJUnvx7r62MQMenieNx8B8Go9AsfgUtK/xCOBA7+VjoCUqmR5c5+QtQF/wGj6p+g1Ql/wCnGlp4thaSevnJm0j/AGxVyqnsM6wsiWKpYSnOEkTPeZwu6vhGrh/Mzu+Mu5Zi/Y9KuXoGAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgADqAstK2ZxhfXXUtpJNgAeLfXHSNXXTKqF/4Db63HJMCFqgJicYMnlNrn1trf3eg1rRCkJRCkygedUjYlR4Ddj3XiWCzeDpromtZPA9QWoOKSwmDEKznwslSsBSlFMuKOCk/aPh7Lz1IzRpFB+Es5jdHmwyN9qVtDdxk494urLIrwZZWJzjZWwoHEgyD0vCyptauhVGd76gy7rJHgBBRgQQbK4EK8cvDwukIDtMwp0KV0Im7emMKxSlJXInDOzZmbKo2bgvYLpqB6kJ8vA8vEnrZGmFtPbgkpg5n3z53Jsjdoa0VKnwPvse0hDCUpO44SSIAPQXZ7EshVE2s4ki/P3DJ3PJ6+1VF7TgcTYKWwDnfQD3ZX55BnpiEbSNozw5X1JMXAb6EQZrAXkKCRnhzuFoqYC7toknISTbc7VdpAyg0dK551DzkYkDp43EejttH+TK2krPN3W/DivyKGp9qqDTwqXUFQnCZM8gP0tjN6XqepPFcLVv4qnAXnV2s58nr84QRrb3kILHJ43rnOXqLdT9QnXCooAzgCSB7Rx5XTR2J1AJBK1BMcBME3zj2cUjX91D5nSfeykzK7La/UssdtdSWoL3jaDiJwA74Hzuq92P1RlG9IW4niBA4crn9tBepqPcQfoirvJmZdpsWabFdP1FfbVis5DCMBbYf0mrphK0qCpEpUkyO+IjvvK7O/Q6xnF9Ua/vmvU4S1yXKY9qH6lSAFjfjiR8hbCWVslAQsEHGJOB5i+Muzo9CbZ6I98jytUer6X260+sHnX6Z58TzE35Ul59uVocVgcYOP53456Jx6We3noj3w7jXPrTPBx6nt1Nq9K+gOIcSRwxvx6i7RalSH/8AIc2x/NIF+DxaPZOEJYcUfS8k/c8ENs4cNntCa5tzDeIPHiPG/L9P7eVjRBU7uMwQScZvxHpn28X0PfR5dfdyTz/J6ip7p3cbaek9uKerTtcIacAGCsP6nwvytm9vbyjweuKMa+5hLlDq9Yd1pzOqNvICkrwvl5GZWjr4moUxRLgxz6+F1kPhWcc7tmbIos3RY37uOPvjYQubtkszVGqDb8bEFYZ84u2ZszRqgm8mxbz4XbJZKLQULsRViRN6syZcTRsuSZsRXherM2ZUTVBCuTE3Xcei9GSJUUKXYNplbqaGMzehFNk4E5KNX7iiXQm27V9q6RltQLmI542OkdMiNmJdxrrkW3alAMT+dsPU+2KxvUha8yQJyHUx8r5+J649vdcGvL+DyS7vxbod9Tq1M1MqTgYON+aV3aGpqzDa1blHIiCrw5db80dUn0PdDWonpe6K5dHg2b5SH9VdpKRof4yMsfcTjfmzlVUJVtW6vnOOPxvyR7dyPbj0PZLuYxWXZ4Lk1yPep7ZsDJYnNJ+6e62At6oK5hSh4RI5Tfmj2nqj1XGj2S7zLpni+odr/bVaiR8cPlbUT+4KR5VSZiQT3ZX5/wCzS6HotVyer+9dcnlSdjlb7VJQSpxSs8FA4H+FoKdP1Mo3hlRA5GT7eF+aXas9HnD1PXHvF1PN4T9GOil7S01UoDdyx420lIq2DBC2z3i/JPt3Hoeqov0Z7YdxGXU8VzjzaH4hxDiZSQQcbamhdpaimdDNQSpHUnzAZX4nGj07tCkrWGfQTTPJo7hxdPKHOuQe6+IdbdQFpVIIm/MuCtU8nrIpJpNZMLBCuV9VB6WAFlaqEtq6Re6kS2qeOF2HJYcmNjwxs4GH25MBtPVRJHhd3UNMRrGtBhTgQ2z90gKk5lIHUjLhfp0YJ5eEDx9znBrw+7srj5jSotKq653YwyVz3X6r2b0nTtNKCyy3gZJUlIM9Ym+znFdTxz2NnnWqUmfU09rGNWk/webap2RrdM0o1z8phaU7I4K5m3/9b9Up09m9OoEoSl6pf9YwBPptjPDqYv1x2KTo4dknKbl6L+p8yepwjZ7P3bw1xjFLl/0PKVYY30iTHQX6QeAEa+4Twi+tYLGHvzsAEWm926R4e29MhWYwPXp1Nxhs0n/QJfrZZo2hgoqA3Egpg4Rx77VKvSW6PRtNqQ2tDriv7oXj94lB/wDYAnbwtfUypZopXHFnq/8AtV1Z1vUtV01ThU06wh1APBbZgx4pOPhaD/t01Aaf27YbUdofSW4P8xyx4XdeJtDjYvcm3OtP0YedT9j6OuX0ByBLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABwoBzE32wAGf8AWHs+zq/Y+ukQWkF2UplR2g4YW4O07Lb+hag04oJSuncSpR4Apz/K87F9LNPg1qdSJHDR8nag0IKQkjaRtHGE5zd7X2mqSuqQmVp9co3dRJgjG+QOpbG3qKSlpSiAYI4Cf0yvtUn1VLSThj8/ZdjyREYfIk1KfMk5bseN7qIU9BBSAY6+F7CMSLKjXotq2y4kYTM5mxHaCuQTiQMsLWCUvUPDFvsfT/ua91reAsNEoJ6znYexFYKftDSfyubmlT0UL59w6iO5jetnbtY+Uq5HZSUdsb9Rw6hoT7FOFrQCc9wP6W6tQ031KQwAobcDnjF8o7U8HGMqZ22dvKKtqj17YXB16A+waYownocRZOxrami4g/zEey9dyTfmKZw7Xii9uqkxf2n+lk2A3wB6EEYSCOhvSkiwLhBFTV33UUykM4LVkR+HnenwJxF61JOWRHgmxvxwGhJ03Q6cuerUArUTJJ8xJtVTtSJi+st3j8ODk+TjDt7dyyd4hmKOmbQPTRtHxsZqwgZ91yeyT6kabGvVCNYNJpF5Cm0piAbTk1+OGHO820y+JaTCdl9SmYiBjlF0f3ZWbqm7JkjibpBqqnpH0+ZtJz/DPj/G8JWTHC9x2yXUycpaoSu0snTxEqv7OaZUE/2QjDBSQAU+EfI2rLQmMZ9l9odzNdTieWfZ65dD1Uhn1PZhlonY6QQfKVfrblq6NtxMkA3649y+qPPCTPnz7JLg9k4JjNf0mqZ3qTC5+4JEg91rz9GEK8spIyxxv1remefyPnvt5RPW4UNdbK9oT6ZSRjPHDrbhXTNLEOJB55H4fxv0qaa5PN5NdTxPW0et64sS6J19RSMyhOcwcOZtVRpTK0/2yAeeV950cPuvqeeF1Z6fsRFPs9qzq0oa3boGBJz5GyaRpTTATtBSQM8wr+Nzudau0Z2brHbbXVM3q0pDlo6gqQkz0MWGkAQhIPAXxYbO8ciKwKCHPbzysSFXLAoof1cJxPfnYgocLEJRQu/nYlK6/C6QlIpsribEVn2XSEKaU5zsCl87pCFM1TxSkx0wsFa7saVAnlevQutJvPBEibLSxyNzXdXSHVIWqMzIOUd+fQWma3p1VU1S3BEb9wmQPDC++nU3G0b1bFGJ5u431OvTBjdqlOd0JVdqaipQSDCtxB+48h0m7I0eCSpQxVMZ31hH6VZze70OE5/U6Oq7f1EkrfUR6olM4pGGPCZwjra43ptMiCUeorKVflfbC6nne1+pwdy6HqWhUJDWnrcUlQbLgThgFQPH8rclNTTACUiMgB+V+h7Eup5ZbHyeZamz2x0xoSNP7OuOPeqtCm0nCDmRxgcB8bczLBBHDqevvzvvLekeVybZ5dfbOz2qCSKlJoFGiCptCgP5hw/XxtRCig8uAzvrPfL1OVNnCHbRPRgJTaZQpAUKdAjKUjDwviXyMvf2XXun6kcDmtEM4R0tJFhynYKY2JAjpYTVQn3/AK2WyXqTxdmHrjxR0fBXq9Hoqj7m0HuyvS6lJOF9I7pR6mUjhPRGXQ6MQdT7K0iXQtsbIP4THttaeKFpJMZX3h3Dazk5LB5Z9tFPFnocbKGlbmUlklSiMpiYs6KcAynCMR/C7s+p3Qbwc9OFVlUadhCIuGI/heQbIDfxRHW49ARMdTeoFhyjOzgmz4WM2rYW5XrqEuel/wBypPqA4+XDKzAeq2pBTJU84vd3++N9m6VexnY+h54xuTfub1R5fuFoqjWKiuap2qoDcvFe0EQOo/Sbu9lqMOa5TIAJzn4fC8T8UuCbODtqey+TWtUI31feW3rFFRqqRUKpaBjeS2E7HHfOoQCeEWj/AFBr/wB92r1d0K3J/duNpIy2tQ2O7y36Ow/23Kqtm+3j4aYLj6UeL9zk3upu6Ry7uXnv2P3/AKCHIHmMYn3wvMYj230IcwEQN5nKMSb6yo4gcf0sAUu0KS4ttIx3LSI64jDvsmjHZV0qyrbDqVSRgIVclwSfwmo5kNT+oc3bBD9OxQaef8OmQp0K2gblOBOBIA3EARyFqOu0S6qjrKxUOop6RhBURtHqOqJG2ZMkEKPECBeYK8iPT3NTYlkB9LK40nbTRnd23/uWZPDH+Np3ZJ79vrFKrJSXWlJOZkLBF6nin7knwSKvyXsXXz+GfXbSt7aFdUg+0WHSnPV0yjcmd1O0r2oBvqRcI4FlyyxcuggJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAlywAKevUorNJq2VAkKbVIGBIAyHO7TgCkEHiCLPgBYYPlf6iaf/o/aCqYKTAdC2v+JkiR4YY2v/7hGWm+0kpgSSCNnmJGBVuGY4DwvlxaLL4vwdrtJkh8B5yUFxTilQPKVYnpeaxaW23lSQlQMAZzxuBFGBMdSN7kTBUYPXp3CyPvJUwkN/ITe1wRLJlrmxJ4KpbCx+I4bu9OdkYwcBnKZHK6HglCIOjeUxUNPJJCkLCx3X0NbHFpzhWfK5NXFh5RrU6a9mSOJHq/ZnWv9U09BWc0fpad9MnGKjSgg/chaknw4X4NkfCf5N90qnZ9bTsW3Svkc/25+UK9BwdnQEVryOqye6z6c2lvUVACJMDwubf9tGZP/rJqVbpGvGt7fzFnbHC97TfIh1jyFkE4nA52R1uRdBoCe/JxvdS1hhhHsvUWIsy+SysrLWUpOPxutVvluQT7btWzUVZLoxJ0cedxzPtyumXlKVco6eJtSo4/cLDanVY5AdOM3uiKVCMD753zosonphKJyjPgtUjaioA3apUIJnDADG81gp2s536WGZZSqdiSepyy6E3epaUOJEJJyzMD87niio25tdTnZWNIdsx7Sf62qChG0YR/6K9k3PE3Rp7Gc3J2IVRSq3HxEcPh0tXqqUKH8CfzvFG6OtnO7GtV0pBjx5AjutUrqaFK8vEgSR06RcRHgslbNKpIbjrKkk4WoPMJxkDPlejPJzqjbVCc0VIM5i7C2kiTE4/1ys0UynTLRaoKuCJOHS6qJBkZjpfKaNyjZ0izEXQ5KOoSsCDaZptXiNxx9+l8GjUonVETscCFAixUzgUn2XkGgWeh+F9SJFgMgGowb64nP3m51KXoAZUffC8rJj3m4ADLiwLrVdUhhKlKMCxpKyEbK+o1aUoVJjvtD1TVS8swcJOWGFoK2ddWvqJvBy27OgOsqi4s9McLoLeLyoTleorBtRMyeTDmbcfn3/K90tCXFCZ8LzRo1gydpWnHVZYWtabpkgf254YzF5aKzaEaBUVCrjn/AOR8LcdHpRQkeUR18qBiOpM3miqJpEsSBSqbTJHv78rW10QQnBKTzGKo+VyjVIvUzbEBxKgTPt/WLt17KElWfH3wvJSjkS3HNvE4ZY/lY6vypJBA+FxGlkNkknEyupgYke201x9RUcfz9lyjaQczlJ+jL37gHjdFt0z33nxNm3M52xRS4pST8rzSthQvLiGzflgQVoOziMcrK0yQDeZEkyrgqRhwTHKyKQAQBZAjRaorVCYZVh+FWfhZKr/BV/xPyN6h8SEOUY2L6WXZmL+Qz6U+URnjPtN5pSBhzPzN9J/ER8nLXF0dNa+lC32VUlmtqKhRH9imcck5AJTNpWo6qjTOz2rKCwl2pQ3RtjifUkr9iQby15NL3Rvt4eW1P0yVvx137M597s8ND9XhfkY2pPl6qccJBU4tbhnqtRUfndeoXLhIPhfrjhBYR8+bt/8AOofJwnG+WBAbQrb3/C+IBk/pYF4RBX0fYqppfWG5AWjenIlIgkA+HG+aUClbZnELE/C8z4f/AChP4TevlYEOUepHS3nuw7IIZ9Str1rSCT5Eqb3bSBOKWwM8RF2+xFR/qOmMJS8GGqP13HHlN7ykvoDe1AMDcBkoYiYF5SEfqRpvI2LxfzPONNWKevRuMbXFIOYKYVAM8LM82hrVaoJX6gTVLAWRtKvOcSk4453ZZi2P8GSHxDiaPqzse8H+zGkuBW+aNjzDIwgC6X0yd9bsTo5/lp0owy8t9IfCvkTX8COU/jfzLt+Ni/cvQMglywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAA44YQo9ATfHJKFR0NgAfOP1tH7jtRXOSSEPKUkzIIWN8DgIPC7H1L0avVr2ruCkfUypxRAzyjcvKRIHDAZ3yk/qJPEuDtBfQiwVwWTzLUdpQoR908vZZ66nV/cRsOG4gHMCOvhndXJE8kaK1gRlpBScMjA6+Hje3ErQFEjjgefW+hE0ZasAkIhwjGYN7CCh1BPFMfC6R8MylkvoZTtIBJxyN8cTtI8JukTsNFHn9Ka1LFfVMrEpU2FAdCk52i9kNQVQasw8DnKVeH535+9jaN9wvOD/U9n7VL62n6HHs5uG1Hq1MoKrm15bpIF5oloqHGXUAAYJA7vnfkr6BLCdntb/wCwqy0LicT3C43jGPC+TD5OkUWJvaCnKyJThYjFFRTqKfcDGd3FNgz74XqLMko0NjVKRQCpBwtbrqAONn8p9t99cjnrlRw2ws6TVjMQ6A7sOBnjmLJr9C5SKU4lChslUERAngfnfpkvpsaZW0rPLFryp9C9zBxjKSRepNqQFKgfE+y0vR+0lIV+lVgJjFJMpMDxz6Xzk2d9vbYuJ0glyzy6O8rEv1HRRuCRgAD1zsGn6pptQ0FocQCokJESr8hflnJo1s0STppnv1xvJy1d0msSTF6kqFjGYHDE3Rp9QZODa3TsBKj5BA64n9L5+ZfstHfwSXFnP+5i8YFhS1BIJIkgmST+d0C+SN8hI2pV53IAB5XpDxZZSSf+lGPuRDVL6thxxB64XSrNQZbC0uLaSdqT94/5QZ28JOEiLZL9ts3a9Pyc/uxXUBXVLgOM2l6v2m0mlWpLlQhShHkRCyZ6FHP4XEdIaJy6P8nW8OkcJ93CN5NvOyZiPGSbbtb20YBP7anKgD9ysJ7ryqOq7ZpZOsmzzS71N4FkrQVESDPCLbmn9rnf3qQ42AlSsQM45XyqztPSoxdZPRZ5tXcOexJ4HWzQuOgr2QOJ/pbh0pulrqBpaGwlKm0mRxP8L87Dw6PXEik6sQlUbjQ3CTHTpa5VUcbgR3+F4kTY8m4jWrA6O+VJCTgblE16b44Y+F85ch5OkcoJUKrSSbNSoBSDYsQSQNxk4+F2nWwlGXzxuUapVwWzKeeRIqYbBUcgLDrLsNLicZvKKuTTD4G7rdeuofLaD5R75WP0d5Uo5qJvpria18HPZKkZ2cibUIU46EjHha1Q6fTFtdQ6I9PGcPtGcczfSKJ5UjlN8mvG2JtLpi84jlc1bt1pNFVFmmY9RAgCYOPGIvZIQlNXwjnXqWe6OtpcsU6OnaYKd43Wl0/bzRnlf323Woz8uXjF4nNrg2+3k+lnTVqvMsexzXew6uh10tc2jYlCEowiEzj8c7R9O7TaDVK2tVDIImA6VBWXdfHzk+Tc+3kv8Wejwiuhyh3cJYU1fzHM1WL2x4mYgYZ59LoUdcxVAFtdOY/lcOGAmZ4wMMYvPlwXw9jpKvQx9zrd/oXn6lQRmcQePtxuo9WMeZG5uW1GYcScCPuzBI8Ra3QccG14t8GFsVlPUHjBIysNZVUp3eo40MdklaRPtPDM2H22+jOhz+/GK5Ql1y1K3ceE9Iutq3aDRKNSkl9LqgI2t+fHPPLDK6uTWvttkun6mtnQ47O91xfxX8iviApUEc+Fouq9pna8elSNFlvKZ8yvZldR21dp4Zk7E8Lg82/vXsxFUKjNY26/tBmDGGVi7Jaa4/BV16ST35d5uLX9Nl7jaoxpG3s+ujPaaHsnbY5NPp1FKScJi1ChY9NASoSPflfn2NKznsk7PTqi2kdoJUjgZCbsFAgYXHKzNmaaN0VHECflZXU93je4skXkw+CtCfqEJp3D0bWf/E3jWVenQ1J6Mr+KSP1vrDlDXmSOezEX8ibcRYzaQyTPCfjcpSn1XZMQQB7OF7fJGTX8KGrjImdtFrQxRjdgsPrA/wCJSgKj2xePqBTVLNXSrUhYYVRspaUR5eKlCcpJM337RfTJ+6NdvGtS/LPN+5Sf3IR9E2cu9k5dzL9ENrcqZEfD9byZBN9AcQaSoxMAdL5JMewCwADMbt8543EwhxKRwz8YsAmBT05ULaBzKh87xpm5TiSkSQcBnjcn8IllGtbuQhhntXYZNP8AtKmmRToSpqjaUpCcnnFyU4jCMU5m6P0vrUv09fTuIHrKpmwFKOUQmCOGHEXiHAg6ZrZzz1G1YQw9YDrGt1aXUlLn7p0rSRBEqkCDZu2fpr7XaotudhqXNsmTAO3vyzvX+OCf+x/kr9UPT8H0Z9FX1P8AYDTCcdoWgeAOFg+hKwvsBQwZ8zg9hj9L3qf0E0/AY3f7jG/4x53L2DAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAlywAIblgANrtXoQq2VAJbEuElZTJCV/d8hPK1DtSmoOl1H7dsrd2kAC8yiWXBqMiRq8nzJ9RtKp9P7Q6iikR/YQqPukbj95SRw3SAOVrX1PZbacLSGoU3/j7vvLqsScsul82qkSR2TbiIHmtWDsaTGcqPtws1ay4U7gMhJ7jeo02yRMsskUpUpURgARhncTuJBmMcet6awLRCfoZO5UHlFwnzKHCflZKguCgPp9R+1qWirAEyD0OXxsK4Xs5JFzYri0GnkuuVNMiPXOx1d+905lZABbhBg54ceYtG+l+pB2ldZXgrckEc0jAjxGBvxbo+LaN91HJ9HTLySdnPtJYR6M1G1B5Xxj7E35WqYlyeyGUSHBYGEXxJuMhtBG87gAwsAU7sBEESL3tJTAvSdGTLRpjU+oD1LQUMgJ9QiQlKTP8AyJH652sazolFWIPrsh2ZwWN3636+zS2SOGrdLXxg8XfuUIevoejbpjt+JWePPVDlQVvK3JxmcPjGA528e1HZJtym9KkpPRHBQ2pk/Mi/qJUkjyaO6d3J2fHk27fB7u57NVUY0M6krXcw6tJMxCoiO/xJ6m7L/ZHU6dyE7QEgHcmTieGN+uUIy5RzXcwa5PDGco8M6y7SafFh6bV69r/DqXPMDgVHJOUweFpbtPqaFkJaccAVt37TCjxA6nrenp1v/FFU4vqjEd+z/wAmV65LoxXd7U6k0NprnMfuxmf5Zxy4dLRTS1iXPTcYJWsb9sGQPfK8/Y1/+KL5xf8AkF3Gz/yY+2//ABLtX2hqqtaZddWRELJyiTIEwIMxco+zuoLUr+0PKgKV/l3fakdSeMWWqMfYzLbD1D2zly2zcdEvkVkPOrAOJUMTwnHA+NrtH2WLC21Va8c144AjgeQ4AXrCZylvXCwYyzvHt/XIm0NPV1KvI2FDoQTPsIt3adpMnZRslCVES8U4n/gk876TZwlO82ctcW+h6Y6qxQHs72LpipLlWZUqClBhIBwiRnbn0rR0tjzYnDcVYnx8PC7t2HGcyadZ3hCkKulNN0VMhscJwH2jhh1F6baShMAnp3j5fK8TkrMzeTUE6NQiaqTuJw/K+fcY4XibI2b1qjUVQJpmFgxkZuwhHmi8lNCy9SJ8icJvdKmEJuxyIkkSR2qkM9IEi+V6v7ZHsF6fBJvBlZZYLI3dZBUheZwPhZNWG4KH53I/ESJqXBZLAheliIygcrsJblUdL7QZIs4TRqSsyw0y9TP0rpCApMSZ4+GR52X0SlXIjH3/AFvXXkmL/wCUY44LQ26nsKGXf3dDUAuSqEKCT4wrGCeGFr66cxA8pPCSMZ8b6w2uqs5xpHKWuHlbjfsdJLy5GNr1LVsAeno4ZQgK3lsrUVKn7lqKlGBwAgW7a+me9NW5CnQpOO0ecCIJgRPzv2aZKSzh/wAHHXsrF0eDuI1LHB326Xl1dnmqtRQlR3bgZhQUMfaMrdWqdldJqwVNJAcP8vlPOQccOOGF+tfI4rfKPJ4Wn0PS+3g+MDcY19xlMNv1IEDBKykYY8DxNkrOydTTiW4A3GJVBjoel9Xr1y5SOa7iL5POtu2PDZ2fbNcET2nripyKh3+4mDuxUSFDM+Aut/oupFpKktD/AJTieEQb39jX6In34Xycl3G31Zv+3mGer6iqQn1XPu3LJKyPMTirA5kewXul7M1a1gOmCYzVCdqhhB6g4G9qEY8I5vuF0MOcpctnRdtLqVhBbWApJV7cOVqaeyjjRG1WPPGDz5cDfRuqwcn3COVHZdsUKNlypUgIV5xgRxHOLc2kdlwVJU6z6apwUk4H9f0vpOfjzwebb3HQ5Rg5PHJ7NPaZTFbsppr7FG24iFjjtPnHUke5tV0nRjTgFta09YUYPOBxvHdO3hnGWyzXYrxjlHojqUUsFxlkEbpOWHKzpb2zOJjE8byycmkWqBqTGEZXtywIwyo9kTcqMEHxvcBAzITELtQ56elvD7S4Ut//AGP5XV7b1SWdPQFGCpzCOoF9dXJdKuzju4/JN8qoQNNZNbqCGEY73EpJ8TjJtT7D0KnHxVqR5Uqnd1PW9eJuskU0lTOcpKhy6/2cpteozRPNNhACWmlbQdqUpCRHEZTazTJSplJ8PhfTXLxSImeffDyk3yafueE9s+yj3ZbVFUx3qZUNzThH/iSMJHyv1ntz2Qpe0lHUIc8rqWdza+KSiYKepxBI4i+qdqzMJHBqsG5wPDgSlfy/O7GoabV6bUFiqZU2rHaTkoAxKeV7ByK1+oJr/Ek9DcEBU9BFikAoUCvT+BvFDO6DjcfAZY8kXJ6b9L6pqlp6us9ZSHNiUbVmRjJkGCTllaR2G1QUbdU2pKXULQEqbV9x4+U/hOGd81yxLEjrPMYhZj8hJ1Nan9aq1DHfUOHHA/cScOHMX2mYFbr6AFBLbtUQpRM7QpeOPIZ3roR4ROo6n0d9DQ212LpGEkEpQlSuRWJPxur9FKlp5vUUNKCkI9MAjAYYADwAvWr4Rq5Zjd8Rd3ER/XL2DmCXLAAlywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAy4gKSQcb6rKwAPDvr/pdLRagj0wUuVSluLH4ISkQfHHrYP9xlTUnWkFZIQmG20jwlRnnfLasl2vJ20u0TT8J5JqCtji0pWkCMR1AvGooblat0KxEey8oqNSojKTiC3t47juBHS+o+1ZVw8o7zwvVr9DLIALxAmBnleqpJTHGBt772uCRDDMJON8aQVLShIKlKISBxJOAFpCXARID4+nLrDdPJUA5+43HhgALtaD2eRp2ntBxG52AsqOEE4wL83c8om6dyPZ2dJM122uo2eiUSyppCuqZutolQp2jZVMwgT7BflnyzWxfUz1QapGdb+lCqi+NEG+TKztEkQqRemxiLyDQCoTIvbYugAy4wFjEfK7CUzdBAJVXpbbuaSfDD5YWqlqQfgbsZNEJKKZbWBn6p2d3lWxAXIwB8ip8U4W6l0SVEmMfG+kN1cnOjls0J5R1GArszWNBASwIQMPOIHUxtzNvlempx7uE36Puxf+RwPK9E1/jf4PSMH/p2v9ZTgpG0KWlOKnAZCcskzb6Vpzc4ieUYX6VOKx5YPOmzyPTNv4T1NDMp+zOqOKWlbzTSVAGEJMwB/NIM+FvVFA2lUhIHEmMr9D2a/c895PPHRs9kehjfoOy1MztKk+qRBlQw/wDrjj426GqROcX2e70ONs5LT6nWhNa01KcUpAHhHt8LWPQCQfC+j2nJmFr9DaRRRTbU5AeHv7bsrThhepbLMEjrybRWULIpA52bshUqAJKY98b2rDDlZkKgZR9wuNk7xYFKhSY+wfK4wRsSIi6guDMhLkzV+ZByvTyfKbr4FYIviJ1G/quAV4XrWMCvxPzvKL1N9AuBObhXj0vrcE+4vVkwYayaCJTMYccrI0n8r1ZkxRTX7cLREe/Sztj3i9KVGSOJopKoVbscR4WpJbChjfRT9Tmjm4ehsQ6zRWakSppBJiDEKwzxwMxa2ql4CL7LdJHKzlLt4vodho1HZd7NpzyzGxweon44j226zR4/Dlff7yfJws8z7b0PQMtfZyrBILCCP8hIHsIt5fsBMge2+/3I+pws832JroekZzXZeqWcloHEAz7JHyt7N0Y8OV93tijzs88e3b5PSNmh7LtNeZYWV9V7j8sLdSaQX0nvfQ5UctfbxXJ1sSqXSG2h9oByyOXfaz6AF1zb5JQUEuC2VEUobAgRHd/W7LiALAnAKriQBle3gCc+FgAVlkxfHiIuoIjQZUqyAk3irVgcTle4FgsGJ8knyIWraL/rVSy2tMtNyVK4Ak2t6cpsIIMEkk+zC/RoVRZdC+g83dS+tIncSXmzWk6RR0NM2ywlISke02YP+krOJ+3oeR6eN6KzmzHkHR5ClPAnAjIRwN4U82UyOP3fncsYRZLqXNhloLgwIlKvHMn5gm807wJIVxMSOnXuzF6izN5MSRqStHn/ANX+yqVUAr6VnzocBJAjajEKTlw8pt/axp7Oo0C2VQrd5SCMIP2mTw3YGeBvtBmISo4STNzj1PnpbS2nS2rApz8bdnbHsi8H1VFM2lHppPrpy3HdA2CMYF9SRfR/g5VdmpK8obdHu9RPiIm43vQspIKSOBzusGAOPs/qbdA1Veo2lSghRBPU+UJ7yboaalNQptGI84M9SMf6XiSuSLI6RlUSRy6L+jKNHq1MtwEj1yFpGP3dM5viYcSlLRO5txbipwOYgi0s3XQet+lFXJPT5nun+3hxTv8Arip8vqNhAiIGeVj/ANuNQ06zqoGDn9rfjM4DH2208v8AA08yJv4j+S7+I/k9SuX0ByBLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAcViLhsADwz/ctTKGsUUrO3YpYTzPExxs3+5dC0arQvAmAjLgTxvnt+IbfiOur4WNPw/k8UrwlT65JB2yZ5XK0lTquKlHaJ5m4uAisMrylDGKZlQ4c7M4lCEhAx24k/wDG1ZA6CirVOkqSmMczY59V7d1GF6iOEZk6KXeyyW19oKIrQFJQtTxScj6aSR8eF06Ssd0+sZqUDFtUx1BEEd4tP4WGrVE1/EiJ+Mj0Gn7TsVbq0OrDSkmNpyPgbaVBrOnuVqnXm9oPmCeG7nfk265LPJ3nrbR79GyPHB5te6nZ6v2RrEvU6kpUFAKMRztB+m+vN12o1rCCmEobUkcsvhfj3Kkmde61+OtM92mVuXzOXablPY17D/ZUCLFTr8oxvyMrPbHBIF5o4ixsrOF5GTYRcaImxNuWAZaLiDY21XQZK0WEibyhXx6WKjLDNwIuY2FEFGSgY+F62k2AKBW3Jyyz9/1uwGpNi0QoBDMnK7QbgYXC0CWCS3tHzspGHvnYAAlJ6fxvSyAIw9/CwYKis4nPhfXuPheWGVBFdzC8OE/G4yGkEYWrO8LVBiwKDTOKxlnNxrOwKOgo0qutjplYZnhdiEZkWSDVCgEnhYKp7CPabrdEbMJNmkhH1cEqVetQGc3Oo6lrBegmtGJ7ryTCvfC9EMsMtt4jpjwvNOv+N0hAW21fG8tETw77pAC0iML410ukADCJA+P53BifndBC0d2A3oRYELRkIHfewYMWBCnA3jleioCOeFgSwdIAj39zfFHDhYBA4pXv/CxuKw/jYFBh5Y7rG6q4AignVWJ1RnOwAAvr8LG+ZuosTLwJFSrWIsdYvO+kOBDoc58sk+pVTqHpPemCjy52g1Wpob1itb35Obf/ABF+vUv+uJdaqEfkeLufjfzMb5Xsl7Mc/wC6S4mDCgc08Z5T8ItCb1UIO1RkEYGbjK0RCLFpusDZ2FxRTwVPGciMLR/9R3nBRgzjIPv7LwVo6J2SLF1OpBPUweRw9zlaH/qhwSoER/TIcLjeB8zVE/I7GtSbWwSQCPxT+JOBKeUZzbbp9SUj70znxGKSPh7L0mRGJRybkLeoaTT1ao2piMYTIxnaT0njmLrUOtBKW/MPLtHBUxgQYPEfKb6KRhOjg4nSSs817f6OdL1kn0yjdiR+vfby7e6ZRaw2VqSEOvBRQsjEFOXcel9ou0ZjKjhNZs3KLqhhabCmjnIG4RmT3dbG1Tu0tUWlEpKTgROMXp9C9DEeCZTFKlWRC9gwIEfmLzTOBbadqfO2olZmN6fzm8y9Cs0vULJ7F/tqq1murm1KHnaPlCQCCDJ3EfrdX/bys02u7Ak7XKeSoGcVkkbucfxuav8AcfyJqd7Gxt/218y7VWtHtty+oOIJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAlywAJcsADhyulrut6foVC5V1z7bDSASSpQHcOpNiN0CpNs8o/3O7fT0+CkKLxSesBM422/rT2x0LtTVPuMVSnHGi2GEpR5CCIMknAjORn3XjbyHJs3p4ZYx8UeY6jDdUoIxiVTneag+oV7RMoHm78ryuCo0+Q8gHFbWFL/Ebw+4gN7fxDE8ybUVJvJLI+ALWO0q8PE8LxukHkZvQBlyO1AOZ4xAviyXEf8TI8LASDygQJGNzjYBOiDq+lWpfte1DCFHCoacZ7/uHxFofZyrVQa1RVG7b6b7aj/wDaD8L493C9TOm1XBo9HZTrdE5aHU0/c98p15Y59LrUTwU02sH7gCOOBF/MkjWxVI+xrZnS20n7Co0uLCw7Jvkys7okS6hXdeGl8+64DQLjaosTKsbpEyMpdQRheGlDMXolmKNMstjdeULhN65InRhlYZIF8CwBndFkFGwE2P1cLYFkyWghUkC66ncM/fpa1XuSyUzVG1OxlkLqP1IE8LtmHIlfqbUQjlQAJtKrNR2jAi7ZnLMqJvxotv1aOtpAcU6rcpR8MpnldbDVGVE0rZeXUDrIsBR5Pz4XASi0zfqybw2SpYFgKsqostYgY996ZQDhYhUF6lqmHjZKRrjON1FiiSJsfsBrAUzZK8At5dLOysKiQw8iPV4zeqkQff43kGnQrAlVIIUeGMzwiyVaTjF1FMsrMtKKQIN5bGHUe2w4M0XkI1qHpubThYKynUWyU5xwuNGotNhMjTQs07wWAZ6Wi6VqKhCVkjhJOfdeDU40ykjKxxoXMY3WZf3AEGeRuELRS9OV10vdL0ZJRabLB8bH6uGd6JZC0bUbxvnE910lmaNUdUoxPwsalnrdIZo0RasLE4rxukJRTK1dbE4o8LAAG6TFifWdpuoJEYZXqF4/KwurJx43qKLFZMSJN4APnHlNhrngww+6Tg204vw2pKr6RWS6lc4r3Rzn8LMb5OMJfJnnWq6oBrVeQs7S+sexRAx8Lb1VVrefecmCtxSz3mb9sYfQvkaPn7JXOXzZmxx0mvq9QNrXvTtwV077bIqlpOfPmO+8SjRurNRkYcqHu1qbK8N5lUCB16422dN1gHah0x0V18b4s3KB2TOcZjoVq7qF+m6nZP2O5BQ5nKbS3q5lumBecSUKGEyVcoGd86NUdk+qZz8i83rITU+itZWFHCScDytuVFWN/qtBRE4E4H2TeaN+J087yc/Md7VS+w6hxlwgQo+YkpIHDkQMRNo+i60l/B4hWBw6TmQLxRZRaOjaaMxlY6KTVqfVW1JqSQUAwr+WeP8AC0JVU3SMrcZXO9RO08PfhZMJFaDZT1ZxC65aUncoKKd0fOwodZeq3XFHGFKCZ+5XTxvrD4UEnSRxmvqtFk8tlmmbLTiSiHo2najHcr+SPnc05ZS+pwA+pt/tJSYSFT9x5detpcCS4/5ZI4dUFd2eq/Qhpb/aqQksBLKFranE+XA9AnoLVvoTpaqXUPVX/cccpm3HFkSoTgPN0MYC8avjNa/iLtf0f8wTa/pPWrl9AcgS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAS5YAEuWABLlgAYqHkU7K3VkJShJUScgBbQ+sXar/QtAXTtYvVe5sAcEx5iY4cLcGNksUOTeqNuzzP63fUVzXdQNGwvbRNmBBwWArPxJto1ekVmtLeIG9NOz661JM/crCfbiLkpeTMI1GPhH3Nteoj60/p9QEuNH0zH+Hion/MTkPCTdrtdolJov7dBc3LVRtkxmXF4mRn9t6JbM/oWkN15RU3CMEwQeeN5qj6LKMwDkOs/xuhZZAyr5SSk5lKh1vlMV/uTAngf1vUbDwjL9Ak7yDKNuJxEA+J6WapSHP8AC/CTuTxx43SRvqRqiv2AEFB9+N5Ws4wJxugy8A6lMqT43kL2kTxsAAsFuFfyKA9hkG9EeogGZlMSOqcrjyimoYdhUz2nspWit0LT3cDuYbk8wI/S0b6V1fr9macEz6ZWgjoQb+f3Ma2P5m+9jWxn1O0neuLOX7fK9XyY8qdWMGxMr64RfmkWR7oszFig2qBY215cbwys6ERbbVNjbXeQUF1tyIuulzDM3SCgXkvAiLqB2ALoySi0XvXE3TD2F2yNmaNUWVvGOnxuqp6RndbIZSNUEdqCOPx4XUeeEfrnZsgUSqzFZVkTjHSc5us6fVMCVd3vhbkIqpfkkis64txcqmJxExdg0MpjKc7sVkqEngy8ndNaU6SvxHXGy0DiKf8AtTBGOPPG5ISuzUCRpR9yy63tbiM7684HE4Ec7yaeTeGYUqdAGkQ4byFJbMkfleQ8GkvYKTYo0yZI443qgqWI4EEe+PC71LBqw8IzNSovtMeUx1HjfTqDCEDEDl1k996jDk392Ff8yYczH2pt9QdbTw1JvlTqTLjC0gDx6YY9568LzKFKyy3RcaNQ2XKjMdE4yTsR65uMrlW8MyQccf4XzZHyd08exFwJr6J9+V8fqW90TldTCQkiMy2iPy6WGo1BphBUVARY1GLYWCSkkHdA2nGBdRNaqoTKobSeHGPG4kapo0ZUlXJTchqpWBIxkRzsjjHqu704YZnjdauKY8qVGPhka8b5LtDXEAJJ9++wNJU3tywvnJUaeTUXZFgWmngqCOIzupTveRMm8Fo2v5JZf3yf0sKHMsY8bgo0vYllneJxiLDv4TYF+QCFybEXBMC6QzReh1a4sSlzl43QiBmHV4/pYnnRj8RdQQsgKoXANhdcJN1IqRGSTBOKzvDhwOX63uKCMTZlsSu19R+07Oaq9xFKtA8V+X9bofUms/b9lKlvCX3G2/HzBR+V9u2X/bEvaK9q9jj3cq0z+Rnv5Vpl70eXKVM+N5MGYv1g8EmZvJzvvhmwANpcjMmeHS8TYAFk1jpATMQMTxuuDu4/pc8UmUvm6IETUq2xiT1mxHD+FqQL5Mhco6pbSgQYuu2oAjyqV45fC8yjZo3GZgVV6p6iUITPXrjdBDyiQJgf5YF4UKNnVzs52y+wopVJmT8LC0sJV3TYGgOnsq621V+o+lspSEg4Y9552laRV4oBO2TuPOMrxPoWSNQJFn0j9I2W/TNQjb/dAVI4NpTCEDw987RPoH2gZqW3KR14ep5SgTwy2j8xd1uya8MzuTRdytWetXxMQIvoDkDtywAJcsACXLAAlywAJcsACXLAAlywAJcsACXLAAlywAJY3XAlJNgAYrqxqipnHnFQlCSo91sT6tdrxQ0KqNl+HHEneEkYJjGe643Ssxtl0Klbo3qj1GF2+7ZVfabVa5xEloLNOykidrST51D/AJGMbmiUlDTae7q1btS47vbpGHRv3EgEuEYYYmMM/C8yfkxwrNxioojzKl+p3RdMRpmiy+sMpqqgNvOKiAgpSogzwTEGcMbQO3ep1YoEMPVexCUJWw2mUpcSqJSMJO04ycLJUiK3yJZZX4rgbXbbU29T1l9xskpSSEk/ypwHwFpFS/59+Z+ZuotBksDWealaK8PMfHAWeobQ8llKsIhSvZldjhk64D4BSaHoMrcIgr+3kn+N71Fa1wlKQnkP5chennBIrqToHnBWQCsbkkzOJsqm0MUoM+cn4/wvRLt+xHkPCKqk/cAcJvpSpxRERxN0GS02YWmPNx+V5dONgQG2qhTeE4TYcwYnA2AB6T9HtRQukqaNMbkOFccl22/pfqRoe07CCqEvpLSvE/b8b83fQfxHXuo+Wpns/bdnMTj2U/Hcj2BJIPd7b5mkEdL+fJCXofVg8mY8otMud1gbUQPZeGVneLMxdF9D11m3jF5YNkTLyXAeM3WQ+JzuA1/BC0V7hGV1w+DYFvJCx6xGBsKXM7At4IH9Unl3j9bEmT4d2NgUhFgr4j3770n7/YR0ugeVEN09Ok+Yj353Ypx177KgGwRNOmPGygTd6EsWQTtV01x0FbC9jgyOc8iMiLUFCQb0QtWExnP6nr2nPqS40hxIwwKsfytx11Iy9mgHnevCL6mbMtyXQ2IjHaBTqQHmlskj7hinvu67pKBKUJEKzBEjumz1DyMqbNNJnaOuOYUCkxHQi6KqKpod3pkqTxSYw5i8+DiaUr5NR2JrJzaoWhXR+OeVtx2tqAdskdxkcul4qX4OiijrcTl5tcjjVqCEjOLbgqCoELcXliAcb507Oyil0OkpYOMpyeEKGo6omCd0C0k71nbs3JHE4mfG8Rg2zsqNSmkjm1gFUai+pZSwIP8AOvL2X39k4tQxVB94uLWkslckHslJ4EUUlMv1byfXcU8qf/QdIAtapNPQjbKRbC4MSmTwkzokD07TnQJcWpQwgEyO61RpCUpEnmP6XZyRzbJGNGkYbpgB33aRFmwWhZUcax+XO7LiAYsAQrMnaR055Xpbe3Ef0uFKAyXRnOHtuvuPP9LgopPIth8XU9RXU+24WjSz/qZ8i4p336XTL5yk3MmkikbDuu4Z93W6a3/KZOWFxI0kGzLZp578N1VulXvnZItFbM2dK/y/peROZuoEllBo45iBzzi+OYcL0ioxIPqMn6t1P/4FCDA2rdUOZwHwFpf1OrP3HaPZODLTaf1N+nslzI32ka1fM8X7jJ/TH8mP3Cd7kvRDVWkjH5XtwRIjib6g8wAzfTn74WABy5YAEi4BYAGk/blekFITigqPCTA+H52ABGz1JsqUtkDcW0HbwlR9lgCkQFHFM45XtCUkYDfCSJOWfSwIrNKn7mkb8d0A+ON6Q3EDakFUQZ9xYljJUvYt0Kl+qkA4YDD4xcpyVOJQVDagEnbhlndM2iXnBqh6fT3tG7oupJfQVhKVNiQcocEfxtO7GwK1BdHkUAmCJxKgeOVyXKokpBZTs1GLo+rOz2oDUdNYf/mSD7RaT2F1Bt2hbbQRtCEQJ5X1i7RnVLocJKmb3RzY5LgvYOYJcsACXLAAlywAJcsACXLAAlywAJcsACXywAOOK2g3V1avaoKRx5f4RgOKickjmTYN0gErYh9ue2FP2c0115S0hZ8rYJElR8b8j+rnbBeq6r6KFJU1T707gZBcyVEYQOF5nOjDduzUIeTOij4xoT9W1iu7U68w2Cp9S3ZUnP1Mf8MDgMpVdKp1Km7J6LSP07h/1irKagqH3U7P4G/FX3K6m5yLw0i4ihVu30F7tdrOndnP2Kng3WVTCkq/boVDKSkEbVfcSkHBROJjpfnuqVlRVgv1LxU4vzEEybra4IsEjfyRXkr69rL+pVCnXVlUzAnBAmdqegHAXQeQ5t3ZJM453UixzgjZJLADcpbuCry0krdUG0qXhA6m57Gnj2BFkUKlClvNpAgFhPtjEm7K2yj9qVpj/t9p/wCRgXldSdTRXwU/2/lW+vIJ8s8EpEDvNyrcDgcSolKCsNp8EjE95uglCymGzUHfjGETlA/OyhaW2t+GPlZT4cbt0ErIWytU7GwpUx+GOdj1FYCg3mRieU3Y2I8GZPBJMqr8biroICIH3eH9bjeCssONgAWdJqVafqFNVIMFp1Kp8CLCg70xxBi5NeUWimtcvGaZk970mpTXUNO+khQcbQvDLETaJ9L9WRqHZ2lBV5mR6Sh4ZX83cvGbR073XWy/U+v28vKCfscv2/Z5aq9ByhvD43uAZ6X52RnrQQFUpxxFmLW8HKYsQvBUBCzuGON6WyUqmzQKmQIhUgcb41lwzuBmggyTGPPjeVKI4ixAAhcA4nvsTZK3McQO/G62QAtMElW44dOU31mB846XQgyNlxlQAjrnYG3hjBw4HjjdA9+AXAqAMp+N1g/OPGwIWizuTiLr+rNsEJkqQR1AOMXguHrN0ZBaMLbwyvp3G4Xxb6ALx6gVsBxJBFlDT2wrDZKeoxA+dkaWuXoRmmoXXl/AmP6S0pWWc+H8btOvxgpMGeNxFMPg6faEh3S0oWSLUFwuSE42uiU2cq9jr4JCeKXbJ9g4WoinUc0x4nbz43fMihI5+J0ko/8AwoopssMLvFCQQApHjuT+c3XIngzl4nTx9n+gFtiEjl0sh3pwjhwysPFroYoroiQn3ysSnolPGwRkrQYKjlHHqLrF4kZ2BLFB1PInAjHnxuoXhlhy5kWKkLI2WFuT0HW6ynhtz5i4WjVmbI8oDJWfvFhXuUDERNxFNWZs2FGTyvKAc/fxuB8mrIuDqlniOfhfVCcBj153QikBLVOF92Y4cLosjsAgmT7xZ0tAWIyFOBH8b2qQm6mERhlaoUEBSiYABJuh2rr00Gj1jxO2G1BJ55XuBvt4OU4r3MSMdzPw1zl6J/qeW9qKw12u17kkgulIP/HC6W8rdUpRkqJUTzJm/bpj464r2NHze6n575v3MN22YcI3jwvKz/cJF1AgOKAkze0pnPjYAAiBne3QQRhcAAO+7SoSAbAA6k47cRfUoOZsADaSN6ueAvVOyVOownzDLxsGEVclgthr00K/CAVYdcYs66Zx19wiEo3wSSOF5byThGkqSLVsyuFEFJEdLLt0+mCvufWAMjA9tifU/YF+le51lbbe6YlZA/8AX+N8RWKWfIy23hgY3K9ps7L4+4VEv2F3RtTFMUw2MYAUrA2nUXqLcQlO5aiQAOZvPg2burN+aRhJs9P7LfVfU6J+npmygJK0Jnwgey6PYzsLUPlmqeOyClcKwmeEXIwlFXZmfcVgTkp4o6R7ZyyfQmgamjVdOYqEmSpCSfGLb/YutOnNppVmUwIM32i7Rz0z9TzSVM679fp0HbfEqCkgi+oOIO3LAAlywAJcsACXLAAlywAJcsADijF5dMJNgAM76r64dO0GrLa0pcKS0yDmXFjEj/gnGba/131D0k09KB9wcWozjipMxzjC8bXSM7XmjemNyNaFhs8m1JxRf/vHBsFX/JUyPacTeAx/qFf6c+RMrWSeA8bzERNyEgKv8JzVNQUXDkwlR+4gYGDwAyulr1adVr26Sm/wkqDLY4TMFfvwvVAgsHRUFbrbxLWCNw3K4ZxCbd+k6O3oOnstkBx50Q2JggynzbfE4TbIuq9RaJTf4EWt7NJp9J84CCCoqPEpGHfjar2seHrmhClAloEp4TAkDxWPuygXVhKyN2R02WsDM0xJVqH8oSlUCMNqRl487NRtenVOKkyuUj9bOx0EasLDLFeo+gVNqne5AH8qYAIHK8vgJcbQT5EEYfH53AUFCvHn2YeXP/2zPsvFY5uW4pWClkyO/CLsQiMMCt5IcSrAkDa2j9bqKWQ8DOKSI7rqTNEbSMy5MLJVKlYmST1k2SrAQox+NQV3RNgQrVFfgb0AcBzn42BAap0FSssIsiN6FER0/hYAcGD5CvaIxn2X2r8mPGYPfYArdjy+jmtim1Ko091UJeAWiTHmT+YNtPQ9Sc0zUKWtQYU06kq5p43w73X5Rv0O2yPnFo9P7dt8Z+PqefVNwmn7n0A0Qod10tG1FFfRMPtKCkuNpVPDEX8po3vj4TaPtRfBjt9nnrTFMJw4Z+N5YWvIxl3XyYZ2QjVEcb8xvasU5fmDcBQYbQIy/rZGhHjcDKAFSnanAHMD3F2Khre2TxwsACsyoADjGWEXFNFCOGMyLtBEbIyKrgCU7gO+0nVGK5KFPsqJhXlbABUr+F6UWzrpceMEckctilyLbLg25/8ALnbOc1/XWt4doaptI/GhClJjrhjPgL5fbl6HsWuD6pnZTRw17JKk4j0VW07Q8yxbNp9UNRG9xxK4ODko+CwL8q0yZ6/t17/I9EX5cE1y/HzHW72hp0EBCd0cZOfdbY/cVaUF1unqHmkmC4hBUmRmAQMe6/Mu3Z6lrbXB1hpv4pUR79UOWL7vaOpVPpgN/wDEH52iU+qh1RSlt5wpxWA07KZ4Hy4G+C0JHTwl6HaOjQv/APXzOH91r/8AL5CkdWrnTuU+r22nuVoCZDKzA83lXh8MJvK1xRrwl6Hpf248Qijz/wBzra+IVWNbrKdJPrH7uC4+E2kl55xlKw2oJUSR5Djt7srnija0zatHd/blzFP8HnXca5S8bHRSax/qTaithlwoSnzbQjKSZKM1Kyx4W0qSueplvemsoSsFKscpzvL0qS4Rtw2HWWrXF2pSVviyeaeHJC/Uaw95g0ltucikY5cFGT8bQF1rh2iZz9vC+P2kjo4e5tatKVu5GJbEv8or8l92pfWolTpUSZzN12EVlT/g0zzmcEIVh/7RHxvChE6eCs22lwkkcJd1qjzJBVVS4UNysOd5RT6spS2jSKSpGZJTABF8/GB0+3g6tnml3urlV+pP3tSkwhaxHM++V16hrVkr2BrzKlcBQHLIXzeuLOn22d5Si8tJnn/utN0WTq9QBJIXzVH9bRNU1FvSfSRWLSxvVAkFUkcMAfjfJ6kdVC3g6OOp+qOM+51c5Fd3XtqTuQiR0VbfVrDNSSmnDrucK2FKR4SMfDK+H2Ud1FR5Oko1wzH1bF9KfzFhfaNoqIX/AG8cwcOUH5zbfZ0Gs1GpHrrd86pCU/YkeAvl9muh1exRRmUqfIlodNvI6WtRQ+2lSFApOeIw/jN40/Q0UqNqMsBtViRHP8788tdGtk1yTyszGLui83C2iZ6d9lbbhKEgZn5XyaoN2zpFuyxVBWGNyMvjj4n8rsoSEtg5D5+N5fJOpuIWEV1ICRenVj2XUVEkAO2D0vQOMznYEBIETfFKwONgkADcVEkmw1jyGmlLUrBIJPsuxRqCtojdGZukMr6sauEUrWnoWdzqipcH8IxtqdsNZOsay84DvSlXpo6QDnfq7GGXL0O2iHhrSPH+57agoeuTzd3u+9ub6cITQQkE8rw8SE3sI5AxulffeeOV0ABQSIx5XEgkYiwACGCkZGOtxAMZyPC4ADKYBx8uOWY+FkDTijhj8LACmcJQB/8AGfAGR43pxTDG2BvXmTwB8OVgCul7m20+kG1rOE+UZTdcuKdcClqn34XH6FKsZM2W1uKX6ih9qifgbxRguIWgAkyFD5Xlqq9SyN2SFsO42G2GnTm4PN4D8zZK1KP7aN32JSNo4GBM99y+V6ZMo1WLLRhLiQ6BGSRj43lO04458eN6vBkhUh09iqdlypQ+4Er2fak5T1vfYZv1EEjAJXjeN0mkZ3HXt9ak1Zvtk8Hpeh1K0hKgBwsXZ+FJT3XyyRuj0+C8aSKOvTq9xO1eE3XpvIMf6X117Gmc4yPLv0HomrQ+Oz+ripQEKOMYW1dL1NdHUBW7C/bqn5I4Qm0fL26/Fnq36U+D0HO0Ci7Z0TzQ+4qBKThxGd+ozCfkjxG9kPCTQv2jHtWwftB7xegYAszbbHahx+qLYJ2+GFi0DPkOS5cBoEuWABL4bAAHUkBtVirV/wBpVgAjw3621q3u0jjQO70kpESSRAgiOGONof1JrHqrtjqkrO1qocScZyWYg9Ii+M7ciPMmd9XwFiqghs6rUjTdNdglL75g9QnpdHtG8qqqEJyGGfCyLEMTCdkqdo6g28+tKeKdyd3wjuvOkVqKXUKdflhMJE4JBwgmLrolmVZR/VKXKNLDwpwXalJLS30YtpC0n1EI4RtMzgBhc1CuRXuUDaqrcfKh16IQ2gNpWtKRiDGIwiTndfTAvKIuuf0FYY2dcV6jlVVvq8ywGWQT5ifUTvXhwj53Q7XamHNUeDCYZWslqfugH5k3EWisl9BNpHQhagZn1FgdxzsT1R+2SBgHHD5uJF3oFl+xMlDPLG+VYyfl18LxWrS2lKEjcUNd5UrG1EbdgFCod9R5ak8Jz9+N4O0EoTw+49VHgPC6sF+ZGADh9RSREHAGzMIPqJVEkklIPzN0l+hnqapA9RASW0gYhAnxi9VfndKjjiO89LpI8GXxRWkwKUygEcNw8ThdilZ3EJ6JKlcsboMo1RHUJSoGfwQR4C91LTm5yMYMjmONgPG6KVKlJUncTBMXyoKtgzyxsDLVB31BN5wcj874CZ9+FgiA9L+j/aRT1K5pTzkrY8zQOZb6c4thaHrVRo2qU1ewopUysFQH4kzCgeoIvyd/p/zPVtgpwcWe79t7h/AePTserYpI9+YdNp2iawxqtDT1bKgpt1CVAjhIxHdfyWdN2twm1R9uLOfb7VsgmhY3hSc8fG66XiQQMenhfGjTR2siZabUN1hacxEwOHiOd5ZWbREy2QFpj5WNtf8AD+F5BQceaB8ud7KwQfj32sEaAFFMN6FKgwek/DKJs6YSOvhelJkWCOKKwVU1TOzvbH2FJgQJ5ReqlJglPG/T22/NM4wl4yskNSeUWMq5Eer0JlJ2vtpcSQncMDtnH2gXeceJdhzienG/dxk56dqaydtcIPFX8+o1v0KTKazT2DSaeGVs7jsTUIUds9ClYz6Ws0rjTCQQlsqG4yoSJIiY5AmJvUtjs3aLt/bO33R8rcJez/g14yl/kxq0TddpGsVFVUoNSioO9xCEbEtqy8kbsI6zbmqGGn17220p3TKMYHgTjeFt9VX8icU+DyT/AGzZBNJv2Z9HW1VSd+4NrVtEq6ZQNM8hZGASkLk+IIjvF4VpCifInzcsDHiIvS2J9bOfg1wfF29t3GuSuWP0o+1PRp2cpNfIWaGo0yl0unaeSGj6fmSptRGPPYQbSFMaghAT6r2GABJMDvvs9jSxZxvYn1Pz/jt+62pP2PuP9s7SV1FIUHNT7MqKwfS3p4KYVxww/tY3RW3WGFFW3jhEd99vvbKyv6HFyleWfH8e6xl18z7H/wDK0VWWH7PVOj1LZL1M3TupKp9VhDeajBSSkCIysIRWBC/OmDEyhJ7r3KafsZbnXOPkfG3au4T6tV0dn2P/AOZ2/kvifyl/6F5a9LbRg6wABMBaPztvf6etayoqM7J+PhdxfNmT4ahtfMZfoz739joSWHyZr+0FBR1dQfRdeC9oR6SRBIEHFUWNzTFKmU30vHJzcnLB8aPZ7ZpUj7i0aNawkIz2qaijV11bdI0ptxoNht1ahtIM7vIM+FqLlGUCSkKIvbnFRps5ZPmav2zZsWbXqfTk10dDb1Ls6vWq/wDd1sKWPsQkeRA5Dr1JtwVCEuJ3phvLAThevuVwZo8cf2zVFK80ejy8bvIk0mjUlKnyplScIAw9zd1Stx8uHUi622Zk6Of21FUlSM7ttBKGnSzK0pAUYE9B0FmoQFGQcE5fneNk3wjEjG3xSo5+TkwyWtgyxOfGymMvZ3WlLBkyo5bNGfTAUm+boM8sONgSihXHAE4nhdOofNlk1FWLwZcjS17jYAsnHK4WikQbfjF43BIuFKRs64sBOPddavq0MMrccVCUJKicgIuxRqELa6klKjM5qvTq2Nr6l9pP9L0pVO0r+8/5BBxANsXtrrytc1dxYMtNkob6czfbs9PlO3wj06Nf24JHDv8AuPtaWl8U8fg8Xd7/AL21vosISkrPXGZm8TAi9g5A26SY5XEY5kWABEc7IgDPcmwAR1MZCZEWRr0szKvCwyDS8TSEjhneVOpA8oKcbAKKI5BVYIMYH4KHH2dLC+8QBjMiDYFkRswtGEkpT443wAr6RzNgQckbCMZ83IYX0ei2qd27knL42ALhdbLenKV6hja2gCPFXicTYad4h5vp+d5msFlwag/wSL//AEIVKW4tU5qJNw+R9xMRiSOOd5whyaWRwabEBeZxBT0m8AlUjiBPKzYwVEHV2MrkNI9GRuKp8Zul2IoH6zWKdGIT9yo6DrfHcjW9pRZ6u2lVGO0UnNHrXZdtamQtQw4Xf0tCUUqG2x9oF+eTMnsSwXAoesEpic7Adw+4G7Fksy0bpGzU7V7DMFKpPKLp1lQUNurA+1BA8VeUfO+sJZM6m5bIr3OG2NZNb3GOqcvRC72Io1VejipUqfUfdUD1E4fC7/ZmiND2WpAny4E4c4v3alUEWKpI+Zvd7JfMzJ22yy5RemMLJT7nTiboMgrpQhhW/bd9+mQWeE2Aoo47lgAS5YAHDfHFBCSTgAJsABG7X19Rp+lPuUyQtwJJEmAP8xPAC2F9Ze279OxU0LCwEEFCoPmWVCAmZkAZmPC87G1ExtleDWtJvJvTCsnknavUnKvWK18rH9yoWtZTkVTjGOU5Wm1Z/crQn7QfMpXUA3lDobeKL1KVbIeLisenObzqYK3kCcE4eJmyEXkjRZcHaNE7nQduO1Kc5UDMjwsNQ8mkSgNqJWM+iTOV3jkrozyS2har+0jjNHR0/Fps+oZ8y3FRvKjxk4W3V1CnfMo7ok+y1BLgNkb6ll6oW85676iopKlIR0GePKchdFNUCy84o+aQAOsz8rGmroE8jLrqnqlKicAtOHAY2BtyFJUf5wYssIpeSeQqVSvTqFLiQrAeyx17qXadDjZxBE9cRBvP+oSzRrgPKAq2ofQkZEbies5XhZAeb8B8LJYZVwyXkB6dvctxZ4ZDhHC7KGANhTksAzyzNzoiFBWfYT67IAnaNyuZN3H0p9OpWBK0QAOUAj9RdTqyEorKLbiWfWUT90AT/wArBUFC0IAw3FR/hd6UVWQB31em4rHcIUU8ZBFjLnqJa3CCn+2r5i0Si6I3gAo/2t6hhMe2yLSVNOCMPMnvGIsCNsr4ZTOEx1w8L4D1sDIOJVAPePbcTgD8bAAen0r7WnT6r/Sal2GXjLBUcEOH8OOQV87ZrTi2XEuIVCkqBBGYIxF8O80eUfNLK5O7V4PV+39z4S8G8M8yfi0z6Ap6gKAk4W2Owfasa7pjZWsCoahDyJxkZKHJXW/kyWT0d3o+3K+jPtwlaPN2PdfchV5Q7kvcPjysDLo2jj7878zRWj1pmVJCg0uQCO+wUyyTgY+V4aNNHRMymXFDdjMYZfneUKN5FGhZtBCfLhyvoKVDA5e3vugA0YIPHl1uHKbJkI0Uo1jXmJA8OXW7L6Cqf04311T8WYTNa51yZE9dYtpOw8oPK5UsFQxGA9ov1wnaOENjR6dUkcNe3w5LOnak2p1IdMD+bpaWGy2ryqnHLIi/VaeH+pyjsTPVJOrXPoTVtUspjxpG6beh1UFEbsDOE9epGPhaHpHaBykR6Tu1SMRtWCds5xjHDgL7RS8k5cGYzpU6cTEt2yUZwg6mvU1u7fXvqVuE1xKOB017VA8wpxoBAEYZDnhNoWpa1RuMH9upaCoBSkx/b3HMJV5T5epQB0m+u3wlwkc9njzC89KOXb7e61zjHb9Td2zp20d8H47lGVPE08tfIsLDJazRlOWfstIarpZEnh752peKwiLC4O6m1JqpGbfk3yLtHp9K80tanEIV5dqDmrqf1NpDOrAM4q/CAnrPW9xgnF8Il4M7+8nqnGMdcpK3cvQOLvp6it+2ZTuVKZOOYmOotEd1YICZc9xc8aTdAr3uVKmkVWXq9aGcUwR7LRK/WfWwSqfneJL0LKSCk5LOA/GC5C1ValO49bS1KdeO5cwcY6914qiSl6GZs4b+6StRybU6t9fl4k48LidwEIjp4czaUqMSkXbspcnllNzZNuz+2kyo/cRmPD9LNTsAYqMnObSfqYlKyzk5sRQemSGxHK+pAAniZ7rzN2CxRTZVhx9uQ98rwSVjwsgGQysiCQYOQi+OkjhnEXUEQj/gGsDiQTeVYZxdKMEs5OPS+FXG1WVIO7MyeTSnIBPG0rtDrbGkac9VOkDYk7QfxHgBzNoo66db2SSDfU5b9y1Qbf8Axjf+pvacUlGdOZch14eYA4hPGbYWr6nUatXvVbyipTiiceA4C+nZ6bfk+EemEVCKS6HH9w7jwh9tPL5+R49myW2bk+pWm+XSmQdFwYXAAbSSTAzvjUbpJsADe4ZQOfG+BCgSM8bpLALNGJOQMY45XtoFlnhz/KzI8sseSxVAapcukRkQLyuXHCfC6hwSXIq2zhSVIJ52cMLAUjjhPfwumbIaUcFRMDO4pJClA9boMlo35VY/peU4mBYXQSTLFZ4NoUQQrobmIERcfoFnNhRopbqPMG3E/jSMefG7GmtNOUIU+J2rltE/fOU9Ez7byupJumVmoK0YoqZa1BW3dMjKAZ625uzGkByoS8/tUQRsREIT3WlJHLZOuBCLbO+nWLv0+7PKoqf9w6iHnoiRilPLpbp0WmhtJhPD+l53zvBzkdO11+OX+DrBUkKunoLTaRHPndhpopaTl5byDQOu+ZN9I/t9MLABiPqLpbCxMDp1Ix/Swdo1FtpwpOO1UcsDetH07oP3Gv44/NHPuvr0TXsXbbhL5M9F0nUWFdlqVZiCjhlkLbumVqm+wlGsq/CRnyF/RWSR+FHyHyWa+pi/Sai0t6EmPC0Ts+/vcC56TjdFmbFDmcfWpOBvKSC0DhYCxQ67lgUEsdQ8lhpS1GAkTYACR247RsdntGqH1KAXsOzGMevdfmn1g7VtV+qO0i3f+0oxLiR/8r0Slv2xN5nLxRz2ztmtcfKR10wqPuedduNef1KqdcccUouElIx8qJw7zaHV1D9fWqA85KiTGQPBPSE8Lzy7FYNUoqkOphTo9JPVKCnnnN5eU3StrSuFOqzjJPIc7pFkFeCrWqA9NZgFQ3DHpYqsFTbSlcxzzmbseQiS4DKzhU8qfnzvjywhBi9COTDEgT7oALaMsieX9bAVE996iimZPoZfJzFQieM3lRPxsADaUKVwnjZKQSMcBKUz4mwCLHkKHdydhG0KTh4/1vVYj01bVDqkYdRIueJFdmrwG6Mbh5dwxBAP63oAvsoWMVJ8iu7jeicP5kTCzkVaEIdoin8SSQCMcxheNBc2O+mTCVKHyvLDtm1wREDkVCgrJTRQrxER8rLqTSWX5TxyI6nG1AWGINUFATw9Qkd+d2KluFPMKH3Ara/VN7RIu0Yd5+ZpmWVpcbEcD5j1i8MBKQcI8oI6bsjdBFkINtkr25KAWAOqb4wo+lj9yFkz1SoRYj5KEilUoQlSgmc9wnobPVto/bhzGZ2zdCMM1IqoEpI6/DpcbgZ2BkGf1x9l9WkCI52AAr9kdYqNHr0vs48FI4LHT8ro6Uva+PGbxvgpxyamvpZ17bY9c8GdXxHsuh6uzqVIh5tQMgbkzik9DbK7O6u7pr6VoJ2KwWngR+d/P3anF/0PROPkmj6enctiv9Tz6peNNHpTSxh7bT9O1FusZS6g7knLqPG/G0dJwpnus5Qn5IXGXd0A4njyupT1QChjyN8WjTizvFmIzFIBKxGXhgby2sKKVDL53gNUzqROwyQU8+F9SrEceNwFBlQJGX52bbu4e/jYAFN1ndPv7btKZlXLpdTonUNF6CQ/TQft74+VqjlGFGCL6RmYM/VF2myiA606mTM+I9/bayvSAvIRfeO2upxRqPd7Y+5i0N19yoTICcCIjda65oKiOvsn3m/St557Z1/vn6HL6RuiqqEAjYrH/Na4vs6VcDjfp+8ebyZ2Xfr0OFREEVr4jyr/APsLWHez7iBEfC/T9483mzu/3CKOHhH0EX9wtRxSrvPC1f8A0Fc4pIxv0Pa2efzZ0l+4SfCOfjETm0vLOG1IOOWUWrN6SU4R0vq5r1OXkJ9xu2ew8UUGaeT158LVW6EIgRlnzvcpnOzCi3ydPGimzTHpd/8Ab7eHK65GTKibKwaCUxBE5eFnKfh33SGUWiv6c8/1spTB4crpCFBwBwvD7sA454TdXJYoj4JJgycfzsTrmGHhjdSNRRG6MSkZeUDyE4WBbomM4tFYNUJNmbOvPBDZkgCPfPhba7c9of2dIujp1f3nUkKM/Ynj3m6k2zt2+vPkxJ0nZ5+73Y8UNT6gdqFa1qBpmVn9rTqKUxk4viv9BaFXf45vt2+n7cL6s6J2ebu+4e6bX+K/k5T+IB33DldIQEuXQAS+i4ADqRljem0biBYAchmWtzqMcyBZ6JoJSt0gnb9p52bpGZS6GoxLCNI1UCfIDlfXEEqCfxGJ77iZC0U5QUvqOlw5I+KuF36anDSAnKMT43pyZlsylk0kcRTIRivFWZ6fxvT788drbYlZ4q5C7YSwKDZQrtNWHd4HlUTjzGYsq6pVTTK4QrcBxyj+tvKkJRonjbEZWJ5Z2LizNU71S+lCElSlEAAcbqlfJm6QcaZrxbZGWN5kp3AcP5j0H6m3JR9nTSU4UsBTpHcnldcvwcZ7c4Io2ejXppZEam9T1HAoYp2rjgNpyHIDK79Tp6mHfUjOQrwIi9yMKVo5RWTq4U8Di7MVCZbnldTsySVJxy9uGF4nyWZvWyaz0nR1pU0MOhw42Ls44fTRjPSeN85CR3jwWPQcNOJSkfG+0p8uMg3kFKbdb8kC9LwSTYlkKNntO3LbnDyL+Ru7rlMHW1lUYg/K9a39S+ZI8mNnwS+TNSSaoSaDXHP+kKZgqMpWsRywtF0ta/2hp5nY+6I77+jB/SjOp3BHyNqqbNdwq2MfGgPkUjawTjYdFCk0TY9yL2DmBz09Q6poAruvSr2MpBB8bAEPR7y4oISSchdAA3/qJrh0fRHfTj1nQUNAmIIx3HknM2wvrL2iOp1btGw6QlhJnbJzIkCOvXIXnZLxict8vJ0jWqPlI7dvHwSk+p5n2r1l2uqHG907VKk5+otRO5XPHK61Y4ySp51O0oMp/wAx6nreW7ZmzXwqjdZsTHAdPbCEYvueZZ/kTzum8+ta3XVqgLVKj4ZJHLle+fkFwjHHzDeWzDriWgXXCVqJMePIXVeK3HlFRED/AOqE3asqwiXRl22beeC0An2c/wArA65P25BJskUrZlgahe7dBGEDOwL+6DxN2KNIkmZlycU4lPlSMTmTj7Lzxw8LAgOmd0H3m4QTB6YGwALVENrfnT5VKjwPXuvtMdjSOMuAmeA53GGrNREeC3qiAoMLzlAxHISDfa5CkU7aCRlKPDP9bisLkpWVaNxLLikq+1wwbCMV7hmMbr4RSIi5bFFr/tnHFE5Qe7+lieWCQJwcQJ9+V4ZUaRBVU4moaTlChHMEcfytOpqr0FtAmUkFJk8crzwVmuSI3qdGS0h1IBW1goTif62d9xCsslphUfzDI3YvoZ6iSKIzaisKKD5kz5f5knh4izFpLVSTG0LnDhPI9b2/cl2jGS1kjJGxR5Jnvve0JkcFJINnyhz8wAQa9dl1rCQCpM8rjcNu448Ofv1u9RlkawUoj8M5G7DjACTHm80g8jnBvRDBXQGoZKIxzAPWLypS0KgyRwuggO0i/TqEK53PTMBQOVyStMpYupIg5dPWlSUzhMXU0ipCmxjiL800b3Rpns1StHPt54HVouqv6e4MyMlJnAjl+hupQrDyEpOBA8p/T23wkkyywz0Rk45Ecj0pNQbqW0ONK4Y/kbb2nVb1GsEZH7k8DfKUaNs7RmpKznHA9dNrQqAog+No1HqH2rSrCRh79L8+yFHWUbR6dU+hxjKh2tLSoSPyujp9clxIx4X5jWyHiz1oxrn5IVUGfGxNOeXuvIOgLKADneGnFWwOAMFlDaTHdfGlTF1BE6hlhtpHTG+ox/PjekDLKwnpN7eA7s75BjldwQzm+CmVNIj7R7L0ULm6KfA6i8AVU7eJ2jxzspSRNi+oHJVcZT/KPEiyPEd/yvJXyWgiq40icsb66occvEm8hloqK7jaRhH8Li1gi4CUUE4MYMXHFWBAAdi8PqzxsEGGBcXgT8brVNQG0lROAuo1CPkZbM7JeKA1tQNxAOV1CsvKKjzJvUIm0YnLJiWTanVKETdWtrmqRsqUeYHE3Ko1GNi7Myn4oFrWqNadTqM+cg7E8Z6m2zrNe7WuLWo4cB0u64OTOkMKkTbPxVLk5TbeRE1mpdqqlbqzJUomTdeucknoJJPhfSHBYYOW15M7MiXV+apV0Gd4eUSpX+Yyfy7r6x4COMuWJcsGcSbnKwICRegCe6wAIkea9pAw68BYABaVvdj0knuu3p9Gp1QCshCSBzxP8bknRJM1FGooPTsbaVAIxVKiDlyi7Dqt69qQNqAEJHheXyCrgoNltKCXFDzfK9OEITiYsCFOrWYhOZGJ6XUfq0qZdQ3+EST1M8OQsajHqydCTkqdAtRqY/sJPlAlUZqN0SvcoqJmTdjwaMzfRGS7p607m0qyURPfhFi04FVTTpn/AORCf/K8bFhl2fCzep5SJq+JD07NdnmmXN6kArOR6C3DoVOhLckYxmL82zY2Ylk92vQlk6wWF8gdVQobbiOGd3q+nUtJCThwnhcshlxpGxr6hQpVuAu9UMKbJCsb1F0Q5SRtr2E7s4PTqVtnNJnus1OgU+qIIycBSb3N2jN/Sc4rJayPjRFEBO2QMDzyGXjnedCV5EQeg7jl8byxI6w4EHaQ6tPIWgKPx+NgpCpO0DM87ywzSYRedhQMXlR8vS4ClE3VUgoPgb1qKdyST0shZllYy6JgNajVIj//ACXCP/aDd7TqcL7QLSoQFOAmeYv3dq71onZZ1ny++Vb5F/ccb2Luj1rTTaApP232qSxRtyEjpnfYHAljnpnad+kSUpxupoNQhbLYGRuhADu7d6+1oeh1DpdDa1JKU5T0wHU5Dmb8y+oGvV+tat6ZdCyqVMsgbg00MQoiYkzMqvO2fjE47Juc6WUa1Q85o9GmChC+Bt6xUph+qW6gVDu4OysrKELIISc8U8doxmOFp3aNBpG/MSU/iVv3EniJwT7JAvN3+QzVVS5Eb6je1BwugpBlJUf7isB3A4jwurXPLc3Ep2BRJbSM1cxc6mooryqJO2ilVhtltIV54XkMsepuuslAWFSokeWeGN2Ns0jMqRh2BqVqJI+1JOQ8bCouZKGM3VgEk7ZDrhKZHGfhF9cCiUKOEiO8YW5ABXX983stn1lDqk/LC9kTwR0V+gIQLykxBugwDqSQoz0g/nevuBw/PCwALDQhpvHBaFR03BXG8MlS6dER5HDI/wCQ/rckJOjUeBEUnv71BTq4pTHz/S8U7gcovTJxAVtPGQZj2XHyQ1QKKU7cYJBOxfKbI0FJU4k4iN3s/XheyWZpZKdErbQPxtiBzxsTqnGHEuIOChmLkuTXIQNPPJKUKEzJkdD0vlUne0l1EDf546KH3D2Y3FEosjwrLFNUFwbJxidvddJh9wGRmMsOl5caNNGkzCky6+2VAkKkEd4IyPdfA8lfEebGRlPS8p0R4NMXZxw/9uytRxJUCeYMC+E7mi30JMc7tZwOWAZBb3KIzSI8bEtUpE55K/O6rKsAkuDbJSEOJUARmAbjIQUjec5APCbAloVgzVUxU2lxKTBElOcXtt96mKmyAtEnA/ndoJksNFVBOQBsrpCllaAMcSj8rqRSA3R1RpnQo4CwkAz8LxshaNtWb1bPFnMdWk1SVbZV5VRj/Kfy62kdn63afSUcsr8e2NHXuIdT36p2jh22zoPRpBUngSPYrmDdfSKxK0hKsUjAjij+Bvyss40exIa5CnSbkGJmbK02IBGKTlHEc/C8t0Rs1VmkXtP1BxlQk+X342FDaYxy+XO04KaJdCE3CVMtWOehrkrSMRbfo6xdIsYlTYz5XwnBxZ3lGM17neE/JHCM5QfsOxt4ThONptLqAWAoKkG/OblrlE9RzhsUkLjLoHG6DVVgIN5TJVHQliump22mitjO9eRkUWxW/ejrPstJ/eTxF68jJPAtiqa2cJFpgqgc735GCeJRQcqxHvh42nqekfd8Re/IyieJS0up3T8bore54e27ZCUUMtycMLqrqRMXSNgBXFXUdfjAZ8SbhaACLcgXVW9zPPxuGlGwZcjNU7E2mapqII2JWMLRVnXXrJKVHLbs/QHXP+u7sTglNpj+oBBIQZuwj4o2kSb8mzk5voW6isapWsTwy4k2i1DzjxlRJm4o2UspqKowB1KscqllROHAWKphKSb0hEknYYnV6iEwM/fGxVy81bp68r3EsUYkTYxI1VYYa2g+ZXyupXuF51RknHj04C+mtWzUFSOO10jGx2VSZPx+F7CPKVq+37R/C9AwOhxtv+2pZHh42Zsh2BEJTwFg3QKlZhLe1IMYkYCzNtl1wDnYjkiG6JS06lqBiTwHEnhanRMppwVEec8f5B+dm6MN2SMToo1kI0x+zptp+85x/Mc8brahqSgdjfmdV5EdGx1/5G3JqEQlSMzkHWpNOlKyQpa5AR0PPphwugXdjCSFbyy4tO4mdy1plSu43mrN1ft7GrSMJ/k3WVBdaXtMq3jcf5U5R+d1FEtM/wCZyZ8LkYmhOWMGXwDL3mUEzB8vtvDYlQHiTYEB1UBKQM+N9VGOYuoiAD0UipZVxCknvBvVEmHWTP3EXJ/CxPhmtXxWXWetaAUmkQQNylISfaAbr9jKpDlA3sclYbjaSMCnC/HLlmpr6mfT1Zin7Ge2cvtrqXdQ/cgmYbwy6WSuaU4mXVZic5zvAZqRZCJU7dx829Xhen2UBw7TPOwOcm7EvUouoP7hhUfii7DjG5xEZ7hdRCSWSvNDm7PyptAsvZ1valHt+VyQZuHAjgc2ntYBSh4CLNRIWUgnp7m8ijSIbcTA6Xt5AQMTcoro1ZEJ9YiUnCyVYlJA6XEUrIxlaxVK03tBTrTh6uZ5g/lYO3Tfp1VK9/K4RPiMPjfq7GVJr3Mdq8s8P7nrypex171XBCx67tagALmcpNt7TNSdQUneTjfss5uR87xOniekdn/+3p295tA07Xi7TpAOIwON9LMpnOqNtHG6eqo2H9RcSFvVDjsFe3aAiZBkTA9mBu72wK2KJdJTAJUkppGEE+ZaQJed5SQqVcyb4OMo20b2XlHo8ouo2Y1eLabPP+1OorqXQH9+4z6cxs28CE8Aed168N1det1cHz7ACfLO6ABfL6m8g6pRSwKqhGrWksAqWslxWAEfanlGFh190OalUBOHpAJA4JgYnPrdWSwI8L5kmyu9To2FxRQyD9u/FZ6QkfrdAvOuObSZ5n3yvSZpIy0ZbdlpxDLSUES6FHbvAAx8M/bead9LwLShCSYAT1/mA4G4mw1RWkgnYF5vekbcYUsjlyvb4dZkJwx8piUq/I3UREDtFR5Kt4cTPCe6zIUHVKCxtUe4G9J0iOzLWbKvcpOt+m7AyI3Dvs7rRbUk5xkeV7TsyngxLk00Cp0pXI5H2319KqdZcQPKoA+29BMwVqjlJgXUGcRh4jEXtCkqcDgwnBwdDwWOVmBFhchadyEJPDd7j23xlOBjKZjheZCTyaTsGpCXHB1Qr87y/gAsdIPOyuhHmgGgW+UJCvtmD4H9Qbi0hLe3iob+69Az7MsgjrQCW0bsFgls8J9875SkuhDavwnAc+o52AfAWV8iuAQqU4HiOHOLI6lVO+qRMznwniLAgapmwsKSC39wEkdY+6OdiaBBwVCgQoc598bVYNKqMoseqHBhxE3hKPNzkmOovPizRq7IiKSSOEHjx77mKQojCMweH8LArDOf3miAMeXA2VB9VPnEBPEH37rYBmqNIGSte7OM46Xts7H0cZOII+BukMNdDdWV0KWhfm/qOV26lprNEJx+1X3IPTmDwvSZEYYaOFppaN6UyOMZjn4i9U0NqhWAPPC9BYMh5A0+6nqkLExNmq6ZaUggnbnhw8fzvG2Npm5K0b1SqSMRdMcWlPmUuDvHEi6OiVMoCZxAAN+LYje6FNn0NUrRz7edoeWl1aHW0iYnPrPA8rTaB5SNpTfmmjUkeuErRmDHGhOBvFBUh1ISrA3ybE49TqkIsL6Z4YTZkgHDj75W8jI8SoE0VsmUGDxHA2b0hx4xe/NPDMEpx4NUw9Lqu0eeRF1/Qk4GLstafBLZY7fUnjYpDUG3BgZ+BtMU04nKOWc3HrZpTZtbEc3GuorJqRaP6tSiM/0vL1nTzidfuHGpCz+6BGfxtF/fVCeCvZPwN8vA7Wjv5nC5IXRWAAGbQf8AU3hOd8vBnXHod/JHDykLyqndkbb51ioGSMvG+PidfGLO/kcfuSQtl8JxJxPvjbfd1eqWDHl+d8vE7VFdDv5I87nJ9RYerEInzC2289UOzvWr23yUH6Hazs9iXU87tilX62hIKEGZm0go63mGuuTVm9m70OdGaiodeUSThffSn3+N3gGXb5NANh4zZXEwMLtkMUaaALIQOI7rzUqwu8hGWGUqxW7jA5Z2DUXPKUp7zPwvcBBdTEiTdiVqr6cUJxAxJ4eF1dSUSS2nD8SvD+N9daNQRy2yMbWUFp9VREwJlSul5cUHFQnAfr1va4KuDnLIeXR1wb1JSPsAgD9e+9JTMAWMtkq/kaR1tG6EpwFmbT6Yx+79OVrtk5CRrgsUjIagmN0Ycud4U+Wmy4uIAgDqbNhRthKiOVIPUPBCQ00oKcXPdzP6C05qo9JReWdzi8uU8fyFoxvLN4LKVKkc768nahSWniUeZQBQk9P5l+PSxOFQx4qwHhxsCy5JkOwEqZ9PqoH23ykBHf8ApeZN2WRVwI3QKr/xVDgnyp8BcqBCiesx7bqIuCS5LMG0nAx4XtpENlRwnC6DJUuTihu7hegQAJ8LAhVQVlQR6B6Kx7zfEkFlMfzj53JLDD5NQ4QXB6L9PagO0a2VIQsocgHJQChhjaZ9NdSQKx1o4bthHjlfm2r6vwa3xPd2TuL9TH7fNXJew96thQRs9MCMcMTakKaoUAUpSZTO43xYZ6pcWV00NipaWFeRBGOJUPlatXUDk4wrjhYlnKSybaEdumMpIEmRn87UkUpSCThAy6YXSMxRqhU0VJAQABjBnphe9GGRnjHO8sBFHHQtrCPMub1Qq/tjLnYqFgI6jDK9O4g5C5RWVMiKVUPKcje3kSLgLYYx+3dKpbCTxQtKvjaj2vpfUpnfAm+vb4kjGp1JHDu8xN7lcGNVhOxIMRuTuEdeN1BULUhoT9pjrkb9iJHKPA+SzVMXtKLm4Kx2qwNn0cITSIVnJvUSxWDDQk8il9Q61xXaWpbacGxlpbeBEB5aDIB/m2STwm0HW9QTVV9WslTqitzHMlTpJUrpJGA6C+Wx3P8ABmXxN9DrpSWu6vJuC+lIbdSr9m4lShiVjyknNShiO686vTKfqkKcQUoDhc2A4gTIEnpxsExdsSXuP76OfQ3s/wBtNMqO03aUP1NPVVVQ1R0LTzlO2pDCy0t59xkpeP8AdStCEIWgAJJJMiPQPoOI+lWgxxXqp/8A1asvrp1px8ma0/7cfz/U49xtam4x/LOfcf7svx/RAE/7dfo4iY7MyTgSdV1r/wDsY9gu12a+s3Y3tDqtZo77tRoWo0tU5TftdXb/AGZqNqylCmVuHbLidpDThQ9JgIOd68I+n8si2Rbrh+5PuT9f4QeqSV8r2Ko/26/RxJJT2Z2k8RqutT8dRIt7W+3D0/qaC2TXX+EZPDfrt9Dez/ZLs652n7OB+mp6Z1hGoUDrzj7YbfcSyiop3HSt5K0vLQlaFLUlSVSI24+g/wC4FIV9H+04OWzT/wD9zpDfOetJWjWz4WdIbXJ1Izq+Nfn+h8rVSCjzJJWg4hXEXwuemstnESY6eHheYUIqzpLkjPQh9Bqqoqe29FS64mpqezFBpFay0aD0zqytR09yuNOgfvVei42ltTaP8b1TjCLzV/XJLWr9qdW0zTqlio1Sq7GVNLveRFOeziAl1D+0SturAKYTklRCrvhzngt/8+RPPj3J4vC+f8iNqP0wq9P+llJ25qK7aK2uTSM6T+3lz9sv10orFVH7gFIW4w6lDfoQpACgvharr31j0ftUxWabU6K/Sac5reh1NLRMOtBuk0nS6ZdOaBvypAW6FrWFAbApZwuRWLKw3mhFf0Yj9rvpJV9kOxei9pVaoisdrDRo1PTU0xad0c6hSmro0vOeu4XPVZB3EtNbFwnGbWO1H1uT2mY7aUOpaBQN0OvMtiiVR07DFexU0LqFaY5W1IE1KadlHpLyO0kIhOFqClZLDjVFXVPpZovZ5t/TdR7ZUdJ2lY05Ne/pD1A+ijaWthNQigVqxe9IVimVApSWPTKyEepxtTY+utE27qOv0+k6qx2n1TS26DUVN6olPZ+reapTSN6k9Qim9ZTzbZKkMF70gvzTONyUU/mVyrJpS9sEUW1zgTX/AKYaLRdjdJ12t17VUvalpL2qNU1J2aeraVsILiQ1UV6NSQhoFTfmcUz5Undtsz31S7P1nYrS+z77nbeid07RntJLek61T0ekVxcLp9Sto10zinkK9TY6neNzflvPjS5/gt4XJfN3VfyPFp3gSOwv0+ou2dLrlfV6rV6WxodNSPu/tNJXq9RUiqqPQCG2G6ylV5VQSQVeWcMLJ9Ou3umdj6PtHp+ot62WtZpqOnTU6JWtUFfSmmqPX3NvutOhO/BB8h8pUONodRDqSfQslbRcR9H00/bDV+zTGvN1WoMaQnV9IZFEtpeqq/bipVp7rblSHaGuSxK0sLS9JSQopsWv/UhjVO3nZ7tXS0FVSN6P/o7Z31Qf1KvRpqxvfrasNNB2rqUApdcKIIgGbrRPL6iJ10Ko/S0J/wBQeyKeyR0qmfrS/qdTQM6jXUH7b0/9K/cALZpHHvWWXX1MkOuoLTXpbgnzTN1e0naRPaztXrmpveq2jVNSrK1gOq9RxhqoeWppkryPpIKW8MITAwu1RHyRu/1KvQQwkkbk5ZEfL2WUpU1vRE7SUq6/8hdBKbL+PmdbVuCScwCOci+EK3DD7hOHGOPj1s1YER1CoKXBw5zfWgUFJUmJ95N5qivJQAUFNPH0hHVGc/8AG7SmWXMcQoHEdOY44dLpE/UzlM1RltBdCFYz8Zzi+ha0LQFKTuSZ3jDf0nhIHG6AmCPFTwCVRIygYkc7sqSw6lLo8ix/iJjiclDkeN1LFlg+hhumJoBThp07Fp9Poc+8j9RZCgtgQRiRMdLseCPDtElyI8UzamlpGxSiU8D08eV3UtJdTtJSYGCxjHj1HyvQi7MsT+llVhpVI+HExH4wDwORHLws37eEqxEfgx+A5HpfLfC0dZ5R27bZUjjrl4uxc01XqNhQNg0ouUbaEugwoT4C/n7FTO3cdu68kfU1tNI83a91Fy8X+BdonPTg/G80q0LjKL8shI90SRyK9O96qQTmPj7LrsKKCOZvnJUaZ0TIhSbVNjZUlQBOB+d82WSNBB9sQcOt9ThcBR1MlB4iLOEpWnOwI1krRTWPzszjMTh3XRZC1dFNYn+tlWP8vsvSbIjJWiotM/pZXETkfhekzNmWilRSTZFNknDC9WLoyWiupJNmLMCfc3SWQtANnQHvsqkAc++O66DJQG0Tj4eFkWmBATHKwIVoAsSekcOt7UjaJMA903SIyVldYuOqAEnhl0vWAkZasN0VKrAEk3U1SqUsFLefE8LqNa45MyRnZJsTdXrUMBSG4Kj8P6Wk6y4UL2BRKuM301a3J5OulYOW7b4qkcd7dlWqW64CqYk4mRjYgDgSL0opI0YlJyMmktobbndKiJiP1vIUpbkDNWVwM1GjIRtOa1YJTkB+I9L46qCG+AmeZvJqkbI3TNgrUvkL60AEkk5Xl0kJLJpEMVboCkoPASbruErUpXU3YlJN9DLds63K3es3qmEEk9Ce+wBVhmnCFv5YJgRe6dBUs4Z2DL/l/Aj6h0Q0EYYhOPffVJwnPzReXmwjSHQrPhClJ5AXpQJXEZKI+N2NhcEdBkISUpTlHzuPDYlR43QSuglwYcT5khJBwyvCDJB42BHXQLksMIhg8NixPfeqdJPqA/iAV7LkiSZqOEVCp2PqzSavTYgBxexU5YmRadTOemUugwUOAiORBvG9XFmpK0zr2k/HajnB1JHvejhyopEFUQU4FJ6C6vY2qFTprGO2W0kT/mSL8juizw2j6d2TW7hF+xcraVCG5gkkZC1JxhptrLcojxvm3QeDVNi7G2umXjvETw5XY1FSi4pOIGWUe8XUSLsjQfJzR3NqiOmB8Rldanc9J9eMbjP6G3UMgHVQPBTYw7+F09IqfIB3XQAK6lYHD35WJK92HCMLMgBlzEE3xZzsCkEXtCyFMK44Gy6yklCjyN1OiIklaKzzBZDL1UyR9jy+7HCza1Tqa1qoSE/4igrlljft1P6UzPbO4I+dvVTaN94q2scWiSugbA98rVOy+mB3S2SBjP5X1Kjzy5Ixnfun9r60g+ZapIA8itshJUcjF196qYBDaSXHFqU8oGZQeEHCeB8L4SRZZs9UH/BIYaKjtI+aMVry3NylmYVKYnj3dLuOpcXRBtpsloK3BvaCr29D0FzFEvAt2aaVnun0EVv+lHZ7GYVqs/8A+1rLZH0g+sel9jtJ/wCnddpaxqmbcdfo6xhhTyWw+suOMvNp88BwqWhaAqdxBAib76f9tf8AOpjVtSXizy71/wBsvx/RHXfpcpeUf0D/AFI7U6R9WKip7OdkOxjvafUadZp3Ndebc09jTFpUQSHz6LqghQPkqHGmlEYIcyt1U31v+kVAhbbGpt0SVOOPLbb0yrZCnHVFbjhS3SgFa1EqWo+ZRxN6k1PCVv19DX3df/E/9DnBPXmUvFenqR6dvp/K/wBRZ+m/Z/V+yvYnRtG1eqRWV1Iy6h95DjryDvfdcQhK3kpWUtNrS2JSAAmAIi0lX+4H6Up//wC64qcgNP1H/wDi3YJqKTJ92Hr/AAzM2pSbXBr7Oz0/lBPrwkL+kvaZB/E1RDvOo0sfG/PPrj9c9I7T6D/072bRUPMVDrD1dWvt+ilTbDqXUMstqPqSXUIUta0pACYAMyG34H+P6mdmxSVImn/cX5/ob1anCXkzxWrZWkhREESD3G71Qj1HVgDyuJ3JnqRiLQZhOiyWTUo2OCt+llDo7KqTVO2Oiaf2iGmp1JehVbb9O22hbAqG6RzVXSmjRWuMkFDChBUQkLxBtab+tOiUtXW9pDpGsp7UV2mMafqDIqaM9nq1+npP2bOoOtrp1VgU23DgpkLSgrSBv4318QpJnLyfpgeD4/8AohP/AEw0ej7KaV2ir+066VWqac/qFNRNaJXVmDTjjYQ5VU7pbbKlIgqWkAAyRAtRH1W0UdhdI7NuVnbjT3NP0ir091nSauiZ0nUfXceXuqmndzi0kOBtwYEokC3QWLy6JVMrp+iWtVDHYOoFe2qi7XftEJq0sKUNMfqQVoZqG/U825sKU0sKT6hQsQNuN/s39eafQNZ7JrRp1RU6Vp/Z3TtG1Ohd9H/uanT6moqGK2llRSl1hx1JYUvaqN6TG6beP8lsvlaZKE1j6V6Sx2apdX1btSrTG6vUNToWW2dDrtSUo6c+GnFrNI75AuUqAUBnEmLUtG+r2hN9lWNFdrO3GjLZ1PWKxbvZ+so6UVLeo1HqobqPW3FXpDACAJUrO8uN9SuVVyVSrFfyFG846cid2d+jtJr2k9mao9qaWir+1R1ROj6e9ptY4265p9S4wpLtWwpxLIWUBQUtqBujGLvdj/rinstofZPs+in1D9jp1N2io9YDK2GqioRqlS67Tv0FSP7rFRShyQrcgbpHMKCZXJq8cEcOX8hJ7CfSLVO3zOtluuptNc0xQpWEPILn+o6kpuocRQMqS4lIWU06iV+aJHlM3c7MfV+n7HdnNF0nRtGp6p6j1qq1rUanVWQpTtVuS1SOUYYqR6S26QFC1L3+dZ2iJmRjllborklRKtu/kV+xHYDs/wBpez1fqNR2sTpz2mUi6zVKJejVlSaRkVXoJIdQ6hLxXKFbWxuTug5WQ9uNBpq36iO0Gn1rNL2ppnWqFlXohVGt2saqlB0JcI9NJC0oDZJ27cLlLmx5LPuVtrp/Ip/T7AqL6W6C/oX/AFFUdrl0lA5rFfplGW9Ar61yoFLsUH1NsO+oyl1C0rShxMpyJJtQ7JfVHSdC7E0/Z2ore2ekvsajV6j+77N1lJS/uEPttJDLxqJUr0ygmNox43VlBPBG2mHFt3j8lXS/pbo+raBousVfbCk0let1lfp+mtVWmVrjT7tI+liX6hgrFOhwrbO51uEbscjZ9D7e9gF9l+z+l6zpnaKtf7O12q11KimqqGnpq5NZUtvJarHFNOugQ02HCylJxVt4WoWsBvPHTIp5qsjNrtE1DRu0FT2e1FIZraOtXQ1AB3JS6hz0ypKhG5B+5KslJg3f13tNpev6jrOu6nRVY16v1xrUWnmKhCaBijJUpymLCkeotY8iWnN+ScYgyFlUsEpocfan6PtaKx2h/wBP7S0usVPZx+hY1qk/YVVE5TIrXUtMuMrdU4y+N6hvShYIEm6/bz6wa5221fUvQqH6XQqmtZqk6aGaJhxYZ2lv907StJcqVJWCpPrOugGCMRccfcrsqndY54EYpfM6/wDSStY7VdqezzlYY7P6XqGpmvNI6lmrFFTIfLSB6nkKwrbu3qiMjaxqH10r9T7R9rapyo1t7Q9Z0fU9OoNJXVBbNI9V0iWW3VNeqWUpbXvUrZKvMYFzxyw5c8jyVJ+rChhcXfIl6T9IKetp9Dp9T7U6dpesdoaZqs0XSXqOre9dmoKk0iqmsZHpUpq1J/sgpcJkTiYu5pP1E7IPHsvrGuaLq9Rr/ZWio6Kg/aVlOzpeoo05RVQKrQ4yt9tbJI3+iVeptk4GLtEjNOvUjlzjjqVweaeGUuz/ANLtG1bTtVqKrtd/pNZoTb69YoHNIqqldCG6s0u31m30tvEr2mGwSndByuvp3a9unpO3btc265WdqKNxtZaCQ0w+7Xoq3HlblTsJCgAmTle4hGJMSLWk/TvRntJRq2sdqKPRdMrNRrNO0Spd06sfd1QUjmxdWqnaO6kp8U7lOqUUKJSU4Cedmu2vY6s7L6X2c7XUWrvI0OqrH9NqdLqGGVKarVIcqKOrTUtrHprdRuS82fUSDAAjG2QhS5p30i1JrU+09NrGoN6cz2aVSIrX6elqdTcd/eyaZynpqYIcUy42PUU6soCEkSJmLtL9TtLr+1Ot67qTGtaW/qC6U0NZoGoGmq6FmmQlpNGtDqk01W0tlDQWpxAMplIhUXVjgJ9DEvqeehZR6jerdGotM1x/T2NQotWZQUlurpSpTLyFICwU7wFIUJ2uIUJSsFOMTal2y1uk7T9qqrW2aD9m3VFkekpSPUc9JpDZeeU0htHrPFPqOlCQNyuOd3ktUl1MLFrHsZc7k7wIusu+iENt+OfDwF61emLqwsJ27E5cffxsl5KixillZLFuLu+DH3OjLOi6oNyW1qnACefSbqUdOtKBEGfb7b8Pedq4PyisHu2a1OLTPqft/eqf0TeT5mvdLVNNDtpSFpz6RdHQ6pakbF/ckwYM+Htv47s691qerY16n6FHDse4W/Un1QstHZgT/C+swsQYvi8hno4BZbWFcLw2kg8ccrw0aZryRFVlpuf63lubyDTZP0CQlQ98Lm3cOlwpaHQG4hCx9vsvqkqTx+P62sBohUdbgm9vSeE9eXsupkRGGistPsxzN9XPSOWd6V2EQAFpnpey2SMpi7ZKsAHt6Y/pey2E5m9E6EdFAOJ8ffpcqFKjA3UVGWGVqlQGJx77w40VEqUZ5XUgiNhlSoKnZ/lvbyVBMxJJhKet6WCIxK2ViZVgJQpREfoLFrbq0tqGROAi+kMsupHOWEZ3Oosa+pku1a/E31xtXqqJzJ+F+jX8Ii+h5dn1SYlyVljHH3F7DRW7AvQOZWrZlB9LzxBOXKyVCUmAngM7AcZD9AWBcJN5+0mxQ3kgZRhkx0uAf2UqPsvL+If5G+URcFcoMjpFljduPW6CVmjTVnEJASBxN9AlQ4AQLAzXAldlmnRtQIz/AFslOkbCoiIyuSDNJUDFWkoYCRnIPxzvj8qRun8Uz4WSplD4DBJn1d3DA/C5CjiLlWUAxVOlyTh0PffHR5o6mywDMmJOzKE+WecXpoGds4lfysAuRFlhCvTZcUYJI2j2Xl4DZtyAED87y8sqWTSwDrEqQsR0PgYvlLKY/wAwAPjckV8lQR7J9LasVugUZJEpbDSuRR5cbSvorXpXS1VITC2l7wOELHTxF+TdibL3UX5Kj39rO9Mf0MdjK4Neh6RSpDTZ9Q7v5VHHLhe2KLe20CcDicZz4XyI4s9Dd8BSWaEjWko8xAnmLuaqxLW04xhwiBYADYe3JWFjDaRP62WobSFKTwyusInIfIo6W9gIjhdLRnzig5oV7/C4CFHI25gB1z4gG8UqitIxNijgWHjyQO/xuQdhCc+NwosFDU297SvCy6gkBsxjhjZAMI8/12lSnW6NRGDq9h544XY7ZMqQhmomC082sR4x7L9HZvFGezlU6PJ+4RppnTv43pv0Y5OyVcyl9NPEARhNoPZR99NQmoJ8pI9t+sHz2HyN31vRO9Q3KOAw+0XlyVlUROE9ByvhJG9kaO8XZnXOwJ1Fbj60uJgJxGxRSDy6G+OICXGkDAnFU44DiL5NFZ2hkkb5K9d/h7ln0wrgVKJjuNj1d79wnypxEgHgBNxcliak6RmfzEl6qQh3BG9BwPh16ze/2O9cg7ScCOt6USqRhyojRGlFxQH4RJxzAiZm7C9P9OlhB+6ATxAHzE3KKmLDWDLkFIO1URgSJB52JtbtMUg+ZAOIj5i4aqy2YsiWnFIwxKfMI6WULQhaVpG0KxTH2nkel4kjbidIuzEZUUnmluFWeION3ahkKT6iBO4SPyuQdGeGWUbNPKsRHPUb8jv4cj17+t2KykcPnTjPA8DfZUzMJdDjI1siwDaGnhAOPLKevKwQtteG5J5cL0UxggZIcQ8URMmcOHO9oe9VAlAC8t0ReZcFaNRVOhE2tiQCM/nZWgHW9p8pvEXTDwzTRVkT3N/qEiZEyBmY42Wop3WnycwfOCPiO+9kjJM5vk1KBYaeD7KEkgKSPvHEf5ufMWBEoOAO1Q3Jj8JP5ZWa5KFwRYwEeC0jaoTtOfjZG3ZhKxMjA9fH9LyuhWvQpQDO5tWBHjwx4fnZSw1gUmMxllZtUSmyJUWjlQltxmQnztmCnlfXqd5tQWiCCIMHAjndiImXRZX0K7ZLS+MZKHUG9FtSvLGfHikjgeV0GU6YoMw4pC8Muf6jn87rsqcQSM463GU2jCk0KzaUrAUCY5cO6xadUpxTGd5Sr0NNZOjMp2i4w2rBeCkmRGZHiLsMbYmPJxMY/P8AW9R4EWc50nkbUm89CpU6MpTnrNBoSJIk4iMiDa3TUzVW3t+0YE/pjmOV6ULNR/n+DD2pOjlNOKv+BAQzV07ZJS4kJI4SiPETlbiOlKZIcUnykwooMe1JwN4ccnSv/jO6mmjgpXkpabqJCQlwhUH8QBI8FX2v040vm9IBK1ShaPtHWU/leY2g0b2xTV+hIu8CtTpYq21EpSrdgOlpjC66jKfKSkwBxSo9ORjLje1XQxHyv+h55KcW3mv5PRsUEv6/+y69oqyPVpVHmg5GOl29M1Rt9QQf7asiFYcogxfRiLvk88Z2NkIx4f4KFDWPUNUgvI2JJ2K654Huty/6DSanitocjBKvHC/L3+j7itc8nqlq84tcH0P2nuVrn4t4eD5sN71STsLROhxCVJyN4p9Pe0VDRWou0y/sc2nyclHKOhHffw5qmev9w7CetuS+Z+pi/JYPnfs/7vDevtzw+E+jFFtAVHyvTCgUgpxyvxEd2fURVT+QVCAPDhZUYiwAoxt5jwm9nCbAAruYHL53tzHCfDjhYooFRwmSM7MWsSTxFgTn2LWSv6axndgtYD4XTJmjVFVSI82NmKYEGO69EMUbfBTcTEn+s2d1rcffO9KgrMMrS+YnONFRxknoDdtTETHhejNsxTNUJ5Z4nMnDkBndh9oCR0EC9ET6GaLQl1SY3EZ5eAvVe4ltJnC9xEE2zE1gTaSpiBrBSgEnE4gDndfVakuOeXIE+2+uo3rVHDc6Rjc2xGqQd5jvsjjKnJJ64TfSFFijjPkSZXCChpThGchPhxN9qSopSjKcI/yjP23oIyySyV/UMR1vXphUmPC6QyVJsHG5QHtsgSpKFHiqE93G6RkRpIgJhPy6CyNozUcsrYDVljwAaMCcJzvShA8ozysA3QfBholRgDMwLPRtQdxjDEdwsCJ30CVB1ktN+mOknmel5Lh3eXM8TcLReEALgUqBy9hva5/uFYmREiwI27KBbGYPhhx531tKm4jHHCzAWUFgw4lMY5xI7rI82VjdH2mT4Gw4JJFq0DaSMVkx/LzN9I8uRzEDlYEiqyHg4TIg4Y4z+l9gqI5WBcIldDbYEgjHK9NAgmLkg1ZQh3/SvUU0naRtHqBCX07FAmBPA91t3T6pyhfafRIU04lc+Bvh3MX42dZ61KLPT2M/qaRw17HrmmfRunulTZM5YdZ9+FpHY7V06lpdK+lYIcaQpQmcYxE8r8Vss14yaPolhLz1xl1FPUGApLmasJGPW7KkpdRHURPheWUsf0JY0a+lKFk2paxSjGMP63EKKx0ECje9HUFI/nAjxH8Lr6ruo3m3kzKHE4dROI9l2jSyjLDQ79PUC2AD0B77qaJVB1CFcFAEd+V4LVFJ0FlMbTt6Rj4XGyM5GWNgUhUrE/2ynMxJ773WRsI558rAoQz+1FIamkcQkTBJ54Y2o6rTB8OJx7vfHne9D8diMxtOzHcR8tU0akrTXqhL0hhVP2dZqyIG9Ynwi1jsvqehL0r/AEJ9BL6Kh3jmFRECL+gsomqXlA+TLEjXcQ8NjP/Z
+END:VCARD
diff --git a/tests/vcards/patrick_schmidt.vcf b/tests/vcards/patrick_schmidt.vcf
new file mode 100644
index 0000000..4ccef83
--- /dev/null
+++ b/tests/vcards/patrick_schmidt.vcf
@@ -0,0 +1,10 @@
+BEGIN:VCARD
+VERSION:4.0
+FN:Patrick Schmidt
+N:Schmidt;Patrick;;;
+TEL;TYPE=CELL:+18241912372
+TEL;TYPE=WORK:+16553219666
+ADR;TYPE=WORK:;;Paderborner Strasse 64;Buchloe;;86803;Germany
+URL:https\://jailfood.de/
+PHOTO:data:image/jpeg;base64,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
+END:VCARD