diff --git a/.eslintignore b/.eslintignore deleted file mode 100644 index db5ddae..0000000 --- a/.eslintignore +++ /dev/null @@ -1,2 +0,0 @@ -.next -node_modules \ No newline at end of file diff --git a/.eslintrc.js b/.eslintrc.js deleted file mode 100644 index 0c9e824..0000000 --- a/.eslintrc.js +++ /dev/null @@ -1,73 +0,0 @@ -// eslint-disable-next-line @typescript-eslint/no-var-requires -const fs = require("fs") - -module.exports = { - extends: ["next", "prettier", "plugin:storybook/recommended", "plugin:tailwindcss/recommended"], - plugins: ["@typescript-eslint"], - parserOptions: { - babelOptions: { - presets: [require.resolve("next/babel")], - }, - }, - rules: { - "tailwindcss/no-custom-classname": "off", - "testing-library/prefer-screen-queries": "off", - "@next/next/no-html-link-for-pages": "off", - "@typescript-eslint/no-unused-vars": [ - "warn", - { - argsIgnorePattern: "^_", - varsIgnorePattern: "^_", - }, - ], - "sort-imports": [ - "error", - { - ignoreCase: true, - ignoreDeclarationSort: true, - }, - ], - "tailwindcss/classnames-order": "off", - "import/order": [ - 1, - { - groups: ["external", "builtin", "internal", "sibling", "parent", "index"], - pathGroups: [ - ...getDirectoriesToSort().map((singleDir) => ({ - pattern: `${singleDir}/**`, - group: "internal", - })), - { - pattern: "env", - group: "internal", - }, - { - pattern: "theme", - group: "internal", - }, - { - pattern: "public/**", - group: "internal", - position: "after", - }, - ], - pathGroupsExcludedImportTypes: ["internal"], - alphabetize: { - order: "asc", - caseInsensitive: true, - }, - }, - ], - }, -} - -function getDirectoriesToSort() { - const ignoredSortingDirectories = [".git", ".next", ".vscode", "node_modules"] - return getDirectories(process.cwd()).filter((f) => !ignoredSortingDirectories.includes(f)) -} - -function getDirectories(path) { - return fs.readdirSync(path).filter(function (file) { - return fs.statSync(path + "/" + file).isDirectory() - }) -} diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index 2859e6d..9dece5e 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -28,10 +28,7 @@ jobs: run: pnpm prettier - name: Unit & Integration tests run: pnpm test - - name: Smoke & Acceptance tests + - name: E2E tests run: | - pnpm build-storybook --quiet pnpm exec playwright install --with-deps - npx concurrently -k -s first -n "SB,TEST" -c "magenta,blue" \ - "npx http-server storybook-static --port 6006 --silent" \ - "npx wait-on tcp:127.0.0.1:6006 && pnpm test-storybook" + pnpm e2e:headless diff --git a/.github/workflows/lighthouse.yml b/.github/workflows/lighthouse.yml new file mode 100644 index 0000000..592d927 --- /dev/null +++ b/.github/workflows/lighthouse.yml @@ -0,0 +1,39 @@ +name: Lighthouse CI + +on: + pull_request: + workflow_dispatch: + +jobs: + lighthouse: + name: Lighthouse Audit + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: pnpm/action-setup@v2 + - run: echo "node_version=$(cat .github/nodejs.version)" >> $GITHUB_ENV + - name: "use node ${{ env.node_version }}" + uses: actions/setup-node@v4 + with: + node-version: "${{ env.node_version }}" + cache: "pnpm" + - name: Install dependencies + run: pnpm install --frozen-lockfile + - name: Build + run: pnpm build + - name: Start server + run: | + npx next start -p 8080 & + npx wait-on tcp:127.0.0.1:8080 + - name: Audit URLs + uses: treosh/lighthouse-ci-action@v12 + with: + urls: | + http://127.0.0.1:8080/ + http://127.0.0.1:8080/about + http://127.0.0.1:8080/blog + http://127.0.0.1:8080/projects + http://127.0.0.1:8080/contact + http://127.0.0.1:8080/now + uploadArtifacts: true + temporaryPublicStorage: true diff --git a/.github/workflows/playwright.yml b/.github/workflows/playwright.yml index 4b77405..decbe7e 100644 --- a/.github/workflows/playwright.yml +++ b/.github/workflows/playwright.yml @@ -20,8 +20,14 @@ jobs: node-version: "${{ env.node_version }}" - name: Install dependencies run: pnpm install --frozen-lockfile + - name: Cache Playwright browsers + uses: actions/cache@v4 + with: + path: ~/.cache/ms-playwright + key: playwright-${{ runner.os }}-${{ hashFiles('pnpm-lock.yaml') }} - name: Install Playwright Browsers run: pnpm exec playwright install --with-deps + timeout-minutes: 5 - name: Run Playwright tests run: pnpm exec playwright test --project=chromium - uses: actions/upload-artifact@v4 diff --git a/.omo/boulder.json b/.omo/boulder.json index 95af133..e9f1d89 100644 --- a/.omo/boulder.json +++ b/.omo/boulder.json @@ -1,6 +1,6 @@ { "schema_version": 2, - "active_work_id": "2026-portfolio-overhaul-d227bbc8", + "active_work_id": "roman-redesign-4df0a13a", "works": { "2026-portfolio-overhaul-d227bbc8": { "work_id": "2026-portfolio-overhaul-d227bbc8", @@ -19,21 +19,39 @@ "task_sessions": {}, "ended_at": "2026-07-20T02:39:58.501Z", "elapsed_ms": 55485499 + }, + "roman-redesign-4df0a13a": { + "work_id": "roman-redesign-4df0a13a", + "active_plan": "/home/tom/Nextcloud/notes/03 Projects/20XX TomSegbers.de - Personal Website/TomSegbers.de/.omo/plans/roman-redesign.md", + "plan_name": "roman-redesign", + "status": "completed", + "started_at": "2026-07-22T13:30:13.497Z", + "updated_at": "2026-07-23T14:26:59.773Z", + "session_ids": [ + "opencode:ses_075faf792ffeug0WEFAbFuiFxu" + ], + "session_origins": { + "opencode:ses_075faf792ffeug0WEFAbFuiFxu": "direct" + }, + "agent": "atlas", + "task_sessions": {}, + "ended_at": "2026-07-23T14:26:59.773Z", + "elapsed_ms": 89806276 } }, - "active_plan": "/home/tom/Nextcloud/notes/03 Projects/20XX TomSegbers.de - Personal Website/TomSegbers.de/.omo/plans/2026-portfolio-overhaul.md", - "started_at": "2026-07-19T11:15:13.002Z", + "active_plan": "/home/tom/Nextcloud/notes/03 Projects/20XX TomSegbers.de - Personal Website/TomSegbers.de/.omo/plans/roman-redesign.md", + "started_at": "2026-07-22T13:30:13.497Z", "status": "completed", - "updated_at": "2026-07-20T02:39:58.501Z", + "updated_at": "2026-07-23T14:26:59.773Z", "session_ids": [ - "opencode:ses_085e9a666ffeAVUWZS18j1H5Sb" + "opencode:ses_075faf792ffeug0WEFAbFuiFxu" ], "session_origins": { - "opencode:ses_085e9a666ffeAVUWZS18j1H5Sb": "direct" + "opencode:ses_075faf792ffeug0WEFAbFuiFxu": "direct" }, - "plan_name": "2026-portfolio-overhaul", + "plan_name": "roman-redesign", "task_sessions": {}, "agent": "atlas", - "ended_at": "2026-07-20T02:39:58.501Z", - "elapsed_ms": 55485499 + "ended_at": "2026-07-23T14:26:59.773Z", + "elapsed_ms": 89806276 } \ No newline at end of file diff --git a/.omo/boulders/task-2-peak-website.md b/.omo/boulders/task-2-peak-website.md new file mode 100644 index 0000000..34fa012 --- /dev/null +++ b/.omo/boulders/task-2-peak-website.md @@ -0,0 +1,30 @@ +# T2 — Canonical URL, Button, ProjectTeaser cleanup + +- Status: in_progress +- Plan: `.omo/plans/peak-website.md` todo 2 +- Dependencies: T1 dependency declared by plan; package changes already present in worktree and left untouched +- Owned files: + - `app/blog/entry/[slug]/page.tsx` + - `app/projects/entry/[slug]/page.tsx` + - `app/page.tsx` + - `app/projects/page.tsx` + - `components/ProjectTeaser/ProjectTeaser.tsx` + - `components/ProjectTeaser/ProjectTeaser.test.tsx` + - `public/img/Tom_Segbers_Frontal.jpg` + - `.omo/notepads/roman-redesign/learnings.md` + - `.omo/notepads/peak-website/learnings.md` + - `.omo/evidence/task-2-peak-website.txt` + +## Steps + +- [x] Inspect current files and resolve stale line references +- [x] Fix detail-page canonical URLs +- [x] Replace homepage inline CTAs with `Button` +- [x] Remove dead `ProjectTeaser.imageUrl` prop and all callers (including test fixture and Storybook story) +- [x] Apply readonly to re-touched `ProjectProps` interface +- [x] Delete duplicate JPEG +- [x] Append learnings +- [x] Run diagnostics — `pnpm lint` exit 0, `pnpm test` exit 0 (84 tests), `pnpm build` exit 0 (38 pages) +- [x] Finalize evidence +- [ ] Commit with conventional commit message + diff --git a/.omo/boulders/task-7-visual-closure.md b/.omo/boulders/task-7-visual-closure.md new file mode 100644 index 0000000..d06c9f0 --- /dev/null +++ b/.omo/boulders/task-7-visual-closure.md @@ -0,0 +1,23 @@ +# Task 7 visual closure boulder + +- Status: completed +- Owner: Sisyphus-Junior +- Scope: replace failed V1 marquee edge-guard strategy with CSS-only whole-card project collection; preserve existing font/token work, descendant Motion settlement, configurable production audit URL, and two-run raw evidence contracts. +- Files locked: released. +- Dependencies: Visual QA oracle PASS (bg_6e19b9c4 PASS HIGH, bg_cf42786d PASS HIGH) — both returned no blocking findings. +- Evidence: `.omo/evidence/task-7-collection-replacement.txt` — all gates green. +- Root cause: any continuously translated fixed-width track crosses viewport boundaries between cards. Opaque guards can conceal fragments but cannot make underlying title/body geometry whole. + +## Verification results (2026-07-23) + +- Prettier: PASS +- ESLint: PASS +- Jest: 91/91 PASS +- Build: 47/47 static pages, no errors +- Axe audit: 0 contrast violations at 375/1280 light/dark; all cards fullyInside: true +- E2E run 1: 43/43 PASS (32.1s) +- E2E run 2: 43/43 PASS (27.0s) +- Screenshots: fresh at `.omo/evidence/task-7-production-{375,1280}-{light,dark}.png` +- Visual QA Pass A (design-system): PASS, HIGH confidence, no blocking findings +- Visual QA Pass B (visual fidelity): PASS, HIGH confidence, no blocking findings +- Server cleanup: port 3199 process killed via trap, verified no listener remains diff --git a/.omo/decisions/next-15-compat-spike.md b/.omo/decisions/next-15-compat-spike.md new file mode 100644 index 0000000..c4890c5 --- /dev/null +++ b/.omo/decisions/next-15-compat-spike.md @@ -0,0 +1,344 @@ +# Next 15 + React 19 + Flowbite 0.7 Compatibility Spike + +**Date:** 2026-07-22 +**Task:** Phase 1D — Compatibility Spike (research only, no production files modified) +**Status:** COMPLETE + +## TL;DR + +Next 15 upgrade is **GREEN — proceed to task 5** with specific migration steps. +All breaking changes are mechanical and codemod-covered. Flowbite-react@0.7.8 +supports React 19. The `next-compose-plugins` package is unmaintained and must +be removed (trivial — wraps only one plugin). 5 page/action files need `params` +and `headers()` converted from synchronous to async access. + +--- + +## Installed Versions (Evidence) + +| Package | package.json | Installed | +|---|---|---| +| `next` | `14.2.35` | 14.2.35 | +| `react` | `^18.2.0` | 18.3.1 | +| `react-dom` | `^18.2.0` | 18.3.1 | +| `flowbite-react` | `^0.7.0` | 0.7.8 | +| `next-compose-plugins` | `^2.2.1` | 2.2.1 | + +Source: `node_modules//package.json` `version` field + `package.json` deps. + +--- + +## Q1: Does `flowbite-react@0.7.x` work with React 19 peer deps? + +### Verdict: GREEN + +### Evidence + +**Installed `node_modules/flowbite-react/package.json` peerDependencies:** +```json +"peerDependencies": { + "react": ">=18", + "react-dom": ">=18", + "tailwindcss": "^3" +} +``` + +`react: ">=18"` is an open-ended range — it includes React 19.x. +`react-dom: ">=18"` likewise. + +The `pnpm info flowbite-react peerDependencies` command returned +`^18 || ^19` — but that reflects the **latest published version** (0.12+), +not the installed 0.7.8. The installed 0.7.8 uses `>=18`, which is broader +and already covers React 19. + +**Tailwind peer dep:** `^3` — current project uses Tailwind 3. No conflict. + +### Caveat + +flowbite-react@0.7.8 is 5 minors behind 0.12+. While peer deps allow React 19, +there may be runtime behavior changes (React 19 removed `defaultProps` for +function components, changed `ref` as prop, removed `propTypes` warnings). +These are unlikely to break Flowbite 0.7 components at runtime since they +use explicit props, but untested. The Phase 2 Flowbite replacement (task TBD) +removes this risk entirely. + +--- + +## Q2: Does `next@15` break `lib/sendEmail.tsx`? + +### Verdict: RED (fixable — codemod covers it) + +### Evidence + +**File:** `lib/sendEmail.tsx` (confirmed — plan said `app/actions/sendEmail.tsx` +but actual path is `lib/sendEmail.tsx` per README and filesystem) + +**Line 2:** `import { headers } from "next/headers"` + +**Line 34-36:** `getClientIP()` calls `headers()` **synchronously**: +```typescript +function getClientIP(): string { + try { + const headersList = headers() // ← line 36: synchronous call + const forwarded = headersList.get("x-forwarded-for") // ← line 37 +``` + +In Next 15, `headers()` from `next/headers` returns a `Promise`. +Synchronous access is deprecated and will eventually error. The codemod +`next-async-request-api` converts this automatically. + +**Required fix:** +```typescript +async function getClientIP(): Promise { + try { + const headersList = await headers() + const forwarded = headersList.get("x-forwarded-for") + // ... +``` + +And the caller at line 84 (`const ip = getClientIP()`) must become +`const ip = await getClientIP()`. The enclosing `sendEmail` function is +already `async` (line 79), so this is a mechanical change. + +No `cookies()` or `draftMode()` usage found anywhere in the codebase (grep +confirmed). + +### Risk + +Low. Single function, already in async context, codemod-supported. + +--- + +## Q3: Does `next.config.mjs` need changes for Next 15? + +### Verdict: YELLOW — `next-compose-plugins` must be removed (unmaintained) + +### Evidence + +**File:** `next.config.mjs` (40 lines, read in full) + +**Line 2:** `import withPlugins from "next-compose-plugins"` + +**Line 8:** Config wrapped via: +```javascript +const config = withPlugins([[withBundleAnalyzer({enabled: env.ANALYZE})]], { + reactStrictMode: true, + rewrites() { ... }, + async headers() { ... }, + images: { remotePatterns: [...] }, +}) +``` + +**`next-compose-plugins@2.2.1`:** Last published 2021. The GitHub repo +(`cyrilwanner/next-compose-plugins`) is archived. It is a thin wrapper that +composes plugin functions. It mechanically still works with Next 15 (it just +calls functions in sequence), but it is unmaintained and the Next.js team +does not recommend it for Next 15+. + +**All other config options are valid in Next 15:** +- `reactStrictMode: true` — still supported (see Q4) +- `rewrites()` — still supported, signature unchanged +- `async headers()` — still supported, signature unchanged +- `images.remotePatterns` — still supported, signature unchanged + +### Required change + +Remove `next-compose-plugins` and inline the single plugin: +```javascript +import withBundleAnalyzer from "@next/bundle-analyzer" +import { env } from "./env.mjs" + +const nextConfig = { + reactStrictMode: true, + // ... rewrites, headers, images ... +} + +export default withBundleAnalyzer({ enabled: env.ANALYZE })(nextConfig) +``` + +This removes an unmaintained dependency and simplifies the config. The +`withBundleAnalyzer` plugin is the only one wrapped — no need for a +composition utility. + +--- + +## Q4: Does `reactStrictMode` behavior change? + +### Verdict: GREEN — no change needed + +### Evidence + +**Current setting:** `next.config.mjs` line 9: `reactStrictMode: true` + +**Next.js 15:** The `reactStrictMode` config option is still supported and +unaffected by the Next 15 upgrade. It wraps the app in `` +in development. + +**React 19:** `` is still supported. React 19 did not +remove or change strict mode behavior in a way that affects this project. +The double-invoke behavior in development (intentional for catching bugs) +remains the same. + +No action required for this question. + +--- + +## Q5: Do `generateStaticParams` and `params` access still work? + +### Verdict: RED for `params` access (codemod covers it), GREEN for `generateStaticParams` itself + +### Evidence + +**Files using `generateStaticParams` (grep + codegraph confirmed):** + +1. `app/blog/entry/[slug]/page.tsx` — line 110 +2. `app/projects/entry/[slug]/page.tsx` — line 100 +3. `app/blog/entry/[slug]/opengraph-image.tsx` — line 9 + +All three export: +```typescript +export async function generateStaticParams(): Promise<{ slug: string }[]> { + return getMarkdownSlugs(CONTENT_DIR) +} +``` + +**`generateStaticParams` API:** Unchanged in Next 15. Signature is still +`Promise<{ [key: string]: string | string[] }[]>`. No migration needed for +the function itself. + +**`params` access — RED (all 5 page/metadata functions break):** + +Next 15 makes `params` a `Promise`. Synchronous property access (`params.slug`) +is deprecated. The codemod `next-async-request-api` converts these. + +| File | Line | Function | Current (sync) | Next 15 (async) | +|---|---|---|---|---| +| `app/blog/entry/[slug]/page.tsx` | 33 | `Page({ params })` | `params.slug` (L34, L40) | `const { slug } = await params` | +| `app/blog/entry/[slug]/page.tsx` | 114 | `generateMetadata({ params })` | `params.slug` (L115, L124) | `const { slug } = await params` | +| `app/projects/entry/[slug]/page.tsx` | 22 | `Page({ params })` | `params.slug` (L23, L30) | `const { slug } = await params` | +| `app/projects/entry/[slug]/page.tsx` | 104 | `generateMetadata({ params })` | `params.slug` (L105, L121) | `const { slug } = await params` | +| `app/blog/entry/[slug]/opengraph-image.tsx` | 13 | `Image({ params })` | `params.slug` (L14) | `const { slug } = await params` | + +**Required pattern change (per Next.js 15 docs via Context7):** +```typescript +// Before (Next 14) +type Params = { slug: string } +export function Page({ params }: { params: Params }) { + const { slug } = params +} + +// After (Next 15) +type Params = Promise<{ slug: string }> +export async function Page(props: { params: Params }) { + const { slug } = await props.params +} +``` + +**No `getStaticProps` or `generateStaticProps` usage found** — the project +uses the App Router exclusively. Pages Router APIs are not present. + +### Risk + +Low-medium. 5 functions across 3 files. All mechanical, codemod-covered. +The functions become `async` (they mostly already are or can be). The +`Params` interface type changes from `{ slug: string }` to +`Promise<{ slug: string }>`. + +--- + +## Bonus: `app/layout.tsx` — FOUC / Hydration Risk + +### Verdict: GREEN — no Next 15 migration concern + +### Evidence + +**File:** `app/layout.tsx` (100 lines, read in full) + +**Line 46:** `` + +The `dark` class is hardcoded on ``, then an inline ` + + + + diff --git a/.omo/evidence/task-18-lighthouse-report.report.json b/.omo/evidence/task-18-lighthouse-report.report.json new file mode 100644 index 0000000..02231f3 --- /dev/null +++ b/.omo/evidence/task-18-lighthouse-report.report.json @@ -0,0 +1,12586 @@ +{ + "lighthouseVersion": "13.4.1", + "requestedUrl": "http://127.0.0.1:3053/", + "mainDocumentUrl": "http://127.0.0.1:3053/", + "finalDisplayedUrl": "http://127.0.0.1:3053/", + "finalUrl": "http://127.0.0.1:3053/", + "fetchTime": "2026-07-23T12:48:05.156Z", + "gatherMode": "navigation", + "runWarnings": [], + "userAgent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36", + "environment": { + "networkUserAgent": "Mozilla/5.0 (Linux; Android 11; moto g power (2022)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Mobile Safari/537.36", + "hostUserAgent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36", + "benchmarkIndex": 3107.5, + "credits": { + "axe-core": "4.12.1" + } + }, + "audits": { + "is-on-https": { + "id": "is-on-https", + "title": "Uses HTTPS", + "description": "All sites should be protected with HTTPS, even ones that don't handle sensitive data. This includes avoiding [mixed content](https://developers.google.com/web/fundamentals/security/prevent-mixed-content/what-is-mixed-content), where some resources are loaded over HTTP despite the initial request being served over HTTPS. HTTPS prevents intruders from tampering with or passively listening in on the communications between your app and your users, and is a prerequisite for HTTP/2 and many new web platform APIs. [Learn more about HTTPS](https://developer.chrome.com/docs/lighthouse/pwa/is-on-https/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "url", + "valueType": "url", + "label": "Insecure URL" + }, + { + "key": "resolution", + "valueType": "text", + "label": "Request Resolution" + } + ], + "items": [] + } + }, + "redirects-http": { + "id": "redirects-http", + "title": "Redirects HTTP traffic to HTTPS", + "description": "Make sure that you redirect all HTTP traffic to HTTPS in order to enable secure web features for all your users. [Learn more](https://developer.chrome.com/docs/lighthouse/pwa/redirects-http/).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "first-contentful-paint": { + "id": "first-contentful-paint", + "title": "First Contentful Paint", + "description": "First Contentful Paint marks the time at which the first text or image is painted. [Learn more about the First Contentful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/first-contentful-paint/).", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 904.9744000000001, + "numericUnit": "millisecond", + "displayValue": "0.9 s", + "scoringOptions": { + "p10": 1800, + "median": 3000 + } + }, + "largest-contentful-paint": { + "id": "largest-contentful-paint", + "title": "Largest Contentful Paint", + "description": "Largest Contentful Paint marks the time at which the largest text or image is painted. [Learn more about the Largest Contentful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-largest-contentful-paint/)", + "score": 0.65, + "scoreDisplayMode": "numeric", + "numericValue": 3467.4104, + "numericUnit": "millisecond", + "displayValue": "3.5 s", + "scoringOptions": { + "p10": 2500, + "median": 4000 + } + }, + "speed-index": { + "id": "speed-index", + "title": "Speed Index", + "description": "Speed Index shows how quickly the contents of a page are visibly populated. [Learn more about the Speed Index metric](https://developer.chrome.com/docs/lighthouse/performance/speed-index/).", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 904.9744000000001, + "numericUnit": "millisecond", + "displayValue": "0.9 s", + "scoringOptions": { + "p10": 3387, + "median": 5800 + } + }, + "screenshot-thumbnails": { + "id": "screenshot-thumbnails", + "title": "Screenshot Thumbnails", + "description": "This is what the load of your site looked like.", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "filmstrip", + "scale": 3000, + "items": [ + { + "timing": 375, + "timestamp": 4493877989, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 750, + "timestamp": 4494252989, + "data": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAHyAPoDASIAAhEBAxEB/8QAHAABAAIDAQEBAAAAAAAAAAAAAAQGAwUHAgEI/8QAURAAAgEDAgQDAwkFBAcFBQkAAQIDAAQRBRIGEyExFEFRByJhFTJTVHGBkZOhFiNSotEIQpKxJDM1YnJzghdDssHwNDd0g8JHY5Wzw8TS0/H/xAAaAQEBAAMBAQAAAAAAAAAAAAAAAQIDBAUG/8QAKxEBAAICAQQBAgUFAQAAAAAAAAERAiEDBBITUTEFFBUyQVJxU5Gh0eHw/9oADAMBAAIRAxEAPwDlPCfs51/iXS5NUtY7a00uNtpvL6dYIie2AT361D424H13gy4hj1y0Ecc43QzxuHilH+6w6fdX6M1vjrhjTeCeGuH7UM7pZ292HjA5cQCk+96sSGGPU5NY/a9xHoXEvsJvJLcFXs7mK1hWUDcJV2npjy2E/dWc4bnGte0uKib36flIAk4AJPwr6yOoyysB8RWfTb+70u+ivNOuJba7iOY5Ym2spxjoa7jq15dcS8TcM6Rrl7dX1jNw/DfeAknZVu7oROygnPdmA69zWm2TgtK7YvDOjQWr6jqfD0FpqK6Dd302kO8qpFJHPGsbkFt6hlLdCfI+tRdf0Ph+bTtcitNEt7OaHQrbWYp4pZCySOYwyAMxGzDHoRn40taceVS3zQT9gr5XX/ZHLqy8LXEGlWepIst+C2oaQI5Z4yEACSxN1MXXOcgZz3reaTwjo0k2py6nZjiLUX1qW1un0+1ZljjAU5VUkRYtxZveOVBBHlSynBK+kEYyO9d04M4N0W5bhtLfh06xp+oXlyl7fSu+61CSERodjbVO0AnOc7uh7VL0/QrXWND4MtdR0JbnSm024W51MyOpsVWSUqQQQo6/xA57DsallPz/AErtP7KcNxcCQTppd3d83SWu5NSghZhHP16GXmBFCkbShQmkui8PH2gRaLHwzzLe301bk+H5sryStCjbnQOCygk+6mCc+dWynFqVbPadoyaJxU9vHb21skkEUyw25kwu5c9Vk99G8yp6jNVOqhSlKBW94T06G/upWuF3JEB7vqTn+laKrXwH8+9+xP8A6q1c0zGEzDu+m8ePJ1WGOUXH/JWH5JsPqkP+AU+SrD6nB/gFb/hxrVddsm1Dl+FEo38wZX4bvhnGfhVjjhS8uD8uzaVdXaRExRx3McQYGRQd8iEL0UsQM5/QVxR3T+r6zkji45qcI/tH/v5c9+SrD6nB/gFPkqw+pwf4BXStPtuGIdQtlPh5oo2EvOmn6OBdmPay5xjlYbGPLPbNY7TSdAk06N7+a1t7hrhSwhug21DNtZOrHoF65wenXce1Xty9tXl4P6f+Ic5+SrD6nB/gFRdS0OyntZBHAkUgGVZBjBroOqRWEXD96kdnp8V6LiFxy7sTMiFXDbTu6jIXI698nyxU5f8AVP8AYandljPy2xxcPNjMThFfxDlFKVYuEBbGaTxXONuf/agR+55XTbvI6gczZnHXGcV6L4VormCW1nkguI2jljO10YYKn0NYqt3FQi8CuNoGcy+Cy1v4nJzlmOc8vb6jOcedVGkBX0KxHRT+FfKv2hnWPkm18O/GYh2e74ONjDj/AHMHtQUEgg4IxSttxObg6xL4w6kZtq5Oogibt5g+XpWpqgWkyCJXGBt7+XpWZru5e0FtJcSvbiQy8ssdu8gAtj1wAPurDSr3TVWlQV7MsjMrM7FlACknsB2xXilRWRp5md2aWQs42sSxyw9DQzSnOZX6rsPvHqvp9lY6UGSGeaAkwyyRk9DsYjP4Uimli3cqR03DDbWIz9tY6UFo4c411Dh6yWHT7XTudG7PFdSW+ZomIxkHOD8NwOPKq4bmcoUM0mwjBXccEd+331ipQZBNKIjEJHEROSgY4P3UE8wlEolk5g7PuOR99Y6UHp3aRyzsWY9yTkmvNKUClKUCt9wlqMNjdSpcMESUD3j2BGf61oaVjljGUVLd0/PlwckcmPzDp3ynY/XIP8Yp8p2P1yD8wVzGlc/20e3s/j3J+yHTvlOx+uQfmCnynY/XIPzBXMaU+2j2fj3J+yHTvlOx+uQfmCoupa1ZQWkjJcRyORhVRs5P3VzulWOmx9sc/rvLOMxGMQV9BIBAJwe9fKV0vCZbq5muriSe4kaSWRtzs3dj61ipSgVlW4mRQqTSKo7AMRWKlB6d2dizsWY+ZOTXmlKBSlWGz4P1W8tdPnt/AkX/APqEkvoY5G94p8x3B6kEdqCvUq4Xvs44k0/VotM1GCxs72XaVin1G3ViD0Bxvz1qpcpy7IFLMpwcDNB4pX1lKnDAg+hr5QKUAz2pQKVa/wBgdbSO1N34Cymu0EkFveXsUMsinsdrMCM+WcVXbmxuba8uLWaJhPBI0Uir721lOCMjoeoqCNSsr28yRmR4pFQHG4qQM+ma8JG752IzY9BmqPNK9bG3bdp3emOtemhlUZaJwPUqaDHSvaRSOMojsPgM16a3nVAzQyBSdoJU4J9PtoMVKyGCYDJikA/4TWMAk4AyaBSvbxSIMujqPUjFeKBSlKBSlKBSlKBSlKBSlKBSlKBW64Pdn4v0HcxO2+gAz5DmCtLWz4Zu7ew4i0y8vTKLe2uY5n5SBmIVgcAEgZ6etB1X+0vC1x7XrSFH2NJa26Bv4SXYZqT7dLl+A7jSOF+FHfTLVLUXFxNbsUluZCxGXcdT83OPj8BVP9tPGGmcacXxazoovIkFukRS5jVGVlJORtY571n4s420rjvS9MbiaO8s9dsY+Q17aRLKlzH/ALyFl2tnr0J7n7sfSrXw5ax+0L2LcQ3OugTa1oO6S21Bx+9ZAm/Y7d2HRh1z3FSdR9nltr3sU0a40jY/Eek2guZoV+fJDKWl2kd84bK/YRVHn46stL4Ak4S4XhukgvZOZqF/cqqyTZx7qopIVcAD5x8/WtlontOi4f8AaPa6vpXin0QWlvYzwSoEZ40jVCdoYjIILDr8PM02LF7GeALe54O4j1LUAh1a70uYWNu3zkiZWUS48tzKQPgD61wmJ+XKj4B2sDg+ddf9n3tYt9L9oGucQcRpdvbahbmBILWNW5ahhsUAsoAVQR99csM1pDrYmiR5rFJw4RwELoGzggE46dO5qwP0FrOi8Me261TVOHtRXTuLIoFWWznPR9o7Eeg8mX4ZFRf7PWn6novFHG+marzIr+C0/eq0mffyTuznrnOc/GudW17whYcXQcQabqer28EVyLpLFbRRKhDbuWJN+3b5Z748qs/BvtY0214w4t1/iCC8WTWYhDFFaxrJy1AwMlmXsAB8agqsdvxBqqaTpmuap4mw1TUo4UZrtblo2UhSQQzbeknbzq2+3jWbjhTiC14W4Ukk0jS7G2jZks2MTSu2Tudhgt0x3881ztZ+H9NsLibTL7VbjVg8bWpltUhjhIYEvkSMS2BgdPM1YuOOL9B4+NlqWtJf6ZrsMIgne1gSeG4A7NgupU9T6/pQeZDxVeRcKanrdtM1tDeKLfVHZd0ys64XeDlyCrep6n0r9AXt3cH2+SWU9+h0p9IG/TpZNwuHyx9yM926d/QGuCa17QrG70ThXhyxtbiHRdGuEne4lAaeZgSSQoIUD3m6ZPcdelWnVvaVwff+1Ky4zb5czZwCOOzFrENzAMMl+b0HvdseVSYG49i6y20/tUgtoJtOVEdobaRuWbf/AF20d8AgY6/CuR6tc8Qw6bpR1jUjdRXF2ZYG8WLh42jwCQ6scZ39s+WavfDvtY0hdW441HWre9hk4hjEMUdrEkghUIyAsS65OCPL1rne/hm101kt7vVbu8adNpmtEjjhjzl2AEjZc7VHkMZqwP0txh8uy+3XQF026lj0iDTkm1FDNiHlb5dxdCcHOAM474rmXD2tcGJ7c9fuRNBZaVdRSQ2V2EASCdgoMi5GF678Ht1rHxb7YrOX2m6PxVw5Decq2tBZ3NtdIqc1N7MQCrN/EMehAqu8Ua3wDrHEGrXtvZ6tawanEGIWGPdaT7gxdBvwytjqMr3OKkQJ3tc4T4x4c0lRq2rza7w7JcLNDeNM0m18MBkEnbkE9sg9Otc90fh+71a3ea2n02NVbaRdahBbtnHksjqSPj2qz33GkNt7ObjhDTbi/vre4uVmaa8QRiJFIISNAzYywyTn7uuaoNZQLL+xep/W9C//ABqz/wD7agaxoN3pMKS3U2nSK7bQLW/guGBxnqI3YgfE1qaUQpSlUKUpQKUpQKUpQKUpQKunCXBsWpcJ6xxPq1zcQ6TprrEUtohJLLI2OgyQFA3DJPr2ql10j2U+0O94EhmS709b/h3UZCk0LgdWUDcVz0ztZcg9D07VJFT1Kz0aWOwbQ7y6Ms8rxSwXiKphxt2tuU+8DuPkMbTW81n2Z61omowWOr3OlWd3OoaOOS8XLAnAIA+INW/2mcLcKz6BpvG3A8zRWN3erbzWbDAjkOScA9VIx1HUdQR0ref2jINEm4/0n5Zvby3PyeuFit1ZD7z4y5cFevQ4U4qWrip4a1T5IvdUjtmlsbK48NcSR9eU/kSO4B9aycHcLalxfq3yboqwvebDIEkkCbgO+Celdi9iepXGj+yXj3UeVHNPCyymO5XcsmU6hh5gg/rWx9h+laHqXHsHEvCkq20IglS90mV/3lq7DoYz/fjJ7HuP8ljj2h+z3W9cfWV07wcnyQT4wmcKIwN2T17j3W7elazh7hXV+IBcvpdsJLa1G6e5kcRwxD1Z2IA/zrtXsa/+17/kyf8A7itbrWIf7LWkfJPSOW+/08x+Z3v8/wC8J3+FLKcyfgjWW0y51CwW11K0tes7WFyk5iHqyqcgfHGK98OcCaxxDoF7rVgbMafZMVuJJpxHy8AHJB8sGrn/AGX3uR7TlSEE2z2cwuR/d2YGM/8AVt/Grnwwlgvs29rcensF00X04iaMbgI8dNo8xjtSxxTiPgrWuH9KtNUvYIZNLuziG8tplmiY9em5T0PQ9/Q149n/AA/DxVxdp+iz3UlqLxigmSMPtO0nsSOnT1rq/tVjfhv2J8L6Dpsb32kXTC5bVCAFZm3SBAuSVPvefkp+NUH2Gf8AvZ4b/wDiD/4Gpeh74m4T4b4e4uutAv8AXdRSW3kWN7nwCGMZUHJAl3Y6+lYeKfZrrOgcR6ZpckltcJqhUWF2j4in3EADJ7HqOh9RWX27/wDvb4j/AOcn/wCWldh4mYWnBvsesNQ93VPlCydUb56ou0H7MbkFLHFdT9nOr6VqzaZqN1pUGoAA+Ha7Uv1GRgDOcio03AWtRcGDikLbSaMSBzY5gzA7tuCvcHPTrXQfb9Fox9qOry3t9exX6WaPDGluvLMgi9z95vz3x/d79K9/2ftUi1CHXfZ9rhK2uqRSGFXHWOYDDAfHADfalL1Y5NY6Dd3eh3erq8EdjaypBI8j4O98lQB59Ae3pVg1n2a61ong/la50q08WnMg5t4o5i9Oo/EV69oijQLew4OhlSQ6aWmvnjOVkun7/bsUKv27q6h7eINFnm4EXXb28tYTYgHw9usgK+5kklwV+4GrY5Nofs91vW31tdP8I/yOzLeFpgmwDd7wz3HuN+FVEjDEA5646edd2/s+hv2f9pRfcS2nqwLdyCk2DXNvZNBaz+0bQBqKBrNbuNpNw90dQF3fDeVH30sYn4E1m3tLW41MWelrdLuhS/ukgd19QjHIHxIFQdf4X1bh+8t4NYtvDC4AaGYsGikU/wB5XXII6jtVv/tFSXT+1rWBd79iLEsAPYR8tcY+Gc/fmrbqWyb+yzpj6t1uI73bYM/zscxhgfDbv+4VLFJu/ZJxNaarb6XP8mrqVwnMgtjexh5V6/NBPXsfwrX6H7OOItYm1iGC3hhn0j/22O5lEbRDBOTnuMKeort3tf1DRNH9rfC+rcQ3N3FFY2KTxxW8IcyuJHwCcjaM49c/CsXs04li4w1b2qa1yntra5sowq4DOqLHKoJGQCcDOM/fS5KcCveGp7W0iuRe6dPFJOtvut5+ZtYgkbsDoOhqx3Xsk4mttWg0ub5NXUp4+bDam9jEki9eqgnr2P4VXrm30xLawOjXd5cvzS10J4BFsAKBDtDMMe8eue5r9N8TaRaap7e+HJLi8aK4sdMW7ggCj/SGV390NnoeoPbqAaTND8n6rp13pOo3FhqMD295buUlifupFRatvtZ1O81j2ia5ealZGxujPy2tycmMIoQAnzOFBzVSqoUpSqFKUoFWTR+KjZaE2jX+l2Gp6dzjcRpcB1eKQgAlHRgRkKMjqOlVulBZdU4vu7610+xjtLO10ixl50VhAHEbOe7OS25ie2S32YrdcS+0664m1OC/1zh7QLu5gQRozRzgbQSQCBLg9Se9UClSherP2l6pa6RxBpy6fpbW+uSPJdbo5ARu8kw4CgeXT8aqmhaxf6DqkGo6TcyWt5C2UkQ/ofUHzBqBSgu/C3tI1Thsa6LOx02Y60T4szpIcg7vdXa4wPfb49a1XDvGGq6Ba3tlZtDLpl70uLC4TmQyfceoPbqCD0HWq7SgtkHHWo2GnXlloVrY6NHeLsuHskcSSL/DvdmYD4AisnDvH+o6DwjqnDtpZafJY6lu8Q8yyGQ5GOhDgDAHpVPpShctL9oer2XB0/C9xDZaho0uSsV3GzGE5zlGVgR161p+EOIbjhbiC21ixtrWa6tiWiW4DFFJBGcKwJ6H1rS0oLvqXtDl1HX5Nbu+HdAk1ORxIZmimYbgAAdplK9MDuK111xvrN/xbacRatMuoX9rIkkS3AIjUqcqAqlcAHrgYqs0oL9q/tLudY4iGuanw7w/c6kCp5jxTke6MLlebtOMDyqoadq95p+uQavaylb6GcXCv/vg561ApQSLq7lvL+W8uzzpppDLIXz77E5OcetXfiT2nXfEosRrWgaFdCyj5UGUuF2r06dJRnsO9UClB0DRfanqujz65JaaZo+NYVYriNopAixqpVUQCQbVAJHr8a0F9xNz9Il0+z0fS9NjllSWSW0WXmNtzhdzyNhcnOBjqB6VXqUFuv8AjzUNWhtV4hstO1mW2TlxXF5G/NC+hZGUt/1ZqHxFxhqvEM1l8qNFJZ2QCW9lGnLgiUf3QqkemM5z8artKC2+0LjvUeO7y0utXtbGGe2j5KNao65XOcEMzeZNe+BuPtR4MstUtdNstPnTUkEdwblZGJQBhtG11x84/HrVPpQWWbipW09rO10LR7OJ5o5pWgWbfJszhCzSE7cnJAx1A9K2PFXtK1ziLiLTNclS0stT09QkE1mrr0BJAIZmB7n7c9apNKULNx1xlecaahHf6rZafFfKgR57aNkaUDtuBYgn4gCqzSlUKUpQKUpQK31nw5JdaOl8s+0uksiqYmKgRjJy/YE46VoasWn8RrZ6Xb23hpXlgWVVbn4jYSd9yY64+2pIgWmi3k91yWiaPBQM2M7d6F16fEAmpdpwvf3d/FbwKGjflZm7KvMRXx6kgN1xUqHipItjrY/vyYTK5l6MY4mjGBjpkNnz6ilrxUiSWb3FgJWs3SSDExXDCONDnp1B5an4H1ptWufh7UCN0EDTJsR9wwOrIHwATknB8qjvo9+mn+Ne2cWu0OXJHRScAkd8Enp61szxMxl09/Cj/RJYpcb/AJ2yNEx26Z2Z++pV7q+nS8PTYLNqlxbw2zgBgAIyuDjsOiAdCcn0602NJBouoTpbvFbFlnUtGdyjKjOW79AMHqenSpB4eu47SWacGN4zIGiK5I2cs/geYMGsuncRNZy2xNurxx2jWbruGWUuz5GQQDkjyPapE/FbSrMrWgZXDqA75wrCIAHoOwiHp38sU2ItvwxqUsksbwiORIGnUFgQwVlUjOcAjd1z2rH+zuoclCIjz2mkhMR6FdiKxYk9MYcda2txxbBOjQvpp8MySoUE+CBI0ZO0hQBjl9OnnXmLjAoSgsl8Ody7N+Ty+XEijJBGRylOcdevSps00C6ZeNqJsRbv4sZzGcDGBkkntjHXPbFe30i/SRUa3bczOgwQRlFDN1z5Ag59DUr5cLcQnU2jkwRtCJLtYLs2AbgPTHlj4YrYScQwtp+rmKGOCa7dFhhRf9SNu12z0HvL0OB1z2FXY19twzqc7Y5KRHktOObKq+6qhj59Dgjocd6xLoGqOkDLZyET/M6jrlSwyM9MgEjPcVs24niaOBHsC22KSGR2my7K0ezAbbkAdwDurJLxg8iwk2gEoAEpDgK5ETRg4C5/vZ6k/DFNmmol4f1SIIXs3O91jXawbcW+bjB7HyPao02nXcN6lpJF/pDkBVVg27PbBBwa2kPETRrGvhz7sdvHlZCp/dNnII7E/pWO71uGfXLW/FhHy4QoaJyCZcZ6sQACevfHkO9BiTh3VXleNLQsybckOuPeztwc4OdpHTzGK+2fD1/cWdxdNEYoIYnlLP0J29CAO/fpntmp97xSbiJI1tSqo0JBaXcTy3kYZ6DvzP0r5NxNHNFcF7D/AEmSGW3EgmOFR3Z/m46kFj1z28qbGmi0y8lsWvI4Ga3U43ZHXt2Hc9x29al/s9fpI6XMRgYRPINxBDbcZXI7HqOh7Vm0rXxp+lvai15su7fG8j5RGyp3BSPne73BHxzWW64jia3lgtLHkRS85nDSlzvkCgkHHQDaMD9aCDFod8wuOZC8fJZ4zkd3UqCv3bh1+NfZOH9UjuUt3s3Er7sDIwNvzsnOBjzz2qfNxTJLLE7Wy+7b8pwH+fIWUtIenc7R+FZrHiG3uJriDUIuXZ3U9xNKQxJHN2EKCBkYMY64P2U2NVb6Feyav8mzRmG65TShW69BGZB29QP1r4mgam88sK2jGWMKWG4dQwyuOvvZHbGc1O1XWrYcRvd6fGXtltRaoGJGRyOVn1+NSNH4sXT3tnNgsksAiCuJNrHZnoTtPQ57DHamxqItB1KURlLViJI+apLKPc6e8cnoOo7+fSsGr2EmmalcWUzBpIW2sQMda2Ka7G7SrdWnNt5baO3dFl2n3MEMDj1XtjzrX61f/Keq3N7yxFzm3bAc7fhmghUpSqhSlKBSlKBW4g0KWbT4bpbm3DTRyyxwktvZY87vLA6A+daet0vEE8Wj21jbxRIYo5YzKyKzkOTnaSMr0OKgzvwtNHcywyX1mpSVbfcS+DK2cIPd9B1PYZ71ll4YUR2RS5TnSQCaa3YnmAcwoxHTHTA6Zz3qDDxHqEVzcT7oXeaVZm5kSsBIM4ZQR0Iye1P2j1DwyQ7ofcQRiTlLv27t+3djON3Wm1bC84OvY0nnhI5Cu2wOrZKCXlhiwXb38s5x1xWG64VngSYre2krRib3UL5Yxf6wDK+Q6/HyqLLxFqE0PLleJveLBzEu4ZffgHHQbiT99Y212/YuTIuWM5PuD/vhiT8f0psNc0abR2hWeSNzICRsVseXUEgBh17jIrV1tLvW7q6gWGVLblKGAVYFABbGWHTofdHWtXRClKVQpSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlAq47AfZGrBAZDrezcB1xyM4z6ZqnVMttU1C1gEFte3MMIfmCOOVlUN/FgHv8AGoLPwXwzBq0N1Bf5jvbtXt9PBYLidAG6j0JAT7WPpTRYbd+DuJLq5061N5pxtUiZozlS0hVsjPUnFVQX12JYJBczCSA7omDnMZzuyp8uvXp516bULxkuUa7nKXLBp1MhxKQc5b1OevWgtdzbWi8E6PfRWdoLu7uLtHLIxLBQm1R6Ebjj7q9XdhYHhWC/0uO3FzYxQtfWt1GRLlmGJFOcMjbh08gRVUi1TUIrZbeK+uUt0ztjWVgoz3wM+dY5b67lgWCW5meFQAEZyVAHYY+FBZ+J0tbbhjhye3sbWOa/tZXndU6llmZQR16dFAqXwQ8cXBPE80spgEVxY/vlTeyAvJuwPjgdPOqXPd3E8MMU88skUAKxI7kiME5IUeVfYry5itZraK4lS2mIMkSuQrkdsjscUHSdNh0fiW54m1C00+0gja/s0tvEjasayMytkL0G7GfhmtZq+jabY2nFN9Z2TtJZ6ktrDaz5/wBHibcd7Dz6qFGfWqTFd3MVtLbxTypBKQZI1chXI7ZHY4rI2p37TtM17cmZlCM5lbcQOwJz26UpXQeHtA0u61fg6a5tIw2pw3LXNoSduED7JAM5AbH8pxWlW0tU4E0u8S1tjeXF7dQs7ozF1VIyqjHnljj7a0Ol67fadqXj4pTJeLE0SSykuYwylcjr3AJx9tR4NV1C3t1ggvrmOBCWWNJWCgnuQM+dEWHVrS10fSOHJrSzhvGvrYzzSygsGk5jKYxg9MAD49ak6BBbzabxR4vTLUTabab4gyksj85VOTnrgMRVTttQvLaPZbXc8SZztSQqM/dXiG8uYUnSG4mjSddsqq5AkGc4b1GfWgzXzQy28MyW0kMsjyF2HSJhkYCDHTHXPU9xVl4liL8DcFCKPMkkd3navVsTEDPrgVUXnmeCOF5XaGIkohYlVJxnA8s4H4VKTVtRS3jt0v7pYI1KpGJW2qD3AGegOaC58H8P22o6Bd6bKITq2pQNc2eXHMVojlFA7++BJ/LXyyvEueBV1W4iHyjoE4tom2jEolBKF/UoVJ+PQVSI7+8iuormO6nS5iAWOVZCGQAYAB7jA6U8fd8ieDxU/JnbfLHzDtkb1YeZ+JoLrwbcz6Zol3xHqLtJb2u62sLd+qzXL5OSPMKCWPxwKn8Cwmbh11u7lbKV+ILaN55EztzHKSp+BIAIPT1rn8OrajDbR28N/dJBGSUjWVgqk9yBnArw+oXjwywvdztFNJzpEMhKu/8AER5n40pW91uwW549vYJrNtMtH1DlyR46W6s+Ps7fdUvWNJL6/wAQ6bYabbxW+mpM4Z2IdY4z8/dn3iR5eeenlVYuNSvrlZFuLy4lWQKHDyFt235ucnrjy9KS6lfSwmGW8uHiIAKNISDjt0oi3aho8NvrPD+laXYQXQvra3l5sxP795BlsMD7oByvTtjrVJnjaGaSJ8bkYqcHIyDis8Oo3sMIihvLiOIAgIshAAPfpmotApSlUKUpQKUpQKUpQKzJMqqAYImI8znJ/WsNbS00S6u7aCWF4N0+4RRGTDyFe4A9fh51JVC8Qn1aH+b+tPEJ9Wh/m/rX2WynjMX7tm5gXbtBOSwyB9vwrxJbTxxJLJDIkTnCuykA/YalQW9eIT6tD/N/WniE+rQ/zf1rI2n3WFKQvICgkJjUtgEZGfTtXqTSr9DAGtJszx82MBCdy+vSlQWw+IT6tD/N/WniE+rQ/wA39a9WljdXYn8NC8nIQySYHzVBwSfxrJe6ZeWd14eaB+YW2rhSQ5+HrSoLYfEJ9Wh/m/rTxCfVof5v614eCZJ+S8UizZxsKkNn0xUqXSb6Iwq1tKZJYzIqBSWChipyPLqDSoLYPEJ9Wh/m/rTxCfVof5v61lbS75Vtm8JMRcqXiwhO8AkHH4V9XTLlrSW42gJECXB6MMMqnp9rrSoLYfEJ9Wh/m/rTxCfVof5v615nt5rdwk8MkTkZCupBI++pllot/d3LQJbyI6RmVuYpUKo8zSoLRfEJ9Wh/m/rTxCfVof5v618htLidGeGCWRF7siEgV9ezuUkCPbzK5YIFKEEsfL7eopUFniE+rQ/zf1p4hPq0P839a8x280iO8cUjInzmVSQv2+nY17NjdidYTbTiZhlUMZ3EeoFKgt88Qn1aH+b+tPEJ9Wh/m/rXwWtwY5JBBLsjOHbYcKfQ+lSLfSNQnmEUVnOZCrOAUIyFGTj7qVBbB4hPq0P839aeIT6tD/N/WvkFrcXG7kQSy7fnbEJx9uPsNfY7O5kWMx28zCQ4QqhO49e3r2P4UqCzxCfVof5v608Qn1aH+b+tevA3BC4icu0jRiMKd24AE9PvryLO5JlAt5iYv9Z7h9z7fSlQWeIT6tD/ADf1p4hPq0P839a+31lc2EyxXkLwyMiyBWGMqwyDUerUFs/iE+rQ/wA39aeIT6tD/N/WsFKVBbP4hPq0P839aeIT6tD/ADf1rBSlQWUpSqhVg0/VrG3ttLeZLlrrT5GkRFACOSwYZOcgZHXpVfqZc2XI0+yut+7xO/3cfN2nFQbq24kjiZ2eF2Igj5Pb3J0UqH+z3mP4V41fX4b3Ro7WOJklKwrICvu/u125Bz5/YO571ifh8R+AEl0Ea6Uqdy4EcpUMqE58wy9fLJ9K+Q6JCuoQWF3POl5IoLxxxBuUx64YlhjC4J9PuppUq24kig+TwqTgW8ls0gUgbhEGBHfz3V5h1y0ayjt5zeRnkJE0kONylHLDGT2IPXt1A70i4dtp4OZb3kziR5hE/h/cKxjOWOfdz9larS9Iu9TOLVYzl1jG+RU3OeyjJ6mmhKTV4m1LV7iRJI479JFATBKFmDD0z2xW0j4qhF5PLLFNIj3HMUMc7FMTRnHXv7wP3Vo30S9SxkumSMRxpzGXmLvClgobbnOMkVGs7Ke85vhk3mMBmAPXBYKP1YUG3l12I8RW98schghjEQwAr42lcjqeoz06+QrY23E9lDHFAUu5I44VQTSAGQlZHcdAw6e/69MDvWrh4avCL0XBjge2DdHdQGKuiHrnAHv5z2OKjnQNRVJy0IUwl1ZC6hjsGW2jOTgdelNDZjiC1luY57mOfmCOVMKBtBaUuDjIz84jHbsfhWS+4mt7hLoRwzI00juD7vTdJC34/uz+IrVrw7qLTvCEi5iEKRzk+cc4Xv8AOOD071DgsjLp97cl9ptmRSmO+4kfdjFNDa6lrdtNrOn30EMjm3cSSc3C8wh93zQSB934V7uNdtxE0NubuRTFMvMmI37pCvToew2/iTWti0W9ktY7hUjEb7T70ighS20MRnIXPTJ6VkHD+oBnWSOOIoAziWVU2ZJAzk9Mkf5etNCRomuLp1rBERNlJ5JW2HAIaPYB+NT7PXYfBTSS4MlvaxLCHb3jcLlQ49QFZj9wrVvw9dhY+io+1jKJWEYiIkKYJJx1IrGugagSqmJUcu6bXkUEFM7iRnoBjqe1ND7pWrCws+VsZ28ZDckZ91lQNlT9u4VuLziW0uHkjC3UcEkcimRABIhZ1bpljke5g9R3NV9tKu11BLLlqZ3AZcOCpUjO7d2xjrmtjPw1cRwQGNhNNKsZCxlSuXeRQN2f/u85+PlimhLTiS3XTJ7cRzmUiZUd8MXEgxlzkdfuPl6V6HE8LXd28q3PKnlLLgglFMLxnHXv7wP3VBteGLuaaGN3hTnFOVIJFZCGk2ZJB9ajR6FdOJHUwtFG+1ykqsQNwXdjOcZI600JegX9pZ6ZcrczXCHxcEqrAQGYKJPU9uo/EVlPEMU0681J4Ymt5YW5JGYy8rPlB9jAeXTNaz5InfUL22gKMtq7K8sjBFADbQSScDJ8qfIt94eSYxqAm4leYu4hThmC5yQOvUehoLGeIrSNbeYqZFbmxFScyheVHGHbqPeJQnGfXrUK+4gtrtJFY3kRR90ZhIXmDlqmH69Mbfj3NR77hmeCYxwSpIFeVXdyI1UI+zJJOOpxUL5DvlVzKkcWx2jIkkVSSpw2AT1A8yKaHvVp7e/iF2ssizpHBBynA67YyrMDnt7q/wCKtTVjfhWZLm4t2uIzJC8ybwRsJjVSfez0+d1z2qN+z13yc+7zuZt27ht2bN+/fnGMUGlpW0fQr5BOXSNVhAJZpVAbK7htOfeyOvSsFjplzfQyyW4jYRgkqZFDHAycAnJ6URCpW2fh/UVMY5SMXZFwsikqWXcu7r0yAT19DWLV9LfTI7JpJUka5iMvuMGUe+y9CDg/Nz99BrqUpVCtmupxnTbe0ns45eQWKSF2BG45OQOhrWVZNO0Wwn02C4muJVkkt55XG3ohTsR6/ZUEK/4gvb+O4ju35iSzCZVJOIiM9F9Bg4+4elek1w/KGpXc1rHI99u3e8y7AxyQpHr2+yp0HCM029luk5ZKiF9hw+Y1cFv4Rhl7+Z+FavTNJe/WErKqcy7jteozgvnr+lNKzQa/NbwpbwxKtoBKphLEqyyAAg9fLAINTeHda0+ykRr219yCWOeJEUt76jBOSwxnA9RXmz4bWSW1Bukd3EMskW0rhJHC/O9ckfjXmLhsSe54xEuCkcpi2E4R5FRfe9ffBxTQzjW9Pk0qSO5ika8mjS3kdUxiNZFbod2D0XHYVqNM1RtL1V7uyjXb7wWN+oAPbP2dD9oFTrHhma6VnEwCI0ofahZgEKDoPPJcVGOismr3VlLcIqWyNJJMASNoGcgevUdKaH274gubq3aKRI8NapaEjOcK4fd9pIGalycWXkkFzEY1HOZyCrsu3eAD0B69vOs91w7bbA1vOBCFjdpmBPumDmMdv/lXqz4atWkCz3bNC6pIssaEHDRSuBtP/AKmjaHZ8U3VtcXkqxqfEyiYqHZdrDOOoIOOvatVHfSJaXdvgMLllZ2PcFST/wCdb3TOGBOtlcSys0Es0SyIUKHa5IBBPft+vnWv0fSBqNlO4dYzHMql2z7q7JHY4HfpHV0Mq8RznTYbKaFZYowqHMjgOituCkA4+GfSsp4iW4ju31GziuJ5+WG7qr7S3U4PQ4IHTyFSl4VjuoraWyuWNuYEd5eWSS7ySKPd8hhOv2VE/ZsJGhmvEEnLMzxqhOEEpjYg9icjNNDxLxLNcmQXtrBcRy5LodygkyFwRg9MFiPsr4vE14NQjuykfMUykgZAYSfOHQ9O/TFTrzh+wgGoYuJtls1wI325LGN41AI/6j2rUanpD2FvznlDRu4WE4xzFKB93wwGX8fhTQ9Sa3NJrK6gY1LBOXy2ZmBQqVIJJz1BP41Mg4lZJbZFtooLWIxrtQFsKrSHzPXPMbzqZLw3YEtDDeSLI0trFG8idN0sTNggeWcdfIetRY+FZPBxT3F0kAbazbkO1VL7M58z1zj0poe77iKCFrOPR4AkNui45gI95ZTJ2yfPA71gTieWOye2htYkjYFejNjBcP1GcE5GMnriokujSw3thaTSKlxcvtKY/wBXlygz+BP2YqUOH4zDLcLfqbaJZNz8o53IyAgD/wCYMH/KmhEh1dlub957aKeK9bfJExIGd24EEHPQ/wCdZU150tii2luJRHJDHKNwMcbkllAzj+82M+tSI+GzI/KS8QzqUSRChG13UlAD55IC/aa+w8OF4ArTIsvuPIxz+6UxPIRjzO1Qf0poek4tu1mkflJtkMhZVZlzuff3Bz0P6VDu9ce8gZbq2hll3O0crFi0Yc5I79eucZz3raR8Kx3cVvLZ3RMDQoWl5ZJLu8gHu+QATr9nnVXuImgnkicgtGxQkHIyDig3j8SyPNK72cDLK8ryIS2GMiqG8+nzc/fX2Lim5hlUwwRJGvurGpYYTl7NoOc9uufWq9SlDfjiacT3cpgRmnTZh5HYAbduCCfe9evnWDSdem02xltooUYOXO4swPvJtIOD1GO2exrT0pSN3HxFcJNNJyYTzTFvU5wRHG0eO/Yhjmoeq6iL5bVEt47eK2jMSIhJ6FmbqSe+WNQKUoKUpVCpkWpXcVp4ZJcQ4Ybdo7MMMM4zg4qHWW3t5rhisETyMO4RSaixEzqEyPWtQRGQXGVKquGRTgKoUYyOh2gDI61j07VLzTt3g5uXllf5obDLnBGR0Iyeop8lX/1O4/LNPkq/+p3H5ZqXDPx5+pfYtWvopFkjuGDqiIDgfNRgyjt5EA1Ih169jsZrVpN6PGI1OAGTDq464yeq9s+dRvkq/wDqdx+WafJV/wDU7j8s0uDx5+pZ31/UnkDtcAkbunLTad2N2Vxg5wD18xUaLUbqK+a8SXFw2dzbQQc9CCMYx8MV6+Sr/wCp3H5Zp8lX/wBTuPyzS4PHn6lLt+IL1bxJ7iQzKCCU6KDhNgHQdtvTGMfCvV/xHe3N8LiBhbquzaigEDYpUZ6dejN5Y69qhfJV/wDU7j8s0+Sr/wCp3H5ZpcHjz9Szrr2pKiKtzgIUIwig+783rjrjyqNZ6hdWS4tZjGC6yEAA5YAgfozDHxr18lX/ANTuPyzXw6XfgdbO4/LNLg8efqUj5f1LmbzcAnYECmNCoAJIwuMdCxx086jnUrwqBz2wIjD2HzC28j/Ec1EZSrEMCCO4NfKrW2MutahLI7yT7mffuyi4bfjdkYx12j7xmvGp6i97FZxbSkNrFyo1LbvMknPxJ/DA8qg0oJ7axfNysznMTRup2jOYwQh7dcAkdaHVrqSBbe4k5lvkFl2qGI3bsbsZAz91QKUGzudYludeXVJFBkWVJAmemFxgZ+wDrXy81q/u94ln9x1ZCoUAYJDHsO5Kr179K1tKDYS6xfywwxPcNsiZWXCgHKjCkkDJwO2e1F1i/W4knFywlkl5zNgdXwRnt6MRjt1rX0oNoNf1Lmb/ABAJ2hNpjUqACSMLjAwWOOnTNQJ7iScRiVgdgKr0A6ZJ8u/UmsVKBSlKoUpSgUpSgUpSgVfOHYli0e3KAAuCzH1OTVDq/wChf7Gs/wDgP/iNaOo/K9f6NETzz/H+k6lK2up2cccWji3QLJc2wd+vdjI65/ACuOn0s5RExDVUqz3fDMcFxHCt2ZJBMYZURVZhgEllAY9PdPzsY6VjvOH7e0jnmmu5OQkMcybUVmbczLg4bHQqexNXtlrjqOOfiVcpW91PRYLW2naG5kkmt0heRWj2jEig9DnyyKlwaJDf8Oae1nGRqTykucnDxl9mceW07f8AFTtknnwiIn9FXpVr1vSNMjuGuIZJYNOSKAAovMd2cNhsEjuEJNYTwyqzw2r3R8VLcyQKAnuAJgliSfQ9qdspHUYTFyrVK2mt6dDYGA29yJklUkgldyEHHXaSP1rV1Jim3HKMouFU4yiRbm3lUYd1IY+uMf1qu1ZeNPnWn2P/AOVVqu/i/JD5D6hER1OdFKUrY4ilKUClKUClKUClKUClKUClKUClKUClKUCr/oX+xrP/AID/AOI1QKsuh67Db2iW92GUR9FdRnIznr+NaebGcsdPT+lc+HDzTPJNRMLRU9tWvGsktWeNoUTYmYkLKuScBsZHUnzqtftDp30sn5Zp+0OnfSyflmuXx5+nvz1nTT85wtTa9qLSxyG499CTnYo3EjBLdPeyCR1z3rFd6te3aMk825GVUKhVUbVJIGAOmCTVa/aHTvpZPyzT9odO+lk/LNPHn6SOq6SPjKFhm1C6mEwklLc5UR+g94IAFH3YFerbVL22VFguHjCRvEuMdFf5w++q5+0OnfSyflmn7Q6d9LJ+WaePP0fd9LVd0LPBrN/AwMc4wI1j2sisNq/N6EY6evesbanetLFKbhzJFK0yPnqHYgk5+OBVc/aHTvpZPyzT9odO+lk/LNPHn6Pu+l+e6G/vr6e+dWuGU7RhQqBABnPYACo1an9odO+lk/LNP2h076ST/AaePP0yjremiKjOGt40+dafY/8A5VWq2Wu6l8o3KsilYkGFB7n1JrW128cTjjES+W63kx5efLPH4kpSlZuUpSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlApSlAqdaaRqV5bie0sLqeEts3xxMy7sZxkDvUGupez+4sLbhPSZdUmMMMfESS7w2NhEJ2s3ns3YB+FSRy4ggkEEEdCK+V020hvU0zjgXPu6hJe20gNoQSd0khYx4PVSCO3litTGjjhS7SxI/aH5Sbxe0jnGLb0248t27OPPGaWKRildD4fF22n8WeJkB1FrG3xyMbwwlQYGP720HOOvfPnWLTltLfhriRtatPFMb23XLsBOgYSZZT5MMrkdvI0sUHB9KYPpV91q6it7jhGDSNQE8QtFjkki90tm5c7XHkcbcj4elan2lXLy8ba3EJS9tHfTGFQcqqlum34YA7UGll0nUIrRbqWxuUtmUOsrREKVPQHPpUKux6eyfIWnRTulvbT8NTW8t2zjEJ5juFKnuWIUY79ciqjxTZTXXDXCslvHuSHTHaZhjCkTSH3j67dv6UtVKpXTnER410j5MNuOFTHb7txXlcvYObzc/3878569seVay7Fu/DCLwnnnnUZ/EBDiYxdOT8dmN3bpnv5UtFEqdd6PqVnEZbuwuoIxjLSRMoGeo6kedSeKrdbbXJolu4bxgqF5YlAUsVG4dOmQcg/EGrpxxrsem6jqdklvzG1LT7GGSYyZVUSKIkKoHzsrjOenWg5pSupAW3/aEmDbfsdtBxkcjw/L6//M/m3VqrXwl3wPJbSGaweCGaaG4RgYrobyeXKPKTIAB9MUtVDwc9jXyrxrGo3T+zvRpzdSG5lvrsTNv95lKx4DfD52PvrJxmbe74cguQZbG6geGCSxLBoZcRkCWEjsMDqPVu9EUOlKVQpSlApSlApSlApSlApSlApSlApSsqXEqKFVsAfAVBipWfxc38f6Cni5v4/wBBTa6YKVn8XN/H+gp4ub+P9BTZpgpWfxc38f6Cni5v4/0FNmmClZ/Fzfx/oKeLm/j/AEFNmmClZ/Fzfx/oKeLm/j/QU2aYKVn8XN/H+gp4ub+P9BTZpgpWfxc38f6Cni5v4/0FNmmClZ/Fzfx/oKeLm/j/AEFNmmClZ/Fzfx/oKeLm/j/QU2aYKVn8XN/H+gp4ub+P9BTZpgpWfxc38f6Cni5v4/0FNmmClZ/Fzfx/oKeLm/j/AEFNmmClZ/Fzfx/oKeLm/j/QU2aYKVn8XN/H+gp4ub+P9BTZpgpSlVCt0mig6DHqLNctv34EcG5F2nHvNnp+FaWtp8pxtpMNlNa7zDv2SCUrjcc9R2NQfRw/qPM2GFVO1nBaRQCq4y2c/N94de1exw/dmEnA5wl2bMjG3Zv37s4xjrmpsXEccrN4yzQols9tEiEgBDjahPwwTnvk1h/aSQsym0hNufd5W442cvl7c9+3XPrTaob6FqC78wj3WVBh1O8sMqF6+9kHyrFd6Vd2s8EUqLumOIyjqysc4xkHGc1Nm4inaS3aGGOFbaWOWFRkhdgwB17+teNT1yW+u7Sbl7Ftm3KhkZhnOT37dh+FNj5Lw7qMSOzxR4UEnEyH5pw3Y+Xn6VDudPubUE3EfLxM0ByR89cbh92RU5telYMDCg3C4Hc/993/AAr5xFqo1G5tuWSY7eFYwxXaZGx7zkepP+QoPt1w7dxXN3HEY5I7eZomcuqnAbbu25yBkjrX264b1CC5vIVWKXw0jxlkkXDlRltvXJwOpA6ipNzxVNNb3cfho0a4MhZlYge++/qOxIPQE+Ven4tuGW7At1TnySTDbIw2O4AY9O4yMgeVNiJa8OXs8yxsbeFmheccyZR0VN+D16Ej1r5omgzarHHKk0UcbXUdqcsN2XzghfMdP/WDWdeJGWO2j8IjJEjxtukYllaPYQCfmjBzj1qJo2stpiBVgSXbcR3KliRhkz+IIY02Pg0G/MgXlxgFBIJDKoQgnb87OM5BGPhWF9KvUcI8JV9sjbSQCBHnf+G01Ltdc5dhDZXFpHcW0abdpYqSd7MDkem4j7DWV+JJZebJNbRPcvzgsuSNglzuAHboScU2PltwxfyS7ZlSIYfJ3qSriNn2sM9DhfPtXj9m7/kPJiLeJYoljEqlpDICVK9eo6f+sGtpf8R2a28rWMO66uneS4ZlKgs0boT3P8ZOB0/GtWuvP4eOGS3Rlj5BUhypzFuwcj1DGmxAmsJ4r1LVuWZXIC7ZFZTn/eBxUxeHtRaRlEcXQId3OTad2QuDnByVI6eYpc620+sW1+baPMAUBGJbfjzYnqT17/ZWfUOJJryNUMCqq8rBZyx9xnYZJ7/6w/hTYwW2gXclrPcTAQxxxPLhiNzbTg+7nOMgjPrWO00a5u7Nbi3ClfeLl2VFUAqM5J9XFS5uI2mim5lnCZ3ikgEu45VHYtjHbILHr6VEh1eSLSJbARoUkVlLZ6jLo3/6Y/Gg+Pol9FHJJNEI1jkMTBnUNuBAOBnJxkdqzz8O30bXRRFMcBkyWdVYqhIZtuc46Htms8nEsjx3oa1jLXLlzl2KrnH93tkY6Gpp4is57S7nuYSdRljniQKpwqyMzYznyLt1xnypsQpOFb1dRktlkg2KZQJWkUA7FLEHr0JA7GtZeabc2dvFNcKipKAVAdScEZBIByMjrU9OIZVuriVreNhPO8zrkj56MhAP2Maw3+sG70qCxFuqLEQQ5csegxgZ+aPMgedNjzHoGoyCApACZioVeYuRuGVyM5GR2zUa5sZLO4hS99yOQBw8ZDgrnBIwcHsfPuK2sPE0kLxypaQi4/d82Tcf3oQYXp2HlnHpWourtri2s4WUAW0ZjUjzBdnyf8VBtb3QALhYdPnaduSk0jSqsKorqpX3i2M+9ioUmjX0UDyzQiNUYqys4DdDtJC5yQD0zU204lnt7iV+UpSWCKFkVyp/dqApBH2frWG91rx0J8VaRSXALBJi7ZVWcvjGevVj1PrTYxa5o9xpFy8c214xK8SyKwIYqcHIBOD1BwfWtZW4uNVjvjceNiwHlnuUCH/vJAoAPwBXNaeiFKUqhVi0XQRf6De3ZSYzDd4cqPcGxdz7vtBAHxqu1Lh1G7ha0aKYqbXrDgD3euT9vU+dQTJ9LVtVtLO3ZhzoIZCSpYgtGGPQDPcmpp4WkS5MMt5HHueGOMsje+ZQxXI8vmkGtOmpXSXkd0sv76NBGp2gjaF24xjBG3pWWTWr+SRHacAo0brtRQAUzswAPLcaKmpokUem3U1zcL4lLRblIVB6AyKoJPY9D2+IrFZ6DNeadFcwSq7yyCMRhScEsFAY9lPXPXyqMdYvjYtaGYGFk5ZGxdxXdu27sZxkZxmvMGq3lvaeGhlEcfTqqKG6NuA3YzjIBxmg2P7PIYpZ11CJrWIPvlEbdGVkUjHf/vFINZTwpM12IIbmOUq8scpVG9wooY4Hc9D5eday61q/ukdJZhsdSrKsaqCCwY9AO5Kr179KDWr8TGXn++ZGlOVBBZhtbIxg5HTHamxu4+FoomRLi4LTtcLEEClQVaPfknuD8MeVRYeGhIYl8fEJHaFNvLbo8qbkGfszk+Va9Nbv0d3SZVLOsnSNQAyjAIGOnTp0rGmrXqSK6zkMrxSA7R0aNdqHt5CmxszwtcrYQXMk0cYkEbneCFVXIAO7se4JHp9hqHe6NJa6tBY8ws023DGJh3OO3c9vLNYvli95EUJlUrFt2kxqWG05A3YyQPSvMurXkt5b3LSgTW4AiKoqhACTgADHcn8abGxOgeG4i0mxupC8N68Z3AFTtaQoeh7HINZrXh6CVpHF0strtOJVBUqyyRqwwR16SA/fWpl1a8lvLW6aUCa1xySqKoTDFhgAY7kmvcut38mczhQUKEIiqMFgx6Ad8qpz36U2MsekLPrl1Y28zmOFnHM5ZYkKcdh//lbG44YSKCOE3SLfmeeEKQSsmwKRjp07nv6itKmq3aXs90sic6cES/u1KuCQTlcY7gHt3rO3EOpskitcA72diTGuQWADEHGRkADpTYlLw3I+VS7iaWPZzk2n93uQsOvn2x086xfI0aaFJfTXBEhjjkjjVcghndcE/wDRWH5e1LbCBcY5TKykIoJKjC7jj3sDp1zWO41i9uI3jlkUxtGIigjUKFDFgAAOmCT1HrTYlWegTXenQXMEqO80gjEYUnaS4UBj2U5OevlUyx0KyBkuLq8M1msUpBiQqS6bQQc+XvqfjWog1e9t7Tw0E3Lj6dVRQ3RtwG7GcZ64zX251m+uc82ZcFGQqkaqMMQW6AAZOB179KbG3PC63GpyW9jeKY42RXeVSu3dGXBPw90j8KxWnC1xcSGLnBZgiMV5bEBnXcFJ7A4x+NaxtXvjzv35HOjWKQhQNyqQRnA79B171mXiDU1uJZ/EZllk5zM0an3+2RkdOnTpTYnW3C8lw4CXIbFvFPJsiZigkAKjA7nqfwrR31s9ne3FtKVLwyNGxU5BIOOlSItXvYpjIsoLGJISHRWBVQAoIIx0wKhSyNLK8khy7ksx9SaI80pSqFKUoFKUoFKUoFWrRNJtWsI7iWGed5rW5k5gxyoiiOAG6d+gPfzFVWsiTypGY0lkWM9SoYgHpjtUFvveF7KGRLeKaU3Du0EZzlZX2EqR7oABIAxk/OBzXyPhiwMFwWuJS0bvCzKchHSNSxwFOQWJ9Og86qTXEzCMNNIRH8zLH3Ps9K+JPMiyKksirJ88BiA32+tKVbW0C1uGiflzfv8AbEGhwEgxDGxd+nYlifLsa+pwzZvPBEVvI0Phi0zEbZOaqkhencZPr2NVJbiZVdVmkCuAGAY+8B5H1rNdajdXTo007koFCgHAXaoUYHrgCg38GiadeRwCB54Hmijm3yuGVA04hIPQf8Wfu+NZb7QdNtFuJm8SUhgaQxB8EkSonzio6EOfLoRVT5j7du9sY24z5Zzj8etepbieUkyzSOSNp3MT09PspQsOv6RbWenxpZW88lwt1MjS5zlFRGAIA6YDH8D93vh3TYdT4fu7YRIb+WcC3kPcMqliufQjd9+KrfiZ8MOdJhjkjcepxj/LpXlJZExsdlwcjBxg+tBddS0jTpzFNa2800EcMUSx2gAeTMki809D/APvYVit+HbGKSIvzrlYrsRzNu2Kyc7Z06dQRjqDnv086qMdxNEwMU0iELtBViOnp9lfOfLyhFzZOUDu2bjjPrilC3T6HbXxt7S0iNvdOJjErH522YghjjyTJ/6agaJYWd9eatbxNi3wiQyy4JQG4jXd9uCfxrTwajcwySSLIWkdGj3v7xAYYOCexIJ6/GoqsyhgrEBhg4PelC5HhvT/AByR5usNG2IwSfeDqoy2zoDk+XcYz1rBBw1BNbopM0c4nEUruQFjBl5fTphvtDd/LzqteMueaJfETcwDaH3nOPTPpXjny8rlc2TlZ3bNxxn1xShZpdFsIbSS8mhvYY0idvDyOBJlZI0znb2O8+XdTXy54etorLUmi8RJNbPJtJO1Qi7evbDHqcjI+w1W5biaViZZpHJG0lmJyPT7KG4mMboZpNjnLLuOGPqR50Fm0XR7XUNKglmBBjWV2CHa0nvooGcHtuJ7V6fhq2W21Fg8xMPOaGQnAIjGcFdvQ9x1I+yqtFPNEytFLIhXO0qxGM98V9FxMEZBNIEYksu44JPcmgtL6Jpa6pd2xF3sivo7JTzFzli+WPu+W0dKJwzaHTrdnuWWaXYeb3QbpQhGMdMDJzu7jGKqnOl3FuY+4tuJ3HJPr9tfTPMYeUZZOVnds3HGfXFKFg1+wtbLTLMxWlzCTdzo/PxvdVEfnjt1P2HNbPU9K0y71ERxRPaqbmGyj2su1QVyXPTqf/Wapk08s2OdLJJjtuYnH/rFfGlkbO52OTnqfP1pQtB0SxS2mu5ob2GNIS/h5HAfIlRM529jvPl3BqHxLpNrpyZtGmPLuprR+YQdxTadwwOmd3b4VpZLieVmaWaR2YbSWYkkeleXkd873Zskt1Oep7n7aC3XGgaWs80Efiw6zT26s0ikZjj3hiMefbFavVdHitrSGa1MspuzzLdR1PKCZcnA7hjjP+41abnSk55j5yTnce57mstxfTztCWbbyY+UgQbQq9cjp65OftNBjktp403yQyKg2+8ykDqMj8R1rFXtpZHXa0jsvToWJHQYH4CvFVClKUCssNu8i7soq9tzsAKxVIu/mwDyEYx+JqMoiPmX3wZ+mt/zBTwZ+mt/zBUalC8fST4M/TW/5gp4M/TW/wCYKjUoXj6SfBn6a3/MFPBn6a3/ADBUalC8fST4M/TW/wCYKeDP01v+YKjUoXj6SfBn6a3/ADBTwZ+mt/zBUalC8fST4M/TW/5grzJauilg0bgdTsYHFYKlaWM6lbKezSKpHqCcEfhRYqZqkWlKVWBSlKBSlKBSlKBSlKBSlKBSlKBSlKBSlKBUi77Q/wDLFR6kXfaH/lioyj4lHq4wJEdItQzwsosJJGtuUN8h3OAwbHl0PfstU6vYlkBUh2BUYBB7D0/U0mLZcefYs93odmnKhgEjzc2JA4LBZQ3fqRgfDGa+3Gi2kapcRwSyAwPJ4dWbLMrqvQkA4w2e3lVYM8zIiGWQqnVAWOF+z0r0bq4MqyGeUyL2becj76lSz8mH7VguIbePi7TImtgsBW2DRP5ZVc59fjXuS0tJoLWCS1MUsi3JVg2NhUkjIx17edVh5Hd9zuzN6k5NemnldtzSuW69Sxz170pPLG9N9qOlWVtpBkQyNMIopBIAxVi2Mg9MAdT2PlU7QolfTdMQruWZ5VZfDhlfqAAz91Hx8qqbTStEsTSOY1OQhY4H3V9S5nSIxJNKsR7oGIB+6lEcmMZXELFJYQPaxTm1e4aO3hHJiO0nduyxwM+QH3is9poVmL+G3eGe6SW5eFnR8coLjvgd+vWqtHcTRuGjlkRgNoKsQQPSpmnatNp8ZECRly28O2cg/jg/eDSYlljyYXuGuqVpX+1LT/nJ/mKi1K0r/adp/wA1P8xVn4acPzQi0pSqxKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKzpNG0apOjNtGFKtggd8dqwUqLE0kbrT6Of8wf0putPo5/zB/So9KL3JG60+jn/ADB/Sm60+jn/ADB/So9KHckbrT6Of8wf0putPo5/zB/So9KHckbrT6Of8wf0putPo5/zB/So9KHckbrT6Of8wf0putPo5/zB/So9KHckbrT6Of8AMH9K+iaKPJgjcSYwGdgcfZ0qNSh3SUpSqxKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUrZ6Lol9rMeoPp8XN8DbNdzKO/LVgCR9m7P2A0GspStpqehX+mwaXJdwMvylB4i3QDLMhYqDj47cj4EUGrpWz1HQNY0y3S41LSdQs4HOFkuLZ41Y+gJAFYX0rUI9OTUHsLtbBzhbkwsImPoGxg0EKlZ7G38XeQ24ljiMrhA8mdqk+uATj7qv+o+yLXNO1y10a81HRYtUulDQW7XLBpASQMErjOQemag5zStnruhanoOtS6TqtpJBfxMFMRGSc9sY7g+WKl/sbxOMZ4c1kZ7ZsZf8A+NBoaVkuYJbW4kguI3imjYo6OMMrDuCPWtjDw5rk1stzDo2pSW7DIlS1coR9uMVRqqVLsNMv9Ruza6fZXV1cgEmGCJnfA7+6Bmp9zwpxDawSz3WharBDEpeSSW0kRVA7kkjAoNLSshgmFsLgxPyC5jEm07SwAJGe2cEdPjUnS9J1HVpXj0qwu72RBuZbaFpSo9SFBoIVK21tw3rl01wlto+ozPbOEmSO2dmiY5wGAGQeh71I/Y7icFQeHNZBbtmxl6/y1BoaV6kRo5GSRSrqSrKe4I8q81QpSlApSlApSlApSlApSlApSlArsX9nrV9P4YfW9b1hM2bNbaczHsomZiSfUAICfhXHascWt2cPAVzoaRz+MuL2O7eUgbNqIyhe+f7xOakjofGXsug0H2hzzXAZeDljbUmmXsIgesIP8RYqo+DA+tbT+0wkF/ofA2t2cKwwXNmVVFHRFKxuqj7MtXPeIvaLqmucA6PwzdM3KsXPMl3dZlAAjB/4fe/T0rZ8ae0DTuI/ZzoHDos7uK80lUC3DFSsmE2kYzkeX4VNqt3s9kHtS9md5wVfSD5a0lRc6bcSfwA42k+gzt+wj0rlnG2rQXU9rpOluTo2lIYLby5rZzJMR6u2T8BgeVbv2Ncc2fAOuXupXlpcXZntjbrHEyrjLKxJJ/4aod0Y2uZWgLmIsSu8AHHxxVoe9O/2ha/81f8AMV+qPaDw5HxF7e+HVe+S3exso70RY9+flzM21D2z0Hc9snyr8r6dJFDf28tzv5KSKz8sDdgHPTNdL9oPtTGu8c6NxRoNvcWN5p0YjCTEMrYZj5eRDEEelSSGr9ufEUnEntEvp5LGax8Kq2ghnAEg2ZyWx0yST28sV0728afcalqHAsFvqNvYcyzCmWa4EWCdnXvk/dXNPajxnovHV3a6omlXGm6wFEd0yOskcwHn5HI9fTA8q2ntD494b43Oj+MstYthp0HIXlPGd46devbtQSv7O+lWvFHtOurvXFS6ktoHvAkgyJJd6jcR543E/biqJxXxRrGqcV32pT390lx4hjHtlZeUA3uquD0A6dqk6XxlLw5xuNd4Vh8JDEBFFbzHfuiChSr4xknGSR59az65rHCGs6vPqkmkatZy3DGWW1t7qMxFycnazJlQT8DiqN/7JNTvNZ9umiajqIxd3LFpGxjeeQw3ffjP3159p1tew8a8b38WqQRxxSurWwuAzyLIwQjYD2G7PXt0rT8L8b2+m+0iy4mu9P2W9ooSKztTgBVi5aLlvQYyfM/bWbXOJeFdU4p1LX5bDVpLm5d547d3jESyke7ux1Kg4OPPFT9Rd/Y0ulf9jXGcuv2Hj9PguFkeEHDD3QNyHyYZyDWy9iXCI0n2k2es6HdfKXDV3bTLDdqMNE2AeVKv91x+B7iuccH8c2GiezriLhu5tLqWbVjkTxldsfQAdD37Vp/Z5xzq3A2sC80qTdA5AuLVz+7mX0PofQ+VKGv4kvLhNd1m3SaRYWvpXZAxALB2AJrrv9pOeWCDgWSGV43XT9wZWIIOE61xTVLpL7WLu72tHHcTvLt7lQzE4+J61ePazx5Y8bW+hJZWdzatpkBtzzSpEgwvXp2+bVHPppHmleWRizuxZifMnvXilKqFKUoFKUoFKUoFKUoFKUoFKUoFWLhbgzXuK47l9AsVuxbYMwFxGhQHOCQzA46HrVdrvH9lj5/GP/wKf/XUnQ5TqXBXEGn6SdUn08vpyna1zbSxzxqf95o2YDv51XgCewNdy9nWr6PwV7KOJTq2r2F5c6xEUt9Ngk5jAlGX3wPm53dc9gvr0qV7I7q8h9gnGr2c80dxFMeQyOVZCVT5p8upqWrgRGO9K7r7WGSH2P8ADVtxWUfjYvvy+DcLDl8cw98bdo6+f2GsXElpD7O/Y9w7c6KiR67ruJZ9RCgyom3dsRv7vzlHTHY1bHDyMd6+gE9hXbvYrL/2iNrPDHFxbUUa1Nxa3cx3T2zhgvuueuPeBxnHT41O/szCa0veNbXmsVhtewJxuUsNw+NLHAwCewr7sfaW2ttHc46Cu4/2VZ5n4q18NLIwewLsCx6tvHU/Hqetc/4gv+KG4dlGt3013p1zc7IxNciZlkTrkdSV6HHlnPwpYplCCO9dy4jt4vZ37HeHLjQkSPXNdxLPqIUGVE27iiN3X5yjp6H1rmMvF+rX2iX+m6rPJqMU4VkkuTzJIGVgdysckAgEEZx1pYrzxSRsVkRlYdwwwa+bG2ltp2jucV3f+zfxHq+te0qaPUtRup4BYSFYHlYxphkACrnAwOgrl/EnEWp3epahp+pahd3WneOMhhllZwNrMBtyenQkUsVfB9DXyv01xVomt61aQcReybXVn0aOBYzo9u/LWMBcMuzoCT1yGw3XpnpX5mdWR2VwVZTggjBBpE2j5SlKoUpSgUpSgUpSgUpSgUpSgUpSgUpSgV1P2Icb6LwUuvNrRuy1/AsMa28IfGN2ScsPUVyylSdj1IFDsEbcoPRsYyK6dwTxro2j+yjibhy9a6+UNUZmiMcQaNfdUDcd2f7vpXL6UHV9X490Tiz2Z2ejcTxXUfEGmLts76GMOrqBgB+oIyOh79QD8K10fHFhrfs9tuFOKo7lTp7b9P1C2UO0Y6jY6EjK4OMg+npXOaUodK4R400ngHStUfhwXV9r9/HyFvLiFYo7aP8A3V3MWbOD1wOg++z/ANnO4TTdL441nUZOVYx2QRppDgM53HAPmfh8R61w6pDXt01mlo1zMbRGLrCZDsUnuQvbNKHQ/YbxnpHBOs6nea14opcWvh0W3iDnJYHJyR06VWZk4ct9M1FodRv7y9kAFtE1oIo1Yt1ZjvOSFzjp3NVqlKHSYOOdN1z2fWvCnF0V0h09t9hqFqqyNGMEbHQkZGDjofIelV7xOgaVpV/Fp8l3qV/eRcgSTwCCO3XcGJADMWY7ceQGT3qr0pQ6H7D+LtL4K4um1XWfEmA2rwqsEYdiWKnzI6dKp97dWr8SzXgVp7NrszbWG0uhfOCPLI6VrKUodP4V4q4f4O4tfXdAv9ZNsd7fJbQKgfIO2N3DkFQSOu3PTtXOdUvJNR1K7vZgoluZnmcKMAFmJOPh1qNSgUpSqFKUoFKUoFKUoFKUoFKUoFKUoFKUoFb3T40azjJRScdyPjSlYZ/DLH5SOVH9Gn4CnKj+jT8BSlamZyo/o0/AU5Uf0afgKUoHKj+jT8BTlR/Rp+ApSgcqP6NPwFOVH9Gn4ClKByo/o0/AU5Uf0afgKUoHKj+jT8BTlR/Rp+ApSgcqP6NPwFOVH9Gn4ClKByo/o0/AU5Uf0afgKUoHKj+jT8BTlR/Rp+ApSgcqP6NPwFOVH9Gn4ClKByo/o0/AU5Uf0afgKUoHKj+jT8BTlR/Rp+ApSgcqP6NPwFOVH9Gn4ClKByo/o0/AU5Uf0afgKUoK23zj9tfKUroan//Z" + }, + { + "timing": 1125, + "timestamp": 4494627989, + "data": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAHyAPoDASIAAhEBAxEB/8QAHAABAAIDAQEBAAAAAAAAAAAAAAQGAwUHAgEI/8QAUBAAAQMDAwICBQoDBAcGAwkAAQIDBAAFEQYSIRMxQVEHFCJhkRUWMlJTVHGBktFCk9IIIzOhJGJyc4KUsRc0NUOywTd0wkeVorPE0+Hw8f/EABoBAQEAAwEBAAAAAAAAAAAAAAABAgMEBQb/xAAxEQEAAgIBAgIJAwMFAAAAAAAAARECIQMSUQQxBRMUQVKRodHwFTJxImHBMzRCU+H/2gAMAwEAAhEDEQA/AOU6T9HN/wBS2ty6RW40S1tq2mZOfSw0T2wCe/NQ9baHvujJDLd8iBtt8bmX21hbTo/1VDj8q/Rl711pi26J01p+KFLWiHHlhbYHTaAST7XmokKGPM5NY/S9qOxal9BMxyOClcOS1FZS6BuDqdp4x4bCfyrOcNzjWu6XFRN77PykAScAEn3V9UhaRlSVAe8Vnts+Xa5zUy3SHY0to5bdaVtUk4xwa7jdpkrUuptM2i+TZU6C9p9md6g4+pKZcoNLUkE57qUBz3NabZOC0rtidM2ZiKu43PTzES4psMuc9aFrdShpxt9tLayCrekKSVcE+B86i3+x6fet18aiWSPDeZsUa8tPtOuFSHFlsKQApRGzCjwRn30taceSkq+iCfwFfK6/6I3bsnS0hi1Q7khLs8FVwtAbdfbIQAEOtK5LXOc5AznvW8tOkbM49c3bnDGoriu9OxZS7fFUpLbYCTlKUOIS1uKle0cpBBHhSynBK+kEYyO9d00Zo2yyVabRH06bxb7hMkomznVr3RQhwhtB2K2pO0AnOc7uD2qXb7FFvFj0ZFuNiTJtSrbITJuZcWkwUpcdKSCCEjn6wOew7GpZT8/0rtPzU021oRh9Frly+raVS3LkwypQbf54LvUCEhJG0oKCaO2XTx9IDVlb0z1I8e2pkn1fqurcdUyhW5aAsFSQSfZRgnPjVspxalWz0nWZFk1UuO3HjRkOMNPJZjlzCdyc8pc9tCvEpPIzVTqoUpSgVvdJ25mfKdVITuQ0B7PmTn9q0VWvQf05v4I/+qtXNMxhMw7vRvHjyeKwxyi4/wDJWH5JgfdGf0CnyVA+5sfoFb/Tioqb7CVcOn6qHRv6gyn3bvdnGfdVjbZRMkH5detUqWholptuS20FAuJB3uIITwkqIGc/5CuKOqfe+s5I4uOanCPlH5/LnvyVA+5sfoFPkqB9zY/QK6Vb42mGbhGSfV3mm1B3rPP8LAllvapOcY6WFYx4Z7ZrHEtNgctza570WPIVISVBmUFbUF7apHKjwE85weOdx7VenLu1et4P+v6Q5z8lQPubH6BUW5WOE/FcDbCGnAMpUgYwa6DdGoDWn5qG4dvamiQysdOWHlIQUrCtp3cjITkc98nwxU3f8Jf4Gp1ZYz5tscXDzYzE4RX8Q5RSlWLSAjF5z1rrGOf+9Aj+56XG3eRyB1Nmcc4zivRfCtFJYdivuMSG1NutnatChgpPkaxVbtVBr1FONoGcu+pZVH9Zyc5Uo5z09vmM5x41UaQFfQlRHCT8K+VfrGbx8kxfV16zDOz2fU21FnH+pg9qCgkEHBGKVttTmQbw764bkXtqcm4gh7t4g+HlWpqgVOZBDqxgbe/h5VmVLkriCM5IdXHDhd6ZUdu8gAqx54AH5VhpV6pqrSoK9l1xSkqUtRUkAJJPYDtivFKisin3lLWpTrhUsbVEqOVDyNC86c5dXynYfaPKfL8Kx0oMjL7zBJZdcbJ4OxRGfhRp51rd0nFo3DCtqiM/jWOlBaNOa1uGnoSWbfFt3WbWpbUpyPl5pRGMg5wfduBx4VXDJfKCgvObCMFO44I79vzrFSgyB50NFoOLDROSgKOD+VA+8HQ6HXOoOy9xyPzrHSg9LWpxZUtRUo9yTkmvNKUClKUCt9pK4swZTqJCghDoHtHsCM/vWhpWOWMZRUt3h+fLg5I5MfOHTvlOD98Y/WKfKcH74x/MFcxpXP7NHd7P69yfBDp3ynB++MfzBT5Tg/fGP5grmNKezR3P17k+CHTvlOD98Y/mCotyvUJiI4pEhtxZGEpQrOT+Vc7pVjw2Pdjn6d5ZxmIxiCvoJAIBOD3r5Sul4TLKkvSpDj8hxTjrity1K7qPnWKlKBWVMh5CQlDziUjsAoisVKD0talqKlqKlHxJya80pQKUqww9H3WZFt78f1Eif/gIcnMtuK9oo+gtYPJBHagr1KuE30cakt92atlxYgw5ru0pafuMdKiDwDjfnmql0llakBJUpJwcDNB4pX1SSk4UCD5GvlApQDPalApVr+YN7Q3FMv1CE9LQHGI8ya0y64k9jtUoEZ8M4quyYMmNMkRXmlB9hxTTiU+1tUk4IyODyKgjUrKuO8hsuLacSgHG4pIGfLNeENrXnYhSseQzVHmletit23ad3ljmvSmXUjKmlgeZSaDHSvaGnFjKELUPcM16VHfSgKUy4Ek7QSk4J8vxoMVKyFh4DJacA/2TWMAk4AyaBSva2nEDK0LSPMjFeKBSlKBSlKBSlKBSlKBSlKBSlKBW60etS9X2HconbOYAz4DqCtLWz0zLjwNRWyZNLojxpLby+kgKUQlQOACQM8edB1X+0uyqR6XojKF7FORY6Ar6pK1DNSfTpJXoORaNL6UWu2RURRIkPR1FDslwqIytY5P0c49/uFU/006wtmtNXtXmyiY0gR0NFEltKFJUkk5G1Rz3rPqzW1q13a7YrUzcyHfYLfQVNiNJdRJb/wBZBUnarPPBPc/lj2Va9ORW/SF6FtQyb6A9erDucjXBY/vVICN+xau6hwoc57ipNx9Hka/ehSzSLRsXqO0xBJeZT9Nxl0qd2kd84VlP4EVR39dQrXoBzSWl2ZSGJrnUuE+SlKXHs49lKEkhKcAD6R8fOtlZPSc1p/0jxbvavWl2QRI8F9h1AQpbaG0oJ2hRGQQVDn3eJpsWL0M6AjydHajuVwCDdpdreEGOr6SGlJUkO48NykkD3A+dcJaX03ULwDtUDg+Ndf8AR96WI9r9IF81BqNEtca4RywhiK2lXTSFDYkAqSAEpBH51ywvRGb2HmkLegofCwhYCCtAVnBAJxxx3NWB+grzZdMem6Ki6aeuKbdqxphKXYb54XtHYjyHgpPuyKi/2erfc7LqjW9suvUansRP71KnM+3kndnPOc5z7651Gm6QgauY1Bbbnd47DUkSkQUxEh1BCt3TDm/bt8M98eFWfRvpYtsXWGrb/qBiYly8tBlpqK2lzppAwMlSk9gAPfUFVbj6guqLTbL5dPWYF0uTbKFKlpkqbUkhJIIUrbw528atvp4vMjSmoIultKOOWi1wYzalIhqLSnVqydy1DBVxjv45rnaX9P22BIetk66yLsFtqil2KhltkhQJXkOKJVgYHHiasWuNX2HXxhXK9In2y+sshh9cVhD7MgDsrBWkpPJ8/wDKg8uHVUxrSlzvcZ5UZmYkR7otSdzyVLThO8HKyClXmeT5V+gJsuQfT45CfnoNqXaBvtzrm4SF5UfYbPdXHfyBrgl69IUGXZNK6cgxZDNls0hD65DoCn3lAkkhIISB7SuMnuOeKtN29JWj5/pShazV8uZhsBtuGIrQ3KAUMlfV4HtdseFSYG49C6XYz/pUYjMPW5KELUzGcV0zH/xto74BAxz7q5HdpOoWbbajeLkZTUiWXWFetiQttTeASFpUcZ39s+GavenfSxaE3bXFxvUeay5qFsMtNxWkOBlIQpAKiVpycEeHnXO9+mYttUiPLusuYp9G0vRENtst5ytQAcVlZ2pHgMZqwP0trD5dd9OtgTbZTrdoYtyHrigvYZ6W93cVoJwc4AzjviuZaevWjEenO/yQ8xCtUppxmFLCAEMPqCQXE5GE878HtzWPVvpihu+k2z6q04zM6UaIIcmNKQlHVRvUogFKlfWGPIgVXdUXvQN41BdpseHdorFzaCiEst7oj+4KK0DfhSVY5GU9zipECd6XNJ6x05aUi7Xd6+6dckJeZmKeU5tXhQGQSduQT2yDxzXPbPp+Xdo63oz9tbSlW0iVcGI6s48EuLSSPf2qzztaMxvRzI0hbZE+dHkSUvKemIDYaQkghDaApWMqGSc/lzmqDWUCy/Mu5/e7F/8AfUP/APdqBeLDLtLKHZT1ucStW0CLPYkKBxnkNrUQPea1NKIUpSqFKUoFKUoFKUoFKUoFXTSWjWrlpO8anu0mQzabatLRRGaDjrriscDJASBuGSfPtVLrpHop9Ic3QjLyJdvTP07cXCh5lYHKkgbinPGdqk5B4PHapIqdyh2Z1uAqxzJRdfdW06xMQlJZxt2q3JPtA7j4DG01vLz6M71ZLixBu8m1Q5b6QpttyYnKgTgEAe8Grf6TNLaVfsFt1tod5TUGXNTHehqGA24ck4B5SRjkcjkEcVvP7RjFke1/aflmbMjn5PThLUdKkH2l4ysrBTzwcJOKlq4qdNXT5Im3RuMp2DCkerSHG+ekvwJHcA+dZNHaWuWr7t8m2VLK5mwuBDjgRuA74J4rsXoTuUiz+iXXtx6Tbz7KkuluSnclzKOQoeIIP+dbH0H2qx3LXrGpdKOpjMhh1E20ur/vIq1Dgtn+Nsnse4/6LHHrH6Pb3fF3lNu9Tc+SCfXCXwkNgbsnnuPZV28q1mntK3fUAkrtcYORoo3PyXFhtloealqIA/612r0Nf/a9/uXP/wBRWtvWGf7LVo+SeG3Z3+nlvxO9f0/zCO/upZTmS9EXlVsk3CAmLcokXl9UCSh8tDzUlJyB78Yr3pzQl41DYJt6gGGLfCUUyHHnw308AHJB8MGrn/ZfXJHpOShkExlw3hJH8OzAxn/i2/GrnphEBPo29LbdvUE20Tnw0psbgG8cbR4jHaljimo9FXrT9qiXSawy5a5ZwzMjPJeaUeeNyTweD38jXj0f6fZ1Vq632V+U5FExRQHkNhe07SexI44866v6VW16b9Cel7DbW1zrRKUJKroQAlSlbnAgJySk+14+CT76oPoM/wDizpv/AOYP/oVS9D3qbSem9PaulWCffbih2O4ltcn1BBbGUg5IDu7HPlWHVPo1vNg1HbLW45GkIuhSIEtC8NP7iABk9jyOD5isvp3/APi3qP8A3yP/AMtFdh1MoRNG+h6BcPZunyhCWlCvppQnaD+GNyBSxxW5+jm72q7KtlxlWpi4AA+rqlpK+RkYAznIqM9oK9NaMGqQmM5ZiQOq28FKB3bcFPcHPHNdB9PzVmPpRu7s2dNanohoWy2iOnplwNex/eb898fw9+K9/wBn66NXBm++j6+Epi3RpwspWOW3gMKA9+AFfiil6scmg2GXLscu7pWw3BiuoYcW4vB3ryUgDx4B7eVWC8+jW9WT1P5Wk2qJ62jqMdWYkdRPHI+Ir16REiwR4GjmXUOG2lT05bZylyUvv+OxISn8d1dQ9PDFlfe0Im+zZkVkwQD6vHS4Cn2MkkrBT+QNWxyax+j293td7Tb/AFRfyOpSZhU8EbAN3tDPcewr4VUSMKIBzzjjxru39n0K+b/pKK9xKrelQKu5BQ9g1zb0TMRX/SNYBcUBUNMttTm4eyOQE7vdvKR+dLGJehLzHiRZFzEO1plJ3MonykMLWnzCFHIHvIFQb/pe7afmR2LxG9WEgBTLxUFNOJP8SVpyCOR2q3/2inJS/S1eBL37EJaSwD2DfTTjHuzn881bblse/ss2xd25kNzdsBS/pY6ihge7bv8AyFSxSZfok1NEuse1v/JqblIR1GIxmthbqefognnsfhWvsfo41FeHrwyxHZZftH/fW5LobU0ME5Oe4wk8iu3el+4WSz+lvS921DJltNQYKH22o7IWXVhxeATkbRnHnn3Vi9GmpWtYXb0qXrpLjRpMJsJTgKWlCW3UgkZAJwM4z+dLkpwKbpp+LEakibbn2nH0x90d/qbVEEjdgcDg1Y5Xok1NGuzFre+TU3J9vqsxTNbDjieeUgnnsfhVekx7YiNANmlzJK+qVSg+wGtgBQEHaFKGPaPOe5r9N6mtES6envTjkiYpqRBtiZbDASP9IUla/ZCs8HkHtyAaTND8n3W3S7TcZEC4sLjzI6yh1pfdJFRatvpZucy8ekS+TLlCMGUX+mqOTkthCQgAnxOEg5qpVUKUpVClKUCrJZ9VGFYlWafa4Fzt3WMhtEgLStpwgAlC0KBGQkZHI4qt0oLLdNXy50W3wW4kOLaILvWagMBYbUs91LJVuUT2yVfhit1qX0nStTXNiffNPWCXJYQG0KU2+BtBJAIDuDyT3qgUqUL1D9Jd0i2jUFuTb7WqPfHFuStzbgI3eCMLASB4cfGqpYrxPsN0YuNpkuRZjKsocQf8j5g+INQKUF30t6SLppsX0Q4NteN6J9bL6HDkHd7Kdqxge2r381qtO6wutgizYUNTLtsm8SIEhHUZc/I8g9uQQeBzVdpQWxjXVxgW6ZCsUWDZm5idkhcJCw44n6u9alKA9wIrJp3X9xsOkbpp2JCt7kG5bvWFvJcLhyMcELAGAPKqfSlC5Wv0h3eFo5/S8hmFcLM7kpaltqUWTnOUKSoEc81p9IahkaW1BGvEGNFelRiVNJkBRQkkEZwlQJ4PnWlpQXe5ekN2439y9y9O2By5uLDheU08obgAAdpdKeMDuK10rW95n6tiaiuzybhPiuIcaTIBDaSk5SAlJTgA84GKrNKC/Xf0lybxqIXy56d0/JuQKT1FtPkeyMJynq7TjA8KqFuu8y33xi7xXSmcy+JCV/64OeagUoJEqW7MnuzJZ6zzzhdcK8+2onJzjzq76k9J0vUogi9WCxShCb6TGUSE7U8ccOjPYd6oFKDoFl9Kd1s798ciWyz4vCUtSG1NOBCW0pKUoQA4NqQCR5++tBO1N17Q7b4dntdtbddQ647ES71Fbc4TuW4rCcnOBjkDyqvUoLdP15cLszFTqGFbry7GR02pExtfVCfIqQpJV/xZqHqLWF11C9C+VFNOQ4QCI8JtHTYaSP4QlJHljOc++q7SgtvpC13cddzIkq7xYLL8ZvooVFQtOU5zghSleJNe9Da+uOjIV0i22Fb30XJAbkGSlxRKAFDaNq04+kffzVPpQWV7VSVW9UOLYrPDaW8286phL29zZnCCpThO3JyQMcgeVbHVXpKvmotRWy+OoiQrnb0hDD0NK08AkgEKUoHufxzzVJpShZtdayma0uDc+6wre1OSgIW/GbUhToHbcCogn3gCqzSlUKUpQKUpQKsMLTS5VlRPS+pJWh1wDoqKAGxkhSxwCcccVXqsVu1GmHbI8cRFrfjpdShfXIbIc77kY9r41JEKJYpr8roraU2AUBSuDt3oK08Z8QCalw9Kz5k9lhgAtL6OXjgAdRCV4AJyogK5A/GpDWq0tBC0QB1z0S6svHCy22psYGOMhWT35FIuq0NriLkW9Lyoa23GD1inapLaEKzxzkNpPuPn2ptdIC9N3EgKjsl1vYhWchJJUgL2gE5JwfDvUddluDdu9eXGKYoSFlRUMhJIAJGcgEnjjnwrYnU6y7b1+qp/0R1p0Df9LptoRjtxnZn86lTrxbXdPPABSrrIjsxnCEkABspwfLsgDjOe/s85bGlYsdxkNx1tR8pkJK2yXEjKRnKjk8JG08nipKtOy24brr4LbjfVCmtuSNgbOc5xg9UYP717tuolwnYx9XSttuIqGtO7BWkrUvIJBwckeB7VIf1Yt1LyTESpKwtIC3N2EqDQAPHOAyPLv4YpsRo+lrk6462ttLa0MKfTlxJCtqkpI3A4SRuBOTx414+bdw6KCGv79TzjJaJA27EIWVFRONuFjnOK2cjV7T6Cy5bSYqkOoU318EBamydpCQBjp8DHj4+PlrWCmzsEJIjkqSUBznp9NpCU5IPI6STnHPlTZpoU2qaq5GAGFetpzlBIGABkkntjHOc4xzWRdluCHEoMc7lKWgYWkjKEhSuQcYCSDntipHy4o6hN0W2522hCHilQTs2ABQHgMeGPdjitg5qNpVvvBbZbYemrQllptP8Agp27Vq3cDKk8HA5yTxQQY2l7m+raW2WT0VPjqvoT7KUhRB54OCODjvWFGnrqtDCkw1EP42e0nPKSoZGfZykEjOMgcVslapbU3HbXA3BDS2XFKfJWpKm9mEqIyAO4B3Vkd1i44hkmIOqkAOkOYSshpTYOAnjhWeSfdimzTVPadurQbKohPUWltOxaVbir6OME8HwPY+dRX7bLZnIhrbBkLICEoWlQVntggkH41s2dRqbShPq/0W47eUulJ/ulZBBHIJ/yrxLvjb99jXAQGtjISC0shRdxnlZwAVc98eA702MaNNXZbq20RQoo2ZIdRtO7O3Cs4OdpHB7jHevsPTs+RCkS1t9FhlpbuVkAq2nB9nOcZ4zjGeKmztVKktIbTFKUoUyQVu7lYbW4oZOB36mPyr49qdt5mQV29PrTrLscOh44S2tal/RxyQVHny8PGmxp2bXMegKmts5jpON24AntnCc5Pcdh41M+blwbcWiU10CGluJyoEEpxlOQcAjIyDyPGslq1B8n2pcVMUOu797a3F5Qg5SdwQR9L2e4I9+ayytSNrjusRIAjsuh5S0l0rJW4EgkEjgAJGB8SabENqwzles9VlTZZUtsg45cQUhSe/huHPvr67py6tSkR1xCHF78e2naNn0sqzhOPHJGMjzqa9qp515pao6fYjdFQCz7ayUlTh952jP4VmgaiYfekMXFrpw5T8h50gkn+92EJBAyMFtJzg/hTY1bFhmrvAtj6OjKLSnQlRByA2XB2OOQP86+I09dHJDrCIuXWwlRHUT7W4ZTtOcKyOwGc1Nu16j/ADjXMt7RVGRFERAUSMjodLPifM1Is+rRblx1mAlxxgNBC0ubVHZngnB9k57DHbxpsaprT9zdDZRG4cb6oJcQPY4wo5PAOQBnueO9RrxAXa7nIhOqCnGVbVEDHNbFF+QpbqZUMPRnYzcdbYdKT7GCFBWOOU9seP51r71PNzukmaWg11lbtgOQn3ZoIVKUqoUpSgUpSgVuY9hcetzElMqOFvtuutsHdvUlvO7nGBwk4yea01boahkNWeNAjttNhpt1sulCVLIWTnaSMp4OODUElelXG5LrLlwhoKHkxtx34LqskIHs+Q5PYZ71lc0wgNwSiUgPrjh9+OoneB1ShRSdu3jHYnPetezqO5MyZD4caU4+4l5XUZQsBwZwpII4IyeRXz5xXH1VDHUawhAbC+ijftCt+3djON3Pem1bSZoqa21IkMn/AEZLitm9C8lAdLYJUE7c55xnOOcVHlaVeYQ8Uzojqmw/7Kd4Kizy4BlIHA5571Dd1DcXmih1xpftFQWplBUMr34CsZA3EnHvrGq+T1FRLwyovk+wP/OGHPDxHw8KbHq+2V6zFgPuoc6oJBQlYBAxyCQAoc9xkVqq2cu+TJTAZdEbpALASmOhIBVjcrgfS9kc961lEKUpVClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKz+qSfVPWvV3vVd2zrbDs3eW7tn3UGClKUClKUClKlw7bOmoWuFCkyEIIClNNKWEk+BwKCJSvq0qQtSFpKVJOCCMEGvlApSlApSlApSs70SSwwy+9HebZeyW3FoISvHfafH8qDBSvoSopKgDtHBOOBUpdtnIcYbXCkpXIGWUlpQLg/wBUY5/KgiUrYM2W6vJSpm2TXEqJAKGFkEg4I4HmCK8R7TcZKVqj2+W6lCtiy2ypQSryOBwfdQQqV9IIJBGCO4NfKBSlKBSlKBSlKBSlKBSlKBXQYVvm3D0MoagxJElw3/IS02VHHq+M8eGeK59SoOi6CsFvcC7dfek3LvfUgwluZ/uVpPsuDAwcuhKO44Cq+WVM6NoXWgltqRNty4bLZUgbmCHSlQBxxwOa53SlDpa4syT6N7FJiR3zIdkzi64xGCtwwjG8+CeVcntzXi5NtHQ8WbHQ9aZ9vYjktKbSqPNBUNrrS8f4ntZUnnsfIiub0pSr5rR59nRukFJGwzILxkK2AF0h9WCo45OAn8sVl0OUNejjWD0ht9UdEq3KV0VbVEBbhOFEEA8jnHGa59SlI7DYrqxqdGr75OQ1bW37jbz1ukHfV0Fakq5PfIA3eflUG+W5plvWCrZbGo18+UkKZjIAWW4Stx3MAcHKtmSnsk8YGa5ZSlK7DpeFBVqfQqZkeP8ALL0eUbgzsTykJX0S4nsF4GT48JJ5rTxIMuR6NLM5AjyFSHLhMStbEcLKk7GtoWfBOSrk8DJqg2y5S7W+t6A8WHltqaLiQNwSoYVg+GRkZHOCaiUoX+dGfRYdML0jG64VGUuaploOr9ZDitwd4OEhIRgHjGT51l0s7Jcs+tku9FZgwf7ktIBQ0r1hOSg444KufKud0pSNpcy+9bokuRCS2X3Xj64CcyDlOQRnA258APpc5q4ahtU+f6OtCiJDkPJQzNUtSWyUoHXJyo9gMDOTXO6UHU9C2uJItjmlZimkXC/RTIa3pIU26n24/OMAEJXnnkODyqNbpUk+jKbIlsL+UdPSxGhvHIUyl4K3pP8AslOR5FVc1pSldK0HAn2fS8rVTEWVKuK90C0NttqcLaznqPYHYJBIH+sr3VN0RGai6SkIv7kiJHY1NEEh5v6TRS26CSfABRGT4VyilKF41PbJbvpBuM2/xEs283FC5bkc5aDTq8hSFeKSnJBFTtQWqY/etT/91hWKO26uKssp6DiEqBaQ0ocb1ADBByec9zXOaUodOk21yRddNsacTHbsi4jCnZSmQ4ylwj++VIPuVnIURgYx4VzWQ2lqQ62hYcShRSFp7KAPcVjpRClKVQpSlApSlApSlArM3JcQgJSGsDzaST8SKw1vrfYETIkFXryGpU5S0R2VtnapSTgAqHYk8DjFSa96w1Prjv1Wf5KP2p6479Vn+Sj9qmuWKcFRwyypzrltCcYHtrGUp7/jz7jWGXaJ0SGiXIjlDCyAFbgcZGRkA5GQCRnv4VKguWD1x36rP8lH7U9cd+qz/JR+1bFOnbg8htcRkvJW22vuE8rBISMnknacY74r6rTVy/0bptsuB9gSAUPIwlJOBuJOEnPgaVBctb6479Vn+Sj9qeuO/VZ/ko/apUGzS5i56EBtpyE0p15DywggJIBAz45PapVx0xcoc4R0sl4LcLaFoIwogZ559njnnHHPalQXLV+uO/VZ/ko/anrjv1Wf5KP2rK5aprdxRAVHUZa8bEJIVuyMggjgjHj2rYO6WuaFR0IaS446z1iAtO1A3qQBuztOSnjB5zSoLlqvXHfqs/yUftT1x36rP8lH7VsXdN3JsQ8ts7pLanEo6yAUBKik78kbeR4/h3yK+/N2WIT7zgUh1kqSWSnJKkuNo2j35dHwpUFy1vrjv1Wf5KP2p6479Vn+Sj9qyzbXMhSm40hnDzn0EoUF7jnGPZJ5zxjvWzg6UnvzFsyi1FQhlb6nFuII2p7ge1gnPGM8eOKVBctP6479Vn+Sj9qeuO/VZ/ko/apNvstwuLCnoUcuthRRkKSCVAZIAJyTjnivTlhuTbzbSox3uOJaRtWlQUpQynBBxgjx7cHyNKguUT1x36rP8lH7U9cd+qz/ACUftWSJbJkuO8/HZ3tNKCFq3Ae0c4AyeScHAFSl6duqJKGFRCFqSV53p2gA4OVZwMHAOTxkUqC5QfXHfqs/yUftT1x36rP8lH7VLNiuQYkOmIsIYKkuZIBG3lWBnJwOSRnFS2NJ3d2SGVstMqKVq3OvISkbUFRBOeCQOAfx7ZNKguWp9cd+qz/JR+1PXHfqs/yUftWe3WidcUOLhs9RLakoUd6UjcrOByRknBwBWRqw3J1LKkRjh4KKNy0pOEkhRIJ4AKSCTxxSoLlE9cd+qz/JR+1PXHfqs/yUftU75vz8ob6C/WFOrbLZwANqUqKt2cYwoHPbHOa8jT903Pj1RQLHC8qSM8bvZ59rjnjPHNKguUP1x36rP8lH7U9cd+qz/JR+1Zrxa5FplIYlKZUtbSHgWnAsYUkKHI8ef/6MGoNKguUj1x36rP8AJR+1PXHfqs/yUftUelXpguUj1x36rP8AJR+1PXHfqs/yUftUelOmC5KUpVQrf2+/sxIcBJgdWZBWpbDqnsICircCUY5wR51oK2M2E2xaLbKQpZck9XeCeBtVgYqDYRtTvMF8hhKlORUR0kq+gtKdodHvwVfqrzddRruFpbhljpuBLaHHAsYWG07U+zj3DOSfditjcNKs25u1rniYw3IHRfdWnCW3VICkkccpG7B7n2Fc9qjN2aCxekWuUiQ9IbR/pbjchLaGVDJXzsVkJT394OPCmlYmdTLb+T/9FSfVHI7g9v6XRChjtxnd+WK+M6hYMJuJMt5fZ6SWnAl/YVbFFSCODjG5QPfOfCtjG0/bJlvMyO3OTGWuQQ+t9ADKGwNpWnb7RORnBHurSWSxruvTPrceMHX0xmi9u9tw+A2g9uMk+YpoEXoquN0lSGAsXBDiXEIVt27lBWQeexA/Ktgzq1xqZIfERB68jrKSV+BbW2U9vJZ593Y1De0861AfkLlxg6yymQqP7W/YpYSDnG3+IHGexqHaLW/dXHW4pQXW0pUEE8qytKePw3A/gDTQmu6gUq+s3BLH92030QytectlJSRkAdwpXYDGanxtWtR2m4zVt2wm20oS31sryla1hW4pP2igePwxXwaUEdu4m4TGWug2pbTiSooUA62jefZJKVBZxjnIrz8yrn0JbuUER1Op9lK1BfTGVEKCdo47biM1NG2NvU6VPIelQus+EOtlwO4OFuFzKcpOFAqUM85B8O9e5+rFy25SVREp661LJ6h43LaV+P8A5WO/8Xur1E0VOlypDEd9l1TDiWVqQ26oBxWcJOEcduSeOe9aiPb0qtVzkO70vxVtoCQRj2iQc/CroTLjqIyLvAnxoqWnYigsKcX1FOKCt2VqwM+XnjxNfX7+10lMQoPQjFt5OxTxWdzm3crOBx7KQB/nXpGlJps7dydWhqOpCHFKW25hKFLCQoq27T3BwCTjwr4/pl2KuSibNiR1RggvbipW0rJ2j2QcnAB48D+NNCPab4q3x2GgwHOk+t7JVjO5vZjt+dbCDqRLNvlBaUh0Q0RWEYKvbGR1c+BCVLH/ABV4maXVFaSZMlqMWkqEhx0lSAsOqQAnaCTnbn8jXxrSE1cpuN1mPWVrdT00hajhvO5XCTkccAcnypoa623d23xktsoSXES2paVqPZTYUAMeXtf5VtpWqm5K1tuQCYLrakOsdfBJUpKspUEgDlCfA8DnNQJGnZce+ItjqkJcW31uosKSAjYVlRBG4YAORjPFbFzSzbkWKqDJQ+t5DSi9vKWwVreBOCnOAGhny5754aGBvU/TtbsJuGG04dSyUOf4aXBgpOQSrufEd+c19b1SRLluuQwpEp3qLQHMEJLS2yAceSyc+7tWW36Vbfci75zLkeUW9j7W7CQp7pnKSnJOc+VYI2lnpER2Y0+lyK05tUQ24nKd4RkKKdueQcZzU0bYbJdYUG2yWpcVUlapTL7bfUKPoJc5JA81Djx91elajU/JDk2Kl5tbDjD6ErKCsLdU7kHHskKUPPt76wqsoVcbo2mS3HiQXVIU8/k/x7UjCQSSfw8DX1Gn3Vxy4mXFU4W3Hm2klRU622SFLScYx7KsZIJ2mqNudWtttxltMA46jS4+eEM9NttACyDlWG85xj3eFQJ2omZ7biJlv6qUqK4+XyOmShKMKwBuGEJ4G3t5cVsZei1OSHG7at0oaW+HFLQpwgId2JwEJJyfHjz7VqZenHYO5NwmRozocWhLa95KwhW1RGE4xnOM4JxU0MFzmxJ8YPKacbnIQwyAFZSpKEFKlduPoo458a1NXB3SkVqVNZVNHTYclNiQSQP7pKDynbn+Lwznw8zhY0g9IYQmO6HXlr3JcQFKQprpdTcEhO4nwxjPuq2KrSrI/pCcwZvVcbT6qhLih03CSlSNwJATlIxxlQGDxUOzWCTdocmRGWkBgKUUlCznCSo+0ElI4HiRS0aelWI6Uk7glEuItSS2HgCodELbLgUrKeRtSrOM9qiX22MW+PbFxpIk+tMKdUtOduQ4tPAIBHCR38c0sailKVQrYt3eSiC1EKY62Wiot9RlKlJycnBIz3rXVcbTbrSuyxpD8Z8uqiylurDgIJQRt2gjg8//AO1BXHrrMfErrPFfrToed3AHKwSQfd9I9vOszd9molT5BLLjs4kv9RlKgrKtx4I45548qsTGkoLiVOKlvJZeKAySUgthTKXAVj+L6YGE+RPurTWCyIuiI5KncrnsxVBsZwlYOVfjxS4VEbvU1tTZaW2hLfVCUJbSEgODCxjGMEeFbLT2p/kp3qPxESChTbjSUhtCUqQMBWCg89skYJ86n27TkByRCQlx9T+yNIcDgSW1JccSgpA7/wAQP+VfGdMQnG9rjksPdJmQXUpSGdrjqEbR45AV8QfKmhDb1QgWhUN+F1nHEpbddUpA3NhwL2jCN38IHKiB5dsaeJdJEG5rnQCI7pK9oSAQkKBBAH4GrFC0oy42t2S4+hLSpG5BKUFaW1NpGCoYHKzk89q16LJGGoJ0MvOuxora3v7tI6jgCQdo8M88nnsTzTQgyL3PkM9J5/c36siJjaP8JKgoD4gc96yu6iuLzb6HnGnA6VqJWyglJUAFbSRxnA7VZZunoDiB02n2mUobcKQgdZQ9V6hH4k/vjwr1B07a0PJTIZlOx3UtOhCyEOp3sPLxkDzQPDnj8KlwUq7OoJ7T0l3e0tUhYdcDjKFjeM4UARgHk1AblvNxpEdCgGnykuDA5KSSP+pq5WjTERSLfJdDu8vxy6y6pJSpt08cDtxjuec9hWp03aGbnbpJeJSUSEDKEgrKQ08spT7z0wB78VbEBu+zURmWMsLQzt2FbCFKwlW4DJGSM+H5dqlM6nmpZkB8NSX3QgdR5tK+EqUr2gQdxyrue2AK350zbZTEWQkSY8cRmiW1KQl1SnHXRuJPBwEAcAZ47VA+btuaabC3pLrwYMpRTgIWhMgtEDjIJAyD4eVS4GpGpLl1Frddbe3g70vMoWlWVleSCMZ3Emsfy/cTLRJVI3PJLhypCSFdT6YIxgg5PFWi42azsC7YiSA2wuWllId9pJbW0kZOPaHtHg+Hn3rQX2zMW6CzJQ6tSJagqKCRy1sBUVe8KUE/ilVXQg/K0oXNE9BaQ+kYGxpITjGMbcYII4PHOamtamniRHU4pAZaU3htltDY2oUpQAwnA+mvwPfnNWJ6yWRazHQxKYS6/AZQsLC1JU6ypROSB7OcEjzHGPCCNMW+Pb2n58x1Jwh1xTZSRsLuwgJ75AycnjII99NCFdNUvvuRfk5lMJqOhKUpAQTlLhcB4SkD2vIeHOainUlx6BaC2Up2lAwwgEJK95SDjIG7nFZ5dhRDvVttchxfrLziUSMYw3uc2px79uFf8QqevTtvRGflrM9thlDwLTgSlxSm1tJyOMAHqeRwR400NDHvExiVLfSppapRJeS60laFkq3ZKSMd+ay/OC4erOM9RvCwtO/oo3pSs5UlKsZAOTwOOT51ukaYhKKWlPSm3EqZaU6sJDbi3UEoKD5BWM+YyeK9R9NRlNmK44512ltmQUpBWFdB11Taff7ITz40uBpvnLcy4ta3W3N5WVJW0lSVbl7zkEY+kM+6sKr5NXGcYWplSFqWoEsI3I3/AEgk4ykHyGKtSdMW6UxFkD1mOx0GgW1FKXSpxx32lZ4OAjHAGeO1UmbHMaS42SVJSpQSvBAWASMjPhxTQ2Z1Ncy+p0uMlS1OKWCygpUVpSlZIxg5CRmvPzkufV3h1sDP0AyjZjZs27cYxt4xWnpSkbZvUE5p551v1ZDjoxuTHbBSNu32ePZ48qxwL1NgRDGjrb6RUtQ3tJUUlSdqiCRkZGBxWtpQbVu/3Ft5bqH0ha1NKVltJBLaShORjttJBHjnmo9zucm5Fj1npBLCOm2lttLaUp3FWMJA8VGoVKBSlKoVnRMktxywiQ8lgkkthZCSSMHjtyOKwVNt9rmXDd6oyVhPclQSPiSBUmYjzZY4ZZz04xcvDVwmtJcS1MkIS4gNrCXVDekDASeeQBxivMSbKh7/AFSS+xvxu6ThTux2zjvWy+bF2+7N/wDMN/1U+bF2+7N/8w3/AFVj149272Tn+CflLWImSkKCkSXkqACQQ4QQAcgfgCAR+FZ2brNagvQxIcVGdTsLalEpT7SVZA7A5SOamfNi7fdm/wDmG/6qfNi7fdm/+Yb/AKqdePc9k5/gn5ShKu1xVIQ+q4Sy+jOxwvK3JyMHBzkcAD8qwIlyG5frTch5Mndu6yVkLz57u+a2nzYu33Zv/mG/6qfNi7fdm/8AmG/6qdePc9k5/gn5SixLxOjzm5XrDjzqFbx1VqUCcYz3znHj3Fe7jfLhOnmW5IW27lJT0lFISUjCSOc5GTz35PnWf5sXb7s3/wAw3/VT5sXb7s3/AMw3/VTrx7nsnP8ABPylBN0uBbQ2Z0rYg7kp6ysJOc5AzxzzWBmS+xjovOt4WF+woj2hnB48Rk8++tr82Lt92b/5hv8AqodMXYD/ALsj+e3/AFU68e57Jz/BPylCF2uIkGQLhLD6klBcDytxSTkjOc4ySawetP7dvXd27C3jefo5zt/DPOPOvMhhyO8pp9BQ4nuk1jrJomJialLVcp6nQ6qbKLoBG8uqzggA858QAPwFfJ852aI6XAhDbDQabQgYCU5J/wAyST7zUWlVElU+YpLSVSpBDW3pguH2NuduOeMZOPLJr0i4Sgylhb7rkUL6hYW4otqOc8pzUSlBOeukl68C5OKSZIcS6OPZBTjAx5DAGPKvEq4zZSyqRKfcJR0/acJwjOdvftnwqJSgkOTpbrDLLsp9bLP+EhThKW/9keH5UE2UHS6JL/ULgdK+oclYzhWfPk8++o9KCam7XFMhT6Z8sPqSUlwPK3EE5IznOMkmorjzjqUJccWtLY2oClE7RknA8hkk/nXilApSlApSlApSlApSlAro+m0hNih7RjKCT+o1ziukad/8Dhf7B/8AUa5/E/te36C/18v4/wAw2NKVvLvDT6tYi00lsPRElxwJwCS6sblH8MfCuKIfUZZxjMRPvaOlXadpe3tTEx4y33ltSFNPALI3IShSircpsBJG3sN3B4zjmPcrFbYMeTJPrDrYjMvNoQ7jClrUk5UUAkezn6I/96vRLTHisJqr2qNKst4tECPFmeqiQl+I3HcUpxwKSvqJBIwEjGCoeJqfBtDF20zbIzDTTc8LU+p7ABU11Ni9x8duUq9wCqdM+Sz4nGMYy91/4tS6Vd77Atj7657EF4xEsRktxomG1ELC8LUdp5wgA8clXesR01AbnxoC3Xy6/Nej9beAlKG9p+jtJKjkjv38DToljHi8ZjcflWptK3Wo4EKF6ouA4tQdSoqSrcoAg4yFKQjOfw4IrS1Jim/DOM8eqFP12hIfiLA9opUCfcCMf9TVWq168+nC/Bf/ALVVK9Dh/ZD4v0n/ALrP+SlKVtcBSlKBSlKBSlKBSlKBSlKBSlKBSlKBSlKBXSNO/wDgcL/YP/qNc3qw2TUZgRRHfZLrafoFKsEDOcdue9aebCc8ah6forxPH4bmnLkmomKXipguc8Q/VBOliJjb0Q8rZjy25xVM+d8f7o7+sftT53x/ujv6x+1cvqeTs+hn0p4OfPL6T9lyVcpylMKVNlFTH+ES8rLf+zzx+VeH50uRu9YlSHd4AVvcUrdgkjOT5kn86qHzvj/dHf1j9qfO+P8AdHf1j9qep5OyR6T8FH/L6T9ltXJfXv3vuq3hIXlZO4DsD54wMUTJkISlKH3UhKVISAsjCVfSA9xyc+dVL53x/ujv6x+1PnfH+6O/rH7VPU8nZf1Twfl1fSfsuLFwmx3Q5HmSWnAgNhSHVJISP4cg9vdWIvvEIBdcwhRWn2j7KjjJHkeB8Kqfzvj/AHR39Y/anzvj/dHf1j9qvqeTsfqfg/Pq+k/ZbpcuTMd6syQ9Icxje6srOPLJrBVY+d8f7o7+sftT53sfdHf5g/ap6nk7LHpTwkRUZ/Sfswa8+nC/Bf8A7VVK2F6ubl0ldVaQhCRtQgHOB+Pia19d3HjOOMRL5TxvNjzc+XJj5SUpSs3KUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgUpSgVvLTpW8XaA1MgR2nI7skRG1KktIK3iMhASpQJJHbjmtHXUNA3+zWjSdsF3U06WdQJlKZCsuNIDJSHgkHnavBwcg47VJHP2bJdX3JDbFtmurjr6bwbYUrpqzjarA4PBrCxbpsiS5Hjw5DshskLabaUpSccHIAyKv7L0ZFo1xElXWFPkzpkV5p0SEtCUA44pSgVduFAkHtmtYqTFe0PKsjEyOi5ouhkOqU5tRKb2bQQ4cA7VZPJGd2RQVhiz3N959pi3TXHWMdVCGFEt57bgBx+dRn4shhTiX2HW1Nr6awtBG1X1TnseDxV5sMiM1adWRJd0YkypUCOy2pT4QFrS62diVK4O1KcZ7cceFerNd4dm0pqWM6YMwyJkY+qOOBzqtAObglXfKdyRvT4jIoKczZbo90+jbZrnUR1UbWFHejONw45GeM1iuFsn24pFwhSYpUSEh9pSMkYzjI8MirbqK6WmTJ0e3Z5DvqsOMlp0SMJU0fWXHClR7HAWOex78dhqvSLMZna71BKhvofivz3nWnEKylSVLJBH4jFBic0je0WxE/1MLirjeuAtvNrV0d20uFAUVBIPBJHHjWokQ5UZph2RGeaafTuaW42UhweaSe4/CutW692pqy21mbcYiIZ049Bl9NzMhLhcWtDaAOck7M54xnNVPU5j3LTelUx5sPMG2OIfSXk7kL6zqwnbnJJCk9h40VVG7fNciKlNw5Coye7yWlFA/4sYr5CgS5xWIUWRIKBlQZbK9o9+BXRn7xbpHpEsl+iXJiLZY7cYqZJwqOhtADjPT7qyUq7Ag7+T3rV3a42+9aTZg2hxiA63c5Eh2K6sNBxtzHTVuPsnYAU4zkZ47miKM42ttxTbiVIWk4KVDBB99b25aQvduYkOyoiAmM2288G5Dbim0OAFClJSokA7hzjxFYNWepfLjwtk16dHCG0+sPd1qCAFeA4ByAcdgKt+utWJauU2NafUX4s+FCZkyWyVuLS2y2FNZzgDejnAzx3xQUL5Om+p+t+pyfVftukrZ+rGKN26a7CXMbhyVxGzhb6WlFCew5VjA7j410oXu2f9qqNSC4sCwBIWWP4g108erdLv8A6nbb45rUR7la5mi1QLuiMkx2HnLfIjulL7LhcJDDiP40qODnHGe/GKCrPadvTDa3HrRcW20ZKlrjLAGO+TjwqLIt02PEalSIclqM7jpvLaUlC8jPCiMHirJdZ7Dvo3sMVEpCprU+W662F5WlK0t4JHfnaqpusrjbbrYG3pBjJvrK2WQ7CdJbmspbKQtbf8C0gJHhnceKCiUpSqFKUoFKUoFKUoFKUoFKUoFKUoFe0suKAKW1kHxCTXivQWoDAUoD8ag9dB77Jz9Jp0HvsnP0mvO9f11fGm9f11fGm109dB77Jz9Jp0HvsnP0mvO9f11fGm9f11fGmzT10HvsnP0mnQe+yc/Sa871/XV8ab1/XV8abNPXQe+yc/SadB77Jz9JrzvX9dXxpvX9dXxps09dB77Jz9Jp0HvsnP0mvO9f11fGm9f11fGmzT10HvsnP0mnQe+yc/Sa871/XV8ab1/XV8abNPXQe+yc/SadB77Jz9JrzvX9dXxpvX9dXxps09dB77Jz9Jp0HvsnP0mvO9f11fGm9f11fGmzT10HvsnP0mnQe+yc/Sa871/XV8ab1/XV8abNPXQe+yc/SadB77Jz9JrzvX9dXxpvX9dXxps09dB77Jz9Jp0HvsnP0mvO9f11fGm9f11fGmzT10HvsnP0mnQe+yc/Sa871/XV8ab1/XV8abNPXQe+yc/SadB77Jz9JrzvX9dXxpvX9dXxps09dB77Jz9Jp0HvsnP0mvO9f11fGm9f11fGmzTzSlKqFWRFniDSzFxWh1b7od59daaCdpwMNqG5f5Gq3WwTdnvk1uE4zHcab3dNS28qRuOTg1BPOl5CVpDkyEhCmFSkrKlEFoY9vhOcHJAGM5B4rL82F+plRkNBYcz1snpdHpdTf23dvDGfDGa8R9VTEuOrlIakZZWy2lSE7UJVt9nGPogJ4T4ZOKwfOW49Yr3M7SeW+knZjp9Pbtxjbt4xTash0vL9jZIir6zjbcfaVf35cGU7fZ4/PGMV4uum5lskwmX1IIlqKG17VpGQoAghSQfEeHjWGRf7g862supbLTiHWw2gJDZQMJ2gdgB4Vjm3eTLlMSFpYbWwdyA00EjOc5OO/NNjYv6VfaQ4oT4K9gcOElzJ6Zw5jKfDv7/DNa+52eRbcetKbBL7jASknKtmMqHH0Tng+PNfTfJqgoFacKDwPsj/AM36fx/yr7frsu6yY68LS1GYRHaStQUQlI7k4GSTk/nTY2s3SLqX7muK+n1SHIW0S4lZUEpWE5JCduec4zn3V7f0TN9ZuCYbzb7EZ91hC9ix1S2Mq/hITjIHtEAnsTWuk6nuUlp5DymVF3eCvpJ3ALXvUAfAbuaO6muDok9T1dXXWpxWWUnatQAUpPkTgZ9/NNiXH0msuMiZOYYQ7FckpVscIwlvfjO3B95STjB/A49M2Bi6tsOvzA2Fz2YhaAO4hYJ3A4IHbx8j7sx29ST222W2xGQ22FZQllIC9yNitwxzlPH/APNRrZeJdtRtilsDrNyBuQFbVoztI+JH502Jh046GkSFToSYSmwsSSV7MlRTtxt3ZylXhjjNY39OzWJAYdLQd2PrKdxOOlu3Dt47Tj8q8Q79Mix2o4DDsdtGwNPNJWnG8ryQfEEnn34r1847iW3g4tpxbpdy6ttJWOp9MA+AOT2psbKHpEmQ8iVOjYZ6jbyWlK3NOpaWsBWU4wCjBIz44rCNKr9V6nyhF6q3o7TIG7a4l0KIVkp4+ieDjsfdnNcdWqfidOJH6LzilLfeXsUXCptTZPspTyQtXJz/ANc6pN9mBlDKui42gNBKXGkqA6edvf8A2lD3g02aeZlnei3du3LcQXVlI3bHEgZ8wpIV/lWxe0jLjuqTJlRWEANELdDid3UKgngo3DlChyBWvdvkxy4xZoLSHYqQhlKGwEpSMnGPzPxr1Jv82Q0lpXRQ0nphKG2wkDYpSk/5rV+OabE1jTSkR5K58lpp5uM6+iOlR6h2Epz2xjck8ZzxUeFYjMtImiQzHbQFqdW8pRGAttIwEpJ7uDz/AC8fLmpLg5HdaWWFdRC2y4WU7whaipSQrGQMkn86iNXWU1bXIKFp9XWkpUNozgqQo8/ihNNjYvaXlx48l991nZHfLC0p3qyQQO4SQM7uNxGazTNKutPzEplRmyyH3UMrWorW20pSSQQnB5QR4HjsKhnUc8iUf7gOSSrqOBlO8g4yM47cCtgjVhNvlokRutOkIeb652AJDhJUB7O4DKlHG7ufypsZHdJN/Ksllu5MJiNLfRvIUpSFNoUsJUAnuQnuMjg+PFae6WR+3QIsp51paJKQpAQF9iM9ykJPvwTg8Gvrd/nokPPb2yp15TywpAIUpSVJVx5EKIx76xS7xKk25EFQYRHSpKyG2koKlJTtBJHfAJ+NNifH0tLfcZabkxOuot9RsqVuZCxlJV7OMduxOMjNa+ZAFveiLfcRJivoDqVx1FO9G4pIBUnIOUqHI+NS0amuKEshCmUrb2f3gZSFr2DakKOMnArVyJbshiK06QURkFtsAYwCpSv+qjQWiTphmZL6NlblNpbjsyHnJLheA6iEqCQltvP8R5we3hWqnafft6VidJisvpUoCOpR3rCVlBI429wrucnBrGxf5zTy3NzSwtlthaFtgpUlAATx5jaOfx868vX2Y9FUw6I6gSrCywjegKVuKUnHAzk4HmfOmxm1NZBaJT3QktyIwkux0lJO5JQRkKyBzhSeRxWlraqvLj5kGc0iQHFPPAEYCXXAAV/lgEDzrVUQpSlUKtunrIxL09JU820ZksrERSnQlSemN3spJyrefY4B7VUqzJlSELYUl91KmP8ACIWQW+c+z5cknjxqDdPWtl++wojSFIaciMOudMjPLKVrV7RAHieTWzVpWAiWlDkqR033IrbJQEqx1krOVHsQCnw71U0zJKZLchMh4SG8BDoWdycDAwe4wOKyO3Kc651HZslbm5K9ynVE7k52nOe4yceWTRVgTZIcezTHHeu7MEBMpKto6SdzqE8HOcgEjy5I8KwWvTzNxtTLrL6/WnHEpWDtCWgXAgEg8kc/SGcHj31pflGb6n6p65J9V5/ueqrZycn2c47818E+WmGYglPiIVbuiHDsz57e2aCyK07b0xpEwuzkxmA4FIW2lLilIW2k48MHqfkQe9ZlaSiLnFliW9sZdfaeLgQkqLaAv2cnAznHJ4xn3VV5NznyiTKmyniUdMlx1Sspznbye2QDj3V8TcJqXg6mXIDoWXQsOqyFngqznv76bFxj6dtbZabG991ctCAsrCkhCmt+1QScEg55B8qiR9N21xbDSpMwOuLisnCU7Qt9veD+CcHPn7qrfyrcOo6v1+XvdUFOK6ysrI7EnPJFYxNlJUFCS+FBSFAhw5BQMJP4gcDypsWVWlordviuvTVIedQy6op2rG1xQGAgHfkA57YOCPLMGfY22r7Bhxi8tiUElC9yFFQKiklJBAPY98Y7GtULjNEZEcTJPq7at6GuqralXfIGcA18fuEyRLTKflyHZKcbXVuKUsY7YJOeKbFiNiixdV6fjBRfhz1srUlRCjtLpQpOU8H6J5HnUmHYbasuyAJCopQsFt5IS4Cl5pJKSD2Ic/yI99VV+4zX5Tcl+ZIckt4KHVuqK04ORgk5HJJ/Gvr9znyFFT82S6ooDRK3VKOwEHbye2QDj3UG1atMWTqS4xm0vtwoxcUfbSFJSFBIypWABkjnk9uDW6l6XgNMtxCuR60ZUplEhCAUkIShSd/PA5PbzJ8KqCLlORMVLRMkplqzueDqgs575VnNevla49J1v5Ql9N3PUR1lYXnvkZ5zgUFiRpWO4emh+SHmi0l0qbAQsuNqWNh/LHPcHNRV2eHH0y5LfS+qWtlp1sg4Sjc46kgjxGECtKbnPLcdBmyiiOQplJdVhojxSM8flX165z3lOKemynFOI6ayp1RKk5ztPPIzzjzoN1a9OM3G1R3WX3PWnXEpWCAEtJU6GwSCckc53JyM8HzqdBtNoipemvMy5DAZkBDT4CFBbZQNxx3HtjHvB71VBPmCH6oJUgRN27ohw7M+e3OM16k3KdKcK5U2S8so6e5x1Sjt+rye3uoLX82bZNu0luO8/EiR1N9UrIXtStskKH/EAP8AiFY4mkGly1RJLzzb4CGycoCUvKRuKcE5OMpBAHnzVWXOluBQXKfUFNhoguE5QCCE/gCBgduKyN3W4treW3PloW8rc6pLygXD5qOeT+NKkWKNpmC4r2pD+G4jEh0b20ZU6lJASVEDAyeT7h76rNzjJh3GVGQ4HUsuqbDgGAoAkZ/OvrFxnR3w+xMktPBAbDiHVJUEgABOQc4wAMe6oy1KWtSlqKlKOSSckmiPlKUqhSlKBSlKBSlKBV007Fht2pElLMda1xJYfkLfwtpfTWEoCN2DkbT2JOTzxVLpUkX+42bT6Fx48cIHrCywxILmEqyj2HFf3h/j25OAMEgjIr5GtOnlxphAS70XHGVrS5yAhtOHE5cSBuXuPIUPAAVQaUpbX0wLbMUl1xEZ4K2IkuqkbDGbEdvC0gKGTnf3B5TjFe/kO1IkRUyokdmMr1Mpc9ZO54rQkuJUN3A5UcgDHHnXP6yPvOPub33FOLwE7lHJwAAB+QAH5UoW2NFsctmMH2GIaXGGnnHW3lkoJkhtQAUojGzKu2fHtxUq62+yQkynURGlONRlLSyp1QQo9ZtKSMOKUTtUvxAIGQKolKUWuGooMQ21Ee0xov8AdTJBU6HfbCOmhYBJVgj6QHH8PHJOfulUxpumpdpkvMMqmSQW3HVAdNaUFQV+B9pP/FVOpSh0S4pt12Ww9Fjx5a2o7TLEZ5/pAMhx1O4kKHtAJb8f4icVhjW6ysBmQ03GcYYmpBdkO5DzfX2jGF4+jyUlI4BOcHFUGlKLX56BCubsW2uhiK6UyC2pCztY2vFRzyeC2Fd/dWq08bdIm3pDpES3vpbSAVcobMlrOCeSQnJ/Kq3HkvR+p0HVt9RBbXtONyT3B91YqUOhKs9l+VG2kxElSml5R1MIB3pCV46248FWcKHgcEZqGxZrSqCj1gxmkolBt2SH8haOttPTO/6vOCjOBuz4VSaUotdJcG2RIj0iVAiNzEMrUIiZKlo4dbSlWQvOSlTnGewzSXaLWm23dUdtkLZccLTzj2RtG3ahOF/S5OMpOfMYql0pQu2nYtum2eIid03HWkPKbZJ+korbHICkk+zuOMjt44r25ZrOId1U2GylJfLCy7lbewZSkkObeSOMJVkHuKo1KULu5FsabzNZEKMY6Lk1Eb/0hzhpRc3Lzu5PCee1ekWewCzR1uOfSKOpJSoBSVF4JUD7eMBGeAjPY5xVGpSi1s1S2zFtMBpMSLHKJkhXRafLoUja0EqJ3EjOD4jtkYra3hdpuNzSZjcZDfrjEMLQ8vDLGwElI3YHPj2HlXPqUoXV6BbIsaQ/LgRG5aI5WIiZKloz1m0pVkLzkpUvjPYZrX6siW2Og/JrbbZamvxvYdK+o2kI2rOSeTlXIwKrVKUL1Jh2Iyn2G4cVCfWJDCXBIWSEoa3IWMqxndx5HyrVXi2Q0wobluQgvTx6y2kuY6LaEELTyfFYXjPOEDHeq1WWRJekqSqQ6twpSEJKjnCR2A91KGV+BIYZLriUBA2dnEk+0ncOAc9vh2NRaUqoUpSgVnbjgthx51LSVfRyCSr3jHhWCpM3sx/uh/71GUdzosfeh+g06LH3ofoNRqydF3p9Tpr6f1tpx8aF/wBmXosfeh+g06LH3ofoNRqULjsk9Fj70P0GnRY+9D9BqOUqBAIOT2GKEEAEggHsaFx2SOix96H6DTosfeh+g1Gr2GXFNlwNrKB3UEnHxoX/AGZuix96H6DTosfeh+g1HIIxkEZGRmvlC47JPRY+9D9BoYyVJV0HkuKAzt2kHHjio1TLPzdoY8C8gH4ii41M1SHSlKrApSlApSlApSlApSlApSlApSlApSlApSlAqTN/8j/dJqNUmZ2jnwLQ/wDeoyjylGq7xZbItUJtMl5T4troTG3ANOEqcyDz3AJOMc4FUilJi2XHydC6zbfbdkZpltgNLeaSzIWUpCkn6W4heVA+PAwfKskm3w0racZixVTlR3CiOvahKlhxIGUhZGdhUcZ5wKo1KnS2eux+FbZkhtjW1qdV6uhDYihYBCm0YQkEZ54HPwrM8tlxuLDmx425aZRWexbI3FO3BwOQPxqmUp0p67z15rXdYtvasG9hhCgWmi2+NoV1DjeCd+T/ABDG3j/rsNNrxaLWQp5KEuPBxYkJS0gEjlxB+kPdkVRKU6dEc1ZdUQuKGm347KmGY0ua3FYShp5Q27Tu3nGRkj2fwBJqXa7db13JlqHFiS4y5i231OOZLacjaE89u+DzmqHU2HdJcJktxnEoSSVA9NJUkkYJCiMj8jU6Vx5sb/qhCqZZ/wDxaF/vkf8AqFQ6mWfi6wyewdST+GaynyacP3Qh0pSqxKUpQKUpQKUpQKUpQKUpQKUpQKUpQKUpQKkNSdqAh1pt5CfoheePwIINR6VFia8kv1pj7hH/AFOf1U9aY+4R/wBTn9VRKUpeufyIS/WmPuEf9Tn9VPWmPuEf9Tn9VRKUo65/IhL9aY+4R/1Of1U9aY+4R/1Of1VEpSjrn8iEv1pj7hH/AFOf1U9aY+4R/wBTn9VRKUo65/IhL9aY+4R/1Of1U9aY+4R/1Of1VEpSjrn8iEv1pj7hH/U5/VXlcoYIZjtMkggqQVE4/Mmo1KUdclKUqsSlKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClKUClK2dlsk68t3Bdva6vqMZUt5I79NKgCR+G7P4A0GspStpc7FPtrFrclsKT8pMesR0AZUpBUUg49+3I9xFBq6Vs7jYLxbI6JFytNwhsLOEuSIy20qPkCQBWFdquDduRcFwJaYCzhMksqDSj5BWMGghUrPBj+tzGY4dbaLqwgLcztST54BOPyq/3H0RXy3XyLZplxsrV0lJCmI6pKgpwEkDBKcZyDxmoOc0rZ32xXOw3p203WI4xPaUElojJOe2MdwfDFS/mbqcYzpy8jPbMF3+mg0NKySWHYshxiQ2tp5tRQtCxhSVDuCPOtizpy+PRkyWbNcnI6hkOoirKCPxxiqNVSpcC2T7jLMW3wpUqSASWWGlLXgd/ZAzU+TpTUMVh1+VYrqwy0krccdiOISkDuSSMCg0tKyFh4RhILS+gVlsObTtKgASM9s4I499SbXabjdnVt2qBLmuIG5SYzKnSkeZCQaCFSttG03fJSpCI1nuLy4ywh5DcZalNKOcBQAyDwe9SPmdqcFIOnLyCrtmC7z/+GoNDSvTiFNuKQ4kpWklKknuCPCvNUKUpQKUpQKUpQKUpQKUpQKUpQK7F/Z6u9v0wu93u8IzDUqNblKPZIeUoknzACAT7q47VjavcNnQUmxobf9ckTW5a3SBs2oQpIT3z/ETmpI6HrL0XMWH0hvvSApOjktquSnk9g0DyyD9YqKUj3KB862n9phDE+x6GvcNlLLEmGUpQkcISUtrSkfhlVc91F6RbpfNA2fTMpSulBWeo7u5eSAA2D/s+1/l5Vs9aekC3aj9HNg06IctqZaUoCZCikpcwjaRjOR4fCptVu9Hrg9KXozmaKnOD5atKRJtshz6gONpPkM7fwI8q5Zra7MSn4tptaybNakFiN4dVWcuPEea1ZPuGB4Vu/Q1rmHoG+TblMiSJZfjGOltpSU4ypKiST/s1Q5RbVJdUwVloqJTvABx78VaHu3f+IRf96n/qK/VHpB043qL096dSuciOuDCbmhrHtv8ATeUrag9s8Due2T4V+V7c40zPjuyd/RQ4lS+mBuwDnjNdL9IPpTF91zZtUWGPIgzLc2Gwh4hSVYUo+HgQogjyqSQ1fpz1E5qT0iTn3IL0H1VKYgZfADg2ZyVY4yST28MV0708W+RcrhoViPcY8DqQwkuvSA1gnZz3yfyrmnpR1nZddS4t0RapFtvASG5SkLS428B4+ByPPywPCtp6Q9e6b1ubP65CvEYW5joJ6S2zvHHPPbtQSv7O9qi6o9J0qXfEolORmFzAhwZDju9I3EeONxP44qiar1ReLpqudcn58pEj1hRb2uqT0gFeylODwBx2qTa9ZO6c1uL7pVn1RloBpqO8d+5oJCSleMZJxkkePNZ75eNIXm7v3Ry0XaG7IUXXYseU2WisnJ2qUjKQT7jiqN/6JLnMvPp0slxuIxLkqKnFYxvPQUN354z+defSdGms611vPaujDbbTq0qjCQFLcS4oII2A9huzz24rT6X1vHtvpIhaml2/ZHiJCGocU4ASlrpoTlXkMZPifxrNfNS6Vumqblf3YF2ckyVrfbjrW2GkukezuxyUg4OPHFT3i7+hpNq/7GtZu3+B6/b2JCXFsg4UPZA3IPgoZyDWy9CWkRafSTDvNjlfKWmpcZ5LMtIwppWAek6n+FY+B7iucaP1zAsno61FpuTElOvXY5D7ZTtb4AHB79q0/o81zdtDXgTLU5uYWQJEVZ/u3k+R8j5HwpQ1+pJkhF9vMdDziWVTnVqQFEAqC1AE113+0m+6wxoVxl1ba02/cFJUQQcI5ril0lInXiXL2qbbkPrd29ykKUTj3nmrx6WdeQdbR7EiFDkxVWxgxz1SkhwYTzx2+jVHPnnFvOrdcUVLWoqUT4k968UpVQpSlApSlApSlApSlApSlApSlAqxaW0ZftVtyV2CCmWI2C8BIbQUA5wSFKBxweartd4/ssfT1j/8ij/66k6HKblorUFvtJuj9vK7ck7VSYzrb7aT/rKbUoDv41XgCewNdy9HV3s+ivRRqU3a7wJkm8NFEe2sOdRQJQpPtgfRzu5z2CfPipXojlTGfQJrVcN95uQ08egpCylSCUo+ifDk1LVwIjHeld19LCkM+h/TUbVZQvWxXvyvBkJZyvHUPfG3aOfH8DWLUkRn0d+h7TsmyoQ3fb7h1+4hILqEbd2xCv4fpJHGOxq2OHkY719AJ7Cu3ehV3/tEVedMauKrihUUyIst47n4ywoJ9lZ5x7QOM4499Tv7MweiTdaxeqopZi9gTjckqG4e+ljgYBPYV92L2lW1W0dzjgV3H+yq+8vVV/CnXFBcArUCo8q3jk+/k81z/UE/VCtOui9znpdukydjYekh5SXEc5HJKeDjwzn3UsUyhBHeu5ajjtejv0O6ckWJCG75fcOv3EJBdQjbuKEK7p+kkceR865i7q+7TrJPtt1fcuLT4SpDkk9RxhSVA7kqOSAQCCM45pYry2nG1FLiFJUO4UMGvmxW0q2naO5xXd/7N+o7vevSU83crjKfYEBwpYW6otowpAASnOBgcCuX6k1Fc5dyuFvuVwlyrd68XCy66pYG1SgNuTxwSKWKvg+Rr5X6a1VZL3eojGovRNfUv2ZthLZs8dfTS2AnCk7OASechWFc8Z4r8zLSpC1JWClSTggjBBpE2j5SlKoUpSgUpSgUpSgUpSgUpSgUpSgUpSgV1P0Ia3suik35V6MsqnsJZbTHZC8Y3ZJyoeYrllKk7HpwJC1BCtyQeFYxkV07ROtbNZ/RRqbTk1Ur5QuilKaLbQU2n2Ugbjuz/D5Vy+lB1e769smrPRnDs2p2pTeoLYnbDnMthaVpAwAvkEZHB78gH3Vrm9cQL36PY2lNVNyUm3q32+4RkhamxyNi0EjKcHGQfLyrnNKUOlaR1padA2q6L04JU6/z2+gmZIZS03Gb/wBVO5RUrODzgcD87P8A2c5CLba9cXm4udKC3CCFPOHAUs7jgHxPu94864dUhU2UqGiIqS8YiFFaWS4diSe5Ce2aUOh+g3Wdo0TebnMvXrRRIi+roTHaCzkqByckccVWXkacj2y4qZuM+ZNcAEZpUQNNpUVcqUd5yQnOOO5qtUpQ6Sxrm23z0fRdKaualINvVvgXCKlLimxgjYtBIyMHHB8B5VXvWbBarVPat7ku5T5jXQDj7AYbjp3BRIAUoqUduPADJ71V6UodD9B+rrXorVz11vPrJYMVbKUsNhaiVFJ8SOOKp82VFXqV6YEqfhqll7aobStBXnBHhkcVrKUodP0rqrT+jtWrvtgn3kxjvV8lqYSgLyDtbWsLIKQSOdueO1c5ukxy43KXNeCQ7JeW8sJGACpRJx7uajUoFKUqhSlKBSlKBSlKBSlKBSlKBSlKBSlKBW9t7aFQ2yUJJx3I99KVhn5MsfNI6Tf2aPgKdJv7NHwFKVqZnSb+zR8BTpN/Zo+ApSgdJv7NHwFOk39mj4ClKB0m/s0fAU6Tf2aPgKUoHSb+zR8BTpN/Zo+ApSgdJv7NHwFOk39mj4ClKB0m/s0fAU6Tf2aPgKUoHSb+zR8BTpN/Zo+ApSgdJv7NHwFOk39mj4ClKB0m/s0fAU6Tf2aPgKUoHSb+zR8BTpN/Zo+ApSgdJv7NHwFOk39mj4ClKB0m/s0fAU6Tf2aPgKUoHSb+zR8BTpN/Zo+ApSgravpH8a+UpXQ1P//Z" + }, + { + "timing": 1500, + "timestamp": 4495002989, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 1875, + "timestamp": 4495377989, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 2250, + "timestamp": 4495752989, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 2625, + "timestamp": 4496127989, + "data": "data:image/jpeg;base64,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" + }, + { + "timing": 3000, + "timestamp": 4496502989, + "data": "data:image/jpeg;base64,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" + } + ] + } + }, + "final-screenshot": { + "id": "final-screenshot", + "title": "Final Screenshot", + "description": "The last screenshot captured of the pageload.", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "screenshot", + "timing": 884, + "timestamp": 4494386884, + "data": "data:image/jpeg;base64,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" + } + }, + "total-blocking-time": { + "id": "total-blocking-time", + "title": "Total Blocking Time", + "description": "Sum of all time periods between FCP and Time to Interactive, when task length exceeded 50ms, expressed in milliseconds. [Learn more about the Total Blocking Time metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-total-blocking-time/).", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 45, + "numericUnit": "millisecond", + "displayValue": "50 ms", + "scoringOptions": { + "p10": 200, + "median": 600 + } + }, + "max-potential-fid": { + "id": "max-potential-fid", + "title": "Max Potential First Input Delay", + "description": "The maximum potential First Input Delay that your users could experience is the duration of the longest task. [Learn more about the Maximum Potential First Input Delay metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-max-potential-fid/).", + "score": 0.97, + "scoreDisplayMode": "numeric", + "numericValue": 95, + "numericUnit": "millisecond", + "displayValue": "100 ms" + }, + "cumulative-layout-shift": { + "id": "cumulative-layout-shift", + "title": "Cumulative Layout Shift", + "description": "Cumulative Layout Shift measures the movement of visible elements within the viewport. [Learn more about the Cumulative Layout Shift metric](https://web.dev/articles/cls).", + "score": 1, + "scoreDisplayMode": "numeric", + "numericValue": 0, + "numericUnit": "unitless", + "displayValue": "0", + "scoringOptions": { + "p10": 0.1, + "median": 0.25 + }, + "details": { + "type": "debugdata", + "items": [ + { + "cumulativeLayoutShiftMainFrame": 0, + "newEngineResult": { + "cumulativeLayoutShift": 0, + "cumulativeLayoutShiftMainFrame": 0 + }, + "newEngineResultDiffered": false + } + ] + } + }, + "errors-in-console": { + "id": "errors-in-console", + "title": "No browser errors logged to the console", + "description": "Errors logged to the console indicate unresolved problems. They can come from network request failures and other browser concerns. [Learn more about this errors in console diagnostic audit](https://developer.chrome.com/docs/lighthouse/best-practices/errors-in-console/)", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "sourceLocation", + "valueType": "source-location", + "label": "Source" + }, + { + "key": "description", + "valueType": "code", + "label": "Description" + } + ], + "items": [] + } + }, + "server-response-time": { + "id": "server-response-time", + "title": "Initial server response time was short", + "description": "Keep the server response time for the main document short because all other requests depend on it. [Learn more about the Time to First Byte metric](https://developer.chrome.com/docs/lighthouse/performance/time-to-first-byte/).", + "score": 1, + "scoreDisplayMode": "metricSavings", + "numericValue": 6, + "numericUnit": "millisecond", + "displayValue": "Root document took 10 ms", + "metricSavings": { + "FCP": 0, + "LCP": 0 + }, + "details": { + "type": "opportunity", + "headings": [ + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "responseTime", + "valueType": "timespanMs", + "label": "Time Spent" + } + ], + "items": [ + { + "url": "http://127.0.0.1:3053/", + "responseTime": 6 + } + ], + "overallSavingsMs": 0 + }, + "guidanceLevel": 1 + }, + "interactive": { + "id": "interactive", + "title": "Time to Interactive", + "description": "Time to Interactive is the amount of time it takes for the page to become fully interactive. [Learn more about the Time to Interactive metric](https://developer.chrome.com/docs/lighthouse/performance/interactive/).", + "score": 0.92, + "scoreDisplayMode": "numeric", + "numericValue": 3483.1565600000004, + "numericUnit": "millisecond", + "displayValue": "3.5 s" + }, + "user-timings": { + "id": "user-timings", + "title": "User Timing marks and measures", + "description": "Consider instrumenting your app with the User Timing API to measure your app's real-world performance during key user experiences. [Learn more about User Timing marks](https://developer.chrome.com/docs/lighthouse/performance/user-timings/).", + "score": null, + "scoreDisplayMode": "notApplicable", + "details": { + "type": "table", + "headings": [ + { + "key": "name", + "valueType": "text", + "label": "Name" + }, + { + "key": "timingType", + "valueType": "text", + "label": "Type" + }, + { + "key": "startTime", + "valueType": "ms", + "granularity": 0.01, + "label": "Start Time" + }, + { + "key": "duration", + "valueType": "ms", + "granularity": 0.01, + "label": "Duration" + } + ], + "items": [] + }, + "guidanceLevel": 2 + }, + "redirects": { + "id": "redirects", + "title": "Avoid multiple page redirects", + "description": "Redirects introduce additional delays before the page can be loaded. [Learn how to avoid page redirects](https://developer.chrome.com/docs/lighthouse/performance/redirects/).", + "score": 1, + "scoreDisplayMode": "metricSavings", + "numericValue": 0, + "numericUnit": "millisecond", + "displayValue": "", + "metricSavings": { + "LCP": 0, + "FCP": 0 + }, + "details": { + "type": "opportunity", + "headings": [], + "items": [], + "overallSavingsMs": 0 + }, + "guidanceLevel": 2 + }, + "image-aspect-ratio": { + "id": "image-aspect-ratio", + "title": "Displays images with correct aspect ratio", + "description": "Image display dimensions should match natural aspect ratio. [Learn more about image aspect ratio](https://developer.chrome.com/docs/lighthouse/best-practices/image-aspect-ratio/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "label": "" + }, + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "displayedAspectRatio", + "valueType": "text", + "label": "Aspect Ratio (Displayed)" + }, + { + "key": "actualAspectRatio", + "valueType": "text", + "label": "Aspect Ratio (Actual)" + } + ], + "items": [] + } + }, + "image-size-responsive": { + "id": "image-size-responsive", + "title": "Serves images with appropriate resolution", + "description": "Image natural dimensions should be proportional to the display size and the pixel ratio to maximize image clarity. [Learn how to provide responsive images](https://web.dev/articles/serve-responsive-images).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "label": "" + }, + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "displayedSize", + "valueType": "text", + "label": "Displayed size" + }, + { + "key": "actualSize", + "valueType": "text", + "label": "Actual size" + }, + { + "key": "expectedSize", + "valueType": "text", + "label": "Expected size" + } + ], + "items": [] + } + }, + "deprecations": { + "id": "deprecations", + "title": "Avoids deprecated APIs", + "description": "Deprecated APIs will eventually be removed from the browser. [Learn more about deprecated APIs](https://developer.chrome.com/docs/lighthouse/best-practices/deprecations/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "value", + "valueType": "text", + "label": "Deprecation / Warning" + }, + { + "key": "source", + "valueType": "source-location", + "label": "Source" + } + ], + "items": [] + } + }, + "third-party-cookies": { + "id": "third-party-cookies", + "title": "Avoids third-party cookies", + "description": "Third-party cookies may be blocked in some contexts. [Learn more about preparing for third-party cookie restrictions](https://privacysandbox.google.com/cookies/prepare/overview).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "name", + "valueType": "text", + "label": "Name" + }, + { + "key": "url", + "valueType": "url", + "label": "URL" + } + ], + "items": [] + } + }, + "mainthread-work-breakdown": { + "id": "mainthread-work-breakdown", + "title": "Minimizes main-thread work", + "description": "Consider reducing the time spent parsing, compiling and executing JS. You may find delivering smaller JS payloads helps with this. [Learn how to minimize main-thread work](https://developer.chrome.com/docs/lighthouse/performance/mainthread-work-breakdown/)", + "score": 1, + "scoreDisplayMode": "metricSavings", + "numericValue": 892.0080000000021, + "numericUnit": "millisecond", + "displayValue": "0.9 s", + "metricSavings": { + "TBT": 50 + }, + "details": { + "type": "table", + "headings": [ + { + "key": "groupLabel", + "valueType": "text", + "label": "Category" + }, + { + "key": "duration", + "valueType": "ms", + "granularity": 1, + "label": "Time Spent" + } + ], + "items": [ + { + "group": "scriptEvaluation", + "groupLabel": "Script Evaluation", + "duration": 353.75600000000105 + }, + { + "group": "other", + "groupLabel": "Other", + "duration": 258.40000000000117 + }, + { + "group": "styleLayout", + "groupLabel": "Style & Layout", + "duration": 165.26400000000004 + }, + { + "group": "paintCompositeRender", + "groupLabel": "Rendering", + "duration": 57.343999999999966 + }, + { + "group": "scriptParseCompile", + "groupLabel": "Script Parsing & Compilation", + "duration": 41.53599999999997 + }, + { + "group": "parseHTML", + "groupLabel": "Parse HTML & CSS", + "duration": 15.708 + } + ], + "sortedBy": [ + "duration" + ] + }, + "guidanceLevel": 1 + }, + "bootup-time": { + "id": "bootup-time", + "title": "JavaScript execution time", + "description": "Consider reducing the time spent parsing, compiling, and executing JS. You may find delivering smaller JS payloads helps with this. [Learn how to reduce Javascript execution time](https://developer.chrome.com/docs/lighthouse/performance/bootup-time/).", + "score": 1, + "scoreDisplayMode": "metricSavings", + "numericValue": 351.76399999999944, + "numericUnit": "millisecond", + "displayValue": "0.4 s", + "metricSavings": { + "TBT": 100 + }, + "details": { + "type": "table", + "headings": [ + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "total", + "granularity": 1, + "valueType": "ms", + "label": "Total CPU Time" + }, + { + "key": "scripting", + "granularity": 1, + "valueType": "ms", + "label": "Script Evaluation" + }, + { + "key": "scriptParseCompile", + "granularity": 1, + "valueType": "ms", + "label": "Script Parse" + } + ], + "items": [ + { + "url": "http://127.0.0.1:3053/", + "total": 299.9719999999998, + "scripting": 19.747999999999887, + "scriptParseCompile": 15.315999999999967 + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/629-681bce70bd5a239a.js", + "total": 207.78399999999945, + "scripting": 194.90799999999945, + "scriptParseCompile": 10.344 + }, + { + "url": "Unattributable", + "total": 190.940000000001, + "scripting": 7.399999999999999, + "scriptParseCompile": 0 + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/9e8df49e-9e9decc4e6f725ac.js", + "total": 140.57200000000014, + "scripting": 96.74000000000017, + "scriptParseCompile": 7.308000000000001 + } + ], + "summary": { + "wastedMs": 351.76399999999944 + }, + "sortedBy": [ + "total" + ] + }, + "guidanceLevel": 1 + }, + "diagnostics": { + "id": "diagnostics", + "title": "Diagnostics", + "description": "Collection of useful page vitals.", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "debugdata", + "items": [ + { + "numRequests": 42, + "numScripts": 15, + "numStylesheets": 1, + "numFonts": 3, + "numTasks": 1213, + "numTasksOver10ms": 3, + "numTasksOver25ms": 1, + "numTasksOver50ms": 0, + "numTasksOver100ms": 0, + "numTasksOver500ms": 0, + "rtt": 0.054299999999999994, + "throughput": 37798535.749499284, + "maxRtt": 0.054299999999999994, + "maxServerLatency": 2.4872, + "totalByteWeight": 382696, + "totalTaskTime": 223.00199999999876, + "mainDocumentTransferSize": 24098 + } + ] + } + }, + "network-requests": { + "id": "network-requests", + "title": "Network Requests", + "description": "Lists the network requests that were made during page load.", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "protocol", + "valueType": "text", + "label": "Protocol" + }, + { + "key": "networkRequestTime", + "valueType": "ms", + "granularity": 1, + "label": "Network Request Time" + }, + { + "key": "networkEndTime", + "valueType": "ms", + "granularity": 1, + "label": "Network End Time" + }, + { + "key": "transferSize", + "valueType": "bytes", + "displayUnit": "kb", + "granularity": 1, + "label": "Transfer Size" + }, + { + "key": "resourceSize", + "valueType": "bytes", + "displayUnit": "kb", + "granularity": 1, + "label": "Resource Size" + }, + { + "key": "statusCode", + "valueType": "text", + "label": "Status Code" + }, + { + "key": "mimeType", + "valueType": "text", + "label": "MIME Type" + }, + { + "key": "resourceType", + "valueType": "text", + "label": "Resource Type" + } + ], + "items": [ + { + "url": "http://127.0.0.1:3053/", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 0, + "networkRequestTime": 0.8339999997988343, + "networkEndTime": 9.494000000879169, + "finished": true, + "transferSize": 24098, + "resourceSize": 268747, + "statusCode": 200, + "mimeType": "text/html", + "resourceType": "Document", + "priority": "VeryHigh", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/media/a273567b21a7c318-s.p.woff2", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 15.839000000618398, + "networkRequestTime": 16.191999999806285, + "networkEndTime": 21.950000000186265, + "finished": true, + "transferSize": 26585, + "resourceSize": 25888, + "statusCode": 200, + "mimeType": "font/woff2", + "resourceType": "Font", + "priority": "High", + "isLinkPreload": true, + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/media/c679f70df756412c-s.p.woff2", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.00499999988824, + "networkRequestTime": 16.3410000000149, + "networkEndTime": 21.470999999903142, + "finished": true, + "transferSize": 44869, + "resourceSize": 44172, + "statusCode": 200, + "mimeType": "font/woff2", + "resourceType": "Font", + "priority": "High", + "isLinkPreload": true, + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/media/e4af272ccee01ff0-s.p.woff2", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.048000000417233, + "networkRequestTime": 16.53899999987334, + "networkEndTime": 21.57200000062585, + "finished": true, + "transferSize": 49129, + "resourceSize": 48432, + "statusCode": 200, + "mimeType": "font/woff2", + "resourceType": "Font", + "priority": "High", + "isLinkPreload": true, + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/css/13fc8cee6012ff0d.css", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.10300000011921, + "networkRequestTime": 16.67200000025332, + "networkEndTime": 21.618000000715256, + "finished": true, + "transferSize": 10314, + "resourceSize": 60191, + "statusCode": 200, + "mimeType": "text/css", + "resourceType": "Stylesheet", + "priority": "VeryHigh", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/webpack-4c9c27e0f0fab02a.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.16899999976158, + "networkRequestTime": 18.38399999961257, + "networkEndTime": 27.634999999776483, + "finished": true, + "transferSize": 2486, + "resourceSize": 3403, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "isLinkPreload": true, + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/9e8df49e-9e9decc4e6f725ac.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.21500000078231, + "networkRequestTime": 18.561000000685453, + "networkEndTime": 31.998000000603497, + "finished": true, + "transferSize": 55198, + "resourceSize": 173019, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/629-681bce70bd5a239a.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.248000000603497, + "networkRequestTime": 21.757000000216067, + "networkEndTime": 28.815000000409782, + "finished": true, + "transferSize": 47564, + "resourceSize": 173492, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/main-app-596ed5bc004070d9.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.28099999949336, + "networkRequestTime": 21.83999999985099, + "networkEndTime": 27.509000000543892, + "finished": true, + "transferSize": 1257, + "resourceSize": 513, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/263-d5483a7511b16a3b.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.32300000078976, + "networkRequestTime": 21.884999999776483, + "networkEndTime": 28.606000000610948, + "finished": true, + "transferSize": 4157, + "resourceSize": 8529, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/168-4d0a50e937ae6a21.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.35300000011921, + "networkRequestTime": 22.134999999776483, + "networkEndTime": 28.75, + "finished": true, + "transferSize": 5970, + "resourceSize": 13553, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/860-b2f411e4b7aa4e3a.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.382999999448657, + "networkRequestTime": 28.071000000461936, + "networkEndTime": 32.56400000024587, + "finished": true, + "transferSize": 8262, + "resourceSize": 21582, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/app/layout-d744eb9953200e54.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.412999999709427, + "networkRequestTime": 28.17600000090897, + "networkEndTime": 33.09599999990314, + "finished": true, + "transferSize": 3170, + "resourceSize": 6296, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/app/error-a7dbc9387ba76d02.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.441999999806285, + "networkRequestTime": 28.89699999988079, + "networkEndTime": 31.848999999463558, + "finished": true, + "transferSize": 1738, + "resourceSize": 994, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/518-6c10c56cbdd02efe.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.47800000011921, + "networkRequestTime": 28.958999999798834, + "networkEndTime": 33.33600000012666, + "finished": true, + "transferSize": 17697, + "resourceSize": 47867, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/app/page-4392e7b55a1591e0.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.50399999972433, + "networkRequestTime": 28.997000000439584, + "networkEndTime": 31.93900000024587, + "finished": true, + "transferSize": 1298, + "resourceSize": 1513, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/app/global-error-b7c568106e941147.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 16.537000000476837, + "networkRequestTime": 32.061999999918044, + "networkEndTime": 34.4660000000149, + "finished": true, + "transferSize": 1646, + "resourceSize": 902, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/image?url=%2Fimg%2Flogo.png&w=1080&q=75", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 75.68900000024587, + "networkRequestTime": 75.93699999991804, + "networkEndTime": 145.2170000001788, + "finished": true, + "transferSize": 16083, + "resourceSize": 15268, + "statusCode": 200, + "mimeType": "image/webp", + "resourceType": "Image", + "priority": "High", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/react.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 75.78700000047684, + "networkRequestTime": 76.08999999985099, + "networkEndTime": 118.47800000011921, + "finished": true, + "transferSize": 3164, + "resourceSize": 5247, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/bootstrapcss.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 75.83200000040233, + "networkRequestTime": 76.18400000035763, + "networkEndTime": 82.85599999967963, + "finished": true, + "transferSize": 1233, + "resourceSize": 531, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/aws-amplify.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 75.86899999994785, + "networkRequestTime": 76.2609999999404, + "networkEndTime": 83.15600000042468, + "finished": true, + "transferSize": 1176, + "resourceSize": 474, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/lambda.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 75.90200000070035, + "networkRequestTime": 76.34200000017881, + "networkEndTime": 119.26999999955297, + "finished": true, + "transferSize": 1363, + "resourceSize": 1035, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/rds.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 75.93699999991804, + "networkRequestTime": 76.41600000020117, + "networkEndTime": 83.32599999941885, + "finished": true, + "transferSize": 1121, + "resourceSize": 419, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/aws.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 75.97200000006706, + "networkRequestTime": 83.50600000005215, + "networkEndTime": 124.25600000005215, + "finished": true, + "transferSize": 3260, + "resourceSize": 5687, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/figma.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 76.00200000032783, + "networkRequestTime": 83.68599999975413, + "networkEndTime": 124.12399999983609, + "finished": true, + "transferSize": 1358, + "resourceSize": 1450, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/arrow-right.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 76.0339999999851, + "networkRequestTime": 83.76699999999255, + "networkEndTime": 123.91500000003725, + "finished": true, + "transferSize": 951, + "resourceSize": 250, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/python.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 76.07299999985844, + "networkRequestTime": 119.43800000008196, + "networkEndTime": 127.62999999988824, + "finished": true, + "transferSize": 1519, + "resourceSize": 2059, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/keras.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 76.10499999951571, + "networkRequestTime": 119.58200000040233, + "networkEndTime": 127.78800000064075, + "finished": true, + "transferSize": 1531, + "resourceSize": 829, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/tensorflow.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 76.13700000010431, + "networkRequestTime": 124.37100000027567, + "networkEndTime": 134.5770000005141, + "finished": true, + "transferSize": 1365, + "resourceSize": 663, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/unity.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 76.16500000003725, + "networkRequestTime": 127.2260000007227, + "networkEndTime": 134.75600000005215, + "finished": true, + "transferSize": 1097, + "resourceSize": 395, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/opencv.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 76.19599999953061, + "networkRequestTime": 127.3640000000596, + "networkEndTime": 134.9990000007674, + "finished": true, + "transferSize": 1473, + "resourceSize": 1414, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/nextjs.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 76.24199999962002, + "networkRequestTime": 128.06400000024587, + "networkEndTime": 134.8629999998957, + "finished": true, + "transferSize": 1638, + "resourceSize": 936, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/metamask.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 76.27699999976903, + "networkRequestTime": 128.1579999998212, + "networkEndTime": 135.0800000000745, + "finished": true, + "transferSize": 2025, + "resourceSize": 3239, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/openzeppelin.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 76.3089999994263, + "networkRequestTime": 135.15600000042468, + "networkEndTime": 139.37899999972433, + "finished": true, + "transferSize": 1077, + "resourceSize": 375, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/pinata.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 76.33899999968708, + "networkRequestTime": 135.2960000000894, + "networkEndTime": 139.57600000035018, + "finished": true, + "transferSize": 2643, + "resourceSize": 4486, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/icon/article.svg", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 76.37899999972433, + "networkRequestTime": 135.34399999957532, + "networkEndTime": 139.48400000017136, + "finished": true, + "transferSize": 1027, + "resourceSize": 325, + "statusCode": 200, + "mimeType": "image/svg+xml", + "resourceType": "Image", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/favicon.ico", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 158.62199999950826, + "networkRequestTime": 158.9320000000298, + "networkEndTime": 170.7719999998808, + "finished": true, + "transferSize": 16134, + "resourceSize": 15406, + "statusCode": 200, + "mimeType": "image/x-icon", + "resourceType": "Other", + "priority": "High", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/contact?_rsc=1p-R_iEY6bj0jY31", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 161.21300000045449, + "networkRequestTime": 161.5090000005439, + "networkEndTime": 168.88999999966472, + "finished": true, + "transferSize": 4065, + "resourceSize": 12011, + "statusCode": 200, + "mimeType": "text/x-component", + "resourceType": "Fetch", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/app/contact/page-ac1a6d29565f2e9a.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 198.70600000023842, + "networkRequestTime": 199.08100000023842, + "networkEndTime": 201.7050000000745, + "finished": true, + "transferSize": 3367, + "resourceSize": 7501, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/projects/entry/2021-paymenow-leveraging-tech-to-secure-payments-for-ebay-sellers?_rsc=1p-R_iEY6bj0jY31", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 200.53700000047684, + "networkRequestTime": 201.00200000032783, + "networkEndTime": 203.52700000070035, + "finished": true, + "transferSize": 5627, + "resourceSize": 19121, + "statusCode": 200, + "mimeType": "text/x-component", + "resourceType": "Fetch", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/app/projects/entry/%5Bslug%5D/page-e1602320c59e72d4.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 204.2250000005588, + "networkRequestTime": 204.5789999999106, + "networkEndTime": 207.91500000003725, + "finished": true, + "transferSize": 1605, + "resourceSize": 1447, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/app/projects/page-75c3d38740a79ac3.js", + "sessionTargetType": "page", + "protocol": "http/1.1", + "cache": "none", + "rendererStartTime": 204.70900000073016, + "networkRequestTime": 204.956999999471, + "networkEndTime": 207.839999999851, + "finished": true, + "transferSize": 1356, + "resourceSize": 612, + "statusCode": 200, + "mimeType": "application/javascript", + "resourceType": "Script", + "priority": "Low", + "experimentalFromMainFrame": true, + "entity": "127.0.0.1" + } + ], + "debugData": { + "type": "debugdata", + "networkStartTimeTs": 4493504198, + "initiators": [ + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 342 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 460 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 578 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 671 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 780 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 853 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 930 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 1012 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 1089 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 1166 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 1243 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 1327 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 1410 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 1487 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 1569 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 0, + "columnNumber": 1659 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + }, + { + "type": "parser", + "url": "http://127.0.0.1:3053/", + "lineNumber": 18, + "columnNumber": 163364 + } + ] + } + } + }, + "network-rtt": { + "id": "network-rtt", + "title": "Network Round Trip Times", + "description": "Network round trip times (RTT) have a large impact on performance. If the RTT to an origin is high, it's an indication that servers closer to the user could improve performance. [Learn more about the Round Trip Time](https://hpbn.co/primer-on-latency-and-bandwidth/).", + "score": 1, + "scoreDisplayMode": "informative", + "numericValue": 0.054299999999999994, + "numericUnit": "millisecond", + "displayValue": "0 ms", + "details": { + "type": "table", + "headings": [ + { + "key": "origin", + "valueType": "text", + "label": "URL" + }, + { + "key": "rtt", + "valueType": "ms", + "granularity": 1, + "label": "Time Spent" + } + ], + "items": [ + { + "origin": "http://127.0.0.1:3053", + "rtt": 0.054299999999999994 + } + ], + "sortedBy": [ + "rtt" + ] + } + }, + "network-server-latency": { + "id": "network-server-latency", + "title": "Server Backend Latencies", + "description": "Server latencies can impact web performance. If the server latency of an origin is high, it's an indication the server is overloaded or has poor backend performance. [Learn more about server response time](https://hpbn.co/primer-on-web-performance/#analyzing-the-resource-waterfall).", + "score": 1, + "scoreDisplayMode": "informative", + "numericValue": 2.4872, + "numericUnit": "millisecond", + "displayValue": "0 ms", + "details": { + "type": "table", + "headings": [ + { + "key": "origin", + "valueType": "text", + "label": "URL" + }, + { + "key": "serverResponseTime", + "valueType": "ms", + "granularity": 1, + "label": "Time Spent" + } + ], + "items": [ + { + "origin": "http://127.0.0.1:3053", + "serverResponseTime": 2.4872 + } + ], + "sortedBy": [ + "serverResponseTime" + ] + } + }, + "main-thread-tasks": { + "id": "main-thread-tasks", + "title": "Tasks", + "description": "Lists the toplevel main thread tasks that executed during page load.", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "startTime", + "valueType": "ms", + "granularity": 1, + "label": "Start Time" + }, + { + "key": "duration", + "valueType": "ms", + "granularity": 1, + "label": "End Time" + } + ], + "items": [ + { + "duration": 6.212, + "startTime": 11.878 + }, + { + "duration": 8.787, + "startTime": 25.319 + }, + { + "duration": 33.823, + "startTime": 43.995 + }, + { + "duration": 23.788, + "startTime": 77.832 + }, + { + "duration": 5.427, + "startTime": 118.524 + }, + { + "duration": 5.066, + "startTime": 133.808 + }, + { + "duration": 5.086, + "startTime": 162.576 + }, + { + "duration": 5.08, + "startTime": 167.767 + }, + { + "duration": 23.697, + "startTime": 175.337 + } + ] + } + }, + "metrics": { + "id": "metrics", + "title": "Metrics", + "description": "Collects all available metrics.", + "score": 1, + "scoreDisplayMode": "informative", + "numericValue": 3483, + "numericUnit": "millisecond", + "details": { + "type": "debugdata", + "items": [ + { + "firstContentfulPaint": 905, + "largestContentfulPaint": 3467, + "interactive": 3483, + "speedIndex": 905, + "totalBlockingTime": 45, + "maxPotentialFID": 95, + "cumulativeLayoutShift": 0, + "cumulativeLayoutShiftMainFrame": 0, + "timeToFirstByte": 452, + "observedTimeOrigin": 0, + "observedTimeOriginTs": 4493502989, + "observedNavigationStart": 0, + "observedNavigationStartTs": 4493502989, + "observedFirstPaint": 98, + "observedFirstPaintTs": 4493600595, + "observedFirstContentfulPaint": 98, + "observedFirstContentfulPaintTs": 4493600595, + "observedFirstContentfulPaintAllFrames": 98, + "observedFirstContentfulPaintAllFramesTs": 4493600595, + "observedLargestContentfulPaint": 388, + "observedLargestContentfulPaintTs": 4493891217, + "observedLargestContentfulPaintAllFrames": 388, + "observedLargestContentfulPaintAllFramesTs": 4493891217, + "observedTraceEnd": 2485, + "observedTraceEndTs": 4495988372, + "observedLoad": 116, + "observedLoadTs": 4493618553, + "observedDomContentLoaded": 36, + "observedDomContentLoadedTs": 4493538767, + "observedCumulativeLayoutShift": 0, + "observedCumulativeLayoutShiftMainFrame": 0, + "observedFirstVisualChange": 83, + "observedFirstVisualChangeTs": 4493585989, + "observedLastVisualChange": 867, + "observedLastVisualChangeTs": 4494369989, + "observedSpeedIndex": 331, + "observedSpeedIndexTs": 4493834073 + }, + { + "lcpInvalidated": false + } + ] + } + }, + "resource-summary": { + "id": "resource-summary", + "title": "Resources Summary", + "description": "Aggregates all network requests and groups them by type", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "label", + "valueType": "text", + "label": "Resource Type" + }, + { + "key": "requestCount", + "valueType": "numeric", + "label": "Requests" + }, + { + "key": "transferSize", + "valueType": "bytes", + "label": "Transfer Size" + } + ], + "items": [ + { + "resourceType": "total", + "label": "Total", + "requestCount": 41, + "transferSize": 366562 + }, + { + "resourceType": "script", + "label": "Script", + "requestCount": 15, + "transferSize": 156771 + }, + { + "resourceType": "font", + "label": "Font", + "requestCount": 3, + "transferSize": 120583 + }, + { + "resourceType": "image", + "label": "Image", + "requestCount": 19, + "transferSize": 45104 + }, + { + "resourceType": "document", + "label": "Document", + "requestCount": 1, + "transferSize": 24098 + }, + { + "resourceType": "stylesheet", + "label": "Stylesheet", + "requestCount": 1, + "transferSize": 10314 + }, + { + "resourceType": "other", + "label": "Other", + "requestCount": 2, + "transferSize": 9692 + }, + { + "resourceType": "media", + "label": "Media", + "requestCount": 0, + "transferSize": 0 + }, + { + "resourceType": "third-party", + "label": "Third-party", + "requestCount": 0, + "transferSize": 0 + } + ] + } + }, + "layout-shifts": { + "id": "layout-shifts", + "title": "Avoid large layout shifts", + "description": "These are the largest layout shifts observed on the page. Each table item represents a single layout shift, and shows the element that shifted the most. Below each item are possible root causes that led to the layout shift. Some of these layout shifts may not be included in the CLS metric value due to [windowing](https://web.dev/articles/cls#what_is_cls). [Learn how to improve CLS](https://web.dev/articles/optimize-cls)", + "score": null, + "scoreDisplayMode": "notApplicable", + "metricSavings": { + "CLS": 0 + }, + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "extra" + }, + "label": "Element" + }, + { + "key": "score", + "valueType": "numeric", + "subItemsHeading": { + "key": "cause", + "valueType": "text" + }, + "granularity": 0.001, + "label": "Layout shift score" + } + ], + "items": [] + }, + "guidanceLevel": 2 + }, + "long-tasks": { + "id": "long-tasks", + "title": "Avoid long main-thread tasks", + "description": "Lists the longest tasks on the main thread, useful for identifying worst contributors to input delay. [Learn how to avoid long main-thread tasks](https://web.dev/articles/optimize-long-tasks)", + "score": 1, + "scoreDisplayMode": "informative", + "displayValue": "3 long tasks found", + "metricSavings": { + "TBT": 50 + }, + "details": { + "type": "table", + "headings": [ + { + "key": "url", + "valueType": "url", + "label": "URL" + }, + { + "key": "startTime", + "valueType": "ms", + "granularity": 1, + "label": "Start Time" + }, + { + "key": "duration", + "valueType": "ms", + "granularity": 1, + "label": "Duration" + } + ], + "items": [ + { + "url": "http://127.0.0.1:3053/_next/static/chunks/9e8df49e-9e9decc4e6f725ac.js", + "duration": 95, + "startTime": 3309.9488 + }, + { + "url": "http://127.0.0.1:3053/_next/static/chunks/629-681bce70bd5a239a.js", + "duration": 95, + "startTime": 3404.9488 + }, + { + "url": "http://127.0.0.1:3053/", + "duration": 68, + "startTime": 754.4872 + } + ], + "sortedBy": [ + "duration" + ], + "skipSumming": [ + "startTime" + ], + "debugData": { + "type": "debugdata", + "urls": [ + "http://127.0.0.1:3053/_next/static/chunks/9e8df49e-9e9decc4e6f725ac.js", + "http://127.0.0.1:3053/_next/static/chunks/629-681bce70bd5a239a.js", + "http://127.0.0.1:3053/" + ], + "tasks": [ + { + "urlIndex": 0, + "startTime": 3309.9, + "duration": 95, + "other": 95, + "scriptEvaluation": 0 + }, + { + "urlIndex": 1, + "startTime": 3404.9, + "duration": 95, + "other": 95 + }, + { + "urlIndex": 2, + "startTime": 754.5, + "duration": 68, + "other": 68, + "paintCompositeRender": 0, + "scriptEvaluation": 0, + "styleLayout": 0 + } + ] + } + }, + "guidanceLevel": 1 + }, + "non-composited-animations": { + "id": "non-composited-animations", + "title": "Avoid non-composited animations", + "description": "Animations which are not composited can be janky and increase CLS. [Learn how to avoid non-composited animations](https://developer.chrome.com/docs/lighthouse/performance/non-composited-animations/)", + "score": null, + "scoreDisplayMode": "notApplicable", + "metricSavings": { + "CLS": 0 + }, + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "failureReason", + "valueType": "text" + }, + "label": "Element" + } + ], + "items": [] + }, + "guidanceLevel": 2 + }, + "unsized-images": { + "id": "unsized-images", + "title": "Image elements have explicit `width` and `height`", + "description": "Set an explicit width and height on image elements to reduce layout shifts and improve CLS. [Learn how to set image dimensions](https://web.dev/articles/optimize-cls#images_without_dimensions)", + "score": 1, + "scoreDisplayMode": "metricSavings", + "metricSavings": { + "CLS": 0 + }, + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "label": "" + }, + { + "key": "url", + "valueType": "url", + "label": "URL" + } + ], + "items": [] + }, + "guidanceLevel": 4 + }, + "valid-source-maps": { + "id": "valid-source-maps", + "title": "Page has valid source maps", + "description": "Source maps translate minified code to the original source code. This helps developers debug in production. In addition, Lighthouse is able to provide further insights. Consider deploying source maps to take advantage of these benefits. [Learn more about source maps](https://developer.chrome.com/docs/devtools/javascript/source-maps/).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "scriptUrl", + "valueType": "url", + "subItemsHeading": { + "key": "error" + }, + "label": "URL" + }, + { + "key": "sourceMapUrl", + "valueType": "url", + "label": "Map URL" + } + ], + "items": [] + } + }, + "csp-xss": { + "id": "csp-xss", + "title": "Ensure CSP is effective against XSS attacks", + "description": "A strong Content Security Policy (CSP) significantly reduces the risk of cross-site scripting (XSS) attacks. [Learn how to use a CSP to prevent XSS](https://developer.chrome.com/docs/lighthouse/best-practices/csp-xss/)", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "description", + "valueType": "text", + "subItemsHeading": { + "key": "description" + }, + "label": "Description" + }, + { + "key": "directive", + "valueType": "code", + "subItemsHeading": { + "key": "directive" + }, + "label": "Directive" + }, + { + "key": "severity", + "valueType": "text", + "subItemsHeading": { + "key": "severity" + }, + "label": "Severity" + } + ], + "items": [ + { + "severity": "High", + "description": "No CSP found in enforcement mode" + } + ] + } + }, + "has-hsts": { + "id": "has-hsts", + "title": "Use a strong HSTS policy", + "description": "Deployment of the HSTS header significantly reduces the risk of downgrading HTTP connections and eavesdropping attacks. A rollout in stages, starting with a low max-age is recommended. [Learn more about using a strong HSTS policy.](https://developer.chrome.com/docs/lighthouse/best-practices/has-hsts)", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "description", + "valueType": "text", + "subItemsHeading": { + "key": "description" + }, + "label": "Description" + }, + { + "key": "directive", + "valueType": "code", + "subItemsHeading": { + "key": "directive" + }, + "label": "Directive" + }, + { + "key": "severity", + "valueType": "text", + "subItemsHeading": { + "key": "severity" + }, + "label": "Severity" + } + ], + "items": [ + { + "severity": "High", + "description": "No HSTS header found" + } + ] + } + }, + "origin-isolation": { + "id": "origin-isolation", + "title": "Ensure proper origin isolation with COOP", + "description": "The Cross-Origin-Opener-Policy (COOP) can be used to isolate the top-level window from other documents such as pop-ups. [Learn more about deploying the COOP header.](https://web.dev/articles/why-coop-coep#coop)", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "description", + "valueType": "text", + "subItemsHeading": { + "key": "description" + }, + "label": "Description" + }, + { + "key": "directive", + "valueType": "code", + "subItemsHeading": { + "key": "directive" + }, + "label": "Directive" + }, + { + "key": "severity", + "valueType": "text", + "subItemsHeading": { + "key": "severity" + }, + "label": "Severity" + } + ], + "items": [ + { + "description": "No COOP header found", + "severity": "High" + } + ] + } + }, + "clickjacking-mitigation": { + "id": "clickjacking-mitigation", + "title": "Mitigate clickjacking with XFO or CSP", + "description": "The `X-Frame-Options` (XFO) header or the `frame-ancestors` directive in the `Content-Security-Policy` (CSP) header control where a page can be embedded. These can mitigate clickjacking attacks by blocking some or all sites from embedding the page. [Learn more about mitigating clickjacking](https://developer.chrome.com/docs/lighthouse/best-practices/clickjacking-mitigation).", + "score": null, + "scoreDisplayMode": "notApplicable", + "details": { + "type": "table", + "headings": [ + { + "key": "description", + "valueType": "text", + "subItemsHeading": { + "key": "description" + }, + "label": "Description" + }, + { + "key": "severity", + "valueType": "text", + "subItemsHeading": { + "key": "severity" + }, + "label": "Severity" + } + ], + "items": [] + } + }, + "trusted-types-xss": { + "id": "trusted-types-xss", + "title": "Mitigate DOM-based XSS with Trusted Types", + "description": "The `require-trusted-types-for` directive in the `Content-Security-Policy` (CSP) header instructs user agents to control the data passed to DOM XSS sink functions. [Learn more about mitigating DOM-based XSS with Trusted Types](https://developer.chrome.com/docs/lighthouse/best-practices/trusted-types-xss).", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "table", + "headings": [ + { + "key": "description", + "valueType": "text", + "subItemsHeading": { + "key": "description" + }, + "label": "Description" + }, + { + "key": "severity", + "valueType": "text", + "subItemsHeading": { + "key": "severity" + }, + "label": "Severity" + } + ], + "items": [ + { + "severity": "High", + "description": "No `Content-Security-Policy` header with Trusted Types directive found" + } + ] + } + }, + "script-treemap-data": { + "id": "script-treemap-data", + "title": "Script Treemap Data", + "description": "Used for treemap app", + "score": 1, + "scoreDisplayMode": "informative", + "details": { + "type": "treemap-data", + "nodes": [ + { + "name": "http://127.0.0.1:3053/", + "resourceBytes": 163388, + "encodedBytes": 14121, + "children": [ + { + "name": "(inline) (function() {\n …", + "resourceBytes": 604, + "unusedBytes": 0 + }, + { + "name": "(inline) requestAnimatio…", + "resourceBytes": 57, + "unusedBytes": 0 + }, + { + "name": "(inline) $RB=[];$RV=func…", + "resourceBytes": 845, + "unusedBytes": 0 + }, + { + "name": "(inline) (self.__next_f=…", + "resourceBytes": 43, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 1340, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5026, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 2270, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 1199, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 4422, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 753, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 1492, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5092, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5118, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5018, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5051, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5098, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5044, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 4719, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5067, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5060, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5079, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5066, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5030, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 4464, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 4912, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 4942, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5006, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5025, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 5048, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 4400, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 4361, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 4413, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 734, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 4471, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 123, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 2186, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 846, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 622, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 817, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 2207, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 822, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 744, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 822, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 1346, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 808, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 1498, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 828, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 2370, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 470, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 828, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 756, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 816, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 1480, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 829, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 820, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 740, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 825, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 1053, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 815, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 1382, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 1060, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 3018, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 2953, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 679, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 178, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 35, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 54, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 2242, + "unusedBytes": 0 + }, + { + "name": "(inline) self.__next_f.p…", + "resourceBytes": 47, + "unusedBytes": 0 + } + ] + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/main-app-596ed5bc004070d9.js", + "resourceBytes": 513, + "encodedBytes": 513, + "unusedBytes": 0 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/webpack-4c9c27e0f0fab02a.js", + "resourceBytes": 3403, + "encodedBytes": 1711, + "unusedBytes": 34 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/263-d5483a7511b16a3b.js", + "resourceBytes": 8529, + "encodedBytes": 3381, + "unusedBytes": 4387 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/168-4d0a50e937ae6a21.js", + "resourceBytes": 13553, + "encodedBytes": 5194, + "unusedBytes": 3512 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/629-681bce70bd5a239a.js", + "resourceBytes": 173492, + "encodedBytes": 46787, + "unusedBytes": 68612 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/app/page-4392e7b55a1591e0.js", + "resourceBytes": 1513, + "encodedBytes": 523, + "unusedBytes": 0 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/app/error-a7dbc9387ba76d02.js", + "resourceBytes": 994, + "encodedBytes": 994, + "unusedBytes": 738 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/app/layout-d744eb9953200e54.js", + "resourceBytes": 6296, + "encodedBytes": 2394, + "unusedBytes": 636 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/9e8df49e-9e9decc4e6f725ac.js", + "resourceBytes": 173019, + "encodedBytes": 54421, + "unusedBytes": 57850 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/860-b2f411e4b7aa4e3a.js", + "resourceBytes": 21582, + "encodedBytes": 7486, + "unusedBytes": 454 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/518-6c10c56cbdd02efe.js", + "resourceBytes": 47867, + "encodedBytes": 16921, + "unusedBytes": 37103 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/app/global-error-b7c568106e941147.js", + "resourceBytes": 902, + "encodedBytes": 902, + "unusedBytes": 655 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/app/contact/page-ac1a6d29565f2e9a.js", + "resourceBytes": 7501, + "encodedBytes": 2591, + "unusedBytes": 6270 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/app/projects/page-75c3d38740a79ac3.js", + "resourceBytes": 612, + "encodedBytes": 612, + "unusedBytes": 294 + }, + { + "name": "http://127.0.0.1:3053/_next/static/chunks/app/projects/entry/%5Bslug%5D/page-e1602320c59e72d4.js", + "resourceBytes": 1447, + "encodedBytes": 830, + "unusedBytes": 1217 + } + ] + } + }, + "accesskeys": { + "id": "accesskeys", + "title": "`[accesskey]` values are unique", + "description": "Access keys let users quickly focus a part of the page. For proper navigation, each access key must be unique. [Learn more about access keys](https://dequeuniversity.com/rules/axe/4.12/accesskeys).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-allowed-attr": { + "id": "aria-allowed-attr", + "title": "`[aria-*]` attributes match their roles", + "description": "Each ARIA `role` supports a specific subset of `aria-*` attributes. Mismatching these invalidates the `aria-*` attributes. [Learn how to match ARIA attributes to their roles](https://dequeuniversity.com/rules/axe/4.12/aria-allowed-attr).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [] + } + }, + "aria-allowed-role": { + "id": "aria-allowed-role", + "title": "Uses ARIA roles only on compatible elements", + "description": "Many HTML elements can only be assigned certain ARIA roles. Using ARIA roles where they are not allowed can interfere with the accessibility of the web page. [Learn more about ARIA roles](https://dequeuniversity.com/rules/axe/4.12/aria-allowed-role).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-command-name": { + "id": "aria-command-name", + "title": "`button`, `link`, and `menuitem` elements have accessible names", + "description": "When an element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to make command elements more accessible](https://dequeuniversity.com/rules/axe/4.12/aria-command-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-conditional-attr": { + "id": "aria-conditional-attr", + "title": "ARIA attributes are used as specified for the element's role", + "description": "Some ARIA attributes are only allowed on an element under certain conditions. [Learn more about conditional ARIA attributes](https://dequeuniversity.com/rules/axe/4.12/aria-conditional-attr).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [] + } + }, + "aria-deprecated-role": { + "id": "aria-deprecated-role", + "title": "Deprecated ARIA roles were not used", + "description": "Deprecated ARIA roles may not be processed correctly by assistive technology. [Learn more about deprecated ARIA roles](https://dequeuniversity.com/rules/axe/4.12/aria-deprecated-role).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [] + } + }, + "aria-dialog-name": { + "id": "aria-dialog-name", + "title": "Elements with `role=\"dialog\"` or `role=\"alertdialog\"` have accessible names.", + "description": "ARIA dialog elements without accessible names may prevent screen readers users from discerning the purpose of these elements. [Learn how to make ARIA dialog elements more accessible](https://dequeuniversity.com/rules/axe/4.12/aria-dialog-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-hidden-body": { + "id": "aria-hidden-body", + "title": "`[aria-hidden=\"true\"]` is not present on the document ``", + "description": "Assistive technologies, like screen readers, work inconsistently when `aria-hidden=\"true\"` is set on the document ``. [Learn how `aria-hidden` affects the document body](https://dequeuniversity.com/rules/axe/4.12/aria-hidden-body).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [] + } + }, + "aria-hidden-focus": { + "id": "aria-hidden-focus", + "title": "`[aria-hidden=\"true\"]` elements do not contain focusable descendents", + "description": "Focusable descendents within an `[aria-hidden=\"true\"]` element prevent those interactive elements from being available to users of assistive technologies like screen readers. [Learn how `aria-hidden` affects focusable elements](https://dequeuniversity.com/rules/axe/4.12/aria-hidden-focus).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [] + } + }, + "aria-input-field-name": { + "id": "aria-input-field-name", + "title": "ARIA input fields have accessible names", + "description": "When an input field doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more about input field labels](https://dequeuniversity.com/rules/axe/4.12/aria-input-field-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-meter-name": { + "id": "aria-meter-name", + "title": "ARIA `meter` elements have accessible names", + "description": "When a meter element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to name `meter` elements](https://dequeuniversity.com/rules/axe/4.12/aria-meter-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-progressbar-name": { + "id": "aria-progressbar-name", + "title": "ARIA `progressbar` elements have accessible names", + "description": "When a `progressbar` element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to label `progressbar` elements](https://dequeuniversity.com/rules/axe/4.12/aria-progressbar-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-prohibited-attr": { + "id": "aria-prohibited-attr", + "title": "Elements use only permitted ARIA attributes", + "description": "Using ARIA attributes in roles where they are prohibited can mean that important information is not communicated to users of assistive technologies. [Learn more about prohibited ARIA roles](https://dequeuniversity.com/rules/axe/4.12/aria-prohibited-attr).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [] + } + }, + "aria-required-attr": { + "id": "aria-required-attr", + "title": "`[role]`s have all required `[aria-*]` attributes", + "description": "Some ARIA roles have required attributes that describe the state of the element to screen readers. [Learn more about roles and required attributes](https://dequeuniversity.com/rules/axe/4.12/aria-required-attr).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [] + } + }, + "aria-required-children": { + "id": "aria-required-children", + "title": "Elements with an ARIA `[role]` that require children to contain a specific `[role]` have all required children.", + "description": "Some ARIA parent roles must contain specific child roles to perform their intended accessibility functions. [Learn more about roles and required children elements](https://dequeuniversity.com/rules/axe/4.12/aria-required-children).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-required-parent": { + "id": "aria-required-parent", + "title": "`[role]`s are contained by their required parent element", + "description": "Some ARIA child roles must be contained by specific parent roles to properly perform their intended accessibility functions. [Learn more about ARIA roles and required parent element](https://dequeuniversity.com/rules/axe/4.12/aria-required-parent).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-roles": { + "id": "aria-roles", + "title": "`[role]` values are valid", + "description": "ARIA roles must have valid values in order to perform their intended accessibility functions. [Learn more about valid ARIA roles](https://dequeuniversity.com/rules/axe/4.12/aria-roles).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [] + } + }, + "aria-text": { + "id": "aria-text", + "title": "Elements with the `role=text` attribute do not have focusable descendents.", + "description": "Adding `role=text` around a text node split by markup enables VoiceOver to treat it as one phrase, but the element's focusable descendents will not be announced. [Learn more about the `role=text` attribute](https://dequeuniversity.com/rules/axe/4.12/aria-text).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-toggle-field-name": { + "id": "aria-toggle-field-name", + "title": "ARIA toggle fields have accessible names", + "description": "When a toggle field doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more about toggle fields](https://dequeuniversity.com/rules/axe/4.12/aria-toggle-field-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-tooltip-name": { + "id": "aria-tooltip-name", + "title": "ARIA `tooltip` elements have accessible names", + "description": "When a tooltip element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to name `tooltip` elements](https://dequeuniversity.com/rules/axe/4.12/aria-tooltip-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-treeitem-name": { + "id": "aria-treeitem-name", + "title": "ARIA `treeitem` elements have accessible names", + "description": "When a `treeitem` element doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more about labeling `treeitem` elements](https://dequeuniversity.com/rules/axe/4.12/aria-treeitem-name).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "aria-valid-attr-value": { + "id": "aria-valid-attr-value", + "title": "`[aria-*]` attributes have valid values", + "description": "Assistive technologies, like screen readers, can't interpret ARIA attributes with invalid values. [Learn more about valid values for ARIA attributes](https://dequeuniversity.com/rules/axe/4.12/aria-valid-attr-value).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [] + } + }, + "aria-valid-attr": { + "id": "aria-valid-attr", + "title": "`[aria-*]` attributes are valid and not misspelled", + "description": "Assistive technologies, like screen readers, can't interpret ARIA attributes with invalid names. [Learn more about valid ARIA attributes](https://dequeuniversity.com/rules/axe/4.12/aria-valid-attr).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [] + } + }, + "button-name": { + "id": "button-name", + "title": "Buttons have an accessible name", + "description": "When a button doesn't have an accessible name, screen readers announce it as \"button\", making it unusable for users who rely on screen readers. [Learn how to make buttons more accessible](https://dequeuniversity.com/rules/axe/4.12/button-name).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [] + } + }, + "bypass": { + "id": "bypass", + "title": "The page contains a heading, skip link, or landmark region", + "description": "Adding ways to bypass repetitive content lets keyboard users navigate the page more efficiently. [Learn more about bypass blocks](https://dequeuniversity.com/rules/axe/4.12/bypass).", + "score": null, + "scoreDisplayMode": "notApplicable" + }, + "color-contrast": { + "id": "color-contrast", + "title": "Background and foreground colors have a sufficient contrast ratio", + "description": "Low-contrast text is difficult or impossible for many users to read. [Learn how to provide sufficient color contrast](https://dequeuniversity.com/rules/axe/4.12/color-contrast).", + "score": 1, + "scoreDisplayMode": "binary", + "details": { + "type": "table", + "headings": [ + { + "key": "node", + "valueType": "node", + "subItemsHeading": { + "key": "relatedNode", + "valueType": "node" + }, + "label": "Failing Elements" + } + ], + "items": [] + } + }, + "definition-list": { + "id": "definition-list", + "title": "`
`'s contain only properly-ordered `
` and `
` groups, `