From f0d38a8b54b3a086bc6c3aa20d1dee865108dc36 Mon Sep 17 00:00:00 2001 From: Forbes Lindesay Date: Thu, 19 Aug 2021 15:40:37 +0100 Subject: [PATCH 01/10] feat: remove es-git dependency --- .gitignore | 4 +- package.json | 2 + packages/core/README.md | 3 + packages/core/package.json | 31 + packages/core/rollup.toml | 1 + packages/core/src/AsyncBuffer.ts | 123 ++++ packages/core/src/Buffer.ts | 82 +++ packages/core/src/index.ts | 69 +++ packages/core/src/sha1.ts | 152 +++++ packages/core/src/utils.test.ts | 13 + packages/core/src/utils.ts | 88 +++ packages/core/tsconfig.json | 14 + packages/objects/package.json | 2 +- packages/objects/src/decodeObject.ts | 8 +- packages/objects/src/encodeObject.ts | 24 +- packages/objects/src/index.ts | 2 +- packages/objects/src/joinWithNewline.ts | 2 +- packages/objects/src/types.ts | 2 +- packages/objects/tsconfig.json | 1 + packages/packfile/README.md | 3 + packages/packfile/package.json | 35 ++ packages/packfile/rollup.toml | 1 + .../packfile/src/DigestableAsyncBuffer.ts | 57 ++ packages/packfile/src/apply-delta.ts | 53 ++ packages/packfile/src/compose-packfile.ts | 79 +++ packages/packfile/src/index.ts | 5 + packages/packfile/src/normalize-entries.ts | 72 +++ packages/packfile/src/pack.ts | 76 +++ packages/packfile/src/parse-packfile.ts | 304 ++++++++++ packages/packfile/src/pipe.ts | 110 ++++ packages/packfile/src/types.ts | 36 ++ packages/packfile/src/unpack.ts | 16 + packages/packfile/tsconfig.json | 16 + packages/protocol/package.json | 4 +- packages/protocol/src/FetchCommand.ts | 4 +- packages/protocol/src/InitialRequest.ts | 1 + packages/protocol/src/PktLines.test.ts | 2 +- packages/protocol/src/PktLines.ts | 2 +- packages/protocol/tsconfig.json | 2 + scripts/test-pull.js | 123 ++++ tsconfig.json | 2 + yarn.lock | 539 +++++++++++++++++- 42 files changed, 2109 insertions(+), 56 deletions(-) create mode 100644 packages/core/README.md create mode 100644 packages/core/package.json create mode 100644 packages/core/rollup.toml create mode 100644 packages/core/src/AsyncBuffer.ts create mode 100644 packages/core/src/Buffer.ts create mode 100644 packages/core/src/index.ts create mode 100644 packages/core/src/sha1.ts create mode 100644 packages/core/src/utils.test.ts create mode 100644 packages/core/src/utils.ts create mode 100644 packages/core/tsconfig.json create mode 100644 packages/packfile/README.md create mode 100644 packages/packfile/package.json create mode 100644 packages/packfile/rollup.toml create mode 100644 packages/packfile/src/DigestableAsyncBuffer.ts create mode 100644 packages/packfile/src/apply-delta.ts create mode 100644 packages/packfile/src/compose-packfile.ts create mode 100644 packages/packfile/src/index.ts create mode 100644 packages/packfile/src/normalize-entries.ts create mode 100644 packages/packfile/src/pack.ts create mode 100644 packages/packfile/src/parse-packfile.ts create mode 100644 packages/packfile/src/pipe.ts create mode 100644 packages/packfile/src/types.ts create mode 100644 packages/packfile/src/unpack.ts create mode 100644 packages/packfile/tsconfig.json create mode 100644 scripts/test-pull.js diff --git a/.gitignore b/.gitignore index d60ac0e..0f2c77e 100644 --- a/.gitignore +++ b/.gitignore @@ -93,4 +93,6 @@ snowpack-cache app/tailwind.css.br bundle-cache -package-entry-points.json \ No newline at end of file +package-entry-points.json + +secrets/ \ No newline at end of file diff --git a/package.json b/package.json index d927e79..4403c7f 100644 --- a/package.json +++ b/package.json @@ -9,6 +9,7 @@ "dependencies": { "@babel/runtime": "^7.12.5", "@forbeslindesay/tsconfig": "^2.0.0", + "@github-graph/api": "^2.2.1", "@rollup/plugin-commonjs": "^17.0.0", "@rollup/plugin-node-resolve": "^11.0.0", "@sucrase/jest-plugin": "^2.0.0", @@ -17,6 +18,7 @@ "@types/react-dom": "^17.0.0", "copy-dir": "^1.3.0", "husky": "^4.2.5", + "interrogator": "^1.1.0", "is-builtin-module": "^3.0.0", "jest": "^26.0.1", "lint-staged": "^10.1.3", diff --git a/packages/core/README.md b/packages/core/README.md new file mode 100644 index 0000000..ae5305a --- /dev/null +++ b/packages/core/README.md @@ -0,0 +1,3 @@ +# @rollingversions/git-core + +Forked from https://github.com/mariusGundersen/es-git diff --git a/packages/core/package.json b/packages/core/package.json new file mode 100644 index 0000000..124b22f --- /dev/null +++ b/packages/core/package.json @@ -0,0 +1,31 @@ +{ + "name": "@rollingversions/git-core", + "version": "0.0.0", + "main": "dist/index.cjs", + "module": "dist/index.mjs", + "types": "lib/index.d.ts", + "exports": { + ".": { + "import": "./dist/index.mjs", + "default": "./dist/index.cjs" + }, + "./package.json": "./package.json" + }, + "files": [ + "dist/", + "lib/" + ], + "scripts": { + "build": "tsc" + }, + "dependencies": {}, + "devDependencies": {}, + "peerDependencies": {}, + "engines": { + "node": ">=14.0.0" + }, + "publishConfig": { + "access": "public" + }, + "license": "MIT" +} diff --git a/packages/core/rollup.toml b/packages/core/rollup.toml new file mode 100644 index 0000000..52e8618 --- /dev/null +++ b/packages/core/rollup.toml @@ -0,0 +1 @@ +exports = 'named' \ No newline at end of file diff --git a/packages/core/src/AsyncBuffer.ts b/packages/core/src/AsyncBuffer.ts new file mode 100644 index 0000000..e3acd26 --- /dev/null +++ b/packages/core/src/AsyncBuffer.ts @@ -0,0 +1,123 @@ +import {concat} from './utils'; + +export default class AsyncBuffer { + private data: Uint8Array; + private readonly source: AsyncIterableIterator; + private pointer = 0; + private consumed = 0; + constructor(source: AsyncIterableIterator) { + this.source = source; + this.data = new Uint8Array(0); + } + + get pos() { + return this.consumed + this.pointer; + } + + private async nextData(length: number) { + while (this.pointer + length > this.data.length) { + const {value, done} = await this.source.next(); + if (done) { + throw new Error( + 'done ' + this.pointer + ' ' + length + ' ' + this.data.length, + ); + } + if (this.data.length > 0) { + this.consumed += this.pointer; + this.data = concat(this.data.subarray(this.pointer), value); + this.pointer = 0; + } else { + this.data = value; + } + } + } + + next(): Promise; + next(length: number): Promise; + async next(length?: number) { + if (length !== undefined) { + await this.nextData(length); + return this.data.subarray(this.pointer, (this.pointer += length)); + } else { + await this.nextData(1); + return this.data[this.pointer++]; + } + } + + async nextInt32(): Promise { + await this.nextData(4); + let result = 0; + for (let i = 0; i < 4; i++) { + result = (result << 8) | this.data[this.pointer + i]; + } + return result; + } + + peek(): Promise; + peek(length: number): Promise; + async peek(length?: number) { + if (length !== undefined) { + await this.nextData(length); + return this.data.subarray(this.pointer, this.pointer + length); + } else { + await this.nextData(1); + return this.data[this.pointer]; + } + } + + async peekInt32(): Promise { + await this.nextData(4); + let result = 0; + for (let i = 0; i < 4; i++) { + result = (result << 8) | this.data[this.pointer + i]; + } + return result; + } + + rest(): AsyncIterableIterator; + rest(length: number): AsyncIterableIterator; + async *rest(length?: number): AsyncIterableIterator { + if (length !== undefined) { + while (length > this.data.length - this.pointer) { + const chunkSize = this.data.length - this.pointer; + if (chunkSize == 0) { + await this.nextData(1); + } else { + yield await this.next(chunkSize); + length -= chunkSize; + } + } + yield await this.next(length); + } else { + yield await this.next(this.data.length - this.pointer); + for await (const chunk of this.source) { + yield await chunk; + } + } + } + + async chunk() { + if (this.pointer === this.data.length) { + await this.nextData(1); + } + const pointer = this.pointer; + this.pointer = this.data.length; + return this.data.subarray(pointer); + } + + rewind(length: number) { + this.pointer -= length; + } + + async isDone() { + return this.nextData(1).then( + () => false, + () => true, + ); + } + + async complete() { + for await (const _ of this.rest()) { + } + } +} diff --git a/packages/core/src/Buffer.ts b/packages/core/src/Buffer.ts new file mode 100644 index 0000000..968e408 --- /dev/null +++ b/packages/core/src/Buffer.ts @@ -0,0 +1,82 @@ +export default class Buffer { + readonly data: Uint8Array; + private pointer = 0; + constructor(data: Uint8Array) { + this.data = data; + } + + get pos() { + return this.pointer; + } + + next(): number; + next(length: number): Uint8Array; + next(length?: number) { + if (length !== undefined) { + length = Math.min(length, this.data.length - this.pointer); + const result = this.data.subarray(this.pointer, this.pointer + length); + this.pointer += length; + return result; + } else { + return this.data[this.pointer++]; + } + } + + nextInt32(): number { + let result = 0; + for (let i = 0; i < 4; i++) { + result = (result << 8) | this.next(); + } + return result; + } + + peek(): number; + peek(length: number): Uint8Array; + peek(length?: number) { + if (length !== undefined) { + length = Math.min(length, this.data.length - this.pointer); + const result = this.data.subarray(this.pointer, this.pointer + length); + return result; + } else { + return this.data[this.pointer]; + } + } + + peekInt32(): number { + let result = 0; + for (let i = 0; i < 4; i++) { + result = (result << 8) | this.data[this.pointer + i]; + } + return result; + } + + write(byte: number): void; + write(bytes: Uint8Array): void; + write(bytes: Uint8Array, offset: number, length: number): void; + write(value: number | Uint8Array, offset?: number, length?: number) { + if (typeof value === 'number') { + this.data[this.pointer++] = value; + } else { + if (offset !== undefined) { + length = length === undefined ? value.length - offset : length; + this.data.set(value.subarray(offset, offset + length), this.pointer); + this.pointer += length; + } else { + this.data.set(value, this.pointer); + this.pointer += value.length; + } + } + } + + rest() { + return this.next(this.data.length - this.pointer); + } + + soFar() { + return this.data.subarray(0, this.pointer); + } + + get isDone() { + return this.pointer >= this.data.length; + } +} diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts new file mode 100644 index 0000000..8ce8300 --- /dev/null +++ b/packages/core/src/index.ts @@ -0,0 +1,69 @@ +export {default as AsyncBuffer} from './AsyncBuffer'; +export {default as Buffer} from './Buffer'; +export {default as sha1, Sha1} from './sha1'; +export { + decode, + encode, + concat, + fromDec, + fromHex, + fromOct, + fromDecChar, + fromHexChar, + packHash, + unpackHash, + toHexChar, + NEWLINE, +} from './utils'; + +export enum Mask { + mask = 0o100000, + blob = 0o140000, + file = 0o160000, +} + +export enum Mode { + tree = 0o040000, + blob = 0o100644, + file = 0o100644, + exec = 0o100755, + sym = 0o120000, + commit = 0o160000, +} + +export enum Type { + unknown = 'unknown', + commit = 'commit', + tree = 'tree', + blob = 'blob', + tag = 'tag', +} + +export function isBlob(mode: number) { + return (mode & Mask.blob) === Mask.mask; +} + +export function isFile(mode: number) { + return (mode & Mask.file) === Mask.mask; +} + +export function toType(mode: number) { + if (mode === Mode.commit) return Type.commit; + if (mode === Mode.tree) return Type.tree; + if ((mode & Mask.blob) === Mask.mask) return Type.blob; + return Type.unknown; +} + +export interface IRawRepo { + listRefs(): Promise; + getRef(ref: string): Promise; + setRef(ref: string, hash: Hash): Promise; + deleteRef(ref: string): Promise; + saveRaw(hash: Hash, object: Uint8Array): Promise; + loadRaw(hash: Hash): Promise; + hasObject(hash: Hash): Promise; + saveMetadata(name: string, value: Uint8Array): Promise; + loadMetadata(name: string): Promise; +} + +export type Hash = string; diff --git a/packages/core/src/sha1.ts b/packages/core/src/sha1.ts new file mode 100644 index 0000000..2496cc3 --- /dev/null +++ b/packages/core/src/sha1.ts @@ -0,0 +1,152 @@ +const shared = new Uint32Array(80); + +export interface Sha1 { + update(chunk: string): string; + update(chunk: number[]): number[]; + update(chunk: Uint8Array): Uint8Array; + digest(): string; +} + +// Input chunks must be either arrays of bytes or "raw" encoded strings +export default function sha1(): Sha1; +export default function sha1(buffer: string | number[] | Uint8Array): string; +export default function sha1(buffer?: string | number[] | Uint8Array) { + if (buffer === undefined) return create(new Uint32Array(80)); + const shasum = create(shared); + shasum.update(buffer as any); + return shasum.digest(); +} + +// A pure JS implementation of sha1 for non-node environments. +function create(block: Uint32Array): Sha1 { + let h0 = 0x67452301; + let h1 = 0xefcdab89; + let h2 = 0x98badcfe; + let h3 = 0x10325476; + let h4 = 0xc3d2e1f0; + // The first 64 bytes (16 words) is the data chunk + let offset = 0; + let shift = 24; + let totalLength = 0; + + return {update: update, digest: digest}; + + // The user gave us more data. Store it! + function update(chunk: string): string; + function update(chunk: number[]): number[]; + function update(chunk: Uint8Array): Uint8Array; + function update(chunk: string | number[] | Uint8Array): any { + if (typeof chunk === 'string') return updateString(chunk); + const length = chunk.length; + totalLength += length * 8; + for (let i = 0; i < length; i++) { + write(chunk[i]); + } + return chunk; + } + + function updateString(string: string) { + const length = string.length; + totalLength += length * 8; + for (let i = 0; i < length; i++) { + write(string.charCodeAt(i)); + } + } + + function write(byte: number) { + block[offset] |= (byte & 0xff) << shift; + if (shift) { + shift -= 8; + } else { + offset++; + shift = 24; + } + if (offset === 16) processBlock(); + } + + // No more data will come, pad the block, process and return the result. + function digest() { + // Pad + write(0x80); + if (offset > 14 || (offset === 14 && shift < 24)) { + processBlock(); + } + offset = 14; + shift = 24; + + // 64-bit length big-endian + write(0x00); // numbers this big aren't accurate in javascript anyway + write(0x00); // ..So just hard-code to zero. + write(totalLength > 0xffffffffff ? totalLength / 0x10000000000 : 0x00); + write(totalLength > 0xffffffff ? totalLength / 0x100000000 : 0x00); + for (let s = 24; s >= 0; s -= 8) { + write(totalLength >> s); + } + + // At this point one last processBlock() should trigger and we can pull out the result. + return toHex(h0) + toHex(h1) + toHex(h2) + toHex(h3) + toHex(h4); + } + + // We have a full block to process. Let's do it! + function processBlock() { + // Extend the sixteen 32-bit words into eighty 32-bit words: + for (let i = 16; i < 80; i++) { + const w = block[i - 3] ^ block[i - 8] ^ block[i - 14] ^ block[i - 16]; + block[i] = (w << 1) | (w >>> 31); + } + + // log(block); + + // Initialize hash value for this chunk: + let a = h0; + let b = h1; + let c = h2; + let d = h3; + let e = h4; + let f, k; + + // Main loop: + for (let i = 0; i < 80; i++) { + if (i < 20) { + f = d ^ (b & (c ^ d)); + k = 0x5a827999; + } else if (i < 40) { + f = b ^ c ^ d; + k = 0x6ed9eba1; + } else if (i < 60) { + f = (b & c) | (d & (b | c)); + k = 0x8f1bbcdc; + } else { + f = b ^ c ^ d; + k = 0xca62c1d6; + } + const temp = ((a << 5) | (a >>> 27)) + f + e + k + (block[i] | 0); + e = d; + d = c; + c = (b << 30) | (b >>> 2); + b = a; + a = temp; + } + + // Add this chunk's hash to result so far: + h0 = (h0 + a) | 0; + h1 = (h1 + b) | 0; + h2 = (h2 + c) | 0; + h3 = (h3 + d) | 0; + h4 = (h4 + e) | 0; + + // The block is now reusable. + offset = 0; + for (let i = 0; i < 16; i++) { + block[i] = 0; + } + } + + function toHex(word: number) { + let hex = ''; + for (let i = 28; i >= 0; i -= 4) { + hex += ((word >> i) & 0xf).toString(16); + } + return hex; + } +} diff --git a/packages/core/src/utils.test.ts b/packages/core/src/utils.test.ts new file mode 100644 index 0000000..62c4543 --- /dev/null +++ b/packages/core/src/utils.test.ts @@ -0,0 +1,13 @@ +import {toHexChar} from './utils'; + +for (const [num, hexChar] of [ + [0, '0'], + [1, '1'], + [9, '9'], + [10, 'a'], + [15, 'f'], +] as const) { + test(`toHexChar(${num}) => ${hexChar}`, () => { + expect(String.fromCharCode(toHexChar(num))).toBe(hexChar); + }); +} diff --git a/packages/core/src/utils.ts b/packages/core/src/utils.ts new file mode 100644 index 0000000..c126357 --- /dev/null +++ b/packages/core/src/utils.ts @@ -0,0 +1,88 @@ +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); + +export const NEWLINE = '\n'.charCodeAt(0); + +export function encode(text: string) { + return encoder.encode(text); +} + +export function decode(binary: Uint8Array, start = 0, end = binary.length) { + if (start !== 0 || end !== binary.length) { + return decoder.decode(binary.subarray(start, end)); + } else { + return decoder.decode(binary); + } +} + +export function concat(...arrays: (Uint8Array | number[])[]): Uint8Array { + const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0); + const result = new Uint8Array(totalLength); + let offset = 0; + for (const arr of arrays) { + result.set(arr, offset); + offset += arr.length; + } + return result; +} + +export function fromHex(binary: Uint8Array) { + let size = 0; + for (let i = 0; i < 4; i++) { + size = (size << 4) | fromHexChar(binary[i]); + } + return size; +} + +export function fromHexChar(val: number) { + return val < 0x57 ? val - 0x30 : val - 0x57; +} + +export function fromDec(buffer: Uint8Array, start: number, end: number) { + let val = 0; + while (start < end) { + val = val * 10 + fromDecChar(buffer[start++]); + } + return val; +} + +export function fromDecChar(val: number) { + return val - 0x30; +} + +export function fromOct( + buffer: Uint8Array, + start: number, + end: number, +): number { + let val = 0; + while (start < end) { + val = (val << 3) + fromDecChar(buffer[start++]); + } + return val; +} + +export function packHash(hex: string) { + var raw = new Uint8Array(hex.length / 2); + for (let i = 0; i < hex.length; ) { + raw[i / 2] = + (fromHexChar(hex.charCodeAt(i++)) << 4) | + fromHexChar(hex.charCodeAt(i++)); + } + return raw; +} + +export function unpackHash(binary: Uint8Array, start = 0, end = binary.length) { + var hex = ''; + for (var i = start; i < end; i++) { + var byte = binary[i]; + hex += + String.fromCharCode(toHexChar(byte >> 4)) + + String.fromCharCode(toHexChar(byte & 0xf)); + } + return hex; +} + +export function toHexChar(val: number) { + return val < 10 ? val + 0x30 : val + 0x57; +} diff --git a/packages/core/tsconfig.json b/packages/core/tsconfig.json new file mode 100644 index 0000000..b57047c --- /dev/null +++ b/packages/core/tsconfig.json @@ -0,0 +1,14 @@ +{ + "extends": "@forbeslindesay/tsconfig", + "compilerOptions": { + "outDir": "lib", + "module": "ES2020", + "incremental": true, + "composite": true, + "rootDir": "src", + "tsBuildInfoFile": "lib/.tsbuildinfo", + "lib": ["DOM", "ES2020"] + }, + "include": ["src"], + "references": [], +} diff --git a/packages/objects/package.json b/packages/objects/package.json index d25150a..897437b 100644 --- a/packages/objects/package.json +++ b/packages/objects/package.json @@ -19,7 +19,7 @@ "build": "tsc" }, "dependencies": { - "@es-git/core": "^0.10.0" + "@rollingversions/git-core": "^0.0.0" }, "devDependencies": {}, "peerDependencies": {}, diff --git a/packages/objects/src/decodeObject.ts b/packages/objects/src/decodeObject.ts index 0ea11ec..4f0bba8 100644 --- a/packages/objects/src/decodeObject.ts +++ b/packages/objects/src/decodeObject.ts @@ -1,4 +1,10 @@ -import {Type, decode, unpackHash, fromDec, fromOct} from '@es-git/core'; +import { + Type, + decode, + unpackHash, + fromDec, + fromOct, +} from '@rollingversions/git-core'; import { GitObject, diff --git a/packages/objects/src/encodeObject.ts b/packages/objects/src/encodeObject.ts index 8bc722a..7ad173a 100644 --- a/packages/objects/src/encodeObject.ts +++ b/packages/objects/src/encodeObject.ts @@ -1,4 +1,4 @@ -import {concat, encode, flatten, Mode, packHash, Type} from '@es-git/core'; +import {concat, encode, Mode, packHash, Type} from '@rollingversions/git-core'; import { CommitBody, GitObject, @@ -48,18 +48,16 @@ export function treeSort( export function encodeTree(body: TreeBody) { return concat( - ...flatten( - Object.keys(body) - .map((key) => ({ - name: key, - ...body[key], - })) - .sort(treeSort) - .map((entry) => [ - encode(`${entry.mode.toString(8)} ${entry.name}\0`), - packHash(entry.hash), - ]), - ), + ...Object.keys(body) + .map((key) => ({ + name: key, + ...body[key], + })) + .sort(treeSort) + .flatMap((entry) => [ + encode(`${entry.mode.toString(8)} ${entry.name}\0`), + packHash(entry.hash), + ]), ); } diff --git a/packages/objects/src/index.ts b/packages/objects/src/index.ts index 4a71b3d..9573c7c 100644 --- a/packages/objects/src/index.ts +++ b/packages/objects/src/index.ts @@ -1,4 +1,4 @@ -export {sha1, Type, Mode} from '@es-git/core'; +export {sha1, Type, Mode} from '@rollingversions/git-core'; export {default as encodeObject, textToBlob} from './encodeObject'; export { diff --git a/packages/objects/src/joinWithNewline.ts b/packages/objects/src/joinWithNewline.ts index 486fb74..6c260a4 100644 --- a/packages/objects/src/joinWithNewline.ts +++ b/packages/objects/src/joinWithNewline.ts @@ -1,4 +1,4 @@ -import {encode, NEWLINE} from '@es-git/core'; +import {encode, NEWLINE} from '@rollingversions/git-core'; const NEWLINE_ARRAY = [NEWLINE]; export default function joinWithNewline(...values: (string | Uint8Array)[]) { diff --git a/packages/objects/src/types.ts b/packages/objects/src/types.ts index d3db451..489fae8 100644 --- a/packages/objects/src/types.ts +++ b/packages/objects/src/types.ts @@ -1,4 +1,4 @@ -import {Type, Mode} from '@es-git/core'; +import {Type, Mode} from '@rollingversions/git-core'; export type Hash = string; diff --git a/packages/objects/tsconfig.json b/packages/objects/tsconfig.json index 3733906..4c2bc78 100644 --- a/packages/objects/tsconfig.json +++ b/packages/objects/tsconfig.json @@ -11,5 +11,6 @@ }, "include": ["src"], "references": [ + {"path": "../core"}, ], } diff --git a/packages/packfile/README.md b/packages/packfile/README.md new file mode 100644 index 0000000..a4c6249 --- /dev/null +++ b/packages/packfile/README.md @@ -0,0 +1,3 @@ +# @rollingversions/git-packfile + +Forked from https://github.com/mariusGundersen/es-git diff --git a/packages/packfile/package.json b/packages/packfile/package.json new file mode 100644 index 0000000..4d14101 --- /dev/null +++ b/packages/packfile/package.json @@ -0,0 +1,35 @@ +{ + "name": "@rollingversions/git-packfile", + "version": "0.0.0", + "main": "dist/index.cjs", + "module": "dist/index.mjs", + "types": "lib/index.d.ts", + "exports": { + ".": { + "import": "./dist/index.mjs", + "default": "./dist/index.cjs" + }, + "./package.json": "./package.json" + }, + "files": [ + "dist/", + "lib/" + ], + "scripts": { + "build": "tsc" + }, + "dependencies": { + "@rollingversions/git-core": "^0.0.0", + "@types/pako": "^1.0.2", + "pako": "^1.0.5" + }, + "devDependencies": {}, + "peerDependencies": {}, + "engines": { + "node": ">=14.0.0" + }, + "publishConfig": { + "access": "public" + }, + "license": "MIT" +} diff --git a/packages/packfile/rollup.toml b/packages/packfile/rollup.toml new file mode 100644 index 0000000..52e8618 --- /dev/null +++ b/packages/packfile/rollup.toml @@ -0,0 +1 @@ +exports = 'named' \ No newline at end of file diff --git a/packages/packfile/src/DigestableAsyncBuffer.ts b/packages/packfile/src/DigestableAsyncBuffer.ts new file mode 100644 index 0000000..af0c0d3 --- /dev/null +++ b/packages/packfile/src/DigestableAsyncBuffer.ts @@ -0,0 +1,57 @@ +import {AsyncBuffer, sha1, Sha1} from '@rollingversions/git-core'; + +export default class DigestableAsyncBuffer extends AsyncBuffer { + private sha: Sha1; + private temp: Uint8Array; + private tempChunk: Uint8Array | undefined; + constructor(chunks: AsyncIterableIterator) { + super(chunks); + this.sha = sha1(); + this.temp = new Uint8Array(1); + } + + next(): Promise; + next(length: number): Promise; + async next(length?: number) { + if (length === undefined) { + const result = await super.next(); + this.temp[0] = result; + this.sha.update(this.temp); + return result; + } else { + const result = await super.next(length); + return this.sha.update(result); + } + } + + async nextInt32(): Promise { + const buffer = await super.next(4); + this.sha.update(buffer); + let result = 0; + for (let i = 0; i < 4; i++) { + result = (result << 8) | buffer[i]; + } + return result; + } + + async chunk() { + if (this.tempChunk) this.sha.update(this.tempChunk); + this.tempChunk = await super.chunk(); + return this.tempChunk; + } + + rewind(length: number) { + if (this.tempChunk) + this.sha.update( + this.tempChunk.subarray(0, this.tempChunk.length - length), + ); + this.tempChunk = undefined; + super.rewind(length); + } + + digest() { + const result = this.sha.digest(); + this.sha = sha1(); + return result; + } +} diff --git a/packages/packfile/src/apply-delta.ts b/packages/packfile/src/apply-delta.ts new file mode 100644 index 0000000..43150c2 --- /dev/null +++ b/packages/packfile/src/apply-delta.ts @@ -0,0 +1,53 @@ +import {Buffer} from '@rollingversions/git-core'; + +export default function applyDelta(delta: Uint8Array, base: Uint8Array) { + const input = new Buffer(delta); + + if (base.length !== readLength(input)) { + throw new Error('Base length mismatch'); + } + + // Create a new output buffer with length from header. + const output = new Buffer(new Uint8Array(readLength(input))); + + while (!input.isDone) { + const byte = input.next(); + // Copy command. Tells us offset in base and length to copy. + if (byte & 0x80) { + let offset = 0; + let length = 0; + if (byte & 0x01) offset |= input.next() << 0; + if (byte & 0x02) offset |= input.next() << 8; + if (byte & 0x04) offset |= input.next() << 16; + if (byte & 0x08) offset |= input.next() << 24; + if (byte & 0x10) length |= input.next() << 0; + if (byte & 0x20) length |= input.next() << 8; + if (byte & 0x40) length |= input.next() << 16; + if (length === 0) length = 0x10000; + // copy the data + output.write(base, offset, length); + } + // Insert command, opcode byte is length itself + else if (byte) { + output.write(input.next(byte)); + } else throw new Error('Invalid delta opcode'); + } + + if (output.pos !== output.data.length) { + throw new Error('Size mismatch in check'); + } + + return output.data; +} + +function readLength(buffer: Buffer) { + let byte = buffer.next(); + let length = byte & 0x7f; + let shift = 7; + while (byte & 0x80) { + byte = buffer.next(); + length |= (byte & 0x7f) << shift; + shift += 7; + } + return length; +} diff --git a/packages/packfile/src/compose-packfile.ts b/packages/packfile/src/compose-packfile.ts new file mode 100644 index 0000000..639a3e5 --- /dev/null +++ b/packages/packfile/src/compose-packfile.ts @@ -0,0 +1,79 @@ +import {packHash, sha1} from '@rollingversions/git-core'; + +import * as pako from 'pako'; + +import {Type, Entry} from './types'; + +export default async function* composePackfile( + items: AsyncIterableIterator, + count: number, +) { + const hash = sha1(); + + yield hash.update(packHeader(count)); + + for await (const item of items) { + for (const chunk of packFrame(item)) { + yield hash.update(chunk); + } + } + + yield packHash(hash.digest()); +} + +function packHeader(length: number) { + return Uint8Array.from([ + 0x50, + 0x41, + 0x43, + 0x4b, // PACK + 0, + 0, + 0, + 2, // version 2 + length >> 24, // Num of objects + (length >> 16) & 0xff, + (length >> 8) & 0xff, + length & 0xff, + ]); +} + +function* packFrame(item: Entry) { + yield packFrameHeader(item.type, item.body.length); + + if (item.type === Type.ofsDelta) { + yield packOfsDelta(item.ref); + } else if (item.type === Type.refDelta) { + yield packHash(item.ref); + } + + yield pako.deflate(item.body); +} + +// write TYPE_AND_BASE128_SIZE +function packFrameHeader(type: number, length: number) { + const head = [(type << 4) | (length & 0xf)]; + let i = 0; + length >>= 4; + while (length) { + head[i++] |= 0x80; + head[i] = length & 0x7f; + length >>= 7; + } + return new Uint8Array(head); +} + +// write BIG_ENDIAN_MODIFIED_BASE_128_NUMBER +function packOfsDelta(ref: number) { + let offset = ref; + // Calculate how many digits we need in base 128 + let i = Math.floor(Math.log(offset) / Math.log(0x80)); + const head = new Uint8Array(i + 1); + // Write the last digit + head[i] = offset & 0x7f; + // Then write the rest + while ((offset >>= 7)) { + head[--i] = 0x80 | (--offset & 0x7f); + } + return head; +} diff --git a/packages/packfile/src/index.ts b/packages/packfile/src/index.ts new file mode 100644 index 0000000..35302a1 --- /dev/null +++ b/packages/packfile/src/index.ts @@ -0,0 +1,5 @@ +export {RawObject, Progress} from './types'; + +export {default as unpack} from './unpack'; + +export {default as pack, HashBlob} from './pack'; diff --git a/packages/packfile/src/normalize-entries.ts b/packages/packfile/src/normalize-entries.ts new file mode 100644 index 0000000..ed926be --- /dev/null +++ b/packages/packfile/src/normalize-entries.ts @@ -0,0 +1,72 @@ +import {concat, encode, sha1} from '@rollingversions/git-core'; + +import { + Type, + Entry, + NormalEntry, + OfsDeltaEntry, + RefDeltaEntry, + RawObject, + Progress, +} from './types'; +import applyDelta from './apply-delta'; + +export default async function* normalizeEntries( + entries: AsyncIterableIterator, + progress?: Progress, +): AsyncIterableIterator { + const references = new Map(); + const offsets = new Map(); + let deltas = 0; + + for await (let entry of entries) { + if (entry.type === Type.ofsDelta || entry.type === Type.refDelta) { + const base = getBase(entry); + const body = applyDelta(entry.body, base.body); + deltas++; + entry = { + type: base.type, + body, + offset: entry.offset, + }; + } + + const type = Type[entry.type]; + const body = encodeRaw(type, entry.body); + const hash = sha1(body); + + references.set(hash, entry); + offsets.set(entry.offset, entry); + yield { + type, + body, + hash, + }; + } + + if (progress) + progress(`Resolving deltas: 100% (${deltas}/${deltas}), done.\n`); + + function getBase(entry: OfsDeltaEntry | RefDeltaEntry) { + if (entry.type === Type.ofsDelta) { + const base = offsets.get(entry.offset - entry.ref); + if (!base) + throw new Error( + `Cannot find base of ofs-delta ${entry.offset} - ${entry.ref}`, + ); + return base; + } else { + const base = references.get(entry.ref); + if (!base) + throw new Error( + `Cannot find base of ref-delta ${entry.offset}: ${entry.ref}`, + ); + //ToDo: thinpack lookup + return base; + } + } +} + +export function encodeRaw(type: string, bytes: Uint8Array) { + return concat(encode(`${type} ${bytes.length}\0`), bytes); +} diff --git a/packages/packfile/src/pack.ts b/packages/packfile/src/pack.ts new file mode 100644 index 0000000..0f862c9 --- /dev/null +++ b/packages/packfile/src/pack.ts @@ -0,0 +1,76 @@ +import {decode} from '@rollingversions/git-core'; + +import composePackfile from './compose-packfile'; +import {Type, NormalEntry, RawObject} from './types'; +import pipe from './pipe'; + +export type HashBlob = [string, Uint8Array]; + +export default async function* pack( + objects: AsyncIterableIterator, + count: number, +): AsyncIterableIterator { + yield* pipe(objects) + .pipe(toRawObject) + .pipe(toEntry) + .pipe(sortByType) + .pipe((x) => composePackfile(x, count)); +} + +async function* toRawObject( + objects: AsyncIterableIterator, +): AsyncIterableIterator { + for await (const [hash, body] of objects) { + const space = body.indexOf(0x20); + const nil = body.indexOf(0x00, space); + yield { + body: body.subarray(nil + 1), + type: decode(body, 0, space), + hash: hash, + }; + } +} + +async function* toEntry( + objects: AsyncIterableIterator, +): AsyncIterableIterator { + for await (const object of objects) { + yield { + body: object.body, + type: + object.type === 'commit' + ? Type.commit + : object.type === 'tree' + ? Type.tree + : Type.blob, + offset: 0, + }; + } +} + +async function* sortByType(entries: AsyncIterableIterator) { + const commits = []; + const trees = []; + const blobs = []; + const others = []; + for await (const entry of entries) { + switch (entry.type) { + case Type.commit: + commits.push(entry); + break; + case Type.tree: + trees.push(entry); + break; + case Type.blob: + blobs.push(entry); + break; + default: + others.push(entry); + break; + } + } + yield* commits; + yield* trees; + yield* blobs; + yield* others; +} diff --git a/packages/packfile/src/parse-packfile.ts b/packages/packfile/src/parse-packfile.ts new file mode 100644 index 0000000..738f6f5 --- /dev/null +++ b/packages/packfile/src/parse-packfile.ts @@ -0,0 +1,304 @@ +import * as pako from 'pako'; +import {AsyncBuffer, unpackHash} from '@rollingversions/git-core'; +import DigestableAsyncBuffer from './DigestableAsyncBuffer'; + +import {Type, Entry, Progress} from './types'; + +type $State = T & { + readonly state: S; +}; + +interface StartState { + readonly buffer: DigestableAsyncBuffer; +} + +interface PackState extends StartState {} + +interface VersionState extends PackState { + readonly version: number; +} + +interface EntriesState extends VersionState { + readonly entryCount: number; + readonly entryIndex: number; +} + +interface HeaderState extends EntriesState { + readonly type: Type.blob | Type.commit | Type.tag | Type.tree; + readonly offset: number; + readonly size: number; +} + +interface DeltaHeaderState extends EntriesState { + readonly offset: number; + readonly size: number; +} + +interface OfsDeltaState extends DeltaHeaderState { + readonly type: Type.ofsDelta; + readonly ref: number; +} + +interface RefDeltaState extends DeltaHeaderState { + readonly type: Type.refDelta; + readonly ref: string; +} + +interface ChecksumState extends EntriesState { + readonly checksum: string; +} + +interface EntryState extends EntriesState { + readonly entry: Entry; +} + +type State = + | $State<'start', StartState> + | $State<'pack', PackState> + | $State<'version', VersionState> + | $State<'entries', EntriesState> + | $State<'header', HeaderState> + | $State<'ofs-header', DeltaHeaderState> + | $State<'ref-header', DeltaHeaderState> + | $State<'ofs-delta', OfsDeltaState> + | $State<'ref-delta', RefDeltaState> + | $State<'entry', EntryState> + | $State<'done', ChecksumState>; + +export default async function* parsePackfile( + chunks: AsyncIterableIterator, + progress?: Progress, +): AsyncIterableIterator { + let state: State = { + state: 'start', + buffer: new DigestableAsyncBuffer(chunks), + }; + + do { + state = await $step(state, progress); + if (state.state === 'entry') { + yield state.entry; + } + } while (state.state !== 'done'); + state.buffer.complete(); +} + +async function $step(state: State, progress?: Progress) { + switch (state.state) { + case 'start': + return $pack(state); + case 'pack': + return $version(state); + case 'version': + return $entries(state); + case 'entries': + return $header(state); + case 'ofs-header': + return $ofsDelta(state); + case 'ref-header': + return $refDelta(state); + case 'header': + case 'ofs-delta': + case 'ref-delta': + return $body(state); + case 'entry': + if (progress) progress(report(state)); + if (state.entryCount > state.entryIndex) { + return $header(state); + } else { + return $checksum(state); + } + default: + throw new Error(`Unknown state ${state}`); + } +} + +// The first four bytes in a packfile are the bytes 'PACK' +async function $pack(state: StartState): Promise { + if ((await state.buffer.nextInt32()) === 0x5041434b) + return { + ...state, + state: 'pack', + }; + else throw new Error('Invalid packfile header'); +} + +// The version is stored as an unsigned 32 integer in network byte order. +// It must be version 2 or 3. +async function $version(state: PackState): Promise { + const version = await state.buffer.nextInt32(); + if (version === 2 || version === 3) + return { + ...state, + state: 'version', + version, + }; + else throw new Error('Invalid version number ' + version); +} + +// The number of objects in this packfile is also stored as an unsigned 32 bit int. +async function $entries(state: VersionState): Promise { + const entryCount = await state.buffer.nextInt32(); + return { + ...state, + state: 'entries', + entryCount, + entryIndex: 0, + }; +} + +// n-byte type and length (3-bit type, (n-1)*7+4-bit length) +// CTTTSSSS +// C is continue bit, TTT is type, S+ is length +// Second state in the same header parsing. +// CSSSSSSS* +async function $header(state: EntriesState): Promise { + const offset = state.buffer.pos; + let byte = await state.buffer.next(); + const type = (byte >> 4) & 0x7; + let size = byte & 0xf; + let left = 4; + while (byte & 0x80) { + byte = await state.buffer.next(); + size |= (byte & 0x7f) << left; + left += 7; + } + if (type === 6) { + return { + ...state, + state: 'ofs-header', + offset, + size, + }; + } else if (type === 7) { + return { + ...state, + state: 'ref-header', + offset, + size, + }; + } else { + return { + ...state, + state: 'header', + type, + offset, + size, + }; + } +} + +// Big-endian modified base 128 number encoded ref offset +async function $ofsDelta(state: DeltaHeaderState): Promise { + return { + ...state, + state: 'ofs-delta', + type: Type.ofsDelta, + ref: await varLen(state.buffer), + }; +} + +// 20 byte raw sha1 hash for ref +async function $refDelta(state: DeltaHeaderState): Promise { + return { + ...state, + state: 'ref-delta', + type: Type.refDelta, + ref: unpackHash(await state.buffer.next(20)), + }; +} + +// Feed the deflated code to the inflate engine +async function $body( + state: HeaderState | OfsDeltaState | RefDeltaState, +): Promise { + const inf = new pako.Inflate(); + do { + inf.push(await state.buffer.chunk()); + } while (inf.err === 0 && inf.result === undefined); + state.buffer.rewind((inf as any).strm.avail_in); + if (inf.err != 0) throw new Error(`Inflate error ${inf.err} ${inf.msg}`); + const data = inf.result as Uint8Array; + if (data.length !== state.size) + throw new Error( + `Length mismatch, expected ${state.size} got ${data.length}`, + ); + + return { + ...state, + state: 'entry', + entry: entry(state, data), + entryIndex: state.entryIndex + 1, + }; +} + +// 20 byte checksum +async function $checksum(state: EntriesState): Promise { + const actual = state.buffer.digest(); + const checksum = unpackHash(await state.buffer.next(20)); + if (checksum !== actual) + throw new Error( + `Checksum mismatch: actual ${actual} != expected ${checksum}`, + ); + return { + ...state, + state: 'done', + checksum, + }; +} + +function entry( + state: HeaderState | RefDeltaState | OfsDeltaState, + body: Uint8Array, +): Entry { + if (state.type == Type.ofsDelta) { + return { + type: Type.ofsDelta, + ref: state.ref, + body, + offset: state.offset, + }; + } else if (state.type == Type.refDelta) { + return { + type: Type.refDelta, + ref: state.ref, + body, + offset: state.offset, + }; + } else { + return { + type: state.type, + body, + offset: state.offset, + }; + } +} + +async function varLen(buffer: AsyncBuffer) { + let byte = await buffer.next(); + let ref = byte & 0x7f; + while (byte & 0x80) { + byte = await buffer.next(); + ref = ((ref + 1) << 7) | (byte & 0x7f); + } + return ref; +} + +const suffixes = ['Bytes', 'KiB', 'MiB', 'GiB']; +function report({entryCount: total, entryIndex: pos, buffer}: EntryState) { + const percent = ((pos / total) * 100) | 0; + let size = buffer.pos; + let suf = 0; + for (; size > 1024; suf++) { + size /= 1024; + } + if (pos === total) { + return `Receiving objects: ${percent}% (${pos}/${total}), ${size.toFixed( + 2, + )} ${suffixes[suf]}, done.\n`; + } else { + return `Receiving objects: ${percent}% (${pos}/${total}), ${size.toFixed( + 2, + )} ${suffixes[suf]}\r`; + } +} diff --git a/packages/packfile/src/pipe.ts b/packages/packfile/src/pipe.ts new file mode 100644 index 0000000..ca9bb41 --- /dev/null +++ b/packages/packfile/src/pipe.ts @@ -0,0 +1,110 @@ +export default function pipe( + input: AsyncIterableIterator | PipableAsyncIterableIterator, +): PipableAsyncIterableIterator; +export default function pipe( + input: Iterable | IterableIterator | PipableIterableIterator, +): PipableIterableIterator; +export default function pipe( + input: + | Iterable + | IterableIterator + | PipableIterableIterator + | AsyncIterableIterator + | PipableAsyncIterableIterator, +): PipableIterableIterator | PipableAsyncIterableIterator { + if (isPipable(input)) { + return input; + } + + if (isAsync(input)) { + return { + [Symbol.asyncIterator]() { + return input[Symbol.asyncIterator](); + }, + next(value?: any) { + return input.next(value); + }, + return: input.return + ? (value?: any) => (input.return as any)(value) + : undefined, + throw: input.throw ? (e?: any) => (input.throw as any)(e) : undefined, + pipe( + next: ( + iterable: AsyncIterableIterator, + ) => AsyncIterableIterator, + ) { + return pipe(next(input)); + }, + then(func: (iterable: AsyncIterableIterator) => TOut): TOut { + return func(input); + }, + }; + } + + if (isIterator(input)) { + return { + [Symbol.iterator]() { + return input[Symbol.iterator](); + }, + next(value?: any) { + return input.next(value); + }, + return: input.return + ? (value?: any) => (input.return as any)(value) + : undefined, + throw: input.throw ? (e?: any) => (input.throw as any)(e) : undefined, + pipe( + next: (iterable: IterableIterator) => IterableIterator, + ) { + return pipe(next(input)); + }, + map(func: (iterable: IterableIterator) => TOut) { + return func(input); + }, + }; + } + + return pipe(toIterableIterator(input)); +} + +function* toIterableIterator(items: Iterable): IterableIterator { + yield* items; +} + +export interface PipableIterableIterator extends IterableIterator { + pipe( + next: (iterable: IterableIterator) => IterableIterator, + ): PipableIterableIterator; + map(func: (iterable: IterableIterator) => TOut): TOut; +} + +export interface PipableAsyncIterableIterator + extends AsyncIterableIterator { + pipe( + next: (iterable: AsyncIterableIterator) => AsyncIterableIterator, + ): PipableAsyncIterableIterator; + then(func: (iterable: AsyncIterableIterator) => TOut): TOut; +} + +function isPipable( + input: + | Iterable + | IterableIterator + | PipableIterableIterator + | AsyncIterableIterator + | PipableAsyncIterableIterator, +): input is PipableIterableIterator | PipableAsyncIterableIterator { + return 'pipe' in input; +} + +function isAsync( + input: Iterable | IterableIterator | AsyncIterableIterator, +): input is AsyncIterableIterator { + return Symbol.asyncIterator in input; +} + +function isIterator( + input: IterableIterator | Iterable, +): input is IterableIterator { + return 'next' in input; +} diff --git a/packages/packfile/src/types.ts b/packages/packfile/src/types.ts new file mode 100644 index 0000000..35ab9d7 --- /dev/null +++ b/packages/packfile/src/types.ts @@ -0,0 +1,36 @@ +export enum Type { + commit = 1, + tree = 2, + blob = 3, + tag = 4, + ofsDelta = 6, + refDelta = 7, +} + +export interface AbstractEntry { + readonly offset: number; + readonly body: Uint8Array; +} + +export interface NormalEntry extends AbstractEntry { + readonly type: Type.blob | Type.commit | Type.tag | Type.tree; +} +export interface RefDeltaEntry extends AbstractEntry { + readonly type: Type.refDelta; + readonly ref: string; +} + +export interface OfsDeltaEntry extends AbstractEntry { + readonly type: Type.ofsDelta; + readonly ref: number; +} + +export type Entry = NormalEntry | RefDeltaEntry | OfsDeltaEntry; + +export interface RawObject { + readonly type: string; + readonly hash: string; + readonly body: Uint8Array; +} + +export type Progress = (message: string) => void; diff --git a/packages/packfile/src/unpack.ts b/packages/packfile/src/unpack.ts new file mode 100644 index 0000000..68a7f2b --- /dev/null +++ b/packages/packfile/src/unpack.ts @@ -0,0 +1,16 @@ +import {RawObject, Progress} from './types'; + +import parsePackfile from './parse-packfile'; +import normalizeEntries from './normalize-entries'; +import pipe from './pipe'; + +export {RawObject}; + +export default async function* unpack( + chunks: AsyncIterableIterator, + progress?: Progress, +): AsyncIterableIterator { + yield* pipe(chunks) + .pipe((c) => parsePackfile(c, progress)) + .pipe((c) => normalizeEntries(c, progress)); +} diff --git a/packages/packfile/tsconfig.json b/packages/packfile/tsconfig.json new file mode 100644 index 0000000..4c2bc78 --- /dev/null +++ b/packages/packfile/tsconfig.json @@ -0,0 +1,16 @@ +{ + "extends": "@forbeslindesay/tsconfig", + "compilerOptions": { + "outDir": "lib", + "module": "ES2020", + "incremental": true, + "composite": true, + "rootDir": "src", + "tsBuildInfoFile": "lib/.tsbuildinfo", + "lib": ["DOM", "ES2020"] + }, + "include": ["src"], + "references": [ + {"path": "../core"}, + ], +} diff --git a/packages/protocol/package.json b/packages/protocol/package.json index 322159f..c447ff0 100644 --- a/packages/protocol/package.json +++ b/packages/protocol/package.json @@ -19,8 +19,8 @@ "build": "tsc" }, "dependencies": { - "@es-git/core": "^0.10.0", - "@es-git/packfile": "^0.10.0", + "@rollingversions/git-core": "^0.0.0", + "@rollingversions/git-packfile": "^0.0.0", "@rollingversions/git-streams": "^0.0.0" }, "devDependencies": {}, diff --git a/packages/protocol/src/FetchCommand.ts b/packages/protocol/src/FetchCommand.ts index b6f50a3..a868d92 100644 --- a/packages/protocol/src/FetchCommand.ts +++ b/packages/protocol/src/FetchCommand.ts @@ -1,5 +1,5 @@ -import {AsyncBuffer, decode, Type} from '@es-git/core'; -import {unpack} from '@es-git/packfile'; +import {AsyncBuffer, decode, Type} from '@rollingversions/git-core'; +import {unpack} from '@rollingversions/git-packfile'; import { mergeAsyncIterator, splitAsyncIterator, diff --git a/packages/protocol/src/InitialRequest.ts b/packages/protocol/src/InitialRequest.ts index 636defe..0aa8d29 100644 --- a/packages/protocol/src/InitialRequest.ts +++ b/packages/protocol/src/InitialRequest.ts @@ -8,6 +8,7 @@ export const parseInitialResponse = packetLineParser( let gotVersion = false; let gotVersionAtLeastOnce = false; for await (const packet of packets) { + console.log('packet =', packet); if (packet === SpecialPacketLine.FlushPacket) { isStart = true; gotVersion = false; diff --git a/packages/protocol/src/PktLines.test.ts b/packages/protocol/src/PktLines.test.ts index 717fbd5..330f8ca 100644 --- a/packages/protocol/src/PktLines.test.ts +++ b/packages/protocol/src/PktLines.test.ts @@ -1,4 +1,4 @@ -import {decode, encode} from '@es-git/core'; +import {decode, encode} from '@rollingversions/git-core'; import { printPktLine, parsePktLines, diff --git a/packages/protocol/src/PktLines.ts b/packages/protocol/src/PktLines.ts index 95187d5..6177af3 100644 --- a/packages/protocol/src/PktLines.ts +++ b/packages/protocol/src/PktLines.ts @@ -6,7 +6,7 @@ import { concat, encode, decode, -} from '@es-git/core'; +} from '@rollingversions/git-core'; export enum SpecialPacketLine { /** diff --git a/packages/protocol/tsconfig.json b/packages/protocol/tsconfig.json index 22378ff..8d178d2 100644 --- a/packages/protocol/tsconfig.json +++ b/packages/protocol/tsconfig.json @@ -11,6 +11,8 @@ }, "include": ["src"], "references": [ + {"path": "../core"}, + {"path": "../packfile"}, {"path": "../streams"}, ], } diff --git a/scripts/test-pull.js b/scripts/test-pull.js new file mode 100644 index 0000000..eee02ef --- /dev/null +++ b/scripts/test-pull.js @@ -0,0 +1,123 @@ +const fs = require('fs'); +const {URL} = require('url'); +const {default: GitHubClient, auth} = require('@github-graph/api'); +const ask = require('interrogator'); +const git = require('../packages/http'); +const gitObj = require('../packages/objects'); + +function getAppClient({APP_ID, PRIVATE_KEY}) { + return new GitHubClient({ + auth: auth.createAppAuth({ + appId: APP_ID, + privateKey: PRIVATE_KEY, + }), + }); +} + +async function getAppTokenForRepo({owner, name}, {APP_ID, PRIVATE_KEY}) { + const installation = await getAppClient({ + APP_ID, + PRIVATE_KEY, + }).rest.apps.getRepoInstallation({ + owner, + repo: name, + }); + if (installation.status !== 200) { + throw new Error( + `Rolling Versions does not seem to be installed for ${owner}`, + ); + } + const installationId = installation.data.id; + const appAuth = auth.createAppAuth({ + appId: APP_ID, + privateKey: PRIVATE_KEY, + installationId, + }); + const authResult = await appAuth({type: `installation`, installationId}); + return authResult.token; +} + +async function getHttpHandler(repo, secrets) { + const accessToken = await getAppTokenForRepo(repo, secrets); + const headerValue = `Basic ${Buffer.from( + `x-access-token:${accessToken}`, + ).toString(`base64`)}`; + return { + ...git.DEFAULT_HTTP_HANDLER, + createHeaders(url) { + const headers = git.DEFAULT_HTTP_HANDLER.createHeaders(url); + + // https://docs.github.com/en/developers/apps/authenticating-with-github-apps#http-based-git-access-by-an-installation + // x-access-token: + headers.set('Authorization', headerValue); + + return headers; + }, + }; +} + +async function pullRepo() { + const APP_ID = fs.readFileSync(`secrets/app_id`, `utf8`); + const PRIVATE_KEY = fs.readFileSync(`secrets/private_key`, `utf8`); + const secrets = {APP_ID, PRIVATE_KEY}; + + const owner = process.argv[2] ?? (await ask.input(`owner`)); + const name = process.argv[3] ?? (await ask.input(`name`)); + const repo = {owner, name}; + + const http = await getHttpHandler(repo, secrets); + const repoURL = new URL(`https://github.com/${repo.owner}/${repo.name}.git`); + + console.warn(`git_init`, `Git init request ${repoURL.href}`); + const {capabilities: serverCapabilities} = await git.initialRequest(repoURL, { + http, + agent: 'rollingversions.com', + }); + + console.warn(`git_lsrefs`, `Git ls refs request ${repoURL.href}`); + const remoteRefs = await git.asyncIteratorToArray( + git.lsRefs( + repoURL, + { + // TODO: what do we need here? + // symrefs: true, + refPrefix: ['refs/heads/', 'refs/tags/', 'refs/pull/'], + }, + { + http, + agent: 'rollingversions.com', + serverCapabilities, + }, + ), + ); + for (const ref of remoteRefs) { + console.warn(`ref:`, ref); + } + + console.warn(`git_fetch_objects`, `Git fetch request ${repoURL.href}`); + for await (const entry of git.fetchObjects( + repoURL, + { + want: [...new Set(remoteRefs.map((ref) => ref.objectID))], + have: [], + filter: [git.treeDepth(0)], + }, + { + http, + agent: 'rollingversions.com', + serverCapabilities, + }, + )) { + if (entry.kind === git.FetchResponseEntryKind.Object) { + if (gitObj.objectIsCommit(entry.body)) { + const commit = gitObj.decodeObject(entry.body); + console.warn(`${entry.hash} ${commit.body.message}`); + } + } + } +} + +pullRepo().catch((ex) => { + console.error(ex.stack); + process.exit(1); +}); diff --git a/tsconfig.json b/tsconfig.json index 691b888..269519e 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -9,8 +9,10 @@ }, "files": [], "references": [ + {"path": "./packages/core"}, {"path": "./packages/http"}, {"path": "./packages/objects"}, + {"path": "./packages/packfile"}, {"path": "./packages/protocol"}, {"path": "./packages/streams"}, ] diff --git a/yarn.lock b/yarn.lock index 1538774..711289f 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2,6 +2,20 @@ # yarn lockfile v1 +"@authentication/lock-by-id@^0.0.2": + version "0.0.2" + resolved "https://registry.yarnpkg.com/@authentication/lock-by-id/-/lock-by-id-0.0.2.tgz#4be3d26e4bb21a80811a77871925d262a073dd9c" + integrity sha512-GB+8xP4PcWVTlSzB5hCb13IplkxrG9T/TEqkMXxTUesK0aj8Nl7ZxBl1iqI2MWokt26T/JbuSFk/KvYR2+cAXw== + +"@authentication/rate-limit@^0.0.7": + version "0.0.7" + resolved "https://registry.yarnpkg.com/@authentication/rate-limit/-/rate-limit-0.0.7.tgz#a152f7a7d7c7be23907c5215d83bde8a582d72ee" + integrity sha512-uonLdxfQjqJMWTnoFcSMDlkt5tmfPYKVQU26hcDeIiwSQw2p7XU1gpnbxNDUyEPDgYEBeMKLInhD+6HnVdvvYQ== + dependencies: + "@authentication/lock-by-id" "^0.0.2" + "@types/ms" "^0.7.30" + ms "^2.1.1" + "@babel/code-frame@^7.0.0", "@babel/code-frame@^7.10.4", "@babel/code-frame@^7.12.11": version "7.12.11" resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.12.11.tgz#f4ad435aa263db935b8f10f2c552d23fb716a63f" @@ -285,32 +299,25 @@ exec-sh "^0.3.2" minimist "^1.2.0" -"@es-git/core@^0.10.0": - version "0.10.0" - resolved "https://registry.yarnpkg.com/@es-git/core/-/core-0.10.0.tgz#6c70a8ad95b7b8715e587c42a1da9b44b4b34f41" - integrity sha512-evBpDnjrJXci6TmQvpnx/sTUHCQEVikOreWxmBe+HdFZA5mHHbam5uh5egOiLyCEmJtE4MDiV91UuC0rTC1OEA== - dependencies: - "@es-git/mix" "^0.10.0" - text-encoding-utf-8 "^1.0.2" - -"@es-git/mix@^0.10.0": - version "0.10.0" - resolved "https://registry.yarnpkg.com/@es-git/mix/-/mix-0.10.0.tgz#d260c0fcb1ad63abca28f9d82f8a49cce2898283" - integrity sha512-306y/wg20d2V7i0k4HASvmn0W4O8JvI2X9Wx67VjEGs/xgFaeo7mnc3gG9GvXdLxv0QGQ1CYtveZF8QTYcS4jg== - -"@es-git/packfile@^0.10.0": - version "0.10.0" - resolved "https://registry.yarnpkg.com/@es-git/packfile/-/packfile-0.10.0.tgz#c5ac5673012ea810305581bf9f4648792c2356fa" - integrity sha512-Sk4irbhKP32K5QGN/cykpvisNCWpzHIU1sF+SKBitzfL6qmpSzuIfFbw/AXtjQkkocWcb5W7NWHi7LeKo2RVpw== - dependencies: - "@es-git/core" "^0.10.0" - pako "^1.0.5" - "@forbeslindesay/tsconfig@^2.0.0": version "2.0.0" resolved "https://registry.yarnpkg.com/@forbeslindesay/tsconfig/-/tsconfig-2.0.0.tgz#71a8a92afb366ea7ca05fe46e68bc033060c2e2d" integrity sha512-SqkFDsM1vgB5iXCjJKnnvYwIlQZhLfGjKQfmwp3PZjvqoDVbng76iQvppJAG1pX2nSmkPz8Z1rmEylXop/Ma8A== +"@github-graph/api@^2.2.1": + version "2.2.1" + resolved "https://registry.yarnpkg.com/@github-graph/api/-/api-2.2.1.tgz#13b07587a8d0c6128c6d7e3c41bc12ad996a11fb" + integrity sha512-pdVF09SDLePrBCKSOdVPsV0Bb9l1GxHwjiD+skNH7vC6cki3dcPq/oA73zQc1xC6t0HT+125BwS2fEvdBkUY4A== + dependencies: + "@authentication/rate-limit" "^0.0.7" + "@octokit/auth" "^2.0.0" + "@octokit/request" "^5.3.2" + "@octokit/rest" "^17.1.0" + graphql "^14.6.0" + graphql-merge-unmerge "^4.0.0" + graphql-tag "^2.10.3" + universal-user-agent "^5.0.0" + "@istanbuljs/load-nyc-config@^1.0.0": version "1.1.0" resolved "https://registry.yarnpkg.com/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz#fd3db1d59ecf7cf121e80650bb86712f9b55eced" @@ -517,6 +524,177 @@ "@types/yargs" "^15.0.0" chalk "^4.0.0" +"@octokit/auth-action@^1.1.0": + version "1.3.3" + resolved "https://registry.yarnpkg.com/@octokit/auth-action/-/auth-action-1.3.3.tgz#20004fbf0b4a7012f4f7fc2c54d263749239cd5f" + integrity sha512-8v4c/pw6HTxsF7pCgJoox/q4KKov4zkgLxEGGqLOZPSZaHf1LqdLlj5m5x5c1bKNn38uQXNvJKEnKX1qJlGeQQ== + dependencies: + "@octokit/auth-token" "^2.4.0" + "@octokit/types" "^6.0.3" + +"@octokit/auth-app@^2.4.0": + version "2.11.0" + resolved "https://registry.yarnpkg.com/@octokit/auth-app/-/auth-app-2.11.0.tgz#7dce17adf3b30a722aea5bf239396418151034eb" + integrity sha512-tC0BjqyTEjReIBHogOjLjF3rc2n4xwjZcpOaUUhybDnqkrp7Gxj5n91aGUcIFgJ3MDYf+f3XZehQd2B4ijG+4w== + dependencies: + "@octokit/request" "^5.4.11" + "@octokit/request-error" "^2.0.0" + "@octokit/types" "^6.0.3" + "@types/lru-cache" "^5.1.0" + deprecation "^2.3.1" + lru-cache "^6.0.0" + universal-github-app-jwt "^1.0.1" + universal-user-agent "^6.0.0" + +"@octokit/auth-basic@^1.3.0": + version "1.4.8" + resolved "https://registry.yarnpkg.com/@octokit/auth-basic/-/auth-basic-1.4.8.tgz#8609c64f49666f3b641e045ae4cafb24f78d93e0" + integrity sha512-k3nsQBmAmnTGj6Z9S78JUtIGqlHEKwN+/AUBMs34/4+lQsG5gs3k5UqqdJEr1a2s3FXiyRz+monY46iirHR8Yw== + dependencies: + "@octokit/request" "^5.4.2" + "@octokit/request-error" "^2.0.0" + "@octokit/types" "^6.0.0" + "@types/btoa-lite" "^1.0.0" + btoa-lite "^1.0.0" + universal-user-agent "^6.0.0" + +"@octokit/auth-oauth-app@^3.0.0": + version "3.1.1" + resolved "https://registry.yarnpkg.com/@octokit/auth-oauth-app/-/auth-oauth-app-3.1.1.tgz#50a7064bbeb772d3b2ec25e2d638d69e68ae2e42" + integrity sha512-ClH/fR5R/GvFQTIbO175DGPVqH7FFKrwmPl8r+ZZtqHzv8D9DaR+qpt10KvnxiOOMElOncKY+Z/MayZ4R8rz/Q== + dependencies: + "@octokit/request" "^5.3.0" + "@octokit/request-error" "^2.0.0" + "@octokit/types" "^6.0.3" + "@types/btoa-lite" "^1.0.0" + btoa-lite "^1.0.0" + universal-user-agent "^6.0.0" + +"@octokit/auth-token@^2.4.0": + version "2.4.5" + resolved "https://registry.yarnpkg.com/@octokit/auth-token/-/auth-token-2.4.5.tgz#568ccfb8cb46f36441fac094ce34f7a875b197f3" + integrity sha512-BpGYsPgJt05M7/L/5FoE1PiAbdxXFZkX/3kDYcsvd1v6UhlnE5e96dTDr0ezX/EFwciQxf3cNV0loipsURU+WA== + dependencies: + "@octokit/types" "^6.0.3" + +"@octokit/auth@^2.0.0": + version "2.0.1" + resolved "https://registry.yarnpkg.com/@octokit/auth/-/auth-2.0.1.tgz#d8e2d39692ed2225b6f219e4d59ebc8bbc5895dd" + integrity sha512-EMjsfoS3IjVzmI2Hag3A4YJmVWnaOmVMXiDDORujP3/1HQydJAAFBqtNpneiKvsiWxg1nxfb250YIAHGYtal6g== + dependencies: + "@octokit/auth-action" "^1.1.0" + "@octokit/auth-app" "^2.4.0" + "@octokit/auth-basic" "^1.3.0" + "@octokit/auth-oauth-app" "^3.0.0" + "@octokit/auth-token" "^2.4.0" + +"@octokit/core@^2.4.3": + version "2.5.4" + resolved "https://registry.yarnpkg.com/@octokit/core/-/core-2.5.4.tgz#f7fbf8e4f86c5cc2497a8887ba2561ec8d358054" + integrity sha512-HCp8yKQfTITYK+Nd09MHzAlP1v3Ii/oCohv0/TW9rhSLvzb98BOVs2QmVYuloE6a3l6LsfyGIwb6Pc4ycgWlIQ== + dependencies: + "@octokit/auth-token" "^2.4.0" + "@octokit/graphql" "^4.3.1" + "@octokit/request" "^5.4.0" + "@octokit/types" "^5.0.0" + before-after-hook "^2.1.0" + universal-user-agent "^5.0.0" + +"@octokit/endpoint@^6.0.1": + version "6.0.12" + resolved "https://registry.yarnpkg.com/@octokit/endpoint/-/endpoint-6.0.12.tgz#3b4d47a4b0e79b1027fb8d75d4221928b2d05658" + integrity sha512-lF3puPwkQWGfkMClXb4k/eUT/nZKQfxinRWJrdZaJO85Dqwo/G0yOC434Jr2ojwafWJMYqFGFa5ms4jJUgujdA== + dependencies: + "@octokit/types" "^6.0.3" + is-plain-object "^5.0.0" + universal-user-agent "^6.0.0" + +"@octokit/graphql@^4.3.1": + version "4.6.4" + resolved "https://registry.yarnpkg.com/@octokit/graphql/-/graphql-4.6.4.tgz#0c3f5bed440822182e972317122acb65d311a5ed" + integrity sha512-SWTdXsVheRmlotWNjKzPOb6Js6tjSqA2a8z9+glDJng0Aqjzti8MEWOtuT8ZSu6wHnci7LZNuarE87+WJBG4vg== + dependencies: + "@octokit/request" "^5.6.0" + "@octokit/types" "^6.0.3" + universal-user-agent "^6.0.0" + +"@octokit/openapi-types@^9.5.0": + version "9.7.0" + resolved "https://registry.yarnpkg.com/@octokit/openapi-types/-/openapi-types-9.7.0.tgz#9897cdefd629cd88af67b8dbe2e5fb19c63426b2" + integrity sha512-TUJ16DJU8mekne6+KVcMV5g6g/rJlrnIKn7aALG9QrNpnEipFc1xjoarh0PKaAWf2Hf+HwthRKYt+9mCm5RsRg== + +"@octokit/plugin-paginate-rest@^2.2.0": + version "2.15.1" + resolved "https://registry.yarnpkg.com/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-2.15.1.tgz#264189dd3ce881c6c33758824aac05a4002e056a" + integrity sha512-47r52KkhQDkmvUKZqXzA1lKvcyJEfYh3TKAIe5+EzMeyDM3d+/s5v11i2gTk8/n6No6DPi3k5Ind6wtDbo/AEg== + dependencies: + "@octokit/types" "^6.24.0" + +"@octokit/plugin-request-log@^1.0.0": + version "1.0.4" + resolved "https://registry.yarnpkg.com/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz#5e50ed7083a613816b1e4a28aeec5fb7f1462e85" + integrity sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA== + +"@octokit/plugin-rest-endpoint-methods@3.17.0": + version "3.17.0" + resolved "https://registry.yarnpkg.com/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-3.17.0.tgz#d8ba04eb883849dd98666c55bf49d8c9fe7be055" + integrity sha512-NFV3vq7GgoO2TrkyBRUOwflkfTYkFKS0tLAPym7RNpkwLCttqShaEGjthOsPEEL+7LFcYv3mU24+F2yVd3npmg== + dependencies: + "@octokit/types" "^4.1.6" + deprecation "^2.3.1" + +"@octokit/request-error@^2.0.0", "@octokit/request-error@^2.1.0": + version "2.1.0" + resolved "https://registry.yarnpkg.com/@octokit/request-error/-/request-error-2.1.0.tgz#9e150357831bfc788d13a4fd4b1913d60c74d677" + integrity sha512-1VIvgXxs9WHSjicsRwq8PlR2LR2x6DwsJAaFgzdi0JfJoGSO8mYI/cHJQ+9FbN21aa+DrgNLnwObmyeSC8Rmpg== + dependencies: + "@octokit/types" "^6.0.3" + deprecation "^2.0.0" + once "^1.4.0" + +"@octokit/request@^5.3.0", "@octokit/request@^5.3.2", "@octokit/request@^5.4.0", "@octokit/request@^5.4.11", "@octokit/request@^5.4.2", "@octokit/request@^5.6.0": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@octokit/request/-/request-5.6.1.tgz#f97aff075c37ab1d427c49082fefeef0dba2d8ce" + integrity sha512-Ls2cfs1OfXaOKzkcxnqw5MR6drMA/zWX/LIS/p8Yjdz7QKTPQLMsB3R+OvoxE6XnXeXEE2X7xe4G4l4X0gRiKQ== + dependencies: + "@octokit/endpoint" "^6.0.1" + "@octokit/request-error" "^2.1.0" + "@octokit/types" "^6.16.1" + is-plain-object "^5.0.0" + node-fetch "^2.6.1" + universal-user-agent "^6.0.0" + +"@octokit/rest@^17.1.0": + version "17.11.2" + resolved "https://registry.yarnpkg.com/@octokit/rest/-/rest-17.11.2.tgz#f3dbd46f9f06361c646230fd0ef8598e59183ead" + integrity sha512-4jTmn8WossTUaLfNDfXk4fVJgbz5JgZE8eCs4BvIb52lvIH8rpVMD1fgRCrHbSd6LRPE5JFZSfAEtszrOq3ZFQ== + dependencies: + "@octokit/core" "^2.4.3" + "@octokit/plugin-paginate-rest" "^2.2.0" + "@octokit/plugin-request-log" "^1.0.0" + "@octokit/plugin-rest-endpoint-methods" "3.17.0" + +"@octokit/types@^4.1.6": + version "4.1.10" + resolved "https://registry.yarnpkg.com/@octokit/types/-/types-4.1.10.tgz#e4029c11e2cc1335051775bc1600e7e740e4aca4" + integrity sha512-/wbFy1cUIE5eICcg0wTKGXMlKSbaAxEr00qaBXzscLXpqhcwgXeS6P8O0pkysBhRfyjkKjJaYrvR1ExMO5eOXQ== + dependencies: + "@types/node" ">= 8" + +"@octokit/types@^5.0.0": + version "5.5.0" + resolved "https://registry.yarnpkg.com/@octokit/types/-/types-5.5.0.tgz#e5f06e8db21246ca102aa28444cdb13ae17a139b" + integrity sha512-UZ1pErDue6bZNjYOotCNveTXArOMZQFG6hKJfOnGnulVCMcVVi7YIIuuR4WfBhjo7zgpmzn/BkPDnUXtNx+PcQ== + dependencies: + "@types/node" ">= 8" + +"@octokit/types@^6.0.0", "@octokit/types@^6.0.3", "@octokit/types@^6.16.1", "@octokit/types@^6.24.0": + version "6.25.0" + resolved "https://registry.yarnpkg.com/@octokit/types/-/types-6.25.0.tgz#c8e37e69dbe7ce55ed98ee63f75054e7e808bf1a" + integrity sha512-bNvyQKfngvAd/08COlYIN54nRgxskmejgywodizQNyiKoXmWRAjKup2/LYwm+T9V0gsKH6tuld1gM0PzmOiB4Q== + dependencies: + "@octokit/openapi-types" "^9.5.0" + "@rollup/plugin-commonjs@^17.0.0": version "17.0.0" resolved "https://registry.yarnpkg.com/@rollup/plugin-commonjs/-/plugin-commonjs-17.0.0.tgz#2ae2228354cf0fbba6cf9f06f30b2c66a974324c" @@ -605,6 +783,11 @@ dependencies: "@babel/types" "^7.3.0" +"@types/btoa-lite@^1.0.0": + version "1.0.0" + resolved "https://registry.yarnpkg.com/@types/btoa-lite/-/btoa-lite-1.0.0.tgz#e190a5a548e0b348adb0df9ac7fa5f1151c7cca4" + integrity sha512-wJsiX1tosQ+J5+bY5LrSahHxr2wT+uME5UDwdN1kg4frt40euqA+wzECkmq4t5QbveHiJepfdThgQrPw6KiSlg== + "@types/estree@*": version "0.0.45" resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.45.tgz#e9387572998e5ecdac221950dab3e8c3b16af884" @@ -622,6 +805,14 @@ dependencies: "@types/node" "*" +"@types/inquirer@^6.5.0": + version "6.5.0" + resolved "https://registry.yarnpkg.com/@types/inquirer/-/inquirer-6.5.0.tgz#b83b0bf30b88b8be7246d40e51d32fe9d10e09be" + integrity sha512-rjaYQ9b9y/VFGOpqBEXRavc3jh0a+e6evAbI31tMda8VlPaSy0AZJfXsvmIe3wklc7W6C3zCSfleuMXR7NOyXw== + dependencies: + "@types/through" "*" + rxjs "^6.4.0" + "@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0", "@types/istanbul-lib-coverage@^2.0.1": version "2.0.3" resolved "https://registry.yarnpkg.com/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.3.tgz#4ba8ddb720221f432e443bd5f9117fd22cfd4762" @@ -657,16 +848,43 @@ jest-diff "^25.2.1" pretty-format "^25.2.1" +"@types/jsonwebtoken@^8.3.3": + version "8.5.4" + resolved "https://registry.yarnpkg.com/@types/jsonwebtoken/-/jsonwebtoken-8.5.4.tgz#50ccaf0aa6f5d7b9956e70fe323b76e582991913" + integrity sha512-4L8msWK31oXwdtC81RmRBAULd0ShnAHjBuKT9MRQpjP0piNrZdXyTRcKY9/UIfhGeKIT4PvF5amOOUbbT/9Wpg== + dependencies: + "@types/node" "*" + +"@types/lru-cache@^5.1.0": + version "5.1.1" + resolved "https://registry.yarnpkg.com/@types/lru-cache/-/lru-cache-5.1.1.tgz#c48c2e27b65d2a153b19bfc1a317e30872e01eef" + integrity sha512-ssE3Vlrys7sdIzs5LOxCzTVMsU7i9oa/IaW92wF32JFb3CVczqOkru2xspuKczHEbG3nvmPY7IFqVmGGHdNbYw== + +"@types/ms@^0.7.30": + version "0.7.31" + resolved "https://registry.yarnpkg.com/@types/ms/-/ms-0.7.31.tgz#31b7ca6407128a3d2bbc27fe2d21b345397f6197" + integrity sha512-iiUgKzV9AuaEkZqkOLDIvlQiL6ltuZd9tGcW3gwpnX8JbuiuhFlEGmmFXEXkN50Cvq7Os88IY2v0dkDqXYWVgA== + "@types/node@*": version "14.14.17" resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.17.tgz#29fab92f3986c0e379968ad3c2043683d8020dbb" integrity sha512-G0lD1/7qD60TJ/mZmhog76k7NcpLWkPVGgzkRy3CTlnFu4LUQh5v2Wa661z6vnXmD8EQrnALUyf0VRtrACYztw== +"@types/node@>= 8": + version "16.6.2" + resolved "https://registry.yarnpkg.com/@types/node/-/node-16.6.2.tgz#331b7b9f8621c638284787c5559423822fdffc50" + integrity sha512-LSw8TZt12ZudbpHc6EkIyDM3nHVWKYrAvGy6EAJfNfjusbwnThqjqxUKKRwuV3iWYeW/LYMzNgaq3MaLffQ2xA== + "@types/normalize-package-data@^2.4.0": version "2.4.0" resolved "https://registry.yarnpkg.com/@types/normalize-package-data/-/normalize-package-data-2.4.0.tgz#e486d0d97396d79beedd0a6e33f4534ff6b4973e" integrity sha512-f5j5b/Gf71L+dbqxIpQ4Z2WlmI/mPJ0fOkGGmFgtb6sAu97EPczzbS3/tJKxmcYDj55OX6ssqwDAWOHIYDRDGA== +"@types/pako@^1.0.2": + version "1.0.2" + resolved "https://registry.yarnpkg.com/@types/pako/-/pako-1.0.2.tgz#17c9b136877f33d9ecc8e73cd26944f1f6dd39a1" + integrity sha512-8UJl2MjkqqS6ncpLZqRZ5LmGiFBkbYxocD4e4jmBqGvfRG1RS23gKsBQbdtV9O9GvRyjFTiRHRByjSlKCLlmZw== + "@types/parse-json@^4.0.0": version "4.0.0" resolved "https://registry.yarnpkg.com/@types/parse-json/-/parse-json-4.0.0.tgz#2f8bb441434d163b35fb8ffdccd7138927ffb8c0" @@ -709,6 +927,13 @@ resolved "https://registry.yarnpkg.com/@types/stack-utils/-/stack-utils-2.0.0.tgz#7036640b4e21cc2f259ae826ce843d277dad8cff" integrity sha512-RJJrrySY7A8havqpGObOB4W92QXKJo63/jFLLgpvOtsGUqbQZ9Sbgl35KMm1DjC6j7AvmmU2bIno+3IyEaemaw== +"@types/through@*": + version "0.0.30" + resolved "https://registry.yarnpkg.com/@types/through/-/through-0.0.30.tgz#e0e42ce77e897bd6aead6f6ea62aeb135b8a3895" + integrity sha512-FvnCJljyxhPM3gkRgWmxmDZyAQSiBQQWLI0A0VFL0K7W1oRUrPJSqNO0NvTnLkBcotdlp3lKvaT0JrnyRDkzOg== + dependencies: + "@types/node" "*" + "@types/yargs-parser@*": version "20.2.0" resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-20.2.0.tgz#dd3e6699ba3237f0348cd085e4698780204842f9" @@ -988,6 +1213,11 @@ bcrypt-pbkdf@^1.0.0: dependencies: tweetnacl "^0.14.3" +before-after-hook@^2.1.0: + version "2.2.2" + resolved "https://registry.yarnpkg.com/before-after-hook/-/before-after-hook-2.2.2.tgz#a6e8ca41028d90ee2c24222f201c90956091613e" + integrity sha512-3pZEU3NT5BFUo/AD5ERPWOgQOCZITni6iavr5AUw5AUwQjMlI0kzu5btnyD39AF0gUEsDPwJT+oY1ORBJijPjQ== + bluebird@^3.5.1: version "3.7.2" resolved "https://registry.yarnpkg.com/bluebird/-/bluebird-3.7.2.tgz#9f229c15be272454ffa973ace0dbee79a1b0c36f" @@ -1036,6 +1266,16 @@ bser@2.1.1: dependencies: node-int64 "^0.4.0" +btoa-lite@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/btoa-lite/-/btoa-lite-1.0.0.tgz#337766da15801210fdd956c22e9c6891ab9d0337" + integrity sha1-M3dm2hWAEhD92VbCLpxokaudAzc= + +buffer-equal-constant-time@1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz#f8e71132f7ffe6e01a5c9697a4c6f3e48d5cc819" + integrity sha1-+OcRMvf/5uAaXJaXpMbz5I1cyBk= + buffer-from@^1.0.0: version "1.1.1" resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef" @@ -1123,6 +1363,11 @@ char-regex@^1.0.2: resolved "https://registry.yarnpkg.com/char-regex/-/char-regex-1.0.2.tgz#d744358226217f981ed58f479b1d6bcc29545dcf" integrity sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw== +chardet@^0.7.0: + version "0.7.0" + resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.7.0.tgz#90094849f0937f2eedc2425d0d28a9e5f0cbad9e" + integrity sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA== + ci-info@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-2.0.0.tgz#67a9e964be31a51e15e5010d58e6f12834002f46" @@ -1163,6 +1408,11 @@ cli-truncate@^2.1.0: slice-ansi "^3.0.0" string-width "^4.2.0" +cli-width@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-3.0.0.tgz#a2f48437a2caa9a22436e794bf071ec9e61cedf6" + integrity sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw== + cliui@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/cliui/-/cliui-5.0.0.tgz#deefcfdb2e800784aa34f46fa08e06851c7bbbc5" @@ -1434,6 +1684,11 @@ delayed-stream@~1.0.0: resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619" integrity sha1-3zrhmayt+31ECqrgsp4icrJOxhk= +deprecation@^2.0.0, deprecation@^2.3.1: + version "2.3.1" + resolved "https://registry.yarnpkg.com/deprecation/-/deprecation-2.3.1.tgz#6368cbdb40abf3373b525ac87e4a260c3a700919" + integrity sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ== + detect-newline@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-3.1.0.tgz#576f5dfc63ae1a192ff192d8ad3af6308991b651" @@ -1469,6 +1724,13 @@ ecc-jsbn@~0.1.1: jsbn "~0.1.0" safer-buffer "^2.1.0" +ecdsa-sig-formatter@1.0.11: + version "1.0.11" + resolved "https://registry.yarnpkg.com/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz#ae0f0fa2d85045ef14a817daa3ce9acd0489e5bf" + integrity sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ== + dependencies: + safe-buffer "^5.0.1" + emittery@^0.7.1: version "0.7.2" resolved "https://registry.yarnpkg.com/emittery/-/emittery-0.7.2.tgz#25595908e13af0f5674ab419396e2fb394cdfa82" @@ -1635,6 +1897,15 @@ extend@~3.0.2: resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa" integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g== +external-editor@^3.0.3: + version "3.1.0" + resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-3.1.0.tgz#cb03f740befae03ea4d283caed2741a83f335495" + integrity sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew== + dependencies: + chardet "^0.7.0" + iconv-lite "^0.4.24" + tmp "^0.0.33" + extglob@^2.0.4: version "2.0.4" resolved "https://registry.yarnpkg.com/extglob/-/extglob-2.0.4.tgz#ad00fe4dc612a9232e8718711dc5cb5ab0285543" @@ -1681,7 +1952,7 @@ fb-watchman@^2.0.0: dependencies: bser "2.1.1" -figures@^3.2.0: +figures@^3.0.0, figures@^3.2.0: version "3.2.0" resolved "https://registry.yarnpkg.com/figures/-/figures-3.2.0.tgz#625c18bd293c604dc4a8ddb2febf0c88341746af" integrity sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg== @@ -1773,6 +2044,11 @@ function-bind@^1.1.1: resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d" integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A== +generate-alphabetic-name@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/generate-alphabetic-name/-/generate-alphabetic-name-1.0.0.tgz#20390ac8dc8325caf9edb4b5643beb5385210e5a" + integrity sha512-/0o6Y1wZ2NgvF9Ev8mYEqi2TGQjyQM0Z9BuyQ8ulZ8ObkDV9inRDrLFTH9nFmMIRswDTavyWz60L4tRndgFyFA== + gensync@^1.0.0-beta.1: version "1.0.0-beta.2" resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0" @@ -1841,6 +2117,28 @@ graceful-fs@^4.2.4: resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.4.tgz#2256bde14d3632958c465ebc96dc467ca07a29fb" integrity sha512-WjKPNJF79dtJAVniUlGGWHYGz2jWxT6VhN/4m1NdkbZ2nOsEF+cI1Edgql5zCRhs/VsQYRvrXctxktVXZUkixw== +graphql-merge-unmerge@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/graphql-merge-unmerge/-/graphql-merge-unmerge-4.0.0.tgz#75665fba3824a8afe3ecff17bd28ad35d2439e97" + integrity sha512-nyr/15MZqRVg4fGlx399M5CNTvz5B/Lbwpk8caW8S6/T2mCg5zRvkWkyCyOyPqlVw4lsvkQ6Xq5YGxVUJnGyYA== + dependencies: + generate-alphabetic-name "^1.0.0" + graphql "^14.6.0" + +graphql-tag@^2.10.3: + version "2.12.5" + resolved "https://registry.yarnpkg.com/graphql-tag/-/graphql-tag-2.12.5.tgz#5cff974a67b417747d05c8d9f5f3cb4495d0db8f" + integrity sha512-5xNhP4063d16Pz3HBtKprutsPrmHZi5IdUGOWRxA2B6VF7BIRGOHZ5WQvDmJXZuPcBg7rYwaFxvQYjqkSdR3TQ== + dependencies: + tslib "^2.1.0" + +graphql@^14.6.0: + version "14.7.0" + resolved "https://registry.yarnpkg.com/graphql/-/graphql-14.7.0.tgz#7fa79a80a69be4a31c27dda824dc04dac2035a72" + integrity sha512-l0xWZpoPKpppFzMfvVyFmp9vLN7w/ZZJPefUicMCepfJeQ8sMcztloGYY9DfjVPo6tIUDzU5Hw3MUbIjj9AVVA== + dependencies: + iterall "^1.2.2" + growly@^1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/growly/-/growly-1.3.0.tgz#f10748cbe76af964b7c96c93c6bcc28af120c081" @@ -1962,7 +2260,7 @@ husky@^4.2.5: slash "^3.0.0" which-pm-runs "^1.0.0" -iconv-lite@0.4.24: +iconv-lite@0.4.24, iconv-lite@^0.4.24: version "0.4.24" resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b" integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA== @@ -2008,6 +2306,33 @@ inherits@2: resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== +inquirer@^7.0.0: + version "7.3.3" + resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-7.3.3.tgz#04d176b2af04afc157a83fd7c100e98ee0aad003" + integrity sha512-JG3eIAj5V9CwcGvuOmoo6LB9kbAYT8HXffUl6memuszlwDC/qvFAJw49XJ5NROSFNPxp3iQg1GqkFhaY/CR0IA== + dependencies: + ansi-escapes "^4.2.1" + chalk "^4.1.0" + cli-cursor "^3.1.0" + cli-width "^3.0.0" + external-editor "^3.0.3" + figures "^3.0.0" + lodash "^4.17.19" + mute-stream "0.0.8" + run-async "^2.4.0" + rxjs "^6.6.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + through "^2.3.6" + +interrogator@^1.1.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/interrogator/-/interrogator-1.1.0.tgz#b0708875bfe947598527acac94dba513f9afbca5" + integrity sha512-MEdV1w90ZrKlma/+Bf24teMrXgak+IbBIXd9MuFURnqh2zHdXywywFNupgOWaidk76UCRbICaoT9/x4mnV7iZg== + dependencies: + "@types/inquirer" "^6.5.0" + inquirer "^7.0.0" + ip-regex@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-2.1.0.tgz#fa78bf5d2e6913c911ce9f819ee5146bb6d844e9" @@ -2151,6 +2476,11 @@ is-plain-object@^2.0.3, is-plain-object@^2.0.4: dependencies: isobject "^3.0.1" +is-plain-object@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-5.0.0.tgz#4427f50ab3429e9025ea7d52e9043a9ef4159344" + integrity sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q== + is-potential-custom-element-name@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.0.tgz#0c52e54bcca391bb2c494b21e8626d7336c6e397" @@ -2263,6 +2593,11 @@ istanbul-reports@^3.0.2: html-escaper "^2.0.0" istanbul-lib-report "^3.0.0" +iterall@^1.2.2: + version "1.3.0" + resolved "https://registry.yarnpkg.com/iterall/-/iterall-1.3.0.tgz#afcb08492e2915cbd8a0884eb93a8c94d0d72fea" + integrity sha512-QZ9qOMdF+QLHxy1QIpUHUU1D5pS2CG2P69LF6L6CPjPYA/XMOmKV3PZpawHoAjHNyB0swdVTRxdYT4tbBbxqwg== + jest-changed-files@^24.9.0: version "24.9.0" resolved "https://registry.yarnpkg.com/jest-changed-files/-/jest-changed-files-24.9.0.tgz#08d8c15eb79a7fa3fc98269bc14b451ee82f8039" @@ -2742,6 +3077,22 @@ json5@^2.1.2: dependencies: minimist "^1.2.5" +jsonwebtoken@^8.5.1: + version "8.5.1" + resolved "https://registry.yarnpkg.com/jsonwebtoken/-/jsonwebtoken-8.5.1.tgz#00e71e0b8df54c2121a1f26137df2280673bcc0d" + integrity sha512-XjwVfRS6jTMsqYs0EsuJ4LGxXV14zQybNd4L2r0UvbVnSF9Af8x7p5MzbJ90Ioz/9TI41/hTCvznF/loiSzn8w== + dependencies: + jws "^3.2.2" + lodash.includes "^4.3.0" + lodash.isboolean "^3.0.3" + lodash.isinteger "^4.0.4" + lodash.isnumber "^3.0.3" + lodash.isplainobject "^4.0.6" + lodash.isstring "^4.0.1" + lodash.once "^4.0.0" + ms "^2.1.1" + semver "^5.6.0" + jsprim@^1.2.2: version "1.4.1" resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-1.4.1.tgz#313e66bc1e5cc06e438bc1b7499c2e5c56acb6a2" @@ -2752,6 +3103,23 @@ jsprim@^1.2.2: json-schema "0.2.3" verror "1.10.0" +jwa@^1.4.1: + version "1.4.1" + resolved "https://registry.yarnpkg.com/jwa/-/jwa-1.4.1.tgz#743c32985cb9e98655530d53641b66c8645b039a" + integrity sha512-qiLX/xhEEFKUAJ6FiBMbes3w9ATzyk5W7Hvzpa/SLYdxNtng+gcurvrI7TbACjIXlsJyr05/S1oUhZrc63evQA== + dependencies: + buffer-equal-constant-time "1.0.1" + ecdsa-sig-formatter "1.0.11" + safe-buffer "^5.0.1" + +jws@^3.2.2: + version "3.2.2" + resolved "https://registry.yarnpkg.com/jws/-/jws-3.2.2.tgz#001099f3639468c9414000e99995fa52fb478304" + integrity sha512-YHlZCB6lMTllWDtSPHz/ZXTsi8S00usEV6v1tjq8tOUZzw7DpSDWVXjXDre6ed1w/pd495ODpHZYSdkRTsa0HA== + dependencies: + jwa "^1.4.1" + safe-buffer "^5.0.1" + kind-of@^3.0.2, kind-of@^3.0.3, kind-of@^3.2.0: version "3.2.2" resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64" @@ -2854,21 +3222,56 @@ lodash.hasin@4.5.2: resolved "https://registry.yarnpkg.com/lodash.hasin/-/lodash.hasin-4.5.2.tgz#f91e352378d21ef7090b9e7687c2ca35c5b4d52a" integrity sha1-+R41I3jSHvcJC552h8LKNcW01So= +lodash.includes@^4.3.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/lodash.includes/-/lodash.includes-4.3.0.tgz#60bb98a87cb923c68ca1e51325483314849f553f" + integrity sha1-YLuYqHy5I8aMoeUTJUgzFISfVT8= + +lodash.isboolean@^3.0.3: + version "3.0.3" + resolved "https://registry.yarnpkg.com/lodash.isboolean/-/lodash.isboolean-3.0.3.tgz#6c2e171db2a257cd96802fd43b01b20d5f5870f6" + integrity sha1-bC4XHbKiV82WgC/UOwGyDV9YcPY= + lodash.isempty@4.4.0: version "4.4.0" resolved "https://registry.yarnpkg.com/lodash.isempty/-/lodash.isempty-4.4.0.tgz#6f86cbedd8be4ec987be9aaf33c9684db1b31e7e" integrity sha1-b4bL7di+TsmHvpqvM8loTbGzHn4= +lodash.isinteger@^4.0.4: + version "4.0.4" + resolved "https://registry.yarnpkg.com/lodash.isinteger/-/lodash.isinteger-4.0.4.tgz#619c0af3d03f8b04c31f5882840b77b11cd68343" + integrity sha1-YZwK89A/iwTDH1iChAt3sRzWg0M= + lodash.isnil@4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/lodash.isnil/-/lodash.isnil-4.0.0.tgz#49e28cd559013458c814c5479d3c663a21bfaa6c" integrity sha1-SeKM1VkBNFjIFMVHnTxmOiG/qmw= +lodash.isnumber@^3.0.3: + version "3.0.3" + resolved "https://registry.yarnpkg.com/lodash.isnumber/-/lodash.isnumber-3.0.3.tgz#3ce76810c5928d03352301ac287317f11c0b1ffc" + integrity sha1-POdoEMWSjQM1IwGsKHMX8RwLH/w= + +lodash.isplainobject@^4.0.6: + version "4.0.6" + resolved "https://registry.yarnpkg.com/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz#7c526a52d89b45c45cc690b88163be0497f550cb" + integrity sha1-fFJqUtibRcRcxpC4gWO+BJf1UMs= + +lodash.isstring@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/lodash.isstring/-/lodash.isstring-4.0.1.tgz#d527dfb5456eca7cc9bb95d5daeaf88ba54a5451" + integrity sha1-1SfftUVuynzJu5XV2ur4i6VKVFE= + lodash.omitby@4.6.0: version "4.6.0" resolved "https://registry.yarnpkg.com/lodash.omitby/-/lodash.omitby-4.6.0.tgz#5c15ff4754ad555016b53c041311e8f079204791" integrity sha1-XBX/R1StVVAWtTwEExHo8HkgR5E= +lodash.once@^4.0.0: + version "4.1.1" + resolved "https://registry.yarnpkg.com/lodash.once/-/lodash.once-4.1.1.tgz#0dd3971213c7c56df880977d504c88fb471a97ac" + integrity sha1-DdOXEhPHxW34gJd9UEyI+0cal6w= + lodash.sortby@^4.7.0: version "4.7.0" resolved "https://registry.yarnpkg.com/lodash.sortby/-/lodash.sortby-4.7.0.tgz#edd14c824e2cc9c1e0b0a1b42bb5210516a42438" @@ -2910,6 +3313,11 @@ lru-cache@^6.0.0: dependencies: yallist "^4.0.0" +macos-release@^2.2.0: + version "2.5.0" + resolved "https://registry.yarnpkg.com/macos-release/-/macos-release-2.5.0.tgz#067c2c88b5f3fb3c56a375b2ec93826220fa1ff2" + integrity sha512-EIgv+QZ9r+814gjJj0Bt5vSLJLzswGmSUbUpbi9AIr/fsN2IWFBl2NucV9PAiek+U1STK468tEkxmVYUtuAN3g== + magic-string@0.25.7, magic-string@^0.25.7: version "0.25.7" resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.25.7.tgz#3f497d6fd34c669c6798dcb821f2ef31f5445051" @@ -3029,6 +3437,16 @@ ms@2.1.2: resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009" integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w== +ms@^2.1.1: + version "2.1.3" + resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2" + integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== + +mute-stream@0.0.8: + version "0.0.8" + resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.8.tgz#1630c42b2251ff81e2a283de96a5497ea92e5e0d" + integrity sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA== + mz@^2.7.0: version "2.7.0" resolved "https://registry.yarnpkg.com/mz/-/mz-2.7.0.tgz#95008057a56cafadc2bc63dde7f9ff6955948e32" @@ -3065,7 +3483,7 @@ nice-try@^1.0.4: resolved "https://registry.yarnpkg.com/nice-try/-/nice-try-1.0.5.tgz#a3378a7696ce7d223e88fc9b764bd7ef1089e366" integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ== -node-fetch@2.6.1: +node-fetch@2.6.1, node-fetch@^2.6.1: version "2.6.1" resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.1.tgz#045bd323631f76ed2e2b55573394416b639a0052" integrity sha512-V4aYg89jEoVRxRb2fJdAg8FHvI7cEyYdVAh94HH0UIK8oJxUfkjlDQN9RbMx+bEjP7+ggMiFRprSti032Oipxw== @@ -3197,6 +3615,19 @@ optionator@^0.8.1: type-check "~0.3.2" word-wrap "~1.2.3" +os-name@^3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/os-name/-/os-name-3.1.0.tgz#dec19d966296e1cd62d701a5a66ee1ddeae70801" + integrity sha512-h8L+8aNjNcMpo/mAIBPn5PXCM16iyPGjHNWo6U1YO8sJTMHtEtyczI6QJnLoplswm6goopQkqc7OAnjhWcugVg== + dependencies: + macos-release "^2.2.0" + windows-release "^3.1.0" + +os-tmpdir@~1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274" + integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ= + p-each-series@^2.1.0: version "2.2.0" resolved "https://registry.yarnpkg.com/p-each-series/-/p-each-series-2.2.0.tgz#105ab0357ce72b202a8a8b94933672657b5e2a9a" @@ -3604,6 +4035,18 @@ rsvp@^4.8.4: resolved "https://registry.yarnpkg.com/rsvp/-/rsvp-4.8.5.tgz#c8f155311d167f68f21e168df71ec5b083113734" integrity sha512-nfMOlASu9OnRJo1mbEk2cz0D56a1MBNrJ7orjRZQG10XDyuvwksKbuXNp6qa+kbn839HwjwhBzhFmdsaEAfauA== +run-async@^2.4.0: + version "2.4.1" + resolved "https://registry.yarnpkg.com/run-async/-/run-async-2.4.1.tgz#8440eccf99ea3e70bd409d49aab88e10c189a455" + integrity sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ== + +rxjs@^6.4.0, rxjs@^6.6.0: + version "6.6.7" + resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-6.6.7.tgz#90ac018acabf491bf65044235d5863c4dab804c9" + integrity sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ== + dependencies: + tslib "^1.9.0" + rxjs@^6.6.3: version "6.6.3" resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-6.6.3.tgz#8ca84635c4daa900c0d3967a6ee7ac60271ee552" @@ -3673,7 +4116,7 @@ semver-regex@^2.0.0: resolved "https://registry.yarnpkg.com/semver-regex/-/semver-regex-2.0.0.tgz#a93c2c5844539a770233379107b38c7b4ac9d338" integrity sha512-mUdIBBvdn0PLOeP3TEkMH7HHeUP3GjsXCwKarjv/kGmUFOYg1VqEemKhoQpWMu6X2I8kHeuVdGibLGkVK+/5Qw== -"semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.4.1, semver@^5.5.0: +"semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.4.1, semver@^5.5.0, semver@^5.6.0: version "5.7.1" resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7" integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ== @@ -4046,11 +4489,6 @@ test-exclude@^6.0.0: glob "^7.1.4" minimatch "^3.0.4" -text-encoding-utf-8@^1.0.2: - version "1.0.2" - resolved "https://registry.yarnpkg.com/text-encoding-utf-8/-/text-encoding-utf-8-1.0.2.tgz#585b62197b0ae437e3c7b5d0af27ac1021e10d13" - integrity sha512-8bw4MY9WjdsD2aMtO0OzOCY3pXGYNx2d2FfHRVUKkiCPDWjKuOlhLVASS+pD7VkLTVjW268LYJHwsnPFlBpbAg== - thenify-all@^1.0.0: version "1.6.0" resolved "https://registry.yarnpkg.com/thenify-all/-/thenify-all-1.6.0.tgz#1a1918d402d8fc3f98fbf234db0bcc8cc10e9726" @@ -4075,11 +4513,18 @@ throat@^5.0.0: resolved "https://registry.yarnpkg.com/throat/-/throat-5.0.0.tgz#c5199235803aad18754a667d659b5e72ce16764b" integrity sha512-fcwX4mndzpLQKBS1DVYhGAcYaYt7vsHNIvQV+WXMvnow5cgjPphq5CaayLaGsjRdSCKZFNGt7/GYAuXaNOiYCA== -through@2, through@^2.3.8: +through@2, through@^2.3.6, through@^2.3.8: version "2.3.8" resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5" integrity sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU= +tmp@^0.0.33: + version "0.0.33" + resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9" + integrity sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw== + dependencies: + os-tmpdir "~1.0.2" + tmpl@1.0.x: version "1.0.4" resolved "https://registry.yarnpkg.com/tmpl/-/tmpl-1.0.4.tgz#23640dd7b42d00433911140820e5cf440e521dd1" @@ -4161,6 +4606,11 @@ tslib@^1.13.0, tslib@^1.8.1, tslib@^1.9.0: resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00" integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg== +tslib@^2.1.0: + version "2.3.1" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.3.1.tgz#e8a335add5ceae51aa261d32a490158ef042ef01" + integrity sha512-77EbyPPpMz+FRFRuAFlWMtmgUWGe9UOG2Z25NqCwiIjRhOf5iKGuzSe5P2w1laq+FkRy4p+PCuVkJSGkzTEKVw== + tslint@^6.1.1: version "6.1.3" resolved "https://registry.yarnpkg.com/tslint/-/tslint-6.1.3.tgz#5c23b2eccc32487d5523bd3a470e9aa31789d904" @@ -4248,6 +4698,26 @@ union-value@^1.0.0: is-extendable "^0.1.1" set-value "^2.0.1" +universal-github-app-jwt@^1.0.1: + version "1.1.0" + resolved "https://registry.yarnpkg.com/universal-github-app-jwt/-/universal-github-app-jwt-1.1.0.tgz#0abaa876101cdf1d3e4c546be2768841c0c1b514" + integrity sha512-3b+ocAjjz4JTyqaOT+NNBd5BtTuvJTxWElIoeHSVelUV9J3Jp7avmQTdLKCaoqi/5Ox2o/q+VK19TJ233rVXVQ== + dependencies: + "@types/jsonwebtoken" "^8.3.3" + jsonwebtoken "^8.5.1" + +universal-user-agent@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/universal-user-agent/-/universal-user-agent-5.0.0.tgz#a3182aa758069bf0e79952570ca757de3579c1d9" + integrity sha512-B5TPtzZleXyPrUMKCpEHFmVhMN6EhmJYjG5PQna9s7mXeSqGTLap4OpqLl5FCEFUI3UBmllkETwKf/db66Y54Q== + dependencies: + os-name "^3.1.0" + +universal-user-agent@^6.0.0: + version "6.0.0" + resolved "https://registry.yarnpkg.com/universal-user-agent/-/universal-user-agent-6.0.0.tgz#3381f8503b251c0d9cd21bc1de939ec9df5480ee" + integrity sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w== + unset-value@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/unset-value/-/unset-value-1.0.0.tgz#8376873f7d2335179ffb1e6fc3a8ed0dfc8ab559" @@ -4385,6 +4855,13 @@ which@^2.0.1, which@^2.0.2: dependencies: isexe "^2.0.0" +windows-release@^3.1.0: + version "3.3.3" + resolved "https://registry.yarnpkg.com/windows-release/-/windows-release-3.3.3.tgz#1c10027c7225743eec6b89df160d64c2e0293999" + integrity sha512-OSOGH1QYiW5yVor9TtmXKQvt2vjQqbYS+DqmsZw+r7xDwLXEeT3JGW0ZppFmHx4diyXmxt238KFR3N9jzevBRg== + dependencies: + execa "^1.0.0" + word-wrap@~1.2.3: version "1.2.3" resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c" From 8699c8916bd380f71455faec872292ad7d237ee1 Mon Sep 17 00:00:00 2001 From: Forbes Lindesay Date: Thu, 19 Aug 2021 15:49:45 +0100 Subject: [PATCH 02/10] perf: use builtin sha1 --- packages/core/src/index.ts | 1 - packages/core/src/sha1.ts | 152 ------------------ packages/objects/package.json | 4 +- packages/objects/src/index.test.ts | 7 +- packages/objects/src/index.ts | 2 +- packages/packfile/package.json | 4 +- .../packfile/src/DigestableAsyncBuffer.ts | 14 +- packages/packfile/src/compose-packfile.ts | 14 +- packages/packfile/src/normalize-entries.ts | 5 +- 9 files changed, 32 insertions(+), 171 deletions(-) delete mode 100644 packages/core/src/sha1.ts diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts index 8ce8300..03ab535 100644 --- a/packages/core/src/index.ts +++ b/packages/core/src/index.ts @@ -1,6 +1,5 @@ export {default as AsyncBuffer} from './AsyncBuffer'; export {default as Buffer} from './Buffer'; -export {default as sha1, Sha1} from './sha1'; export { decode, encode, diff --git a/packages/core/src/sha1.ts b/packages/core/src/sha1.ts deleted file mode 100644 index 2496cc3..0000000 --- a/packages/core/src/sha1.ts +++ /dev/null @@ -1,152 +0,0 @@ -const shared = new Uint32Array(80); - -export interface Sha1 { - update(chunk: string): string; - update(chunk: number[]): number[]; - update(chunk: Uint8Array): Uint8Array; - digest(): string; -} - -// Input chunks must be either arrays of bytes or "raw" encoded strings -export default function sha1(): Sha1; -export default function sha1(buffer: string | number[] | Uint8Array): string; -export default function sha1(buffer?: string | number[] | Uint8Array) { - if (buffer === undefined) return create(new Uint32Array(80)); - const shasum = create(shared); - shasum.update(buffer as any); - return shasum.digest(); -} - -// A pure JS implementation of sha1 for non-node environments. -function create(block: Uint32Array): Sha1 { - let h0 = 0x67452301; - let h1 = 0xefcdab89; - let h2 = 0x98badcfe; - let h3 = 0x10325476; - let h4 = 0xc3d2e1f0; - // The first 64 bytes (16 words) is the data chunk - let offset = 0; - let shift = 24; - let totalLength = 0; - - return {update: update, digest: digest}; - - // The user gave us more data. Store it! - function update(chunk: string): string; - function update(chunk: number[]): number[]; - function update(chunk: Uint8Array): Uint8Array; - function update(chunk: string | number[] | Uint8Array): any { - if (typeof chunk === 'string') return updateString(chunk); - const length = chunk.length; - totalLength += length * 8; - for (let i = 0; i < length; i++) { - write(chunk[i]); - } - return chunk; - } - - function updateString(string: string) { - const length = string.length; - totalLength += length * 8; - for (let i = 0; i < length; i++) { - write(string.charCodeAt(i)); - } - } - - function write(byte: number) { - block[offset] |= (byte & 0xff) << shift; - if (shift) { - shift -= 8; - } else { - offset++; - shift = 24; - } - if (offset === 16) processBlock(); - } - - // No more data will come, pad the block, process and return the result. - function digest() { - // Pad - write(0x80); - if (offset > 14 || (offset === 14 && shift < 24)) { - processBlock(); - } - offset = 14; - shift = 24; - - // 64-bit length big-endian - write(0x00); // numbers this big aren't accurate in javascript anyway - write(0x00); // ..So just hard-code to zero. - write(totalLength > 0xffffffffff ? totalLength / 0x10000000000 : 0x00); - write(totalLength > 0xffffffff ? totalLength / 0x100000000 : 0x00); - for (let s = 24; s >= 0; s -= 8) { - write(totalLength >> s); - } - - // At this point one last processBlock() should trigger and we can pull out the result. - return toHex(h0) + toHex(h1) + toHex(h2) + toHex(h3) + toHex(h4); - } - - // We have a full block to process. Let's do it! - function processBlock() { - // Extend the sixteen 32-bit words into eighty 32-bit words: - for (let i = 16; i < 80; i++) { - const w = block[i - 3] ^ block[i - 8] ^ block[i - 14] ^ block[i - 16]; - block[i] = (w << 1) | (w >>> 31); - } - - // log(block); - - // Initialize hash value for this chunk: - let a = h0; - let b = h1; - let c = h2; - let d = h3; - let e = h4; - let f, k; - - // Main loop: - for (let i = 0; i < 80; i++) { - if (i < 20) { - f = d ^ (b & (c ^ d)); - k = 0x5a827999; - } else if (i < 40) { - f = b ^ c ^ d; - k = 0x6ed9eba1; - } else if (i < 60) { - f = (b & c) | (d & (b | c)); - k = 0x8f1bbcdc; - } else { - f = b ^ c ^ d; - k = 0xca62c1d6; - } - const temp = ((a << 5) | (a >>> 27)) + f + e + k + (block[i] | 0); - e = d; - d = c; - c = (b << 30) | (b >>> 2); - b = a; - a = temp; - } - - // Add this chunk's hash to result so far: - h0 = (h0 + a) | 0; - h1 = (h1 + b) | 0; - h2 = (h2 + c) | 0; - h3 = (h3 + d) | 0; - h4 = (h4 + e) | 0; - - // The block is now reusable. - offset = 0; - for (let i = 0; i < 16; i++) { - block[i] = 0; - } - } - - function toHex(word: number) { - let hex = ''; - for (let i = 28; i >= 0; i -= 4) { - hex += ((word >> i) & 0xf).toString(16); - } - return hex; - } -} diff --git a/packages/objects/package.json b/packages/objects/package.json index 897437b..c692096 100644 --- a/packages/objects/package.json +++ b/packages/objects/package.json @@ -21,7 +21,9 @@ "dependencies": { "@rollingversions/git-core": "^0.0.0" }, - "devDependencies": {}, + "devDependencies": { + "@types/node": "*" + }, "peerDependencies": {}, "engines": { "node": ">=14.0.0" diff --git a/packages/objects/src/index.test.ts b/packages/objects/src/index.test.ts index bad59c5..ed4ce85 100644 --- a/packages/objects/src/index.test.ts +++ b/packages/objects/src/index.test.ts @@ -1,9 +1,12 @@ -import {sha1, encodeObject, decodeObject, GitObject, Type, Mode} from '.'; +import {createHash} from 'crypto'; +import {encodeObject, decodeObject, GitObject, Type, Mode} from '.'; function testEncoding(inputObject: GitObject, expectedHash: string) { return () => { const objectBuffer = encodeObject(inputObject); - expect(sha1(objectBuffer)).toBe(expectedHash); + expect(createHash('sha1').update(objectBuffer).digest('hex')).toBe( + expectedHash, + ); expect(decodeObject(objectBuffer)).toEqual(inputObject); }; } diff --git a/packages/objects/src/index.ts b/packages/objects/src/index.ts index 9573c7c..e7800b6 100644 --- a/packages/objects/src/index.ts +++ b/packages/objects/src/index.ts @@ -1,4 +1,4 @@ -export {sha1, Type, Mode} from '@rollingversions/git-core'; +export {Type, Mode} from '@rollingversions/git-core'; export {default as encodeObject, textToBlob} from './encodeObject'; export { diff --git a/packages/packfile/package.json b/packages/packfile/package.json index 4d14101..b53b3cc 100644 --- a/packages/packfile/package.json +++ b/packages/packfile/package.json @@ -23,7 +23,9 @@ "@types/pako": "^1.0.2", "pako": "^1.0.5" }, - "devDependencies": {}, + "devDependencies": { + "@types/node": "*" + }, "peerDependencies": {}, "engines": { "node": ">=14.0.0" diff --git a/packages/packfile/src/DigestableAsyncBuffer.ts b/packages/packfile/src/DigestableAsyncBuffer.ts index af0c0d3..d8ff097 100644 --- a/packages/packfile/src/DigestableAsyncBuffer.ts +++ b/packages/packfile/src/DigestableAsyncBuffer.ts @@ -1,12 +1,13 @@ -import {AsyncBuffer, sha1, Sha1} from '@rollingversions/git-core'; +import {AsyncBuffer} from '@rollingversions/git-core'; +import {createHash, Hash} from 'crypto'; export default class DigestableAsyncBuffer extends AsyncBuffer { - private sha: Sha1; + private sha: Hash; private temp: Uint8Array; private tempChunk: Uint8Array | undefined; constructor(chunks: AsyncIterableIterator) { super(chunks); - this.sha = sha1(); + this.sha = createHash('sha1'); // sha1(); this.temp = new Uint8Array(1); } @@ -20,7 +21,8 @@ export default class DigestableAsyncBuffer extends AsyncBuffer { return result; } else { const result = await super.next(length); - return this.sha.update(result); + this.sha.update(result); + return result; } } @@ -50,8 +52,8 @@ export default class DigestableAsyncBuffer extends AsyncBuffer { } digest() { - const result = this.sha.digest(); - this.sha = sha1(); + const result = this.sha.digest('hex'); + this.sha = createHash('sha1'); return result; } } diff --git a/packages/packfile/src/compose-packfile.ts b/packages/packfile/src/compose-packfile.ts index 639a3e5..5eefa90 100644 --- a/packages/packfile/src/compose-packfile.ts +++ b/packages/packfile/src/compose-packfile.ts @@ -1,4 +1,5 @@ -import {packHash, sha1} from '@rollingversions/git-core'; +import {packHash} from '@rollingversions/git-core'; +import {createHash} from 'crypto'; import * as pako from 'pako'; @@ -8,17 +9,20 @@ export default async function* composePackfile( items: AsyncIterableIterator, count: number, ) { - const hash = sha1(); + const hash = createHash('sha1'); - yield hash.update(packHeader(count)); + const head = packHeader(count); + hash.update(head); + yield head; for await (const item of items) { for (const chunk of packFrame(item)) { - yield hash.update(chunk); + hash.update(chunk); + yield chunk; } } - yield packHash(hash.digest()); + yield packHash(hash.digest('hex')); } function packHeader(length: number) { diff --git a/packages/packfile/src/normalize-entries.ts b/packages/packfile/src/normalize-entries.ts index ed926be..2ea6bb3 100644 --- a/packages/packfile/src/normalize-entries.ts +++ b/packages/packfile/src/normalize-entries.ts @@ -1,4 +1,4 @@ -import {concat, encode, sha1} from '@rollingversions/git-core'; +import {concat, encode} from '@rollingversions/git-core'; import { Type, @@ -10,6 +10,7 @@ import { Progress, } from './types'; import applyDelta from './apply-delta'; +import {createHash} from 'crypto'; export default async function* normalizeEntries( entries: AsyncIterableIterator, @@ -33,7 +34,7 @@ export default async function* normalizeEntries( const type = Type[entry.type]; const body = encodeRaw(type, entry.body); - const hash = sha1(body); + const hash = createHash('sha1').update(body).digest('hex'); references.set(hash, entry); offsets.set(entry.offset, entry); From 9564fe64e99a5b8834e6853302692853ca2dc241 Mon Sep 17 00:00:00 2001 From: Forbes Lindesay Date: Thu, 19 Aug 2021 15:55:36 +0100 Subject: [PATCH 03/10] perf: use builtin Buffer rather than packHash/unpackHash --- packages/core/src/index.ts | 2 -- packages/core/src/utils.ts | 21 --------------------- packages/objects/src/decodeObject.ts | 11 +++-------- packages/objects/src/encodeObject.ts | 4 ++-- packages/packfile/src/compose-packfile.ts | 5 ++--- packages/packfile/src/parse-packfile.ts | 6 +++--- 6 files changed, 10 insertions(+), 39 deletions(-) diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts index 03ab535..6565674 100644 --- a/packages/core/src/index.ts +++ b/packages/core/src/index.ts @@ -9,8 +9,6 @@ export { fromOct, fromDecChar, fromHexChar, - packHash, - unpackHash, toHexChar, NEWLINE, } from './utils'; diff --git a/packages/core/src/utils.ts b/packages/core/src/utils.ts index c126357..7249d87 100644 --- a/packages/core/src/utils.ts +++ b/packages/core/src/utils.ts @@ -62,27 +62,6 @@ export function fromOct( return val; } -export function packHash(hex: string) { - var raw = new Uint8Array(hex.length / 2); - for (let i = 0; i < hex.length; ) { - raw[i / 2] = - (fromHexChar(hex.charCodeAt(i++)) << 4) | - fromHexChar(hex.charCodeAt(i++)); - } - return raw; -} - -export function unpackHash(binary: Uint8Array, start = 0, end = binary.length) { - var hex = ''; - for (var i = start; i < end; i++) { - var byte = binary[i]; - hex += - String.fromCharCode(toHexChar(byte >> 4)) + - String.fromCharCode(toHexChar(byte & 0xf)); - } - return hex; -} - export function toHexChar(val: number) { return val < 10 ? val + 0x30 : val + 0x57; } diff --git a/packages/objects/src/decodeObject.ts b/packages/objects/src/decodeObject.ts index 4f0bba8..0a7d5cd 100644 --- a/packages/objects/src/decodeObject.ts +++ b/packages/objects/src/decodeObject.ts @@ -1,10 +1,4 @@ -import { - Type, - decode, - unpackHash, - fromDec, - fromOct, -} from '@rollingversions/git-core'; +import {Type, decode, fromDec, fromOct} from '@rollingversions/git-core'; import { GitObject, @@ -109,7 +103,8 @@ function decodeTree(body: Uint8Array): TreeObject { start = i; i = body.indexOf(0x00, start); name = decode(body, start, i++); - hash = unpackHash(body, i, (i += 20)); + + hash = Buffer.from(body.slice(i, (i += 20))).toString('hex'); tree[name] = { mode: mode, hash: hash, diff --git a/packages/objects/src/encodeObject.ts b/packages/objects/src/encodeObject.ts index 7ad173a..ef0ebbe 100644 --- a/packages/objects/src/encodeObject.ts +++ b/packages/objects/src/encodeObject.ts @@ -1,4 +1,4 @@ -import {concat, encode, Mode, packHash, Type} from '@rollingversions/git-core'; +import {concat, encode, Mode, Type} from '@rollingversions/git-core'; import { CommitBody, GitObject, @@ -56,7 +56,7 @@ export function encodeTree(body: TreeBody) { .sort(treeSort) .flatMap((entry) => [ encode(`${entry.mode.toString(8)} ${entry.name}\0`), - packHash(entry.hash), + Buffer.from(entry.hash, `hex`), ]), ); } diff --git a/packages/packfile/src/compose-packfile.ts b/packages/packfile/src/compose-packfile.ts index 5eefa90..fdda5e1 100644 --- a/packages/packfile/src/compose-packfile.ts +++ b/packages/packfile/src/compose-packfile.ts @@ -1,4 +1,3 @@ -import {packHash} from '@rollingversions/git-core'; import {createHash} from 'crypto'; import * as pako from 'pako'; @@ -22,7 +21,7 @@ export default async function* composePackfile( } } - yield packHash(hash.digest('hex')); + yield hash.digest(); } function packHeader(length: number) { @@ -48,7 +47,7 @@ function* packFrame(item: Entry) { if (item.type === Type.ofsDelta) { yield packOfsDelta(item.ref); } else if (item.type === Type.refDelta) { - yield packHash(item.ref); + yield Buffer.from(item.ref, 'hex'); } yield pako.deflate(item.body); diff --git a/packages/packfile/src/parse-packfile.ts b/packages/packfile/src/parse-packfile.ts index 738f6f5..2cfbd01 100644 --- a/packages/packfile/src/parse-packfile.ts +++ b/packages/packfile/src/parse-packfile.ts @@ -1,5 +1,5 @@ import * as pako from 'pako'; -import {AsyncBuffer, unpackHash} from '@rollingversions/git-core'; +import {AsyncBuffer} from '@rollingversions/git-core'; import DigestableAsyncBuffer from './DigestableAsyncBuffer'; import {Type, Entry, Progress} from './types'; @@ -204,7 +204,7 @@ async function $refDelta(state: DeltaHeaderState): Promise { ...state, state: 'ref-delta', type: Type.refDelta, - ref: unpackHash(await state.buffer.next(20)), + ref: Buffer.from(await state.buffer.next(20)).toString('hex'), }; } @@ -235,7 +235,7 @@ async function $body( // 20 byte checksum async function $checksum(state: EntriesState): Promise { const actual = state.buffer.digest(); - const checksum = unpackHash(await state.buffer.next(20)); + const checksum = Buffer.from(await state.buffer.next(20)).toString('hex'); if (checksum !== actual) throw new Error( `Checksum mismatch: actual ${actual} != expected ${checksum}`, From 4c49bd8f2d8ec03ba956d3f4e5272eb2fc659cab Mon Sep 17 00:00:00 2001 From: Forbes Lindesay Date: Thu, 19 Aug 2021 16:12:42 +0100 Subject: [PATCH 04/10] test: pack/unpack --- packages/packfile/samples/sample1.pack | Bin 0 -> 796033 bytes packages/packfile/src/index.test.ts | 18 +++++++++++++++++ packages/packfile/src/pack.ts | 2 +- packages/packfile/src/unpack.test.ts | 27 +++++++++++++++++++++++++ 4 files changed, 46 insertions(+), 1 deletion(-) create mode 100644 packages/packfile/samples/sample1.pack create mode 100644 packages/packfile/src/index.test.ts create mode 100644 packages/packfile/src/unpack.test.ts diff --git a/packages/packfile/samples/sample1.pack b/packages/packfile/samples/sample1.pack new file mode 100644 index 0000000000000000000000000000000000000000..85eca11bcac06730b36c4ecaeb18ba1ddccfd6a1 GIT binary patch literal 796033 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

dJx7~$MQr=UOCFh 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

B_zUW@;3v(rOOhiTp~hyye9lr2 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 z zI)W(Tolk*6C#k%>_hdfiKz}6_p$d%u0adId^<2GJ1oQ8ut4A(B*vpT&UC5KZYXTD% zd0Z&IE|L3?G}CPfexo~ap*z)okM&gR6E6juS_OCm&P78zqg=qbI2MHjgxn5FQ^yAg zi%u4lKV(D<1w0S=9brMMV015Pp$+It)kH+(r;O+<*qREyIGb>#f^TbPBT^;7fz3idD~mlEb39keuh-eg7~o_O#6YV|LT90TGb8k#$XR>Y8EaGtJP9@$K@8Z4^3F@47@kAJo)m)#Le||I)vMEMQ@O9 zw4LFxS>tLqDiyt)gbK0RR& zdstk|@loywRKmkde)RJIeP`GKzM12^X<`QyBc*Y>0Y=2`M>I8hQc5O*051dO3Y8F* zdr(dCy_NckYr=vk|J#_H{Nm#z(;a5}kvJ`wDQ*%e3_5aT+|IGBq*&_E9_ zWP0U}plZl6Nkab(_5CoJnNy$4A->w8WjAG5%_H^AYU*6Y#I;FJTVaC5%0zsXFfu8o zKeOu_0yhE2)#%7q)7%ysiRt3im!WT92uWCC}y+SrQ?RkefkV|9$bK1?v&bh^`?;P;|IVxFV6uLBAijt36a> zCHK5YF&Buvb~>VRXdgL$J=O<)Kbux#xeGi#6b9Vr3P?(GJDFAdgH@dtgG174F4~TS z%$o&+`7ehM14#S+bKb6JkInguuR82RB{6RK?!yNHNqP_Glp@M)jRJ$8&<9DeQM8Pl zW8Vjusa6~*s~|+cre(k_+E!?71Pt8_2#Wx8yk-4=*n-mbhX7#8sd^oV8yOLMGHn#! z&@%|Q8v;0V)0yhLAi{(hZ8Ei_sbTT=Z4MDxl++R20)&Lkw9n%n2Lh9PC~+)xT#QYm zk^iesJ!$Dv>G5%F>Y_MaSymNA-?^`2E0C~bK&2*`b?Fm`lS;SHkETjExDVt3+Xaoa zAVnPueaBxuU(*^Y^q3ka-6Hmg(a;+WQz0LF511Lq>63{AFt7m<-n<;$$zkBUMxQ(5 zHKwIonC?8Bx{>OLv-n_PDnC#ZAenH9Og)t_X+dO{^rTZ7ArE2XCbG@zw5LKdIE-pH zZlP?5?E!t(LUs@$^EcBPvlYLG6WW!_*e^ZF0@F!KWvNQifBE+O7BCTN%01^(InK=F zsmP7$4?IX$Jnv>XYaxFnSrMI%w4Ccds2=o2e8xuO>GzdZ%9z>{+wU0%-LJ}r-168; zPL}Fb4RSgTIcHdC(q)VOjQ3-f$k{7T+;I_r2+)ljdW@!>Nw9A`OR=7uTvZrN@44Vd zRd@66hCs|vL<%r@xLiDz%%M0y#|~u(U1wl16By}7oz%TpmWp)<@WDwP3|GyMDRFBF z5>M47bSOUVUOu^%q*)(pJjN1FjxzOpaQ{u7f}AZoEJ?T49Y0LW!mw!-9p5nQ%USvh zl(!HuOl4KlL7_OUQHD^~aJ@b|KT#E!61Q!vNmFqlU`Vpn887I8Z>&jl?bR(`sLyzW zfmvaFN0w?xEI2-N0(%92xF-O^$6OPQSJYwME?EePRI+XhAG_ErI-HbsX4XpVi0d&p zebQyhzsecapGWt|#=F%?d4B@c&i@-op z8v+&k!8oLXncmEH6pRV-;T`Lub(zm-w!6}o*V;X&X-u*UCbRWu`>p+U@rm~WEE_>f zhkvpP2+|vDOtDfPrmOdi6sYy^c39SkYV6&>zu$C4waMMg?01Wf$NTsS>Gxb2kv{&F zyD|K8zl`n_Dr;lZFOjstIBS+6J-5K*+5FZys z{z7>-RGfN}O29O;!!(#e7AMHdVJgK#@J)cHcNi}^5Io9S+wQv3=XjLnNv~pU+t_!0 zp~{0ldvD0x+$ydA7TO8|pU*)tZFz1@O!seiu#hokPrG&DcXo8Eb!NQ|-FX}#y_ZAV z&NZn-49}!7Ie+aXR$6=6*@>l^lCippxg&@UYfV@LbNX_OGiOS_9KjzT_9&~hC>s2f1Tl!rgAtZieh_g!TQL+UR$k5-eA4^CFX-i zO|oX9-d?c~ngKs8$%+v7>$`3?wNu22|1dcMt_`33nz~aYF}G=vxD!%zPvCT6CfI;I zxCE&JB_XKV%20kK5~6|i2NnD~rmxuh8dNgc#ZvPu#1+?ffL}-um=ZF%g#igF+7H4l zjM%#mLF)>lSuVQ7E_0&(j!d&!f-C_twNr|w?JTW=jz(L|0lu$nZ%M}>U~6#@(@O$Y z%QdNdS+5++osVzoK17|ncdTX&3+jul+~P1}Pw>siFQ%)T zZ(ZH(mBr1IbEyUEIp6t9>tF(PcQUAJkRU+UaB1K_!oHtiq-Z7B1BjketM@jG6w|7g zMoyShpq8Ygp9csY0D|4Esfo2IFd!EM_;)K#K#3V~3%3m#9U(+A1Hya+?QdQIh$EUc zZ0(mg5x;wS2dWWehuAlrB;0Lk^HFXWwgUq`mO#g|JUR^ zM@bysd+;*M^16A=pna6*rHA3MknyvXAdl;%$u@RBS-8L_E4h>!oS92itPi2CoeHESXs6F3&uhGQU1CBMkl`(kXm)cn6|34nmShbj}@y|a8@sff~KO8|>n-z@wr~JG{!Axk72O-BF*Au!(WJWr0&xfGNLJ-MIEHFkxuG&hj+1U*V z!R#8YE6>ZfjMy?Ui{zX%vuvTEQblH3$>O!TGO1;1tRIqDlkUWnRV4&b?B#FgmMY!ZR!x*2*Ot52UXcvHt#To7D$6vvxfk+niAj zO4P4^|5A1B=u#-_ZSy;3W<&1V>H~C_#rh^<53GM999OB+tXT~(E~B(mH`ix0U~AGP z*Y_a{3R%4urx78 z^lGZJF}$oQ0NM&QVvOTGJBIa8OzsVvhI>yOrGDXQU*1+$GdX$8E00sGf(Qqmu$@^F=8 z*)?xV#v@=S^c+2?oCU&q@)KqkQ7%H%AKOMtMblgIdOp7@TSTmwV{FqtDQ84V;h5M) zYX5PzKhgKm>4#ZO0H3RNFP1Q9%6RyFop{C?ec|R$f6r^ z=_g~z72-Z3;TkfRT$b%ln660BhdPeXwj+1Ef*p|v>L(;{qtxi4Kz9c!uf9kPgl4#I zD)&lS2Scr_g%{FcQ(Q%-Lnnr2{)SxQc(BSr$WqbnEx{wZuZ9TjhV@oJ(_Me9O3cOB zj4mUiqq1snx?NVbo(p1~HrF%9y1n~&xNSoVv^^bBPk;$mb6;vrT!90jv>?jp4yRIR zm|o(v0^U=1?-pc5ZuTE|-0#Riz(a)>Ms%S(qgEpo>_zf-LAA;AK02!4%Y)b9wXVEi zu+R*{o_R(D$IFP!4CE7r7}GmDT867Xyfo=$l5QAtU;m;Mi|=Q0Xn6oF(iiZ`f!?rB zOTiwe&Yj(}h6J&@_npUv(1*X!3GG|@vNM<_W|%^y;2G2F?Uo!(%hnrrnqu%yIVxfB zZ{j(fJ(s-@nZ)*v6CQ2!YMYO?Y?rSbF=m zq81=-U$+FS`%7%-J1_z3?ANoNBEs){fv;k~{`S3dJ|I{BLHmv3e+Ki10*32JwOP8| zP_%6HimFk~6@GP9CTjLX7pmZ?H}G@)Z`OqFTLoJ-7;;0O4MLz-83)u~BqUFi;NrR2 zYq_G%SsvDTzp@d}2K{}+p$LV~l_e=gV0|l$1Yij_sBk3x?T7TlcX5Fxcz2XWRO%S1 zuORELzw*Dc@4gryKM;2GcYd$!=KV5zYC7yf)@csfSx3MjuX9WH`#{7jucZrvV-hAUEOFT@yjF4nS-kyd zI#i{!O&no&vV1+7+p&EswSs_;{~7*Rv!x`meTG|!8MvciR_R)(ipxamBgIDS$dQbBYu~U<%t}&?@B<=k(7>NjJO&i58 zIDyPPn)|}+AKGxreB8<=t9DB2`KK)GBa_Cs42ScZlQba3cXvL4=sJw(;E5cq_&3Y9 zLiJx-#PY9B#ZA;i3xmh&v)?>&Mtz6BVgMp}?@Cui??D8&mrvf+hNZ5g@pfF~YD6^* zan6+Cv3;iXL|MZIitve}+pf_?0Z&Vjf@W2I*wyr1le8iXU)%8Qygj!(7B@3kW>U8%*@waWHm8G~jldXAg}ZR=k7;59}So2GPYd7yYLJFw<*IV_xLl$@vL8H7AVI7FUEE zcSb#*v?$Bcul61ri{G5YVGi}Gk)mh{iosz4mpQ$&2O+#b9Pe)y`wdKfiuvremgbt{ z_aHsEy+NrjqUfD!`HVs!5!znh2s`pplBU!)c84w=<9}Ab6Q`|e8i`8<tGUt@Y1oX20u3GX+KiqWR`pe4+|A} z_6s4ypnZ4VyC#{bD9U|?s0C~dqVp4aTjC1xAPnFBGM=x+@b_k zZWSE*e-lJ z+Jn-z)KYsOV`%mvNoKa&iw;p@2*Ck8a^92O9T*u`J3)t_A%IT*W5_qz z8*n$vSB}X-`(uQ4j4Un9{19E;j*9x9fy_xcIvQnB8DJqxdUSSXk!EKwelY|AI`l`n zYheYjkCi*^08_@TFEpF9H336^fjJ`K`3eNoFW|{SYqq!}C8un{vEK9)0%4ruXfnm4 z?RyadsUU3O)8p`CXHt@Ss} z8ohen5v0%|ohh%LAqmC476f<@NlObxqvd;>t1^R-Tv{s!_PmtO2Ew$F8)m9+W5upj zYBLFOnA#PXePaG=KIaM)&gW3oyVvU06MIXxrxuzjysPO%?J13zrX+Ex8nY#HXA{U$ zr@Q_{PG(OO>$F##z^F*eC5nXT0Vru5Lo|u8zyJK_L~d-$3vApa<_tE8-m8*EQgAqp zL~OO}Y#EGEudyhgrA)O@e=5ZYkI!^uLgnJ442h>oCa4jgK%<9Iwn_Oj2)VYLq4?RK@0LK+9<O*q^BmO zC$f6eq@xgKsWR*aNytN$0?nMw<+RNb3{@Js%Ah8(rED1KAaeu%rRvsoul$!nz<0;G zR?YMOZ+Kg&8 z(YZ92wQDEWJk-4`>w~E!Xk;frHEeD9>CfDa>s-}MhyQZC7}AY<-=qsFl^z9FgkVu5 zz5G{(XQKFIj2?0W7C}r?>DN*6Cl-{XlUM}MUud@~Fv)w=^inE4m1qzPM%J zrnsH&@z5dv4GhrZqvsmBgn!sZli4%phF6$i?PD6YZO+h0?M=K*oCo}Rf zOEi7`QL!p92tIE`bT6HtX_tSCQMzLQ9|XA4OCjUkz#xSYGJZ~#a2tcQ*7bLBVQe++ zZ>;QuzsoOjDAz7jJ#9|MjU@}__Tily1OjSmNqLD{z|8jZATZv&uf*=o@PoH z6S4b(4xwaNNafrX}!aNdTMQbhZX1~opNtM|tk^ejK# zcki3)O8e<7fAXaQ49$Kqlf4|jRvSBi{c+K*R#n6EyQBQ8;t8c9DXD10%z2frXLhhP z*?p>ZT72bcxC-I|TUJFNsFs`r#!U5$epzkm_ejc4_gvK~l}Bl4n!F9Ko|*}b;9If@ z^U~$earjS=*>k+o75f!~nhz$Vl4d%X%zI^N*IM|rxH9TfD$D<~Tp{*iNnSrc%Ah_& zkMH%ZgX~pr>#@Vn?(y)huD0hz9$3vGAnOt(1h8}19PG*Q6{-?etk+Xx3f`J1-i&V5 z{@t-tFZfe4y4qkJUdxH|zid;*#ihrjX~jV*bi4e%=NG>|u9Cg9-n}{epR28!-+K^z4v9&^z)o{gbo2LCL^i)~;H7)|t-k!XTh}jjjg*Y! z2WE^#xzU5A!YPqDcIlgQ zX?u=p^m2RJDD}=ypIV4zH2^LBmlCm&Lz}EL}r6#z0L4K@D*}KPf#Wt2(Equ%Hf-WRTbZVCGJJ@>1)YW8mwg-}K6n`;tq~W%IKK#b`h- z2ANLet05biEq4`Td>14$A~8-Jm}HWGWS8qQkP;1m76yg>fr`~KjhXK zk)ksyCO6-Hm^LTye7<*SJ@VNa;pesNBP4E&I)c z7q~9x^X^+re;;%+0IkZ`deIT`7{B0uy>x%H{9|as)2$-;Y1?RR#;y#L=&sCSX8W^k zz?ru8`8Lw@ymI35?j}A5AN#Kjx-#c{1DD}RawGseiunk^MnXaU_`Pl5S>`J{OS?V>St{?__IoPI zX`{K^rFaT{~NW)10N!N#E7ef`$Mok-^Pnx)O$N0P>NJqXdBA@%y2 zQn|m&SJW<##I6D@jre`tgGh0UK%eiv4<3oGBcf5MU*3=9W72`yWj&poj{Bk{W$737vtAOPgoH)Uwdnq=I8nW;s=8w+hTQ|Aw zwh(Qqs|TZ}Y7d93n0ujoZkcOZ1<*D*`qNKfS^ltehz4M7qb`~;|Y3yZM1Be%FO`n5W5wu z+e~V^oH@y@v1lw0VT|k)3H^$vDMijv7LF7NMDJR+EfD`D)LHgX=PVUchKCjhM3^1< z$BcH&)2Mr>M0T%8j;F6&A!wXv-T@>B{cRvqyZjElXO_CQG_Qt@-O_J)=G^L+T{W|f z7>CraYm(=bgW)%!d^j)v-v_yU&P`8)3bi|-TZ3njTXl*AC{@U~^_;l)gB54wp)ubS=b|cl?cK=Ry zuZ)w96myb>9Vf1XKKU}Som>c~`vg=|-2}N?6Q$o96hEu{F^zoX%YY$u_N}Qucf#7q zA@%96+&^zR&Vpeqx|smuzqu1zvKuA!Apek#!HfxEib?ylFy?GzEM}f!n3= zLo-A6NGql)6hFOp5uulzr%eY;rRj{o2Oa+0{yd96oDb_H0u%yo&KItczhy$nXYn57 zaT4c!$6AR?d;KVSEsZXOkc9g|LI?dQvD2jD%l~Fq?I^N7#OW4@HW#gQTYLih zXM)!qf`)Pdf-lhCsk`=paFkuIPlRnwVzTEwBik$Lpm($$+(|^X$eW ziNU-%$UF+3;@7q{s#TUfM~)&(JX>PvXlw~>=P$MoWG>_41e=1DWkd=1J9aYjuciHx zx_GJ7&&`Y8h4NNK-}p%f{J4y35z5sz1LHr4kN98|U38?BQ~y8%jJetC0L-79#9p~U zM#Pa<-r@O@iU=74IIIK%g9Bj1;KOWf^$I+Cxy&FB_fHC0m`cpGtIoXM+sExbDC$Kw z1(1F3+Fy$$y$tH2%x$>~Y;g<^UDI|#^AasN^=ZoC@sxf}1zJUKaQrSp6)=>q&rou1 zr8hVxoGoG1vlQNR)y&vdDMRiVYTYRkG;cCMU2dyRf$-VP@?WqI_w?>jKvF{31>R%o z1{@|Y`Hl$kB4G=|jrbl#RvI)gr5lBHh-~Ql?XPo{?Pm$6nooJLyzll|6HAb%haCMK zJqIG6jGdmx)@?caa=vf&1n!K^_f>JQ@^UD5Z>pLQC@cATo6`hT!YLB$@Lv<&6dG>F zonmjQ7id@&lVyWDHa(C!&`Ok1>8!MI7hU^)TpG{tBf1I#YUJdoNtXlboq|rkhv__N z@$uf_&~qXYmFjv@59>XPIsxu$`}L-f-obfJ+!djpxU4%HhHH@8cJl#x5x88EH2uL2 z2=4>hx>kL4EvD$-Wa{B*H{bz&00VnpSCr)M|BF7u#>6$487-}^->>-pl4uy1#EIy7 z$IvKQ6s2=8$f4D^9h-?bROCqL>w6zzL`wo-01~UZX$O!x_|B@! zgn|?pq$}!25z94Nw0hdO2cA^4z|1kbj%yW5&39(81J;eORFN}qYzY$CfNSH4n6DbV zTMNM+g~PvFqiZzF^Bea)=!yy-Xh;3F-KIZt4Ayh}PDa91e`fdQLP!r+xdY0tu-+`SEei8q!ApWv3NliB)^VpP zv=*OVQeBNdRlfE(mbCpAUWMl-<(`eA$YU-_!$LVZKX35qpt{M~!ixy3Nh1|x;}wyd z&3zO2&r?4X)4_+<5cP{R+pf{3E@kVP)K@>*qkE?rF5ow_`Jj>+ zNu(at{%>Zk6lm7Rud>+f-p95%bpb>Gmm0c89jwV8sxIHdM*IC1t`rto;fwb_*qu*4!wrR6kfZaCmH5Jf#}n2@`wW%;_L!8 zs|*8n)y4X%?Q-dDHcKg8*>|5MlHvC&Ggk);;B<`@{O|HB3b_30rv-?tPJ4hO80bXE zxFXxgTEdC7cMfB_`9JJt`M>&Nw;iAF3*!pbjq4VAKsxftLsoT~(1k;6(>Q@v+^GfZ z39n^l=bi=xZnNz)=&ZGDNn85{u!~)Ec&s>V9^ylljF%jd_(U@Pkd7%r{na=|{{@rFGrEzBk3w)7p##{=--)?E7HAg@gNCPiKapsQ3l>Hd*b&WNpT~F8QsB*l>>4HKADUHZp|Zt8L|n}j76Lw^het~ zc=g;;tR6F$-BB6WS<64_u2_YOVvxsQD`Tyd_otpbqe8?C%^{rU zl{{%=#i)y>tU~5<-K0gA}YqbXa zuxj#$Z;b6}!*CG4lLk!KXK$1MO{USz75L%z*VIc1P!#Vv#;4W1&)d^IK^}i$h)}Xt#oh9CB3+19!3sCr<=A%Xlf_;+% zBlv9V?0Mc`lnS9E4dIFY`b3Gu!*$q6QopFikbl-(sFbSn6U4nxg7E!{JIm4o7U}dJ z@m&BFK+iB&>$rdL_7WgDnZa?|`10sqNjyNT>bPyWwXO5|PAi9X|ySH%_50nYN1_dUlY$Qf6g zuzKL%?c`Ku`^D^XS}CwXvkuQq9dyh^Ra=X{kLRglsSxzRwrKWH)!98`33@F}tRfAs zuxJF%aVd((o!uF{3Y+oxNX}c$mFC*TZ()&w!uiBGp^!7^`a#qcZ*l{&ZR_d6Hmf7= zMYTFQ6=5>Bcnn_(u_lS*f*TuKhe1C7&6XA4z~qsIHFY8f3o51Y!eiE^(u3R>(bH>y zW(O`Z?#B}j14UM)R!CMYJR+Dv8=^8P7cCwo`rlA@H#(-6dNCxmV1#K~1wdG8kgiP{eG>fSN{ulG9D?QHa^c{(`9w)AHJRV7n-a)|Q);-` zt-IUQL;*H2ho3Stil4Hz5xg>^lNNK0J&mzG*-?=;QZAZ(tG`!`+Tlpd;GrkLC;pHz z1V_kDKPavvjHQSQ7CC1BS8R2#jcSs#7LNO+PKF5BThJ*po#D@sa65%d?XUc4RRKG> za2@<^{?#!lPU{;hh$Z=0Z{FS(jDKIoFjM0+hiGPjm=pr2TAT@+X6{zJAtFP#;sG=> zv+GnJQ38A~pekEe;2!UZu3~2^^>v=wX`)zXjwA5sND}TdU_7*Xay;Ibj>zZxy)__-08+L<)HM4Mx}F zpdUNCk!&BsbxudUIS<>x+#QVbVS0kX@&?{cB=Io%M*&qXc>SsK#ou``z4rEq=poc& zo^qtdFVL(v*s6mB(nm)~4K?{wZGi3|D&wic$p348Y_)^-L>6}VvB%*~03rdv`7WPN zs6_UKe1CbS;T&Vlntd~va}K5Lf(pl*6A8p55ae(<=un=Ax70aJgNh_yQ9-cmMkU;w znKY8l9q${5;!Z?P*+wsA9d)!qK$=Y`Q3n-AlMo-lQ;)aNfNp#|1;>0@n-< z{{HP4`7)Kp>OcF0+_kXls66Xhvyw~e`y65n`MyNRAvXm#2-cSji9%=M+ts|CLyUcI zmh@}Ch{{=2l66ZaDLa^wjXmjzt31585)*8kqzEOAkbZm-!oib$F#V)p5Mq$0E%xLf zsDOJdLD6RGVF+4517T_<9}~x24ww%lVNv~a<=;dl$lqGkrZnq+zScc-G=JiPF&d7f zOB#R_yWA>cozZi<-Rc)bI~#cxtea>>QDxLF3u7iwg=}?>68zX5r;9FQVW~N)D;7TC zN6&;@ZyytIwM7F-KG^RWQjt`L*SJv6i1|rq<2QL}Nl=&>wQ+@GMqmS+ zH_g;Y(U^61T!_kLU{^cgvpX7HM?>YUV}e>>gjYqQ8mtXez2V`CTHW}#f{m_t@XlV> zg2LNINnI+WUGps3vmtBvN~JC;%gNgO2$~m14AjtB@I8WU?fTW7KQs>4&+g%wytX_U z>wLT~E=jx_K-VQX){}2tVkvYf^NJAn>vx5diXL<6`K^>wtyX)2%$b}TBpE0WDmHNPx0$T*@}?dIEv>O{*5 z92~rDvIVmIQ)9b}uQ+~g_pYONMUQ~UF+!D0e{-b&gUPVdac{*`#1)FD>Jyg>fhZSf zG2;ObyPtB}!Mk9Toh|MfQo)l}f(bl4oCs|_3uUF^*FE!m0}9icGz$&uy7Nmp@SZxh(= za-2rmwKeYWZ;s7gLO?6$H6x<6lQ@eYvm!nP&!+Tffw6Kb9sBKftJ*hw^&zFn`|QW` zXSj*bDC8EJNSrB{spinjvfQhuDH!O0?d{_ou@E$>azl5x{t+x(!>)%Z1_OAeuN%&A z-g+UeT3x=$gJFzT7ky>QE!5pMSs}e}2n3#z4!SHmWc4L!C6~05t5##a9y^*g+G~TE zin0R6Of)2^IvN@J1cD;hEfV{0epFh9fM<2DDVZ?g7so%S4%L=Zhm>KeGa`<8DVj|u z-igHtM1ICHb@Aa>C+;txFe5)cyP%gQy^ZOgFlMdYIAKKLjnT|f$L%YVu5q!wuH%z;6zWQCTUEi_IDSy;2*pnu|AynU(hs+`=z>_4)zI(7 zE;J$D+T)k>IBIqCiR@Eit5Uzp_b;*d!_Pf!TRtlE_~cY|sG4Jz5KC?q;}Uxg&)cx8 z21%h`1aVG}*@^tMJXqNt>mgp|aRz7P!p-izDl8FoSe}N+d<|Dq9QfjtN!Ovhv8Fis zDp|a12p;KdUv)Ksz;E4eOk|n~O|MGuUb+UgBaVi<_0+>-5%!SSW&$+Qkr$4GsTHUF z1q=N3FBL~5URO^qGY+;BYx1T6ahptC40DwZ%5mt_tygq+;9`0imwTW>R}&7~H|t$E zTI|*y;6dD+Y|jvP%o0=kJdo&j*#8P|=b00}HN6c=rnO&QH^_(a$1Zv+z|` zzr|n0gRWjVWyk#Y;;-O5N^;C&{Zl=rIHjCAtz85DF(5?@jYXVS!6KG>O5$X#MVn2i zQ7?8hOv!LNr=`<#=lKDsZgB__3((2eY>Zhc2`oF9LkVfvvM1IrvU!XAgQ2D!dK8aD zfdzYYvMmutjFB#ZPlR-kNC2{7?#xzkG)_TD6>07H#U?2YK19aS?>iNoi0y5`zleeA zR4c9>Qa@;sDHcR6NCNcVB22U}jC5p|L?4@-@yjsDixp`ejfO0*A*br%d3bajo2|>A z=u0<^;>-Vhd4CJd<7x`@2=0WU&d!=@`^~;YcW4u2-&Wud%%^?Xc(RYpTZKBz6X=$bydd(_J3cz<@lLwH?=5rO6G%7SoH)MPF0g;jc}rUCZPl%^DJby@ zK#rX*9-i}+eYS)#ua|{moVR+4??4q=%{w#gcU|qrz1$Y2*mln(`ga{p7Hc>=eGVVX zGzf#~FShw`hR@uG@su8!v^b0$gZ1h69O!sjqyWJ732M!!=)pdIAWD?rzM$#mz;lhu zPRfHhMN<{bkmfo*4@rA}pQJW)whcj=cm7&kP`Q#xXzwZ^yxeg~t>Fo7czrNgvkpZ3 z+%K=x%&Y+TA`pXBsa#vN|A(z};1RWpqVw3cZQC~P*uG=iwr$(CZQHhO&+U9o+oWm# z!A{=fy!)KB*0ZuhMA>^1&C@NzQ)>2_%i@}t*dT3$$gLqr=~EAAG2r2kV5z!deKk34 zRrXOkp~vWhQHz2Vm#mA<5b5n9Ej+qCrlk>zDvE4!IuRsYG}B1L>8Nfa4I1_hS=a&$d3bkVN7un{N(;B`vYZa*Y8Uu@#ZS_! zd{QcN_br;bX&aVs-8<)VJ7U7qKmFk(M?ka6SOG>iB_L$CIdk^k_5k@qA(j4ev8t5!oxn$9C0B`X| zvehqo=w(~45P=7r(q-&85ln{|z8*n4?I?SW6gC;$Ux9rLev%D?7pR_334$Cjh{ts= z=8HS5FF?zI)HR?sZ*jjeil;}-#>eshh>0EHYWtdLJkV-{EqbPkc3dw_tCv*?!jrbA z)n98k2y~G65eKb(ed+1`fe+@)j=a4G$^&rAN>=x@(o(}z%V3GUEONo~>5aJ_iXDpO zxaF|Vk#4Q2tv5lTsJ6el9EtR{y%^n)FMxR&Es?2f$@TlLHy1{(^kZWCn=u4p*ax;v z(qSGbS;@xbpEd^~48d3}Kjb>ozG|QK1YaSx`pUigj@Nr@-{Yv~lXo-zdC7Joi8hwd zrAcD1h#;5T2s(dTc-zw#L?A+RWJcKDL4_tEMi;jn&_#tl%o0DeX!H`}T}1L*0WeM~ zZ2;p=$xWzCfTWPqa3n5i1-d&}3awE@Q=L2n04Wpy6{3wG3DHcDP6DY@mT*CxU;vq$ z@5R)dl|00N?)2#E8d2;ZNR^-b)ARA)b3!vKAWZQ(dO5kGyyVpykOBTk|27aqbh~A zGN#CxhzPA8vi1X^p)Iy~#~%=j6~X!LgrFfsLYnGm-XM}(BAOtHCcRWxd;|psFkRs% z(okHGHW?J`xDpM(NqvV1z3`xIB9GiOg2=1 zNM#PWYo;2c1R5U^xo}00#)x9$kWyDSG6v=e7C$2&UCtj6)Q@rq-!Q{wI-yvRluW9a zjlAR~loIodUy2pa(hsqO-K#uvjF169PT5iZom3|)Iw0LSjh)11Tc8I^ zxH`RMjHu|{qctPt0~bLQ(;MVi;M5?Za8t`k=Y3Rkbm0m%~a06#=^WOuR{W!fo=vRUj#qnV`8&=fT$e>cPJEx z1UH4>W9***HX;`ESo(B|f7Tz|{aJxN^5zl+Ag#Rrm1%!ghP{fbc5W&a1vlP7_-2yb zs-q!c8cEs%yi<`0_FaSFWsxenol;}<`A|dX=A*_Q4hQnSOYn`1!q*;Wa_%4X{QL+O z?BTSVuLXxM`mon`HkJk;{fyVvy93Q%_PPqHUpNo)uZq1HTtgEbSzW?BgA1q)YpR0) zk+H`dl>`uu6@yrC$JvdNi6AhuTq8d#N%~I=Kr9=`{xTT6*V5c3qB579P|6U9&A{=P z%{L@U9Bna4PvGq=8giQ2+JW+RR@Qh9;$nDG7FuM$0%*c{mbwH=A&Vwdst}eujhlz- zTt5I+svF^>YO4kXkT!N>5Xxf1IWsEv9F0+pk4kk=V06lhwb(!^R`m@Q$@vJ@{GCBz zzJ@5oj_p#bbv;HwBHNjH!+>^TG5n&2In^-I#8jnm9~aOfNq7NLV`wG~ZdA;4Ys8m9 zBIb^{L*Fx*CHx8iD82uTTK=>-3+#JLx(T#bk2}H)`|BWmX0=`Q`Wh<9IV)xQYzfi= zSz*gCSUy^!k7IpXie7@F*Rx0@=87gxnvQvVMVVQ!G;PWZ6l)@F*~5-?y^G43#-AQ$ zDH!K~owlH(uCr7lcUFm+8gR&OQ~^uSO4WXe6pEWMdPti#0*<}VfF8X2fL$oEm#@md zMsm?3GdYOS*fC~Rbrt6ZxA5lLnqa%Uu%^CYIs^DAO z7W)gDkX_3gaQv3n1E%cSqx=ge{=sbIJf=$-96#K99zD}Q@o2zZTP8u=*SLSyMy-pK z1WhoRIdY5C>7WsI46oKBNK!jMMWg~uwYbuYz+cxkl8OGpqWKa>(O=c8H)8fiE`OQu zqtAwwGvNi>(b_Cj(qA}ej^NLgI`{clvu7=A?Cprby}dT^xk+>P`Lv#U{FN{b5at3l za`NGjY`SZ!0qv=5Tn629NY#n-U~W$wiqwgS2*K_c*SQ4ZndiF^0~C_kmHT^5!gOv` zF$9xu1!P+IZ!gd#wx)u`k)sIWE@U3+5I5VC?H%Jb9FE+|31eQFnP*dfd+QaA=ay8*XTL3kF{Mu6k21Wg;eamHb#~eicCR=Q(6llLz(dv}9W9^jf?&93!*AYCD_D%+F_z6@s1Mx(xRbbe&;@ zK+ATMA>uw$#|w2}lVt<7gu1*{HNx&VWuW*pbRI+@L?`f(e%5kWNA2Uw;;WBeW905= z0{6-&=UU4~bxNJ8=z;__yQr?!Lbn0Cp6bmvlj4lTpVzTy;ZDcu!$BHB28 z)I(oPMeJspf>j(kJB5b6PAlP&f2~~xRBqF~=$^8hzx5Avbe0Q{N!o|8~?iWl#sdYtDG?toDL+4tk*ee6+VseQrN zYuE-rHX;7%8C9#S+rE5CB|Wa&U>vj1+so-k@2!FCbWkCiKPkn(4)-`+y(l{mNZ2bf(Ekxo;XWCoGv71ImJ#8Z7Rk@j^)p z?B5BzL#0U_^(;+KGVS6;y#oK>`KK1Cu(`PV0dW?fp9c9N$j6~@?%oS^0}J9ZXZ0fmt zXliooBwcp9iGi$=WoO$4P8ZUOiV`@~$Iv9c#efajZ(#(H6A{(t8Bfgmw!N?mO#Myw zrrC?gSzVo&NPbSxy8B;|IS48noF%wAh*{9Ravy%WQ=cUUIZD++?{$2{=nhb)v2@a5Hj7!z9X z%mdasz)eW54IeFRE?-K4ZjV}{% z{TJ6^@M#VJC3NeV#TFkoBhXTqc@NLU&$OsfdOaq?|q}*#tJS)|&(dT%0BjH=L7dSSuNZ=G%=*8}Ggu1TqsB zaTc2xB&$%20xolZtPEB*I^)Hv843^kn!S4W&wXei$i~RjOLmfj9Odc{Bl*!t%X7E* z2w3w(oEqe=ry*P}6D75Tiu=y0nu<8bQgmn4<)*SCS`8cj&F*wmz*tbvdMqFFgWPB! z13J7Qqm7k720$Srz8B#L`Po*Cz0* zoY{VSxN3^YZaPMfv$v&Yxx%(bdDT0W(_76j_l@Qs9KNPFjyk)umElc<(6J)mADmkN z`-LM_o2z7+su_uNx;ZkV5|aVyL__ogoxfqP1EGhW`+`|-y@;<*71@z5D94Tn%ej*9V;GMxD5uKvwDuw+`v5okaMb3n=(#KYYe0$_j58S@lByns$b2hldTl{C)1R450{E zuebH>v*>lRUIvoQfpItZv*32L$L{_hC^8FkGr%~8oW||PGV}cELHqU>Ne0B=q~s=2 z6LOr1l&WP&!G4O$ZFm{58%dFhY5I0B=`qx;JI=$05oj#hK{@=7vtFsI#-=Q zaqn~-?4}D06GtS4y!@x(`pXVT_(BzO%`(!fD(*{Nh6*;o5m$kMkMkcEN;$c%gUj#w zhQ{K}WzPG)Xm+FDO~1z9$^XmIt6HZbK|L)^H$FA1G)D6xK{GQq27r_SwX6*VC0b5e zEb0!0^NpFK1_-b{F^#h(FWK}!}j~n#v~dg2=z-85q;$x zo>P&QqDSbA!|N|@3!5GSTPXTNMkR4;g9U}E9(niK`P$H(0+$OGwiI%A~U~t z`=v=tX}fLTgbu-}#34oMLfSLg&6d&he}+L3`5lHvNwIj&_yCi~uPy8v9?d}02Z{E- zSwPVT8SYMaPZ&M97CNS~h-B?JVazjt(I(?(gcDk?aO@+~XiCvgM!;+Vd1zDL9?qT8 zYd?=58x$FQVfZC(jA1^&p!80Q2c&fD1zKNJ8j~4{r}Y1s*PGu1O8PLVodf!T{rY7F z+QRGucp9ZG9z;mtV;Y8VKxsjR1H(zd0Q9ZEWjcPDM=~+fPyqrcVy}-V_;dsE0~0?C zIFQgxUYi=&I^>ZsnC^AExRxo&OZ7o+pD$u8Y!p)tQoX@ zw}eXQMX_`Y>iu!ZA$wk-WZSy1uo)tLjWj=M)NX|g14ZHq7skAqfSEuqfCcFiP<6i! zRo;pJM0ymEId3^eeNY9&7FDBuNuOpBV zy>*AeWwlDw=tXjqo?nBVvEt-^_Oz~3>Xb}k6@O+G!7l)bFzkzd$=0Q%`pRb5YWbh+ zXX>JZIFX(8>}*Warp~6g*E+z^q9R@P>1*09u)$M$l5+jJ5o%= zd2%9PA2aMx(gh1zY)|f|ne4z#^tUcxd6fTVa13k5+y#iFbsFJK?j}@`4eAalre~^6 zO3-|;0Gh$=AJqzqO1N&5*CA&o-72P9E%81Qlpodm5$V59WO*E0T&d^G_`V1M>)UDE zBTl%F7hF>oO;F`S((;IOYO0Vm2X~9&m_$bsbHeeL;GkFaUT2d|3&r?)inco4kkmrZ zK8f4bcu~QZb*qx&DAG)MJm=9;9gmphpF}>>_w<#}RLsaK)d>E~d8p8$*ekIrJoOuX zbdfL6Zkf8bv+u~=rW7$x=Uu)YYg)L~qiN_-jhwQ;dCF=mU8S+41~0{fz%wr^%Mer&3OJ<#+-X=Y((i+_(4P@5I()y^-&%9dT{^d_NRE#ItbSgCC4M zb69F4zRrQa9Sq%@SF?fHGmLT4ASH<+3ezJ+or4#vJ5izH8P+lY{{!VuQafoHiHgqS zF4mS%qpzxR)Xe|Vt+b~>R;Ij|WiX;%!Z$dE7^j_Zz)OqHq^85*FXPecKmOJ1of|Oz z)a*Sd_S)iQ=^xomptpoh<8BNA2f!y`%;VAFwl8y`2a3_~u*E~v{+Qb6w?3sf0K zrW(pFFryk7fqJ0dkwRFhq9E9pM!Ab9^0+-Klf?yyV{(2_tVTt3CIsIeYQr*=JVfzL zY+5y0_wDayTPO8^76h@i-5et3;A>&r`5UF1S^4dzeK(BRg=@2D0uQ64$C_RN{ z+VlsLveoQELdlu#()bUxiez2ZUp)d;+FeNkNkz3X?W*v*bT2}p@-?XKY33GcSH)ITnznp*m8UNWyuw@%+5lNc~ zxr=3;)eXUwsxh+q?;wA!(+;hf!(6WB6D#>v-h<4(n=5Sn!EG-d(a?P`uByHI(Y<*` zEL{)qNfV<`t}3NU#^QAqGNHrJ!ufb=G8_H&l-qal4C)&KS7eiLTU;ux^evT)#jCTk z2OKAl+JO;3;3q>HKaDhQvn@Zkm#DNCyG4bN}M-;z6&M80#LX-^E;;OJ{> zYO;I{cRMz?x6I(##aN=-BH2CKdOg}QLHUQUulLPk!gZUK>!a_f*G;*7U~Xe3~NjZB?Dx6|KUM=0P0@G==tyLp|vSLk}LKyIkjIT;mqmhjK<8Of%@pX`2 z=}>es-dL&tV#Tm4~rTI zSoviLS(s~w)*xuA{#sgA<|V0Sq-rOm=av@zjU_S%owuAGZq_FzPOP6liH-_w2V~y+ zo#FS4{(qN0=_yLt=HCJw$3}?Mx<9|Cc*3Mj;D2kJ*Km?dRM1v}u>${ypQIU%u=Qe+ z>icU9ei}){hJE7vgp%=HGC)g)f+RYSRhxTApno|Mub7!vFu7?7g>3ZG43(#Vm-DY zy&=L;NF;^fl`%{}*Wu!V4YF;Wf}K+X^k=Sw1@diOyd%yeh_9qqp=*Zu9%s|TReP@X zGik}ZC3KOAkaE?IF`)P=kh^*Wd3V!=k?>T@qQ-fZpe1SZuZd0Gmh;73c>* z-cy_KPr6!%0p_2Z!I0H4g)j3X}9{n}wcI&<$dH-fj1%T|rlG7rT?=Xw;TuD}6RLm@F;DaWIP;NiOm2Hh3~ z;M3-Ri>Bq&P7SZu=(K6xXt}hq-K!{I*koT`9E;UdtzgGERtfq>530)r80q$8btE5% z1Wynkt>I7~sREb*i=cp(P8}LP0GHB(f$2->4pz;80MOdk&*q7P4vI~YATfH;#95vm zN@@V+-S-iK73m2Mxjhr>+*p4Uay}f2|4b6ZYN|GXEeT}PGjB33D%0eUgVr9kr@ADN zrKLNsN9UUz5AWToxInZju> zpyGy=B2cig!6nw&5f4EEM3(p^HPB{0RBK=dW_wu>rrhqKSrKRjA_jMnJIyfLWcV)Q z{_{`f;D=F1d_LCW1=>haprxtqx6Zv=T}uv!9mVHVjiV6CWSD7FLIqz)0VP;@Tv$}3 z>_edJH%NaYi*Xfx?N2b^d)vN-H|rv(QEq`Zc5~nEb?URHsyY8`%Mv(U>AdCSWFLhTSEq@V_sH#AO0X-6DWCm=jeISu{6TX z38f$PjQvY;{>LHjYs8HewdB!;3a!EVG%sVCRa&73Lqhd^=c3<))z(Sp!x=cB9m`G& z0tRycG;R!0@;M6#&}QjTqR|2p>qPZp*n_I)r2?EsAS-rNR39A8t0AXNk~1^D0IZ0=LjGP=(}fLq?tKY8yXP%QsmQScV5{8U_Pc|*TR(?@!X{Yp#c z*=6Pz?MmC8ErY}}lVy9Y#d+LF~zXMv>2kgCTTDS>pE$s7I2p5iZ#306^cW4g4h%_jAjyjhy5)0|hT zX#P0R$T#Reaa+P(g?@WyfVUxt)#(6h`O-OiKV8zV4x>VyNGve#g^`jpv{@a)R_I0& zg(FLLO;CvX;cGJG$-r5OhztrMdku!&;Ru*Epd9l^z7w}k^N&(io`qnNrc;oEqA>T` z_m(hSouOdRx5&G6ZP)pi8mu?z_MgObatw$*eu-_zEJy9nNOadMH_TVW5Vduia{=qT zRL@S6JVzzyL`@7~TONBabA0fpWrwW_5q-M~rIpnRnZJF?rW?bRg_%kM7D&3jAq?9Q z$FeSn4qmUY!QGCMgYoNXHqH4T1J>|NQRwNdgC++sU>zZ*Lo6vH$AQd+xQr(HPF}?l z(zrJq5kR8q_CuVPOXAgNo^dSh3{Z`ln>}&*!Zr}n-xJBs@}$dX4L<3@zvoO3m0p${ zR$j|Ot`8h5?haD5s{lf;AV!()U`h&7Bq>DgRUQ2SH_9q5^$W%+LAC}6Ml=6cqPnM) z8OA6={M%M30zW9YB*y8zM>&b<19KasgInG8`Q$*h;CFA(u@boe& z+JL6BN@pQSfyGiqKLE*>>LED9NAh_+z#6X2(wU<1+2pW6qJ%3Kd0P#W0-S*-0SRD` z_qM~?^9)2Tc>tTa7pvWCjcp;lL}v1}Ge6@&IkkAc(QxN-BJYrPs1+*`r63g<}kV$0_`jQ)KXlnmkBXDr8}*(zQdevm8#{Lk`~gqX9s!R9W^wsqL?=VUh&}z`R4<@ z5<9%Fk1RZ~!;jlBc|z69k4}4q@r30=FaMAMJV}e@`vVV%_d^04+;Ewz3$}0i?`2?G zO*<<)ryB|1rbBgmPcP5R2c8Ow=EWD_TKhxg7Bo`jHz}xKDW8czq4L`=Tb-Gen~+hJ zs!~-`4sHa%2`Dfh9!}~tT<%Uu&=OD$6xV*=PPk}-c_QJ17WYOX=E%Ui9-?6XAVY|$ zn`S_2S))k@K*@yPRR{9_TkZb$yWZSyz<+F2x$Hzyer{C_;@OoJS2TkG%+;eBcaQvTiOH&yHk(`s+n>}WLjDtF#H9l4(fdGj@_DYy!`+<(pig4i8Buq8A6eOOIz+mf^kt{N>?M)gI9SEcUk zded-W8y8;WWPfjX22>6>i+aQB3TRbGo6-S7E8|a1=l7|EZXK4j|$8`lwjXdF10NVi#lV@&4**427EJeuhUZk`p zY&V;WlPiLgqE7BOG6CNZc6C5ZX+kK(BlIl+Pt2;;2(xG!#g0)w3S)oo=v#SDuDluhANuRlGODKw^k+?u+3Ze#{4d&ZCyyX9u7XW@v>ZUVG#wPV3SStjH*NFth5a`EH4K#yYwGJf*JPqf?lrcLJ zv?O-l;%2h_0yWE8 z3!kg${Y1A08E%B-)!TotW%Y!>Qr7$dJg<%*DZf(iW!!-q(=~J-T)hz2_vzM9hVx^@ znuv9NhlE80Msgh93ewTt16>LOb&CJtSOY#=NHgCLo4T2cTEVsRRNyI{>Pl!g7N?UF z$FH@Lvyhg9&cP>h8>huI!=%}=c!fd>F)oM2ka`71h&wWxpf6HwBV zmww3hAg!+$Te>+0CKo*8?gB=C_F5PEuj#EPA(^=sGsX5N;soAHwZL6-&_bEK*PyWV zveL=h@E|~3_C$fmDLZ->r{Wv$#A{2P&%_$1T65`)043FeZM_a9U({eYPzH?i4l5ZY znku0lrM=pY3-!l1a@81cH4-C@wV=E8SwbkpY8!}?v?P?UYnBVkuNK~OsPIkkHhbAq z!id>AtWs>20Jve?|bT=ahm3!v{F!{Nr| z2+Q(lLd|f>&%M*{&NH9^!G8xkW$F0bS z#e%0D)40;t2ts6Eju$qr2DozLaW5vup{5F+|CeGxikUv_@mmRfUQQ~XN|kGm=K#>9w<>tLNUK4L4L239u8l1VQhoo zmuE|DmAl`&`{?vKbtAD4f8L`@>Y}bu-bW2e;r>{tw{nh$XY^n;vc8h?T%wtUUduLV>2eEz+beP`c5LuU9YA+|VK&wZ>^o2KUBW_#5WAHOhrIMxb|zfAFN z;;fr>NP-to@2=1hv~qAxH+fuZH;+!n5zMQOyWY9CxLL}J?JXFfqQZ@x4k%<@|0DngR&wqHIKcbosc+TcFg&T_XjhTb+$?~d>w`_u^%y^CN2gdr<{ywH zFtI2A*pqRy-fwr4rXfuY*+O|t^Q`Gs75U#em`!ynh}9fY(Vr68ODP%TdZi0cvu&^U}CAmPylXUrZ%L@BT~S?5(701f66=_WHLQ1!SPX2<8>QO+SM^g+NZ4GdC3 zMrOAZin6NaSu4g`a;%0viaiB2;m?{xEJ0_WS+2Iq;#K(-z8W&$4|CkQl&T0MtPa%e zFvD|zvfF|Ng^Z2LED!&;TJvs2JpxooINJMR= zA?whX^=)1#r=->U3TOf>VxENL8w~EZN2QV-eB*Lqa?t$VuHg1sip96zy_g4?hnD@8&G7tIMSL>S*Uz&K{(t3WkAXTvR7yneSVpao?cv3b#-qrPA8|ruj4y zQL>{#7HXxI^kVZ^h=100N%kj*8QCDTVs+G^Zd)e^4|((bvpi()T#K9&sR;je)skWg1Pd{GOavTI zm=ohT)1(lA*6)pvqG1SJKW3o%M~C=w?mH<@`%JCa7o!|VMIX;(77(Se9o5{Y85Z!= zb$vo3uTJ3-FCO2nI*}?H(XXH?l5)%vArkP4^t9{g3M@j*EM9z~!$lhz!3uNhOaiF5 zWOl+*%}#-9qkZ!owXRIo3^WKM(M>5Ja}h%{ibd(C+Ev`Rp+oD1HzQ=u9K6$=#LLtC zQYN(^jUu5k9TkO76Cf$?CMnY0tU!)B#UWAf&>*%1-)%|L(L~4!Pkt$?q20doe#`%Z z*Q%A_maIC4WzPshlPLPG{)$3_g-0v}psbmyA1ozGN6iSr>GK12=$WNJj#5K4%;xb* z;;ok@e?8C;%trYlZ)Rq**%l}z#&%;b>FWx5M>ZoE8d1n}d zz_#Knsk~4I(dmhBIq0tk5SCXevgpfJ8sdwlk)u6!*hQlXiFwu7k+I#?e1)tU0K1m~ z^_glV874k)4B0fhKLq+S!={AKlkG0OYLiX%F-c{R(WwK!sKs+(pnDjAyHTvPS`m)9 zLUq0%;TI`A9Msm|h?Fl>TP#>sTJ<-&-a}fWm4iGx`uLx}H2K+Kl%WbeIz<%f^kB1O z-du}(XIA7U@*{ADyj!Fz-uc%b8*Bq8R6r(R2jq2s)@))-$Q7;h3tEn&P*3dZJ#&sp zIz%2|Y)`4F&ZdPuFe9+CzVBz%m<`DSmJLx_Zw(;SC5m}D(j}TpU5Rd*x{=^&oR8J2 z3iZ@GBigCAqP`M3zl+tC)Z`O1#L)x%^Om;?dMzofQVq!9K~ho>Yhx=Js{<}0%d6eJ zeGK?qM0a+}s0IdMNFna_TJySTtZBa8?siJqEfc(&cJnp-n|kl_5xk;idcblGqP41! z-=FBBQ~mfl8#2$HCYd98$?s=lHzSL#k&8Y4C;sryNMO15<7b$EkP2q9HxUpt9KQ;x zItW<{Yp{r$)0%!{VR!Gz>|34G=2Do)_h$>&chePV<#fNpR)%jq$1?crT|2CsRVxSr zDR3mlT!gsAW0GomNgQk?3|5k?QY78>hRLaWE$&mN16tSzTDr{FV)u>5G0SQ_#Bn$z zJ_hfeH&cB-+{j@6=Q}V@7)3f>`A+xjagd?C59{bEv5UMAq?!t7eX z+`k}zRUyv)=mZe!kY229nZuqM-l0CjG`gF3*_o7kG zMVmXB9$0`Rmco-R+EP6qnC;ic;MOGYXULd52lX*?b28hwwW*r=Kc{$eoOpgBAVqE# z1M7B7m{I|*<`UP^mQ~#l`;vMLZKqQyxn)_1xB3s<(I98;JFWRG5zQwS{;$R{66w=L zbtpIKjUS2%)OSNN0{Ot+PIr}9-OK61(IIMJnOzff^IeXyvU#B!dLBlvoB>AODoM8@ zkZ$$>2`^k%#@DLYMp15vXc9Sh(*wja>|71)F&P6N%ui5%ez`7oi(YYtSampfngWSL zLtizOa1}fV{%mqvYI>qRIoa*v{VZ@lG`DIrDTvj-@8d)0=WJPl&&Xz>*XBG>9UE9J z=O+`zcp7u;Bm0+$#wuIZ{*X|f>iLz@2sdYlyZdNJ$3HPYbuz=-D`6r{T8R!gOBA(z zBS|bpQi8Tnj0;c)r{W?VJ>;^8!nAv2u`v{JDW#G=PFw#z?)S^1&LjBD0CMSPW@mTz z40n%M(R5c#ICVAs`}*{A0;SHT33HPLz#S*l#8uEdq_#dGc*B0egujq(#h1gjZHPda z3YEqq#S~pfkkBD%2wviA91v8PEZp=&Kk_^;M4_}XGu3Lo6FLCQF8ynvnKVgW*5QOCJ3Ji)IYBXUcJ zO}s^mu+1VQlT%`ej*`org~IUhokm_`-UUtR5^0Uj_#emQt8|6!%;~Q)TJ2FIFeZiU z!*wd$z8+rinv%VVj^gY;sLO*o=jSgS6nf{jZc}7oNLGRl*o7hn#U{pgkokfSOld%A z`yi;&;l_6g=an)kR6dY?P$l{_eZADMMXOrn^R z?-0IOHrg(msBs4D15aJKMdfi}>fpz|1vnYKDv)c4eE6wk=d&%ia310kc-_0wj4|=} z&=H8Dv39)R_Oz)|*OAzbI7L?*h^%OZ^}*xHw9W0JnCmerXIzCv(}sjHW;j==G_o9! zWL}19fPSh2x8e9_#hlLlsT0?mX?=Bjt4Yj2)GUgm6lepPI&2*b+6H6m?8a;&G%j<@ zO599ra77Bpou5giS@1|`Z6=1+#lF>wHujeK5B>Q75a02Y#ze+YO|?#X~ycw)~(90}7rg zR17G5$g#f(W(PT$^;c|}4Hpvkd)PIQO|O|#T+tfMF^!X~U^M#6ma&gnKr|B?1+~XO z4*VsT3KD!}7ZzPBjVQ?NJH4L(KVf`t<%(%?SR=8WbpFm!ybWG%y-#jabr-|$#p`n! zR|RhOn~Mei2MQ(8r*R9NrT*(tL+BE;9jFS=C3^o4HLa+a_^6}^{7Wb%2ZO3a12ET# z6KK#?t?wwo6I#iDF2W+YWt&&ihSDKaFQ8y#U-oE3NrYcKQBEnmN^}$z{qy*!{qU&B z`k*+8svQ~e5Xq9{#T*&Q{J4OcfE1~O%H;ST#~Mi*B?+Yol}TFB@i{_qk%gW5VTnm* zXMmi`oiLX{TFk(H-KKwPj8cT*kkuga`pZHp|9@ROrgUr%M9au}KK zmox{VkOxIYOAC76pLTJeH7Y*iIl9eB3HyGVZEE6bJL?ig9EX)Zw6neL?s;O(DM#h3 znAFUrn942XO~d3^M)hr;uENz3nC)FPjDN}fon0x;%^gXkbHcUqFG+OS&#HxGk&HSj zf=UO?y9X@yz&IUU@6fUx0-m`)t(?d=s zk%vG3GT4+&Y2Kz&`P@V!-Otu5A)UqI1XCg8^@(tfGaXPUzUXEsYDR}7#JQ_$L+SBI zyD|Ojk!7~YJcrDHohfolK7qlP?pbk>^)OuPJ19AqpZyQ-MODufnuc(wdvbJwsq>@e z?8O+(V-^bQn-CEaxGjQ4l#_~JqDMNr0buc8V9lFFCd=EY{>VL;#o4^zxpvZrm2#UH z=LE6fetfoxWhk{B(;7z{eL34St8Mim1jRhV#e@^4U;a0LY{XjsJC}6E48F-Pxdz@~18@#xT0u}_II<+8^ zb`-v>f{@ri`rJ*L5+Uz~U7ejoFb9h~#PlG{RtwvO`wi5Ug?QooYXnA7hE!vzM=*hW z<5?Cthe6awzeqR!`OT@#yRq;{gfxyHf6uG%dw7)6siCF_2Nck@?uBQ6^KVj*lnu z6)4DbT*FwEIqNCWv_OBp`pM)0jr4|>)3H3GppE(oxS|5PN&CwD^SvUUT#z!IttX$C(S!;aaVK z-lh6*)gFH6NbQ6JawAv9C$Q&$RsMTfK8;@J+2#xh>MYD2{b~1cx4ua*EzAiZw$%To{9fc6NCzabW@mz)E#smk3i&lQo=^i8Z%*2jLE~ zbLCrN9w+~zv=E>^AE8=HdIXtaf8E84JCA8Fl~Y$Yu5h3CM-F{9AxdGMCeYcN# z|0RVE5M7I=+O@bM(o>652Y61Z1v3{1^7(+sT(kRRkADI zG1E{xo)omoacD>v6;@wqXrTIY_e4n6;LvM>y2Fe+0N6OmOsT#ngrbsns6O zd7ak4UIO9cR0VE?jtZ_dy9Ve2d$h6zL4HX;FGEp~`#8TWJ2|e;9Ge+~rSF$hK=M!^ zjU3k$y9FU3-9*8r6g=Ky}Aumd@de;&EV_ z!wI(JRDYXfxEkKqrAZ{doOErORd1+z3M3^wc>pV-%dELs3_K$!%9+PI5n3 z`W?RBiSD66EY~bpFg`H-SebifcCz^XwO+n%(nU3 z=c$6U3P728A}uQ&8Ai#J`@gW0Uaxzu36hE<6@Rde&w@15cVtm19F{5RuK#S9K-{Dc zhB8|XJExnYE%OXV!DM3QQ87A{X-%eci7hO>5~@Q(%uuEzl9 z%xTVDQm~y6S`YzSNRCMf&{e*>RmdFHzMZeui6ag!#aVZLeOJw%M(;xUN?CR`kxgEc z#p5E-*nF8lWeg_eZCdGhG{3&!G&q+jb~chU^KrU0QO(*%aIq&VLNMz-|F8rL1267P zFowcI{6XIp%)jIro$#UW-Di?Ly1Y$aF~Qb`D3F1J5soT;;(IcQ`O|PWomT05Nj3s! zkg8jNj?&p?1tX=WJUqP?bKdJE5?V_PHpiLYc!!M`^PS?{^FDGH7q? zPD^$S#gNy^?(6n^UyUoF6Y7K=rF;DazGEbab8H@~=$2)zB4~*%jv^MV6w%ivZ@`W+ zAuJyk*JMxEj)A^FA_EkoQ@1UwLymjh(_DfzO~c$sHvsWGXDR1-(fy=7hJW_&EPsw) z{sI1D=l8i^k{U99o&B- zYpFa{Y*2gZuAJ3)UXGFv@!Sf4eYw_^?-OiKQ@!p?>KGSiVEQ2sy6L5Oc`oPHl2M#X zh!7yS9Ul&U;P#)Dh^07UjYl(k2e#ZDH8U3E?k3W^+4J)C_Qmq&wxOSKcPZULfTPaB zN*iBUAyep&+f+Na^9or*xOVo|&)cG6xk4aYSf`NMQ}dOJukZYNM!{GGc{ckpe)cD| zu2m8AXZUs_rI3Fa1960M_+JNvrpSvsrF}uJv-ykT=>~Q`^wUyP2En*TP7_5pWoU$U z@y$GUp~J=nZsqr|O-c%4i{1em|Ij!r8K{}!9-z>d3=r5f?fwtDoj%Ebud%%x2pN1E zZc=If=xUN-jRk6D<)zIxV!qQdEM9dQ9}4f@1IsYCSpFIj10)k+RkO47XO|8`aa}md zzw)3L#(crnAGzj#{cfVcysOIHwqb{h; zX9~UDtN^Ip6_&U!>PeGel<8?!@oD3)|AVu44AL!X7BtJYZJVcT+qP}nwr$(CZ5yX_ z$~LCH+jlxX7#+*w;1IzCSs@`oGm?oEtNq1A&BWGO{P~Ne7=`SH>J4K+Yc~W7OY70}U62lZ zR{6>K@x(Xl(A2|e)2FxV9Tfx`gLK~-N~Q6TdyF~zgTxMs_lpVRe}6#WoVF^Vh0Yed z#^uf3+~LvImnBi6;@{vg)mucp z!0z6Qfr&a8%^_J2%gvwSv%>gz?-Kt8=6Cg(#h&#LZWJr9C{z1&4>RzETN4$#DyDs! zIl+mrwI%ItpMC1l?*3t>q*O8qiHi`DDN6Ja*cC_C>XU6JOe#tABG`NTf{;DV>x=lN zC$H`GwC!xbg=k+Y8Q!}*J=A=yaNbyS!^-C6WaIOIbt<04=6l4QEQ!WBsdQSLfl7{{ zalRwH_t>$*iZyMm2d!pGHZp6)Dhc@!1yYb{rg!Xn_L%*d72On!Q87C$qWxCs>1a{= z>ToK1H#_~lNYm=O`i71(gNHjN4aNT5nhA4~zi{-?gk}}b1tMB;kW;j}i4XZ_1%mv!2*{-YiW)mK<&IKBxouUC8`ATM(qE;?&L5>oX)#tH2XftTR zrP#W^B#%tw#_}L<9nrk3N6GzdoHV>?sEpDpkQvCV{E=+;{4f=;GPgX!#eokZJZ_|- z9a48mTj~x-bFp2$Y(0czQ>YEfbTuU|O0XhQ2AUDXHDq`#xD7gs@bbzR!jN%4>aQSRIE&%DZW+9rQj$`qFi9uq<9;9)pF-IB0hZAKlmfl5vkJZmy+@(zoVu zm<-}#fX+G1CL?x$K{Kk*mW)@+F#phnY)nZqz56ff!42E$TXHcQkI8H-`w-|4ww3eS z$JNl6xJB}DRT*$U2{jPVR1cN3Xw|7&?raWv-l3g%+8CM>|5E~@B4xM50P`R6aIdnc z4mohB&Nd2$tG3*QKW-$Rv6ja6rYhOgRUpxiPa(yIqpprqgz!BvU+)om?S9JITs;Ws z_hSmuC6mmlOUj%=Hm^&X!yhk3)$WVnMZPv{hvC%ZwM}zeO~~DCltv3GpNj@j3Y>NP zrX=+YzKB76x6s}G(UE2VqdfkB3(nIKX2xpOemc|K(mb56?;M~>I0G${QL}p#Y-8gO+27V|%MG+G9 zCIWS$bm=6n`_fvnY@z!ke^>_%M|Rg|w%2QwV4b3$CF`O8EVkI3RW4f8bpx3 zd&oQ*4(W#)jkCeg_L_z(Pih)wbwd_gLnX3zB-namvsmo zIL7)*ZeGYQ0M%E(<1mI1G=Hr#ofM(U|HEQ#<-BsXJ_cn9w2v>556l#o<~l5_#{ z6!ip? zYfKD4&5j7w7r1g4C`%MHoUJ?UX}t*2Sq9E-;&^0d8;3G*Q*tm)P9daLtM zD$k5|n0M8EN`C{oC0)RkqWJthZnc~C0 zYpk{cCz_>K55Q_atgUEr%Xn&liK6u-dGWH?YVkiXy zupQvrIfM)BF#aty8Fx%D5lj?c5+;4=!#;=G`)PU6d*Dcg&wIY}O;QDWMhK(8p&loN(^>|(-elgfvyxb_t-3d} zmnUN4#BwSlMO&gHRO)^C*yCZ@I*M}0q+$i^4+;3tacDde78-FYi z<$5k>vpjCR_PlShic;+6;(F0n0kJCL`3(p1MGo0NSR|@!Hs+&@As~SV+m_&Div1}7 zFcl#R(*x(q`;{P_*^m}h^q_Y+3cqNk>0*mq#It~Q3cBHahb^R-v`cj2VLF3}aq0oo zn4DK`1g}2BVM^&)py~kFub9|K3}eC(@C17`>5j=2kR-NO`;vGBjzz<5G~ne#2OJ@h z16eF4!bvqkEHP#ib=zks?rKP4jKB$jw1h0`0RSJ}?BJz8q3Mf<(RIThBswbKV7&&k zwLCtTr>TJsp500QQR$8^7P4#XAf+?Z1ti-jOA(89{w!1AG|1z_*v+C0UH$l<#z*RK zm){`3FJ?4e7w>RY>a)K75Kct=lUfaqU=eke`E9>F7=Tyf za1|JwTMuBRK2;&@!DL!;jJVEhJ?WK@AFl%sLDHPYK{dCrHaITJwgzgq6eAI(xjXef z=+lT`Jv-+Kx6EJ!-C?&P-!7UehLq<*vz1~kbWgF-dQH1oE1o6jcu{L}dRyi!f&iXr zfgpd4qh<3R-QLlCzSNSz=+GoNBZn(1TcMX`TRDen#Gv-A(4MHZtEjs{c@p4AUR(8Y zT)ANEtA{J?-ZpE=!tyXJoyssw4fm~`LuYHLvtaIwj>qqljqaZcHNg~XXo0ErxXF|k zUtB7d`8p4^R17PKM5lm6z|`c5W~QX@G#Mj?IXn>$u$v;w%8&77$QtC)9z>&#@Oxum zE1hJ631?cytNIPJ5mR<@3KlT#>7ET}29W-f1DpdK&x!IX!PqG5_ZScfUP9FZVWLSo z+w__s%Yt(8v~qCZm#9L@cO%qxd<=$y8CGU^GMgZ*ZR_lybolT2(sjL)?q7?p%lC71)$+ z6Kx-z44Q$oeY+do`8MjwMB3shM$hts{s-&NrLR*tBxnRFW+&-eXN3o;ND6__v~U}} zw4o}*JNJgpPqOpC@j55Z>4X+WjYwiLT%;!oI<5ly)2W@KW^2Odav2*rGxHlDfMBs+ z#|@yr*{@;o0rr0uKo&san@~jEH*e|(S|H57vH@6Xqg1QOqjVa^A^~58;W_?-1`N9X znvkGL#x#hv&Pl>Vz|uEUP{2~*7YwDVYiL^;SXfgNsOTV}V5-}hC@2#HRGGNEJv@yA zszt(@#O63DOLv?D3$Vb7%lf;fa}xh&YwBHe+8^b_W=PXiz{oh{maqtCdh(w&EkeO4 z_!Tpc@P8(zXw%Ea+h5=>nbRELHz2dx55j%&f5hY~Vz`|n1Wi)^ma;$PUg^|T@1s^< zrWrCo=mb?HydnU z+n6$#28czXaC%^j72=N0%;FOMxd#R~2+{kw0Ss6q_}`p+MEU$g0cKudh0kDurV0P^ z*0#^JYO1$Tt1fdi2a&4LV2Y#_A`MuWq@g2ckSV-7_- z#)t{lVf;@B=)BY%&4l#a6uqR$`dc-#ZIAUxT@&4TWMr!fd69EcEta5)396a#NeT)n zvvi9m3h_I~!|kNJtHMM`)LyW+3ynXOqoeb)D=gG1>*AD*!FuZt#M~WQ)Lw}_h2HcT zY8)ar?-NEPXME+jDHw7on%6?x9FwmGZKYTF+p-g=a!OoTQ!8UKfHsMurRjH$w>-{P`V4i50*>=_(#uc=NJ@(U1g@-=E4qjPKz{tVH$b(u= z#TRFAd~RxY`UZvfx!H7_?osE%7;WFq!jY!{2;eKvE_(#&kMY0Miy_0{o~8V3JXUHT z$(N_)fEHFevC*b*GirFTI~jcr*NL9DOSR^4U6Pu^#Yc)o*-f>9PQLFyK+S8!Dl-@) zn!9LfotR8ANvGU(DimlH<=V`H-Ttw3_GA7VHJP10Si7QGl~J**I={+4Rb%u0{nNw3gjMQnJWayC z);Qo%8Y?DJIQSIg3i)2Ox%pA9?P5Xwe_7)I;UlPGB|5k1dt|mZ@tQs4?@FxX?8I9% z6hOl#Eke_8Mq_F5cP|`FPRU8c%>CC09NOQmXMSt2x^4sa>=0#{|D-#5KGYD-{B8LY zeQVMTDdMkzsXGh$7jZ)i!8c2-S{jYR6{9cL;*yidC>b7+#+XEUUtY(7+wUhvRtC%D z5w#7TqywT1cZH!4w18w)M5bjL?Tso=MTQCT$n0TRRZ2^-3d1&mfs~GQU}YR#_=g+k5@_DUk&iv_4nWj-qxXaxsPVcJ#h#8tvBDp{#AVyHA@F6fy0ytfkDC68 zn$0m}q65oMm}VCRg5VMmy%5em<~89oNT)RYxRV0(8BCStjyC|L00jkrhsj#VM01f- zhmN)za`|@xP?jeDVBv;)iLXk~tb&8(6h1mwtP4{S;SpRrMnbEGVQTOnSK7tn0RMvJ zF(ja6xQ_#AwgkQOp*vD=BsCf4!*r5vK~I#p7v1B$4OLUrFda5FwVittJhie}xS4LJ+vJ=Rp#TXock zW!s!BpuGsA+}Nm?HTxK0)1LLm`{8NL(3A7R5<}WrEC;7Dk#b$)8lcS(k-`S*c-%qv zBT+QeDzKcK*}$IVUMsqHGjS`OWXld#hvst<%<7BwdEo{7cg)^bwU3F7#%Q~1tz?Pi zILhYx2o8rY!o&zcMm@}&Ri`CBYYsppZ#4@dGUPzl7JVD~t&j;P$Hugw>)kBHiNv&W zUA#<--0Pg^a2vyTSKy8OcQu<3jPT~+Q~Bip$It7Z?2ZRpQqcoil8pd2EQVSbWuMvE z{);~wGiq6zxRZ1Z=A82rJ{w2@U@)xW6<;nal6^ZSOzY5?f;#Rxm6|@iTztHtWUsRA ztELv`Bu@{6LNDB|Iw*^}(a@YiXkRk#OzFXqFoLoG4u}o+`05$8_r@g<4 zgej`kUkK(wBPcK(-ODr*=-hT-_VV^}cj7Wi$Zu$?8*UulKPsFKMB}AXd9q%7asb{{1*f2Iyi~ee&3{6uBr8>GC1+;o z0kwJ*h6)!)8!1IjM2}ddhW6?9z090DmUnJ{9$CjLgvsgZPjDs{Dq4S$zyI6Yl=CB} zKMtb;?4$+Vu<#tvK;QALO_Tj*Js#Yh`|!))ATuST1kHFp4Qmyh&v718DygcMk z)Aap<256A8dbkAg|IJ8Tn4Oy`GX8ghVRm9p>OZe~Hr{h_+p8~kebCLRMBT1^t{<@kGy+HIxxQ+!Ww35ARsg4wd5D)gyl;do*v(}DBH9 zE7CwYoBFnozJukZRH}F^tdHYiR1|@qu&@@7UqILP7=XO+S-E_HpSXwJk0Y0RtNc$qsZNwW~UpB@rVSe-z*H^ zH$(KTbXOglAE0rUO|YDBoNQ+ISOwps6qA!nSXM=6eTYk0x7WYD8iQ;t3F?m&;}}f&dc*6xgtX%|hDYzoA>ce$EPuvEHquIb=m;Z@VsTOClL8i; zzWN&L(S~~>f``P^ApDCvACl$;4xPF~&3D;8JLG%04GXGFPWGD8AIdC1YU@|N8DiCP zx7v_3`+=VQtxQg#witP|jgy@-_@%nP3DlyzET0>km1q^1LO~TD-f-BzhYf4yQH~#e zOg=dl-$yYF0#2t}hz&DYMsV0VIiu*OOlm(YE>*4&&rK5BL402u*M}>h5awSFI2D72 z{vhE<;c}ois8&d|;jib4X*NtFAt)$NPSn&cOv}|MEUxItNLld51+Y(rOK-`9`{m#2 zSUF*fxqkgNd5PKx_LB%Ky4oN~uBN6gidMSQrWD6i2|84P?fc_EXAc;H6*f12d(C#l zUFQPwE8K6kR7CQM2l?*2Ty5>NY1uuPw5Fe4RqN{Rd>qpH9!HIQeia$+o_K8-u4wmG z=GC1zd7n;|u1{r7eVWr}Ek~KsTcy1_t3AD0>PAPoMR{)g*>KyiR*~6itZg*# zAT=qvJc;@x`EASx#59^L)TXMaqOQ?Lio_T+`a_1+$G*s8F$%slzHa?az#7VlYTVH~ zT4MWHdhbrh6EFI5I^_AT*uWIw$00&Wgd14=YTecI@6SnSCQdL%+JbKb1d#{09#|BJ z&ingWSgsknO8feDYJIEJ1P=rUwqaXr?#=Hx4;i$&GHd?Xs{Uu62$6VeDd9Ei7)4lf zc8>;qp%|5}$~xu-zyFxB}Br`48J*bc-YgJ9n#LF6$ z{N75=a`SUAO79q5wUs7PKHQErXZj){?Hh6LOg0&%(9r`}xJEswe1s=lbv>xO#0nuz zUUadHUEXAld=zL!|Dc$PMZ=yKa(jQyBPS2vY;DThfd%JwOdnom^b?D+$9m<+ZUD0N z-IIME-e#n(c%`wuvIkdmDQ{D;FR3-n1G)cDOY4BxqLBt^`E@AlJm0m4W-C1FbJ6ua z1E#I=#N>$#U?p!;`S;JkuDWzWMjyC{{Kw*tqQP=#KKW3_8v_E*c_vvrS)a<%TcVK^ zga#BCa=p7oT%Q6KF=|K!z0uEzls=lME+NNmCOE9V20;_prj3@@mm_JClWhp|9+1)uTa$A z6xZ&esX%VgHloJ^U$VvisiXIuKE;{s_2veb7X8C?=!15ZF~Juul;2p-`1!D#Nn;%@ zvTF#T>CM#NLe%dEq4PsBI9$v;Lmdz;QI2rpBCiO^3xU!{VG0>BRakLq7e!u)Ie5^l zkE^zbIiW>6`_SqRG@5XFFveM0*;km2E@FjyN!=Q|42e5sh$g^VkmX}@9*PG^f`v4W zT6tupg+AFJwT|MmCCC+a)669TU|x9vDJ|U?;s&#a%}J(nVzLC3h>_$|io0Bo2B6yO z)XG97%eik%1a;~4bh*&<*IHG#I#ooqZu9csp$xMSBco;V9LTk~Tm_off9Oz#e;!_B zYN7FTshgB+MZrW z4^jq2BcjW6CB4TG7{*sa-xxFpAnnkgAz9p?_!b_MSOjdIF|4`+hy0U5~dUoy#Ync;@lkBcs5)GtqI9;_(@Kmnss zEIZ=zz3>q+z!E={I2+$vOxGN%Xz)VzPyVsnp|!kxn58^*E@LpX#P9Fx$3w_(7bSJi>Lylv9;@l!&VZj@ zaf*qs%P3@fQ7q{feCmySP@pYoQ?2c(jzlia|I3)nHaXK$IDnBtbHMt`{i5UAo;Cnt zi80_DI3k+Pvp(sJS)*N3O%iM4dGhr6%c=@h$=PQjInlA|Dagb(dc+|)MwWM~{s9=c zo<25;f2-xKyrsch3T$jd0`igSSIH613sp7C4*>huBKmV(i_Rd44jnJBHa$D^i9HbK zidR~%4w5+`;Xl~NTmKHS0@ZnAP*0c>r5?8+4p&BSuc?Z6PYp)|OZN2kvF_hz2#m<0 z{vLHEcP~MN6l}gk+Hc;v<{3T5?639o2k7^6N}r|p1*>EZJKa0AJIWR3FRphdajsq8Wb zwVp`emRkRNC$6Tru;sF%WRx{ddT0IdVXM7Ar>y!@oa#63?FPI5U3GH9tlpDul-j0|+j6YJXzz!@ z(sM0rPXek5S1fW$yn62hOsmruuF4aM0{1n?*;zpOkMUZx)`&P_+DTSKIoa~(DpG8^ z>JZmVOeJ2VCtQ@0$k?S{5NEj)#~R|>$^)KK`~YE+TyvT^r^-6M{WxvpK8bC5baVfQBbtroA(3aVJDvKb za$s*{m36pI(|~m;42?XmWEmUCWAX>P@PsUbk{yP~`nrU)BpV?PP^&FNPQ&MfBG?oS z1kk}9rglW-*5Q%sUm#afuYx&y4O4?j2+|y!4)wwJ?z~p#gX2Irc4P=xsE#7>!meq! zabKeXAoaE~AyASJ`L{B7{O@kJ$4rVExCy4Cnk(k{bEt?rCrnRJs=P<^?{)z@edkoS z`OmQ(3!MQP>)gQNxNaaW_H_1$PQk83v5&EGaztxglzf|Omse-r;Vs^u3Ko%^kQl3r zty-~~Dl;S^+k74B<%aTlUMmNwP}0WPGq&*DD)OGtJ8B2)xINnX88|fowtFGRBj5i%CB5uUvm6lVrg}%O8oTes zoBvwLQH&xioN3WEq}0w48Gf zfC%dw2a(6&^I`?F55ob3hGV39u$ssVEioU}|J~{4Wq-v`43{zX(6=W5sI}z;cHOp7 zl(B^vM%dyYJ2&(fI09^VH%BmuJ|D5gFbmRkCM+`toJQ*#6``~oiv}FFfyMi|y}X03 zBa-t`Mb%Epn^d?bS476qhF59T98zgvzl)r8!s(jL43ero!s4jCnFJu8AzSbbrx-5O z+}IwOe*Kh_u*lMTgvd!z;oTD~S>6#etPk1~HU$)CD#vp;Nq74>tjVDusAmeOPX4jI}@D3>5K4}w$&#@bK z>XZGdrL|XR2~-E<~XJ)wz}Rv8m8}ZD1u4U>wjDzlZQ>C+5@byaB_1rAZ)v6 zGxKi@bvbXU^x(U)(`iVN&A*lefsESB=xvlG=;rTb)xm4kf`B=-eepmiCJEMiv!Eis z$8K12XqGj`xczz&Grru<1?M3LCT*p2tw!cf)+Bc8MJd)8Pap20}c?O z8RT|qw{ES-5EHEO!pTal$L@G1{%U}Aa4KKVP#iHFMD)aAa1qMACzq_u(Cw0fKSh0o zBX`4{H}%EZJgTHJgRbJY8f=SWLqiC_4)Bh&V1w@ltDfaq!L+sn!N%FK1+Wjqp~Y<= zF6&}>fAIxI;}GN>__Fq z@3hTC_Rau`QoFu(O(~tm(=XDU9SB^1 zAr(rcNTB4zaAqyyK@6F%S6;semzsSTGSy54d;#OOcG%a<;R0$Vm)`GpW0()POqarB{uRX%Z`=D z7kcOxc&4_oKxnGW9uY}Vin{q zncMP+`g*&w7Ivatp}BeK>&mXV7yhyjx3SxcSbK@H4iK!AqMYYK5q7)4V;|EBw zaTNGXEa$ylP4?!P(FdP+u-=t%3I_>3`P*50K}D7=u*E}^m%mmI%!Um)F8zYm3c+dF zW^@|<@4aFs6g!%seq;`gJ(?xWD6H1wthdc}rZH!$CIC_PQ#oyA9#9gJR;iVcV{O8d zkucn(4j!CvfFlrH7Q&kZn^#y9IQAsnU2AUmm<4mKaH-Ssq4Ds%u!p8Gj9xC6cO+Fd z_5#HwfEeJF3?T?G|1UKNDc|Suhqe3b^{st#n$HjU+w@(BlOOorl3nR*sMfYef8I?m zrKr)>7nBh=NbUU#ke8x1!4A;OK}zFAW6$*cdCvhEUqFIu-paHdQDPPX%XVy2+8ll^ zH<^Aq$OvGw+i2j#+PKM_>+@rl_%#l7Xy7N$S1yR)ZUO=}L42SrFz&t;3(h4B$YLL4 zgn?MqgxLrJ=0JZ7xi;`x1?9#y*B4?gsta;<3V-XHmR{G^t z=+8PIjnUy!9cp9&G9(17AuKXf&A`^V6K z|Bk3}D7jawL-5zh!;mD6iWQjr1g@XY1WMpye6kFEciXMbrvDH43lPWe3 ze1H#X!T!)@`B54YZE$dKI9dYp30OpbX^q){v%^WmvOJ(NVW@ti|PR=U@cGomaJ)XJO_i zrI_Ec(p!SwaOCG95Q@jj&f`l)wu>Px?8Rv$mdE8Q^k3(cjTyfxUW`Ozkh{h_+bM*~ z{Hv9F;u;Xl0=T^$D#ek_*x(q?Wsy6e=*hqod{hw8qd%1fmzRb6op>Q0<>YEngmgNx z+Uy1vtzLT(KMn?Ma;FPEaM0>n_tb3X3#WH!hy92<7XYw|tIcR;n@z&F{)(u@pNzJ7V+d$wT364iKC* zcoLcC1?AR3cw4yPJcfeTA=8ZE`E{WlUMO6jbH2l-0AkynSfA8;#~hc%RD(Yf&@+GQ zDHJj8oh9Jhgxht8-ih3FMnP2+ftn>r0kkMS2f7We|K?-g+aul?c}#|yQg<#4(hko` zz8-tgxb14JpN>&AR=em-GSx!?2q#(hiRh1?ty2xU#t}P`Ps1IE@u4$sThf}2yT^?y z$Ty+@M;ad5)Rf|(&-+*dcQ*eajLmANnieo-wk@@iFTR%X53a=ut2WVa6IEu#uor}r z4jlS^oTU*Frc{728+!2hTSl42z;WvBd(_UT3@MF<8sQc zZBo(JBeZ-2Ee*@SI(t2a+%>myUCUS zWb^69i9{op+@WpHC~J=skTaf_wisL@^9$TT5A5divr zw)lgbfIGF<5FP)tn1yVrltOQ%SEnoF2@s7(nT%{%k@l<~;jpjT!wbR-3^f?l}&1-ID0!m-`( zoTQdkKD^N|pD#Y=5}*%`9`rbT_=fJ~Ib#ynxG3bKVu*c@4pB{+if{)VAL%a9D|avQ z7sZ_04g7mzRe&q-s{24Fu{RMbAX17V*qMRZr7NoXawIOI7hc}pysY8-gdvfQAz6~% zZ+k(Znw0Csq+SdOMYfR)cHCTGJ2t)}fSuvrvmhe%vkz>dg!;bmB4RC#+Lb&z&%TI^ z57G)}KVruF{U3MIDP-#R`y@`raBPLHE-eU*I=2=MaIm71FOdyuPP{)GdlX1z`ul6fehRm@wpI16kC_Sz#_o?}w8 zi|ZrnT(hRMMvV|K6WJLf)<*iyrX>L$t4GSlferCZ%lw37Y_P9b_nM+awHZ%bBacM| zZWRrg)2fF<)Kqo^?a1JjOXAI|nABC0zY%(PLn5>n(9@%^E0X%lD@M5+(EtO@ycdgG z$)_XVAmGR!eLv4L`_Z^c(t@nF;fG}KDfHM|oAT_9P&*~zWoiW^wF@Fauv`56am1*( zp3Ix$h-?PC){e?x7TAAbQ-Y-owfvloYwWsRf@$h{ea2|_uDk61WLi)NC_=NH=gAs0 z^AwY%I%N}*`1aqD4QP^wPUeSr%SGDjfm2$cUSESN?r=wH#BL=~rtfwaG{5U>ymX62 ziLKkFK4kGhhK5d4aQ(qO_~wf3@qxMabKhs@SEGM{zZs=$<0=%%Y37oe-Z~uI5Hz)B z*V4OcqG1PQ^)eD1L*z1T|0MHpfgDR`>0w=h5dv4cplK#2RwMzX-n(DF4mEI@P*Qok zkEYUf#^Yz4c!iEC(8RUm;R|z;p%d6=|31!g6u@KIV1?T`ncnq`1F3K8Jgrc|;HFwt zj90+WM@~bSD6fWPPD!GC#xf)uL5L7xExw+l!HO2pV@(u9O(a1Qp3Wd|2+Zq$Koe2A zY9=yMVu=+6i&K6rD=zub94502w_p3zr`Ng~WEli26zm3&dZWtIgBNJzE+L!(6QHF? zL8}Vp#=Jr9NH}+`)G%N-%PQY=SE(S{vLUHsxwOgrNH}N!U0Y<>sZ@IG` zQ-B@7+ZrvefFIXZ=XYnQxbR3&TOVPPZItv%cyH!;SqAqMOu8Jh<;HlyVGI~zWcdA9 zlEjAGKzgZ1Kgo))qTIFAXk$#X*wqF>dBZkq z8WXFa0-rH6AAX z0Rv}3_VzG}EJb0|pa&2MQ((WFoxjnRk!Vn!+&#ZIKA3Qscc9(Es{eT(QszxHs#cph zKP1hhz5-KI%A~BLz%M6_mKppGgr)NgHL?}V0lE}-6_pv~X*&yZ2Ihgbxp(OasFlTcF4enxP(%9b1_|b+K*)sc>_=HjOVMd!ljDFh+ zOi}h^l|<6L$pS0BpDDlv15C6)B(~UWv`^#1>7pzZ7BAU%&A$R$;4?8anthXEGZ8H) z+-cGO_;bAC1;|w=yG_>DV|VLHMp7>39!7#IF*4pa9kLt5^E-+R_P_!bP{5fN$+CY8 zaCi(<>tSu1Tbq{#M{kKaSNGPn!TI4JtqpP65PE%$O0%0+QYt!zJ;brMO&Et)H70PU z2fN2no|Ut_;e(7QS1d7jPg^39U;rcz4eC-NLQwoOWd@D5A&^^9{_=NtNVon{LDvaG zi|K7BTZ-6&b%ayo);@$eqk<$~;dOadD20+cl=Fdu&*P1^^dga>YYFk7j)=E#z zF$~KhFNf+%O*Y)e#ra;s%nk0MN)PafnSkP0x)&rOhvN;RW~NYtn=_D4bl0OtPxB~A zf*4TbP1m_(k0vG2dmW1qG^UVuGJ)Y_KriZJ|G_3Jk>Hb zLivV{+}w8#D|sa@CeAQS=$*qzid)6qVw&d-ZCl#OJH(6aiOghmeBg#%4aS+!IzWK`^-gO@3-QK}Ore;B*VexbMLqo^Iq{`h+ zhutKDaKe)C^8m8w^m<#HD#N~?ZBrQX3K+x2jFT!{1KD~b@>f}|CgtTTByhYYOk#L7 zW@_Gn!*0einPO3EeVNAqDxwCDa0?43x6uv?Q1MeaN+T!beJfnT7uxrLArGzp6LQ6G zU>nUU*h5?DoT2jZ&AmWV;nqf-H7QTVk?z$cHphEgTa{g>|zWWz~VmofgNHO(AvQwyS#Qh zPvjpMeN-24sgHBWE(C6D2MSt|4*0n^Fgybxa6^=|xBejvHl=JbHg0l}US#+>`{R;S zzdDKvPq#9=OgcYqgP5OZm}twFnj^FmGd#2pf?Qzi{L8a&p2=3mQ)l%FTuxYTuA|cFZ z)^ioaEL&ag9DVayisJkSAIEI);*Jz_vubmksknq=%3C=LeczDOx?jpbp*fLE+7~Lt zd1ydMPq5OvA3=#g1EnP)>7>E&g+)29+`IGj!#@#oF1fS z0E~3>{b9EMIg7XOcD2qP*iwPBNQsi=5qU<=d#8*PRcE>ueuA>Vy^CSZK zOKuVgkR(dc-+izyDO!rc`w!Q$}v{34XFQDYyQ>6V!~Z;Ht_{bdCR;Ua9d zrQ52po&6SFN$a4xshMu^u3bn{$?XqrPDH}khH?((SxFH2j$h3{d`B_uu1p+H#4!!&GlDZY|U4vbK*gV}x;z1ZtnuAkT{s zW;2E}+)i{P{|-`UI;7jNG1}q2gJvwEC>xRx?$2Q1{YMShx<52bR ziiTp5cCEuRc#K-tQ|b8ZrJbv|ZCjM5)umIaKFZ3f9$5)m*HB2k5_r_udNB=v&?9UQ zX%xaYo5wym%**`{M;jw~u)!5+$7IOpyG4P?7>FjcjfXS)Dl&AZOHL-z{u@1;cRT;o zVc-`f6Z4$-D&T=X|@MZ zzHgVqi5qg?cP_t4)alZ;8&tU`QqM>8XDFW*9riPbxr-@D)MrzIw^s_Gyr6w-3<$Sy zG45XcRvyoX*1ICg(1O%;G{PLA30vgz?jCCtST}?-=Ivzs#Ml z+mRjS%{p|@>nr5u-ZH%#o}QMbC|r)`R_=qp!g0O8sv9`CQ8Zr&SVk7i!q%?h!( zZCN)O3b`$ssFt1jPc@Q@H!2~Oexkz8W>w;7d}4n3y$&!B3bU5mcru;`meoU0(vO;< zQ&m+GZlgUoU9!sxtT4PNLO*YNE%npX;m_w?N73lWY04Y znA}nuy0)N}_myl&iJCT+lHSgTcLVvTIS^xz@`EMAyS9t;$BWV+2nmaQT2UMvSOnEI z6@W@~k58_IX@rF7TH;|ixqNx>>j->iw&5q`(^Am?qGbf?#rR%QYd8M=QD1`E;)3-V zsdk8TvHwjn`V0iXxkWu*U2^Yi(`GX^Rc>yINYw0zyt~u=l)i0f+8}39@9GByaAn?# zxz*x@HPf{zvC*I8Rvt2_<(uUCX}kX=P!hpG+Y6Y1n4{RqgviS5O)LSA?4&bRQmKGv; z9)|0Gg#a73k@+nzA$A96j?cfBa}@4kY?*oO+LG9vB+>BWUIxbnD=!^7{PO+t(fiXCm-l_vgDdy>1?Q_WnF?(v z*sYLgtRfI(UZSn7`k;vDP!gD5D}HZ@vQsH|mPx?(wy~gd^jA#b9Z-SE`pR&DI_gXqL`StLb#k#JbuJCS?5qeB2_s;Opq~3SwkI-k^6EZVich;tX^a~ zT$WG(ok``rHxYSp)#l#za!}39y&J4tT|2e0PigJb1VWc2HU!NDqr$y84Qyj0~NYxj<9)ztt@m^AsOq48qM3J>l>M+@|X_!_*5fBd0~K^&y01z zbWwKxapCGwlc8XE9C>JsMAx+U1-n@7>zdao8k zpRMEEUCf!yosA)~Dr5O9t4DL82FF@`O3b>wi(PrB(D*Q8IrPo*fV7tqdBd8*IqRuu z`f_u*ZrX8`d1&xnqq6)u9C7J%L{*|xp`72ewd>q^Z-0EKJQek@@-eXyulN*bV=hE| zh8$F4e2B9PvbRkhI!>->s$#j&f$TDjViUMyE}VM!P0#@q2)zf^0e0>SFP4q_5HkBq zXpipO`G)7XXVD$uZNZL=X8YC20s1ak`7`JxLSkxd_*5lc8806Qxeu z&YiOoxp&(H{K{D=LAK3?sC?XqFxQ7xb{WLlFzp<4f77@4zW)@o-;rHe*bPjxuvb2C zDUhTvejb#_{#C${{j3J;U;V(rJh)cHx48W|?g75H6Jy{{p73+cZpDcCDRL!$aH(|==^5K`K`_;c00)%OpF@(xLQIZ@O&}M-w1ey$!rl4pF^@HZsO-Jy#){;ORXj^6#Fc?K z;cSOUW}GkD97lQ_M!9#D_OCYkNbYn0F>RGQ8EWyJ$2~3K<@sI-ijuU^l<0(mRz~w= zQ`Fy;h(XWdRsF}1aOiI?qzI`IW=CD0`Z`639Tny*QR=kDb};8t5oxggY8$j0_%B-t zmcK#1Xc)*w}w(+Mt`FIIewLEgaw7RDbyohW0?+ z_FY}^r>42`p}Pv#OcNUFy2F&VO%EDJ;9{;!;nH<@L^u7YY2wP9Y9`GRR+jMjMtKSv z$SF0>#D~w-hu(t9p;%LNgQrN;QF;HtB3apfFej@O_B483GQ8G8k_g0PV|Qk%x%EJH zvMj8aLYtaJF6Ojo9cuCy$8UKy29A@#P*Vd!eNjq--+oyNeewcdNx4hE4<>LV2z$pgH2d9!6%+Cf3SBr%7xT z1M>cBP}V8{oE@^{?a37A(C>#Tv!#&G8CX`YV#F4corX+332K}C2}7t=iVRi7EHxCG ztL7Q6D)Bn$F`SYt5F}SL89hfetV>t-#sM6Sek$D&52Bm;4QvuW3yA0pB0`k(l$FyZ zOADeh;Q&b|qUkQ3_NPumQx4!0$RAH)aZv2FeP3XKh}fU}<0+o#j)<}4+IKR|0bc1O z22ne>sj{co>vr9DHRedZqiw*EDneG#Eo6Jn%Y%m1&{Us*97ok5X@=nYWsJG0>3;h? z%`2A?#Iz%!`>H$uekiviu>Qck_;xIj+7&b4ad$0Xvbp@0^TVR>xhF<?~ijipO}fUIx{ceBX3CyC!;Z zTVMd@yZu1u{^E!J`O6Q(zs(Quw-%9O2{ml2GxMOL*5a*S1o*RY3Yc|g?7-R$-@Dx_ zv9@RTCQQ%GZP1&(R*9FlSB&+4@CF+YCg?x-3;R18!zjwKLp5=lkN$8U(63YWxvB0{uA~4EA2ads@s%MQXUv@N~B&P&FSP&C1h3|N24c|6Ur~w zVu;(+XehI)Qihp_@gPvogh!rxKDGo(V6G6F4(2VNhXKlujRCL^Z=Zl^9q_mL)h4uJ z#-F_GwMa!!XO^}Y{bFW>IY`jmWL}{xMryg$_)8C*SUh9u#3hWF|4B{^)p(`TzbW{+ zg=E|?L6@GEMsYSQ)Z5;&9B{ax)H67^F*E7d7Y8#r03P=Jz)2W(wE88bfGs|b;~;|A z_U*|Wm;>Hqe?hprb@aduPnS2i=X@MN8^1Q_uK{^9EV#v;DhIB;(;LAyCfn!!%7JS6 z?}_$Xd{3(9)ZRB+{k?c;saq0|#C?tB5%*B}#I?WbWyH@qD1MQGG}Dp}7kk`j{?dG{ zbmnVQT(`N8N35`V8^f|{qmTRTMZ(hu`&y-_+T4p=R^OZCJ4TjE6In_-7uRZ?cuQX7 z(7DPrs-j39l!to}IyM@5KtHx^5C8LRK7AvW?8yIR<$jE{eb$3|3_&IJ<6e|eC~;Wu zUd}K(8a5XjW*KuYSa4m9e-%uR_ZW0#-m`1LJx)feFV!JH8YZlCs_kMzW&LzqT)D$P zDfZVbR_vV6XN<`HLp@u5hj3`eh!42ag$R~@7CfKhfVteqelUG;TTxO4X$|!B-%}Fa zw;nP$tiA0b4z8UX*}=sG+uNz}=DMF*nF|m~J~yxW9641KdkRcW&gB2A9JW-fzQ%pEzWQ03}hVcP|kEE=wPblv^QkOcACe zq7(F}BB!BHHEwCD51=Z^^cM`)DB?NhqQem&I&%lEZ<*n^q~t^yIkvUF-*+)sTCuR~NW|S(mM|W5?hk_qOr=$JvYa_UDyRlL3S2N#hSHiYjGg zG;(;?zWbP{#B^av76*W8GO5CjJUUx6Msshtp~F%kRm>ux!;+XJjj6+x-Rjhar<(Q_ z{Q(7+B&qa1zs4*KmqMzC;<&QWbpSq1GYb(B_B&S4HOU=w$=mq*YLD2Gi002=h-P`+ zRd5r%b)1kQzZ>Rjpj?wnFks5{0wjT*N%{w{a|Duq!RyX(6${!Tq3{WK%z~F_)F=2 z>t^RLGj5FFWk6HCvZ9#baGNm^R$E%c;6}W%nX?u_LY22BlUu~UnY%mSFpmt3+!oTkgtOK;R=S`ktJkYnX1g({TW zIi+?6;ilw5{~gJ)bd|=1<(E2tBxBtWBYtKh_;Tdt_j{I}pJh!SZM6|3R5)px#E=)sn%rt#|BBdw}(>A-tf}ob#!cJ-}##G#CM-mB-jVu)e$nA)w4}k<>Jh zBmGTRm1|)~|NEx>f~ocdN_>N1w~%FF(jaxg&yi9&CaiX<&=QOxH>yz@(tUA3QCK0y zf5?kvh7sgn%R^)|Ig?yb{e*g@KA>UqHACy6K}k!z<}qy{({aetA)zieF28siL8_NL zrvQzEN2`Q3+xydxykHsn&W1VHUb3_cHsb!wt}R#u-XVxBaqmi99Pe>;3+(OIDZF-X z7C9?U7F6}GY}4tf%+TjfFQ;lO=i0xTpplfI8$m;ZI)Yt^2XJ>(fktbfX+1^3OTyR` zQ>Yx$eDDa%@8t01Hj z|Lk*EjWyu@jC!)C@hvX+->^W%4EB&>%59fDnlXJ3(AYB zkdjDM;c1DK@b-gJc^;G@K|oR>RmSi4Lwe4J40_qE)z+W|lS<#tOtbGzznZ?xbd_Se z$+Wr7oSikO3of0bs9sP;b^2w%94ehp085On=vJ3iP2rJS zgJ9iREQ6*689+z**KzEc&JV#y#GAs=W=vm`g_b=HjU71MDYIM<$S%-oNd?CGBiNDCesbeoj9ddfxb2PQl>_esCFGv(}EB&Xz>| z(!Y~Y7&1VR7{{^IBK=l9DLjoAdWA|4<4^>b5fh5%Nt(AGjd_g8-tH5W)I#;U{m082 zbNJYCW_o091#QCC_G-LHrK-%vS795v_b_pUg1)3BKujE7HrYhd+`%F%A|INExg^z8 zT+YPLxR8pY&;l7B0J@YPMmr-kgN&s{kL_AH9!vHF&>i?eROQpAeQ-z;3!Gc1-LQCj|9F{jAsSugU(R z=DX27P>jo(t*4qa_5%I4p&-hk(tTQ&L~nyQHx5_WNXq zRsUmA`K3T5Q5L35y5_a$9^cfPNlW?Pf>WhARCyJ?+}T>+fm#@HW?z=8oO3-}w%0R_ zgq$c8)zHxlp%jn~uFkj4!0ClM-O3IcPH~T}p+Wp4!^RO;y^VeA|G0t?qNFgG*H#|< zl|LQo#y@>TV%y3OFBhor1dSD_5gnkM6(cau?4^^W-5K4ZYg-leqqb>XhA}|M|BDQB z5DRW}8)zZuWS7qCzB7H`;HFVu#W0-xt9yZAzv`b%rYS@$5>~5@)M2nCLx#)*kDr>V z8lR#venwMeU9v?|~YA$bod*w|c0;Ff9WSV}|WpO$d8!YH+`?$KG(4MUS zH4GRS2y86eEo_|twqZyom_hKB4701o>7(Ho?ieVCl0pH^7}(hDPQm>Fe)~eFK2tpg zH4tOOzCr`r*cdCz{^5_?$iJ85aFsY54(0EIQ-{3VN=&hPaaUZYpU3fw&tUqhXJ7yX z2+5fu4e>T{W`0P0)qbgcCVh`<3G9z5?UIE57n`=!SoQ*rpXaPW^yVjNbsFTh>sC9L zzCD@_2e4(#{&T7yIH&&~v1P_`O8}wNCSN&z9uK+z<_!VcIxIC8NioyNlQMW)NPybH zxUOeY#ZApY2BPyNH|)G6p8UKaj89mv5Pm)*<&eTw3U2h{@#gm?(YuHr-_Q47?`tt% z1`$R|z%rfR6fN~1&<3pR^|){W zLV5_0L84)@42O7kh=viKPx|1@BG@U#Vkf0glS&fHKh$UxuI6(Kqc+D|m*qr86+|X7 zyl(q40lrkvAj#Rx@E0$I6tPDcQ4dmOx>z$vxX3@gsWAIYKpf;FK?LCT9xZ>syD^c6 zfD1RS`;-?A{mihh1(tyheq)Thl^c6+<_%!#gJwj3f4YRVRB9Sdl)l}nxBmPkuBkm zq3Df?Ql6v{q%uN`y1+fM$a2|ob5tibE-*=xXW4C=ITA%H#yc|qT*kIxO@Vl|>|!Tk z@^a9pXli7OQAH!wDJ3=dh%Y7#dGfw(i*!11e#mux6iEU~73IjF%y`NU6-AG$qsiS4 zbJBZkZ#JfL>;=yS<{L(%B4;95QeQ@ca4x=z*^S77>?sl~wo%P9w&*Xs!5wA3qencd z%1d`5Z^rl85ca6Z_?H2r6dIR;Ll_1=Bg<+-#v~ z3peoMJ>OpPIBQ{q3i+$8MFW!}8E&>D==}J6aeKzj6v@uU@i&W~ON;X5@jRE{;pk z%+4!F$W2d3O3BQwDwl&*D#(w^D9y`@K%kYRCZi2BpOc!LmY63S8>3xO_&Zx^2DK!U zq5-0!90S_`PXvI}5EN2M>Z79^UzLyuE(^^_OD;-F&Iq~zNl4zDLXDzF1B}%Qh+RSk z{P_Li3q!rpHbPax3Jw1;qqZlDx1!p#_&awS1b=GA)*7wC>Nv2mFw!&9DT<3rPkzzZ=2h z)8`-1+AZB)U+(9PyTb$fXcN;2W<)3fC=r?(ye`9m=a_xVX>#gbtrqPgIZf8|Fb;qF#|&P8FeOd1cbq@23%FoH7ulqmV-T04kmpp?)w0Z(7W5_oG}7=F(&6< zaTk>?Qx|(6?$1678`$lkK^9~nQ9Ttmx4Ux^3~$lMf%4*$#RkEAKssp?@H=OrdGl-n zh*HF86)gDPamCSkOx|?P2GD>EgkwjC7o;Xr%_eqvtmQj+@h#^7Ak8w;gTUd(-U0MR zhv5FsQ2@>Y8k5xWXVviV~2$!j3Y8q57QYO->% zsa3Kjyp{bB#V1JoEdBF z)8ZtH=!xw<@lmEc<$ zu8e3^ahm)-4;Y#YmfT}!_ki(tZ9L5y?EB<&sZ;qBCxrK%F|+N4j?S6@eaUR4TMBYh z4hd{TT&+6?-Q#HrOMh+qXBZhY6+Q$^3qL{vRO&Gt?v1|6zU;f zUYswq0vIz!aYQGt;o;4>M%qBO)g~!9rl`%oO{!I=FG^`h6=Fc4c*HWy2a>GG^ffd$ zTc>Hey_cY|-Gu-Ag{}PrIfVW+g>exwVdU6Md#FS83cL>2TCC_7Wc=@V+%K3UGef=b z%LwhGtY`H~*YzZMS+0wLB_z`#Ck1=K7)1VdYYAEgwt>EXYi<#LKI>oXphoqs{Oz-O z1gIqAr=(`>D8?whTu@l!=kI+krmsK0PF=Nlw{hZjKvGr_G<0!YXaq?CwMUi2h_bE863zbG(D!5{wKU?0n8=|$mXEr4i135j@DAj10Uat*`&tlUXj zrdY$V|LO3v{8@=`TLEAVMH@V%4e-bP6_OKsGzSu8zgQHy-}1^HW0elbAc*os%dy&4nfoH`2-3KuVKwJ_xd^a4+Xx%m4|x|nDvjth+WF*LD0zq56;cundU~|?%4`mXXCD=P9rPU0aWiB-h3`#dn@0%;X^q%*skNfSm`6sv+9{Kgh^bBO^f;6cg|hWd%A2sR{JuzuRvwWegB ztu}2a1o|#h+NxGUMzaq#!aek0W6Tbt5`WacCD{?JzJ`;nnkOQD0(4?Wb^Ecw-T$KY z;j30|ps6-ki$Ezl@jdEN)F)t*#HOpgKPKtSN>I^y>M@{$v=8N%fV$<&SEx{60R2u< zj5UYoob(JN!OEdknW^{c9w7-_NJ&DGkFOUuc7lwbXSgWQ!1v3`hJ&?4p@q6htTflC zJAIc~R7fM{w$aQQk9rh4D>I2w^UEBFML8)lSp6BRlpie7tD4BiiGyLnG#k__?h4wf zwztcXXAGtOdC|tVUtD^+lUF{!>gpz*|GT^i8yCJ#B(TkL%Vx7G!!XNZWXfx#kt9W4 z?7|EZs7^5qVe3}6+4#564hcs9 zyh2D$wh9!C6FCZo@^}|#8TAe<{PZ(QvIppytjv23QnvUl7wtje5W7lZy`*S6>^`iE zT(Nrm$tq2Os3FKj7VC(skGdt$6PJgN3Q{Z4wt;WRDOZ%Eq*2x-r7}Y$HF7BQ&-Pp| ztU6)tSdgj=bdd#g=`t7zr(Q}qG#3vs=F#-TRoyW-G1H04BXs=9$)NV!5RM=1d?!5T zk+2rH(8MAUd8&vIGZ`n}5OafT6I(^(uIm7qlY0&)b@u~r6*E3OwX0Zwa1uY!j8inJ zTk)58pBVvCqG{ZVpB{KOf8ZC1y`A$7h%H%6OPFo4IFiI%vXTwg_hU{DUF%A z97y^YS@Sh*kz;@K7pgHfrJ6C?@5`ax`N%>Ct3n?h_&u6oa=efDDt!ZU=A`SGf-vK8 zWx2keT^ZOO?|1-IC;IlLm)IIypqR6J`tVbwfKy-LrHLrRoCEMRk1|j%6TZj|ZGfav zdJ!2b6)e@v^ou|SL7Hp&t<%YPSWgAI=uEcJ{~cviN&9U$A{B9?a@>Kx#TWq!Nm#8~ zAG3u8u@}!yjEJ7->pL&{fDiRR!W~Cbfk-{~dZuS4@)!?sO5nTu&bqttQbJAkTciN} z`&`$9lYY4i$n4x7XZj);zIsib7`Oq^V*l}O?{Kol{S)u;6ay}Jwb{e=uK(TZ@v~D( zi5b@{9$?V-4mfNCvvtA}_N(5eDDc`X$)l){bSWH#1F8tp*k6Hax!eG%8>;9)AQ_ei zcOu5){BDdLZXWcU`Ia+bcKvP?lCML(qgsE0i1~uOZp2E1KnI;%InD8&fF?o_Rx3IB_?+%-s(-|b@p~%+*)R4rnZefmcE(r z@ZIrn@Oe70faRi?pbc;erR#HmEA(41i0_jMOMr@iK72+1bW3#jbC_u3Nc~n@@!Q%= z*o`X5ZctC$`$^iK*EAn|?UKX{Z0ayXFF|8xvX?Md>?_SZfdiyFAjz}b`T%>?3eZ)% zPKHugdI(R%3)BaoAgf31=7T5PB5m|gI@ubXf8ORF@&2MtKrjUzSEX!L-bUl z^vfsHkmqubN$+NI$sgBUBo&7vrFl@eE)v-(Kw~-yEb!ah@+w7Qjs~Kj9-F4;g%1}5 z9ZRU=$n%+i$V!N|oUGk|OSgpXIA0F5>n9P&RBy_4Xn-jF%LKF>LPmjd+K*MN6Dp&) zkKN#)^y`W_vvW2N9gpLJS?z*SJ_|z|IPJ$LFVIt08*)*AtsJlmYx|Kog9?t3_)mD{8SD}WR&*~S z8}(a^o*0cxFX>tG`~QIAobvpX^t6x)8djAUkdlp=#>c>kk2Qq1yO2O&rI-)vX(V!bv3@&*#xJ_@x7 zDZz?afjNme{Ra>-QOSIyc((fTgxrGM5~Tl1urei>->;$liGIJ};D77vsK}iVk%b=k z6|;FrsX zA!6cP28k&Y!q?L>*H*y-Pr0BV_h7h2oSfebCChr6#1=?JDOEi=1Dp-oIGIt#O3_!4 zQ9CaHNxnX{Dis=_I*h*1)*tCNZJT=d?P&z;l6Ut1ZSSd_>cCGLG#VN2Up$R13&|qa@n( zJAMNG|7HBN`QOclD&>U_!`au%MD+>-BQ&jP-{UkVDcdeBD^uBwT!N;M08{Q}1T|Ry zW61trqR;B6 zOTK4qK$VlDi|b4D>q&d2Bk`u)i0>0qC%;_OjSdL|6Z33JWy$!eqNqCR@od=8IW6DQ zM%mfysvKSIT!zP%Al|$PKm-aBv=j#8`nr>^^6xXlgs-1S3o-O{~w0(4?+wnl)U8KC}Oj*bo>%Fdvq}n`$}R?$$*L-&B3lqJq-! zvOd6!jQo_mvc0% z;O{AX+g|V$TI_mO{O=JzSu(no^tP9+iY=DiRKd2x^bfkdGc~qfhD;u6mgJgN zwkm%?zq{33sV$Y9Q<{a?LdIpA7O!R}s}+g1B3)K4OlhHdG%2Ao)aBbs2lV9Jn^b$1 z*(O>lS(zKUO_EZX6XVv_4N~SOC@xwof;AwkC9!nWsMm>V*m8nqW~a!;kgFH%hiXZD zX@m7?TM}U*Q+2In%|wenN7uPiSE#O>*JZ|kEA?QZbr6Vu39<5lI>NS|8QDY zMRyRBtAQ~Ju-uimSneA3X%mOrUUgTRSy#{{qu$3Lr}QcrW@wG*Ui?Y3x7xHC?L*3?zv}yF;PKuGwBcUvGm%M*! z!!{mO9th;?#A`Sbp;VCW7h)ahcCrVH40euRz>D7Xa(^q96wDqVe+g`U%m?6mxQ_y z)sloKwp1ub6RRQ%lX7p=2C_i*H*Gs4Pk$CKtI5nQ6PaF`dW`bBJJb?qWm3o7_w;3y zrEWlI+$h+qu|`}pTbz>N8ac39PtY-)7$u@xH&Ky6WDi9$0GSuACZzPZkc9$`Eu7GUVAhk0dzd#xA6V9Ggg8wiP0lh$NoZ(3Y^kzgE_31+&lV`vSCr z7X8QC20-P?!ah46)?#_uYQ^XK#$hej5O*_(_-}07SzY9tAiAlcCs2#{y%0+I=_kM8 zF9JYp0uF?^KNMZhfhmu0*Ll6UH0?~Nza*R&eEO91Jxhe(P9r&x`-ZE0Aj0|uU z40nNZm5PeDxJ&gmI7K9A>C%&&joG1a81QsAEpMuw*;RN<55O?V<}$B zlVP2+wgs1Zz&5CM{+N(Bjs(*4_uByvJ?XQ%ekGHDZUrBq3mSoQ_h8CH0!0b6%H^Fk z;wxaeE7iW9DmLT*=4rhx#MshFQtaqmB30BS)X)pB{Nt;Y)k$ie>8kboGCkQEf_^*7 z2A86A4Pguo#|@n{DYTnL5r!mLGQA#epKq)2{>LsA7UP2VFww|r$@)W~LO6L++e2=q z&iY(F-mp@58&X0O23`DiYk$kM%o!)qz^07CfLNVIq)`zVTnOnvb-VEbHn^lXa@<*8 zlbbdk|{MBw-(r3=>AML(UV z`1Xyi!dNj+M6;u;HbDZoW}10?Yy}CxRN=f2`y-3mzY~^C&indf(CTPqLI_*esaOI- zHg^bJ7s$~3YEwA1XZjxPuBosn@hE)PcF5K^5kuY{!Avb<&mmF}efnSg>dLVg;6*p8 zv?v03I0WsI0|Rzb3O-FIn)PkWIk_B=I6)Yq6u}mNV#HtwVdtovMFrro7Ia$Pjhoe@ zq!{-~@*$lzg|S|yj*Us)WFDQUVA~R66g!5ijjFD=7C1rnG-s*Z-aV1IRD&8ZfsK)< zkoXTq@egBGE+jF*t1!J+DC?COiEKLqz8>7D5djgX%0Um70|F7^_H~1|rt#3r1GN#czr1*&SjBZYnQmVCF!&n6U#!_IGM2o+mcgT4YM#zaRD7tr-r%Ka=&YO z_YYvccX#v+_vLYK=5uxu$FhoJI#|+P>!noo!LYxiFB@|DpP!aP7@+$jn3R$``loD@ zl!@7TLgtYdDeuw(M57>rw>~ zA%J}TrbVa=U$BH3mx0qoxXI1uFH8yt%Tn^e6-r5z#k9&c!8|T7(;9^;`9_(s%}qYv z64(=H*#-)>y_=;YM&fVq9OoHh^Y^%7vk*RJ36V~nakX*#kXvX^)G13d z9=Md2>tLogC*=JsY0CB1%b~`bdjTK`7S%bm|i4CP5rVx zwH~EO!{GvWOyx4iKsj7zETV=(0cNdP6)Z+Ix@q3$6(#r~S(gW>15POY=AINC8r4LW z0YUM8K58%@;LDe0r)g@32Ss7~ zZiwgImp7RQ5!c=pG^~;3kGPrNN*8REmGzPbBDx2Zh99>(8h(HU?vPXUMGDxLA5z|g z9vt)BI6n;`UVy^c+>2>Jcs3c8GVoGQ@xw6pi>%H=3?)B30`9v=73B;6G;d#ux0jvm z`kP7nisX?fhYT5E({sl1ev_e#WZ);)RQlvt85935fkvFj6mB6nEZoj>DUT;gV2(-q zzc9er$D+ItSnEXa=!Igen%ee|62y;b0rRD7;o|W@P6q97g#py3fogOzkDHmSri_Sf zcVi<+cGNMJR*HKi38}h8IuoS|s4dEw2FlCcP-4tB-rEu>ob&hDo3qJT@X~IHbExZ3 z^=^DQP(of(P+&;?)Xqib8HnkTQQ2v6 z(TrCP`36Po=?%4glTayRqRV^ljO0U<7`0=tO}P#tbP0iSVDPvFh2OE{L0I9n$(5Jn zx;Rpf`W!X_ztXN*9FUcOhE`}C3=nXfy?4m6zwhW*!wgfV1p_92d>p53n{us}ukua-$cLYAHI;n&3ePV~@M17^sLhv{3|8Z6)c^7K z?thd{)OUL6G1EKk#3Y}#d%ix;#ZkzmvkxFtmQt`bkf^W|H&C$i*C7?VXWXQGX9!s> z!S)rWWmi^AC;UY#7yd1sC?5DUk)B!1%{Zfz^W50dC)8WP;smawC{u5vU}eWIwEaJI zP9zSI)7Km0N-9vcej|T9+1-@&C8a$Gr=TRGnfWINw?Xy(-K(ZzIY?eSsOpi1((Uu| zK&S*cFGMk3y8<=SasKGg<$7OBhW6sW{V_RBPY)?ZDL$Tqw~0yYgPXzLOC@byA91Q} z{``ktSt#Do9pg0vmEqv{h!W>-`0u!q2X*z zWtNS+3jhGJGEmF|z`zT)-#n$iA(`<%5a!2YpS=jLh-$l%Dgf@6Y55zl7^+yy8&xo=7R^k=xj^0ly%*Uo zX~l455gy%k%%YFmO5n1;A}L*E)Lj#H1CzCrpZv-FC1h0GDoz$D2|FoT^g7564b6=N z5=t+TQi>Fk>*;VR@I{0EHRxg#$t^;LJwNWB#$&|Ll+(~PrsJZ3JDqn>Skd2d&y;l4_P8*>kUpWo7cJpZdQrVEQ1lojrQabN_Vn0~+bKLa-|4vQ~j9y(MUD&$03` zUE^$YDiTHlTVlPzm<(qJDxtk)2a-{qaV9QMb|92)C6(5m23aA%Mf3Gcu8?3eP?6jt z*XVs;UI*_32af+1ZWiK!0HHOgfY_x_5#3A$>W={5 zfy7A=C_qN!tw_n=lLw%2yzXMg-4r9iN8IwBZQp+8d7X9jS-o%4YvPT_y+JNKh(sPU zF>PyMOTzo={CwH$4^j02(DM4nn{kM zwWN*bR-~R4Q`8ng8k0K^lH&kQp>mLm(yH|z0^KF8uJ7Q`t^(N8zO|PFUe8ymB1O~Z6lZyZ~iW|`Vljll2OWrguKlM)_(KxjYD z3|aMJ@I1{780}GfZlPc4bqLUG6)3MQq(!W85V@zmpkD(WPpYOLR4VRi`13LoH|QG2eg!sIX{g2Z(e>$Xan zvhb2`fX)QIcF75I#@i$Wz{C#n_Bp#UH7t~4${OSz<8`2?6Nb{SsU*O=W! z7wl1#j}$hLQ-6!uu)-yK3PBASs6r(k7E1#p6c(JS(o#|lMp9Cjqiw245R7L6lJJ4~ zY}tGvvC85}qaZQa-%QE~AtYMIVXen0Qgc?8VGzc^Y*ovH`r_aQ@c(%yds#k=Jr;@} zVWj30{p}kL08VWin8-p0NgKLSx^(JNL`}f2E;ROnOV-h-5t0JeXZqM*;u+Fpc zH<0fF)1R`(Z3a@DRx?y5zZ5-6jD96jhhf@Su7y$qt?-$p-Q5!e%u8i{^xx*%JgG)U zAMZLjQ`JWE@yRnCb7n%KYl}?BN$sPfk9@Gq=(tMKx`y&H46v)y$oiN_$kJ5h%=tow zxznQZn@Mw03e;yexqT?%-oDD9s+Da?{mj^oWrw{dO5h1$I>p!lsL}ddx`Hj(b@JIk z%>(9}K}LUF!j3C7CNap=Ky@cseI6M$2Y$3VhkBVZ((*mF0l$;3e!Zsu>&L(S6KXRb zq5Y8k^d_c2qq`;Z`1eEkr*#YzTNnCcRwZY*)p;jdG2D}E@@Oqrk~g`4x!hnY0d_*!*T3!O=mJo47k~yobfa6UIuN@LpakEZ{S5i(14S%#E^c3 zNLU*B9m8Ey+}9xFcy3euxS-rL^P%6}3?3|#Xu4xKfa$ra`+^+HT6PVGVPOLkB|U+v z#p^1bvAbkRNwzN}3m!c4lmpphP8J$u-a-DpZ(={pU)ni}XI>ye!1wjzCAySoJrPIR zh!+745N@wS=XZOW_l))!Fg@FzKz`46T{SiC9r&}^y-R}}clMtyZyzEUd^nf>oDYCy zqC|aXWk3r*t<8r@fO2x(qnLVm?K2?oX0vnHw?g{62R*BfCQ* zQ{a4|&Tm^SV*zZgkAn{;){W2Y>z__vyDq;M$s$p$mImgg8hOgjUA7nZ$(l#UFt}sr ze7!OQy{1@N=io_`RieisG6;9O%O-SeXmnVhVVQJu!Sak0T=F z2j7=EpvOMIyDbz(ba!#eFB61}-`D?2ASWj7N$r%@Q;b4g7_u&eUDcxDLp&yxUI72o8g`Hs;Op+{m9LddWt#FVX~_+f2lL_@VPnY#Yia*hs7Z%j zmFwxtPM%Fni9;a(eNthdODZ9%ueviT&<@wVf8d>iY- zF@O67|Neu#Qi%9JCuJIn@rq?x$r(z?|FpyFE9VeX7k|hbtSIi)MReGuy) zOioMFRDw`?y0I3VSVl=8dD0_pe4?GB`WAfh+FfUpUfV z*!9dE2EYIG3ZmD{pe0iXs-PIBou3;2UyPkokZnP`Wy`j0+pbf#ZQC|Z*|u%lwr$(4 zQ&!i1<3=N*Bf9r!dw8dgX@R?PU z*2@rygQfHcb5tlUE2>6mR?Orf41(dtZqd1_zJ{Ia>vi+qgeHkE5Jhyi&0%I99TX%n ziD9gPB5V$z7MJ?7n7)UA%DGq`7YWCM3&6t!xfsRVPFAWPQCc8x406^_o)r#4szLfq z$s9gUIBcwqPricmqZo>N`;iupJ!%5MMeudcNP{RDT$hwS;uV3DZ3BisQni&b zMIB887{9>SuQGzKjo|^6mSPd1=#P|lDxKMhC-3z%uN+Y-6a4 z&febB+m887AYU`&P8M$wB@4W_x!*eLrl;#b%opB~grlx-bSV+gZi-%1{k}dY_S^`b zAu(|Fe#t$BBCGt2PL3%DO6tipz(zrnZetVGPd5KbVh4*{Oee|fFjC^0Kw2qT zVoQr5N5v_on;o5tYR#F*2@7sgR;?ppwp)9Rz>PDjyl8P$ceGLeA$}?nw>OdFO^7lN z@2GRL1M*_WN}iixSpon}Q1TdtIHPZ9cPRSW^RG4Tnst~d zxzGFKy)6a((CtD|hKD4^s9c= zL+aN=ll+iWtqwGPNXs%FTqtlA_~zM)`gRrj-6|9a5ZoMGOU#G{1(yx}L3k@*S4?25 z{uA=2t@Y=#50|+2w{Pou;UeqTQ6jp$7}GX?Jz^BB!a5fz2VksydlC9x-AXqn`$U4}GV%KQ22f<+f>c=tUeLw$O60p@xn-skX3i9Xi z&vtU74B{^T!$4JvpJ<#e6T9c45v=Xo8+V1{0H;^=hZ8hWS5x!*qitl?J@_4Ny{f+r z?oTCzFSu0(lM;3g<%TCz>9B5*@~*LlWIggNr*T84XUv53D2ZuYCm|=IR1{(XAGw@K z&bf(W@;Kzo-Y|NP*$1yBWH@F-R?&p)UVsEmOXI`Z5wlw<;WRb-85-Ks>R5tfm-v*R z5Vm(~`iI(bM}~X^1!)V*zZtN*nzyR*Y6@;q3R3H-*s!#C0uSFr^SZ&evMNLOD2cC4@KPHCh;v%kE5o#1F-rO38}jy4`4|`pSa%@8<}C>i zd}yY?ZuYiQTe=Mlv4nmAEJXdITB?7uo7L*OcAIPnzO#D$SOUb$EtcH6xN8m}tebO& z@Yr!zlw-iO3Mp6`58@TSNc!Jh+`r-|$5piQg<;j)5uZ0VorgNHf0Sg84s#$I$n;_$ zFr~qzn8GTz=~4p`p-d^_vKYVIBVscPHqJ)d7Z$30JwxSGs74^ENtPQxCpe^{ug*MN zoSP~WI`k2}*3`5Q<}Gwam}(`FuAr$FBW?vj!S|0%pqRiaIX+5fIH6?=T17E@kjM=_ zW+u8C%AeaRlf_=GU5E;m)Iw(g!uxI-PKtqp{oxV7&Za6A4>@)gUu~Bo48Rp``TctX z>Xrc{sPGNbKU41xtFUxMBcmvTk1x9S%pJZE8=xpE-F zG%x|;4O6qbiiF@K>IRIA0gfliVLmh~b^?AE07B(!eiDXqSKOEJsFue;4(bgXN@oZm zshwN^WQo4a)~4W%8Sh=R+cR!Qtf3>3le($@PS@oEkY8WB^j^F6M8HX!DK-vLgo;U3 zAy%*>KXYE_O8GnPX=$xg-1ZS!7;s9_0*4N+ko$OVcu8Dd%uQa;5F|Gb=0jNCNi+>@Nok zC=$~)Qq3uz_S&mEth{co?F@%rq7plrZ@0^VJ&ednCa>*Fs2kfJ{S^PJ$K0(cq;kIH zBV>bGy__jR2$}U=CR%|fCtaqtp|$tVz)Fst%evar!-w|;#_mgeMXX-bw3O8+gq+qv z?kU;Vm1{;=5BEg9VPZ!Fg|eyANZ=wPR@eceKEB)_d*r_Mxb(p$EM4vIZ*P&O@G@^@ zqN@ti(?VDu6za)TP3W_l{ocD25pT@GsaAk!aNCfcQwy;=`-Dy9L|Z$qoeCf^ScP4! zQZvulqO?roe*K7m`_#wPvWq!4UsOhE{1x0rF*aBYMms4Dnm;}kQNXQ5Tb~xy9-Z~g z$D^3f4z9!cNSAqv&24*Ax}oZd0szZrz% zu}ocE@Iwsx5N7{a-RuL*flp+PLk5aqhI^H5TM@U6eU9KKqWdnNyJg*Ses_Y+;6^u( zvn_SmuHtCkZRW$9JLH=pR1-MbJ?BK;icOh;DLZ?;VtArWl0Syrs*qP!otQ__ya*0o zm&E@zI$clFbM7PbBWbA=9MBhjT-m|FzqxL34j%%ti!;;QiL-mPQAAXvgaVv`XNye} zTwe%k>;l+pt^)nyc?$4c?E8n|dC_1}a-@97J1zP!$`R_CG!zv+1h4>F$7rx}MxYu_ zSq+ZEp37g>l!1}muymeuGUx0P;{HbA)m&lEXDY2-Y<`lV&h>u(f-iYvTy=Rss)f0+ z`ddGQ_G!v1@UNYiO=;E-G?mV(CMB11`Nx%}@0L5)Ly=a#1n@M%sgpIg3I%CEf!LzY(Kk;?NDk136)EF?I}gCzVdm>g4PyT`GRn z+u+fN?uEp@jzy;$ zP6G(|+7-zK>5Ld5g4?~_zugH2{mshmSuV4SubO(z8j#x(}YS+MBeW4F$LJKsNk# zGIls@dG{c>JwBjzBZ{5wTsrA22&Z+~!b=G0Owb_43 zkgn$~^Ak|oQU*|}p>EQKLk!D>?}O*X4FYZh!S~xl%7b}@P&d$Q+V5^g<53oJOGHhw zm`Vd=J<4R{VU@Mp1I%%|rmtsIC>G1mnfY=lBCQ;vT{8m9{vm)cqMq;cA z7{Q2ToXKW9noifnvq{0pH=1ZrFUV&D+k266FuwH|Vd;gept1N|oopf?204#sGmz&l zed`C!_U$?N=U`h;;nx;idv?C%8*H3n#5sK(~Sk`OwNc;)x0dNBD3KuM_Yo3gtmA$+H z5F{%Rqb+Ew+UX>Lt%nRj!{y9xG%X=lI_muT`~}yCFiC0NoHfNagQYLhv)u?$Rh{$e zM9($QuRJMhyG#v&lj)eY5Xc3(CZ>Te4hEEsK`jfn#I>+slW*Ob=%0YOLFJXgzG^_O zwvMRh96|Xo6Eit9p_IgdD*&>!nwAnbu<~t=cmxM?S&NO=?-@T!$dQu3h*kYClXTQ0 z3IO6w=txdWv!*{#1MIYUB>E&Z2u~A3%b;Oag99k1VTVx41#^L?Q2t~I<~q3sL$Ai| z7cN2)3MSLO9KGHyb;tT6x&tI?YZVJo%!wXwDkd2j+y%qB2#_Wh*T*0D^X0H39YF^` z(V^xo3uwyerJxl9lOkC(pG#9jFskIebx~DFi_x;`oD~GI4~H|Xkh=SZ6`kj%xEggd!$CWj)7kISy)m{lu0jf}KsV$`^Mg=X_i&ZV z+RIndj4GFN+?&{->ksnbH^P8%<*hQat1M>G;j;Xu-t?)?w?Cu>qtfFkh`i zJ;1pTsS9HwDj)8GfPEa{EX_bCK1Mho!b8h6*9{ZDXTu%E$N&7YWS>{Ux0X?a>WT7@ z>X}Nr|3f)_;5!U;t$)|DdiVe>5Nk^CK^3QnPNhuwc|@?(H=FREC!z1(f;MOn z1CB6^6Y}EgVJ)K}E?ZD#qtlW4^e(7Pi)fo#yTsW#C6wf!Y9~Ff!{Y9p8Qo{Ha^s&_ z6^4EDrul;BoO0JH~MVwzmPBLJRFW zY;z1#=;+v{N5eAuJgbss|Cr(0Vf2i>m2?R5+z-Ib_KlP9%l4|x^DT0(j7#WJ-YiDT zPiNn{$q40)F<@WYDPb+-`IWr^4gNtB)Y!?G&2>$gPm##y`z9wwr~!edA&a5h61u%| z@KIOwz1B2|EX630EY*o%>HZUjlDtio~YQchhMQY7wqfMs7 zf;jn&^Wa_Z8o4KS!5z3sy>Qai{EqScJBBEN3j5B43MvD(qH1ptv3&$KDLpNhRI#;f zJYVqF$PF4R$~}=cKyWa#$ylAW$#_Xze2`UFUJ~T+#rp@Qx2&7SAI! zPR{6W>X>Ob{*|1@bwhe%vIB0xl`aPbsli(49w#oFMle( z*zFymLXAn!H?uxOy&YqUD~)U@^t}CV?wUKemnckrfRZANE?T&LKXeK*as&Jb-7jj= z9BIB9a~OsccrcEAfn))EdBK$1McX#6tznE`x3X^jP%DY4uFun%>>oRDUp9mbMF7f| zMFR+yw$y*mU_$R6Ix^(+lbJzhrN-3#_fne|{uDt#9mBET^*h5sE^&2+CM3I8^HE3P zl%iyI^g+BN$7%KhdvofmBP#(C=taWH!mzQsnBT#=z9Qq@mwX+y^=6Tk*`@78YBVI0 zL5;ep`p0C4**J5RcqBDU%SLCAtPRB^E_+v}@A1*JNlJ~h=ByJctS00#xmU6atsEYdt3-+@PQ31^ga#@`~KV+f*S!rIV${EaxhoFd?iLYWrsZE1ZsU ze1(uSJp}d?T5SjXfNOCK74+c!U&0mtU*Sq)dCt7B4EX;=xdQxuDpy4RH|2^Ht-mD3 zS$dxMQEAZy+R-nNevE!Bn2d3eE}hdy(*M7#D;MHe|7~6ANZ1F%q5>@bFX>8*7wvU9 z_WwLq|KIq6I>trslkcY+c$L_2&ynR?(=r=I4Lb-G6~!d=6pbpi^vuD!u2F{(quJq7 zEHf4xN#(4%!_>z{lrpCOmaF`#RlrWVhOax_=s8*}Q;oN}hAUlp6=42={eN==GLPA@ zIgxgQutb@&XqZPcvFdZ10W^U+E3FkSD1%J-z@+sX7IjiRs`i z&ljOy76M*Be^I?OCfa8Sx9SP1)ln;|NSfO~ih^7MV=qcqtw`a8Z>#_GRD|+zeDAr1 zz3@|EkX7dt;vMI|CT*VSFKmJOcns@YFG!LIlA7iU`KL5;dmh`ue7Zgazn% z8%daX>3b=X`@_8!Vk806Ck1}^cI|WK(y{CuGOY?W7!k{>>W&}R@NId&`Ckm@&ws5) zA758wj1g;}j>cW%f0cWvT;1A4vi&juS8wh_%gX;FCI~+-_tY4E^MEO7EU3g3QLE>g zR)2_D-;L%=zMuLW2aHMwI7MPM?fRXJCV%BV(X-QXl+zNlC;tn2ppuZLKLPqJ^M=yx z_yr#(C8nh4Wu)br703Q-J=ICTf~qzYR0kB8XGjP`2w;*yze<*Nl7>9ce1Uv|rgj1N z5;y=80V--+2B14&vWkw?p(u*aYHgboUWdPUNl~#0K9p2`W{@>Ii~pZA{*i?>Jgvw6 zsj--s)!TOF22#6*YGD7dg)g3$EvMPDlbk>0>L`nDN=Dcc`A#$MudlwCh0yq9iD$#2 z!40a(PmvPW#bFazPdxJzNrVTjHCY;2z2k>Gq*)%FunWCY;l>IfYgCP8mX&f7o(b>| ze`r()J|P{mQ=N&~4tky^L=-og6{V1sLXA&RQWHv`QSnP-o8tfEIaE}K@3f$}5=zQA zU6w;9oa|U`K-5~Jj|dd6Q`o_V!lKTTQ)?cH9+*=?^~S}IkS$fPIzCWTsPOMVXRJsK zr5p)&qd~97+0*@P_k8vKptd=V+SQ)xozTyCd!s)--um-*{U@cqrlNvkN9M6F)FOCN z()@lIs~#5e%HsS-bxOTP5RznkQdO8Gzmb`sJ%%q>!HEZRN?S{*2JTiOE#&vomkjed1O?CQ z8K=Kh#R1ZsmVZY4S=F)!I8FN*v)zS8fOZ`{hg!l(`{M^@@R`4x;srK< zDX|7Yl#7sl!ltgV9QI#K2QKuv4greaPCMwWd`u4{n6x?qqE(DFP5 zPV<^h1bVy2&Jd%O3Jb~BxD4W(bmK z;JD&rpz?kO@p$|avTVY#wAynpeaA&xNR8{2u0resX-)2`9g8Sg zN7-P*T)=&16)FxdK$TU1KFcG5X`k|^@w$wv;dTChc63e;TJS3R^18@K%g|YupiBn# zkJDZelB6>{;Whot4GO&uPBkp*NAlq292zP^Lpyz~F=()+oS;cW_(P}eJ9W)GUu|zD zoukqyH0UK!dgMMN?=@f;8bvL+_cQ0kE|$Tx09nW1ITylV>~i zzS29y?jr+({t|#8geG09`q!Gr+fM8Q8`r}$%N}S+iv_sUVeAwWYj^n~!JWW9w>IZF zCu_;YztKrY%zyKmdiC6w>90@wdRva#df3Rl$UKVy*7?}k-?E9#v=_F5jNyq1h$i_8 zkp`+Unx6iMV1#+wOC@p7$J#{NA=_D>+yaGI|2j+vd4${pV6{~1Z9PrLh1p>-DhHrO zHVQ#aY(DD(fdQgU5VH$^bzuJu_>ED?&eF`&(vAPJT(k?cGvYF|^VD=wX7brC{vIKy zk1M+u5vGo8U)_AII}{)QJuAo>ja3ltS<~27zj}a&&cC48`c~Mk+LJMl=7|7at2a9E zozsAshUgHEF*J+yzlY2h@k6U8z8}+fG7*khJHBmwBBYKS^l)Y&M`zR659bFDgIbR5 zQP4oW^ePGo6k4OsvJDj^>jA=(Jai`x&gi8gDLvtfB1kDsI&msla6KqT+~1mZJ8_ed zFX(oV(UYXp<5XRR#<(X@d#Q#$Y;@yXvnwoeY{tJu%sR$zR5X(u-J}|_XbxQD3<*;d zcOSS*_ye$%%n3v1xZiU4QW>QNK(LKGQ%0IFJz_Q4Wwi|+$#Z}{+GZXaam++48URD3$rK(6tv~Cw zM29v=v^X!tmg#Xp7+-4k{TtMCFhAILebF^Ko1w7xQu4A}9Ajg4x#t_{n4U z>jCftGRN=#fXEpYzz-Fi1#FTAa0KcO<-psKLjcBR6U7M)I|9)a<8Wr-wAGQK!;|U< zoqPNSI%Hqqn`wQ=#pn&c$Ci|QY@;ad!%0N?2!rN15sb+*iSnU<l_=CPA{g&=FFVMQ$FxlwtxP>kh3J+3{A zQ4Ay^o;@2m(y1LjUw7{-EUb&Ov-{Lk9J|clx7YK>+QmpY{5&Q8>%_ceO=Sz^5e=$T z8S>KoF1ZG0&0-aSQ=JFYIR@X~eR_U@;yeGJQ45bxqnyx8xX}={*ds;B(?yQsxJU-d zva>XmNYLrhbwdUDE9{A98Hq?rMOG}%Y73sfELav?rB2{h3P7`CO35Uq$c^n*kxlE4 znUH9ExLc_JWh-Z00rU5`>&OeHl-q|iNcka=v#CFy-r*Tp-=F)7yL3M>J4QG#u{b*h zB*~bfvqsJzX0engg*ppQLFELWkf-5NBPGu|hv2 z8R8K5jR+*?UaTXQ4PnR%MU5cy3wvaF(Y~Da5wN`(+sR_XX}-~%ac5&^k|X9bq8G_+ zeOtW32YUr}3KR4@wZ-gWPT*q3ML`@a6Y33#M(b^IycSL0g39dP8j;>o-`g=MVB zY0DJSg|)QK?V^3E80iT;&LyoqxKS00@K`yZc$~cTbxgdg(Fc$Q>gG4K=@^I#ojI3H zLYsov99N+;EU6SK3Zfi3gY~L`rIp4rCye80I_@qP#8b8xq&7+3=?u4iX{3hvsNfYe z;^)jd{s%D;YEy5?V`tRVklb*GKO1qEH;*A-taF=sLy*Q%HbIT6fGiY$hcdYo5>Qb} zc%>6GFt#ObQRum{+U~F$blzz5r~x8Ox+sPljDR(6F;jJ7mAb?gEyt85cViFJwNCwT zU{C>?NaNJ6_O%5|Ul)?8btNV@xmjj40GNk@$fk?*1qLJsN~Ao-jKVI%3Ppn`ixQ`M z#DfHdE-Ta4LrK{n#TayhvD>5kdD9r=>ox*fpAX}j$C!ZPt~ zE>snsZl|9%jiF-5Ec#*F1o1LWBn+7j);(Qt_edB)YgGT{89vW8$ekn?A9cjGzF+l;8X$g3phV)C@5IuDFQA&Wpvrzoykn`2`gikWMZ{rUZjI8p z%ynchqmiGK0MGbUI*R-;^c2EdZjMKto_LhMrq^@CIi_* zxG86AVgSi;)c}*2ljO@7OH6IaWz>KA42zC?7VoG<(6r$g zP&QKI{LYv6T$pMf5m2wv57}TnM998yG%=mAQS^C)P-Aoi%;V5#=8m2{_+a+E$X8GI zz)u{C`v|*fy%Wcfo%owRvm2usFX#-IV*1Tu;jK7<2C?t8A$dlMIa+d9H{Q27#0FRK z)<^E{j+)@pu4mAwXAM6}wZwb?U`2UScd`n`jXp*By_5uQ1XAkVw6a}mBN6pXHdFK~1Zy6w9 zAMHL8(x&6&f1FaUg7|vL9^3JgCA89{U7({O|A){Z6LcrIr_D9+#9+3lauDt}#U+Mi zOS7Mp`wk!IEfW&U*RPk_PC?SpnL2Q9$03kgy1@21G4jz6the~Hay(2y$s>|}?A$ZW z>;O@0;ZOk3(q-VO^wxTCCPJN+tM~6OVW{U47?F8N}V0kxv!AjT(wk3wJ_MY zr$f2_U_}<(?V?HKg)$UiQv{>)_^&4(WfIn^$hc%i0(We^W#|vPEomR)x^>RwW%x+& zVotD=ucTrVcEKwe;;3q0pSE`dyHs>S20yF6$SErKM^A&}-K7;K?RuE*?1c*}@q^(V zW(r+192&tZH~AzVY5zDkdSmih-fOya><`XQ6gN$eg=gwt4MtB^JYr|d`OxT_I9h3u- z5yN5Q3>o|dk^S~-C^}OFl?L}rO^qu;s2k_P=fx)dX7zoy?CypJ=WDahMrRAO(= z3|2CHU~6&WA4jp-1Z?(1ZqIrlZcD*m(>8eMpI%exXt(FPj_BK+43hJ!sXm3q>S)54 zGG6esU=Y9RM-~Hc+fGD_5(E%>^8MfiZVW92-qe%!Z18_q7;88$6EwtWk`m;dwD0%8 z;F)*d-)_~?0QG1&?QB+-h&nPI9DJK9uJY8P@YylEhk!pY@LJpmj_L?o0%K!012XtP z*l|*jlaz#Y^`G&>JW(2tbucFJFeAhc26LVkag0yPHW<~jCfiOUMB&7ir20C)k`}F9 zKbv*v4wPllam1kJk5=m*CkokNiFO|)OI)Z+NY>a?Y~BD!V;it!dVAUOWHkV8)%)tV zt#aJb7XzeO(4Lax^4K(#nfakGg?Fr$LeO`or2~Tz)8j4E;o7t>=4O-n5y8jsbYHge zP+UxgBux=CJyEg^gnxAhrxAtuj6F%)m?gb5@tCtFmaZAOkD~tc&QnvC&paI7>H)sRV1B@B%{Jdl4u?+KzCVTT40>c*{F<(V0GJyJ{l6-v}pRtcGT}U3)uda{mIW&_}AxRz>u^zarFw6dG-djKW|`7 zczVbXZ_-3v667v)o0GOeSj2!KIkYYBXjJZYTqvbQYAdG1Jqvr#*x%k#ZG!R0z*EYB zp_9erV*_W8!i4b;9r%&jn)*IVEkq&BoOEhu+NX>3Gt7%}pjP=AnSx!wObvbbw4cwCF90VRR3Ar=Ot zp9VK2D3i#Ya+ghKDe4M6Xk2AJ9ES_RZ|4Mk^Q?)AixUC}etyNiL%p}y9n{cp1p$oB zx0cFwEql`ntLLcq*9c6z)XePc@pP|_kjd`(V@EJG?Pqf#e8|70p50pw4&L!3p+N2| z>Poykv&L>ag)?1tPgv~n^x<$w0uCRzy?;yP`gi9jpZxlkO{4RIBh`RAm_&Tl3 ztWG?RSTq~KRi`Jo6%;-Y%ICmmGO0oY^IVOl+gQ3*8fVpo0HZFf9P~TKFS@Ybm$Og$ zy7*+>X>^T`989ap9@9F?EDsjtGT4vArdPnS%GSV|1Ff4XlN}gQsSMcT5x*6>%bv z@cNl(te&a>|6~c=lS~64 zJNK5U#2T(sO`>7|7cDSEmZ930hT|qG-ZCv3D`*y`>Wb-x|25@g69_Sz;`XMQYq+l` z&KFoHvi_*OE3~om=r0fO@Ukmq!JaY$8-cNWn}RysH?#jW@%fiGuCZ)7b^hRb3mWzq zKD3Uh@ZA`q{w`Cgz5Wv&Tw%$SvXs~*!K!UN381pk&j@ii{^Xph#6z0i)9`x!RKpv= z;%fckiEZqyH?J_uJ3!z|5Sln%_Pj14#`_Z09RNw=8pLIISLnfiQ8H9JYsoFlKCNe_ zF~Ct%J`7$2Tl}mumVSy&up6=xJ}uWA4Nmbf(O&~Xvf1X`dwg&2VVk41{v|3y`F%fk zc>>7B^AR&mm{0VBoG&4OI#Sv}RK#aMLd2lM(BA=dd3fZ;F{Hihl3WLbJ*Q#NF)IwZ z+mj4!ytY3R#H*xk<40jwG#%0XmNj;Ch5IkdkU0f^Xavg400FSpu$|II9UZ_j^Br1E z^l)RY;HHi%NJ10MZ`4XV-8-KLQx8?s#Q8!=kVne^PSb}pK&&S-`KcT(=U{{Xib6pU zv+T7-sQB*Fi$GQ=DrpzmfoXy2h_V>pU%#)Pz@0(Cy@weo^^w*Vvm@gZS0Qw$zaJ1Q zkV6h>==i#ThvK+=TuExBF%6xdGwP28h7Zq{$-nr&P49JYq@S1E94=0!wpS%O) zlBGIlvX;)(c8nYbmytGz>pf84J4nN2IB%-F>!LLlVKSWpM8PmZ>)i^C{shn#+GoxG z1o=rJ_(raAScxXsb{KboK5QMv0xHD+wXFR~>qCaTl=3H=21<0vUa?Qd>PcD05rUZ? z2*J~hye(IC-5~(ayE=FTr`5iTvbT==ONf*1qOFqn~MRP2dLAiwMGH{Psr zTJBHE7PULs*#CfA%hBcSGs?ptVEyPi@s?dkG#iL4^4{)(t#_$W0}z78Wt z%{ochR*83pnz4}kbsttPE}~Vn-|EvKruLEm>jZGgmT-BZn@UP+Vl4&Ratc@DX5xU8 z;x!UQCSNg00ml($Anx%9Rit8GQf?wCMTT#`p9M1sP&p`qDq$jwYSY5`lBtV;nX|_h zlm?>Hq7(CF^M7d&1Ma#c2|y}yx2(u4ShF!Oh%|Vk#DZ|+5%i6%#EsRZsEIo!9RV($|n+ za7DIcvRY?CAKwmf#7t9t{JKKKFy)F@>q7rXk zj!0+Qb!=^x76CG`R;mXstp`csCi^Qcwa~Ql>%yzGsD8~-a~@10P*SQh?$y-|qwR%| zyhd$jXp&0O5h=YV=a9B&&yOc6gJSd#k5@zQi!y*4wT~*zVAvMqm3C6?^T#I6&1*p0 zsw3`4?IshkP*6o7ibolSg7c^I5>&^ta5Duxc5}4(h43zDFhVS+9WjSZG1)4Xopds% z|CmLp9Jh4EystX^5MC@qQHcrff>*$M!tpLPfrSfL z?#7LrU?$Njt4%kBOAlT&;t z>`lr1t|3bEY^4gG^C#X;&<{_H+<5BMNU?6JsjFTq!sw+ul7zzP>jgXZeW9t+$Dxjg z4v*ol2PbVS2F9zWXQp6p=5ysEXBJZ~gn?TA*KtZ00`765mZPiapOF~*Du~fr>q~(Qx%>y(>FLLl+3i-)&MXM z`ccXVN?^$}|9jvXRezOS>e~3=>1f-u>2OMn&!7WHpan3I&HPYl=3n6myfRRv<(uUK zhu!K%^gUrtn7H2!C(`-?v;y@4mnC49y|oKxW<{1&z{M zClzlpkFdK`NjTDj1&`Z0`$Hh;noSV#nnqjLE;qaoWkUrVrR4^gyf3fT3EY_C%^9hk ze8>x&%QEov*Ikj4`up=UP4}X;{_nL@r`u6p_R0vumgEfW!g=4;Uc$9#rS@V&SDOX*5MMWyXtbKaF{VV;TuEJ`jMA-a&p9-4OW^Z+5k=3fCw9( z3P+qTUDr-G)}-l=bNzU=ht9loYF=gE&Ac-ZE6j^+NZr}4#MGDldYim#RZ<=hSM2r-n8U(!JhqBHA7SV zaW%$LEv1v6qk?Tgjkp$rSKOprpUUpzew~;2FvO38N*k}#sn!o~dFXsOCKR+NFWysV zeq}$JxfAqat)zmO@l`Yb6HXyxu}2~cFO%|~?Fk!`r7a$~zT6<|UkuOb&*R`Gx(|ER z{AgZ~Q?;M%j~1+r!o&k~D(y}gJ9g&n9!u%cZ)Q}6{Md2eYj&2pS>7n=3@g#x^>43n znbUI+L~A1*X0(r_m90ufT9Y#KW_SaTcd;Az(#pU`ouC5BxK;mK=Os{5ta zUp`HKwexzwtjGz)lyx;MiNkBkOY42nVy6A|nidioU4NLm5pO=SC&xepp*)Oibq&^|{A+mprK6JhzT zP%LQ#N@?pE!C>kr#>$qW*id;M}!l`>e=V8c$ZvhP5%x}jA+3g?47xV8PoDcpmSRhrQZtaMD+!nc$dju+@mT@$m3& zRP+v-n)oz3@vY$46p_zt>PuB7^jV?B*_cQ00>*!4LmhAzI)xFMZ zU;R(4P*uzBKorIIR1N2iupZh}M!!)7M^R;7wOaLBb%OYy-=9$$*oX@cTt4Hc=QL{c zIjTL$)uZn@Ytrq;sf)-gj(Xf|B9gl{Jm}OqaS(&#qjN9eZS|iI?hvlb=i})py?9Zh zFI8jn?RO`;RBSXN*sAH7z zAo>(20~1x66xN)3Ou$gOI11HDJZT=qi)34A8{;NDTTU{IMDb5@HwqN_Bant9~f_qE(LDJ4yMbm|s?=cin&v91mHUof@Ll-9g+>5hKLu*tUeCl(lu3eYIW-zc39cq@ann^ zP5t>7zxmT+d-%{COi6dYl8=6v;&kIQ-9l0hU53C$(JtI%NUdSF7F}QDG~++)XsJ(z zG+c;&7uB9C`{r1)=QxfYilV)n*$I#8p5#(v`rI|Ra@ouoTK;y~NFi**8F(9|J{(Lt z&M^-MobgQSR`+;Ny7Fjj3)3DX>9i!1k5Dou-wsPZP~1GwlN3+8(H>xZO$x=iEICWA z0-T%zO&7;_qV_JJH}W;q)3E*fWj4}fR2FLpa%e+(nCRa@aT}~=i}3nP?SLoX3Sa333QIO@5-AOtlb(FML%v_k|Mc_l1J6;5ceTw<6K*k zEYrjl=^*7{+_#}tbNNRlW2pucY7r7iwV>ZFRt0`vF)7GW0X@16Fe>fc)|=&R%f5pR zD3*lut8UroX~b4vi~P~XCWrN?rNf$54B6^|0D(nYW_=H3S>QXfM+iH}ixq zcV&=lsg3Y4Q}1fk0nc#a7q3k_0E9vFOK_Rl*#%4Az1T+s&t=e?x(xMJQiai$-MWAF zzM8N_S-Sp3fWC4LL?4rXVWtdqdj5GWMsV0>6D&G>UO{_*g}gDh5jmu_%5ZPBp{y^| zNx~r23Do{|mkD?D0Q%HbDK-6aP}GvNG}APa%kry>|EW;|MD74xC+*-&_xMjf=OSZ8 z8{nQ0MzZR6<$vFXQ~a))ryZl4pB|r*TK*-VIr#Q>uy=D2!zW2myKB~ObbYJt=FkC5 z>5&OrGJgNJtR`c3$cE7Up*D44h*@W{{-%u~T7PY-kjINM%?OE>#M01~BA#5t#@g|A ziyM*9YiM?C3~%Gtw_tzbz~LQ><(VuxCwjl;-l%&^tt3x3eXC6{C9toDs&@7gs4u;u zAbYYGc>{0SY(yf}eQmP4SsxI2P3Va`Pcs&=(x1n+i5HS=KI(bMxHSPpXey`=1j!5o zMMjl!N*$J@UEo&%V!DUeE}1u_5rq}y90yqvG4BjLb{sJJr0t*@PHHf{Ujse|KWNdk zXR4gsZaiLQe2+Au_b<%)E8nFJp1FLQCzWyXdeP_X%3v%Z(gH<}u7J6#t4E(wH@kGz z%q;QO%kDq^@v?Z9k^eXXg6P}*c6a}Wref=E))g;Nf%F2CRn8uTQ;jU)Bs)hm^;9aZ z9FH_@al=KFIyIKys7!g`jUL4kR(r@pL?DD#pLg&S1on`#I)zp~%>%h_+8s$7JW=11 ze&CMA#{kpjdD`&8ghKj>Ln!6Up}$GML}7+rD~aqVIKf&T1uenVa*Iaf9u)nsLmKVj z-RsFkL5u)*jcoA!HtV}qTYcnmSq?v)0m1dniv5rEJ{h8aQ0Db`SQx32sSEx0>)oUs z=Eigam7F%oHM>m`n5Z*}tf)4F2+NEKNRqXwZvfx*Y^U#Se!QN5mXua0cFT^3s>=>S z7jcr0tm>^n8}eFkL-yE4b_qFxb7)4b>=%H*Zb_z7GL>PxAV1>dkgD8j4fmTnTOC|?@gc)tGOq}spm-abGnuNk8A=9~1^`;I#`HsP#+|`W$yIuWBV;7dZ zgmlU9kv~>I(-p$$Ei<=c>rS&f{(d8M^IC}`RWD76M>aOk+YM|IY?E8Ej+0G^MUA(! z7RHepv*z@?zI*~+b(DDzbj`dwcehAJflI-HnTfMaq9)cQFkUXE2K1&bH%yx)1u< zsMez1%9apY`uRHD+QVa9dBlS8XXg$lS1Xj_#T^C?C$;t7R^(x9U6k##*sD)_+eZd< zn4tEokY{KUj;9EU@XKt#ZlC@;;EjVf*RD-%gHK>KqnnUgex)bqP8}|MQUN47J5|W* zgxMqSj!~Dobe(NASlcF8>9~TV+kvCLXXtd|bLxtfuk=1GR=0)7-AdI#m`uzQb4k z207s<#qZLQQ5i#dSB>(x4({N;ZQEb5JK)fSZsgaWz>mWJ5N`}U%5_!keF*xY>EQP( zC>?T?M3ks8bQ68m|4LHf8A=H%_(=LV_{cH#qc4Uz`r1QloXTa#SAW`$4WXB03ub9) z$EIsf%xGGkev(+e-l{H1lHsFUqPueWRDl7}RFtglLj`tq&(6Wt$=1l$$`NS1KQ8jp7nlef zh5MHG|InI(00Csdp*yp`*RUitS;y~gW7oG2b^r9hh=!B*VMd#)I)P)1C5+6495M!x z2s%Dgzzo7tvk=jhuYXs0EX7VQ)v! zj?~lX>L;n)3o#eA2#NQ_&OEh-^ADF1skJV<4VHi3jr3B46q&-sMNXt##q#7MjVfavKa zLW^jqBP!l;6Z8)*1D&emoE_2WJo~}y_^ZUqC>Vo2$;XA!&_a_BV|so^ z{o_cpOw7E5Yy#!bKKCUisXKbnD&dEAyn=GdblK5GXDMw*2N;Ft*0+KlI!qOEgO2$j zB1{nS!&Q)r5pp4j{zW5nP_2ZsWn2zcctODVPWvB)Nv=?Ebj2mdX-uzLfjhn=LSa(maklUZ?VOJz~7 z*5Vr5BYs`I?!WJ@w+cxgB0Lc2q}3asBDN)pilZE)z|9_%KAulOR?8wu(wumiUGfH? za|e+KG1KJn6sQYc8Wnp}uTilo!F_@5P(eb-ufk3QUb0@)O-TX~ z8)mU70oO#XLX_Gk%5qJhH{&}yjU{4z z4vEkiaRc6)jVW*ns>aA^U&HHV2k5&RRi1ZdJm5Ba+Y=YXB0&%DlUQCq&{?@jysja( zC0^(Ot*!zyvl2Y6JCLLS4`ATfpqiZ<4G0j+16dDg_NrxENUh$*<7>$DrG4ic{i61w zjViA3$}cl(qo4Bk%4E@fYyMD(Z+4G+0BXf3Hg=obK3?ai)4KROovk>6d`#*68Qf;@ zaHPx?MxyuxP3@1ay~I!nT{Y66 zVVI0?WCgX+#vcjezB7Vtd4~+7YN0Z#0@{oE8-IRgfioU-#~jW3p;07doA)297bdhb z@4Kq0ydqa zr++m`H~5Lu)xB>;4rWS;SD|vZ@k>SXeRuV89QUm3$u`L!b;tlfHjDxursyI$; z(Xm~;D-#_3mVud#4Q9Wg8A9zrK1F0a5u@fb)*|+JQ&ALa{D{QVm@MSrfZ}!lHcWHC z@vT1#uve`s*EI}ZCQE98Rxug6yV^uM^=up%z*@a!P;NdhD)ZA|r{8SCyrxYu4)xc` zMSGc%`A1pXK?16kMiWUZL0BT#(p3hmAcdO@vL;RMf^9~!-^7XIgs14NmCGLP560N! zzo76`{sK{K1r#3@Pjx^%iQ3!DnGl5{VAe!4rX;wY6LO%Ux@KS&3i*4bT&hl+GEUx!>?;oiQlvo+@aO6l7LE%6_N1Ra zb#k|1uO@StXb-I1W|yEe49Ts?`@)px3noaH;BdAfp{DYj9B2Gp6(}JX;pRgC#@JDm z?5DdqaTQ9tlAoA&84QSa!P(=be)VFYJcv6~w$+R!y9uhSbD_@B7p1mwmW@|}*KZ6ceG99kN9rrxZ0<%S$jBM`_tC@{9%t{(aK}C5blc7sC+SHw8R^dwW3ZxtL_)zXB)G6eZ%JL zgBF3fn?%0`!=LL+pqx_AX7lD*s*A#4_|y_hrF8E$2jntrR-#s+*>6_taB}=EAMAfy&_>DF&>d) zis*#iPGX1Zes2kh!?1e05 z4X3B8Wi@q7yZwpe&l?fp(Dcf^hY1vI3m}C(qUW0bL2mi?A6q%r^=!NMx+j&ADczxu zrsFjB(2%|zM@ot5>ha|n+36{oiR$rsV2Zj_2KA#SkK-zpdO;P{U0geh$pyOM`FMpA z@=0GVx7)?8_;8z#h-|)^SY-uoNdJkw?FO@YmRTmPw)NaYWN4mJ8O!SFJWr5RZ2JdH z@(%@wiO0?CN$Mo_I*?hf4b!w+`=R5A<5;qkQ6Qx#mutf1&uqF*-L&iQwB>vD!P~;A zF!nw_=^&A5+xv1-x2jiON5klmc0#EFaYPL|ED-gD)i>tY&-9=C+B4Ji86&F;ELNiu z*yn9)tLQJ1djj9Bikt3{0U#)}yE`RCY%augbmuG>C0#Vn)_ap@SHK{srW)B5A`lSO zByRK-u+(>*MgX+?6$26j5?g^L#d516AI~=)Kb+c`awdHZclk3Qu3LUy6XCv7?mIeF zNj7Gl0qHw9DHW=W&B=P84jpr$i&&l5rbxnO&&vBA$$@Uu{WxQa9Ce;EsnM{^&9QPUhN#q9Ec3x}33@ zeFweBL;^ps12|-o_xCdzb>?F@60;DPXF+cUCxHS_Q(v9kpr#oF#ZH+t3u*Y#&^7vJf-c6jQdn~pF~jn+V_o|BpO>c3Sm z%bQ~Rfdfw2GOc`W%IOe&xBjea;kRmu@$*pN?+JCVPFLQ6iw;l8fIagInwg_`pg-K+ z40pN0vvy5?Z*?xWI#mtdZP?iYo4J%?#YwYVN5lA{!|6aBo!B#NA`{Ny!9&GDA(P6h zkVVDTt8436ww=0g*D2JqqVYY!52`7?<0+G@Ck6%$EMsPHNlXn)-Uk@~!kuM)4|aBA zNJRgLyES*3)*@i(Y!K5_yZ5?3ym!tvkzD?r(`{Lw{`lt~=hdXDtP-v`QrEef6B}fe zz&9!EFc63w%r2mULh(259>ZL7q5r0au?Yrt$HVr$hY9I{0~Nbkk>A>8cJ`;+W=+O! zZ1n`mG|wwQX_T4`kdbC0{wJ@kBX!JibA{X@iw%}Zc66}doQGPvLh9As$dU^%?%T5F zutobjfA$jJ^|vq=GhmX2db+SQGoEdVnt9(2cl-T0+@PqWzYRB0Y32IquIf=Y+uh}l zx>?TS=z6kVR85s;FIAIfzNm2nMCxT%nkFZtPHWk_~3=DNuSpbLuzve|1%^0SZQOb zTEjEZw_Hq*Fg+HpYVlNvF-H$?5oD68I>w{0nP@%8PX}=u1NGEJ(sH#N=D$#y4p3?` zp&SR&NqOuaW!8e+IlQsHEq2QoXqppDrXxzTGGs%Ym$i91utRaAez`BN)1Ap_F*!0w zz9R^R`j}(0Wa=!Iw#3aab!Eq7H)=0eLtpMmnlk*QagF73v%G2WR-TY4Cco|>O6g`$ z0p|PQEB<@}nP<7$vNSVG|GwkQMnqwjbscU`w0Huvf;p*zT`Zm_7>74Np3XYNijJw$ zFv6Ud9_vw#XQU2+b4stB&u2&!1&tPPCnd49&PK3B1Hh$q8Skkm*bxCl7 z`_(M`sP~{)G?b`oXaViYTk=tI(iT#s!N{iFs48MU7eOdtQ!@$n=YEINSpsCgDYp)P z9lbsJ>zB&WXhKg$&o@z-9;ZJKx1Tuu6g0X1&MaRX^I747#7ZhMr1oS!9)&iN>H*7y z>xtql@y<@vR6N=Gku-ayJ`dA*Qf~))byToUKgJkCg#EtF$S&;ngAJ)d#2+ItoiT|{ zRUeIs3W$E&FOwPZ=O_@Ou#t7Gb(q7IxYqvOo1Qw>Bp$u5;N>^;de>mO-RL7Z`yP7GuV%kpDIXM z`GyTQ<3=MtOZ)b3?8aSYe@iKLE+fXVg^fEV?APX$`o=tm?3e{=e*z0yKx7}lhsb}s zyU0JpN_F-0dMWw43tI~*>ICvgNmTOw!_3Pg)ypeo`AN+GlbD_#ph91fT0zlN%hEuh zBCPZCCqFr}Bw;ZcMM-s;f9xWpx%~1%1L~6JaY5qDkk%N7l+v2 zG3IU^tj4|e@tqFwX}Z`r5_ivxPh#_w-ZK%FW5MXkC%-YG(30WxqyV^IW=^!`8aNdh zO-kgN9RsVN;Zx)32*GVhDxx*k8eeCJO;p!&!PVO$TYLoPbDF2WwsJ22DrkCm8$Z!W zzqg=VJp2u%;8G}}6%`GUn+*;>vccyjjM*me=8!wblb(%nLg0t)4ya^F<{L};BaeAD z5G{)tKOsp43s%8uZ0SL7Gq9RZsfJ-;V99I{XnUWjYG_YOhwW1(QJPsVRccx8yrp{g z{@U}j+dIQ$h`X&vQAwpB9j&|}B{xn0LzLc{g}a)n$jmew@!k1MLLXnu%c`tX>vV|eO|$|7!-7(7#9con>JI>5d)jL5gerbqB3|OiRi>6y=}+DD zm@PU={T-OmI_%_0hV_`+{1_f^ul;fH@%e?n`S&`=hQxZEV(rTuYRfE8&e$fDgzgMY z2UYeYn`w50bG0}Lm1>sg)14WcRF-Wr=nk$;7-KBJkcM=JV2YR^FU2e`X*NlQ+8bMZ zBTWV(jR8gZu)X@@hhrhCcv`S(Z8?oEs!0{buwh-Kw{J$?p(ak?QLmzg=M~h`2>1=W>AICb)F~q2mYDAoDHTHNRlqs8XKjFnx)2z zT$JEm)vV((Og1O}YSh=Ks`0H4M;-#Qtsh%lQ*s)y67J^F`gJ5LxU?M3sEJx<0YHc6 zj@Q+X6%*f@asZLxXIrl7VoGQhLIBbZO~dys~!Uf3lFtbfdkQG^ZF6FUMzBWjkWbtaXryFveA)Az6h&J z|7uE89+im!hx5S$tohfm1~N|(M1AyZ+hg@%I^<(niQFfKCvb_+IBC~jc6T3o`Sh(Y zgPZD$L?C{u!QV2CvbU3p>#<2GAeVSP=Kt z1j>a;$|)|V>`YlT9q=OoIU&{6K{^CW73wk+6KaCfI}0oxq8iVQO>`%$$-a4A$6$B) z>{qb-(=LnO_X4+h>|STJ$ZGmFZ;D`%YAb$N)|*6&pbMa+ySHI^o*ClFXyh&RhYZIWh2*JK~-u@ zbXC}U=-|55>G5H_up9plC088WB6dA1Q?CE&C<_WGK?yTn@r)IVd8U(nPA%x!kwoJK z+n7!)5papxp^l2c(DN?)y&9nTNbFY1sV$COyXV~gbd$k-=QEZH?CxIfo@vsub(nTP zDrjfmflep8ReVfh3)dRt@|a0Rz47IR*9C!4Ed5{vPxI`AqQlQcj|VIi62l6g>&4pe zxzasO`%H0_(tTcxff40m{4rj2EV7Ys8@{{M)sIV`(|3+go#jSPgT8GL;7PW5r|8(3QCfEQIPQ2WP1iK66JF8$Bjf#GHBypvgm1((v8Uz`rV!<0N44HQgOQHL4zWtt{H{aB1D~QCIf*v;B8ag zb~^V&0`h&PIFVc57GuE@AnDpcnnCbOG2ba9>ey1D(xk+V$XT#WbqUpiUBl<}4?ExH z&r?^3I8EOTndEJ{jah_8{hh2EH}|#Tz#|`$;?4J?;X(W4?ZjtQ%r$$AYaAiO0^^SO zH@HFyIObzgS*GVUVV_De8tg6NE=&WOuW9_vQ5;Z= zv5l4__~!(k&V%8RcMZSc+epT!=>^;0lfINMKa~XnEsijMiHjXV|E+-fWI@24KAx#0 zXnodWpg*gI=ENfR=)f0yReR!363JdAGZOLvweH+bIfe`P2F!5NwaM21e=2iueQ6Dr zfNmocVeinbdi!vQnsB55WrF~Z(=>n-7YsnOs7&CVecE_-4+v=CK)9!a;d|;S%KqH{ zS6cwCZD19>c>uXFHr=de8lBjBfd7jy)7cXaNUhCq|v&!YSf>&s^yl4f%jd8Hrty~dUa zGEp4!B6odc@Ti6SANaxf3wv{!D6+v8-?W_xmfBphnaunT2XLZ!916{3bui^5)k=L> z6`r<0N>+r?lY`8UJ!NG_;-g(A1wr7_4i0{D6?$@h9pTZz?P(QBR8j?4Qo&SMpyqP% zgCh_>!hgs<9#PKy{9c|IVhV0if|tpDy3O3IFZ!*c&o ztf=oFVPoGYEZnk|yc45Gpw`&@WuIgUDwU#!pmb~axl|RHHA(6vL_GZQdtt!%5_4J@ z{a0clnqMN+25NGYZ|$n1`{Gwr1-Gl*pDqqZSY=5QT`3E23HXeYiN~n=5ErS+)GWJr z*TeNwJ+-9X#U7pc)3(MhrgQYX<-OnG8AWag9@)Ac5as0@B(q3`10VMdCCK94j?-3xR=c*^nAykzYYU)Ji*5WJE?Vk+Fz3UPHpN-Al9+BnYq*^zx$Iy6@EG$B5s^fUdI(~quPGp4^62IdtDJ(pCW$^;sw|nr zjhlsjEFc8yW}$4l;bLzM62-OwIp7tGtGTmb`_WWM@`<`cw0oZcTq2l)^$(gNn>S;x zc&?5=3C4Zwe{A;7qrS9ocMuRShUEd!-@J@gY5&dC8R7g zNgoBW6L-CAU!Vp5)6@EuId&!(G_I(GTqAxTuTDfZrdc9h4>XC?*X%9ikc`{HJ7jUU zBbTQMXS2WFYw--~P10kQU=&PFbDV5EwKOC-@xYb5kO{aV5KYLM>3u;$8x*+O_Dn9G z3KcqAkozY2j=ie6FSJ*q6U*u^w<8&ORHp@1Rzh-qFek5c)5WC4Zd$F~gq1=hL&#LR zzgjrV6;*sjH{dOU_!lX>j8vwpqH^K&_?hzYI0#a^7F3$*z*;uxm4h^-swpLY9<7)1 zGYs{$@j+dTH3(J|57Us188waA(F{iI`XahJ%2a3S&AA@bGg45{V-B8$V$C0rffE0pDe|)K+L(Gz_C`BVW4^H*$cjPqA4RC@dsF3;k(3)I+}f(I&C#9JS#zA|(*1>sFKpcEOU3{;T8)$m!0N@d7Mzwx`;wOhZkdo-yqdU~WR$7}LW z;U2S0$-E8f#Nl3vrb^K>p2njo4cC9qrXHz1p>Y_3?^7UcLq5P+cLF| z-a*7~veG2}g|HG7S|nl>A1aGd7eqli8q!SL_aIP7{&2xespy*l{f2UtcxTc8mV#9X0|VZ=HtMPf0HbxaWl;4O{`o}n6vDX zI1Se*Vfhei811hB?tD{Rd#NWMK6q83;0EDR*=W9Qz(c~GbLZLbmg^e2X{H-rzQJh?A;{SgwJ+}xBQL(cpcS6FT8^;tY5}|kRPli7sSUcwdYrilGTsbiHY)j zv#XEBoA|!jbc%uwfedh+-Il7!Pdelxut{n?oSS?dIr`MYP$dicV5;m}GQ z$&PyZxxU4*+eNKJP`uu~;{^?x=e=Hgxy}x6fa;WyJv8gq7{v8yrlCt==EO-e92cr8 zoR};x%m+@?qsS|rpZUoLG2|d#>SZDBHg;A*5q4KaUYxgY{G|9`5|1>OqHyg^S73?r z#j0mIY{)wrCGd$Rg@!9Seo_aExmsZM+n*z7Akeo4g%A!R0t<+#-z<*lLbQ;PK7OUd$jLl4|QeyZ*I6yG=0oYC^Hqo{ve&m2$_= zzhg_1&bCMxQw#gEdEU0e!XE1hAYY-5;ynE^$k&-V@q?vOwS4X*<)+18E~c#w)o6T= zq+7(&@`MLLtBqJAn2BGbi!LHQ1~ynq{k0IiIZLc5X)4LpvB5)1*Show0s3uuPB_62Pdq7K%}gNx@}sD%6X!GnCwc<^yn0DBrIjyrqi#%&N}G zCR4$1BV;4KCWoH31KG@P0kh`>`0TMU3tH8V9G`{d$!Se(QlyYu=tY{0v5(bby2lsr zwD`srP2cNsl>E3&KM_*rJ-TB9txB|)?4hvjUwFf0tTKoc@pP)YZc}T!IVs);kbqV9 zOHmKFPtRxsULJ3<{j%!2pNpL^jGRe)rA6l#UT{2x3HbT;7>|_ZvVVGIfyAzDAG~9J zp_>~?veMurv{(r-DNe@s1k3hQ2&b#ldp2SFrWjOG54BrlOek5WFG|t!Hzi`>gyPEOe-QLWYRKZxAGOL=)a3lFTXB4)@|ps_a``gw~Tncfu2gr6S z!{7AH6+@BsQYHRXLsE+F1iDC4EsOOU9hC=mZ}8J{rc3AqF;2p4F^!m;q!inh(DT^0SY zURn${Jnh5#stycP;UJ_Khe21Do3IEILZ~&nxSENvM$qmW84Rh^1*) zv{gRTxCnXWyXTlQ1PjV zM=k;+NLzjx9hyt?uj~?B7bnygruqh^c+mR*k8DB?d?0@0ThWX#T?)F!^=A-@5Z+WB zG)YWvN_`saFODlH&HF*yPxB#h5xJwRpc%E)+@?yKwJ2fiJ4Ih@!<aqAWj%>VjraR`a z?|oeDoC`j7E{HN@$stf^@qxhIYmjW;xcdwC2SS{z{#pL3z;xt%o-}n@85F{Dtz^Vg zhd~UVaYzPG3TKMBL@l*CO^(IE35uVRC%cpraT0qwlNt)Lw2>8#Db4qcqnEa>k?t~W zFIrte6cf^Ds5{qHPF9F)(-*+sFK+W~Hf)phgbcr&NZ_>8sPJtBgqM70eG<53cF@mI z?|kR&BgMyQR04^F!HgCS0$$r-{#|0i9Eyg4gO`cI0A67ZUqx484$}bGFaYebZ^TRR zLU_POe*6MjaG_N2-X0tYFI_eKoQxr57$EG73+B7>9|feny2Id%Vi&ouCcI+-$moqw zw!GrY0^J=MwE+7Eh!^>h+6iqOa7Bua;etbC7)fSknvRq}g0z@W%MQRmk&A4wjYe+3 z-pbpyIE-*U$2GNAd0_t0$>K^*zG4*Rx=c#Tqp&ixurXXoy8@Nq~!X)$Gt2V`K5y(R{b$)g0iDb6|!fnF{C6 zh+Hq=+SzYGd!P~@Roh@3v)zFH4vF5MDWOQkH>)Yxr9}uE8!x!exV8Eb>NuGM;LgsT zebkOaOQfmG+o#b4e*r)hEzXp5CJvZq=Nu$#gn#L=Hv}7(u%(i6$HTD0ZO`b~)Mm@` za|GE+Sf5Uc5M|Y-WkWdH72c_Yzm85_(Wq;EAHCZJnmvw;wU-ej*y%lp23j67=bW>&1YwD(;nq#kna;bSr-EFQEI^OdfZp zY$G7iDf|-X!J-~H_8^5;+c2HhLXGkyiPTF*Y=2cmFN^PJUh7Qb-V*&h^ScCOpYkgv zDRydk9OQTDtd%o-pGoUrn8`=JR&j0G2(w>Fc>}NuV#Pz&!U97WZXAL$9Py zcR3z?Ht^4Fut^wed#S01Lzw4XUH6ANZI@ho>lVeTcF*9Pdgh+k15w|8NB38k&l*8I zUKesOON;!+B{_WTTXnJTpgU&%ZnF&mc-1C_6k(o>O4~{EN0?rm=l8{$U&ttMAX%1O z_F1S=+BkIB*2RmbOR%Nl(hu;BW;eUX5JBI2o%OzkcvGP&Lyd10x}<`kLwP`zkb;GQ zxrsvg@AhmybqV?kbsa~e$6qEc3~EXS^*j+Tzc4Y38Nsc=0n`AZw9K58% zyH9Aa*6*ysDwY4JDP+7?+JC^%U>1t;65DJf^T(1YS+LbbTs9Idd`0u4cC6EQ3MAzZ z-5*WfPc%5%klHQOf`;*nlf_j}o_i=^nxeLi96b~Q*o0w9x2RiG|H_}svKo0sC(A}~ zZqRZ%>7WIk3=vR&IHM?1gMKIhHInJ=qmD6;SwE?+mG0nabw&AxSL|{|b}q`?z{%2@ zL(48pDwl)x^1q{jZnR2W04aa*<#C9hUAS-)#YOk@gMta9Un-DX-}G>}3^eq@lQ}HW zv7rOqz1%82_I?nA!Rt5@tFlzm@DqmcN(ooTC~8mqqPv;Y|06+33P50wl~DeA=ZjyV{I=$We1esSpz%0^)2hyLm(zkXayqw94k)ZM$}iiO{fX z>^ay7u$;6PKj1y2Oo3}kFACxX>srjdjXon`4lzvj;XeB^7a@Our*mrcRku4E$hct7 z(`(S}T+Dpbomc?vXElZYoxJ7|VP71*<>SbL6noH@ChZ)s{(dv_0As!N3otDT?+h)~ zI9J~fP5~OGjXZlyK9{gXNg6vpY|rELk;_H19MAez)Kjp?R&=E z-dn~O=?qKu{T9YrNYT8EpgDioVyC()4tc1};*shEL46=1CUT8I2`krYS2OfzTOu^% zYOR~<1ztSF-KsPRN6#gewq$3}^X!2A)nAZ)G%BWo3vwabxQk;}VFC;k?~MishUKH8 zCmh_xNg8O3^68a2Bxq7VSJd(X#R$8CK2BQ8%X&I8kH$~RG-FCeoElT9o$acR!?W&tc zTRMVwMEoNZt6mUi<`4|;1}l0W8|-Mi$=w*m1i+$>>t-D#+|6C;!(6)D!NBur93#fP zXQ3EM$RL$9Fd#iZ2o^^oVwNwy?K{9KIsJ5wF3~hLpPeuk`?w8)e}Kkyx8k8sBAo2$ z!1#I7h03ZBc2(P4`_dGB;?@=v;xL?y%@}{6B%hzwu_Rw&CVQ2{%3zH8l0gd8#u~La z(nPy@GP?F$`@8wK6brhwtecxQEkSPc*h?+z)NAMoP_HD~W}jeQ@+=1ZEPsA1jnvc% zurPGLgdHRiEho^4MBC`9UI`?@xW71>Y$dtFJ-&Ok>iM~v$yk2f1 zaL@PT@_NyNg{Z&+qKhq@!~urlF5G$3piN2Ntdm>j%_}QGX8mGrG`>75-FNh5a_sKZ zT~bx9UZe1FZ-1xMH)_kC7VkHC$GfUqn@=#IzGl__3i4CZ98`aJLTCYEtAZFf?v@5G zed8vmHxu~=G3R0AZm{E?z^QCX3Lk4Nl6qXqIkp*BevlBe)XP-71mB%=+L=?t01LNF(P+Ww@BWwQpjE6xuwdU=F=fCJP-zD8I47tgmNryC z>wfD*0J!N6!p64*oc4%?RJ3R8?elZ`YpMGwW~c`<4$NTPuM#=EDkRCO=(e?t;N$!-^j3lnR z<3L*740o5>$n^%2#>ZvsN5(CW@9j!}AQ9uASqm$_=AI`Vx%rU&bla&Qs@uk` zf#jQ9N5X4VCVu>?`s#$R<>D4_U1b&~Yj=I1EQ13n7*uJ^)atbsTQug^4-m6oXLZx6-!59Sb9Z{vwa z_!idRFKHto%PA?3WFwJ1{xg`r?QtVU-YA}(2o?Q#MYIg!*xWK<>_tpLs)NZ$Kedtt)O`~eSOz(t2AM^V0!c9&J;ew1CB zTC2S!PuED#v5Sf?)qU7$8}RI-e1Xoa@u2L(1$-Z%h(`0n^f90f^%liapWK|xfst|w z*dvS6$IYolEfoLhJX>LYpwJcP3CKvukQBu0=I@TVPU3Bt#ai*0_8)!f5fA#)wBg1D z>Y1Adx-EEYxllp`MIT6#7`#;Mob;+?8%ijxYV{53!b?ylwOGNzui?5vNBUM z|M){^)m&Sp$Z2>w#$FCJx)aTRe6tteh@~7*VFjq@a;iA%hCiMzr9Zk3Ro`{-qxjNs zKvWcB)e}<_64DDY;??7!6yHBDmzQA)@nzp$<{Xzh`|3${bF9&376KB(@Ht$6Ce(yH z_OmB|R&+}Z-d}#kfvc!yY9^+of-16HKE1Q_&!vjmX30B&RPp=;o;jf9=!99GMfO98`!jg8*@`>13S)`+Xm?dG@^o+4q6RT}@TLR(T^X z(`dF^cE28%#<2SLq61CtAe{cw80U=?MCcGbPS!D~x*&gi3$Gyo%dw3)Q4*SOT5$k<4qQtc_&Itfcu#UfP}nB0UNxC* z(Q`pL`Spth^95EnfwHu?TtVY!j(kx)VTzsc9XgvKCSlMjKWaUxTc*x;Pbl!aBDqJ; z$cRI^11@cO(k@#r4FO*ojH-(xR454bt%!eHqGV0X*6>P5!NESTf)b{ z2-xX|@Q=jaA8D*Q3BgZ9{V;2g+=MuUm({@T<4+Et%%u2ny~+Mq-8Q#b|HUP_0X`;W zO^-PJ*(P z&2}ZmN^AIsF54kUN~rf02lud0aQ(MyBK~3f$Q-WAWu#?maZL%KM5$9z=g7UaaAUVa zx%+aVeYBqVyO9^$`%kk>M{hWK3aiMeH?|g{Ns8M3$KM&J#_W9 z)1bso5&_^d>Ce$eJ(1q%c%r-vKZ@Jjd!1ezsdTa10a^3ISlw-uaUAjL!|c6Tt%BTaf~3h#M*9!MAg z=XrcHlec%eMS^M^r2*=?k+cNhQ_O0|H}c2A<|XYyuN_yF^t)ERI%2M zEBg2C$4Dde6Tyi*XZCHz!DEKDpD0i`v1Zxc#7Ru|oXG2WACqhfMX6o;yQ}I7@x&rS9iOPrHqS5qU zKMKfwn!#|!g%#QFIX(R*s)bfo1y-5*I5D+CFqE*ovUAL$$==VbUFnd&I8sr5FUG~1 zj&77+q{6yE<%ejnyICNNOQj zvqdO7BJ#`+KpAy3`3SBTh%Q7@EUBl#l!fJ3!!>-yTs@ASX#T?zi+n7gm!C}+?aa2bQC?%`?cy{q;Nr z3zEQL8R|P@<$XTjh*f~0ju`Z|8mAU7~9#>SvUf1AVLl( zfd$1akt9B`>e)rQNKA<}_W%wr{^>uw4?aYg3*!`o$_-dT4@SB-4Lbh0ku|lmdWf;9 zh5#y#hBep$q4=-g1u_>%X!~zVpid&GX}apM5NsZrTM;Y zW}u1xT(=Qf4qYu+hiano3;i6q;+FM>{efK92q&qXoLWmanDWt_txJ z+S?9@;C}{#E0CCHzO==>f`0$S?>Jty|4Zj(=6ZH%6e3a==m81Axi;*Ce( z<32S>o}nxS2O{@IjRbwjb)#F_qiQKXn-x&psKT<`hv`8K&r}zk|$Ku4#s-YeI;sSo4+-b*pP+q?31Pm# zu#$+CUW-bU^wxO=w_KV7RZuDQeR%d5&6x>pD8`PkR`CeYI#>WUhtn7#2VqXBnDsp^ zo3tLtkmvDR6M)-qY-O;dLG_q!B1T-;2(c7dwFkA1-C!0(65 z_TChUqI!4SVzCLt$hZ8*oZ*D{H+J_zt8T#qbi9W*F($LZ!96$I>}{%qD#7ydXdmeA zns%srO~H-xTiIR7V^qNI_>NtbJIggc_r~jAVo;LP#KC%4+;|lxe{Un~b9h{qJCT;dYV$D(=!vf}Cw&mb(Xi4IRwt zN#Vu=$roowH)hj%pZjN!GW7Z8I(%^|nI%yB3E zB;{FQiz@Tx4SwHT^Hh?u77OrIH!f%P8{qz&ok?!>0RI@Ty!%7W$`dIZ3lx>uXER0J z$4grG+E+ng?@1dgf_W`ZsQ6Tf2MNT=_(r?Wh*4_qMAepJ>>VJendVtSq?k3UlQ{cX zcAG>O?@|`npyYj_&`RyZJ>3BS~;>OkrCJ^Fqc+ZA&S{LLAcvU#Q%thCsf(PL9>$Z4{I-3CC;h*NM z+ZY%84yB9MZEQQ)v2EM7ZQHhO+qP}nww)a(JG%MLIS==-tGd@icURZyIp;S9 zO(}o9%wm$ar3dRFA=p0K(UwmAm?|(3EECojcEDw+%<&$Pk-gAxyvCA1G9M?EMcp&n z&&0X;)%xjpnkw{f0BziRru=@hfrA;$miHs-v1t zGOGFtXB8{Wr;76aRVfGnlUFCDXy|06Wk4mC9RT>YrzP2c#JFnYLkf9#NXOfgR{ zR|Zg+f4^#)=i)8g6%AYkX>A`__lmzpBG#bj5e`IJsIGP2B8993*B@xs<7Q|*3WH0j z)LQBO?Mhh;Wv*Oxv<*&-hqh?1UC(9%Zs!BQU&#dJ5+L+7W6sJ7Hip2wF)*s<2-cQ=}$^Pmf7+vYrLgF@|)VQ2zzGVKMo zKj6p1uKv#u$+OB_*?1sxB;;RsK<<)RRZ?1f#RfVr+YEV-5q@N$#vE4B<2`~dtUb-v zhR2Eu39bq7z?t#{%$5u}Ue~~+z_{#G23U`jG!hb^`fjpdo#Q9bMq*d}=yiC@10+h4e{c&WWzgibM#M+ovr-JQ?qTgjORwki4y@I@8g;>ej9gj!f z>Bve@9Y=BYO0F}jDkChW=xI*VNPfa$!GvIt<$up&xotl@Z_>PK2iIL!daa2Z@2DMc zuf$xb8r@Vq2Y1b`j|*pV5fE&6TlIYEJrS8(C+O@?N1T#qw8BqsVr6m73Mhr4apsOix z4IXw%X%@Tt=W$zUL^r54*P`cx*BSbhqw6d!_wGPrMPOIG-pu+sFRQS-kv);MP_3DLx{3kQzU7n1Pb=q4`0>H^y(HOMxfLxMwc`YkawY~QIabyoA_Au3Rj)M zm|~Y!C6dmmfGRiR(31z^{%MFC{IN89IkG@$%q4a!Sgg{7a8Ro;EN&d>*WsQD+LWTb zx0auWdfHG2$3|N^2@mENq^UUk_VTk}HvpKl+B5|>2f5Cr8QFB~x+0oz_K%La9SICW zr~U_z7y^gl#ge`}qMuV2Td(3N7P<=RiFW%yd+f3;s+?^zKv~FW);|wR=rqKxz#L_+ zhI=)VZXWldE_3ca{;tjc+-MP3^>U+hdn4&2$3GVfjs4U#X})5L^2IPNms*QDhiS0x z<8(f_;XIDmOe?nw)2U#xp4`0^4&2UEx?`tXL*WJ3VL)Bg1PC}t+aVS*r>w5sl=$w^ zZrN^Z(cUZpbZ1N28<&tIpc%x?i}1Ud$s7lVsD*q7hNqfV&fp0(W`W+ zj=hEJUcGz6RMDo&QZhAHbo(bTcD9s2bqC*W$*70}D9D+y2E?)@|JoprK|`a_W7;CJ z+c~rrTlAB`mb1W0uw%*-Gej(bg}^_Hd!tcq;?s2WT>Pu5hE)vg7@!q^&-lW}+Uvp6 z8XrH4J%^26+II9v@rf^QCkNEq2u!?%N#k`6MLC|_K^}cWG7|ZP-9CiH-pls1DTvEU zV>|D#N1b(4gv38MS2129(zyG4&!@v+I%fZ38yAP`zj>hG31qe&NN~w9BKf%Ky=h4P9BW6>SBF$ zQJTOIbpBJwq%VN;V0w6XX4s*XPC0 zJD@QlSfZ?&vcsBxl5pa(yz@6(LUSN+0Yxo01?K!#o_y=0{}?8jnU^8WLo@Ei%%*~p z7%B*;a>x_yj9Be2Lu?S8Q^(GdRK(j%z4t6mch1$BGCwAGSL{xHpr{%q{l?Mx<0$w# zZ=RqZ_3>8QOqi$cu8{eTPiTlN`20H)kCk}Yry+=$7byUO#PyFmVgZ2 zM%j5};w_!XNMYtAgjW4cE61A_Bf&#BP8`Z*xdIZ<1QSZ!_;vj>?_O_qQk)3|bcSNukGfi1Sv zKY(>qFY6Wd0l0jfnlR4R9nO@hj)&PQ26x8fPVtURsXowy?b6-Kq73mji<;J@)hT2|}X|EzYE!LHb^Rd{4dWwU&Z>A;-LtRe8^?}zw z%yp#jec8x>h{ za%iMHx-;5FnjL5*^9!;AN7}=s23wdzH~m$_2!Izv>V+z@Cnkq6*@GIwKwd}ZSY@gU zN7_avyO$mO!$5HSfr{7fW+YJ_X+b_bdLNsj`7e_SFKIk6iOO&GjIz@t*hPc*gry6fT8Cv>J5ZDc2=+C!5%4Pj}Q%mm@X?0vwHRHXh{49|FgiR-75VXBKR$z zZvD0dKB&-o)xnH8dN%C?aFO!c3e6XU;(e-}vW5 z$TDjf)lG7LetM0zB@-t=R7sd^l{XZU)gL0}Z#y9*y zwSdLQUh?JW0{7I(bEplPF$G>|Cbv-8x~BrrY#qh2vyf=^p(!1<+q}@f-)=$KJPJ1n zdmmtzssnANNCQMo1_H2x15fRI0{=hb>iB(^@5pHX1`6?&@I>RuFsr?dqfMlh z;y(5^U?A1f@+6^j0wta=vxA?P*-Ot<3ANs1L1>_OSJUIB$BkqAEV_#%_>)5tx{AcC zL?X>nd1211k8*q#aa1H32F-cjWpVz%fJ`q1e5d!z9pBe?SzKD*pfmdg!s1wf-uLJG z7dSSSOx(%37Y8fuBmoCfISCKwx(Pp@AG3oD$4Ij2_z?{LsE^|^SrRYDZBi0%#><37 zUa-&``XFCAtO0Fs2EwS=UoVioF$27`!D+${*!hZ#)rDf7&;YPnA zRSpI2e=P=+wvt>4S+3FRa>u9lUrAczZ3#AN?3a&z<74WHGf|*4#g?%ns&beY70a^> zVk`&ivFw=)W5Ez{>{-YWk8N>zyMEvQ`Ar?UO-#qbPW^t~E~e@p=kj>_i~Tu?4a%CT zo7yEGq&sE!*CbZRJXq_RI*X%d-=WMg`dnHn6cjLh@bwa_GryHl7L@uM3TB8pq8CTF zC)ke}C8a1yZ7)v}(H^}!s3~S)Pu`S7raT0SLKwy^W|BsV7{r@Eb=cLXpxi}sFPT}w z(r0uuif0nGwCe%-{5}GGJ#gUAP#^P)`g4&W;+SCc6bKY6>=H&K55hzYN zp<@O9hyuhRa3hbE_?RY?bi1vLJ|I^mVDoRrqwltD%r$;g{hIYlqL&A1Zrf_v4Q zO#VtvS-_^so@H_+y^IiFDWX;-tQEf}3wD9r+G}SiKmSo9On_$Qn%fl1s5NIeYmf}zdHr|6L~(svYM=8F#%dRo z$zoWQ35`?hdfje>o`5=i3J!6OsN>TD3)B52%}*qwM)#RvsJmj^$Zt9CIyT!INcLc4pecsU-y+ zg6U9|fHpel3}r+xcQsPE`Ywjaz&9^qGFN5ffW?U(c5P2)eaAy6Zv{Lqod)%JmVoiH z2}xN`HD)~)zUl>PU4#B00&F0(2>(Lb?&Jc(L#MK<|Gb%*v1BiSc-kj`nAii@;Pw1E zV04xGj30SqH^eYG0r(U|b31-EBvPHZw;R4`mkt%{RCqN7kJ7Hbh6iwo z9&KX#BG`gDbU}li@S=QO@=C$H<(LF7R@dUikN;+z?jQw}=t$%r3Aj+Qb zw;I3)WZ`raJtJ9|E!eVJE0KvjsTwcC2Dg6^df0UlsWBu|;Us#Ar)fR_^p4?60t`jg z=)uzo355vS5sZb8EtHOz$kJj4k5JnT78O(wN)>J9u zKwui}PK{6g^NOa3=L~J~lPR7W$mbm-91>KhV(0sqQL6@jf5-ya3Y5jSctkZrQ$g?u zSI46$KmX77)XIVQIAB-Z&j#T{6kNYrse`0=jQVSC#>=dEY{v;qjiBQ@M z*;#kjIemtHw{@Zy75`0E(bfO9SYrv3&qM>4sy`tsZL38QaCoAGHv?Zo4{_H4ur3yE z+qV+nS}-@6_js`wZsab*G8!lkQw!`;6nwQJ3u%(kEF4E39{eA#C}npF3e^Etv9Z96 z1kS`x>u@hUZ5aXmhPCdw)}`tgM|%X?XR$VJv++F*VQfus0Lh~_@YXJ61>`biINfN?omSt1*=)kJai*G`Svuse0!!r+VQ2UAEz8ba2_7_O$23tu@>TQ~^hB+_`5G zxjRCc?$SKI#MUss5;0l1%Qh$YJLT9i0i9N+a0pL6rk$klMe+&&)Dn zuIhUti9Jq$|M7~3RdHae>f$`c#Ls!=~-^#6H9pB;60%_!*2-R@2m zmd4}(Q2 zxR~r0ZLN&Pi7uxBO$h+^iMi!AdVc?iHYtJ+t|Z(Go*+k6mFG%44Aua7xWHS_dMM{0 zQxzGtS)39p2J*5@ua;5|eq82R(9*6 zpFzsd0##r87@fbx?Qg^JpITJlS1lUz5og`&^{W=8=rV_v&UM-rdY#`456vXjIgo}l2BS`z&KHzXjCquX zS<}tM3>U$yN07dyXr8+m-`x( z<++a}Tqk6a_YzGJ>H)h847>DccTP+NO8~Fi{*s*VIU`^yY92Us0A^uhC`V(}vy_R; zRb3=j-+S0qCMejsXdb|cRZl^23GfOH7gVTqd5?*w0xsGNg=K?*9Xkp+to4zarb8oQ z6XxzL5=8%y2H^)**K^5)xH03e^(Enn)BigwqkY4A&$({GQ)hCmgDeFeCAB0){7|nc zlqB@$%ceEgD5LZXtl%alA>s4!l*4_v&L0di4n=Q(v_^v{n@z$NLNsYZL2oKcycX63 zz%HTYB3tqQgc2j%K4o#;J@HYreIPbzHZ0FY11^eJ+y4UCF+LL}N1 zYiXnSzyWIqqYGzI3z=~ryC|TsCtUp%!v_Ky!a-xZQw4~U?Vt<^p`aKl`j0hhub96S zLQ69>U0JdZ*Q#_?rsye}bbmWwxG2mw(3?QZcg?Rk@q&S%xoOY0 z-KGuRW^(5`O``Ca@={fljbByXH#}w)+ep-Z;L9NE)X#=-QqEBH;Z)E~VI z(|_iSg_8!of-=dfF#}+Kl%0wT#4-g{h)7U!th|?|kHRecF|4MwA-5~FAwI*k_1h{g zZ>e{iEK%4Bt)8XbtTpCF3*NN$N4yjbJvsq@$L>+rT125pa+-x(4dq_*t`W6WiL+pJ zU{Hd=KnunhBL~uxNE8DJ(NMxi@_X<4WK-9+H&>afo;Lqvp2GW3`{SuQKpETG5x|S> zzrUACu1@q3=^9gWd;luf$$5TJg15zM;>7p)bW`t*cZ$C}TN0d1Bj3uQ?r5}Dg0jXu zgTb87GGyt(yNN3-Y$0Lv<$DTn{@7`6o_O(ya1AgxTXtAChaN|x zp-4%S}r{7KtAPyVb?Xhzj}S_r5{|y#-*)krs*O{dW}I6aq;t8_!wwSIV9LGIjpr zEC#s*GH}B=>5Ss2y#Ng_o;7(i3g9d^jn^AopUjVs4URJZIwMF2QoPmSqPP3t;9;=4 zwDBy4RPOVL#V@DS=MW9%h4AGiQAjKWV$OBa*Va-93{{j6?BmxOaoNxz+v_8s$=J6c z2OLQ?gOOPYv)u+2h)uSAQ{M)i1&tsQ*sKA~x`&}L(i4=yggt5-G;Hsb3XN!=I-X=5 z%`9dFB4uU4T87VTrd~a8g1k!5!Nd1PCx3*l+P~@XS2gc_o$6h4Z>ZnbwhT{= zlHA4rszq;0f7PN`&NXYqziLqvorI(RQ;TZ9tNJv>XfGj%c?SuDwS+c$70Ce$q%OA8 zJ6nk9(;eUI|BqW#lV!I70JzNAfh4F>{Fz|0ceMWlx+k~M_q(6>f83&)Z#hvU6TvNd-24CM7TtcQYtws??)%SJQ==wj zw59BHr3Qy%o!B{Hp((zQ(@Z)9X>RM4k%myis zL+oJ65od?X=$aF%56>m1izE$&!QGKbsUHau{4x(=3?q*$|c zhP}e2USb#=h84@TLm&zcpP}^6f@q?cP7EMN!3->?T)U2G=K|3{8l9UxXFee2R1PS%kzn2eH z0<%zoeE6;K7vCHcetQ}l?yJlKDDV?FzktY8tZ^J}ePNQQtVm>aE^9kU$&|^n*`u67 z!XulSv@~%Zc7VOx7slt;`H4e7)*F3uFj#K4OG5v3rj16G^ABYh2rr6r4u?e2#Cgot zne(xxuhOPMzuMMz0jHRv!b-(`Uc^FYJA^bEK*JESUY$Ch)-c03BpN3RKK^EIF6KLc z5}f=P__I>EB5+m@6iixFa}+-cqe0l8twmHS1?4IhFpqbYKGHxxf==ud zJP82^8PBmAoZ}mVsOFS|ah6~#&(_U~0thcfM8$CQ_=K{ZA!9zMdhBl3xD8lG*CGYA zO8<$V+XjXJeJ_1U@BUPQ3UG>yhH6^nJQE8?`B{;iBo{+;8J#syhc&2t4xgK~BYUG9>s zud0E&RLBJZB?4%wd`eAy;BRS%-Mk}l*;GEnmwYAX9zZgL5S;odDbywAFHIZam^*+h zI88Kl9q3Z)53_zw-jD{woahW|`%bNmxq1U_itB#95o|6r^TExQ==VF2Y+HGoS5ep- zLu-WH;OfN4qm*zMCFIX7f%V2Z-{gr|HGh&Cr$~R+{=Q#=+Q}87x@l(N{3sG=oBi>s zb?5f${#tuiRQQFtUUeGNnQh$D^!e2YS|ai=#c7w`lT2>9l%PI*3oIM^O_GrCZ9&hM z!kg`84n`)8j_=pQzkmOr_+BFP2WQKh3R8o{;p63m(VSOGeyH<9khfaYGG0ap9EWf3 zYVp6O^ zNfKf-*vyia5GxzrNal3vhPVaS%uP{!cXI*Ew1>nzUwIsGFpP|baE!e8WhL!^O8^j7RU(`b2I(cJ??mk!VFkbOhff()?9ZSd0a-N)?t12Ubd4nzJg$Gd1FQAXWV(ev`t0yNjv5p zIKY@}ceTa05DcgVi@f?d!uF<*E$Vy9`MrMD?GV3nf$KjUy~Y~Y$S!OPKC*^^N@!!I zAZaWaa929X`ZxvLpYNqF++}g^;W6mDNwK#N z?=Plg@HR13w(A_pciDHVLSQ$n5M+wHaBT(Gqc$g{wf@^Ym7_2{F#4YbiY39 z)ov*_%N!M}f}&(LZmPa0cssPvMQbfIpz3Ttz+nk~jyppC1J~caTzrqz5I@E!g-wzp z;)T3&W$T#?ZUoMf&3 zW0v%ky@6C}_mtWL<=ep|?l6auX=}Zd))KLW`;5Zt+)D@<1-JyFPe5@fN*A2kg9$$f zxH8-2KmZ$NG7EWYH5tBevX5FxxI!UjSY8F3%5s7--gTiZw+Y3=5D2cKP?FGA@a3*U zADJa|IK)yifT@o$c&1==I;HS|3+VtxMhw>b`Buq7dc79 z^>K8QvP@qo#R%7+v6MJH%%zs4GspnF-w|QrUKwv8SRyG?3Cr74+EIK`Qj(I10P4&n zP>pEy2T3PKR`AAd!|du|T3(KD5r+pZ*4&94YeVf7P?7fwk&2NK)g-kh3i?%`7IHw6 zl=Uj5sK|#XghIz8uiy6q#UG!Atx1@OqAy>)j#!U~q=8rgnVg2#gY@Hiq7^$cYl)*0 zLj$E5RhpIW7{wR}zy_Jl&DJ0DH#1K9E$xY?fCeMNW=+8kWZTwVH~=sW5YR5_BG93nUhn`%$l2-`fwgpJPN`ZT8`%O z&ZMQm9^tM{WSDR+zQz-yJD&U4CJCEuCd_dV?^0yx?pbQX<|A7(c$MLSjMC~i`Kg|W z+$d)hC^;;WC5s*KQ6z2rZFnr{$FMN?sY;8twKEk*8*q<`@;|)iGO$=)~ zt!O#{0{FPV8?~l@xC8EJDmZP8!}`9~t(%vkSEgFHo#rNYvh{E>z1rs(W6x~|WzEVT zN*W3#a3?k%{rlXDf>*asOSWFP&`OFBHgp5L2B-E9aZFntC7p`tU~c*HNn2s{{4;j; zCrho>c9sFf&tg}0FK2sUnzAB^yX~E+$>ps-vZ`1nwwhDQLbiSxZHlp_N90TpnzY2# zFL6FlVx@LtI~mW-L(V~dZu6m<(6fGE)K@xHPoi26)x&(&A})rf${Y$>UjLz3C*`@d z&gP^%fKo!`1YV8xuBc&llL?nYilKP3*`*N#00(cyXpjgQ$+wYaNypacqlWUT)!<#_ z{nogJD%D06&3L8qw}-LJotur3R3klXb#HqPU#+>i!AX_)xk*aFAdc=JBX{S%-Gjif zpI)qx(wvo{k;q030d+zOwCnC@v!w$|lE|!UEP~aNRh^N5*YZaZ7b-p1eXK1Bb)z#E zlRXrjK+s%Y(mSJPa_Bm?hM{}G9Oxh^gJOIdc%pQRpSXxx{Mpm7IyV@B@L4OTg&wBB zDQ*mo$`^XTFmMaCJ#H*o4NkyGy*$#gV=rG=P7;3LZY(y19ZEOs9XkF?v(oA0X&Epy z4S}v(EUVZf#K}M+99h*3i$bu^vzN!*v{c)>Vd~|BAn*;2V4StgRM1Zj=d9hQ+`4Qo zcZ%cQaseITGkKdM&+5EF2!W0u&^<2r%H3?J5Md}lHS(}5{uMwhbVmdg+bTHoJ`4rw z6Q2CV`Wq;8%~gvsl7-KWebOqtSYG!crjdNOu`G+wV`dQN4mWY{E`qQ#?2w@E%A6-V zHy&4;+vj*(JI#da%$gsbiPS`dl$aX=GW3Ik4&A9pF4tE{i^`eX;~(GT4O(=)VD8tt zOrxt*VvD>(zi=S0N2fTzj#Ph^BhL&RnN9^!Zb!1hxmkX{k!j@`anzkd#XFmm*?%6k z1Q48)anRS=7uS;-XONFcK-XgzsKv(BgR6+=@K3b2H>L@!^h4B4)|3< z=2|E}xOKKNJDIlBqUd>AexlSQ> zZi=JsScj}?y;CSFhCu+D{^=aduzF5y;wDl2X)1quey&+H(*>P-jKTdY1ho0s$5oFc z2J)ueU`9Z%qr5@|FliXU0#(FX@L}k0uBp?<0 zcx4V+W?SZ*OzVt+_kEECbV}Xq_MJL4NG^c=9FGR+JJxXx(1AaE=Y_&vXxjlx^yXnor6L zNMg`WPmI~0pHz!x#3MPItuJxh_=qG6uvaE{P@Pq{uqZXwf+RFR)C(|vgaz0I+~T*w z%;^O+=`UhCYnE$;vMi-iDcwY*nkeM$g%ITRAYjhUqRVZj)js$`Rt^V}t5l4%W*XRECfOh-KF-(Pcf3T6O;nuzUfQFL*rNU7%lGHfBpIUeK_8rw^YFxi3UuDTU}g(129-wqny)l)1fSp#UrYLYtl zB_>;+NuKErGNF=03~L-#Z)T5aQP5;KX;FZE=8iULtX;r^jy46**qI`e>4Fb=(jZVy zJUk-tyklH1a&tVNZ!&zvF}5xf1It^L*_(49;O9{O z?wBH4@W?%H3IM{v^Yo)5;Y&(OFG(;dGCcpl}?xWt=U|y&ew3X#&TfPR{JpG zn3aT9e6^wAm+NNz3 zuPeokJ^%!A%2mV67Uu}Xv23AD+Ei!9{=itJ7*)=pl5*OD&p%4Xq2o&s!8x=Oyv&ez8Pv>l{|d z#FGu^=>&@bh5(zZ)0wo}l3SK9Pz{VD7w{t00TJbUed(KYvicWwo0T>r3(uE6y|T`) zB(WTxInI*cE;wS+Aw=kMDxJP`$lMNSbZ6oQD!|svSmIR=m5>@k`{-jb+Eqw|ggFk^ z^gFa8Pj+1J2b7QK$^Qf}LF=1$Q~sx&If zS2E2rEi$EZ2S`NbNc{pps#2i=`i7A`u7MPOx4&bJx&JLUAUb0aopi@Yd5?~6hC!i0 zLB4`{j(LHJC7WuJnAx4D5RviUbyW5+z*VsSUuKkMV(pg~u-?TL5JB-Ee^gO-71)Y% zQ1jkBG`ogSNKDei&e2ER0#QuOKkIb2ybE+yTEFaC;}f zG{5Jv08IY;&$*f?@J^}1OKpgJJ5m#t?S1^SWXrqo3ASj+Q3Ji)92F(#gI_?@HOGLsjRlJw_aWLV9=YuFs4Q+NN8o@WvUY=40!p?5x!dOh;Z3b$3B+093Ae*wya zTdIeDRc|u=T}h?#=4}#Ox29u#k6*2?RG}!RDH7+1u5E@Mh!;*;q2y7n&8{tyD`f;| zQP_XVpew|Q2#8!Gg+P?EXr*Mfl;vZ%=Mei;9#Gt%p6Gu>@NnbwpARTiCx~-C&YZ2t zmZ;A)B8+mhTX1NWW&4n&_y%D)vL}PY;Dx-&XE*VByD(V4ccOYSAfYO@P@%X|zJPzj z>TXk=+1)G-uww37-~B!2V!{*|SmrDG_a@6sOb$qN&t0XzavsDZKw!PzpJWj;xXNwm z`rn)GqA>9vjiBcdbtyYK5`lwA_BRX!E)NHXF%fAL&!A8o>{n;jom@E+ax$Z3+95ks zDNJ$uXnYL>3*&fEmPPNvTHD#?xCm)DwX7FRlYb_eYdn|^gpx`D&mZfre_QOz!uc$upF>U_PqrQ9EYN*>D?Y+1Pm>f>KXrbA<$Qrh^wDKp1!SQ zvoROlD*dc)h~ch~@;7&sMRMY6xBl1Ht#1o*sPFcyDiSv2@y!eHb5FBlT2d3MsQV$K zME&%buWGbAL+a=g8&^ao`oVyPakFyB;o@<9;1P1Qnoye%Ryxe9BavpS(XJ$HE4?k^ zH)flnEcH7mj?jCi2E*%5gEUld37D)}E=*aeOxeOFSrWrD3g)$@W9J|Fu*b!8)sh1c zCK`F1GsecW$9S(ER6zdY< z64lBDbr})XDR49H4e+NhoD`sFa*~Z-V+D8?E6L7M`o4i>)#X?|e`<0`qhTSVD*ENF zooNH7lOuiA#c5nwr%uH+t$zu|f2zLR(ecHUqVKf$08g!d<(bk0EJssmUV&_G3HM$= zA_bfNV8g4A=v#X2kIC$sPXP{BF@#@uoo5 z!s|t~Trys;yUQ!wC<1>rd#Bu?c zFA4Rh?IUxt)P_ZwcnSh;;L4bLJ<5y?P)+j@01J=bJh})k?JSMVexaF#wR`RzuO^cc znDx$E<9Y`98*kTob~d>I8y)PAY0?^R>OiPLmr-P-6S;~Sm?S&3ltG8K;FE`oE3N~V zMzSjB*w_>y@0&|}KRCOr`TfqQWv+py3)~t!yC3ip!F;vfi$}!5$~_A9D8LT9R4vpO}Hzjf1a$x96(&6>wp! zsYJ(0Crqpnv8%HYq2HJ98TcCe`t6Yn&^$!BQ(em&l@ZA6MxuSWJ`sY5^N(!*UXB_( ztr?usgVbNmxx=~ZzuzQ%9t~nSHj*S{w8YdSHy0y`wb^kaktIvci37*)BiRYd`CV1O6f zx`5pQYcRHKw?tod^c)6(P*cQ{8(`5wfNT($M_bohAz9&G24n&dITF>Cuv3|wvq`^S zdCsO&BC)CXzw}|vX1{oyh&<1+3|K4ohM+v(&*Wbj^H4?#E7qX>ls^l|mdwo9AbOZe zg~sg<6&N|kvE$b#SFuA5k>OWiJ>4pF;boE@N_RRG9^qbj)+B8`8`5|dV8lDlaE5zW zA4_dXqO{zx$(GiT>oMSVo(hx4lr#TEpex@A(^aLl(5}En{V~y2wq|*6BvIOtHE>^a>DsH)ShLYIR9enk%8SdmLKHm6eH1_Y>`WNtmsdJso zO7joklwXP-N^+&O@z|udX2w<>y<}4kSdwgdwqQO{-gATEw?If2QlX-?M;kw$7qnc; z4~4kGjD?xu8=vpF9xf_1PBF~9Z4NhxnIAMVk0IlXNm%Gs$rdihdwwP9DZl^q`Qg;> z@1~r~`$g-0aj~JRB18o3A(d}DJTsq4OnGb^O5x27Y=wa202+te;PUqViip5_N0ZQt`_k-aM3xle{=tYEqA zNQ{E&WPJ*nyKpb__aiS0f(G5p0y_;a0KAE*`b+|de$h%Zq>Fp}HYBb7YD zrNPp)a}l>Kp8zhu@&rG?E0J?e=3?&NXfirxqC2^3oTX) zyIUKAqUocdE1@x-JJf9GW@J^Q#=m_WGCWGUlj15t{qK)t?N1!Y54UM)zFIM0JVR@Q zr21qEJF zJo;_x;imj7&2K_0G@a<6xnO~;wEdR~@?Mh~)K#$fhYCIrHrSjvqJIspvDvbi_(U%l z%G5`dC16&eTMQu8ccim=ZQC@KQ_qPoRc)85cs?d7Oi_tAy|t~pFcNYw)HdKNS<;gp z^Gv!}x}q1uT5R98CXFg2D39@U%n>c*j2t(jRE>(K={6Nr$WM-OxCPN=CU@p_r!0}) z!O&w2sgzOwU=j02IvTpmm;7bSDMlv%FyBzExG}%G#TTvyg(C=BzsJWoH!lHzXgPeY zVrx*(->wzu3VzAsUAv>ez~~s00_*1y2{QaDXhf`Te>#mejJHa~CZI)tqk=FAor1&W z+s(IW&|fP>gWXT2$Lkc0u-r9}IhhS}K^d@+$CPH%U%Nd4>moEvDO_?#vA+JJcAK;% z2JyPneo@&CPPfX^xpr-Nqb;eztF?S1N)x{3WG%(!LZJq}XwtMlc`c$b8Oy2s;(pJr z?B0eGm^<6%x1s~$z7ut$JMUX{N&*+cXjD}&6R630$Y5i<=sF6?50$I@CjyFWmv45C zudbLmM0*|b*d|H{Db}wM$R-$*c{V6Ka{yU)7>GmC3H!BOS>ECSleV+ALJAiGz3mbB z&#Xv@Qg%hlwowF!DrooCgK+!LbLGyWKUTWJ6dBur@~+fQh3XXbRmqW+|8qk%WyAQkUCIUA49&=yW4 zZz83TM2~6pzGY3Lfsur~2t%*&MFLj2?&Wf1u3aP0iXZpsy zwHo?LJd5~Ce-kff9V0U`p~$=aaAc_tyVy@I+kNiu2NnW?L}|`D(7i|xh$5Hja4rWS zbVjc3L(bgt7nizLj0R@#M~`iZ0(J@_2)|DL;&abq8#KktkeCpg(cv7&-rE!K-V#kV zCygiI)YbDmaKdz|)SSx-;-YNd%_iNp2npgk#+HRgNmfzgyHf4`8|jp5a5IE86jUnb zDVqZTmfJY_jcgY!Rv{9)5wzYf)`c6Wq)fR}QET|~5;CI5>rX;Y2wtBDS)(}Vgs>*i zkw{gQM)S8UEFzk#;Sgd-0#5ucIVkbjc5W!#c=Ewvmv zy`JxukbE~?p<7_ecz+2BX#@IQl+(!NZ+$>PfyjU)#Fw%lOX~c%CW2a>`x=BGamAPx zZcHck6F-EcjT=riqAAe+A6@SlWNXl^*_LhFwr$(CZQIyo+umi{wr$(yuIl>EIUU_M z;`Z;gVnyT|8TrnY^O<9O?Z352SFxsD3I;Y@3cX-&#_NJm0%iNoPYgO%43*y8tC|nn z)AiiVW25vmC@zdj3D9$Km_c+)^U9|lwc>TCneyv(d1NSpEUE<#CUyBXkCXQr%YUGU z)DJY)hX!WCKFqdBCALP0f)Iky7*C*zbCa|21BhDe?SRV1=jKRI(7eBd?e;S;V)T0v zn-k^=ykvO`7sQty+;;W(jkmLU>bX%@s!%JFbmB5z%eHp;8PB~xtw;ep!HM@D{Cxyv z(8hrg7)OYh#rdufl^0||@$+LEyjxFFPaC7;# z5b=m=N=Q{B>zIfNToGmPH|pzuk$cM5fxw@#s3+5Z`HXW&qLr%UqZ#c^a?BpUP9&8s zNUHN^NrFEo1?a%a8hDVSX#y2iv>g4=y<0HHdOo4T{@utsD;O{P!eCGlgEqZ2`T|N; z@v-h)8jJ8~i;?ee!Qj*gnH?YcH_*E0C`d9sUQq8XPgwJANo7>}H6jPFSB6z6B7{P7 z=$lO^0cbQBg|aUQhL8N1bT&_OsLsNLEq!(hzVT|b^Yd3+0rL9oE=?*u(d4-o1xW60 z4tLAQhjcIe7Fiz~gH7&;4nv6Tj$LU~a_V0rvN5!EVR2#}M`K_8;hel_w)>0>!AfB?~7BugeCedudNQp8$yoArT}P0Ij#tzt@|C zU;xrdSLgb^?N<1x)+l&>M$oTy3NzuF3+Dn#@DrRDH+zsG{1MFd}8U*y<2bWZ>s?+V6DXV!WZc#)dp5Y&IjL_Q@1{>YS zqG3f9hxZg+mWGS_D1LV(%oso{a+Rv(r|zz`CtJ%98}XB_%8Yf1WtqKGP=M(_cG1rj zu-}v>XJZa{;YM*?toDahQSlI}TTf7BLwPe;C(iLX^TTRZiw9hWU@RcS1V8^wiH@oOnG zrqEQmhS(y0akNw&QX~3__tZLrKz4RE%eu2~K*TZZA2$w@pnpT?%6Xy;S)OxK`K5>z zxEYW)mE+5Zpa3sNu;K%kdUDIwrbHVl-D+7h^=FNS%x8E zWKl42$vfo6$J%fV9JM-|BS;-{NgVEqg0->Pws*U#1)6|{{{njZuDCawELRP3XtQkr z15$f0KCgvE+SmQXP;Zcn6NO65Q#@zN{MR8Q5ZJAEY)1VQUj;4U5_18f=p!j+RoVuB z2{HOU1S&E|cyZ=mj$e&M{pP7bCZ+@yLz}xeiI}RYY+!A3UCx`_e%mm&AuHTbL%>ZX zil$MB=OOaQ#1EMJl$v@R`y*wqC{{QeY0S6JHNm^-Bx3eTowMhG74pYolG%E2>gv`+ zgGqxI!TK81S459`VXskt-m*m4ysgXWl7C{mxl;W85fi?R#ngN#dz+vDZ%;1)IUwop zT;Vq8sW( zZF~YpMJ>$lL)q$5@Geg)`33ds+%+=IgA{g!{J6ZeG)Ez8bC z502TOX`5mL0y{jPnjC)MT&H7*i&4#{cp0i>9? zXro0`D(z+%dZcVkYVk52?)p!Ww=x=0N%C>-Q4FmAHIA4jKs^Uw13M zXo{RS#aAmY)&L@1)4Z4pYaGN$6wT%0Uc<^yY`+$_&X$pxC90ohoHhH~f#4Us5LAP+k9P9dtjW*ea4J(H%is+Q;>}Geo!bRLs zo~9!bH3$@igkN}4b38igfZ||uJQZ!SoB2PBnj#(B(QYwKPP``T;)ctjrd7Yx5;nC8 zmTCR@r3M1__T~-DukAL+x_mdsxKu+HBViKrk3V?tVN&OIH zNuQAUNpuLk$w0VT*n;7un#%c@oeD_0^$DV(#Rnke zKi+ZjyxAz{bCO5f?xWs5?k~V8bFC`3AzOo_5^nqs<71k+=(O}v`4j%-jV_&D3}=F@ ztp}TPEy`U9HO(5Y6!2r2*CgA_5pDB-vUwcKR%vh3eTm@Nc7}Vo(=+f%R-0_ri5kP2 zd6Oz2E+pMLE~c#suPs6!AQGC4=!2ul`c#BTD{C`qGS?r6Xa11MbM2w3r+C!0%hfff zdA(Io2s~*W$0&3RiWtJ4Kxhe&cEqZ_NccHz!NDQ2`o?JL z$<5@EpYA#UVl$K*p##Y5)>*lNHHo;IWsFowG4YPgltLqXv__OoP0)g~-5iprQlo6P z!9&Has8q*wNwJ+nyf6ZjR&bXFldCJJ6!%+tOhUEd znIN6&@~2CMYLf0Ox*d$g3SkwzNFjO4GLg&KM$$oR5syhZJ45E$I2MiU1Wlmfs2YYv zEYBRE1iRIKo@9%l1M=~>kG^dYaz%0E-3nbV%%a}j1Vv6+@vdO-h$^sdv zvNTmXYMz5-XfahgVpG(c$8gBhdw-}f^_}GBwe2O3bX=#5;u_o3N9Y}}h%0-#JmhsY`#70Sz(*G45R#dX1`*U`eJfOYZs9tIra?I~tZ=GhG~DHFgYr z=Fs~*@MHwVY*H!5+Ha9(#SV@5>Lg=MF>%bGg>N$)32;|$@ulbgY!JLsqjm;k+dVmM zRG1D=L%m$SLSN4`IfG{&_JZw-tC62q5v-OKe6KF7seX!eXkA6=G$TgSxY(TE`Acza zs+f#W8lSx^CmyMF6c;mR#xb2Z>HGtHa6k^)#|>5ftt`pE1TBJDnbn>A^z^L$;}YC4 z(Kmy)Gv`n@e^5DrPqMFrSRp4nF19i`K}}9QBPBaVPx+6&CIC>V_SXr*s-hrRK*7p5 zECpByIJ6Qt8PGgf+=mmQ|(1`A1mZ!BzSKk zhW5`Z9*#F2V@{d?>O{ScLjqL+N2Gr!iWwS{8C}D}*T>*uQ~&0YCuVxGA7# z;DNu|pihD)Aq!#p$CLA^=IAU@%~oc)o`F&}&Rk*F2BuCP=jzgDBYiiq)L-Lg;&=g0 zOBF%b&JiRI(v@gA!V6R^f!J>hbA6f2+8N9G4s=)nt5@!t%K-dzBej(!jX(-OjQjbqj%l?ACmnUTnCFau}V)Z^6+@9&zcX79+ zp>0kvGO>hIN>PJRw!SDiTYbgyrh|niiM64Naa>J27W1JNn5A8m69ponesVHKO`m&h z$akaMj`@{KuihQ^;8Yat%yR7~`$y#u7xaI_qY;O>Qzrr2+z6aM%bOf&@7JzE*?* zx_%OY5`p5`Im2~QC(EtYO8l)V)h&ZbO}We*g8qjJYi{X6YhpxaYXYF0;jmw=sIGL} z12)yddP(&dRHvQbP*~K2bKk4;>vB`+|AlnGbbnI+d6@%|xZZ@L^}>j(nWW=(>4Osu zq+r9Pt|t{PyZ{sa@h!fhu$+hM#7Gs1yyfM)z_F_)v<=c~O*hpqh?dq2d@=ZiciQAP z!UbZP3JBuLNN!+hBL8g|%H_HBhC8A$rk-lWuJIUf+NbcgVfwHT+= zv&F(v=$Yf*w2bpi{pZovwF=T-l(#41g4aao5@x^kNdHt#g=mvwrPDHjytESd;H^xS zpL@&0k6y^P;ut(05Q34he0l0-q8)y0CGybabM-K)n%jk zv4%wIJD648c>^jy0r341s{W@F0T9@W3REW@Z$1Wuqh8N6M0Pf#?7Kq@|WT* zrVYa_=iYRph&3rl4$KXTJHx+6z=qKKMII46PGXvn%}hD%Gr-Qa-krR>7yk5pkXP5G4RmT_|o~3P4opF9|(}C>*TjlS*^Yq`+FbYyQ&U@ zlYa?nGcI>UBD(=F+ya;wj`j!o$*_J*3CWZ>RV1x={#HNHvDfnY%+(vM0y@wIScpFl9t4qhttot9HJqsCTQvSS3k>_V&>}(avigFO~6vn3Ch0FOQgH`Q57;>GJ@A?40R{hy z|5RVF#h`~*a$x#Ee?b&S;q?+(fn+!Pp|kvm47|Pju5qD%Kdz+E+K&pEWpr?l*HAuI zAteVXdz-B2z0(9-f|N{SYzW$^ktoZ)Ug1cKpp))CeGF(B*D*edg4mG@CIX<}7qTN) ziPCEIx9bXEf8z|)+3^%qy>tjr=E<8jOM177jeGYI`65_GfP=hf+Y=HtjdAUG&=o&aF$m$qSAmkhXl6+xKZXewh6!`T6`YF! zR?}5{q*?iUuT(o)l+t!M1j@i|f0!P{KgA1Yd8L0i|E`z;-&tJ#&*f|BDxxsYlrqj$ z3uCB#)ogOa*_1)KiBmyaIeoVv(&G$uy(4)KUk0cLpf)Vk5;-PKUZ1z|Xt=t`Q3eHnQF+hb8N`o7nCMFS32c?&%D zd6__M!R6SF7>A!t-`u${u$a@FvF^!Qw3B}B;QY;cZ@;CUU10`vJ(~WL>W(kFssY_M2npHtmm$1JG6O6v2ToiVHSocW1j4%@3MF6rCr&7HEg ztmdCRT|AX21OAZEx@M{Xz49il6EGB<>*HDXkJ4SM;5&CH-7D&v^M;n^*L(4 zC5qT@n1>pSZB8P9lqmcOp$IT~O(GHxN<`EP0mefzcBomBuD&yw2Ib#t&pN57mf9r| z`Q+q!2D|;v)D@}ke6C%JdWKUriGT7&f*sFh%tQv1Tl+F5_XFu7TB)eLRL)^g7vX74 zOrFfkSi3vRBvn#7^+PJAzmxLn#$mXXgP`qpc5)G~ddgRGR|573&+-HxVQhg?d*Zea zrA0beEtH~ARZxR)z@gN0?v$9HwRDDEGH;*0^}6F>%4%r>M9^0Ryfl#``awjkmVx>Q zrH_nz#YMWqv=vDwJtn?mL|@pJy~;G8f72qN1%T8@BKJ~8xeMMDz$aMwePhKYR8Jo= zFAj_Pa4<<))`+V^%LsgJmYgX=hyHFbUO0Tm`a&vp3se)(pBK_<$GSRQVCoI+!5zr8F%Gc9`)Fim|q`$>{juJ@H(o`^2r$i*3 zwS0nn&7Hr?A66B~@)D1tb{L=LpMao;yMlOp%pGxD;JP8*2^{ytF(SeZipNrolNlS7 zxpRjD2w#flfCLx_zo68T&J@DVY|iM)wF78?RDxTMFA?-qmBNM3B<+e%hUXY^>Z;KSnN%@8M`(1WkWpA%@kafMr{O7&_$Rw(i(!q&X>Vm)5LKPGlg#MVgpg>4O zfPh?(fg-jsBTo6pKftm{pz~7k(v1{YCrs!~ww-lp=6A}1-o(n1(8MVyB>eipvS$mvIt*1xxiG6i3{DyK5#iR8t9E}=b~&9j2VeIYskg3 zN9)vGV#_3Lsjk0n9kZt7K3eVbW+g~a%5KG~06{|`q6x&O?ADD>9bt(yL1SKWcwjkK zq~d*qCFKpDSh+&?rH>;_w?R3GOzM5g*&XUqJTt}Y46001tlWRi|jsrlSS=c;Nuh{O=+>8Wno?MC&AXG_N!wbK1kQZ(Tw zH$%Y#s%Xh0*xu^A1#gqHm4kRl}^v{KTenR8TdJLPJ2KY)yUw6jXNsm{6C;$jD?szQO;i z>qA<_Ypi5FAE9NS$J_o__0;2vzlf4IL8pCCkQ@|#=P*C(ghfB*T!BwEI_cbD8Q?pw z)i^8?vZAkmj_Fu9NQv)Z74sgXTAQh}@%%RMCSh+7NuO|Ze0f~09cLG4vS5iv6qgH4z`pAyS#DM7!Uv^4B=wi?(f8UipFl-RtuuvZg0>S zuLt|urneNnO;bSD+BB#I&Kn&C)L@?zsnsxd#4j3pC93boyEmhNq-NGqw=dvzX#VT# zB&(oiiN9Leof2caR_(P~vDg?hTp<3&GL_aVhP%<@nQNJk@>;A3t0(Fdf(#2? zxfXeK>EQEzb~F!>?)RMm72^6|#LT$jiI=$wcn@*)aj((Blv>!WZdsGQGY_?q_xrWP zdPbo#ScT=B)(PeNc|szzM0U6S^%V$ZaAnj4Gk^a3Cakfub9g~dULpNw`CJ?<#f2lQ_ zWpx0@S;L)d{%?CaU)ek9OP1&L>8NwMGUe}^q0&A7(dzUW$)`2)0GsyaUw*YnCsBCz z5KMoiw|6M{f}R%uS$hm^q`0n@517wC#?2ia6LnhZIdNuDFfQAI>T%d6y!ea`%X5fk z^3{--45%#P%OJbJ;O;A`AZFN&EK**OKh+KAp#2*%6)@5f4OL(cNLSd;QGN^Vs&&FZ zLveCtjOl60FQ+C76S?g(l7eroF$csqfefW+79zc*%h=a#v=wl@OB@Q|Lh3gRfE>M& zxe^$Ki8fPVBqa)WC#!kMo`p9;emDy^Q*uYUf`S~HPH}yL%NiRop_D<72VE+wM26V& zcZ-+5So*9fL9UCkw8D7HE6!OQXPY<83w>$ptOx#Lc6>qQu z>lcjyr*=~6`Kg$Q{hEv`g%?*vByj^psUa7cf6u>1cjH4Z=1C+Uec+U`lyEb^r!zJY z;U(xhoQx#P3(jd(999B3x}E z4QOOg(3*P#jY|SgQ-FseDSEp;>?7XBjK6ZNNAAl_9f%7}AQSHxV;Mm)@56XS>yTx7 zYpa4^L2R~X%m{q<{*@4qnwZ(KW8TwI&2JxL>^f|fsPLGg4Wh_HkjrtEcnZ)Hz@<3D zq?x=w61fkmPnM>VE4EUACt%-0#&4OOTF{Ee^)oTL$%V1ybkA4Q^sK|mK~-Xj_AINP z&C#D-Jwxu_HUb0B)0R?1ly0LHCT#Xf z`aC-fNXU?|-JOO2Ce6EGL$^SZM-*fN)}-@p%Nm)*WjkLyFG=a^vjn#W2**B$h25OE zP{&$uZk{A;0$v=~#xezP!ugw2H!Rw-xRxDmDOB@T0~55r)V$}Sbl00w0SVi^Q_$jT zhcNl@ZN|<~_dgyHT!oC$L%qHfcQY1w6hp3~(1^5^pan(#mzU<^K-a?8lYINEU)=_lq*kdeiLghZ$w=I~gM^OKi;9(2euh^x zSxiz)G^50nD&XtXjI%zAvfz~pf+8S@Z=oQCkN-JIHG8rSYI~Y%!s|5OY|=)aPR*+5 ziEXB{U&7{}P63^PAw)V*kH)A5wp1C>*T6H&OWJkNtjV*rxgjcyfT?T0F~Yk@!KuV+ z8%ux}HZh|64Gw7(^4oZj_*D@sTox%XZUT#>ify~r{WJNySmi#j`#cf7Duqv{^3A!c zCRJ%~1DX+HQ>)B`=r`@q0pw(LnZT-N7&1_StZQRGh4=4RZHpFZtm`~V7;Y=0X zJ@N3HFI0f}t+eipl|3Q#osh@W>RcCgGo^&x7K1_dUTuiK+=-}i1pCGGVo5YuCB9Yv(W~@PxbQkOoxMEa+FQxTxl1f^!O)W+MOGL3nkSpx=t$N4dW0v~o5n(3@k_tgVCy~DQS^2-qK0+TyB zeP#6Gai`v16}GtbV^`(oAkKO~twYSwRjjZh^gUYekK`bWhZJ~q!GZNJCT?%FxDgm- zp!4iZe)E{Dd;wmsV16Z!4N8d_|LWTe+3*=MrrD?R`bM{=5w{lv7miAa(czC=MA+=U zwQ=R^_fF{^%cG{5$?^cET`G%c&_$Ou$ntNLZLQG=54_T6`QNLcnj!j-Bp9>h^Yl_v z;#z9-RvdMSlu;lYg_ihcfS{rzOnMT^ans-~pwsQdd^S_}jnN$j<>mH0mD2LfG>c0_ zFe);%ZEqtZAbV>|$#FSpRKNbQ_eCt8z4*ENq0WgASGvGbD|~KcyArtuypk-c;O^%P zcIQ9|adv82Mae&ALr*}5U;T#TLn?LXN7}W3Ra8i_>|A%JxN1kI*$r~)^a{l+Acsd# z>c?bPvi=N)bOGaeBgM_0Tqa?{Y?dX4)FjiN1T*izt0^C}9v?4g%hxWN#j%0~ey6hz zldGafI=YqclM}Cw+odc+Y3%Ic3jH2yguv{maujNx=Vl2*-BN54I?s_QiWTVQ&9Yx; zDY7K4_P3GnnXt&#wr;-_l^2KapX}u_t2eZN2*kiHp`ZS=W4o&)Z`b37jty_rzBk%) zYBwu8fD0^toG08We*jK_iprXwemkWp>azBm9RCRh!DI^CE-5EsNBSYv% zO0BlcD8;jz*evy^m6UFHUIdRIE4_&LR|I#^cb^kkdNb^-t8Ho^Y>Ptqu5#i7+p4tp z-gLngykc!qas4e_4crp+jx3ekALH`ww$y27cav_08d(o=UKks>lth|WJdzPEla^yQ zlAKwx?YU&4D_>}??;t|mnK8S3{_sx6O~zN-UYNy1{I1$j+TLV3pvX+Cu;f?`?IQL1 zml-DReEly`X6YKJ7BBU!fURxI-X<-kF&x#LS+wIa%WSN2dE(*tP)@W@FeNhbVg%Pw zJlIsRuCBlyFdOQVzy|~DYqAEN0ON0;H}@@DjNQ4#0UhW9xC639rSXxli?tDm$Y@T> zVh*-?4#oj)dJxB5spuEHtOEz6p)drnwl(xEknfpT8qr>jK+j zz|eYNA#&b8Lf^qGTCPCFFo481$f z;{Xcr_`JUZVGL*%K-*J?HYl3sUf8F$5~fq7hTd+`S*qXabZYyO)tUL~MkMvGseWeS z`+1Z7_($lxcT7GpWjYhQ++pSWL`c4jLpY}G8skWEeS0=XPZz3QC@x<>JG%I%=FC_^ z3!Fir^8)M8p5JvOI*z2dE*b0e0~3xT(&D?9E;puDbuC9W>Q9>NIyNrsOJy!-!&SoA zu2fJ^3*I%zU*nU?*C$dN{j_cTAm8O}VaiMO7vx?N+fd8f&WUr!^Y6YD`8fRSi5tHF zg=a2YCAK<%8C-qh9;hsmo&-Ddra5VWrBGn^u>hMs zn?yT|P1ch`Ih2D#S<*n8eUQWoHoMch|2dOd{j>bH##*MFNfeG6$40t&aG*~x?Yuj|6Ac4eMGpV*67hzRWUByDqHm2a09heeWLeu z!qeCEbXFFrvq5v+lVl-aZ$!0DPZl@~7gy;=5Oaw?@@hE?*pkQye_0I?YZR|$A_bKt zL0hkl$#=yz}d@E zdN&? zz32h;WJAh8qTBmQWaoJk7wX?e2$8+fr{7jBzBVU(aHaVc=4RB{4d~u`;TV7)$i<`R z&XdD=E77V_I)W-WFpYDOv70z4DkPeo1%Qi#K>CJ*by>dG1FgIAEv#t~H+BKqcERAT=`WZoE9KHz~ zC+@>6149lW=rF?0(JX2J!bfl+$cW+1bkP+C34BUF>l!ayXYeFwg@KpAQyh=-A)OS} z$2oPWB+vA}Em0mZLXHKO5Sep1@(di(!+){py+5c{o>)8j>2oHF8gc&pbl75!Qp&lk zBoW#lAGYa!4F>AyXiv}rrxQ6oJR8xCLk#yjO6{7wR5IrLhw4c0R&3ShPbZGueCi&; zto(`rlmZx1RH6IiqO0LKBHCZ>R_)*4pdop*EZw&M8H3xDJ7hrceN~SZ&?-Ta^$=0H z8yJjCc_|EStx(!BS;*vaGvNkp+VJ1SE=M~rtU;_TP=cBXu&}f@Z##dj`HE-l71ILm*P#T+WsYA5)sEoaUtq&45pKh5 zpOW$6(UMM|Utg1A^Gi9}@$vz$+%z(tm| z39wcnunOid89i6)9hR>}f*u@4tQ_20w!v|yS9dmQBR&uoEfc59WIojnbA>>%E+O%} zpnv<9wH|oFrqA$n4mm^vy5#St+@UfNv64vnWP{J05%u<3Gc|;28oq+Bqn{&RMnqvi zEe27k7^ggh8?F5@*n4Rx!E;!~A$puwl!`$iA9MGL`P>tkV`_o3xo|w>7a~9fAYXQT zV`H2^95a`!rIS3X>7g@C3IpI=cmQH>7)*5>#fTP!SasJ@W>9k~#8$%9xP1VsPMmlh zQg$l?T1^fBOPKcz;Y zuaP-!=D)5o!^+KzvP#Q;$vkbk~@$l3nm8@nhe z2yV0JQ()g3C_elfbI)mc$go?6<<*#F&BFR!TgH$3lZCiRejakm*L@YLHMZ zeD-CkI5(mDI@#4=izuEYv#i|jOUkU3CvI3M;J1eLXzwm`ReL1u!Ed5|zQGsCK1U7b`ETq}7R7se9CCyoby9Do^;gwx8qaGt$N&@So);t# zRxFT6>_W+eLa{&y$hF9Z3!OkJTx|RHLR!Lt$)&+x`nL1h7Dx?iER(L*_UDGZqQd$X zLkB?$mkq=#BVFsSdK)LF$EXuVeS5Ho!8M^S^8VfctQHE0rvz8;z=ARWj(G10lcyjb zkPlS;tE1tW(FB#+$ea+7WUN`|1oE^=oNDtr%AhXemT+I-&fXoIEX=_`NVEF4bXejy z{FK0TiCB6jcf^N(*G?s|I6ty5Oa*gv?$EhnJ4H!)WNqBqO|F}0Yeml!{Sq5A$cQE` zQy%D5-*_sa2xFp%x5k`gY-JYGvI>;fS#%m0xlz4kDM7{wYJmVtF2nUV_;*1yRMW5O zM(#sgpJh>GW6)&L4?$~-l65Gwfg#`5a5{R#z_DPSY)AN%d?r&^Z5*!b@%7w?7WlyU z85(0@qVEhO@YMJ>lOX}n`jZEo2V92_$aCwdT4&1jDvPzhKvg#`39VQz1NA?l3Ut6!e9l#r|bgEZGilaUh?x6JAU)4WwZJ*roaK|5vtUd{%n-cUpeV zy61zri>Bzr@?VL;N=h6uuS;VNOo3IT60)?C>!R|bQWTQ(LzKWo_15O=(Rq&&oWk3u zN6PznlwNZLxngoK%0I94I>n!BSx$>7O|FX4K`M3wWPk*VCd&9ln_qwh|`C`_?NivS<1y6^T z_E08xqswsbGYA_`S7jcf^#E|l>wew<|JSfQA3*=l9pD{cd^@{oUVrv5mDN03j6zFp zr_Gu!iu&UJJRB!eLzDk_j6sxvze1T6DT#MGV}^O1m;}oPdMpvJh7W)O7oC3NLW7=x z&O&t(YV~$rW)XIJeo_^7f^tTZT7HT*Lt|Sp_}>h`09O)l4jpN~{|=_r`knqWHgHMZ zawS+yt0+@6F4(ZhRlmuF9A|E{O@mM1NZL;Zh!#*qf%(tdO)$PNNzOi_+!pqHJA6A_ zw<}bP*rTkuapn)y7FYpQh_3!bH!>`ki;~0Wd zZt~OJz?;NaNtF2++U6(8$3l?>h61uJLXxat)zToaEpyns@x^Vn!w60hrcEGkL$?hT z`!bS_@uh>CB&gpxbuS)lRme+MmAJzFro%h;^%wdzbz^^Y3?YA-!4Y(+&xQO#c)G=j$;YHZWS z(sa~_^u%x&h~f#CqRAV|FzkpQ_&5!vqp*bzeKBbCkRYbI7IUs@Nn`}R0gC#kq<~O6UA}VRZ3K20WfblBZukJ zGfMDwp^}tk)C@E!ts;{O)f+{uOnmM|KqI7(^XuoS0Cs4Q!l<}vf^-L>NX_E-<2rY9 z3UYu{T>_LOi)N8DCxgZ8E{7qmn{38H)OwV*Z>)vB7lYPLBY@18-KKd4_`_JYWpm+L5nlRED zqp@fM2RPLyDQ;gn=m7nA6X=ra1%ja)|4~)~qnZ2yLZvkynW}4nwf&T>RQ14O(@>sn2~VWQN_d<{aH3xcW4nVGaEgKc1bl* zvdj&g3y0@NrhY|&x6>7++>Tic0|eGUO!^Z~+^H$=rek0i1LST<|#HD76dB zHevfY;wPXgPFT5$x`v+XpYNY69kN|fKx(3hff~?t;-;9S$T#4SfKC7u0)+@qT-d{c z$7r_k$HMz8BcEmM#EsA9*!3CdmClBHQpv?oMywaH8XPB-zSuk-F=rPTRh?h9(zFo* zIjwV#-0qL+t`VgB7o2cuWij|glPY@40p*k}RNe>x44#doEbkbVm$7+}qSH02H|RcG z^X%>9;Orsn$e`N$ElgmX>VFR6@5pXFef|DlW`A*8F-5&V0SU2c0ReeE32iThdI5=k z!Cw}6LVkHddVW$>`pWc5ism|&MhaD7U3qzaa%M^VQWT1^nsUIj>HkL1fSxaeQYx-4 zHJuy)X`LkHr31BqTL>r`A-bDcF{*1CB?xKNPYz*m(pfW<;hd#Mw3-NL32YTE1^Iw# z*Zl=k&`k_elC*M+z?(xN#SKj?Tu_;g;phM5;K=WZ7uy8HK>QcC=D#pF`(m<+WB^z- zzy_Cq0TBkj2%TwWqs5RTVf=qUL2>hGc1Y`!7`rp62mBv4esuJoGbuQjy8#;9# zK0l$HkUoRrKH$}X$cKw%aLj0hs-W#}t-r6D--pp~h!U{-JD<>5=_+qN=q9EQ8rm>K z6#DR0c=g+yY&Ei``(4Tu3n=Vx@lc_PY^W81Iv`=SL1jFc3NVs%umel-({EZfnME+D zIjNPg;;s}`n~=q(XTV~p6uzO5pq>QyFEMdF2Qdjhz}P$hBdcN9dCD)1?8MYMAX!#z zFP)?yzqB;|H|w01otIdVZ(&`Te{^wrdx75INh}WM>}#p_pJ;Y&kl6nY3{RC4066gv zz5kEsnn4sx;ZotNI4vtDQ4{1TJP}TZP)E1=*BKX9ET?SVh!)344zRkZ-*^ieVDY=m zGG|fqK}IoiQ0>sB-^KmkYs&}FP!X1-=WP^`T+D=~&`s7-(n>B`yQL_P~dPjAR@x9>e<=|7q{0Rb?)pvde4a{O+@s>SMVL+-;9_GslcHvbdH zJrDpf6>xT&fJFNLvrXs!dz&@_8~zrWU%y7Z|4*T5RyQ$oaTm2@cX=TO9s(|uN(hGg z|5s@0NV~P@UO9571m!0Z9YN{4GKXybr_khp!=S_%lCxcW(|PBNI!qKaYLX!9iX^hmGnx18P0TLGbk(jMXA{ z(Jd(pw@KD}QPy>mt?$EWr%W2M-Goy`OOwGgVT_%W(Vs~Nu z;v;AlHMQ=pWbPml(xU@l^Kjp3VG1UA(I+~VPg2{V2QI-prD8?yh z$rN2PD(Hl--p2Anu3&XXsgX?AO)WHk1(ZO*v0caFIpT29WLU28o@J9zbs=EpCydV& zj15JvrLO)>#pV7fmZVJ;c6H}2uEtSui&Gnq1v}J-No!eD++zTq~tAs?MTs9J@k$V>GPZCx?RT`0mYARnbtuf?JjfprC)4wU+4PAo38yFc|PMrT?*KPgkrBuAToaCxw{ z!mkIZi#Rruuhwua$Dg#|yKoNi!Ip1&+sDTohwQ?g`#j0l&vjmyVLPQRuSRgWnqM^W zb@rF_835yZX{3AOsc>OB_1C5FjX<2aU*<*?VS<}?Gz<%vnf|W3Z%Wa%M?e@GY63q^ z>3=p2=SCRo;NQ9GT1j@`6{y4YAU**Uy?CJ@CB+L`}%b-PE(_gj%IF? za65yk{)}aLyW}w7HR73BAa>C9$li{Bl7{+&AQX{??1(-8*-+^%HS(y@3sm|msHn43@}S>Z~YmqkK$e>Ge?{4fvx&vE$#%v2p z#_Wo6bD3F)l(yswW@Xrhz~IYLjDjWn;<5s^#aiBag4)Jl6YZ9m7Mr*~NaUt~6^NI{ z=r_R51<9jD|I;qM0`axeBJ~qBZfeAIeNGJNIgY&G-g(<;K7luJ7JO zI$7fsCw%gHtMPc4@MDmC(_tS9NN|p!B z#Dd{@E`6bXSCt2Bh_jRBk%|QmR#r`b&V9 zCAFrox_jw|gwjFTFPa+{vxj11WltkOdyUPdY6HQ;jCWmMC-U1j;eVPa2*e{1uLb-2Uj%Vy1h3| zjQv`bV^egpB@NvD#EaOfMhXgMB#adWJ?i<1nh-28$bMs9R>OY%cZ4BR7`Xj@FU>Ax zelm}c^F0kO0leqsRmWzm+j1S!pj4O*4rK22>0;E(=780Y=GyiXg}ZD@@egIk&AEH_ zTgM?d>h8c;9^J}aMFlxD`h`qT1rrq4=wmhKyV%Dl?M}n z-8HQ<{|DyjS#NL6qrNW}9i@)@>sY zCUR|`S4WdHwSOMVX#XIKmQAy;zx9p6`FBY#P}qeGtOY@=mrUBb=txRyjsw!CRD6S1 zI)UTam#khVr7o%P&K%7Ph@lrmVx(>^t_BXSyR=$rR$C?mKyp#KSm5b-drz`3rnAz^ z!_ED<-x)MmI`>@m!_Dzw|9-9JdW-N4h~+Qz@w7-sCpWX!$#(g8FiwY$CkWR(XEIy8 zePBHMfzpPQH(dvzIo<%(!g|v%ub7`j{t5%g_?ck)IRs{{?sSB9CSVv+IFV~Knu6do(&((3SKg3?V%Egi2AGvaESSZopmFs!4CkG z2i%y&YFZTJ1+vKl;%%~EZO`@xR(Obh?emSHU0f%%-ICs+_m{5^OQ*i0#hs=A8wTr+m9{_}CuL#+5^78XVlo{G3d4jrNpQSwBXEP_~K zP)o4XjrL1Qk83OhO)nwJ!Z?h((e1@^#El~Ug-zYO*d^qlD`?B&tSR8Knfi3W79L&@H#9fV|xP5W|$fS|QTpp+^ z%mv>KXOyN#_3}m>UM#p%4wLz;qH{^~uiMiW@6Pl^RHN8gczrud&GFDc0+#rp_LTlc z-iZ7C6Lf@#ymF!&#VNvCFk~<^&#cw)xT8;6%OR9wq&K8MMFfRLZfDwKPi@5v;Rm| zX`B>fLry9H&$+}#@Dt$VElv$f>@nD9xC6R=9#3ZxlNoe%NuGf@FN6B~uvzBEl_T3}kO#WqbNuM3xTgghc`vRz<}s1X+A^!nq+7h#&flDpE%eho zwnjo@pkm@-CPO!1E=@~?apEjjz*rSYV(sRKeiCqvrYg{=2$ZDDFV|<>AADk%eLs~* z6kk7eg1{gkI=~58M43Z!7SDCnXIjRYyL$r-S#BcTg9(GzK?pGU&2 zED!cI7ovLU)ewY^ubY#L z1XaLwZlsISFfdg04`7lI+M}{O`kG2TTzSViXL9dyv9|PwY+g~uc|M^xu1T@EqTBVrFo#q^^u9zyOqWp{qYGj`sbcm!9aNY|QF9*~U zl@8}UD4giJ#UJ0(kHo`gbVs-FA7J6hSxE2k;NK72)uQOO)j@6Y76#V~(mJUqGJrq} zMD>7jD^N9kTG85NbcAA$6U(vS<@y->yBIX3EL-nX3q%Dx#h|<(z4`9km&DgFM8v(3 z6)8@Q%VIln7LM*xA2vPO4u6s!MeQD6DUoq%4Y29jRmDjFp00V6Y7f1Yn$|v_|sAe*z>iwlo0+( zsekil=9*TyCUzp()zli*9b6XW$aLExt3@Sj8&zK>YOk4q0DFB|VNXiVmQv`;9eD!A zgqcNtk23f1E}RTakTe3lEzVgN7IadEX-bVUD_tK~wB0D%idT=Vve);CJEJV+ps3tF zL%;7^>`#O_NY1NAM_qiDd*{)i6Fa%WTfsyT5#dpD@bpURNW&L$q-2;3rKlVgl9|}+ zEejQmSve{wgM7jbP|t?dBp$t@#gEMP9(cKCzMz2en}3~~WqhMjhW}X32!PHN3sR*9lSFzqJFC0So9WS-$YEU1NH9x{D4xF)7TsX<@{zaA3EMO?t|KJ z&&ed+ziG?TbQDK0DI1>(3R+;)C)4*N6ad>7yw3&jZ}P;Y_WRYK*0yZ8G$4$_lw+zj zDwH&mRFn(Ab@}~quc9N?)+oQ@E$!-8(fD~!rw#{BYygflWP}vWDJt0s8ET5jQ}oN{3el%0Q-jn( z>msD+w7$sq%k=;iW8?Gdn=BOStKxKQAqJb@#N4C1e|*yh^1T@f)wo4(Uzd!^&iN~d zvM{C7H7`YWc_&{@n#->9kCkRotDPW5bAUrsauhv41e!HmJC5l{T;o4hL~QUHDup6+3))aDhHi>2&9ymaCn_UZLiZtt8yvtvJX-T!4I$#-!^C)^r_&E4V(*xEO+>`=!H#tkQ zKw&w)82a%>4-yG1BcTwu9F4ijw1cgx}gE{vkK{3Ravv(%zH+``M>2m-91I|eBo{7|K`obPK~tP?oI?u zlOh3ywbt;r8)klwU@@xy$A60ksJk4)+)+TpIvA~kMjD`P2$089K1OPz$ zt1jv7wnB?5bLX^>M;!WcclmTiF}=HYwy~C1+|y-`&Z2a2h~teN$zAz?`|bif zQ7sAu&k>o-mmiZo^Av66bajE0(3j}xQ7X0B%4L)OBHgKVlV}3saSsGHvP)L9a1J|R zdEGGkR%0dM-qEk92#fij>#G#LSy#i zWTF&DnmLyWmLhMfr}$fht2{yS>S|1AD1Ot9oBvT|^4NGQzd&4qAktL&~4hiJVIGVdKA6L{(f7<1oeV1k7-+NH3$1oZOQW`PzJGq z2dUiud-~;6TA#c(VX=VJJgJ+w_rR=oJ$)q4ervQiBiJu*_iY>~P4u!%TUBe$Pj(OY zu3Byn-VeNJ?W9M$8zb)@O_F~kF`O|&U7u`|g7L_>pJ6Z+6#odkHlvbZCTo_W3kUyP zklZKJyE%X6cw&8zz}f(jhiw^e@m)5&lkC=?dOgQvIYG!hHoQV2R59~i7s25XtkS6B z19b@(jaL`>nzO%{+tT%Xo~sq>3(SnUe*Totty`A^w`}CE=zYEBi8}%OK+TTP5qxBwx;qLhcU6HRLQtd!gKnJ%jtxncR3fU@j^5#& z)dMEx^ni`?abSYdqf;J^GD za$KsyEjgImu{RT~@if}Z%ZXM!%V$k5UC>Y;Y0o%^R5c%2WN~*i%ouK9Z7o3!Yadn< ztA9OkJ(N5pUpy@U^CirkFeGeR(>te(Gn-~2NVW+mEW(?td@+<4)zJlMu+!Ms{iFV; z-1?mRYUvvU^T$wl!v~N=-XIA+DXWG8>C$x#&yZC9p=UztS6jnm2Tut-9^L^+c7V&d z--kx#VEPpemxi}f_@G@|F&i&26$9j=zF1}qg0Z%5krqP9EH*Xhvop!x>f(E%zH>3! z=D&b$@2Ad3u-f{#-Dd8-Pt@?%0kRXdZpP7Zt)en6I7A#KDy5&9rA=3z zUKt(`Vh~hdSTB@2G7(S1dc<$_d~!Sw;5c;o;6kGDz`wgUg%zI*%H# zpTYG4SKJWX&QRl&+Pa4YSpBbt(G`Bi|B3|zcHn0qv*UJJlhhCMcol*?thD_<* z<6{T4**WBfO4OJ!X9j{&N*${Q+DX38ky=FT+a6lwr7HluEnD7Y*cSQF43Nt`Z8aUW znj^pK3b_oeqc5?S)P131Rf{~PCtvAR3WEPs0Mhy%xQtDRiJWtkUOY9Zu^R#qpheV8 z6tYBGrtufMt++bZI(J*suf5eDH+;adGVu?=Hpvj*377LM6 z9_EOb`R_7Epcg>F%IewcY-SmS_JwlE;{5(G<8*P-^2sU3_@M~tsIaC{P`k3GUXpl< z`;PDIsdktMn-n-j$PgHZ#E$>gM(E(`L<#_PWBq{nC`y)f!n!7BsvgV2HSum>!uyR; zj9O0}ZwZMzI(ET}WR#|LfN$d^YT#lU+Z%YB8g&DVommkQLrpsL(W15}btkk@6g7o0 z>@fy^Tx|v+S8FmZU3awW)eqn)fYh^nQeYnup(MCQhiNd%OWu8JCl*_>v&tF8E5(j* zlOOCJK1h~vxR>|053e{WJ4lbvbwaJ$zLZe*0Eh|>mBLRYDEI|f>VhS74r>J-EdP_! z{BW8Cj6S-Pk&~fAI%^Pnn)9nLuVrR#z9(IP;|6L*n+qI{NwuRT{F=vFFeEb3%_71t ziJ}G-)ImcTz9d5XMI%5E1P>R6GDDnwO zPGeqxeXbIRwkrW`ftVnA+VB`JU%7?%(*KFOY~tEtu+EVxq>ljVmc(+l|a#>zU%%t#@9+I{h#R zx!a_vbgL26s7F#{-Y?BE`^{1M`U@+i)Ja)B_cdEb^&XMG(t{!h8Ixt zTRV`E=aU=Y$ALvfjPeT?Pca{WUs?mB=uapigA+wYM+QfZiJC;lvl>t%9-i! zpC6hQ=e*_k1bD~H&c->M`0GAM`m*z}{n72F=bgNZFX*8|EFOrB*HM~}NUtLwz#dDU zYn4k%>D`BLxEvv)*FNIS3jk0T)9q*v&OgZq!55~q1~T8=lvuVZgNz8tSOJxKtoaxd z78pZokc1ExzTSNmgQWaNxxC|viJnDU2rL~g;Ll+oV1(~2_APCyvw0;=I|-qiX~;2UbG6wMn>$%)i|8k5yY$8U0QrEGjM+THHJ)k z=q2)OfmQ_WwQ8|k#F39FEfv(v5tvUMJ;sX4X+*IvtULv!P*2(e0)D`TOa&VcbFx8+ z<=ePMPN4%KjzLe}f*c{wFvdztRILKKC3J=e80Zy4c=NO0bnW4QF#V3# z<`-%#vZL#*NGrDU@N<5rla=4AU~F0UauUpVHvX^R!%E5}pSYsJLk^H#5;{ z!Af>KAK^6rh5vq9+!40{D8{tsrkl;KsI)f5ORJk_vD9c3=FjYIG0%BpCGw`3=Aiko z%7N0(T&FOATNi`aT$NM&rhN2DJcrToL(ud4);~cbzZP?cIUP6};CL zFOlUlv+%rd?kWDkfkyMdBIta|ovHml|C%%(VNQ~CM1u%B12(c70dvDLX`7!pX595V zd`zdV{1xjH>D{Lv#LN$D9x*X>HW_@-Iy0LSuyRQk>f1`N)GqmBy!ZDS_5XDu&cE!< zhD>loxqYv$!I1iJ>F3-cs(PEkaXP}RZfyzqV+=MQMD$>=K~~ZBDAwz6oys#rcF%Ko z*Od*p-&KQP1?Zu*?tz;?<{HM3wGd=zhIJ1?nqX;#;3H!r-N_k(Dvl#3x-gcHZ?LyR zwI*5Fga3U=vKhB6>9|!W00b{jkt_@3WNPkJ%-3Y>hOs)UG2W848*E(%61OC(4IZL^%?Q+WqJ}?5@&t9({*ho^~1u%;ADQg?Q%my&rCnRE2Sr^G3q47 zM0DqKk-qk2+Z64^bWhdk?*yyzhDoJn8B@KtS18A#yNWDiarg+hYQJx`^jUOpo%$9( z1n5!Hyye#j`9VRoG?qXIJey;|OqMsJT0|zRxM@ejQeCDEm@I;Ah3t_w>?3w0{dbgZNJ5g!(z*3)1~u_jqRa*m_@P{MB|<*+^!V6uEQy6U?~(QzO#7 z4ykJ|S12XSCGDELh*2bxs~g@~uZ0h5jn7nLI}^{ehvM{V<%_vP`MYQ7fh)SjVuqG! zQ(g^Z0r^@;00mN$5;KnN{bO64doc=$Zrnz-8^u+aRnbg(HbnPTed~$$eS#7&%bWAb= zLWpB4V^UKx%h^@47!!KGo>Lsye6G+`au8v^#RXxmtQB=xac%m$@oS3 z5CA(bDAhez3kTnk8fG#zpbGHr0wX$Uo_kRb!&Cjlv`b^Z`ZxHi^9I2)uKNeDSgPWeqjsk z&lktM(vz+L&rN6Y!w;z{eiI+Oib5g`Yfw<-81uA@{y!&Bjm^C%n%P`$R$n-P&pq{y z8({x2ir-?2ZO?%BAl1n9DrPBz1INjKgZ^x0Ox`F%hyH#BN#*cykoU5qN?0d0Q2{Uv zV?s7p{32XZRHto!S9(1kl%_tAuxs~3V(7zona>MCXlq>nGzuw}8p;w>w(--QH=psz z#;yD-=n{h&cBVaV`G1>(@)z@4u3_-|Gw_WrqC2P~eOB>a&dOe|Z&>kFXN!2=kH^1x zT(`CV7Io^o0Z$~Enpl?3j^ytc7ujlO57bzB4bny$BjdqpyPbTuyN-PE|2% z>u2wl9%#7ku%Xx*7mf87a2KOy(?Z^*+BGpPqa#ZSPVo=-kj-zAQu8+TG|ft{ zNVi5Vl=W=f^uzU|$2{eW*&2X9LiGz;eC#BDR`fLIW5$VC%w}0Lp3Vs)dy*oXfk9j9 zaTW?$eLSDw3HU~jgaIL%maKq23h%eKF#3xu7@_MEw0HFWWqt}DLc!a zT1!g?q%brCuBG;G0ecz^tbz?5S%-c+29l!-db`YavCL_=<~dcSh;}C!VsTx-p{{?$ zu5yOy9sL)d-X5nY<@;mx{7v@>3EtNGQzy8}>}W8w;JT@72on{T4Ow`>q2a$o8TQ#C zVg+#B62vX6=(>^xe0z|@3` zB#jFY3-_yLrAB65KzrhGRS-nx=57NeB1{SJ9RQU>(V!b%Ln_GznklDvKC$s&Wb(Ut zq+l`sFn~E_rJ+EbR|EhW!PW%|;O;7Hc0-DZjh+K{d zq*r@w;VTwurdVD=(ssbptlC3C2cR7&9Ss`=W?su|+Y<^xc4H>o1ABV5#_}51sC(Av z#evlaKL8S!4uTh7TQ{3-)xcV{iGDzoJ9-l}8KVDY@CmtW&0ogd+t`W`GIMFhwpVn| z+T%o(Asi^I8<7c8Eyf#jo8g(Rlk7o8?3yGqz-cPd-P@=_VL$*zdE(xH4AB%JQ;uDF zr_!!6js5kIGJ3z1X@{_yBu1u57%v1D1{> z`TM1$PS4M-#$80FeecjbLB4R1`^rMDrpl(nj9R!SlJMMay%#v0mM!yjPn)ZFrX1&o z_25EKb%)=F;`9({KprW-354cRW z<`O0_w%V>zfn%^t2sbXqD51bL61UIIo;#?SIG}rKFN-IhXPave&I?~(Y_~?IKgg)MXiDU zpFCdt{~cTU*~Lvro-1YnzL>}!MA!JUf}f7`2TmnESEC>+5k%2g+nCsPfQN41;zG<} z*+XR?X@bo=FEWzJ3EEN7B}(ddBjO}rsiH^5Zb#jNRwr(mF%U_~G5wuth@5XJl?csG zh2iKrB%z1QgYPaAT`p$5kzoge|H~ak{uJHr_ytn`GPrD_e*eI~YxEe5_r?3_kx!o| zXlasl;cM`(_Z)Wx2^wg~H`Ego4yTWGzdxqMeWgxY=I9)(V@z{Bjx!Rj_tZ3?*R-?I zBkOx(7Xp@a*CNq@B=@1Ho%Z|iL6yzV0{4fCTndI(^=}VT!O!yRk0nreO)iaeg538j z`eXc4>w3i%(!6fLpbB*=L9FlM(mIYfu&!DS#TUY5#@TOEj?H&m{RuoPdfENwDsRf&ZX? zc@39+;w$@#R`?+&7k?`E zyHj4wRjTmbV-BdcD6_UjKXoZ-4k0jgDsS&5X!T&az2 LSUo>i!VX|)v%oG8L<#S^qArt=6lXUBlh&~jNjOYn}rKl=!*(uB8O+Udo z8RIexT@xa*(8dkc(M~}H9(g3XtuH8fO83;0#}Wj)(8?P0ZrPtbWOQ64mR6$jzVwhZ z!b`ndyi!$=MO`?j$Lv{gi~b_AL>z;nR7G>*!uBfID{fko8_~^Mgo3LngR^Xtc!5i@ z{2h0UX~q+)bp+X&QxM?5Yh%&7!~_Vjb^ zaTtK<^D#1ifL#Q-1V+i*o~#Nx1G5eZe4&~W1`Ih-MqdFg^{L_$QW57&U4xifWDfhZ zMjLpHXmGN29!r9hl*N?G=S<0rkm$J8bXkw&*%CXxXNr@IVI8sDnlN+>s$0m_{H5gd8 zF>?2{Zo8;KyZYe1?bNs*jNfk@X8dyxYsjz?-fxi5QB-L-GdT$Ji46m8|HQ9y5!F9t z4Ew!cr6kVUA~PV2gdnM;)MoE77YRxf8MkKHnp4gJCm@J@EC2JCKhTNmly$orekPly zjO!!(#}n_#{}0n0E;q;_G4M1dilw3V&GeY<+u`RU$c|2ndZ`^zQqT8%@D|3guzLY^ zR?<6{a{B6iU=8|&hH?hOD@+>zyj&9Gn!?dp?oJh8WPla2K~%CS8W*Q;fGVy#^TQCp zNtcz~Kh7_zr(G$f9$w(5SL6@N^Uk71wVW2;i|f8_=Z8D?^?A}FY6@GknrP?M*uL$T z`Op5l&Bq1p-Lcw-lohHrOKqK*Bm+Q9RA(?y96_5+Dkt)U;dP9TXtYe}Vuq1aNHM@! zL5>D_EbZ?&FZMuk{ctTVH#gY>`K{s_Ca=+hc^&2<#f<@P6z9P@86Pjlcs$8F*fG0A zBauvuNah}9QD|mVf{OFYEPp3-xTtQ#J^eP*tU_5g-{`W7zwcs0{YKyDMgVbh0aJd* zfYKt|JBtE42l;PGEWix3qQ+y)vH>y(;ITRGJTP&8Qn_=Td{5q}KZa$Lq7E=R&@euj zlWov7D2I=2xO}Y^P1pjgib|S#{xkPw;pUCY!GJP`m&$Nb3L?hrR=mHnMaP~({z+|M zoO3s9IlU_mxSb7}Ja(}Kw;gK?O>{TZPYA0d_QF5b4?PuoKnZM7Xh|;8cz5Ca8|==X z_Z>U6Dg?nJ;vfX~Y@NheD`WwbQ3)ba>54rOn&f-9h3!6Dq~dv@`r)KVHU&DxG2<5- zw~hzm9Q;I@;$2|$e$KG3#S3QW~brLGhFoWaimyaE@ovE;x+SVDr8cZ@% zoLxO%i>p!g(J2kiBM4CF#nTycXFqOPekvM@AMCEy#w7o8P_qW8fX+ht_iwGv(}F4G znZta)jq)0Zl)|4a59d3_E3rwx^Jmu9_HCPnbRNOnd>2iuJfyOfrsvv@v*qF6?qDY2 zEZvTC;d8$|#H^Glz)6z;s9B(4L=GBRKzXCS6i6y@NS@V7Xrw)OaeyN)L2Y?x!Fa{p z8bgf3DcJdN~lLaX(+N2B<1v(iG#wIwY;+A8{)q1rn)DERbqJ zi&AXBX6h7}n87z`iztsVgFh*ltl5NKl6XItlt6F5S2yn!tv*I);wJ8~&LicpF^J&xyPCZ| zSG##XYhJDIh&|eV?mj9z>M_bN!m_@AAnwD!tx3Q4;vAL!|6nWsjwZo0^XdUM1>w&6 zqrlc!1rqT*$Iwm<5c`su8`@IEQ;Jrsn%-Wz@<~Q_{?zfyB8~mxHjk%aYEOgU9%VsQ zC}t(@-3oaukk^(gj4RgCWYI4vnWeeXRg)-TbE%s|!w4ey`5$oez@PfO~33K}h^0@T0tpO^3W)3R8h*y}@S7=5@M- zF17seplJnQ4vEGK<6w6tp)UR2GH@l)YP8EO$H>%qKS+t3BYL6c93BMUS_i0CC?7K} zxR@nsQ{E0zJw$vDlJR9!2_xL9%_x~-+>Wshqg0Z=qE8ip$`?kR2?h8t7Wrf9jZ{VU zr&L)q!_yF#OQ>#7>s8{E&36KrQ?S8kLHPWu3F=lV&GE+L+HqgstP;GZ z;KD%z2NIVpr0K!^`{~)7(rn~s!c_`t;VP&XHx4BQ-n?(_eLVIg8k;T6;Q5fd`5@eO zroxDXI9@w*L@5rkXMU0-SNF;tU%WU>^gjqp)ARODvs-7ZR{>?okY{P8QHI zBtFztGf7!e95=Ymk9w>SPN@Gvf{6#UhqnVPt=Q?*`tsH!Aw50RdCQVC`W7RKcplsq46ww7Xu`+&z(L6ef0$Pd+5 zTT5vX8JDA$em*b}!tHcYWbl5!`q}Tp6or#pCmrWAWODGNI>)(1F$Ix! z%1@HA@!6q_yDyf?vWKDpV{KsS@{*66mE~dzF5ydWI%e#C#4PyxW6FUJub?u)?XWWj?(`= zAa*@aqcO;j`I{VJu$$9zH1p$|J0in`6RDxuM52gO$siu?c2bWA*c6%12boxLa5XY% z)9u}TcOt}9N9b!0%!!BOF;wVVM#pO!gHTw_6(f%!C@fw;tc`k`AwBlrC=@p%z*FX3 z5{>ysQx=|iMtR^&ZaPB8z~>kr8UjvmiP>n}2x$tezo)lIjorKwV6u&E`~%OjEmQ-S zb`#u^gN^4Nb7%|ShXi&9M@>>D$O(;%pc-Rlb*vL^Ism&!Y4UC$xx-Hn-7}w3qRfq< zO2T^0q=`9MU?)q+1801IF)PXQ%%|%H(uiX%a0pw40(u4{?vThW$TXMetf=rok$Ac& z{K>k=xfe})lekJXK09cG3CPf7OK|Vd9QHcWT83UHRR6>y00M25eEUytJJ8>osq&q$UN{y^zFbEFEqafELV?#^vmRfuqN{ zE9sHwT=efaeJBZLbc%0)E=YCIgk6{yx68 zmf@yax+`q6N~Sz6t01q?wM?RsI^5`zX?EC)r|B;`(7}c`>D2o}5CS@OZ-8F{h2_OX zK~loEk;tXO@V{u&ZHv3qlU)k4Yr-YL0 zTT<~J*FKR|yurnj5(^r_2y~xh2x$GC2KTfF^gCzc8ugC#5W*}R+j@>?;#*lhd2bHP8f`5G9UCagtM5~!e01YRw zUM;QQ?tt4`Hcr@ViQm_HfQ`0=`w>_Qk^f|pPZeWn)Ra?(C^g! znu=ULcW*p80supopmQF4IBZmN`vJCNO0lMd>j@g5CN(@5fBw6qK4otM{&o{YGH z*;s8UTO6`=UHJWQRMFE(?yWh-?O*R$P4<#%@*2`hX zm#glXfV;jNg1>w;R*+S7%G$^>(O@A_UpINXN;<2+VDr!zvtq=2nhqnEiyki}L!^AQ zy%iFos`O4pU;o@PMgASAEkMcbPPn}U9)}yUN~CHyvCtb~tU#1`T2Aa)nAcc0R!|7D zN{D$dNMu%a;bFvv-lFt5uW@zI)DEdG_sxv}L7N1^`^=%<=i+;{8pk9=knu3yz)Ax~ zX&hK@K$5(xV0g6iaw_6C6N;YWtL(@R^PgnK(Wu^|1(CwqsuuO|m@+!zGKYnr&s$yN zqZAAl2kq&N$_BfmbfGL1X9{cD?3mn>>+Ypoa~yJ2+D(h@F=5w*pW1 z{T>Fd+TJb@5`3Z%JhF5a2Y*~~kDA(bHdJ$AlbkNQMe+G>WuAA|wPQ-r1bT)b?s*g{ zHnFk6hcRj-jugC+7j*{}^xbqrCNpbHKSU$}ztJgNoxcG>Ph1r|QK&s^9hO!xBy8S< zt(F8BQgPS06Hf-V=C29fR%sM8+~m6^uQyuYWbrZaviZIUa@(mUkJSqR@xT_CC#bxv za|fYY)=gd{c@S@N)aQHOL9ST6AI?n_ezIL(2c_MFIY{7Q4hfUW%Fc zBkO$`K^$Bop%G1kC434bFcdK3-f*^l6P7Eqx{seuLA6~QFtJkU!PJNIMh6Lc)0D!x zMhU|zCnuZiP!#9#3FT!YTUk++xN|m*l)o-ZlBuX4x)Oj{jm1QbZ2>#<;dWXX)ZyyV zeLbMDh15oJ)A$C3kaW<(|548{hln|vG9t0KkcYfUs%4Paq0&Ke(n=MYruOHI7Fv6h z?y%3&N8J#G_6|*IW0aH4Ea%YYkE6uksQCv}F=4 z&vWU#4gEidj`I(`n0s}ig@Y!<9NrlFq-neoNgK!k5SoFhYRs@Ywl-len}E7#f&q{# zhmH+sua!{*GM%uxz-M-w-P%^z2_iOmF#9;ARM~DZ1~|Z1yrb`WGfbg#+tMCz*dwsAl-5fcj=6)Q=qWmYWmxQ++YdH zGO5>tXXfRnQ>oqeAdHWTxCQ|<$zt-8K=NR=hZuLZyRY0~Wx*{c#tM9BCnh3GyKKcJ z7UXurIu;e~YQT6>c%328511^wQAR_xbE4ML8PCKZ#dG~wvwz8i%6uLhPRJ4&GgIc{#euB+smv~P|7H$*YYt8 z;Vo6}FYlk{;CH#nf2$SQgxk?2c`2&NccZG#4@^{f7N8>i-&qoCM9OY%XGJe>vghvCK@@u1qNCpM__|LpWqm1j zV1d=~X5=ZNE2PK9r5*<40s&;{sL<7T-t3fi75U>wZ28B!ld+R-w^~#i=UZrvp{1m@ z(4)ev%c8qE4ehpD-fgii-?irC5Bh7L0TCP@St7c0#^B;rEOyy zP?6EKWvzIAPK^nhw2$1=f=%P_b1ux(Y#AQ)zR`w{#g+E1mol_#+|Y{)q;{w7w0t`F zF($1}ny=&m`lX)F?VoL>d-J4}sVqGREuwblY%7>(d$*^6-fCuV6nZkioa9`{>DoU%|WP5$vbV+A7pbg_*9 z)be9xykw9c!;8>8#wrV~CCDTkHU`ycnN;gbcaUB_c9!@}XzUnGbvTGW@Wf2i)$Y8J(NDY8oDdAWLWQYg z(9)t37YW`~=$w$);QEqpPdX*nvh7#kWhMsNTDV1V_{~Qb=Cy0=wRqxHyW`7_<@?$C z)l}b1e`*()?*??*o*Yca7tUT?!4mWloq{V-)psy60k_{)YdeRg#@(a)Z~>=CUSix- za9~l>NIBpq$tE9~n zAH$1-YNa(>N!6*+{%N?*0v^k|dY60w8<{mw8W9puj$@rcefeNbYSXZHgqq{=MTToM z7=w)p9wxAqW_ChX)as0&;m1XtNeA!8E|a{{2V)l-8{6}CetRm#9hU#&;rV@h`9ybo zTYne!=c@df;DoOC>vQm|-Q#N_TPOSb^SHhrs9MNCzsJ=Xq z(}73C7OK3{-ZZJWt0pLMLL9$`4g6R=c;5E)s>2(-<1#;vj#wFW`R{GK6Jx?n#M?qNRd z{YQ2BnjxqwI{euksXmGZFhNh$<~l`0)RL%^(hiHUXZGY+!7Hg9wVcW*;Bz(($bfV*_Q&O8K~D_ zH~2GZO=H^ZsoQfp(sT10d5tj6M!Cg;YMU@HfP;VXPG+4>rVV(jR9W^$_BhbI!M0YE z@zxJzWv&i?uE6|!FRKY!zFwY+gD7C`^VZ`+4J}6y6?L>Bk|r?; z&B(4?Gq*lOV0+)aA6*zZwfN5>gOh713#q0TAb=o$0agOBSvI!w2e`jB?+GQpBD0E~ zo`OyG?aPGDk`X#$R?^STehQhR^HgPj<0r$21(>vnG_rE7_~D(0Bg|y@OO) zWO18mk2$n6=r=NE8a29s8%I0VN7ix1>Z)oIcCXuqp^>06e4E%{T_599nq>aX+WweS zCSEMzyW?=~7C2y|u?+e;HdLtRX{s+7ZoL3s5uBLO684vf19@eU6ZY25C!^LKsMYHF zSV?-<);J|A77Gj~_35g{TMz2YZLFra+`>>c5Rw1JK(0wJb|p&I=LN#hr@U4UJT&ec zq7B>$=w7*0X(3mN1gA)?FHY{XuXiQdM77>=d=BY*c4Q+m8rz#^d zjq2&3sGs6=uF$O}b1y39o$)c&v0p26fkZ5aWZ# z^G85Y*w?A7!c@wiCT6sVi!kvEt&Dfj{9~(OurG@&5kWcL&ju2UT;_k|$*bdU8%cy8 zn8%+hkdFQIB;FUhaBG~uhiVa7T;H<`KI%Bfs9)oG86Q#4=SJkTwLk0a-B z&1!BvqM2sWfrJ+wwn41w!{uuN4W$sXo0Kr7??=#Uy6r@136S;<@2`nVm4F;EA7&zQ z@as+UNEqWSO3CCQxg9ikv;9Zs0OB zCv#=yTI8&IlB@XXsJX3c0z7f-A_J|*%b1N?5LOW3{^S~~YFb9uufZG2PA#cR5~sh) z1)QBejuhQ^1jZ)`+PX(745dIG#N3Unqq%X7*1jr_)YS~!1n_!R-UIuI;@`n{OUrI% z45qh9?AWE$esXe2_aJx7bT?ILH7;C8Os!w*+Qu3px6x%g8dAOEGf>wPx~sJ0RcM8S zr=Xpa3Sh1lz6Kg$;cf0Y!-Q6JT+L!9&({QVwZh8M7_=78d&0`eA!<5z7PA<9!>cx@ z4_e)}G^fQLu{8-hFVz{CtJQweE;)q#tTI&=#FnM!De-$HL942q{CmiGlAx zC6xbLVQoZ`R=)}7nWz~yBfrrMrLy2yZdjDYK}Gf?=8U5&!A!J-Ap2>bZ5I|VCL2oQ zs2F#C$vl8tGFLk87)ruIrZyPq;YPbt7>nnTjo^U0Muhuqkf3qne>U@-{Ii)4 zAA;)~^7;=6lQkgWAK;fh@dv3p_|uC23xWQfIPQw&g#=XXe;U#oT39x|Xe~*9%MLBy z==m8a+vOP#oXTWmB(!(5bG9?GvvvZYZ}-GHPVJuwFfbK|XHxe_8kICARD%#2n=&<> zLwfz2gFi7%RLcAQ9l}zQ4WogkOprHT2i$B=cH? zl#fkHPe{^&d>v_UvN}HO9O$`!rG6Vrb3EA(_pL@#P;E=|Aaq)yAbrsJagpWtmSV1Y z^Hc*zAz@t^SWYQHOD*?Wh)zhz|Zs_^_jrh+AlR(yETD7T6V=i zL~6Hv3PHGt{j_eJs7n+N6MN6*P0(!_ru3l4&6M9-$Q(^kwMzxGf#=2aaO(V){z0g( z7@gcs1%gH4u__66FLK|dmR#>{h!J-K&3?|B)xSLnaS9Iplgd;%9aG=0V#ScUEhs=_ zy{3$Q@PuhFfjKXEhGJOXecG_~S9Vo0*;?K8w4n$WD2%hd?3;a?F4p=or2OGX_8CP4 z8>!%8RW?p#_7(o??aWx-RzAs~g-Lm-%H?9hNMSNte6=Q&@gNx0XanuYa$GDSH$-hl zh>nbgoxC_QAzFje1y026epDG#*YP0ZE+7_mF&0C#*)2PQ$az<~5iAv|5Bq~xAR5WO zqau36SEXFh;ZD+$?u_j?TElREGnMVKSmBdhaGKYi&*^0=OrUeYHx|zBb#=3AHNVucS zl@hjdn_8b5;uudUVY$2>^*NF(?;#y*?y6h3dL;5S=*nNxw-TiEuUVM`6{}IWbnn3$ zVV<+&UR{Yd@;`{DO;pD}ISr~34rg^>nRvyla8}SoeZpSeT@7;>- znN`X_d5u5v(CWzTDq_q{9SFbcL1$2P|zGG zo6M2-alp7-%EPzv`Pj$sX{#HqK+dP`xz!iy&4;RtPNY6qjkb(D$CNBe`7h<;O!*&sr@6)oxj_~ReKym z(Jw0utDve4dQZSo0-H93`n??ef;jAUvZIjtu8uma)*6sEXwcHS_ElNRDH!(eLrdP2 zF6tb2VPe@qgURwd%BitflV|EJA7v(!&e3#8MGhvvKYHIS=|SpBgby;V0RaTajACGioa`j>^@7{=Kmyf}k)j zhAv~2XqZj~`PB?Nh+K_DG>-l7ZjD-vR3AOMdnY<;D2;^a(Xe>ubtk!SEJ*eRgh zVPUCMN0zN`07}hsQCTMSpCgwJWs=eGGNRq(&28Up$VXe# zmiv=G12$sFM_Mz0qIgy6nsz{eP~V4|RA@07F>zAOX!tS5xpq3#yF7?NF>8;jS} z%Q!?==A~??NMTQa{K}R-kcdq<*mq`rHsB0>xZIh^q4yim8}5hn1If%-&dK17NtemmaUpo z9$RfU>Me%cSnBPlswTeJY_+GY{}Rb8WEmTihn;di{`ST=2x zIfE_wixz9o_Xoo>C6eQciuK=|=g%g6=^V}#&j^R-D8?~Y!ND3Q#I!gmqj^hMiMu6TA)_J}x_CR|_Ie~XdBEFji zm+Q{-Dw&T9;YzD)^v}hZvK(|n^^kAqh)jyS?B-`a*?SqAiRm#^fA1vzYH09ivb7k_ zMT$MGz+qpozy~3+kN><*FmzeG8J^d+)KsGfBmvgj8To=D!->;GX(bnS2Y3=`jHqtE z1Il6T7{9HZ$++$6^X%R|jKt>XvopK3rxDWA>l>!Kb2d#LmagPR`QG(rXAiCAmpijRmba-*tBOS8xpK*vU5rIgq?w2&Ph?fzr6sk?qRaiS09NY z528b1EhYZ`SPwX-*MH_0@d)q0@l3xp3}l)MkAUh>;1Yw>fRQh*mfE=2*Z~E$>snB` z@?BtZ2OBC!4_z7HhU@6uAA;F>_slxBcnz~r7k5yfr=y(;JZB@$d{sM9hVGj&{4s(c zvMtjqt7Hsn)*nxWSa6+|L*FS=j(%c16S6$s;MSI8e)csEC^gc7`{4fG-tj^{0%a|R z^5$w_Ty80qP_AnA5l9lY?rt8KaNehj;8^UaEM(qwP%$%{U7<19{ya)Rx3^9D87ii! z;W=IJg{*6rEJa3HHugnwnsh)^Hh-{Sq6T)e34cy;!QB!*tuIy~I;54(Ipl)Zk}i^Q zo#d^>%o!59M?-N|avb<6Bqv{B%E;_w8F&Z1Io_K@?Z{2rzP%g(mO@dO1%4D8B{K0&d_t3VN_ zW~sfdeygR!z^^Q*r1IJE0hhG%daDI{_O8KgEzWB&EFDL@vqDCvBkHlIT)k*&q%H>1 zTX_1ezwI`TA7ryGYp`p*q&eNg`=nDColMPCuic`B_xf+OsICT=g3Rgbx46iK&e%Ct zF4<@{y0QbLh9YP_lNU0HrI6A1ZKu1P6fFr=rO7#Z4LCh_JYJa^P)^xQ2!6}DWw;_2 zp4>x-3P1p+hva;k{msDV*nbgN_o?OmldzhAygWsa%RP%-m0CfdxAA_H69MNrY# zQ_<3)?#KQQYuKnJ0XiuGNwWLX#r*tN;-J!veSAcECI~`_sVUkyz-pCxe9iZGjrdZS zM9duC1fP53uZUA)CwLqb?)HgjVDzfSjDEo(#_-s% zjB3I%Q#c4fp%e1z0^}S9$XEP_=US*?v@atw-0nP{d%3yI`;<%VzB5!&&SKXY3$XKs zC^UkwBZsB=e=_xTp@EwZ%o_heJ0$V{P1aaQ{yr9p zgv9Xi{=PNnmVc|cvrI3Y%_{uE_^{}JH2ItC?rIyGv(wKVJuly+_kEc*=Nl1zV6IiZ zG07Vj@f&8$N4?3bMEiqGE6Mx)tRDsy_bith7BwMV)Ih8H7TrFdUk+L4n%mg{nG;o-0){mS!)k)DqSb84@evUA9Cptk(13VyM~{;JNh}CWEWXY9f4KOOsU!8v}13!m>Lgt z^*!OT#fNvd$Vmu6$a*-td$J_~br0pCjNQpK_Y9frV0X4-Q4FTZLY$9`z=Lk}@x5+f z6Oi6#xGMW>hZvh-gtfJ z3`yje*OLgMDhi>ur51^%;VzRq9E(xsiWGH7Z3YfOc2U+r=E~rh3YkJ>Wd`A#?JiS7 z%PrsX!LGkP^i`!~S@i>8q#QJ5Hv*jUd{JXBaS!-8T#K1E^@X@*5x|cG#SL_v3#I?= zIQIYMIAf64{|6>GO~=>_)?Xqj{B+!%BWL8TXM(P9Y2b4$Bb?A8rJPx$q+kVLk$&#W zcpIfGwlz;3D9_Z@AAN~(l=|BQ=aNIoZy4O_FrGxWs_U2Yjjp^Q<(E8asrWuqdwYzu z;x-r=?`lFTT<^Mr)r6Vh8Iajrb(BMJ|9)Nf%nbTRZT$fQ@}HgG@?Y=r7k3SV(?11| zwWKCn+nV|g(n4Y_sf>m;u#w9fy6uiS(NT{x%&VlnM){Bc77lTlPeA?isDZ1{d5Ri? zV5KgrnlVQc?MO3(6r|1UE9zjNW!{~^Pt2T+*8d!2w4@&dstF2L|VU^Ddp1e*bS z#yHXcR~Xn)_$RD=a0%ctB7ly+FXIZr`9DF`5`Ay!++de^8a_izaAdtMW{tjp{K2-W z(unl7LI3>wf3>GcOhEbztW)Hq{6f$9PKHHz6DfVxbhS?}h6UJyKtKZSl^fsxzE{lu zZLcgr-W))Ln*hI}Dxmyh9b_FOP7A$o3GK@kQN{D@?i!*TW@nuGN-5)aTMqVWIMWz3 zrc&L0+a>>p44W=hr=-}w&^u=%`#u@r#Q`alQ>$h8J#hq%Y%h@z>XN@?7vqC`&v=u!!LI$I>&$$tp; zgz`X%$vH})5`$ySo`je&hrW(I`wlpoDJ$t|qgxaJZ4}hG`=d8axTOprb_MNAu zNO^wMBx33z0-dI5zBVl~+_R)N`ld+bQsY-&j}bl;<$`;f#<}s6xfOwp-icJgRSbRF zU|r<=V%>~NHX3VdV1CHNxVackrj2y!;V!isHkSS)kX8~dSuhE!DJ{l_LvNH?%4*t5 zh`}`E4XWe0@;8tc59I$(w0M2%cl-O>4-L$Gc9slDaNE_J-b9uJBJ54XOf7^IO{s#X z`kPyTx~MKtb+ivRxwos)^6O24u=uFO%z(vw!w}7}wfOId%j;?<-Y0P{SON^Z{E;f(Rd54L>RK)Es*9fcKEkYBtfsRDL3@ z{J7mTN_o$KEA|qUp`sjT7?Yo#p)yTXdeCgiJZt}Ls=2gq==7nT=C#W~A|mS`Xz9o_ zut3IO=Vv^==V8R~_>Osd2Ay^_2oHGHY^}Zk3HZ}*iVxWNo72agp%WI*3d%|?LjU9p9-$Uep^K)M5hf7Ik%#J6DXstqhzTO z8Iuwm6POX0aj&OP9^ZG7F$Azn!YBQL3@JecasilKnEmV>Nqtn=f6!DIhXytTO>jJ0&!J_uuAkdm8G z6qkUi9vm@wYh|C+^PO$bUC?JdY$a!-C2_xa&h2}PK>$jz8NU63bpNMS^Hh&owYp!n zsTd_s%_nfaOSf-YZJV>by_16?L=_qwK%oktj!NIf&`&I@g&)N$+SwD^F68@%9~L9h zc@eOG@f4Qd++q{AotkPjUcfl%*MB%%b-hXNsm{kF+~QyWJWOdhe?hwZ(jX=Kh$=T7l>r~yH3WUnP4LHX{!fJf*lAU-^}OjUyy45ycLZ#t#+BJJ4M`< zP+PsLiPJPhaH%YxE^|k|0#Lw45iQF$=$~8p(*ymtTlort?&HtKpV)o+ zT#r$|FdNpD-7%O)|K}@SA|mPJqy5)WBQgD#nA!z0xIbcTkmd46ScoA#ZQyLe@`B(C{QP#4Mw!3fsW9_upAHJ00r zAxQ==T-yB#EfO;Uj05yD%%a1?ly5fKr9>!Hdn<{C%tqJgMLRXimp%>cc;)mQ{9L%k zi#rKe8uc-SrRZNj!hN4x?iaSkq@VJnzS&9(x~A*eFNwC~oE0Vb$+p!#+`j9X#)NB1 zNC_6dJ>^v?-Yn;N?5)=aVRpDr1M49lLP?1fhu`S-pGVqG7lOIyc*PEQcraBW&&|}v zAOXddo}=d={s3SEJJ=X*5r|hHvHDQ6dA_R_(82cn$mjhvu8xXv4IYs50atM35t0F{ zy+y0e040Ob5s8PdNF=DKk@Y3uSCf>?qp+aoL>Tc%k;y(ONvAf~@ayw*Oi!ypTeRZJ zcLrYTZ}0YHe5VP&?wM`4HjerTVBzUl--I2MU2}HpdFZrA5(ye@WXRLD%0`$6{{B+xD|6;8S7(wM)fzJVgE0;KN%% zOK=x7CiGR#q&Op#M%gg+GgbEm!LJ6(YKesW5iUl5Qa9(D-$OGoa*`n>8Ooe2vo0W0RPV>wgSP}Q~wNK4~`+Y01paBzc0WR%O;iHsd=Av|Aa5GCx(f+BQH;cgC%6?7{U zQ}Pu73!x@>GgY6;ksBaDCW1v8NhhdeqR1;%`6<*f!?y9a1%2!t`9a$Nw1DFW1Mh|o z+=e1e(pgR!7rM})PvkIxfuGdi))mmxKCd`M3n-E%23~QJ#Qdr};eeE@&48+V!PMDq zGG0_&k3qSn6ekD$hEuOJQg?409?&jntm2ORog+c$;&{@ASUNcBt`FL9e$aGcG08Es z_Szklz`Ep$)918|9G@m4ed;yMa_IPz4@~*> zH5Mrossk}^qw<5$tTYnutWi^q7Jo_iJhQQ!Z+ab7g0jA0Rtzo0Q3FnlL`QJ?3aA>2 zs$&j%g~G=7AJgCSArd`e>>zvtXF|)YW`2BH1Ya!j^Url3`SDfI1Hza>YP@-nvb5Fd z5FlUi1hy(YQA{Sh!>rVKde}aLNhTrS4MsX_W>I0;&C?qFjN*vX>yd8%T;9dyzOhh2 zE>_)HEx1G}4<>h}PwDRX| z+3&bFYmu`{z|=V8)S!ke7;eTJBg8)T-fSkqTGu&@7zbPUd;1(( zO!t0D0oR5&IYpB^HOc!p(oV|wqZEs&=3Nd3|L1-dI?GRiI&)enqlmvbSq<8UC{|f* z947)?Za%cH+)Uhqgg0%!GG=*I3e?I&53fCX@HS`cP80cbOJrW$w5QY&FFvuw= z4`dJL4pS=&u@Q{y4i(F@4(ZYDd6+tNEN$O--M5a5AE02UHU2EANY(s~_I79Y ztE49(hK;(P1N}1NsXg9^(}1vQeTQt4JIg8H|BOjf{PJUk6D6Bm=LbG?2D9YFdR{onvRr0b7$Q9%3OpI?X| zT(}sAHW0ntejnR2L_}ejU61X3Tz@@^EuHAhES&#jBx%TZs9--3aor-oem@T8oqq7X zdnbs4NDO*^hS>&H{p&f5JVn`GR@>r@SR*ipUL~m>+XlT^+VZ_QJ#(fM0BA&j!`T6k zMgiIv1ayDYgVuwR{$+RpZmHY$L7bBoH>qI$(RP}fhq=4g;8E<5f!=`;HD@(yfL zr@CAA7$<`4B^-)nT^EN^3Er2zQ;?8SAkB5Ox~w&>DzaJvr(_nnjrEA!Mlx>)*{Ta( zhlL90W(X=}q7YG$=xZCjrdN&;#eH={ha977X&fgZDXgK~D-87@%C&Mh9HGE&zdw%z zUK}zgDJk&NZvvBEcFP^Ep9YCMI&Mw7)1H1#@?NfQT|Vwqe7=-*g@7qb3`?AaW$v^m z<*pNG1T8yeXOp)4zMEiD!R=KWCb|3xBf(Nq(?7i0kGMJf6LVV_a**cK9?8afRzUPc z;1zeZo-4&RmN(*WnSl9(fP?JCmEwTY48hlwsrUqp3|dSz^SS1LE5RAs*Odf+jcsxb z_{n}2e@S-=MzAf2;q97UWAk@4!&P!stC0w?Dz!R0g#J3+RSI@a)Cdl*F@s1YI@!wn z@)DTSWmPocte^QbyPVR}*u5=XBL;q32JX3+(7fv$ULQ z?n`z`-oYm?@bK9!Hb)n6)o@tMA|2UUZX@YK)Gd!iI}DEtEorw(mdJLZ6@xSEdj#os zq~a7h3{FMPO<_ZpR8m3f7yKO%7ve;g5G5uwBv@$qH=CK+?w0Bk$IDf1aT;alql(GNr6Y%rV>I8zqbaLF<(39N^2djt#w|X0TJ>Gw0d6;WW*$T=l82$b-fA6eZvb@~H z$VH*Nq5OdD1hhY`ZxlqBUtO(2)d&paNjEZW32_n92zEdaTsjO~hNiwe&k`;<5nY>X zA?UOC5OoR4ej|vnCBwPq35?_->jGk)5Y+TWf-DbwgWFv%CRTQEmQet&?TTq2^_8Y0 zy00t*qHXC9)v;jIp_%;F6!tFqZ$bE8E0#5sAd`^(qvpQZtr>F6ZQkOppM%xQRUAxv zO-LY962QP<7$jO9v%#|{Yl(?aq6b@!poeE-?;<$d9rRrdygrF^8iMVa_)plXOt&#Q zeiPZPZLC>_=winXN#t{GUs2m~CwEOt$H!V<;^HD#d1L1E9iS8m!9N=}72M?EcKg&2 zFPiyYZ8%bGx!Xy@UKPIJ>XZNL#fxIlSU-&^I%>00IXinI?%Yi7xV8^SXp`j1>s}4> z(2(@SZsMfUn4QX11C~cFrY|KBjIo2KPcO7zVeL!inv$g4c4gkur$&GOc)W}b4|h8b z|HW)Bclu6e=K)4_nrCLq1mX_Th!q-$rq*)KG|H8<04K=703os%sGJfpP#MAj29g2} zG~OBV{HwKtU70b)OO;5Iu~{a@RblFK*E$*Og=0+207dub@7MUI1LXv|pK)|8vue>| z2B&y3-sBcoWuQiu$%XxY>bnftBR#>X%ly-q8W{=R=`yM`nL4$; zk5p8zWR#>XM{)Z@A#_q7ByZVJ=H=_oA0_KklPA#}JiNx?BkB>8c-*9JQMv^&V9T># zCHtKvxoMwD&!HFl*2p)IDU}5oZ``7>e{F;(gijo^(?vX`H!Y#R*p=3vok=)}ji zWV#2RPhuq`XO0P1;iX^~#f#d|vb*uu^p=Ec#DUqDT&)K`=5jnKKxFH}A~kb?Fymck zXybnVT)*h@9H(Uywq}}ze=SbSl?6tS^01lz6f1aYtU+Vk`4sWK@KffS6^)|12_bk( zRghb_){v1-G5fySuKmN+tlV`vPa>2Hr>Az+a)s;+f6kJ{2x;is(kfpe3EWY)Cly}n zVsfyZDRBpqBX6JcG|7^>4_}do;z?D7F^%LhTW9pw`ioncvT3MM7nv{QC<29u;*lKv zR$yM(E)#`cRN#HG$TodDoaR2l60C7!C$?5ywbo&1S*6Iv51q$UtQI>whH4MQmmCj} zV^YXp-`wGeuaQ|BIVUZs2%X>N)r7RNujao57oR1vUZYzF${I>7=38uEDZ;#D61r+O zDH?NJaa*8%W>AJRdAuIFIEg|U&2B`VSj3hqQmdK&^bSvg+oFCYE;&GsDO8ZvJ$Y{v z(G#+0lH@blhV8n_$}Vx!H-r``zOEs?D~i#zICt`n7ZhF~pwcCIs?# zv^ru$BUWz0U7Y3%YSy(L@Cy4gsO1jp9pZ+n(CrK-ni#0q>X}^kz`O@ZwKMi%JhbY4 zgQm<{MWMH!l8#4D%lgFM^SlqhNFL+ad!nd8XHWN**AP+=Bx)dKQ?CKadJ6Zc2}e1Q)b|(6Cn8q*P<|H6a>?ewgoKz&}Rgg6mD6%AXPaeaPu zH-w0)q=_K)tR1og<4ii7A(03l6@L*b5z;QmfItj}AyG;)>nKk1EMQh*f|im-lRHj#x(!fPxil3=D(^IsOp{e=0Z;`Tg~O83^oJt}#6ZjxG2;O`D2FKL9vfEvNd_w{TVSj+NKOjcj6nfdU zQl!>ZYq&TW6;V!~-_b|ut=;#X>g^-sFBc$m|9WlXZU2{>Fe?W1s=>(*50tdA$jcGn zwdY&NzqUbvY9)We(SVU4@udpxwOH*E{pFix(o?L+;=`+9DjQdhA_!pE3BLB9*XmDF z#+!cFPYZAA?11p(!#SCjSpH&G#LPLLJ_Z3yF2SQ65Cs7vULc46igUJuFinGrr)7AO zkcXn7e_jY`TvcH~TznyvvH7Vz)i*&V8UODgN=z~!aZFF28`ONHED^Oi;t;-rGjF#y zDAPplPz&INp(4Xold~|OSqA%upoW1df*A__SkwY5)1oKLtEt%rCOF$UiAm|&N}W%< z(&&+S{$jvARUQNM_hKP74If2INejhnAyrGoZZ-|Vzwc!N;zA~_WaU7l!FlQNN$EMt zu~FJ=-YjL?dRjN;gyP@E{@CGTaIG%nP!djdY6sfW;Kor|S|^t0YiKXB3niOdQr z7@ve%NB3Q)0JQ<@=@^6v8PZKrM6gSi@*vW!r|u4B#Z=~$m_?W=hlw&ViE-I@RD|pv zWz(dkf?xD0G8Z<7L1E{oHa#f_FQ7R}0g*DcjOaP9OSw?QoBE?PNb{{8O5ZvdS7hB1 zrh2JvwfovDL^ zscw5fXhlI}{NbShg0L5$AO#uPIvChn_x^}ddv2rS7pdo!sf07bA>#ynkgETHRh*duw{09JL_M6kC&&-UgQaI9m$7QAy&~4iu z-nNmtJ1$@F#pJ=EsrJM0#)>go8#sBJr0Ok{W^F7F8{vnNOsu%SY77=~&_E=Zl8FYF zp?!Gtu`3D@F_3^8bf{&L5q(|MCH5*-%T6KFmUb|vu+JO(3^IYiNh6(1qwfIn=plVa zC>_ZL(1zoqw*>GsTK*tii9|N2NS6_0;M6)a4)21-X?8TeSM@%Jy0UXk)}~+CxAe>~ zwVuHGM$kmxOYjv9`Nj{j`Wb6m)ejy2@n{F^gYtEq;Fn&T0PT9AmIaqlq7=l75FmLy zk-NSxFRpV-Y+5VPbZ>Cn+%q%RTa$&!o<-a^m}uEz8n*XxjlLi4m)TC_ugEK{7v9&_ zw}z|Odnd+qCZv-XjMil)z@_uxj{Ij7jbnI7SuJ+dgNURN-r7*uvFR{7#CslbFIKDUqI&yU56HTv}U#~g!N{uhVtu5O8v!b*boyvg{c4J6>%yQI-p_b2y`8m zWAV^5#k4h==IVSggjSGoE7*57E%y_PtRA$A5~ICMGz|`d618rNz4$;%@X~DKAarKy z1|d~<^-umiGA|Sljk_`DLgA!LG~EIfy3K_7q1}`2F}X@Ku1kFV1xXmY%%9ET%g8VB zUa$*ozlLk)g=In7VH3FvpPojzi}iQml5T4d9kGSMBZUwUkfgRUEt3D-&d`CYh(!vl zRcD;lHErG1I@k|}fJz_;nYw1jx>KA1$eeXq$#GiFF`x6Yb!o7AmZ_e18j#ng%Z}9} zSC#Y)DU&d+R0tYW*4QBEC@prZ2l@~vMs7jDcP`Wv$sSK zI3P-;9ognG;_OXDkPsfy&kXz}TrytBd`8k!i-9C1#J+ z**V4`;c;_Ua(Rv5JS`0b_yHOQxyJf0l|4Hh!hNy~C;fP7c6Rt?@)^Yj+?*~>gbDXQ zgE#5nofxZjk;I^|Iw;p;NWFzfS?fm~!_87!R$=6550m|QU|ltG5#BTnZb}C+bw}_( zQqvT7bU7El+SPsf2Gv(q)a9KgQCD$C+a+3Dym3C3f9sx`5WppTs2m~m2nPz}`FWGS za{{sjU!p)G4E7VJcou2gk;gcR6he{{ZfqhI4ER~~P4pTt-YHGMc%K>!v|RjdlC`U= zzVD~h5Rt-)Zrsm{5KiFWaa<5vm0AhW77una627wX!F%Vr4$YwviYI{kRRPe<;~>1C?O z2&=rc3$J%4#eozjStT`hC<^EC+Vy6LYc1NdlZ*VAy#c3u1K9wgo3dqL(vmhXG0qUo z1XlMo6V%P<0m6!_`-`Xh#f=ZYFz4&r8d68iS<*b2RwEnSX1dX5&ADIgMI*{qbm?r) zc!};)ED$g07S?%1GSnp)bnY)SXPYwgGaTKWNTg3b?w7-Fs`wV_TJ$)&M?4Tj5+lTs zV2?8@AxKJZHgf*n@k%Aewq~@&ao8DykFoT1O#!9nNi+dgxC4Y|K3BMF8JuFbidh#- zeTmszmxBh$?$_z$w@yw{3yW;y?h?43QD=kk0v~N5C ze@>Nr;0B(-wE-Ml$r=K3<{ZVl-MzK%U*L=*;t(8t_{`R7T1Xv9@Xf! z1Bal5VJ<-ipk!_IE(2F~p^;^4;+cOm$f&Bpe-891UKXymyHAg1%`pFD^Gt^KYRi9v zJI%MTeEEu0xXCo#i}v+6@=z=E0GZj)nX;X_`$NJ8ZKHK=0pE+L>38u>r6AgU3_TIaa;5rEH-b-hX>_U~V8}+`Q5F!> zF%+;bZp!H(++E0#W5F1sZu36Wyw_GrNauVcG-+nXwYkt{ZsK_v0?d9g4j2dv}axN$;CJlpCDxpOcJ<{Hrpg$fd5dFi*?YC z|5n5p`+Hbw1NKyf|6fIn|0b;{A>(}g)X11ATw>4m(YJ86M4Q@b97&|2s^%bOsw=6; zJfKn`&Xk|Sf>Z-3~^jFC%COVBj;-@K1<^ zfWx1RURUjD1A7-=sT^1JCNjcmbYs{|>U$WQT$yQm@0gU^w%e6X~h)kY+R z$;TYxR%d5GQB;9`pKZ_pK_DzL@tW)*j8ZWAI+_6Gv4D53Rn(lLd(}YH2*izz64tR7 zK<*fj!nQ$yIq=`E9iSEaPO}SjPi|RWvG0B_yOyWg^_8QJ#_xt(%nPs=f#CR`O8&@R zMh6c0T&w-Q4^c(Z9~;kCdf9GeL@Kh1mWGn$wqk~gw!XS#5_N|NL(<*qTOBJuefJNU z0@(;P9K1jy4C9E0v%0rZ_`LQ$GkM*g?CEJd*tK9V1yhexEzwC$O)-G1zmDC?r5?#= zjiGFUv}7e*Ty7m2wSxbTYW^CYzX?KocIH~%DXKHf>K#6ovdTUG)cj9u4rXWJ=~9QD z$rc0l<_}^si~Bnj$PU7}^x+bEpi`6X>P&K;o7BmxUzJ6oOjIZUb!47gyCC85Ky=~E z%*rHVyN>A?i^R!Nan9JU7z`kQ0eQ3s60!jSY$K$drDyCjGMx3rj9nZ|oZ5}@TLFm0 zK|UUVgslO)e%1$mjy4O%IMk!HDt+Fkn}P%oNQWaH4gEq25)nT~w*p$Sa&I*7inT^_kvp5ILXnZ_rX9cHwF03QlZv zekk#S$UR2;nznT3k68!2@^V5ZE}kAhrPQ|PtXt^m)6hh8e9v>$*BRO-VRKv+RYl8B z8sR6f8LRR|e#h)ZPpw&t*&Y(5y<`MHvB{=V+9v2i^9iz?je!}0>h{j}ofPRMP`xjp zKQ{xYspTifW57U)g_K zYDNep?baR)sowuMr|TrugR?MlpOJGmoOE-oR$XNyMsus0Ujn%O80%k>Vpdovhwxf4 zfZwW@S}_cSf1LE9PCuxcaBBu|j-nBK)25+8Otq}y(uc51$4EWVKZ_`;0hNSXw_r%A zveYbgRSr~uuM-$L#-oPn8l6iR$KZk!ORDHq1L>D?(zHfgX_0dV1*rgQ-Wm21)XIvl ztdz~O4U$XZy{^F~!|X>zRLc7e!Xh;Af^*_c>vc(rM>x%*1r%k)$ZLEm-6$T?-L-BOBT&Q`8XN&&O4TqrCHRZ%}q&X)08 zv`q*_0?f~#`1EWA+_(^;7^W;x(;UVUdO^c9xt+P1XW|){xd?x18ZqX6(6fZ1!32hL zpJjH;+%wdmNzb-)L>@DP?uq78J847=-|RaIcCz}+hjpi71yK=M@XCRMeL*d>Rh!5^ zk#d+`PK9Jj=I3hk{vsGDPs|GiJtb4o6hf&V;5pAzg(2eMmXdmHXWU!{Vl!mo@p#6d z&kZ|`ANbh^UDJ5hNuj3!Cj7H#;!p1!J7p+xl<&2*k0eo}1KTp_8L4J~t&5w~ zaU9VU$`KgS2A+&U1FP-~*K5Yg(_z>zIwF~#Zel-TR-<-eB(i8lRizankzPE}FfKpg zR^V*kjt=2Rb z;*e#dCT=~BOR{F#wy`}}^e{OKjACkr^@-BXT{%S#7DYd~FEgwbGO}~r`HAD_e2PgU z*{;SJ$pN09H))nZAADJx2*iv-A1X4_fxPVomUHW`_jQK3+t&D9J|;S%#Uv1w*0Soc_v%=Aj&z$^U zxV{(?)U1nX@5u`dAaR6CPx=AkVrQq!B7ltv8KvBUE(7310Js3q?&f1)^F@-nv=fkG z8+ck*axE~ajwSj;m%Gk8AaOZwNHTX(a(~;EGL!*<1&phHdB0qR=q)*xxE2h-e0jVd z0PWz0M!>0VS|OSg+-qT8#@-?wYaCs$Sdr{b&zL(u6==7!xc@z=wt-Yy*IGn&|FZk| zEf@o=-S(D!Z&Tl~Nm)}q*ErC>o#&~6z*omlbt412F6*W(p248_zJk7Ody&U8=)l0n(ZWj^2FvQ z>wC)_sa^0Wj5WLWf*)c94z!W|xsk%w?#$aTv8jTd;7z)?jkRj&$-_BVMaC))qX*=i zNMcUz9$9SpSDOx(l;)^%$0U(Sug1X>8P1l;N#2B&OqRb+?t+-#BPP-k>VrJy$)+vY z%rN>@#kYfWi+V^V@>7w2=8K@6>hG)QdBx!=xbAcAb9>-Kt%6>XgcyEyx|HZ`3@yjAu|7@inh^M)@5|xN3if#^ID{F{(ak0yDp*(VN%CXRyOcR zv$3`5LbV?tn^;*OPT&yCwJg$W@>39eZ|wm)Uysl<{DBugR)gIHCN%eVSSJqzB%+_d zov65gZuhA9u|mD8T*+$A;U--U0R=w&Y@^E@J<-k=e#=RJFt-rU%NB7F==)peN9Jp? z^sgH_+If|;(#DH5bVs#{M>UK&x3|(?NK;aO{9nwyQ;=otwyv8-rBR7W+qP}nR;6vL z(zb2ewr#W0HqZFynrp7TB6h@yb9e3sdi3%2hSA>lX;+^Me!NkwW(lbuzCo6ZPCJT8 zI0+y}!!}fnvw;-1m|ydnr|fSDjeQ)eN2X*K7Fcfjq?`&D_A&6f%6u9MD7mEW+}Yr9 z4fCzVf;Ta}{Sy5fu3Fc0W;(H##v9mOVIf}H0VN*A&8;3D1Mcz+`+nbd_e;N>CiYPc zD`;h-yF5$Uhq8;tAgs0R8O)u{)SS%QbPH_mIJMlq;OALLS_ZvRMfZ1099gsbayweJ zTv*#8e>bGD?rU-oGT zE=ww-qRhh{NglY8fwJG$q~)5)cuvbTRd0|AyVWV5^ciFZ7Qo5PJuB*)&B0Wv%?+06 zfEh4L{p>%_j*ndyUYXw)E9zM{A5IFiH*Ap35KIzB1Ko>6Y-qZ)&?+eVl+>Jk1zwZbfvmyegb`#d+w=Rb=1GFBy1CG5}a*Vo#yoeqYO|X_nId5 z;XKHDR)jZ(^TVqZ(9d_8)_j&3$}j2B0m8o%dj+)YP|(TQ^M6j~6*+f+lho6Cn*fF7 z#FQMxl*E!$75OL~C539Oia6Dj6z$mLjM6N*B+clGa_Mn-69f>nA{>KF@QN>Belu~G zViNGHAuYR4bPACah&&0*?+Q4{=HC;<9pD|{SU*(KokgEj1)Z`{4_#`RUX!HwpWQ`q ziBkJA@U3US!AFh&aa)<4h5;xQm!*WLY2CK5>eJI0g1QFVbM5sJ5RgwAG-K({|CI1{ z4o*)la6gt=<|kwf)Nfr^8ajzLf(-)9T|E}iRvUkC^I3%E!xvK4r}YJu4e35yHbm;F zMx5bV@IGn-s~jDiUYwy{jMw_koz-r^cdLC}C5>ioHqqZtzk`d)lL%Bt({@+mI~uwa z7kXSyUMS_b+@A~{gn1_jbIGOtzjV)%K8&D7&F>E)`^A(cD;1-x52VKq8hGk}?srVu zaMV|!QQYdaXfkrXC&5QGN82QGzZQuwBSRxDO>Ht)&++!WsS$I0hq$DkXUt<^w>8_G zcG3HPc`uHv-lW5&#n8J^P;%nC3YoZWwx_fZ10@wBq%cfxHgo1lHk~Z;4R;>+#!7U1 zGM_$Zfi5Y+zD}V1c>zC3Dv;UtD#$lTYyj6Aa?k9J1cj$LUDr^1^_^l$&W6mt$6iYE za90}8xjx%Bw~xwG@w z6JH6!m6yN)j7Oa;TvCkrKkE7aZ6t+)*E1S8bGtNFzN4x6#O3i!ve~qt4=R-gO!6nB zS7fH;BxE2cyjdxZ8lS8)er^yc}<wN~O8ATI_O{<>rC^OyguH>ek`M=H>@CpjU=S zDrL{2+Tu$!Ei;GuIz*6pDQ6v9`?nhe;6Guj!YDi$G|{_9gu_ZU8E)B0{^b=({#HKA zW$%+E>7%G>;Q&3`n7C*h+rC@A_zB}uR2?UCV2YajedBTTK{c1)h{*zM@JR34f$ElN z5-nh2vSBaQF|1sHMiZ4`!E>u4roZ0r0;e{tN%O3Sis3b+X*s@Pp! zUUZICG&HF|S@H>H9%|8f7|d!u=6l8>kF+KqAp(AjM`{7p2{a7=qg!|~X}_}~dn6*N zFEw$O*0w^?q&&HzeuswrDSb%>A^bCuP?tPa(_0@@i0#5mXfR$7YbiNfcrj-EWh%N2 zd%NXz5~F1-Reobm`%&z0re?XOpW0V#HEDtFbzv(SZlK&Ur?4$;H%4#YfuHeMA!v*7HOR)3_3B^?WvXTD zQ&4#zIr!~N(ls?IDHKU4_|jW@x|rSpn{)08)N=oTN_8~cudlgNhqQ(La7i;(u%8*O z-2K)j14n44yT^=a;j-=izIwm*`H1tT$X^Oax5`GhQaP;XJY-6~)p~lW!BbCaAkHXJ z7>Yqsr`ErKxap_IS4jXiL{Xxj?V&-&Xz#3X3%Sg!H_^3g26fU;6oDOq-oA`a`uVY? zA$m(V=B7tr@%@Tbvn-+tKqfjSPm+9TD2q^2VD@O;w(d9Z?v?D`dS`+pfQ`ZDQn(M5 zgYS+~>KZFhVjAEQg&Jg6Pl(_bA_Wou$+1(`A6;3p(5WjGel6^$Te;_;dlR)ZgV}}m zF+lMXO*?Mk@hel$tXaV95UyvMK334klTMjqxd5RzeHe@{KRm@oq`hC`Jo1iZrYlEg zHRzt+ryOH~!1nq4;%eigI-IhR&+gJARf#!T`)dWq6^TU(9Q-ycm|;q-TiIYK%)`NE zlyajoz8nJ+%`Rjv1S<{W8su$a_&4S#2Up31ZyC=+`s7yq%K*Wm$slJvDmJigVr&=t zw0{+gBftTCjZ;Rz8;7O%q=4A)uusSeZnr|ja7xhN_UE3_oM^5cR92`=bNH)Rwz0o* z_Aq77qf)kxN-F_qidk4*T=r(YAG!zvYYrWpNi72QrQhk#SDL^W+Y2zk`dhcj<+aF} zzGyR393%Y@`|Ko+RJn9La4mkq3~O`Ms2|4)nhs3l94dNv*kyyJP}`csvBSkG`Iu!5 z1bfXMlPbDVc)9pf5KZ3`8#`Y&dlzazP-5(B193UuFQ;3c*jTt%8GWuEcCPxv5AynG z&Tz(Jf}aom`CN-m26RJf{JC4W8|QTjF_+J)0x>vGs|qo}pfBkCe5r5-v_WZz!yz}` zP&uvx+3GM#p7hKhvq;j{L?ACdLF9w&I>Pla>e0LBh%4}7y(4WVN7eI{Ky$-8u^;f4 zHT&BiS8+Q?uQ-Sf4TY7FC&*a}z5b})YT;Z#aXOhoZM*kK<@%vOVjTewc0u9n!oOON z_4Q8RQi2O~gz0;WIs!q38GDc3_qN5Ud4#e3tliv*7X!urcoqbLj+;jqmi{W;Bxi@qP<1<>p@HOJt=SDem!ld3jwqEs41{Q1!p8MMO_uC=~)$^Ve@rj_VzU z{W&~L_~HBK#POw>JpY}a@M4r{El`6ugES57rxGn3{U&qKQBUXBp-QEd`peRh7 zq=(|Mi|A+vJ8dSs2H2@yOgA4hX;F$4V6ziSwai^0H(c;~T?1rfc!Zj@6l94Lv@*LQS&1KHs-;X1=0&4OsB-UP$_7vA>QjEr0R*LypBj5lVpX;8>HWWOBSo zjZ?fhh%0b6O(t-yMqn_u&l5(PQdkLM5;pvjkAkbByn}5K5)()lUFXHAK&1(rJ18E{SL^$$@?Mp+NHA3f%WM zATdZ@=g34678-y6ghK}?rxS{kl(+nWUp8Tt5>_aTfMKLKHM(*Di}?q zd3ZK1pSzf>Z2z=XdVw)@^V@Itp3X@n%ea2q9kV&cFpAF_N7v`7bQoS*j=i;VoKWu&|0UZ{7wA5n88quiy%yqS9Ra%=p+ zec{dE?CyD`c_vhzyCjjnfI~pwW%IV-X`w@GcWE-ue(t1ipI+<(8{$;~$%qPh+jtfi zsjc&!jfy4Edhy^-jg+ezbJpnj#Zdxiwt!F+%-z0*$4H(+X9UR@mM?QLShJM@DY<*U zNFMMk_9%Z|d!Az1cmY{>R-9Nd|L7M|9Y>P4f)KT-a=9w6@_U1W_-pF7c;JFHG;)I@ z8vgK*sZ{1!qEG-9!KH0&pz$RI?RtJ+Yn@was;2Q&4f{#o;PL!DE0~G)Hh4Pqj(R%P zZ~?ObMl3h-GI9<94p>axccMV+8*( zaYCOvpDsH13}s;W7A>-PvTmI4;iF|S`>ZY`4=G6M0676$5k0SGla|=dZ+!?;)wl)!Fkv_g%*j~S5rlLgJd>+W+#pTUsfWQsFt~cQ=clqGk57XmT-^AsHF=ulAt9>4m(If0 zLF=hA@vZr2N?LHZ&0^XPzgNzTm&!GnME5g_44psqlzx{Ks;L_i7Y)-mS&tF%G!|C8 z|Fk9Aki}I4XAYl0?Pm%tv4YKX+2h-&>McQRPtixuw`tc`U^PM?=h3a5V2-Jga!Cv9 zIcBpPUg7`5(YzG_WIQw}hw@XWl(}KnRvkGJi@o z=GO}q!aLKJ=s>jzMT3 zS$@S@SSxilJH_W~8}z7yOw0M?N@F3T)eUR3VHodmZV;R9o?U-`0UNJP{qboh`~z}< z2 zp><<_)~6kV>jTa>STe-=*UPm~WbzjkQuch~5vRRPH6+4BW(_vM(>50CCaa; z(B^Ue79_Vdn13!h4>#8^?)c|4{b@30NZy@fUvX#6eGLf$@!N}Yq*Xx7qFIHZM1!Ip>(o zy4Eqpx+P^h!uAdub(%&gYUZYTwdxt@p4HxAU}@bYeoNS#Q3(T&s~`2;PIw^GdmR(8 z&xh=j+doGsCdU-+GSa&1u=39>5!smaLPF~yqIg)f_Elz33yFha#I!In-!r)HI1XCa zNA>2pw1U;M#AR^h%pVrcHw<*HEK=pFzp|SiPCbul4@bkd>t(DKdKAY=p3045`#FYmCvBv zVp@sY5_ssrbnh#WU?@f;go7^`>eQR~6j*TcfCq0<_lQ`S(0U}>78owqNoQ{zQ&0F` z8}S$y_w#aT-C#E}g^2_W`cbft+PcMwQW1pM98Hk3_5JWN>D=06Wr!g<+GHfBw|%@uZ0@Z(`qxOKQ z!FJTkgi$G=D!2^UH@R(7l^=otaiIJ2mc3o5kx$!oh?LlE8y!)~DGE^k8MIn1kx1vb zlJybw>il4b7Qdf_PcWZ9*L+@U^A&sLgG$qVak=aK?tvM6+d~`d46#hD9VaF7ZmFzE z3u$`)4bI&-vjuyT>qBOpdrQ0CNbCJ>Y91d}yQQ!WM1D0t2ohGHO&7D~;+jvfX38{R z`Fq%jq~#Vf8^7kQz7|I-CXSbCp+FQMl>aq^%p(e>Z?(a55xKALL{T8K z7Jay1p2tIV(V+6NtpS`sq+x*^akgeBXwP-^^t9~M-VQ5ua~gcDl%dXo{aJ-*HoH{@ zRtM5tY5zzej@NSEiN{H2+7%l)>t2R;WQfV7)gB+UBStVY^JVLo%s4nCGH3avOV$25 z?ChFCQIvdrEpsWeA7K z<8YY^v(cprK`?pnlIchvA=+Hj^wo#jQ|<1bIHn zJNjAE%1<}7_Og<_c((VMiv8BkQxI%mvT_JnB-oER4RcN$R~pTXECiepn*u!u1yGUa z!|qW>y)_`1&a~3~N16>%uC+mFCW@tDFGH;B&0e&>N)Ia4!{-i9@|OX~Sd1ARvch&j9_nfxfw4R}DR0>{NPbsM2g+ zS_)H(JXh*Jbvj(Ej$B}0kt@&JO%=DQR~dvRY!vys1)_rnWo4Cn+(+ykieYdzPx8=r zZW37;7x7bi&0%{7x|pivF#ig<2e%VK{j69|tR0o7UTI(TdPjS$vfcIiHFWDSHrxoa zq}la$rrvle?i>zUrPF1(%w@gGkxyB&ribZ&<#m~kxYWI)njH37icP+ajnapUyCX0b z^(_msh9Pyp&?OZddviPPt`RWntoc>CVA%nFr(1&&lV-o-e6cRKAiwbT=Z`r@LC9?E zl}njcic!0WOa&}Dp|Yc(h1n+>8%^)vUgZXl?E+nyq^)?AnC=|Z78e7@Sxx!>x( zjzsi19fdFUxhi{>pvhjez`rfcKhN!}kX`iYwQKIUe_F9oltD+YDqMmm*bjJ$MjdtJ zki3Y5d0?6EE7%Ed^;%u3#@V!7YcgYZ4d zi>H2bI_l)X!E8Ny{%U|(-v;|djl-9@{<7`Z5Unk}#5%IUcX5DNvqOZEucCLAAdA1# zI|&VMWF#i&9RSq`#UUXLx9#8nw9ExF!^2fo5)%56cyCk#YVpUPE#~e~IM3L-a_|Qh zv^h$l_Z$*kR?tR^?boi#^XI%bCX{Ur554`l#V$FohUA)saJMTl#p%-95V1rgMojmL zbzeUF?HoCvxsthNIpu{iDAgBy`svR$shtqw>G_-G>`aC!4{z>_%QOj(=eIIgpIzfO zF_>5t6g;Gypxx}B-p;yDX@LtO>HEV4?ptPdu9%aVhdiFJms0=Md-&+WtL}vA?-KB# zBL=36v!an>rAvBs&a>fw*s*0P2j1Tsupm=Wr+ME*Vxktp93tL?@&e_q$5A)(WJccS zLFp1>-hQ3}fox1)QUuoH5Pz^1wFktKd~E8ag0T(bI)J_#!fsQ^3zm&0gIFId=~U-$ z7$k-m9YBe?g#_eR{GbaR!ccgYzBX|3kf2(CZ3B}a&L^90Nzukdq3X1KM<6AqKDw-2 zgQTxGZgwDVujZM_rdh|u1+5b;`V{5{e1Q~C+?mp3*|~K2-uHIvT*Akk0okXgXv-*s}08r_hXUnLJYr@cs0#;PTEQcHqYLKn{@l zr@hNC%3%u_ijZrkvti&a)%|6yz)XMqPZ7S)KUb>UcQQtf&#;}sP`#j`lGDw_S!U>y z`QzyM6Bz^K1b>a@G}RJCx79!q-98mo49)P93xe9`d@m0IgO{s}GzUuKYRs)qQ176u zl4-18=u_AA%{X_w1C33yVP1uRM0HuZWqPYk*=`D>sx1`H(j=;u@h9RId;YdEalN18 zudrexH*aAUgi}cPArPu~eZ_vhY)Qv-Kx+Q$70fJLZu12)Hg-G>)E5L2J`_~!3wGO+ z3D+~BQK7Nel9vwj6`Xnm^p`a<)Ri=A@szU8y!Js@ zrc=hxO`@cdfUEI|TN*PmdFQof)B7^n&4aCaj9;lvdSB0G5!Y}=dB#R3&|@2M$nOBf zz;D$L;kTT`Lc^w-~s?aLJ6WOY ztg|aWKUo#Phs-{ES}1SQ=ujsm7~Z%5KSw`lDW-wofq97V9PbPDcHp9{AytTZ7Z~&` z3e8>p10M-ZRF3+=lN35S$wn2Dq_&g!Wqpy!^0Fjmmea$+!ZX!wPka!|*6%jLLEbkn zN=N_6?WFg4bH!&=c3beYnZO>3O^#2ZlVwllF5PqNCU>*W7|x94@K+_OSLlu8P9B?` z2n9W5#N)l@tMx@^Eja|`zGVIf#(mMvA0gUQJQ!BgTl(ZqvG(L;)zomuADVtmt(&3I zv+kzjz*EeiJ5f4F`sw`HZI#`l5Ouqi@RIt8?wnFpvx#z&<8-=sZd<&S>hTJY6zZmwmw}Pu_DJq|!+oOmxnO+K z#ybQ?;xWl~2x0{EnL}Z}NWY{l01ATL~^ zc$Niu);c!Gg|sLws13J>#k$T3zqvlYQW8HL%a=I;B$3ZC%!HN$X4po5mC z#v(eG4JkYr@Cq!F>D$fSTa6Z)Vea^MsKs+7^8`8cQ7^zhOBoK%gFlLfM_pmw{7HUz zR>9R$G^H7`TRECe+;mTyG>(VG(}TsNJ+QXV1(;5&s+uBQf_C(X1Jm@bMi-ZikQ~nO z)~XZ+a%lFhtBK}*jh?p@#X!L*+wxUI86`lB?+GrJDmrF~L(!k4mxrtbkUNQh3aP77 ziSI+vsR#%xPDu2nUwYc59va243^Uqd7>(Wroe>{$W;oC#+MOeX=HH6Cn0pagUsLRz zuHSl*vqH==NK_O6*NwvayHmNd^%u~#dQYA629pelm0?jp;J~lxCW5i@GGZF{uow96%t{A#Gq~7luY=;e`Xu6CwBX9FHC?t0V>{2*I^vxLxw83S{#Dq8%_Y* zgAEyAX6uJ-PT^1};t9-Sf>^|*;_}%p@y<_+(qiuJrr$#264I=bi5oQgQYun7Fh(Lpfp75IiE0h)Xb9BP{hS0=qk7Xw-7 zoc?mKYBed}wlBg7bZp8ChoEh@hRE8))^!iLt^KFC?Y} zCw-E?5kVGcZAoOKu2^O8NSZ7+4wl{^s1>zLKbuD%d`fImwM_CrK_1>Eb$!ovdTHLc z1A+jKN?O%Vy7kYsu!%J~vmFWOVBDr6t#-0iYHC+z4hGE&DM7dQX;Sm-wRg8-h@Sg~ z2hTtsE|!P&_4%xs$Mp2q94X7n56FmYf%@Dlj)iFyGNBz_Ha#qz)*mL&&={`S{1f=* zO-j@`pTav5UOg^OXR79=&9iwU`nSm&+{eL$NcBoaC~Q`6nCXR^K+=cC&9_UMo}T89 zS5J5I9-b~&%TI6PE0>W`I+!KiYyGQo=11%^@_e2kGwN*p^cR%rnKkL=q?F~>+!sW)4dT-n8etP@Lsn5USm@`?7Zlb5 z2%wn5s2ef$@eCqo(RnO^=#wPO*5S6gx6Q5+Oc(YEwLv00i1Hpe!@!wOVLkgYJ-mg5 z+Fb6qP@Ugam2jq9P)}@Fc2LC#_i(Vpkc$wGrBK{Zue(XO7&|+b>@m}9fIVqzC>%bb{eG^%Da`~KI_zH+}bwn|G-vqxQCG8Hlt zdVZ}CHC7Ye3D(^<`=U`W*Nijvj{6&luSqoHGV7@6gZ}v_Fu1z07dX0}I{Iewvm3p1 zltC^6dzS9;Sx6sgYD`1p2xD$D&_-gUTJF z2Osz<>`aw*u{eJBk)LQtLKXbG2(UVc1P8pR(ohGH%4I+2aEvF?8--3{{4Xk1Vj)_} zNg$LCP4KVa@WK2CL+~wbq2SJs#KkcXX~{{7vay6F%%8*wejsBW`VIfW5du8*L{xlC z2*gyN2l!M#jLs2E$Z!HbIt{RuQR?sgX~8HO=T{)(F^eQT#$Mar@Fx;b9tG}3&l02@ z#}y+a`H!K6*7VJDt^S2tN~M(NIS2OR2OOu7_7rCTt!Ynmij}mR6O>1YM~H+LJXrIe ziKHC}#PKdjc%~g-^8XLNE(;V8S3rSLA2Tw3t)w?02E1$#A&sh-+w!)oC7=WU*|mcQ zz5)f{b2BEmQ``f86wDb@>~IM5nfH*X(ejy=Ho07Fte$9*Lh$FtrfBxtolT74tw*rd zWo_@yUAZ&9-aZz>z$FY|Yyk`PVRP?-NdC_!iEl)Yt_?3w(LgdEmiSEDXjJsP9Jh?2 zMV0~0^}$V_fB|ge|8nL2>ly`txz#R$RMI?Xa@iY`l@sWYM%bM~ivDk|T?leJh_4>LMRg`8oVRiWULCKe}A31jj5G^)4y0n7k9HfQhUsV z6oLt0T2kJgGO!lQ2?D^zs5fyxtjrG*E>n)gtkcp`7j1106B62h6%jue46lGA&!_SaM;^L2Y-M&NGw$k2MfQt|vK5mzK1r@9A z0wR0}us%wwbg{6OAkz6>cv-c1%+>Ac&p)6_E;HieqoU)JBx2K&f0^h1n^68UGgt=T zZddS$`xzvdyi+;x91IP_giG>bBM0bQ6y3;s{4+un%o}KDR7`=0NWc{KKqD790SAz@ zP1j-Im+JOm=Hy~0^54k8&d$ZmsSI^2b zgP>;b0%YI;#b6cQ3Apf$iT^s%bD~oe(m+@>pu4*uf&V#5C-qU|Gt@B0yq2+5;z9;1K``$1*_V9mO%j9Glqgnt?AP*t6eqya(y zFAiI@2mO z+zGE{8s77`q`Tk!+O72ZK0W3fc?Y!l3b*$cDx%=O^IyMdM9k&4uS}|or=ZjO;^jw= z%cPl|S(o|0nX9Um8S#Yxr z+rB&Zt9e^&lW1o)Frh~@;$-8KR*~QA%@XTx5c^?fQ=tKgI4#HKQ@rGXkguqpb0+s-@ zr76oVab{gfL=iU~$%Z@zEhKJY%23gDp%a0c9|;#$F6mR!scDz2tNUH#Q1_7B9yju% z*EfedH~4P%_}yvLYaX|YJd>Tz$Nx|*y*+tf9PPfAHXt!fB|#;U{1_yZTq8%_el-%9 zaRSr&jY_Zm3UloXt4OP!-Ym&( zL#^V*w-;u#sMSL=m_BHw6z&I6T#;5K22Q?VtDbq0&f@1Y(p(|jH8%cg{3k~0(!?^g zYKI!msJWD;1Un6*LYck_6@YrtlWW-n#?@QQXcit|^aG52Dyvf@`c(mDQsZFSq2p_+ z0?jZz_sh;Y!J~!|d9L596Ej`ne)(}q=I>Xh%Zitca!QXabA>H6*5*&1KO?nT(MCN) zg#MBg#FAzi2$eW5GtjncA~#UO62m3A%yH?r(1@3d_T3pn7pyjX&WPu8K(dzK%={Sd z3mOnyH$WPp?4krJY(-xA2}jGrA;Wr*oewh$Q-XbL3-f=S^MUKp(aW-oo4+m*PT$^!IU~_Ho1K zJpKv)PRiDT?aCU4ae|6Ik{0#<$1*2Qb$z2dQc)Ig@YsOJ!TLqR+<-FxznvKA@5g*6 za&B#(sX_5`-uYOM=#C%DaJRCDP zSZ}fLU!cbm|I|AE2FY+qrK-51zU1GQ1B0=V${=G@lML??NhcgrZFmQf z`ltg>iw6Uwg93?3scuF)Oaa&uzply@jf=#z6m{h?U`7R{ykZDLr+=p?25tPNQt}?C zy_kQTf@5&f^9e+5EMz&m2N|0aQ~+8-%a1~2?)C&Tdn&o?vHpp? z!@nn0U{14#VVlhfZc%KIw^;xbO2J4*<}q;iIMM$ksxi?i8&X-K|CC*l(BRQ~!2kV% z0W?zC|0&5BGQo0AAj8KE|9Sgc^gp1@Q(+l&b6RkGdC3`Sg?WGahHz&AZhSK%8TtaR zO#ke>Y+z}|Hs%uQrqX|C*3i@j%xiuU!VvvIWfbC*(;<}f^GsPE!E?ztT zfn@akiTT?9zh*Yu4s`Xw?UvtN?F;WX8v$E3{BfIv+5Kegg$ppJA|Nfrn%YlIE2w&S1kxQDKju>=|nCE$%| zxP?>Lh#Iqhhho8a@daU$=N_yx_?_>jXT5ulWQ3fjTc1>Q(~Ot8&+i)O1sl0go1FHn z@0I9R*sDr5xc>q~&xboJ#s9;H)}?H)dF|;v8o&C5l>x(%Qja#7X^fzfkd_j!8J7+M z5RVK|nofKi@Wib+R%>_k)vs7h)JP?WV4z@MWkqnh2D{%CJ#dK9IWw>NO!0N>U|R?Z z7)t!Hk?6Lu0Qi4NMiH6jE@2WI%g(spp$)eIf#zw!oPhet0-k+# zppox6usN_;LsX0c6VUxcJa&Amuz6y(tY51p_Xu$=;i&3_<;`{VZ53EhBT<4^JJ`h_ zel88Dz&yYiPv|Cxun`@~|5R67BuoM;h5xL!0Vr0N0N|~@|8ujA93L5z1mC~>jlygk zd?YLyI!XxTcKJ^X_mj-va6|vu>X17eKcCMX+_~tG^D&4zV%Sv(5ROLWF9vu4AYkJG z$~eK1gZr>D=TWxN^!v+Lnd-^mGPZy?Q&jwTyd)hjeId_gm28wX3JheaD6Fx^AN~Qz zo>hui7v%Gsj9pW5iKA zj>JX|3qbxTR@wy#-JBsyv;?OH&QcUt7bQSb-m8G{7)*qpGNWr3ZnWKg3yk=U!dT3Y zP?jk$NsMFeugVKfqc2I^?=L<(Z~oiI<8p$CQLl~hMi*3^^QVF2BD?|xcfkA^%Q*UQ z+Hh^xv{CpOIz{tO@NQ+<8h>bsX|Z(ZE6T~-<*jB>c4KaMw`>!gAaPE#@cd1vYC&1LIneYwBi~2++NzE^Rwo@5E&R_&ZZ^Nq0uM3 z>do+Ajw%tXZq1-?P+h_4p``>)VWduBYk7Mg^e8=#*9pORDn+H+4t7%7h10Z?D^ z1!-@kZnJ6gYS)>dz{b2}zj<1iBzT0Tgfs0cxQ^$~Rb192a3xf1CH!9Vy+azu$!Af0 zS*@18SW`9IkBXDM!c#U~PSUMT3!T>0%YO*7(-5TQwtTT@jWx9#q4}z}7;-cpU$3#K z9@UbGt7CEdgjUOo8+Qoe_=`}He>P>lEyI751hriHxWN`M|22|N7oU3JMZ6St?8ch2 zYO>*RLHvsXn#ufS;Ya_Z*9gnH$6Jpm5%5+Hh_m4-ks^5y1Tw_C8NxNgT z!GgnwHx015Is3XSZ)%KL$(GYTNBsE+f`18@yY(157k!3} z{yjESx;H7a85P(*G@-S;aaOV9C(wHgZFnK#e|~9k07{Lz{GW}(c2xQ<7U@{+VjRZ< z=t(1dpoCgSSg-`)@%Q)hj0?^Q_ezQh0+KjaOs!HE%`Z0=kHJdoO^{!-osO}f<;)~3 zGytQus3l0vUE9J2wuoB&IYd^oICt&IfMRL-B6qBW$Pm7Xm9BHiBisFMkE9-@D5hUcd%o>nUgBfD&RbEi&aA2Gdd^#qz4fhPo@|ZEt zWRsNBojs>{j-a9#2ke5-AlZaw*2i>O+|^CmH8FkEMB&j54wT4dj9I$@u-GhNOvoOJ z-tg)vq=VL{xRXqn#<>f3h|h_JJFNCXU-msUrs4jvF>WzX*xgam`Fx0k{DWN|G|<|< zU9Faq*4?2wMyS`9siIwrR9if0d%N}nv?~K1Vu1o6CIS7a$Ixny1r8qgXUWwH{#l!5 zcmJd1mVjPioC94=e(cv`fIvmL5I;7RfJAG`rJLV=q3LDKXu_cUHMFRD_K&;ZScEsnOy-l^%!FPV4cc{+ zyl^%YZKEfy%yybluy*zvl%qq~#ubRnoQE`LOFg398n?(Q^F+U2V7!OfA1vhWEPZm) zLgo~f?*7=JVQ6&2^f}+u13~!6MZn8m!MtauiS3eQf@AOe?KJ4YHpcz28I8PqW0P~n zxr2;N5|+w=Pu}Q;0O9=7ZO6?E{$ME$9>gL-A_V&)oSONZJ7?h*wl7ezWY_K*Dpyxp zFjBIc3`f!C;%{={g|%{Gdo!cYB81jgFbXFGV@K}~pYX=#uAr|6UKD`%_bw6{JI4x# z$cZ*eeVK#cHSE`rYy7$2A+25$byJnmd#GK|tgokMF0M^lB`mJ2tgJqH1j)cvL|P~( zMcsz-R@?XWv+-_s-Xv71E9CpTG9uR5bk(G~eP4S#)mWypW2klYaaXXQ$QB8y9 zw#vFxodkoMZKG7;H{xx!!I+o#yL@q#chUAl5^u{UH1k7cBLE^78i$I+p}btv=?imx zl|6k8WND29tmTNzWucVzH&%7Y(rByU$#`Xoxbndjk88D5!Fl{ZxAR_xFQ^{jj0wib z4BkijnkUSU%p+4Tfo*(cxKOmko?}7xXm1vz-ZrIoD83{WOu9t^)4RBW;Th zP7?Q|i>XeNh0X|6vXZ?yNid_)V3iIJjNU83{0J}l_JP3U<@J(Y7}3~SjTWpym`45i zT}&VtL%`s7RTZcq`G?nwSm@g9^UsIkr-Nbt)6>}lJ64s>oU4?)I!V?pt@|BTJ?&cS zR#}^9?HRMzs?38Vmg&={pzjfh)RuGJ3iC|z8V2X-QrGi~Ly5+AceGFrYv3*)1TwL0 zPa3BZA_teinmdR{OV~2f>+~n`Q?X4_ljbRGOp|70$Y3+Q)+_n^E&0NUb+U~0ft+uJ z_vfed_NHWCkmTey0qni19B0?O%IR0aUOVOTC9%hY&E-RBaeLPNQ*)MC`?4(`muoVX ztoWvRi~4mrTaSz@dKe8{*FlyouaWOZiV_)-=J~2>WXXI9D)J-x%kaoERe-n$ErrwE z3N+^VJ3hhF7a@}_;(%y4HZjq~L;F&mP2#zU;~2<7!vs=Y*RI#oa(<{`R!xHk#od)?9J!y~jJ zw)BVSu$wN`7R3a_CA4$m_lgg*d5EB%h_BNl-6>=mYlj-TQ$ey8TfS7~e|jS7S0Xai zL&Z|ajPri%%@gg!BPl$eDBHuIgw{6QMMkO?HV)$%CJ|QM3!>BdQT2B0*`08>E@6q9MJQsqe~mv&-8@TQuYeaIE z55gAJ@sRyae8HAu>JzE^%o;(Wr}d%Vtfd~&A+^g8ohaEGX(*}QU%1GT!j#xgp@ZDs z_M-!l^+iQ{Baq9?F`JHy(S<$kqL6#DE7A(1d!1z5{xTqRpG=S~FR&K<7J8PL(Bpo7 z!1GQSe_Hvr=K2MjHuWaW@%MmdFhcyK0i;+{+ObK;X{!_7N$0I$5(@}U<0pW)Sn z%>X`P=R1`uHX+wtfh$$lO5_T5BkSgPwjuuto52?PiQDk-07ySnM89Ac>JMPcO5~ zWdcR&)7OEMwC7E(V-c(oUB04HF=ZaO8(6uR&sd34mhs_+K-7m>^@I!56zZ-B1kC6v z_m!>}DcvFx<=+m;<>cQZbpDY8`?|3L4x*Ro=#)6kTZ~*>ZrrP4EgD*q&R3cg{y1w{ zZH;S+jlR;{xdiPupl+E>8hQX20J85)i64h6%TEea5{-K5jj^JusX>G;Cr#I@zNaZa zV)6#DI8Nm7D$cj7Egc|YaiwUUE?HA*kX4-vzK_}n*d5vh?p=xq;Y{QG%bTb-yR4mY z*9l?x1!9bF>PaGn#A&~w4C+LQY=)K*+#UL-VD!q)10t8{AGbX+icrt9`-4RT+hwG% z@sa2oJcSlWVg4TM#(cJns&~|JTBITrQo|%vBy@+Sm%!lDZQ-qm4ob#_@J9B1YKD0} z5X=cjL*XT3*ZW3owUAXy*L?^P$F(B%Do}O5;k8iFUoDbGMLhFqLg>(=;xyHCMMT%hu*F^i^2f;3*+qwJq~qB@K^}Py1fon~Lhf z>*#03xqs@W(`|`0be2LvMus>HC>?QWb^g5lUGf}2-A#4pnH=W%G?PCHv(h%%4J0!d zz`Y(1d*Hv7@kfs&sO@wm*;`zHBgB1=m(dKm2icAL6+a8y)0issBjA;2CkF=yE>zEa z#>Hyo{4Sh{D}7|wnIVK83<)8?4tsjUk(V<~w)obIkpmZR#EaF%0&t%aVNdB%h0yFN z=mq@FAzz%t5)$Ta!}xOWUb}0?;)WB(BtNpv_8qZP1VJVkJSR-Q%m+*ej=maXm57@+ z7X9t1m`(~6tR7)^MmsvymH+f}kO4VV$N%iuJ>n^BU@Ao$3MY%jf&cvxQ;Uc#CwsTs zH;jg~-k96tVPUqcnos>2KUg3k$;D1O?zlCV{^rBZ5iMl5<%OI1f>{2W_t(8WbA%8( z84=XF0%8xj=6c8sG3iXbwgY!@JYB~0Hp(=Lc$ZpGL)KrfHF3x8%77%up1wS*KTnIiB{Dw~Nbv$eu|sA~hw2w{Ar4*S^hJ)9VEVq*S|G_0k*7rYv?;)v}@j2iL6 zdHdo@x6ysrP3j>pnNFtnEdf`{Z*R)bdN}a2o4D|U+b3rg1c24@sOro-E*&8+m_s7? zFQecFRCjT6CU%j=@V30W28bVsR%PLPQYIH~sqWoaEM%~4MpW4vK1blp4p*bU=h}y+ z+xRVb_bu2Z>?0k+TCfIzkb}F$Qofk>B^OVHg;=4Sp&e)pE(fbeL>{*xhcp&#g0Ll7 zT*%syGla1(a$!;^>m_IWoG`+0JYBP&W4~c0R%Vn}t}{H5+-PUz-}~DbQ(yis{u z*j|`(ya3XrY%Jxz;wf1P{Se?nT`e}Is8)G7S$|~NwhlHWi*(Ke`Sr*G4sYxAH;uVU zY3eQ{oafVz&c2C?PEy0~oMv~{qx8pCM1qlV`zL9%2(UD<+!kgJX!kYPP>fjuo zooSeP=>%P}mXalqbvv1g#G;npa!sR7pOwqEp88c~hMHA-u1$^Std5P=qzqmIvP7$~Y*yCn{*~6Rdo_=Kz}&0mI|QfGE=i{U4|8uBTt}1a zc^|PXX0Vu<(PCz1wwNu8nVFfHnbBg&VrFJ$CX4qx&&=$^#CvbNA2#;Jo{uLwx~jXX zGPAlefB)!(%ZrCB^}`@XC(H_7NpF#A_2*k``SLNd90tjakJbZbK<;;F&ULpMfA{@5 zoe|dKz8JA8iCl5MFsK%1+dXK$v#Ck0-f}a9<5Hh@%YY%PZK1FqAYzMO&>OSb(1tmD zHCPoURN3a)?5`j=*`}jbe5qk3p!G?{*OWyB)ti)`(S9uoq>s!Bgkbw~=veuC=`XQ^ zw41;>ds(S!L&>Jj+IN}s%DZ!q{aD;EI4k2d?#zE94QHOx8S_!gD>zTeXAE9IC1?{> z0q13u9kH5cpP2jwlh+IQasAt~am^Huj92?db18ogtAsOkM_FzmEDaY*MmcZTp>nJ2 zQKgbQKi0D3^kASje_3Bx{f;p=N7`hlCD??nUtqX_Yz;}+z3YtK3bMpv%MBp)^xEl8 zbH=Jc$j3ruZqmA6RXEaqzlJ%xJ@?eXOL2kqjerPTdq;gYq#7O0SRqOoULf-U{^H## zPjrJEthn4MmTCG5TsD&lYtJ#y?$zzLQv0)%BKEXvG2?2>78RF#jn?^l7|T3Dg_Cb% zMFs1uQG$7_(f<2Os3L(;l@RBtC>HBdvPXlKw#nRQtM%Xz%|k9s3S%O?tGs?1pas0K zX@11;T~A0uFff-s@#{7*m1r3_VN%=e&F15B$(x>MZ@&Of@4!Q`#*skvsz#HaVUgNb zk%N_7CBI(^6bGtB3B=%4u3_I0l@fj3x03S}kOkW5VY3UDWqsZbc5mbH5D?SO_#^l9 z3KAB{;>PlLn{#gXKd;?Dv<02?szsse2g>`)aijOV;>@ID>ZC{VbrM(djFHN(tLqWn z!Ol-P6y|ZtSLuAxg`3g-E8_VGv>_(|PExEyA8d-Q#e6#=Ip&L%x~w7eB+JAdVU} z+mY;a)+)zBnqkOlRx*|B{CSG*ehKkV@wB0OPZ@>jpAnuHk8N=f~&SLzGWK zR%c0#`^(SH9eXz4%R(a-x19DB(}h*&5<)+5KGG^M^iR;VI+EqeN4FR_k_g(|$q6v` zr3S9R;Nlb^JvKF+3jOhZl)SF1d9o@DcgO+7n$4Z87p^L9&50Me2DL=aEs8!L@cx@! z){y>%3Sss;58lqoqmO8ZMQuD*Ud_Oy)&U!w-A94((hmj*RGta5whFE9wnx=2FHq3; zdTK{fVe!BNeq9w=8Q?*z+-Lh5u>_@pfGaJUcDVH#T@WN2m5(Kwp^S`7d=5YA603A_^ zT%2?r#$R^HT(0=^RAcC1Fh$|@rF}}G9E9?|!(w6PgqG>QiUYI)-_iw-MFMQ(P}MmJ zr38~gjl-y5xsql>6=xEoiYKG6w!YZP&-;qysV8saqOlTxCH;z1(gEL;P*GPAX&|Xb z*k-VIrlyaxW+cbu{Zn>DsR%qtveHy+j)aORjx|h`&;n$RB|*70tgiA4A?NQMYHAI0 zW}-r|*#d0XEQi22PO-HgVqKLO7*vu(G`6~Ga701e(a_$`j@u04pu&>|uLjAqvkQq-ukJF6WT;mDb+wDUPK35T@h1vie8EtW zLX5|TVA%6MUWe6Opv-Z?%yQeyWn3L~)p=@{z(u@8wYwr;<)F%(S=QdriPnG&<(22? zCc1=8B?7c(Gb)^7j`PaKF0E2lp164sTr=s;=>57bi5V!ZflwJ&e{Zam~HvaI856$&Eam0bI zY0i<1JbFgyO!Be?kAbVO#jP{digwT#RnyWA+D?3RbL} zv&CpEK-VImtpCI&r)7`I$?wMxnaflCh~SMPSaJTj@Q?ui-eS+3A}LE=!aSrV28ziA zfG(175@F`vEbrM9Fa{9HcMovU&dLYS(k+cyDY<|N;Vl2aFEYaI$KnYLBZTHbOj>|ww5v*^v*9%;~Td6s=vgD=m@ZR4GDJNfXf&4&d z&aWVf7KZmM+>}}%_$8tiGoOxdR(IpmP0i8REeTXDP-?edXM{U{N3Vs^J{nd^7)_^P zw&6+RF+Hc5RYJQI$sk8Zk*ajP+!8(&RBWZ04JG!~1+>%JASkKJ2t|41T^Ikt@|oRV z*~AA&S5g_!Hj0OP%-SVw^mhci!URB;u~5U{R8fHqe$#57V<;VLo0AIQ=Wa~wB4%rw z%w=H?kXrJB%#_q*`d}6Y>Bm<()t-ON18-iVBV|zqRaXaLDdb|KS73lcQia1ck%)|h zHJ`*SnUg)76FY>|9{DwQFj;f5e?3$j8Qh^`nuC%3I8Kvyn)uZ~{nXgD-e>!D0FFny zYPa2?cOw6qw;!Q~E;4I&Dj@cHZ1$mz(YZ%?qQ3 zZjk(@&VR(1J}Xx;bDXTw>RiJkA6^k5SQN4xuZC`n^9I6=pIRj%diZG=6lbhu!-J;RW-R^^4UUYTJpNxI<+;p2rPeQEjqczon6=|&=HEZ1w1 z-O>bwhZlc6+38#{iDtg++0P`Q1(U;~LbbwT0rbh~#!?yU^`5)!s=F^f8BjIZfr;I| z)Z?-fLDcSX_~tE_#;xCvF9HrG1xQJIi=oj0KWM@} zp4N1I!6ilsEM8($Nio_Z-rwk0Jvz(g!__O%tTZE*8Za-3WUD6}NiM7@u1tQIdf2om zR}|+rzr@Ncx0S)ts7}mAdb#y#%wqLMF4WhKyg_*WI!M1zp@P$9r28;0#5hSi(i~Zc zT%4?Lr9gKAA-ETwzhJiU#cRO!7>cOU$N01$!a5}rTt4k-UbkM+vS>aWgqcuqQloO3 zJ9l8H%AJ6HJXkhTuNS&_toIK=VWq4j&UPN7tDH|BOWznNr~O4QI|fTBt6voK!x1k{ zJfhQ{+)$=k^M&IrHp3JG(wy3Wnf=eU8xe0+?n}-*#428LK8JV!wMux(&#V*u0FMk8 zlnoCI2GBAO+aZKZxNda61P|EE^?&?@Wl!C>t>!7Tt?t3A^u7E&$-uEmSOdJ z`jHk?3|Eu8P>>)Za5yS-*Mt`&88KDRjylPN&$s(WUXQ28jc)o)3NSuho~F@4CuP+H zdhJ`S6TF&zGh1JN)Ub9DdUegABdn7kW9vGNTJWgE{`3cg^t<;iu0JgHofgiqMyCC< zs0IEc9{nal=DY?ps`zinBz2|e)v;=_7cdHGQIiO?#A6~*K?=R^H(FCVam#XEpN>4( zN_@>ZFlC&#ozGdN6vCFqcc}}UzhcjF9E*+KWX#-m<5)JzASWI1$rm6eMa18oHY4`m ziZ*f7Qs$px`S-erYLR-0*h5w$Y*GaK2PTQTF%3xX3Z zi_QbPB7cPPg2;#7wlG^#?+M}5MP6Y2GRs5uTvwlM!(iZ0fH&zhNZKa*IB@y`wNw8a zQ@OVn-04Tjc(#?5r}zYXy<~!B{DGAwh@}L-)_#(xtlB(IY`rax!_(JfL3umG3LnHa zFHpC9Fa&7TQi@!yQ14W&IdP?I9A}DUyc(P13}l?q>0J5?4Ni$9D8yY9JKb0>t#tus z5gQAuie&@au9qxft}?|adcpxZ6$k@iYrhZ7;%x=JaJr?ATIfmWFLrbqBWF?5e=o=2s4xVpw#ynef zKDsxZY8;*i_{M;yjQ5c&htD-oy(kQoefVz}Qq zZ$SxLGFmVe!#4Vd2snsr>1Go&B)eD8`AkpVTDoAPlX>=Fp1tvNrr&G1E3-;l%ErJP zmKC4+I#UGPlJ=e=JKYBiLk`ujq%#M_ME`86ip^H&=B1#<0X!k?d`;kDR@G{^Zzy>K zqW|Q{gQA~8-q=vi-Qhdv#6Y+o&>tiLaV|m$?u`ccGl=Ni&hp1CcXwEJ&PGD%8g@Su zpnBFd%0e!XoXTCntVsG##l}5gV>lZB0Qw$--6y*HROS`C}N=pRj?oMP!SwK?Svvtg^#{9OeM!(*zobVzIWZO*pHUMzmqb}9*-U9$P zMF%iuA$nakI|iRpfFIA11(y39sFJwziNh{>QfTGcN)EPtjfdu+;?_+0wP%SID8d>k z=yL?{5I#ADDuAWMZgtlf%9{ToD!I57i6Hf5nlKfl=9?hhrr*@I%O3}CJ{8(T=N1Sh z8$Lq9iP+z&#yn2R$U^ZCj71s*w*qAZ)vv#$d~&a3>)?sUh;+Mo2t}9N6jQ!9eEkMs zUGD%*^xmt_?RGrxgiko_)dE%*EUjJQ?q3Kx97k?r+>q(vYG3{lq4vkF+ZLoxT#Bj# z@f~$PB}6F>0Ws1jw%Oa~jLYmfU$ehExetGxD7*JpekXR$O>2Jvv%R`&eLa+4#=vY| zv^?tJh=h11gbx#hJ&`3NA{`dwO=H@IGE{#r203x<{HWpqe{hAhj4ZdYcwCMUx(z3D z6Ivzz#&b{PZQZ@ey1Nrn?gL2|T3zalB>fv>$#O$)eXo+M9n9-eZlgav~>gt zh0ptr?;FOntrCthjD|$2CBA0>^fc&>OX)F2T;rsj=J;|Ua1Yc7OnED|hY^i-YgqO}7lwL{xJM&uy1JI%wQ7LbDZwfPbE6)-|mz-7I zTRq6GJ@Av^V033kY-r)0phc;Ykr)(62Dm0Uat!FtNu~I1C%YyUnIqV<@pz4Fp zL%y^ov+cKULCC7;NB(w<6tkpByum~R4OYL_B?9f^_B*~Bug6ObSoiB{(l!y<9CgB^ zE-q^W_ki?tUmw_t@XqA=0|tqAHgV!{nk-Fo%-Mm3%1Fmou;F>7iT{&rMsr&8rc+!82iJ3vm^)(M`VoCf*&_XZmAEuzvJsh>?KXTv;BjCqI;Mr{zCtd-2+vKVvz`AQ-H39BrjD=)QYVs0I-9V z{iO6epS2If&0=m4dzC5e7Qjz36)AGC2I=kF-BKB_;vu* zaI3zhFA1gRRjW|j&3*b2Haa8w3Hy_N909V35i|7h z4SCOwQM5>D*yJ1MDsBYqAmO4agH$`Bi3}xp?LA}JfS;T`dLKq+{`W+gF^XPT&HSu; ziX~B$5v^<)gNf&@bQrz%slG?X#bIgUFxW zJ_GoQ{VH7x1K2e)y%a9313LG(OR!mXnr!W{z zca@Ha-CdNHcVyr>t!c(s6m6n{71gqU$hTL)$)sTzvI-Nfl>D*=L$c+B{)`4hHn{3S z%ktk2Wl}a{d8MOD@S_M6Jhn$YAah zyfLC5B9g|SFQ3LPvLg-UfW3CiTty3Jc^h*ahVVhMMssc}ykByvFzb4fr0k2`vp#UD z*jtFV5luM9QI7g7lpOe>S^DMv(@J!rk za&><-2SX>;4*yeUwTLq!j0y-A)nRo*c+2uHi8;^jHl)!=tf!Ao9B!Z)85Fyn7iO|b z{FS_0PFXWk%1%6?=+xeyp@%$~nQ3l}oZ~5Ur;yO3Lz5n-I_A{=Q}UpaI=aiGm$x^#gVkhF zcnSZr+tlA$WnmEV?AyjCQV2XFk0Hk3ZrK5`wM>57q(<8GF$8!#2Zl#lXqkd7^N?ac zwr@dOc9{hcAUQNzl;!i?$`7row${AiTlSX(hJquM5&HKMP%mt{OygYBHafr%?@F6A z;Q{>-ZQ~~PS!$xzm5^SnK@N_{P2-54#t3nN*yL_8T{Opq%0>88k?_ug?W*_M9Tb_^ z{lbrQpJu7B$@dDMM|rxR6m035b{;g&Y;z*7RtHP3=Ru-&h&TqRfU<85E2O)=lgDJW zfdOr|UN)b{goYsB2vK`!vMuqQHv$y24#9EabuefKeA&9BDb^4cDd99%*M7|H9l<1mL5t~R{W zj5YhkZ>5@ZJly*q!eCu)5r&t-zIKXXUnKCO8Eq2QI`2?8pS$ziFgcO_a&6xUFix-`U`!6l|GGY1hKM32hcwP(Wo-Kk#{3RX)Gu!l zuCt`uA{270QO%1)`~HGud(*%<3qRfH!|;w^k+B^5gDBytGN-fK*~bVH1Lx*qE1X0l z=eOZ(0Acj>pU>&Xirk4n4M&*)Eo`W|YA5!^31@9J7!ctXMiM?#D#6H}+p^@P~z1s-b)Q?B@Veflon6iKtw}iQRb3Dr|>UMk3`8`drZ4uc1To`<3L+vDj z1_&gJ4*3qvW(x>96`@*u(-~t;wX3=3RWO=Bk}XiYhz2wg6fWKPwzP%v@FCA-(r>=M zLkx+2%B9$`hC^1xW)010#2@@->JY&UeO;9Y<&eOP_)=u5&y8wlcM{pcrXFWwEIq1+ z+)I+}F6?#){)=L*SZ`?9bUMf+GY>qVyu+*WvoaTK3=a(qs@IL~Ri#Mv0s&fnM{n<^ zf=8%yOzRL#akX<738`{+wotc!F&<~w!kdnTuLjQIQc^og#NGsf)Ugtrv zosy+j!l2V~YB+iPC)?BPoaQ<02`W`U0!?d0)ET0C-f*f_>FgstvTb%w7kAdNE2;u2 z@m|onRPCT4LY{%@&;+23G4#hj*QnKNqrG*VPv6+y3&jQWXcm+X& z;}krTRbA>J`#Azig!hN$C+&;N^NHuRnyY3W3cxW{sPLn8vX0MHlg#-`LFC;EOLf%?drvG>c{1SC zLGq-Gl2AQ?L$fMhkK0qh0K|p-YjbR3V-y#R)|%F-Ww}+652U>Nw%S7`<;5=7`*kO) zI!c#~sRX4`sGwz2z!CN)Il~ER#0AFLm!&hfOv8wj(XsM%XgcZ?u-p3n$gF1rMFA6> zXJyS{kx&OXtOmm{OjzTT>vDeUX|@m=s?p%?GJrQu8?$+{M!tUVl2T<4k8i|p%cEjN zPY_?!nIZ<6l%wicDcnCw0EW?&p6$~3{JIt{5k`@&CC*sOV!|yQF8n1cNe&uTL`;h# zq*qDfQyAx7(L|S+AC>)^;@c+4?~tHY(anlQ6~opi^YccVv>3S{nSZcdqsx_ORgN_C z7NR&fYRB|rhB7M6(J)vVe;dptH>tE`{}3L-p$_huGTZ(3#^bhozC3Fz;PAF&CXfu0 z=I!dQwgn02GLWBw<_bEVb7S2$hG zGu`!KGCnatdIN7m`8*e}nYjsfBneLoBnDhX49|N#u=@n5MPW3{H0aO=(+~Ok*f-G8 zydi|TuzrCr|NhE#_vzkJDZ!J?`g9YVja z2$sb;%Xg_>y*nu7Ezo-OisijSXpj?jy(r&1H1#N^p{Owd8CXl>U9UJNzZe~bHSMDh zkG9dnNakY?Pss;$mK!w@#7!+Jb@am<=6qf-cc({#YBERI| zx~zXkPALCOsN0%EN;XTC;RYzmadV&ebf7nQrBxMLelO^lrRr#<6!M8O`HCAfdF9k1 zeQjsaHj~I3x|w9&w`pNMDrn}hFFNgU0uS#-d}1Pw>nwaYGWB@*CZp!0*$B-IS82oy zR9NzjB0+414#r>2y>mnl$Vji60gHT?Tl#rTaBpn&+(EZq{auD&=ze`*N_gl?u0D!X z)i>dxo@dFN#B^_IekkJsm|+n{Nq+`Y%T|!UCf<9~Hl#Fip*yn7-#v&-L6eUlq+kaj zKjqo<)=5Zm(3HEXA`Y4bp`}E_JT|OX6_g!Ev67W95@xTS)eS< zo`Z^zdXgW}wZ%znN{EF6NF3YBnICWA{R6Q#sfKdp2!Z&W>)+t(bR_{iq!nKD;EzP#r(*FyFN_(b#f?iSo=yK;&p7YG=$ zj$pPuHeV_B?%C}^iWv#MM)G{*)|ka!Cn%l1!t2+$lQKGw45{QUUokGo3nZ#S$-yNo_t@AjJ~ZWu$q zG86KUJk+i-vNlDXUjO|ReaP+!mZV;kLAQ42RI557LZ!q{2AH{xz%E2lo?MOGX!*B_ z#mUciB()ej--_Dj@2KKe_3qhf`vf`(OsHb)ZL@RF558)3^pY)Wo|pxyaH3jO>F@{C zb3MaIf*)X>V7C_?s;-$qDkC;)z}@^S4S7eP6mI(wjF3TYEBbNXSkbXx{2;q>xT7R> zSjL~NF;Q5ur7}dwhr@|mAQOJ;Jdirg_iKyJ?u0usVj@p!J6_9KFu#MvB0Rf`lVo!3 z4-=EtcmWnyO+f4-Ay$Q(iDZ{;56N5?mL;XY-c_@0e4lu9=&-sAk#Mrq-Uz zJ|m$KvbiDHdo0|M^_$J0I@VP+X=r;;M(8g{3$6-^isLE=U~25qP6`z_HwTG`q$6J) zk-9s9l9W99Q?UBO9OuX!_|YMrkV?({guXy&3W%xlQ4|(c7rWUH< z!v0alon_iA(!kZrbhVxw<}aVaLGW3%?Q>~iyjx+lKZppQM+rlSkwfRVq>e>2ku3p9 z;G1}vMSksFocz;IkL+xCl6JUwKkr6Wu_q%8C8vkws!1(9K6c)A&b3c6IWfvzhNe=P zg~?{sy_f|jVV9<>{xoC%<8cN{(mmHUr!X%xhnJp|>UL0pw)?Rjf>o=GW zP!T6x`V=Cv8RswL%<2%cVAPCfejBQ~TAhu%X_%f`-E2SqNCHc0Ke;%wUQS1xWV!l(17T+Ru+&Z=LdF$=rKDPb zqR$Jk3$R)Q5Hxk^h^XZia1(Wf1_DrfSC%MH> zqBpZ$X(XiO19-##Xnq}zY=i}zK-n;}VwfQkf$^G=s_(Dn0i0|LS0F&$ArJz<_P?5E zMz6ND_!XLP(qu_{d+?FUeRd94w*v?AX^ffmQ zvr5hB(w4HdL4aCvu-NePcs&ohA(i6uEQvk~`>eV8{pR;ZKL8rd{vRcHoX+ptEJ&Ug zs3+#Ar=Hq@+=^}4sQH8pO@V%UH=`X!En8+7R1;c7J*Krg1>LS0d47IrVPU{xV0&jn z_i{ZoJ8%5HwMz($x+glVn#+6dA!mi#S18>K)BivAM`Nrk1Mn#-+5h)b42KKLH8WIe zKmV*qwB~GJ5;0x#tNHr>_ET)%$eQoKMO6ZApw)xTW3{^4HO!*Z6zxv9S|p?rS(#|v zS8Osehyk^i7s)WHld=K#6MciuaUHLkw{ac_AXWyYbGP16Hc%)qd_RA_KYskJV;trk z2xrRu zW&exLBHeQ21Da zn_#(glv6#%IM0qE3o0e=T+3vL4vHQz_09cMjmRpW;!X$ zTFon%|cGtIo;fmkVb@lD<~ z>g_@jEJ;v|v@uKB{9_uP&57JcLOsw;ac4;_Rv+y^k;aD~PLu`D=!)1Z*>I;Mtns8gAHQP~ckTJ!3KdZ=f7=6_G`S-Plv{oLlx z!kLN_ z={LPqeh#NPoHS>HfO?TY16AkzGJ5v9A$|5!fM!=nMoFke$q|I5eX*H_f6IoTXWibg zc$Z1z%LJJU#E6NJ+%Mu=4H^{(%(po+JuzKT=%cKE z?=ff)MbwT!pUN0o%=XmuObr?{yagY$1RQ4}VDFGbMUew@Jr&xezy#4uP)Yc%Rm}~M zs;zeDt0hHhB|PKZ6${A}~3iS}W2uXT5Gy=J#{R zABSVHEViLg^FcUx@a~FmfycC<()uYEtBBHNrYGN<)kW4gqS_#66xhspg~uS(BAXH( z7u$Q8B=Zo;NzI;_q&MI_NfCqCXuf4HH?)CzO@93ih7S%}gv~r;i4<0py?C_}z;#lS z{xDknI{Q;iyxShTIl~|9#>-lAc?Q7?pXke-osKyeJA^5>3ahH!M@d#54>U=~A>5O4 zujJ>VVogHJ$lm-;Z5wTMjR~HQmRg>up7N-TMkj;$=T9KAm$Cq_v7KCAkg zbZ7fKWLZ|GPN45+4?*r9sLXfeP2E}lfHjY)p^PK1+vrWXHX9-;2{MiR^d)`6RNbY8BG0RImO(@2`s9VThjLE};p!B@XS z8RyX?$_b1KxTZ6%*}&X#r1cjN&g^LGs2ThH&*fcBFKIXaO+24nGGot&nxJSj? zVTRwnAKhOAB=9D|do+CT)>M&(>~xDe5#>Pon11=e5^a~xpyog96TGu);z;bPlwPPG z;Y{tMO3uxbVb6#Vd4=CgWGC~bAD5?(I#R->ZS7Xozbwoh+6*mMxV_f4Q;z|J)x28d zTTY4jxW&1<3-oJ4fq=PwAYiV&*D=82H&L9+8IPr~QuF2yg|X~*n{d&t^i9iX{u>&E2S6l;i`if!51o_f}*jBS8b7cDO@cbD*2D@KU4JrNKu%HSeI zHK1!t`9!|!!P)kuD~PkyrIl3_Stt7H&-;7VQPq=FlPD@Uia%ILBkhlsv!<+NQ3Nc| zNE>tCxGuBwcgEV+I0e)Z==w7cn5>NKq5iN&$wuaSgmtK7%OxihIi3pn zlO|7nJMG)YCFdKeADQLcpBW|+#H|{4%r*r;1?RzM*OtmK<2I3#5X+w{ zsc+92lE8C${8TI1HC2_WG5(U{MRno4DE2A7R`vxHnwYRA5t_+kwN%|lv193b81g#5dH`RwBkSErY8Kz{BPt02448DtAP>d ze=z_4ONmY(RP#Is;Rbm95s=3CI(4685r9}QtWx**<+CWWz3mnzd9opLZ?y*)pW1^0 z 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

R`x0B zV~kQeQ-uuKAEq?>VO|)&oTJ^1&lfaS=U_KfX%OtibyaKV4{K1)m>b(B-hq6n^)f8h zUs~X<*U?}|=Zy9S>|{SFZ-a&dD=IwMuI%>yJS6##CP*Ss><1Yyx1+qLLA1X@h27GT zYHut+0bN0`>)Rk7jE!_xO8Y*+r2^mp-Tg>{iz6_A7&)}VAsCQ$!;{cLXYW@S&{m|Q z<0WrnAY-CjW?0Ln`q8pa#K3+?2wUAb2QTG!?pQ$;mwoBW&|dc)2-y#`@;zw(L;R26 z7uXU!@4o9e{?}C)Uokhvbw~EL!YF&FU|A~+Yz2K?qlf@nJ8EjYX)0>PV%5 zCt2bkiN$x>9(ai_x+At+KmaZO{{=+;?*ju~^yI>2n7_=S@|ifm#$NUatUh}kv3*}6MoMb5()-Ud#v zoAjqEIPhYRgp-~U6SMfa%W-P>{BTJU1<&tBMO?SRij4Mlh(17N+I43ekCxuQPAw5Q zL9i`TpFui!=?Y49=>=)ME|M;=WB90YIEhXQi`BscFXC>?*d;evC-pORxPPhsq!~l1 z0-9s|#Bbi#u?7_UOrvL|0?~$vsL=w`+oaD0hDJA!Q)EU_;!x{2V|WG!SXMl81~8-dvHEhA8MJ+-qvr)vC^VMz$%1c z9sQox-p4G3xG}%KupLBULBTWT(lJD{8-N7 zjvP4@wRii+#-VT{CGCOu0jqt_J#Ueo{`4g2QGd^ziS|&x6hPP<5~!IE0H$bvE46>i zx?AYo;?e^{e2sHC6P~z*YuxG?mLBjxqS^Kk=p^QRa)UKkq;WReB}0jQw;C~|zT(*C*fX+(5oE4%)Wl6Gm`YWRx8>~7vr z;L3YQNLYtpe`&uTD)fIwud3Ds0|shF7)l03%l0FDJBSx8J0Fz}BK>$mYqVc;$aIly zF?sM6yzAE~AMd*MjNNwu5)4FG|7z#|9?_fs@vu!@A<^%GmV6xO|C%Hu=HisDFWX&f z?S~xE!+);M@+#&9;&i|y0f`Hl@HfbBASV>4EU*SD3kv_KD$rCg(J_$!^;cG4`vCoV z03HNnj{hYv|FgDpHz#Dm)wEP`27P`^21L7!07}3{K~)M2fn65cI|+K0WA&m!JI%J+*B~pF_1U* z4<{_w2K`b3>=Dbt1ON^E5RyF~Fo)Aw(tGeVxvh>j9n`1eJZv<7!tpKqXA_nHwxTg{ z88sFXA%mR=g8I#lH1%fz)ndJEUn6)X^$_zJQg&t*&%r|1K?}w^DzEE zSWwW=B(PFqnvjsrGYE^)$!nNT(K77*ChJa&f$&UL=Z9M&+#glfb3htXC+%$JCdzvM zAv+%in|mbI)qT0?8Vc8?@@jNQjJMgobSxGpMmuUk5!mfG8$a4K51+DqlgNj)Bi2M3 zDpa$|*uT|D$4#wH?j~ED?y-=j?Ezjcrc6rwP1szNoUjA8L)Q~9VJxgX)TgK|AE{eF zxe;~i+8ecxFYek)ZOps>qqzXzfhzUEE@1|dht{}ZF2#6^dZeT6)66)%$IPu0=rAeF zLolVJ)gN$*(2X)#r7j{-{Ln)ch-8BS<7&>YrG@SEQ`u@K54aYdla=$R>{V5*I{6SN zv%B=}_$|Rf)0*@I)-2aaFL)?%&ZoacNvd%ukPZ|UBu2wljToH^XGg{vJzLOHnj}4D zJ$q^+RZP{a2)^>6U!J*IJjP0PvxvCu)%+6Sie!O=5npWF0d`zhi@(_I*$WW}t;9Qq znE?1ho*0|yJ-f1ssupJW&Hl(y%M~;uenX*~GK*^a-Hf}Bm*%l4c~3*g&_AJ-JzFz+ z(<4>p#s}VNO5Q1qcl8(@>!YRBw9F^kyzY@p@$kK!Vfc=fYqKOJK40X*67)GU<@x=7 zKc|hp$^P7Ly?+JMwybHYD|h= zzV2XmY*LnLQhZUel5&KBno6ZcnUZo$R)&s#X&m??m{F;zrUOtwrx{8{`~Uv8)T5MR z461UlS1wo03YQafBjUgY#x(NKf9zP5D5pjyl*Psw6h_8n#UZF60bk2eH`@NM*9f_U zR`~ZN${+v?A*g-zz@s!jKfgRbKRqfnS3M;;AzcZa-~$O@BZnjc;+^A@6(bWgkN_As z(9{Fa^^Y5N$RozyZ)YD=M1JY7(+agje~9a$-6+U=x!zsK8$J2N3&5B}G(QE2hXrDj zqrgDWpE@5JS2AZq{fr8vxd3iIkcM8OgZIG|6c88=dtt5y^n)WU$@T S*`v{SI7 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%0Dv% zFVNa%DLWW?!w%im@EkSTFKDQHui+Y zjTiU3ze|>`*8EneVAGe!F7;ZPyTEul{>rR)MVwb#s0broVa#OL2n23CU78Z0g;C8c zQ~A^(-WGgf9!^n~X_UUgJWfmPuc|?U(_0Jz(Uj<=SwvOQ zKr5fqN6Y>UVnq+q4ozov4(bE^?g6JbuK|(aDHfTds7i}6iZPtbldm;KSy{vF2q4j> zus{{?e+^+IWha2~8-F(tG!Bk&aBdVAZ`psol3+xl)!4psPOp?95lJani0V;PD(=ePpahfYl-Z*t`Q0C|Fz7CR+!Vq>5M6yY|JNv^$6-NhQlRY~}`jx2xfa1wuTiU7_aguj(R&176{+G8W z1exyV`^dI`>UPDAl~gZgox;y$<1s`~Qp5#bMEWifDlD=667u0gL2$vKJ*>J-<0%s=s?dFC~MNyJvRozYR`Oeyxvtsvd(}M?QdHW|T z-e#)-Es(3xm)}x)?7YcxAS<+4+}WPbiOMbfg|Q0~#P}%s2x#{Dr-*&{VIcxiI7)|B z(XwqC;VGt+sk2=VJq$?g_Cf>6?T7Qf0!_jK-dlfLq<_Xj#ptb!4`bwMlHaK)e+8Z1 z(!`mi2$9FPk!}Vc!k&Py0VnDIy7Bx!zY*Qh|5x|hZynr^Q>Yc8|5Qc%Uy@PBFk!-C zx>ojNDeS5I_TAtu?2HyCqg-L71p#^LVxGDLD*`6Cfii&1|IfE$Hl8G&Re4KtlHqUS zx2}5nN+UBz>&OW}ayMdR~Vp}gFb}><@n!2}_RdiYU-YPl?zp#m8{F|%n{HWsx z!$;(wPZvk0NDZI0-=T@|5FkRH8p|yU!0Vi?F6;Dfiit`OX7+gM5pfGPZgPI-bsV>n z?lysM)x|Q!rAt;M}Al1_q{!lqb+2XI4Fu}%IHqT%Is!{j=LPq za${%3E6ad+>jcTuoQtjlwDk!F!xP|4A1GYJw;bDKxuBrtM`Qx_lKw1c4tOKhv$n5F z*=Xs|P5OuElPA^Ncvyr!7k=IF)lI5TCl?}M)g}@Z5vJWH@dnUNn>*}##IOl^R?7z9 z7wYRULXJ~aCzWz7rT%ULwVJWBRiZzS_krv>jyTqKmO1ZI!H|I1@siF3Cld*ntD_}Xl#{7O2QdVHK9Z<}NvlfmGJht#0`Pof zDk&YUUe}3EEFfP%k;V?<1BiUxA9W#32 zTa1P;AB2oz<6&x(mj0d%FAZ4%Wmwgf7dvVthU@)E$5Z8e3ZJTO`!3$r;rg4}SKt6N zwd5iytpSgG5qy)*5zHPHL#wf4*Skh!>o)wj5znDzYsV7__|_=p9`z8Nd4 zym2e6#cs&v2yrO66<$~AJz3F;C1k-gQdXQ`NG8IrC(ataEs%w~KgoAZQ|{zK7Zslk9IciDK~BczJ?9Kh3Bw1JXyqzwds+e%u_Za^Rfq zpO1;R`+RyWEOq9u)X{W|CPp*e{Nc)Xn+Q!co3o>5Xw!*-PSm_b>Wcn=fGvh_zBUd8 z8tGhA6k|6;k(alA$Nf6aS1J}!*J5V2G15CAF9@X$FHnw0L$Wq!(5n{Q(#v5%FqyuP zIRh)nd*)1@<@<#IIiQmTk7s_9d^VKmUx2log1tsMl^o}9k1=?xvkq6tH~%A9uq%G2 zKBM@pU^Pd))OOc*yZt1`RyHO?M4^}+JQGi%_g6&F{8yv4J!BMc@Snp@7b3%EmE%>Q z6~Dr`?A@BL`Pv1+DjQ&V_&Qf|Wbn~xD;x!OW2K94kI_w&WvUcVNz3sD+(0XFWb!v` z5EFZ|FY!C^n|9-8_(NXFRCYf$KSn8duib9ikDKRFS=)A8ZCiU>tM#OvO#WcM!GTXp z-U_C^ycRXrn*__S<>KhG1SKU?+S^@kJAMMzoOZ6e_sv>&=?^lnQG`7ELqpCF1MHq! z2_JhT*32{-~lJ_^1#6qtW2e2OUQ% zsR=Z(g(@I+g_WoW;B)E}LFv|yJ0-~iaD(;0Y^@hZXWhreR`i;kHI_<< z8%#83OgFJzlwa^FhMKOxACsRl(*&|gFQS&G-rdixRGEXq>`&!>-n^I}ZvWcU5lCt+ z;cMapH%hOHk_RQ3rzDG^q62gGN`ATrlot)@N?d4;dFlQ6!LOFmCV>-=BOsTvkXn0@ zWJL$hbOT_r<*>%DJXF#Ts!n7xGtW|NIe3lk9$VkM>+`U;O;5Z0u9RRm$e@3GK+ z>`f<)r`B%Rwzy132?ZnFZv{CFTMj+f-Df6qefRm#Ntj8- zn7pfversCz-ILYB>$RekazeG*QYthP^a*0JeqnhEwczo8yTqb*!kqg3>dX1C37I{C zhWac}&Yct4FCXokCxf?LI6+In8e}xG>ld2>_#+-K^)H zMJ2Ez3)f1Js$c!n;}*iC=!ja>wYoUTS(t7|xKE}|oD;oY9Kb+*>rvOAb@J(_l4_^)*?bn4-sYdKo7#Xx! zGQej5@=)5Ah!gYX8#+M!tCxts0p4%^+f}Xdb zN=kL~$7)u)`PLX>0Wk!@Wi4?_c-w~a*B*GRo0KOrW6uzb1_((dRY4V`^=e1GZqTDP z6)-gqE>7X#Dou>xtuA~=fQ4``3rpKUPd-T9HHm1)S2Hp3YyN}_>1nBLHeP@L{XU)# z$f}bV$dJyR1>8}gU`W%H&;&3{ZZ4G!Pc?FvqjLt96Xko-qOKrvq(M~rQ*%031E|7@ z(Nf?LwNZMqN!tR0_c|jJfMj_b&J+86okcX;2RFHys}x>jrqUO)13wCGDD|!?jEoUs z4Tjm&O+rV!)$H)gE;X(57XKHD%ti7lh(8?Sx0ERRY1=xVzFi^U*R-2%$Nul#Kq$`L zVm$`bGn-h;+lU+pCaTX6Lm7hO`mZoPO2y#q7%k zyqm=5E_5$n0`tQZT_xen@Kpn!_1=j?B6K(!y6c~{NM-$wL=z`Z*4DJDXW;A*FrQ{u z$atkzF=0q73ZJ;8_XmSugkgRU-IjMY^wIAEGBBRTx`i>Drpw7l_z>-jM&R-zXYOct z;qO)cpV?kfR9FG;18r5>9FaF@9-3dUbxpeSdLe!5PiSxPb=E@9`6q~__0i9&md*`A z6Nj>oxP&b~V!B?5xHx6=mq_!KiCmJT*p1Mq?f{%QUCz0p~*NZRBfQFi6Z z9WO7kKXjqtlvAkzkFu&vo7>geY)8elequD>wLOPXi%wpRw0F||BfgG%A4%8e17fXz zI{QR46ga=KQR=Z<_=c{Acaj>!qd-F;mK3?c)+~{QszpNKEGiMqLR_aR5#waB)!y93 z+mdAH0>&J;o!k3kPyq&W6&nTh4a!==Itm)o-K}gvVln8_>)LC_=i2L9_Gl^iC1*h5 zkk=5oUbkKf+Xve#D#K;N_8Cx<3=ELfi)k(;QXJNPokWwH`T59EqphpUV&5G+M6*g* zr_UG6mC1%|7N|lQ40GK2Ad^OXS%+}Eg&iqiBir7wxmC^+kKl<7N#?CBG|d+zKRJ4NCL6~ z=a;Y-Byp^Wb4I!q9K&5ro|B|(0w)n*M*Wh)UnonB7*pv*nKZu^^Z~u7OR3hUk{wmdmJSN_y@+r0?eK4D^+(JTv2?@Q|-pA zLN4{y7BsAmF9jV8zOK-aONqbjUz?(vr{wbd%Kz%jn&G9 zViY&`CHbOVo!{SR)L7j~xmRUA9~!&vJmAWi!BnR%?`c|alNk|7tFqS#7CYKZYBzbA zwnLsh98rFNWBY2z*JpvbgC?s>|BY<#epQ!wj8h0}boI|OSA`aee^F>O2OH!ZfwD}k z=K#dxCEx)Sc{{wU-c{rsHr};o9=`YFPnnHhALi|%w)$WzUwB;A!qr`T*4@q*2FrU| z)f@EWyW<~Do3V}$R-cqT3K%;z;U(k~s@65ylrfJY61W^44zPTFVsw-y$~iwCKn8wS z>1oPNJqO6f8yagbA&s{$4CaWQWCrXGM=j#e&ns)(X<2+0Av;N296q2=?&@~2Pg_lb z()-8kBCvh8TDnoxar5P^J|Dg?)ijCo#Zx_%pjAVF9JDY>e#oBN+M>aI=Ak{YYW%9m zzFbIkFRQuH1p77J@q!;-6sxDx=l=e}*lfK{y{Vn7VBjl9q3tLwv@l=LE1JJ8`2G+8 zg!M+-%2udCyY-JisgqSShH6ZW6S4ABBRa2Emk$ zc%dpEK?SkatS2nMey;v{rM?Zu0%EXVt}e6obQ3D;cgB9&b<3o;5>Dj_ewKx8l6;D= zVLY?+_e3Tk(Q&?a1qyDf?eXtZfp7wmw4|lSc@CB*%os&tCc1>Z;gA6xG%PT#MS`ZO zN%wL{WK$BjW+;7vP;_Hhr3Hq#fd@ToDnFu>sI?m>RkGyQC^L2TCigy3BP(Jm*=_>c zyuzkV!4FqS`qmU*fDsJl3SvcjaZ{#=22|nTt`d@$JU)pUq@2iD4odM~eKgk4Q9-WK zB9VIhG=RnwOt-9^{oTssr&fpTwX&+VDRz;y?6+<;|MxKEtUHitBS^Qa(vY@P!>{@6 zu`1wfza`Hw;b!-YAN=vmnGw62CFLs z#(VLFubj)Z1d_&pXlAwNPl{(Xv6-zM8CXjG7CfPjwG~zX`593J<9=uzG8Lp)vrCu? z-h>uU?Mpt_I}~&5i?(EdOXp6oqScNB5c&NaMd_66;qlJGbg}W3r2n+%Mrr7x_8i}v zSh>?FPrIe)+^;y`hXjIJ1+wVe433l-TBvp~Ifw07&j2cd$an5OSzI2nI3-4hIu>93 z+B7a-8uyJ$Q9@Qmev6p|WPagovVeTkw%SxJm()ppxUvo;JVl{#op0`Aa+|HgXUOzF zn%r4Cq&(xDzE{977(*@kQe2}$BTW`RAbqwhKwk-qD04B;#$M@pS*hIk=Vb^dR7?`GdGsb(LexuTg=h<8NlCBq`|MWDIz{ zts}!U-9ZksA@q2~7v-$cDu2Pdd zai@V5XN(`tA!t*+QHn#@PsP4;X)y<<+V2KSIoeknBot zO411XBBVqH@3?z;mkj1el##1+HhxO4mqktQM!&I_5-PHKgIFYpVpZ#5)wCnPebv z{*VJRuzTiKt}p8yh9XWDrFkf{hjJKWde#ffC%a6>RI% z1|v)wbX9tC+o+kpb1QCb^!hX80ia+jQ@?q^eL(GF%IuF>gY^~i+K72VR<3$hZen?A zVs5pfMut{Kd7(mFMruNOYW3JqF$iS31uSlaK6h8vV&_9b)EJ(ou{&E;{(O^;PGS`W z5StdkpT0@FjiMB%k(8F0m~oJxkx;6Lp!x;uuee1GmPXR^ujB<67|xTyBT;|$>`|t_ zR7Bu?L zl4CKffAm}E=d#O5&IV9zSf_>{J2HwiK=IUHm{BiRfP-+fM44(N;%A-P{R&1y8=T37 zBA{da85<?d9kRGU1Du0l$0DU^N;q%UfXcJilVV!^wDZ}{BdD;InM@{kQ@buym z7rinyv%fd1rPb%@3SvaI8S-IfIG zAfJecw4V6e)$hJyl4d5QkHl$x9lKwggaaTa_Sl_@cV<4bukzsd~7ZJ ztPB{a1Ef>(USq#4nK$t;R|!*18gC_vy}I%F^A!H?*po1=u~-){0YH>h#~53#NB?`= zitqx0qulsfEqa!!wcLy3K`&!zZuxMP3(Nhl;;cvp=guUk)ybX`dW((PW z$Vhbk%(TEm0IIeAgN&3?6r6@57FXQg~DLb z$on)=O{agpF!nnN7K8`DzVtsDoeSu*88uTxAmw*z9zi26O zug9t&Ni@pGb~SW1|8HM5?^ncvSD-CG`6=(HbDTxLZhX~ar1V4e+W2uWrXwJh%a(n} zNPb~378GQ18)4jf2FSM3?&Aoz0cSlhmHh5Y34+xIwpI%FpN}Lkq-%N>IKSqaQ+I2X zqN3;P82@vm*^^{Jsuzg>Pa@@r2KSAYF}I4lZshIpQu?jyNbMCs5G{~_3#O|0?{6h= zB}&)bO@7&K!eyi#8N|vDAReRTRUA`A)4@{FlvHD`apQUcUfKw=%cYz6XqvjFS%N!_ zsJyh3x`CXTh6=+trD?G!un8<4JzQx7HJXNIcZc8pjVdU-vJG#kMOiI=1>p+eToB_s} zb-?Ky7(WD@L-uGK1XY5TzS6@%eWz<*Vyq&Ef@D^imaAo?BC4G2*r7wIG@amRJ>Z+p zeMeK{TR&4^K|SIx_HpLlTAXT-^-BCx>0D zNv5np6jwR0ZQP$}dl+Hr@jz(qmx%H+E1(A{9dyhPM@dqDGrWE5N1WEoH&wmEdC09w z0=>ih*+7#0#}^QD?R!AQ+86(&mTu~7$rf&_N-xvbK~q>S-qD$UL6!3EY?W@zxa!;ZUoH$Io`&)Q( zi{a&IWcwE?F{VjK3{mtDbu%;TKQM2e9tbB|bPVCAjvl|=6UvTo2dnN09K?ZNX0PUAp3xZWdvQua<53z(ZmgV8vmAwJTQc*4_-B<9e( zPq$aj+!J0fx}TUe%g<${X=bleY!oJ&;9l?k1aIBm*1>+T1p%LQsJDGG{H&^APUeA^F;$N`3FBi7RqMCIb) zZPF*25xF=!b4p?dt4*66Qutx}hhABX_>ujLfVyIKl9ib*uLdmhHA$>KI=`83J0lVDDw_|58Y_Bn|DAdON4(UxKgKbUvmtnjJ-u(xYU0}4GYA35aQVbX6?!;(SRhW?O)t&mA#DqB5tAyE z`_Mwcg?ANMN3GF=3Lz@R=sz8q&u^e1V1i4jzU=Ch{H}kODXtQg28IMm;Y8Q%Q1(`k z0pMDsx+mWr_q92D)gV>+%1m9Tz>gwv5Igd_eMzRvM22kkv=h7OsS8Fi0DYz(YrP0CwwDHxeFZ$bQ7P?>lC*K z1UWRo9td=gy@T=T{9C?d2JDhfVl3>ch2^(Du#d1(%wkfoYTsz(C6yO|8gqD-1@t^x zN;~wp4EzbQug^$GGlv40F;kBHgi(o{!1#7*>P4`nAofMM?n%LTNo_C32!Aju1}t?3 zED+mZvY(ewK$Nw1al3*GIMjiu+;D0q9}g@|88=1v5NtCnWa8ShV6BQ14Ydp=NmV6o90O5U?StstQ!{)v9A$ zrKgY$wq(qsK~~`PAd2lfRO=I7)?%#IVgw;DB-?1Fbk7P_ny?)B#})r$CVJ~}R)o4Z zUot;fXMIx&DWWr)6WA7J4gNUXpwo2S7s*2?N`B;xIXhbdOQ1KPo}}9l=Avqh1kToBtQ; z<8z3o6CCI)SU~>+a;<-LRCLP)x)Gl-D4*-a_`rbBA zwqtmd?P5?o`1Ou>^Jq^xsZ#cr1CU;Rsa18hJj~QXpf1I&;}eMcHU6ys2`t5d1`4lX z$0U=$Y~cD79%yDOBxh-B36Qjm5H`&TR5#Q#w0BfA6&f1^OYbe3l+t z*%^A!yW|9?yL+YI^%2Sbs7*ZIglQ-msM*`dd#G8Pu=7cpNKuTrB%qQs`EK_xIl{OT zS6E+UQ;Zz5SF0zj^33wgAUUEcQs6*xD44OW{ej+l-toVO@|QyE!c7T+_Z{5n8VabT z;~lThaS4J@_Q(#%3CKxDO$`*TLX1<8l4Nj_WRRGWmYkBFmSIq;R&R+s^yR8-K)%GXY)(N@Sv3?hfC5Bqxndh*0{yAWyE zz#jTvj3A@h=3H1mJ9Govi60ULiFJJs!KD6HyXVWrCciokUxc#n&B_0k{1g2jEA{3gA{(DT5xlR@IRo_O;!V>x|Gw@54t@g40p8}ZcjzZ zS7W1Le30QX($rlDv;Y1ih>(nZcp`r|DME^MC)%At?A98TD&lb zR=wnpnjek-oCHG$!$%!LhxlZ$J%57{)f2KK`}E(F*omiLFa8(J=zmyF^{WugXwMzw zmOlNo`y9?sFzE2q{Fr}~1BIACNvW*-lr)1B{TLG%4O8;hHRFeuBid!Ae$^EK!HwmF zB9oXRq7r%OxL?N~yM+$KkgFG{OhJaIMMWQI)g= z{DYu8|8Ck0+b&!v8uWz%Vu`N#K6?2g!l#?p7qIa}zVcI!XdL^Kga%UcH@=eav9=NYt6tD1UT7{AqJ3Pt!UOWhyZ-x zPp=75@_7Vy^gsGh4=*idG@Qu$iD$#sCJ4$jw6W@p{+ivkk`j+*x)?N;wI|di?x5!? zoOu4k-|C~E6j&D19G!uA{?0!9krwz9vN`d7{mc-DHt&0=( zqyX(M^$iBKYVN{u;13(bu&qH-iU!kRQA5 zi9)viXUJ*ugvy|ED4Vq1w5VVEFnz_o&fB}YKS9sT%-RaK)vHZkHnMRh6%P;tbxR@@@~HP-hZz?)SvV_T!i`5wrpdL{G=dk?7D1!QvG zzc{u3e~?=9p_-R<-|#C-zJUe_9fPGi-6wGR2GEX8N=sIOl*R8q9}XqD(yu?qn~Y9$ zw2;cgT&+Q=gS*N8JemKPs8s&}h{U6{P1)x@_3%8yDJ|cR5*3LPlC|7UQ4YQ!l2@P7 zb2PqHe7t5(6zoqzH}hBV)?Iyk=vVhOBM?W~vDdC}(b>8`?o~-bFQz;WM86zOV}0-3 z&VL-0sI0_saP;Wc5mHb@8Aj%oCzj*+Q>|` z<-=}qKTar@5f@Ba6-eT~5e-iwV-30vl(5BgdT|GhN(0X@)c57X_^TuX^H#}lWA)FImR7H zHxjb9FMd23Srpz8P_u1>2UQY^vj!z@S0;NLLGjz~RfqA97&6MPlbQSd|6D^Het!nA9l7a+XGcd!Pfqsf!YDr;b zL7r}Tf>v#15p+C>94k)(^x3}c@3lvlj04f(U}a*Usw2k`166^qrli17MgaaTX{4qi zt}De>MNv>_0U?J~8&Fy^kawv{hz`0iv|0WZ+vtR#g+RH zlc+uv5H|nfY2f!ErUja3(eF& zYL=w*1tXGPfHDJXUqh{7HWKMlu7Q93 z_nuZRBg1}LkO*^F=$->mchD)dzL*Uz_%5KKUw{n}8T%4|d8&^XDP{+Ue)*vGu)8W_ zG#FoB&$mWA+QTFn-kjwSv9>X-57{inFOU$M1dxJ)~xcAh1)qOjaFP^}%r z?ia#f+=?nch3V)gP_R{w!N<=pRAP_Q=>;`MyhTvyseI7PtYHR0Kg@FRpmYuGzONNhP#%`9 zB@F;s@mNXAecD}AL0Ni%bVz_O;6D6?I5UPQM#QOj3j&ZJ$zIHy7g?uPf;l8d51SC% za3-8;tUqgK_rMGmQk`DT%OU<5R?9b;Oe@%S_lJJMk|It0`Fi$gS`;ic(yF{U?o%Y3> zz{RH1r$GUYPpQ}fsHFp)d>RpYnL0WR_tEUJ3@e$1OY(p*OBt>zBnA{@jrS&YiSA~T z4U$w9vM>#9p_=@LCBiP+G^>G)#sVQ2l+g}=J)|!p(j&xY!lMu_5v$Ji`ZTNAmIW!* zTN<>BBU)VeEtYJv+r~_=fameiKb3fIyK>eK8rLp_(m7w(=ySsFpo6Hkn9?|Brplc z2|A=6mX^{hD5Hvdy4n6xQk*W9bexw))1J>QJh@cO=_Lo!Yq8P@-R6xm5BO@^tz-#; zPhS;Ng(4uyVe}>x8(6sb?2ah4|6Y;a3EzdQj7c%DpV&T2U^wX%dHi!Hx`<2Ql9Y4= zPgsV$r?FJV@S>%Fk8s1uIv1sLgI!ym1nSFKU%Y1+>z@;^De!|>QA3wllN|$UF9lC) z@R(zR2e$sng4y5-K^grYGK+7)?d_F<--UdN&Dx7?PPYqlKX$QpBXwCs!GxNp*$u`4 z-}5=XJ7gO2-|UyY4R1QMH~ru-JVJb=+3XR>e3VJVr@*AL3Rbj(k>?7uo>5FIOnXCF(eC23L&12yR!99_q|S--$rxZ=5x@n0mts$z zxfhlH*c^|8l}MlviqPU}(_m0L)>#{Zf$32O*{{}~h?J=gn+i|y3oBc+lf-b45uXbZ zYOgm*sE`!VF_P8#*Ey*HOC||BTYxHP;`Q<@cS<-aWy{VSTxNxE+ILhsBu~I`ZXTo$ zlJZvte6Abtkg^V~X#6%S-}pM`kKsL*B-U2M=|7*zjjv2?*N&T);9A3D>*B(KnT zDSe$pekXMuacdDZJF|M9+P}Q>da&tBQdKLf%R&_z6#KIfK(f#<1Zru4qRY4*AUhv< z*iCR~t~dr=wHUm#3>(`WR88N0%L-$uF6dKKOmREA!6k z&$J5zUULbp?6(U}EzS8|Rbib|;~yw4#gqI93?o=?LZj%Ueg!S9nR?{ZG!UU9$X>%E z6ix=8ytLD2k9@F4%~Koc9@zAjl^5&`Vg|({G8eQ6@ADE^A&ZYM9X@6{2hpT3aAPs2 z3YQhet+1#uM&!KNF_>SzbL?Z0p#b_Z3%?*~KJ+-3)vuoAsa)~*$a;XIy+V|sF3KE$ z$0h++t$z(-F`~?6to_mfND&ABiW-PKuQHde`ZtIraBh0nX7QKa$*qGXEt;Y=!Ra1_ z!W}m51*ph>ZQ_T0EO|_)o?ts{!0l)q)ab<>kK`;vfRq=(QC?$K1GBk+yEBE&|Lo3? z;pNJkW(0os6_Tt20R8`td)pTS?9GI?PXB_phXSCLFznD+j6|9Q0)mY@daMNO#dCfAFDBqc z>KjW98`j|R7hH&a%WsqFwdz1BgOXA$n36{#)g81`z$NH}>^3zqJ9mn>{v8ov&X^B9 ze&W#&A~^x3UR?iUS>$hzx(PrE>oaoBvC4yhD_D{6=AQO{Cbtvsn zlQ1Ce0vzLdK@`6g09$GD81vr$L!ok9@xfqZoyd+fX+l~&r>0Ns`PET7)ye&d&r6r zFC$D3S%jQuMrnE5Wz!ES$uYX~<`ij#Z1y7n4jl^6ADW`Cs#0jujpn+ulay?Ea!Q5k zGImDe<|fT|=`<6~Feh$ljTaQEx#gsQ+g!1Y*_q z0+}x|BS+@)Ew2E|Wugg_J$8Ke@t%|J8+}mjN{t_OH_jb%9#QQm%$HbR_ixml2%YYG zvwcioT#(zqIRH~tGYP->EAH&Y6(_0fek^Ozh@$EgyG`8I@eLpu6nv=&E`#3rU90sa{E*iKqQN`b zAk-vDHJYXM`h)v7lsNlH=1yCskVHT;0x?-cw-tItWQ=OAPRuB}nF#*5&5F@2`wl6X zxq96+*PcQ*wmzV)q)mvZE(A2)f!7!lVH}U-eDf+8#w6cacfvvKV6|^u92ulOHspMt zfL*g0az&9@9ld+Rx9?ICk7D0Vb%`#dJifeC zqv=Gmmx!b|%x4mj7~Z{JQr`d*b;Q7*NQX0t?F0G9dop&I33F08d)X+7p~Xwp2t+Vf zk1}4&Rv?{2Nsz~S@-$|h;$ndXW%n&CkV{pLL>snEReJmyUfQ0Hwws$+78U&*il`Ak z``Sl#1sM}%V2BIK5uX$e--BIGv&l;K%pHy+as)HOI}n z@g zT{Ra-xjwsVJw`~2Ij8hJu3bo)0_rZ2));{<B{NQfZcP6mS;Ah@-bGalL3cV z&U1c5dERZ>-%|yGY*^XFjIO!)_d|1=T8{9c!#D{E{>!eZD8rfbI%I@qvG0j5tTKXG>6JtV) zI-Qw;88Z67u3lI+)0op`7WBN4Ce_n0dk0IawyI+ zvvv?k-xsDH?Cl}CNV_VQ*bNR-YO41>w!2Ig5{h*QJ!zsJpi7{&553utBoL_)udB=i zJs~5>YI1JRa2SgwB6As+Z=^TauL^E@@Ktgg`C zdQYZ$#6?+5uNcBffRgO^87nj)^byJW=ek4$_7uu!i&Ju&)8S!JTy*QoCC{5YL-|0e zHS$Et_BCD3h63}-Kw|eqCV=OhUmiNrzUssASP&J8P+yRH1!wr~WXagrLZ`>h^()`D zmzR?u%SH=ADo;t@M)O9Y)uKsDXZ6HGu~f08E8bF_O52NOWbB5K{bhS)LeA_hK-pccT$o6%(&`_5& z;C@EVZ?fT^HS#T>%dAP+j_p96JLw`f58S)sNOc|7l`F}{IZVSUK#Pvte+>r%?fVz}e>UZ1~F~CR!M>O0zH{Vi(dvP*4 z%&=RPw?^9c#HfsMTz*A#H?A1*@b($^+|gGz97?4H*#S1Z@AoAFu1KST;_C;$&T0Mt z%Nm>bF1rN<^r5BI@SeaQT0mNDK9ejSRoFU;vt?KuDYH=IuAse6sD_L6y*0Sf*RbIK z#@sswX9Df}nz8MUZ9AQ$W81cE+a24sjSf4uI<{?F^Y-3HcWR$g^I_)B{hmsy@~(Q< z`s4RJ@X*er%kk>m=tOa8>gjPvsGy*r*65&yjk-d7$+pPM&lr->qaEiw}O zYonA!sIwIFUCEyFHaH~~FPncdqH|n->+H;O;B0*EZa84%+W7@a{9A zemtVze$z&*?$cPO%o;B28$2Xkm+)C~z7i#pF+60H1f{s?^Ka^>4Cgkk*p)KCIqOrA z2Cp1SBJ2+urcm%sr#N-wD-H{pfHNdV^v!U* zfM2WpP~q+)8h8Rp?Y%Z6pU=Fev@c70E>n#(4)N1bf_x^M-cxxY-7G6zDJphoT)`u~ zU~Xw9H=N|$b~Es}67d7_)18*x z2CtL+UuO&gM#mMjeYN9fBrubU&pfI?EJ%8PXAEiI^wZbCteSL4dx#ch*A_Q@abb@;*Pfy0O{C3X>|f-soC-!wg4~L`UARk%80)~(~4oC zP}nE`QcF+)V}OE&;{%i;*5{LA!@g$?X5{eRO$>)Y{*tZm$<8-g->^;MEy%4(pM`w{ zBaQ-iKxI`xvN=HLF!O@pO0aW%f7@D#dMsLqXL|pf@kci{A1M}g2CTam0lJ@CQgD}H zVb)w`4SI}0@F=FfH!G+Q;;OLz$7&lGosS)>{TGWN{FD}&5Pa8gzN9I~XSiNMr`W3* zCZ4W8pK)se+7IMie#NkpZPH#XY8*l#ag`Q|kBJGeAHI{4#H z+WxVfHYCWru@9Od3pgi#_0Rusp+BHijR9>IV+-JYqtKYq2%X4OfCBlJ2o0=*28)#s zb;LC%9@Rx!5IK?JT^Ar4_q__eqq7Qterr~ja#|CG17ti1vE`&i5TzQhJxIs1hioX) z@mIfflu9GeI8rf}h`YF*h#7r7fxHo>7V$`YuSQ6Ks>0|ALtGBIOas!eO+z|IUL<_h zGog03Z=ia-ou?YgJ&^EoaSpSZS_E7GUl*qT%)wt?VGCX8Cc5_$Eln zjF;+BHcK3)AGTpDb|TKHaybLN~Nw+$IF>1N+(x!6Z~JLeB^hUGmdt6rGyl;nasn=|V`zb2y}_ zFYLwCmp%8BQKR>S>iuSJ!S49SiH9=XbTi536_tdH#L!)}WCruVH*k-1lV)0JcXun0 zvj^25FnyjiCU{`|MH6;1*vH93s$gdi*ke4q4jFf4y80<`dvbEgGxZO*Acu)R%7oFL z;_kejMSco`b@4gv10kZv`X3?pg;QQhg-k(Dx$@2f{|7P#Dh7xEo$V67mL;EZgwC-t@U-##xwQPP3hhfeHqtfEP`t*_d)4sE6U zeK7C)C#s!cpgINuCSWaQ!zqj z@Q?+g%rsY$5ng5WntR;%#!;8OykNcQX0TdoIfJ}LYxl|E6ntw?Jaq{Z=WZ69kJL)a z)2oJh&c^KLawrLb1^Y=*h{0WR_IFMk1%Fcff~!J{uSrA3C1$N{+n~zK%uFk9m1!`% z7Nz7vGK!>7e;RRf_740%ZjBPK+GAFY8BR2kgliu#89lDy~HS;5~cBEhjkDwk%| z@cob7_2Mgwjyz&^@q%jPrRt^R z!Bt2`ke9;2XU&@IpYjwgW+{*0!cqp+d^Zl4cQqGQp}%rF{GZpam%P}f_- z$GP0?Q1Y5f?oMa0kahl(ew4>Dxzdst4bY=oNE2zJDbtwfUd+n;Jd@JS6QqbI*w z#4tjqaUO>SJB(51^$I+LP5Y7{&w!1zlaVA({Q8<{!rjdNcmm$Ghka>nS$q2O1iwUL zmy$RP;~>t&ApKj;+1&gDb58P%c;f3HAE?zrIWL}m3+9E7GNoW!PtWoIP9IoX3fqS$ zOX;u6p_%)BV-T7y z@)8L|q>PW84!>vI56~`d!{RH2NWhyoL|MvCQ2~RGfDw7f!Z{X*hLJrW7$x+H+SIlSs+|%Gn zxSWqK5XZ-74)iIn$1g<;LZtkZ6nCg&+4eUBy>U`jNEQgL>7K9H`}{)J?xIP4B_l3D zu9%bzA&jQU@(wFm7C72&0qNxpL3Bm?g-e{0VW=_{6)#*SBb_xyYMf-Y{hJwS1uYdrwlTg_1NkG7k4Hv-mpPk4kHE8=Ta?t&{y^J-Qj zM&r6(vFPNT?38-N)yx=t1S&(sz4ApdM$w(j6v%3No@FY5ykG#Dspy-$|9HET=E#PX8Ib|XDlzh~@T-Ypsyo={)AJgGOvJ^r2m3q^QdwVQ(Bn&&U+^JLwh z^6PNi!xF9da-s$W!{`nQBd1|9cmw9x*{_(6shNQUSz+Y+g>(ii39^NWXrQBEGT?YM z9zmJkYq8gHQC~lV+fD4(G?Y##Cyr9>1@NJkIhGFybK%U0Oz->H3KJO{`V;NA?axfTN5M z$EBYd$gUCb7uVyMG?eu%44Jk%xg30X#{%S46~4QXV{hD~bhcm%&_|o)xW!KbiBk^4 z8^5HBf3m(x*K0e8QXHH>_UKC{8)(1tB>I3M$YG!;=U5Y^K>#IwLem_9jso%l{}qk) z-_;p-(E?6TIhF{aimKnYo`xl4dR!_2b%u4LITrU7MC>qNSPX0j6!*_}Vg*{Fh-hxz zhi(|gvm1}41(@5NyoXHuZ;t=&{rH^&DQqBq5J^P>^#KJ*W4pVa-?}~R-*EGeCiZrJ zY4b?~romC;+6E>40!S_X=LL3{&R+a%^v;(cn}Ap9*=%QJi-4@U;Qy+?Bl$;LUwAIV z%CYDtt{EL*ukD{pmIht$MgM!7=*nZh3}Xm1s0WDBU#S`oxmT{gd}x8_<-SXI*Z*4( zdL01!00g03#9K#d&VdAGzN>?YoC^IZfJWNFC1^!is#KSvCPwELfBzeVw*27V4U%yR z?YH~wVSld@lV`g@i34ecwUAnllkBd$G|at#XxTI@py}5#jS1kw7JM?UY_z>FKKOV9 zyQ)o9L9EASRIkQ3){4%LhY5Q~ZP~;5l@JEt|Rs0uhn7KqoA-4QS>$hamqxLl;);kl$#RYRCS1gU5wFx!07@bNW zBeK#>;Cj&AX*Gr~!ixbEA&lS!CD1=M0`Kgg03R~WB)qu`=+PF03ww+yn#yf;BcYLQ z%RUG3JzC0Qfm*D3q@nv5cE6$AVve3}H`OBFHkfR{`ab6~C9%~7%02{@I>rdh@iTt#vD%M+k4o;Rp5iLBUGEY@s^#j6JEJ&co0{Z zM2|;rec5R30Z&K@mpO=02bfic)j?7ZWlO zKvq`=zoJ1VG^##EVAR91E^TIM3o~!&+AxaU=E+u$#fr7yWWyHbK_6=tSnow!DuK@e zGoc=v%FZn6TDt}@f{w7co--4#>WvA?=xmLV6)VEs^ERE^(FX)T#vv(<#xh{&h*izn zpMRVel0Qye}{>LCbCR4ab9a( ze>kit2I*FMtQ>PbnirVD-T_DW-5B&>IeMuX$+ zX^$>dy2d?u^e1CRrGkdk&4E^wX&9!v7z~>~Wv>>lgBp%EwrY2GdkrTWJ{n01GjKTC z)nU+T?=nu=;iE&t1h+|zV-e`#{tz$=c6Uc$*ucb7Uol)Mbu)@o8{goPKRs>!TWq`s zkVov>_u2%uDO*}9_j(9xv1Oa*&*_r6#>W9qHea^vQByTEmW$M9547D30i}gf*4I>* z6PGd*Gc4Ay$O<;iWHWCw^BTU}tbjpuidfcI@ZHw8;@t;^*pxx*52-uGoGPD=u&wKt z^3S)k+zRL0&o|VFn{(HmTCN3U3*Yuoe`Uubo=|^IZ|x!e@Q~1`e{N1R9D;z6 zmGrLHWuf5NkbX|EbC^$;$zaLUATb&nT0Xgc@6HU#H1c_FxGA;3XHmM^X+dvf3CU_E z@W^V7k@6*=Jm>T!mn61rpYl^C11qm`=M##O9WF#R&Kg=4dJjpw{xWaKH$C_f1;9<& zC`p;4DxejQ?sG_(CRki7H6<3wkdw>2A}1|EX@c`Lqk&F zL1XbgBMsB#z_hS{Mv*ylQiUc&o4Yyr)i+*n(l9%3b;cS}c6W51R*L90q9Ef7eB~RA zQT+y6bgoXLI4AQ>hN`7yyIbT$ zSwUkeq$VLsDpziZ)~q6udy>UWYs($h5vejMZz}vI5{FU!-uG>|#tGl9)5v`nrm!b! zhaR<8sU)@jCwr$!Oq?(jf*Lm05)gfBXx%RMNq(0FeB)-`Ha9J&OoP$E{1*5tBK^LnQ)Pi8rBK8WERof}Akka6Uk|{Oi zLH4iT92UR6`f&n=F@;u_BDwT9e7(TRehXN?l3KqFT@Si};OI`xRgD@(;E~<*{w@wz zmkM8|7en91_rl0s=6qZ+o|7D9@Tf`w9{;4WenE9V$?akIBKu^hUP^&xA9&dIBn+AC zA$A2#+zu*r;A-_B?&bLnu_nXeW|^3OZ2ZS5n8<32rl^e*qYZ3v#B<<*1HJPQA>=|s zqCTO7T8dgFhL=A2#}CU)!n?xd?M8&iK^kAM4r9FQeuc_8gYmAr5=E;wyAF5qB+|KW zi1JM68AT*sqJacL9?xL-H`fMPFa*uhZhgS#As=wyhJ2iXPdf%EKmRlc5Y0NAq#+He z5E&(|wnNjnayne+&dgP56Z%E!+%+QMm=8rdHfzR3auhu_H!kzJ(bC{ufNV$r9;JV2 zx&N}sZNK>03Lp9T{j&r1QW!XmE^YU;yq;75I93Q1rW@e)h*s*g{cD*!qG1JCis%v} z@o=-M|M(BzG|9uLLo$%?@j-`~WkViH>@UB&a_yszS8CsaY^6c?&0x@UsJ@Q%9Tv4Sw#JG}7Xn^Z+vFtJ=h^YxZah6rtHtrzNqOCY zK$Cx7BA-`mS7ng{V=^i9X9`x@Ok&D)lSrv{>?RCtUKSH)~el?kff`^qrUY^g_h5U_I7ZE zS!Iu3lqQ3|ZHJCxKL^(N$#F)3QfwK71hmlU}Mm|Xl= z@GOypl^(+B(5fyLE>|gv{9#PQg&O0&a+*gH)kd3^N-%YViq{|rA)42q+1VvQLJ-ZQ zaV5%R>j+cr+XeUQT$&=Ej+(bO-_#0+Yf51SqJ9bTw*z5J?MW6-7EQIHlJ}TUQ!!bX z!lgxySu6bbL?2LDP)`RcZnsUu;_G2j7c*rXNgs-(qnR_}wh2~|mkxANtk z&};^q>s@4Qv>3ATHyt@P$hvDip4MOvck@M~$USQA^3V7CXT%lUH(bmNT4TwU3z$kn zMukC8OX)p1M5E(_i$bit%&EZc!Q}4MH|R+(VXq2(bC4fVHwY_l&NpCLHqGW28D?rr ze1{r8irm87zE<(3!hU=K1?o399w7z+hA=uYOfY@?NFoaL8nOB;glR>ifi~hKDOC4R zl`HzBmjf%|DLMR%VhRj9Hl2Z)=*YBT9A6(_DAO|s=szN$c^l^_pQ1e*) zpb$=YS5<^Q=904pNW%@(OSf;Q>PR7c)E$675soCAn?KgIA|kF(Ud>4z*hjw@*OKax z_WU*vFTT?qMQNO zu@|Q}Rk3Ru*dMT~#ogPL>eWx1GWw+c%wcDMYybxIoeli58P+|EEvgrxj}S@t%6o7# z4-;iN+RYEt02u|gwN3_SuN!s|-|TQw3qGK@s|ikx(A$Aj`PO`&6}H}ZSZ=-*z#Vlh zgK$a@IWpFoIKf=V?h?z`rUP2EJvTWh?hg~!5}dm>wUl?n4gL0+bh!KK{(XplIc>JB z3Po3@aOTVLRrB)Pg+46Q~8StNN!0@ zEFbxeiZ=Jh*F~j*yokkMJCy_>+o@x)De!kB1Q<@81>M zF*1of>?y^Zn+LY8JRm?UYq3-NpaB5C&OgRL4o3moP0ii~Is|(R z|8buX{1vK>7Y%%NeU_F`BdJ<;>yX;Y(hhZ3x{ZJ1w9F=J1y}Edo)}7n)~TY*b8R{XQ}StC zxCJsQCBY*aGL@-?qn5>-?BqktDVA9^{jjLXY4Oq!!ob>DrUsjUDoiNg>JmpH+Hc0BI$yUyJCp#uNoVjddUA!KpAZX*eLEn8O^Lhp?Z@) z=_e{)I?tnt?SffyDlGEUyKOOTw>@MnB}11dsH3zGd$UT8G+&zTue50|75IPr!1=59 z3;g*ks>NF7xA(0B+^*C!Z}sUx6zWbO+bO`f66IEi5Ma9rs4DAFTy^1{03Yik>rL=) zC2`?KRs6<++5TLSvUp~CaZUUXatKfKYmNd;m-ja!Ste3nhMHQEaRR+Obn}FDtTlOK zZI@@lrC9#>QuY{K8#SROY-(h_ivjKY@VPM^}z1Mi?R!^&Rl}OU# zwQBv(oYAuM0D+#L`*EzIe@WrM}j z`6ny~xpTg_i-K6&=+-v6TWjU8hD2Vie9A$M5hQ;O`#Ijz+`V@Ne(K3iN&f5_*E&|5 z+h%euiqujkeU1sg+5%5tUS?PrCrIvmbxe*R7!>O!Z-7qoGG{#-Hh?Fft?4Aenc}6_ zt$*_jssS~$pj__{ABk)jsD6<bOpP153*tTypIycaR-Rstp z5g6!41%&?*=-uDG<$qBU|F#K++SR}rmZ<`Z>YC9@5Gp4n{~z+G)(1`4I~O3gfF`Qf z*nN`3;GdqJi2-3EE($&d6^6>Rd|#`V`-$Z9s@dUO9o5F#daQ(Ejhant~K{-BpUe7@~aXUI&~x)-ufQ-e3&#EN>O1#_l2;1S*KTv?g9SgKD)a zT_QC+7}y4%b#-8sRRmnaZDmdImsK{DmKiRN?y271k7~jyJr`&rd9^0;$08JAZw1H) zWj5TGdb;_kds=cHCQE|HvI%}f2qY(Anxv4DANb2Oq-4xH>gKBneeE&C9$Mh1?pF%8 zfB-E(xIdpk1OU>>TGLG_7Jc3;fa`8oxvR<$BJt7)ao+R}z=H2c{xxG^8`+q76d(R} zp9SlPA~ky(=_p_cwi+wVLydGw^{ygLc-#9Kjlk7miiM4pmYzllPz~+}C3#EvSbHmp z@##388eE>e78SYQJ-NMIlciKuoDEC|5-0u}=5{6{HL2LsFz|B^b2 zuT_3sm0f-Eug9 zf4BCF;pQnt>%z;0_0`-GN?Am}P{B}E))GNHeL2ACiS@-(ozI(vtM0W@nP=;gKttYS zuv{cPTwi3)wp)&cHd^C;@g*<`peN=AG2!V`fV1IZ^u{4s+JNf%(aavjEv7g~(jv0J?1&lg7 z=CiFS>`V<$@5IeKWhIBZ@9aT3#Njv5>o^5|&WXpXZ%j8)9;;4l*pdS7 z>~4#^pdxf>nwr{hdSVG_i|wD-0m%a$F^_WrW-grvg0Z;4ukBQbf*B!h%c=xgKEOY; z#gqU@ret2gr}bY_>J)7WXwntBEU-Br#Q7^U`MP`HXMevHqN#~d4FS;x^Qk~;xW)pfGxNHNG+rkotBgy7Gsd5 z>|+Kb{nFifd5~e*4TN zEsA#m^S-S~-KfYka3xqNmPkdm`8lOK=Sa!Bc{Yx2Bd#70pt}TkWov*h=#B7R)I5md z%~a3TgdB*t7>w=&Cc29husT)1q2d-uRGQ-}YAGvVsc<7Kq(Um2)()CgsF$Ugl%7`j zHvnWYsgj~z6sM`6n3SenpkFDUq^X{vkyMdi0}u%$XD+zy4Lfj;0w zKhonB;Cq>jg-5JojJ$`t)5U%Up#xQ%aN8ULCjr<1|F~=nqqc-o(!wkEIecLbSI$Q( zd%=M0381RCLHslRhS&*#w*CVo*ss1$RpMNRiCP($k1I?f3!Gi zK}3w~A2c}zKC)yY1@4dQ%>)l-xvDp}vd}T^T!T(B2sVi0Ry1X9iq9-xMS6FUk2&ay zQgC-wX?1jkP6P=i@$jaZP~t>DzXLyf^U=&>!9sR=x&t;}^6xiSudLy}6$PQb4Gs>qX|v%1avG z_hWcj4P3SAFvslz)x+!z5I(o2 zN>#>Z_ri~=eVn_SF7N8gSZ`pSw1(O%Q1CBmQ^C@~LRO+40NXS%wUmtzboABLrB+YZl{9s5^wqG84?Wy} zi7JR1O#H=IGGZNkc0WkNZffowG9UKARBO#?jdia)rO zRiJzj__RIr{r6F%cX`0VC@5V?-Imt@#Zn?#$L%^nDx#~Jx1s9hcb>*B^-Gao1!;|8 z>UZ!#w;$F3VG8fqi~tN;qM5*+S&j0(owI8sX6cB~vxT%Q{YB~PmyAvID)SrTr9_YB zkJuse1%|t~)~CUJb!6GR12B$SQC$?G@OM={%PiKax0HTpQXDL|J$aK)AIP_`x0wQj z|8tICgOsxq^Igy5|8&IC?^An~Mg2T{7jzL97I{3aJs4uL^W;yoV~fN9zQT2u13v9*Aa$FQ+dLs5xvL~#Zn)%%HrzPIeP4j&>ZkW6Ln zWHNY?z?b>vTY)d>&u=LiCACsAXsG()Fx*zIKyWNr`k{^|$Vk#Ja&sOWXf_8i?~(aP zx+2Vuw5VLfZ|pQKrMa}{XsT3{3gB>mFBZ_7Oi}8ti@uz>6Nqdd+sXa59hohCmGWHB zoGql2+(daz!#~GCTL2y@+NRLm(w-rtF7lGC5OL5Hal7Tbgp6cy{oS`Ck*1bdjn<~Q zYDG|8giDLiqlw?HS5TYcyK!%M5r#V2$1^p-#?I()8BS5rlw#rcu3jY+Ior`)i?U)B zy`-umq@{P8Vp_lJNFdTPAUpZk;@FaU>Yp2t!&i`P&oRrFqYWj6Sbi$w4hRm>0c*OG z*I!a2qaO7sd+q+ZxV~`LC<9@X_b>b~CJXn?b!Vou{?1HoR3z8S(Cd-V`B7B- zYFqPt5Z0o@h#n)2`afO0c>L9w*)oCZ4p)wfSWZsMhm;Sg+s#;teemalt{IYRa`gy* zO{w(EX;v|t(e>Vi@f=If8|Mh~HQVgKFYN?RHT`OFnZCf^aXZeY$j0Rj^HlVa@dFOt zwZV_|SJ<0h1%WQ50M7mfFZr_!j-aM?v*m5+*K(S1220#-g#;=~lBg7?j7ACw2 ztL8(9(xZiQ&;Ouj+qtu+v&z|!4<>uAbyP?*HD(S z_;SfpxI@#xz|rkJ<#=OR&=zw|pjkFYGhB{cjZ6UhoYbM3@vS+_4EgE+0^?MgbTWx2 z&=#8xAYVSJnYC%`nfg8P$W8GG=cciZfd=O{CS{c&yU){C{_Sg}d&=Y-6S87WPes_C z_Srklw42-UJTtF@^n+p9MWO+9A$VO)VsDn_TiU?N=s&oGB?S4;*BQTyE`zJL0fXjTMY$2_Dd=byP)#85#0+>SM~=i zT(d>U1xTX&f77i9xEO4&frTWIK7yL}bK!A&uy5)+nZr@R{RSLFf)ZaR4oLa}s7QZ@ zVsC2ZL;fR~G}YYX%LdDy456D1aPrnKM)sts3A4afpKs!$vWbLPp2vd;62HZMQz zTjM6#(Vj13LcB8F=e-Du8(DQxs%lgLon2^Xj>H=#<7FxLYTc~S!Tey6sT=ay(#;F? zrNMDiva1CFfqR0<`T=fWt?)CxuaZ_a2${C$Guc&^(){Uc8t3tS;WGrJiFB>y$Dv_4kGfdh^Ee12I(+$+ z8Y%xyd-Z&Izbm1d{e+TkhZ*oEU_av6U?rYIcessyzntnt}!iHz)(yJNR}UY zt0vYeaW}&Xvh(!>-FWt?N@u?Cv*UT}wQwBF)Nh zoJ>C^$Q8q@nEgn{k0izhkkOVuB07<;&=%8|Y>(K@=a%u2VX78Z@)irDv#OGUtBWBz zR2#Wt53=zJoH}I0b>i7j|0^MtdzoG-(RF8j{)`#OtX!rmwn$FomReF2OO> zAjYzOcnd|2{6w5B$zcyl+=G+dc^FSri|l1^YHp}dR-bNU5x1rG${1*FG3n?48CmWl zu<$4^LNht$uCh}{&3}N4qP7!JMumab0L8+`Bc~6Xji$i}N(@~(Mh@YJWp@d66W~*3 zE+g>Qv2sCFT<<^H(gfspW|;)T;^e6ziW>CWQ{Kai`}G^e;2De9b)0KTTRh{Ssq%kZ zt!ko=dqm#kXZDZc=AY%pLiaTWZ~%Cd+GxMM2FBc{yQYzy4LzH({Zd}>6s|elcY8Cp!y;8O{Ovq%y+(QFbZ{z_DEy!( zR+5)axrSNHtp7ym=lv9-+;xA=%0(E#B;Z*^@b%xQKPah2W*Z~1i(tp&23^>jv5S-} z#mrE#jI?8Li!rEeVpaR?)2 z@7Zo>!kNvMfaE^=&sFOde%S9F9AaorcTVdf9o^^+H$8Ej+2fj(r`O{_n|T+5MWchV z-i=;KoR5yXUstHqF!7-!T+auDL3TUKSL%Ao2&AQRjAR2&vS&&T1mCg0`;$2LL4TO? zYmn0W)3}+Hjd-Xd9UsZaD&-)RyZ=#%Jjg zM8*gvBe$EJ+xz)xKOkHq9kN&h+m_{bcgwybx-~k)Ib;|G{1IQy!AP{DfQN;PbhN=H zqwmKTAynb9)(91UqYhsOZ89{+sGg&gwqZj9k!G=%cWq=B#SQudf@=urs8zR#sWPe` z(Ei!GHo(>FYOf;niq(pvd&z(;kS^VBbq04<>Qi2XRs0rDMx4uCgmGQ>}<`BMT8L1ZOn#TAC@2L2BHv1&&-S~ zR4&7&URGaNNwtWO+o34wj0L4-RH$`)`8p<_E_UM3n7&}z@edo_R)JN64ubk?D&-aC z6B)(~gj9J`%%rGTzXe&3d=m@jqx<;$^+x(kN{%jQ-XouYu6K)k5UJ4tiRJIs*5a7G z>H|7L*GXrx2v_LtupAW_9@Vy%WXysQih}{jAv} z<&A^^XRySX{A5^H_EJPS-CQDI>IVWQ^FONpHC(INL)+ZAC2 z3dw{5?3M?NfM_y%Gr7tuicEfMHvCZIt^G5{F=BH z4r^tz2Z)n7sxZJH3Kk_IDdEw2I}bnCd#R05FUOa!%i-{nsu2=*g~fPHV5+n&-)gv! z8jcVzh&vU3&3WPjiUoO@1hFsSRISh+r;~%DVoV9eR3z9-04@e}vP$zt1nJkTVgqL? zcEIggVAlmFjM^4K@l6x!IV9<=T@7Ee*g<5k-odS&-309LSEH>!BsD=fvb>tJ;+)9> z8Cgfv5FD4Cn?zaelH$UFfK4*u#HXTHyXDoG)?9d7ezu6J-P-+L8%0J(I{>WSpFQdL z0``;i0BIJ=Ac0Uw9Q@o!RAK_Y&AQFeoQt_pcY+#}*L-glqBvr{Cvi*nTA77Q5MPrtnJK2E_?`3R1suqFP)m8a495hHjJVxTlILQ; z-<+HRW7}J{pyO=XY5%mpO{fA>q;)ZsR*=TyC;errlN3RG%HBb&@$+Wk;iR zhB2e2Il>&mhuQeh*SD$<;$U#qW3HUL~ZQPaXh?;sicKIaT##FmI?j2 zwGh{U99f`cERQaugt5R-L!oL7u}h8Z6EI4|aHa~=QPu%Bf{89dHsl1i?Mf8POb)8^ zqjKzTRf%bVBnu_n!Hds7U%rn7v}oNqqAgBg7`|$J^20H0-B$Hf;yFxld=kO&Oc9)? zx*B7<0RH-&NRAwpH=SbUQ6}-FhdJv{$m2}QrJI-VGpOm2M5!=CevUTc$+W+`_rx7K zW5pRxCehBl6hEeF5Eydy&go+cXm_t(rS3LhPA}~E)Gi222@UOS@B5r+EdPjcxcc1+ zOipgzD%NH56=K@?yWdMkU~IjO0pRW>!tvGH z>?PLoV;ssWbwjOYjBr!m?o39KGqLxUIR)rJTL#~4lq*t<(!_D>F(Am~CJ8xvJ2rdk z?g&G}n;ZZ&WfY5aYmNcA4KDY&)MkIfIF5$s?oj+jiE+{%C+RfW)jesXZNJxVzG?G} zi2cvY@h4JrNYqJ}U_bNxDTb@phDK5Ev2CYQO$)<$>kQ$}4GNW3Gs8d9R3z$;*&&Jo zzcf(lY=-1heJ;Z%cyn-P9V!{3cRsu}s;B){$MgSw z>#*Q?E69rBHYW!|R%g2LzRG31e?wyDpS{Bp?}e4(B_9u^j$r)6_7dB1BDYE-Aj0bJ zChenuP2uE!C8oWvyU6DcKr^>p!8H$$Sr9KsDN3Maf4R!ukxH_5n~Rj0^uBY@#l20Z zL8=wKneD+ydj38ySvOvwjwd_^Tdbz5^Au1+dS7GH*Swmmw6jwR#!p1qttdOixvh@y>Sn6%WP#ve*8%;N!bvd zcn!_$QoaEBtq1fcrc6{Tx4CSZNJu2~jT6leEt@O4ky?;g8JeXGf%Wr2wN5kOJenRs zF%w}gnCuTqRIs9JHswVE@8Tijd4yt1Zc4@9!Vu9lEppd<1taoq%}So&!=;y(ck-3`!bDt2Xn-i$9O$CG$52i z336JL1TR>N?2vTh6b7R7sn*JLAU4bY(9%+sclhSfh8j)qteFa$;^j>ZSAa(<3^CJ; zJCQ_Sz<9SB7}N$kXj@?E)L2v(kPu9rW={7AvS&2-KvM5ra z&^eqK?n-v`(A3>;!8Nn}_#SJxmDZcLyr45k2|1(Tru)RY+}&L&xQY>iw@E928#A#& z{JzaEy%u9~Cv9xcmN}vp=hIe#+7{i;2~kZiMJ?bnZTv)`>v3W_qgCn%0QU`Aym?{Z*!`H3KU^|ekz>PSTWWRPT;}6(bs3L&{}8s01SPb9K=;g)2hJ(rd8WEg?BLVqj~{r-eI9+ zN_N(LbIrnt-~6z?UuZREgTZ-geh5OlsZ%ZkPvWq+)RQm zWUS66PtO_-7TZq=9W#rD>iZz)m@a!ykU^wfo!6aFWIEX>1S^3Mo*yjt%h!m})14ix zB#3F)1S7r)KdH5Z+i%i$={B}M3omeHW*g&j;^HZ|Q44%9yg7Lyf1qaIDO&Vy%r{W@ zx(1Oq@)6m)SqN@(G~dn)PO7&snwhCZL?inh=if1;9Q0H6;*88s@S$Gwry8fVa2v>t74;KvtnDl>vtZG z^PC<%-uLbPqw@i-J#yW9&wH-5=9*I{AsHlO(%xM59ps1FUPF4uFjb$<*Z^DWH)SwN za<(S`1%aERq2QmHmrEtv;$C}3Rsvg#3dM_)MV&uw=2}l-zef8L@}lM7$P@1hV2Mwc z7npAL_pZtRKhn*<-gjiIzNwE)M$LKhf1*!JFT!sjf>w-ANd4Kv`=WT*t5tP+*WPHy zOUn|Y+W3J5a4`@xbaXZJEYnkS@Wt<+@ zuWWSwh--Xxr#T@_h>mEC;KA!w0|k(>eWySFTe?|;|DSX-vX4=)2{*iV-r^je=H9zR zPk3tH)PMCwu`jp?mRj>kxX{LkTyuX2hO^rqRtPN_9+5Ewwrz)w9-F{3S9y!y`Hf$G zdb#n}pBW2^p~O+;R%>bh;>E;&9l9;_^-G>s=@l-g&}ODC5xPx6Cp*9ZstOa)Su*y0 z6rXOV)?Pft4)^#S=mb2wIv+^@KR-llPQm?wjyE7OfclRdupF@1O>}M21{>xd!chuC z9|we;%8kAi*`$ADBz2ZNO!acOK{J;9n8ZV#@kSaM@4)fDCVDb_El|@>g^Fz|GqnO! zcA!re+r#8a>~;*H4Ln&3PzXFZ`_IV=10VHl`M#3R_bs{V6o}lg5j4CWvh+oLdcB;OAr1jJUjY$ZWOS8#v)kziLdTS^48}Y z-^3F*O^#;9yV+&20%Z^*?bMUj@2%BU-dY2z!&cd+YQ~#hQ-YEDmes9x@ zok*4D8{+5tb+3z!OnFd)`M!rwNSEN0F@m|YYEihWBdVHa6hgP>txu{ZI_2LUY}eUN z*DFU27gAtmn_nQl#l2f!?IMMexo47Dev$o&VndT@1R6Sb?*Nqyw-VUY9Ijw!tt64bF)N`{oBO?qiIHyNODP-gDLL`z4842I z(TKZ_I7%yqJA57KFIv^aTy`Hu8)t|R5!!7UFon0Xod@%&FGFc{7RQ0Fs--50IpFM- zh?(AK{p2I+R8|u-Dq_V{vW3lBj8x$b~^xYPivi!k_YEl1uRyBjeB7O)uYzr*BGIgrBj`zx-a}5GwlO zOmfhQP<2YO%a6XGH5f zw%1O+!Ch>%ZU@{OxDhh3Zn5IeJUm}g4l8lyAGjidbm1<>SvQX>0(D|9w(Utid^Xr$vGJ%&zq~2~a|T zp!=!y2^wy*siM7%40y=;bsQwzC9jFsbWorGq zLp>iKn|yN#tGuooD=CYByr8tOa&DS5@LLD8c&2P@VJ$Au0Qx&Kv#?Q!5^)JI zFkn>3Fp$-Aa&^--N(j&4RB<8{pq80Ak{OlpeyiHcc->KnP0}I+y5pykFoIX1{8Iq% ze;_>q{6o{p;cU^gUj3l^;e_Fu&zt-E1bi7O3jV)@TQurf+U%Srk+Uu*1I*2Bpn+&=tcj3uINLb?*)D z+uVqf_`SF41t+I|6$u^Y!wQMnzGQd1=B>HvzOGL&epP zIkP7>`@;Qn?PE6%(1~yVaSr0|4y0#8tT7fsDZ?ZINyl)TEQvn}7_p4$W4SmOJa&`A zHMIdh9T3hM$^O{4joJ1S{t1ZC)(<2zZfqS;MC7}L^0e_HG)B`L*t!nW(tPy-2|97& zqN}g3XYo3OgfyW*N0j?|IfevzG}$hAzEb53-73Bkws4KRGMo-$Os};ld~^OFKNW*8 zmXp~~r!n0xEe6H*B*jZBa<&e+%0c=W2K#P6`t;IkcCe67y*e1T0rc3H-1uvzAU`wK z=V%+(TBc7=zjn0q{65be(@ckgHqT_;h+(8Qc6wv-m3&4q`fV<5^IC9+{d|-tR^7pA2E#1f>aKp%a z!c+Th#Afxi)%!dKyO@CM_sku|AaY&-Cr53G2nR5S0Z?$c&zA^AFz$!9e_0!&!sEi9 zB>lRFl+w2Y9}D}$mryL_=WD-r_}U^WR;1J1W>a+l%XtVlZI^+kp+( zfjBNboseSx_K54>$%!yNL3FDV@y&m$|KBY1V?eUBB3kz-T z7BRBpG2}?mZ?i{2ma}293DS~lRrc`yQyD}d9tNnM{x(iYW^q)_zmN+92u#SL?_|QG zmJ}gM#+c+~1oRbxXvdJd7Ov4ZOc`~rzbLzNd+Z~r*GJ?V?~aY6e^(PoIdXC1CD^zz6b#M0j9f-|K)lC`Ld5Vc&Ed~h30 z$fNr^eHZ6}vLK;~+DmrxjJcj}IR1w@@fP4DkY)s!POCmFO{Z>8M?K0gs{niDcGawO zIZih$IUzeiqew|VsW96B1O>um1eq<+ST5i-{_)=vX3r1XcyQ)85svbMu(ny~-j8ha z={Q%J-}4lM08AGmh@C+ApUMN@!PT$ewKt-!Z^>9PuTS1nI&1fv(X+?Dg%I%35+NSM|? ze&G`B_NQ6OxZ|2w%%9)!U>%gWIHo*qepb){8tLE{x=4T?OL3jH!HmekURj2sK{G_f zhv@{AxQV&FiX*HKH=zB=d}}f0-1jShq$^i5Esvo` z5A>pY8g;I*(Esiun#lS16~~rlf8>P_L8^9owA`Q}xaL-(<$Rk2_}U7?B>pa;lFmg| z;N16PBS0t5R&+@wU3&BV(njnwGpkg5Z?eJOpO-gO^8~(DjYO)JXrlf9<8ML-zB`Dj;sg*V;kyp0D)fZr!`8KBc~09_v;4`c;=cp>i_%&5*Uco- zoP~rg4g3TSOo_e4(Kfj9Qn#>)eG8fL%I?rGWc(D?e|H|}s3u$_h<+F76(_fNuFPR2 zzB=+PF)i&NU%dLgj;F%U*f@=C#ZdHOEp;f%s{@~lyl*y-2OVr&CREcpKPnOJJh6t|*%D_vw|aTun0dgIicC`;q4n zz-}Nxcz=mo<~&BcG(Rln84ioCe0>p$f+FH}3x~AwzMWLY=@Kh1b@@d4cCR5w7*kfB zLv}hU>A5@jI`F_UBOhw)1Mw8U9WShW%RW{yRexLo1t-pf`#F^9ocxCOW%ADCy87$% zBqssRHOf$(j3msMY$?Kip7j4tVTMNDq8eeF-jN@Vr5X3+=P@IEA{^^YT0qMYy z;k%>=;c!tJxhJbC9Y5do4qCo-!1r)|dcgP^0&&weu;uzM9{V%+w2kq9JoeFn9{U(4 z{)qqOvHwN-?;iVXK#zU#@aKq3vYzX$>4$-rxAW)%yA()YE4DGZ3c(wO@6)_G1xJok zV`*0PrwvD&rYM=2YdJpaDL{+;r62oCAqC;8lHVQeG%qVnF&51^I74=IrD`=7vTc-L zN7g@;J{$@03VgZnRVvM+@))(VDy;0qDl%N@YHs4^S!QQ$78()!v_J+l*e{3f$_7jy zc%kQOiwoKz3x7!iJeZ#?MN4}vO_vU%%Ca?oPl~0X^03V`Zv|J?PB>4jMZNh3ZVsd7 z!J_qz$KYXtd_ooDdxoXyLna#Ch|&$tL~`pv)O7eN*|(=zdn4s2CfBAyL4k5yL|6;c z!fj+!S}=}5qL@^AP_YnXUTEK^qe<7!^ZoC zjM=gI6*tZrOec$AeeIfpTY*JG!WX$2;6$yg{#9#Eud_%*hXe>=KMe7$L}^YPIw;c5$a50jIz?nh!=NzC>C808iQAH@t}wA&8$OV zw@zwuRx=QE&9?wEkPsg|Z+DZiXpG#U(FKi98Slod9umt_xAaDGTstB@;fg`>T}5*8 znh%K^2zP0YuHXiJXhd-#Lg7$q;sP!2@;piXAOv_g9l~1+!mt=XC;hLW-CgaUO%5FJ zL%vsL-vzOTS%}mbXoYzzEl|y?hbZW z`^k9=5!0y(kE`k(DYjoUDcIg+=8eX+z5FwZxcA5tL7++v>C6JW{pyAE>Qhe;r1+$U zDei8(KR|GnIBnp}v0ZEH$+&hMH8P>2#Z{Y5LpPb&?eOH9J@qQC26S~5wx8x!JIbNg z2|7(42ut&t;dG=tMr70>zTd|V z>>|Y%ON|xKW-bLhZm^f(g;ogbi8hTTeI;b~P@J>IEI0&Y*KP*z(Jb(HwnlB%6yT^K z{mt3{vy3cNMR}1XBP64>K(beD@1Se&s9`F*$zz zcs4s=@HSUExl`^%xkl``wnf5#;_-&%o|317r!1w0Vcc1-doy%SEHv#j?v8=SN~FUs z9qWETU^vmf&pxe8J(F5!C2&OsL)U9lu0CQl7VSe^%EK?mc`k}V2VefF`WNfr`7_Qr z>(sh1d};5^H21v4!12uM*I19vbtGu=-=Z;E7j1~9oieNXaqGX1(>NW+)EDjD4zntT zJXHOpQ&Y&o!Wz_j;vbv*791AWfhoH0dTSV$cNIG;It ze(ae!L%=&nSs9m+GY%?;=V z(>*g9O83n;oRzWQ86K_uZE?=piO$i)#?JY#9leEEDGVvm6P^;C@;skuDg~G-5bghB zS+;h@CII4`3{G|HdRG)D^@5;r+~Q>3Bkn&95;0plK55hABze$+{<*V+G!MlFD%HYCFvDvRR1OTZH@s*El1=hr>GX7MrBpJrr-<6rI~yIfYvrt z$~~}bpf|SmICG3>>z{g+wDrrsWf94D=TLT&3UCP&YYa6&s-bGAX zIS3C-DDgt^$usbQsj6ngnL{hh797}csSdwiIsbYk6aPeD@`2CtM4}=o=?Ee*U`-bg zrAy%^+URyNabfW2&N5qYi3o_3R!Xw)UjdwQlUgu@!yN=tz24Sy}D z)AIY8Jih)FH1h@r%f>#yaOj79*@;cPy+w8g&H9*i8ec-%yg=4;l2Ik(Kb|Y)KbAeF zfmLHo8fm57Wp9?O`@%c|3m>8mrHOjCHMFWm28a?-x7oGI(G*hjYX(8{@bHflwdRRL zpZ^-#+WPKx*3<0p?*5{QJp4>AHy6f>gr?(K6$mVCG9&TR?d@Y+CZj*nB=pf&2*?X= z6Gpztx{jY^qDD7c6TVBkM^DB|Cwb+J{h?~OW>iB9eJxgpD>oxWRt3s!%h`oCWNTvS zp0M2%0G_tW0tG3!8sQ#z)O%8AaRQ2_CB|ZP(9TE_s`;D~889Ud1gXQA>(9<7)@qg~ zIEp0W0kZbo-)d8B6KUFA$X)ozGE(MY)xVLlbIpF0-fm^3d~`V`DqcP3ZlEWLa;Ph( z)jg02%|WmhF+oxCO$y1pW5^Z^z@1Sg#UpwNV**4DKHl7(qDzeV*K2rV z`DzYg%_C_Q&V-s7i2f78&;jC1(JG&tMb z{mFmj%Syi3MDdnX{zY!DSBsDJ)hL$DENPpdCUWgMY*$3^nU#Q8d$( zxwNl30*;ihI3{I2=pckowlm`l9>eiukKqw^WQS}MaCic^`Ef5wQr29ATqE-FexGm3 z#g2v8w4;~amCiW#%28IeYKmu^sEorUr?W{-2Dfl|cXdVj3cW_z+LSPVJU$(}24i_0 z6Y5$nZ;@EZC#~{k)N?sbuZfGVL0%A!sMgPLVV(yTtWt%SV-Daa9Fyq_E#qE=*T1C{ zvF@_0NI*;)&ciRXxvwp@S91=?mKr?sVR{B8h^rRGHK#2&7B-Xg_T(!sUgHG>EIvTA z*2cil@_i@Tws4;DE$bKA-0<$u?4z*s)4uoeJLmAW9_5?|pd5rR-ka+p)ZZU`BVg7$ z0t&>s=WRmRKJp(w%CmO;(ImSH4u;+)8oY1)l&-O+ej`)hM0JBhY8hAm%i`JJw<{IA zs?+=&-g6Neft087g0AiPMeANhxFjua{%5?(`t5wjeBRIaSK`>~g%h6cu5i=W`LrfR zZG-g;R=!`2LX@L|5gq!RjR$8MmRmNJNryLUR|mwUXiN&CTmx;QrL9k7U)w3@+Ts*F zN7voNrWR7C$njpXY98WR{;_ns)-fSqqqddd`VNz)%zbd;^&znB_1O}B+JveEG5yi$ zS+aEt<4&HUBw~s^i^3+;1DdB=yXL+t-eEWB}T`gTpSQ zzXk9`Y6QsmhyjiH@6pNW!+Fk^7nqla=QWhcDoqL3+5L2Jq~KAa7cJcGGh6$Jhp7|St=HPffdjyA1|iTO^e*jRXWWvj#($NUk<4WuWjNJ3A}Jz`c7 zj&dIuv_dx~8tc3l)P^6khTfI6@fldSszEc=!WWk6EWR>23a7Xesp*eW)B@nz@#@qr{ zcVUh~<@>`%e?OynR_JSnIg{J?yZl+;YzVP1tX&iln+o^B1O<@GLsVA*8OZ-h7Eu!Z zTCeTw>$Q4+H)Qqw9Ivw_s&^Kt3er~f|1JYLo}A5YtW@YernvlofvfJ3^5r3AgaEkd z8xQw|+SCfh_>{YqrmR!j&KIeFC_Rom#4U$fD$>yz?ys#(8#VsVYb|B(FP{!T@lRg4 zIQAYoJ`eyjMaE3PPBt+7{ja9jJIFgotU9_ouLRt7{=IH@cKU3r0qM&rf~`%QRl<%8 z(x-C};6(Ce=rP7Ys3q(rbaT{UM|-1ym)Y2@!gG_$@20dTd^rJRrw|Fn&i@=7Sf!7$ zrdsqNEc^ui_T$4JCIAedAmy8Z4aNT!3H%R6$Urx$xHwNEK}#+7CxVyc3E^ih;y<6j z|3^!%Y*Y*#WwRfcV%?v74BOIeChDJjAea=`JW9#-pG21lRkJwoz%Pcax<=j`kGiL4 zr<$|<^i9B3Rexy3A}OJAxa{hJ0qHzo)pLO(9hKV6_mL73@MTE13V7Wzz%8QT$5@9x zYLpn+3y;W8iJ7sgQPqw-0~c{`zC-olFF!zjbt4M5{{WgBpK1IvAyAlvqz<@)QByb^ zVF=v8AfSrqXvNMMZm1L^=ZcSDDR|#>b0a0wa;-u1SsIHXtaaZMct4le&t)dW&n&fs zO8)vYTh~a$S0|~MX2#Os)FL)1`|N7(ZU*c~{qC5{1f49cjahXy;vV~q67iF`72AcD zVuW~QRK0n_Z{sr@GNMJB{ZFG66qnB6Uo@SI-W0HD6zB?;XfR?$ExvJqZN;EevBXz` zXuT*_B%)zTf;Uj+3_4$wJ#U19yap>^k+qFq!FiE6*jsTw;U;ZJ083MccBb!W5MeI6 zkj0(4GR8xkY`LdL^|FpPR;z)caNEbf^zg*YRsClt$z5|F{VKx8rF2^pD;B^R)aC^S zy*11VE2N!wcBADQ(c?>8zQ$YTv1RF#GDW#$#8Q>m7_T&M zVI6_iPKNiXF9o!s>|$WDCTCuOHJlE0W_w`CX8ue6?O-@PUCfNKRKPd4b3Du%B%j+_ z1VUSnhL%J{+*m^}4nGSAlPKnP=*%x-+Fu2!p_=B<<;VFTS4oJ!bieHi9^$gv$Y#lP z#G)O~$u*ay$+O8B!8`T!R}ct4X83TEKr?u0g3ph6e~RNXG$2VA9_O!L%V9jPiD77G zmvc{B)eB-I_HL3?HRitNf%n{jr6SbKLWUD?J&~FN70oG(&5rNhnW?M6M^n zpJq``NH`Vuw4X1Q_9;A@boG?Z5h!Gt;6|FAwlA4r9+xw6707KxIv)}I^>sH~{6{^U zZ;Rd@w#ck*)cSr7wT3yctuze^V$y zj1RRBL-XwMCyvx(%EiP45>ci&CeK^j! z?elA{E^UXj8AS3WeweAQV{0QF;v?cs9g_U?NXZYvBYe zL0EipIb7iU{@IM$N?EcCeUPo~o1;|`+K(y{hzjcVhz*dit@kt`w70|Z<_qQ(bS-L< z$e0h#tezNuv%teVB)FdNAI><2l$BCq=SGbNp+pKxN|)H4`%!iKtply@ZVnwvYyoMt zSfdVKOp{7OGABh(%1&MT+Ir7wvYZ+82XQo;*LBuZq}`vG1wE1=M&?z=;+j?BAIFw+ z;|Zd)cB(XlXlSpf7<-||O$~45R+>^Hk95fn=PvZt&Bosv%JiZ<;9rCl9rWv;K&>)}RI`od49 zOmb3hflH3aY;R?&k|d;#YLRt4>7cBJ&WM}{?{sCSIyy6shKZ4`ZPb2(?9q{AG7qJa ziS$N~VQhV$s6$=q2oWS8|0&deGyziR4YwPk%w0dELi& z0ekwT5>$eS3^ifow?@ye&zn_!(z$lGm`9*JM@PQY9E%rK3|ntn&4#iJ6jn3410u+D zU8=L^@#V~@CSTG;NCIUI{eC84FMoR%*uuYXfwgmu3k<)QwzSywsNOK1GI8!L@zhbu z6jmVS#)n_$`dM15P~Pf4A%!K<)0=6YsG}u=%QnN%J$}fGMgfD(M5GU5`J}s*i0p9D z6rr^nIltIp%P8j6fn#U76Yk2!CyF!^m3cqCB@HULz_KB%SK`v9%3=DMiIH(>V0^sk@2oyw3xQ(!BEfTdGHO=u<)$8%oGVeAo2P(*_hMF>dPT=&?{pk) zg|?t^z-{Q!!MzgY#z$Ry6T?3CoBk5Qbqq>$7FqS(T`1~zf91KT=bfvVZrK&i$i^V` zahOVfjS1T|7e*!5flqjh)cdJ*+Hem=AkeZEEE&u; z{LWk`V-ZU^4Z~xse0=#8IrRavGvmW_U>B!szpk^CRRJ8HC$s%bgtV106(Yh?U z0p4Of4C^GCFUtU@gmH$Vg$;q+2PS-)`Z2W<+>yiN_{QSICO;YeY6_Pb>IVFh25+Nd zSk34HVx*eBtZ$PdlkUEw(S>wt3I(-h)&yyACKQu8olhGu9dSOBtdSXe6T_8-4Bnb! zC6rU{p<5SBs*o`}VcH(F_d^0H9Ln?q1zoHb1Pd&y?j7s3-JMm3lW+m1<|b?#`lb2{ zMAxwn%iJw2bd9w`TU%>Y!$QE!oz9eji32cn!uZrv@NsV-8~YdSTd-h1m7!hiX179W z>@exE`lL@J`X7bboo|s{U2O7g(Nvov;oF57S;j)xU)r|`gx?v7?aWlBq-YQwv^WVNV_v#RSPri z^?|co)r;DSy@_4Ougv{meMa0+&yW2j^v#O{%vQuhTN1rrqsnr9H~22L9YJPRZ}ZqL z`sb<9qF0dFMkuV2GO~pljK8lxG07&p(7Woen=`-P1^L zeuG-B?|_`zBw}d~5J6Kr)uL5B@sQ#0NKg(C$%E~J1+3~aSmfA4E?B80t4mKdZ~GDS zL!J+-7Bq0b9)k2R#PsGm<|Y%rD4=#*X z*koBI3^$Wa`noL`pRnwz1?MuH>*DI)(q z`Vt4FIkFeyEk-O_N>(W9@ugC9pmae87Pe8RQ3tRC%fkD=0_#_KcWY;8XZXbe6H4D} zBvKBEZ+~22sfcR&^%rA@+gk8uV%soKG=g<@4qfF4j|PA?9=cIOHe)uee_I7q0jI zh3nyUR&dS#j_U@p+``xtZUV2n%@;^+x^h3$@>qvySD3}+Y!fO$ja26rNdM7zW)=k8`;C49rzH_Q74=WFO{AkEbG{Rr?96`}@@97w0cZKq;^ zCN!k6HJ+^l8@cyL7DtXTaWzq5lq{o8s6R6){UEX6%hvPx8%^}Wpg`UgQ`RK8rgcbL zytgBjCaxCD%h1w|r;J&p&`E&Q7)Nwf>^?8`HGt;SVn=2#>Tt+feWe>gG|gl1KDSlD zb!Yq+&qZcW`_iFI{jlUl)SA}wU~*(R)NKBw$iHXlJIo~yhtcwUVX|iGFwg+2 z==laO+HIoQE8$!rO3W2s#?tV9(M}>7-jHcP2aApnDAKlgnAJ{l7j3a6uU0?Whr{~O zZpS(`HRf2mU%9hF3u*I|%#~d^xe>=#-ZX`sPhF=XQ{S|I#Y zN>M8oxq0c1J#;BLn%(^mTIo*yc3k+(HCz^(Cwoi?B^^||8 zZfHBYUZ&RLY(ON375<0<&0f<+ao6E}M;B^IPM6IR#PS^VI&m)Q=1@D_cn767bL+L5 zriCN0zLha2{K$sR}BLM5_75zk~ug2eBcBO>G-%Fq z#a+r(`cv~5PuU`$-bQaI(pQ(MP_+UKfw2+()cQT@>vAXW&lJL#2NTRUzxBGtO;fw@ zGf4{W6&DaC66M$H5yFq+t zXJxB7ca0;XeDlPIcK5o98RNdj-p3(oJKk|nX|i>GTZ(ed2CKI-;UxPi(#$_&;|tmyUT_qIRwtdWasPEdHW}D1k`>FSuqC z6+c;LW^mfO)~Gv_N1$+>&Or)w|M5mffnmsHIFXZ6JmVs@tLZ;hG+Jd#Ncrc8OSLsmHNf(`(5J(wYe%^`O(^TvvjjE7PVwy<%#=#%~#2fd6W?5zZ^jhn&$c}z*rCH>seD|zxL+k!}+_<$dX?~w$HO8`KVqfi+9-AA^YD(t4@>Ta1O_tzEAn=RJ!AB$j;$t7Mb%+85 zCFVA@YyK9aOnJ;#p#S}60_%0V){oLk%LGB|Qa9NzGbx^gZ&zM8?){t4>5y8G<@@ke z+pFs3b_+rJL%(K6g$&8qaV5^JyfS6Vjp1Cnz=t^lfW{w0AzPxS>2iszYBfniWZPP1 zUyZMND9CcBW7+&srX7B|sI)pH8rb)>xHRS?IBa}Mihuti~C@bexE9xPzKxN%1o5Dff)0%nfIvGRI^&lmga>_E=gvAhkNQ=b+#UGK z8neN3lKEy3asq}G-2r}zHH-f+84MNyBp0-c6mV!X_T3Wsj}=I&)R3*<-4VA!#ezA~ zk)Q>OEr??iS@@Zw_*2`iB~-RR&@a3TX{L!sQJLt3jdUGF-wZkR+X56}BrQ|?wU`gn z6`4i&RRs0?xW@*|z0T~qT#L22C=ot(deZ_MH=`50lp3b*_#Qs_G4HPtl_{lzb&787 zOY0FIM+c#cFsi{4!b3XmzFa{UU$K*HOG@BKi&vS*TAY%%v|YpS5cb_rJb}h#h*}iP zl^qHFp8{y2iU$f#9yG!p$eJr`-C>I8pI)QG9pCTDq1MJ4FB9XvSQtEvuxq^NPY;4p zjhHZn4sPz_13MP5t|tM#ELz1(YxtGMf(9rGb~DIc1vlzw=19qtZI>qoD+n>?Q| zd$_$k-{WjFlx@?gQ8xW>r|<)n{sM8o3mFP@TJ<9H5OoYfMzi`;5RL44&>AWvLDV1a zc@~xa-btrRK>}`s$h=ROOcWR7RL1HnC{;iy?v9<2DCqsrj4z8*PfN(Rm?+H2sqx@z zW+MS4ekFAHAEaT~0`_C?w(s7X5AJuO-27l|Y{4Y{*;}BYbQ}8oHT_zVWf!fzfJ_Gw0fg=iAJbY{Hyf#c@WD0i=F$CE;jK=Z|O7N)E7n3zcBXN7}yt! z_q8oDwP^_yj6$gS8r`~C8k#VpI^O33eAMb~`n8f`Yq|V^qDKFXy6Xr|%D%OFu<0&Vq z?FCme{W*~GZdoBNp1?!_^&ehjPhTASNyQvG1AoRxb^KgY!3&wq``j7zx`T>rcg<=# zG4hhK#7e-_WZD4|vCl z#>oN=dooIroj#5hg*p;YKqN5rkxzj$@_$SY|2}#Be|<)d>{6LAGUlXyUjt5~&HILZ zXFL&^s)zOuqv7oXn|F(P(8GosdF0GlCjHHq517qe1tWj8!W?evov9;={Xq43fy^9F zEq}9tU{#cXlUVei9}@q0LXIbB=e-B+|L0Of0PX*|v1F5Tan)1kOp}6U4CWOOS#;{Z zbq}17qbsWeg~X9y)m-wuA44RT+%Q>seQ`NG(}g ztrqB_D=23uspYF!b@20iVdOPxAVahi;)xr!P?Rg79UBeMc7>910@}g1R*|(dbcB=`3GZs_SLHU?URE7sn0hXh zL3`4&1}Miv)mz!hSo)^+6qlat#z=Z&EXsZOy;!2lD2hrd8al#ABn}lBu|4qwBaS~h z^eHM?4m6)cb;2sBT9lF@pY#QqZj3!|Ivxy+`qMGL)38*fWoH7El`GQY!If^z^E<~6 zu|W@Qc@0hZ`|uf!LY|#-QybS?U;?5giV)$V;aps$T!abqHhNFQcQ3UJX=XN< z>=E~Po1P+_SVgq$A{{msh+ibxHp#kgm$+iraKJmB{Q>Ja1Hr%^cms4B0XN)5+qlu}P1WjzZ9sVJ<4Vl%O z^Mj(Wk90f&?J@7PgZIIo0BCeav;-FB8>L8W_j7Ln8+YQyv7!g1beC$vu?2`;n{SYi zrsU+Xf4?|S%>j5rsLA!Yy%U4C%Za_7<7%ZV?{+_9*{lgH3+(?mRQ~msAv^Q}-`V{O zYyWJDs9h$5L@Uc^Ih_*XL3YKM3IxDSN-45k1GuKD!UwdVLQajjFKynOnid%?cM8%ZbUN9v-S=D;(UEK0dg598lx+-V3x!>cc8c9SGug3 zNPa3%AeFBs5sI3Y1smW^yVVBrD2(ySZa%H5SIjNM$=E3-^n_C{G4^xD5O1GkB{g?bsFI?nJcTcjoIbW%>0p*i z8oDT+Rgvi8fZBi!4e=#BgOsG`xi7RY2-P$LlnNNc1Y}2gd)1pHAL{DuZyfG1FxJ+) z;=Xp|Loo`zA2yokzK-fHrkUu{^ym=ubnp)km$jK6ZF@c5$7c;APKH2u9S^Acw`?Wdqz6nwX%Z-4HQx#D#j1216avrW9N>USMH9soD ztm%q*Lie>b?stJS>mwnZM1|bVUE!@>Bui?`&5wS~ObtrBZ;M|1k@*;ZVmqFaz1XU~ zHmfKC`@rdLRjf)5DyUG3nleZf?)?BNfx1StWZV2zBoYs8Y0|53`eQS)&nGFjT+Z}# zWKwDwv!38$7C(>wWru!vMy+hF$x906P6+It&5$4p4#v57c0N6Pq1xgGQ-`W1tCsXX&=%kfy1VG;TIn>T{0jKsXo_xX>HOqKjmSQE1~_sKQ64i*<7YF@>3%D=*6l zo^VZvHnDQioVfuAW!DR&Xi^e}3psn!tasKaH2p-Vc_T)3)Z%y4MYKwWG^sQg#G31| zpOOxQ%)UQdT-&!Ipn3br4ajf7dc= zvXud0(@_iF%fqTT0-6E`(m|*Nb3t9NUFPUwk!5AKG5bU<~ zR;s7O-2XPd5YgE8@oPon0dsA}Q>rQv^|cy<<5R!@*_{mGr?0G=u(25a4irpMEFsAQ%+; zEq`#2u_y?@2MsY<{ZFB-gfyMx?9-T+A4WO3Be zk#0;zxwDF%P#(8$kq;sPd5ym07`t>Kvp#PcRg`j(g#wgaE@_nsopXxCsn8LH;v}Nt z=qP~^G{5}wnJxAPVYQ}>C=zGnbd;5AIs3RvZM3oJS78PtT$$bQ;Ku?aZ5%l%ZOsuI zw#kDw!TlHg%>w$o5$oT-C>s5mFMr%QgTx(lL0oLI<@fiI8Mp`{5Yx8()Pxpq{Ryws z)qjgzr4^#H+S}wPZu1rzqIk&%ohjN#-}cD1s4`65pAg~6qXls|#wcvV-SaR;E`EcFI~mAhJ{*oRyyu-&9H9h z{OSfELcRZqIEHa@(igLYYiUx#lRxd;rcv; z^lV2FBVLd?|w zgk>t`4ZdDpiCNGFc~U9cOVF-7B6NQaVLDzce{BD1a`Xi&jR_Hv(JQWU9^6HzS#p?1 z0_}q!u2c?8;r7oJ$#3)$cZdkq6h5tKb6uX%7-ccomgEn!S5wrF%*Pi~?qr9#er>JR zXU0$p8)W*QjNd{8%B~ynjkJerCB*I#;Hh1$PNDqufE;qbInp99QBux9!P3@OvdqrV zQOs1Yj7?qZZ+Q%$X;ET=hLYc+g~WUvMt<`8sIqEy7L0eGe~*tEH^hS=4H4HCQF3CD zW{psqi(sp4MMt*`Fs8!5~~Ft zye|I!!~Vf@kR3s(zV<5JBO810Xa`d7GCi$o%fL%!$VH|8EvY3&1S_0ZWAms>NrVX}yVAwFRDF1vuuj95ID$wJ1 z-=#0FuQclIZ1vhnG&5hk-{msl zJ5Bx1An#LZSZt4#+n)!PsGF9UdFz3=9ZT&T{*1TCPz_Rt5KjukTMAm%HKUyEGXYueHoz zH7TboaW7Pzx`T<&4$51pZw%+r%e5oxP1|WspGD0Bz0GY$L~HoUWLRp_R1RO!+9#y6 zcWXNn<{imEutmj9tx}-zyd!WZQFerWhi#Xa0Rkn%4kc%B6VI5@7B3y4{rhQb`<6|W zhLJVMqz5_ncK$Es-ZH2THQf^48x2lyLV!SUOK^wa?k>UI-6goYySux)yF+kycMZ(W z>2pr^t*`H`o~fz&=Kot;UU_sqYtj2k!x&HnRh~o;maRd|js_q?%+cz0nKpoE(qZNBr8Uxvgh z-l?E>nqUNd*s^-$2(RyA;u4&~(XjEOOgT4(UxS1>$JHs? zUhuNQ0{!a9x$wHCpqtO9MAN)tYVP1NruZ#85Q%bs#;-oqIZbXKGh8REcUP#X3-HGt9KiXz5~=Ael)5B zWwa9EJg`1r(fIGvb&e>!od9_)4pVU{8sBtf^Jq2OVK9OnD43W(<-i)tPT!W@8{X-|DuNRW)K4b}_~0H*>1`0xB0%M0Db07;Uk z##Pfo_=`kR%ZZ$YS}*~>gk+V4%x}{{A-wAIEH*yE*<6BG&%Q(Jp`jA!z1H$@-Fo2M|EOMN1BvY);kx3ki^_6R)g5WgpgDIE&{S zNg&v#6&6q^v(o~NW3}qw_u#gMgSAcUd~)d;+)Llul`G;Jp#h^U_w_{QC;eg4s~c?t zR=Yrr4TV!kX3yRqO*(ZMRXcg+pWRL92Yo(4IS?Gy4D10|e5c_PZy~E^?ML)hPfEq& zMTwp^S>USSXXXlu9Hs^JM1OYQ{X~!r>p&NHnW%!iJ-;KL&9Y)E%eZq4EOSAo7Ny#P znc9d8Xm10x2|)CvF)3e>Pk&L`F_4nLi&&#G(_C#PmC!GImwgv$PV?giQof26Mb{>He_C6A}QUkgy87*UdUMQ7*7T} zVhJVKMz$xSuXAfSUKQlgk)2yGdmMu3k*Og^Xnkrp!m(3#trNPI+pq?;5F!Y7jvvM) z4GOeezXZ5w4pCa~6voiLw?JZ*dkF%sYPehtr*zXs`1a+g@ZF&#1DV1FO zFWA#6G&SCH4xsNk0s8I2QqU5e#p6pr;W9k*O}l?Hw6CX^LK z2@@P!+KG|4jfthcVu&@d+ z-f69Chsmph8rVT-)B=1S{%OUiG-;?)1*SZ<=C#R1x5doss5oj(lG>0{xYe90l`Ph* zI;**Jv2XTbTgdKR8Vr}^Yjeub;Uk{b8CYmSY1~$%jSU)Sy)Qb-mJ{d9pGTXbV7?x( zAEW285hm{Vu{MP&9R?a}q*jk4(xcMn7}TpN(=D$W*gK*_P6-;f7zk8g!?v`9dmGKP z9x(E0d&#@+G|Iy<=a^U}&;QhP4Y8oZXY$Ap`Gk3|rZRT@4RMcP{?YH$t;_*(G zI3(D=Q6H&8@TQrl292i<8tI*^MPH;HsxA}N^Q}8f| zhfZTlBx&X6yA!&=d&8>iK+8bL{_yTc0)bVioQx&^UYSAg$4AZ_(KQwMd8aQ3oY%fy zas>@izNzG$DzSY{IP7N<0QO8=ef!OVQ?wvNgwESapLh;l^dpkEFd*g{$$Sw7Lb;*y zn%Iu4@7w5MY)vWn2h|40IURJ(UVvsDs8o56@?T4p2qxu8Hxt@2hu`CssP@cLLh$ph zewQjA-;kjG4=rLE-8Nbqw?YMiP7;#vK}WTbaY{UxoKkGEBD^e0^J3v!MvAJDjqB?w zIOGSm;DL|#;D9t6D&*StpukgV1SDOE+CclU>kd6uh7$;Z#({#FW1 zrAW=h#y8wOWtmyNT}~96n?%|$ETR+}eOf>#hj@9&lF$PR$|Xv@O0V1yYWCA;hm1@H zDrpQp9(b{?!*!&GqYH^1)FvnQ6+3B@_@0k?O~TJ;$GvOOE-EE;Akr6mnSXFGT%#|i zh6W?EewJ*jKY~U^jK!Km!5WERlI`voXsI`jOb!V%G&FPwaAs`@N_fe}Fh^j>d^F;E z+Ef$PFwBYZK@V}`U#!50$LuuJwrw;3aJP|opSPFWL-=bDd|G87$ZfJ$?Iv6o`T04; zq4VcXL?-kn!AxcbiAZ5TiFd2m$rwAa3-TI=@M(5&iXlmT6vgex>@u+l9@pQ#B2j(R z7^LqYf^l&RKLG>?^Q_04^t)r1sBCm})1J#JmC6esFS9w)ZuCaToa_g&bK@V#=LP93 z5qSJ~Go%blb~9-dV!aPGuODrABM$W_##}mf=3rzTqDZV8G%7*7&zsPNZopAKb$UU6 z4$Cm8HZXO7wg~OLJO%f90SDDxhwNgEyWKyhINtlZ>L}>W##nj=St`dlUY6>#{t;{F zk$iJ+Lx(6}zSah|n-#3?4jp{LuWg_Ob0Jh(x^Jd^s%rU) zNZ}7UW5e43>G5>Z(4ZOnxk~sex-fo1yoj{}d8KSsW;2m}^9)RjNksW3zW}}-gS@CB z$4&mDANwNErAq3`3!A|J-p+9c>CyK@cGN~VF}18h8Rb|_B=xh#EyMSXSp?sKEZdjjvfx@_tdzk!!BLtkfV*bhe{{MkDrH0utk zY|nA;LL;LjIK96MR$T3aCbvpl0Rp3crN0zZ<}Z>kb5nOuZFA=0ipv#vlOY z(BLzsf@ae?P<-FInsMriel-D@iel`5N?>MYF=Igdm?7ZW*)#g56402>pJnsGe`scY z5%~>-mNrPuzArecmiTbrvHFN*2k z*`A3P7J!-%V{RABiwG1-_q(L&`w-;}hGL)_G)WsaKm*TBeCx$Og9{qQPE14gO(htmXG2|_+3^1N$Typrmywun$3QBx5 zKkdtp+Al;q{So6+z9eY#s8@T7ShcJe*FF!MXzaUg;ySpgPY3*@?PiQT4Koi8J9zPl z&*c5w(w?HS5OW8(M1k)B1f{zvI>VVHUTuPWPC=wMye%x5z>FDx6Dik^3>UZ)lXn_u zTPdmvqvs|{fP841Zyk{e+28B~z$H<7XCAI8u}rpGt{~v6z~Vzba`hA-jYRM>R=+Dy zbp3t=Rjx>x_*(jF-x$%u@b-NyNB6IqsP)phczxz#XQ+kbLKcF3+w2{X>TzC#jL4@t z=c2gi-9*6m`WcWy?sr#?kw1s)fshbYRJIa*sVTW# zFRD#eXtm&K(Dp?)u8_q6pUL+u3#sWUBUtFCzDa0yUKkDuRtbvKO-*iE0R!IaiW#;^ zCfz9l!YcqfIAFl4Y4>b@|(Dq}OoM%xYVM+FT&=hM8Z4`V_p|r;SNya4Yw7pe6 zOKy&Mt8rL4pyuU<8sw4q{Z?zj>z%!T@nMv(ab$3sl*x-P8V|2a@>DhX7rO8s4hgH0 zR{$3h?c*uef!xEYju3P`qCfJ94IZqWm%;(y44vCR+S+a0OeN$V}iWF^87 z69c1PUG>2wpiz2p&$DPWq=~fyVyrS#%MuQ+9-sUMz*ETMnfI5tX4??l?05zf25noL zI@ZOQOM^FBUvQVV)n$w?fr<`xK!maru{kR6#Iu2C68 zM>Oc)c0~Vdu>DqN5&6Uz!L&5umQG-G*8kaH@AClD9Biw$>{CL(*M&`QP_3>!(vwhrmLwVw|yB z=CX8l1(Jw^L|C=T{(YbE0afq0UJT?aV*VhR@IQY=FZ~ilD`f12+lA8SA#2C(-++NounObeq(2Xg>4AKjS>10sl({3 z1T%K=Ab|85Ij&h=)((4gTBnuFwaH#58qt2A&|zxjtXnorHUF%2aNqW|gehcySVQvC z$~e42_CP1F4aesv*<(R5zo9l`5*NkLZr2A)4wD8MM{R}=i3)^fVJROT6chjuBz73Y z^p!E0ejiX7RY!^sW__&EB|Z35t8)jyNcrqO#CpcYz(l*GQpJAiNycEyniaHTzXE>< zRnt=1-_Q(uFqq|p>p4*CywXEFz-*?#C_HEFg5eq8%fRoN#>%k&q#aymWxLvm>*nNX zE2dZz5^GPAI8N56TA_W(;ol+vu5D$2qqEM9e;W4sPG#3`$jX zzL~{B_d+tn?Y;jDyHq-yaaLh9)x3I7ACz%=_+VHg{%!cKfI(3uk3jdkA}>A0D`i1Y zR*``51;@lm$f^-tJ2UFi^4DoHpj51QaUaIdm-*O=oImzgd}ClSJV2 z!W1dX5aZ^rIXSdW&f{(;LVNDdKy2Sg0OQ3E<~tC*|0Dk6ZN6|*2(kF9gyZ*(BRgEh zOTGS%D53zg)UgkO!TL5ZjPqB8IR^KdynUL?uKeHW1CBw06aOR}%$c-$^e!4n7>U=e^d@;eC*8?osA3K|c34Hjc!k&QjW zu~)(?zW=uqFcbIbW_m55P9&~dC&2iE{1K=vohIQw`oBDL;|3}3;snN z_%Hm^gQs~PpJTfMRQqlfl1AL1zq>eV{W@}SJ{e;bkpeR(l9xe+OgaeVK{ALnO({k>XSgG!*Qu?sP zNr<0+&H5z?ObNW9c*fTFO@E$}x1tXLomuSi;|)jK4ZOU9wO}^EVCKK&e*j+f2%LZ@ z1qeWcQr(Sy*4|ZvDel!4xF=>Lo2am?d(62cG^QO+9@(xmfGT5n%Q}$t_}_aTXof@| zvIo5&HmZ}Hjah?;i^yOzb*vc4ixN#Tb+j1O>*mz~^L#Yr=fFUmzs!l|`@O{oHl%qQ z{fhN6_igPY=hEU|13&%<e-)%7Z3U8_0@@cw=yYcFp%68^Gu~5OThS`c=rx z2jY1Lfr>YUebGl5!1@WYzXN0<%%f$`ydnzgHr6zl%8iyrXTQNm|h6=U8$@? z(SGC0@K%Th25XGrl<|0i7V{MI%gzo~q1TyFtum)MDjTHdrcC-`F=A+GRsXVAuT~48 zXYCy_PO9L|^u0D-bd|Gm8Lg^0%Q)Y=sDM`A!$4*tg(=B=ZF2-z8;c+=BjPpsZw(?8 z;Dd{(-L&!$G$vdl1alv2v$R^O267B;mTK%R3-xVO0ovY{5o!Gl0UuY-TaT9^LvOk&|L7 z5L&7)#r5ZcwM9Leyq+HUc&TVwD#gy2K}lqhv>d&2Ok}Wuv!H=wvA3YCv8t+xjGaNL zcXnABudKdEaXv3&0vNJhKDm(|#m^;4k1s^T`I+V=T1E(H6_8umv(eMp9Dd@*W6j+n z;xP!l;wn5$$`b8lR2+}_WcUq;KY!%D#EO;-(F^R7?uQVIdywWs0aycQOWJus_$paW z(0QY+TvKY)%wouB9mE!c$WbUU%TEEbFH^pm-oKeTZZZhUlu^4082&M(+Dqpp$s#&p@$wzZx}`3K&Bk$KI(7%q-(= zXZm)XchQ@8B1|EF2!~gS=7HSnpLHoK8@oFP1laiz32m)$ zwUu_)dvDzm2a*0UwN{e_)V>W}e`E!&^zm|!u5x%%dJl%eM%-62s+NtDo)(h~W}oK> zq_StcRZ3?pxG0G-;on5r)CLFizied*%U*H?BTRzF_!h>*lDX%3Vs}6#QF(My8qV`Q zjDo>91w2M`pUye`EC*?3G$Im1()@xWef0f(+LKn@3#FX7quyHBw68JtQW&S}mjDwP zYaSCDT0YaVyyuA0-2pWf(j+_iQiYYnhdLAhv7)s`!N1U}|8KkD|EuN}==;jSUV`vX ze+mL6{l*lrOer}wijq=sv`HvI3= zsKupZb)WEacdQ=|MdU)}VIXQ7*U3#MG^+WTy1|NbS?b8>-D6f|-um5D14R?CL|6dqWrx{(9}>BOiC zgHB@vN6-=cbs7H;JYL%v+D1X2x2xmha9xboe^!fBi<9 zehUB$$6!qt{tH0tKe<{ErNY|#O}RoO`f_X)n#R)zYfkD<)44Ez6Pi`(THBZjtc~vy zheW4hL+&5&F+#8Yz!trF}cxfLGUCd@C#e@@H# z4{pXEhhKW|feB0+T@WYJI`d|6%m8FzI&zNLPe-n2}WqIJRcf+!%vTJyXD z{_k7+|N6fq|DUw41cv3mmcssRb^ibUFVuhhR+i2F0ZX&X3i1ZaSE6l%V2K0|`crVg zu#cb$NQQz6)NANz^tbMYkD6B%yT?}*W8rPACK3 zLBgGLCcjv;yUda2WvO*e)ELw@fuBDEM(%@}*MHcmXs~FoNOd&1B&*Fb870}>cBs*M z#$$?W?@F~OtL*U^#JuJ)5PTy|Y1v{~5ZQfS2_7vo9vBphGUQ+j4%+~X4!{V6z3KY8 zMa&w@MB=!(nx}tzb)L3JOfDL3p8JKcE%i8wzGfTqf+zl6Nt(T~z|=X8F%LyRJ~B3M zI1@dc0Gx%7bY$+WH+WRPj-;oHSA|1!JfcZXhtA#>*;5e}@LWJ4hES|~Oj0Ll{l`qC zv3?5dX0S%8e3-Dv!PAioSobt^(R`(#pCF4lm08|$CpxaUM2;|Qz2Gb(jKnANk9xd3 zOHkVao+{KseBpZV^~&+Iox|8@agf@P;O*7X+sUe)qa<+V6kXcuD=ThwGSQK7^p)(p zz3z6T@GRQ%2OGE#RGF2uMSFSj4cjuZa1A1WhE^h?*(2%mrpU(LGxPMWq9#(1Zz&LV>qv&*9I(8m)k1U!0l_xy1GW z;2L-A8G@%9z5u1mj|)bUl{8(~xEOTFPjE<-Z`td?-_iihp;71;#*l2gCJp0BB+XQ} z@wYHbB(`B)3-1Nk5&Yjd@MwEDM^yEMM;n)t{iAxePY%+ug-5I`ODiv=s=_4X7 z)?OVn4|90s(bo-?QkZDjih-QCM%`=RD9sX!L6cT2XXvke%R(J4h&maMC3n+1{;3J& zt@HxFERKeymFjEt56R@o*dJH~uGuRC7da}YrH;AQ=XVD&S)+y&$p*0Z*Kh`$SNbFT z2kjBJ?baJk8}C{*#JroS%K}2rxFi^}T#lWTV?f&5PhGg-s$343-L&DZhz?avlL6^G zA9GFY@w4Zg-)Z;yd?ooByiIg~`&n?;8LhJ6m(jxtW@%nKjayM%;iLmQA6(cymv5*a zm}!Kz?tV_^09XD|RUj1AG3za|UnaMx%lq#uQg;{^I3zcSTlXfu5`4lD zkqG;wnX!Q701YlzuX1e=9z&EI3x}AtOm9eiqdMBa<4oh#Nyb3pqnx<8~2EYPL(><^rOxzh304t8YVqK{B<8sfaWxBHm-WGYHoF`WcDs2it%|# zU6!KJ0{9Z8fHC83U|;nH31aZ-G#|oQ!i0MQDuh))|CJ#B=w*pO%e&yt^Cc~Ub1yQl zN1(It8LrAx4S`!f>70e?&!UV8^l6g*GfBw-(jkAQ0$;`Oo#=j3l==nK;V_9wNn)($42lC@1 zfe|wtY8=GRb!$X0kI&uNM@QC4#PlbXgCz(nuaUNWn%W0;2pUs$oH6k%Cn#o1Ek@68S3rmvl?`av%$zgo)OyN|g9=!1UB&%d@7W4&F1R!>n zv*AM?*wYGkzyJ`&K?EHGLqN(Wf7KFL4h=+j*-n#R;^-;ZNJvAZ11Fq zE2#gb#MLjt3+ls;NvIqc@y7aq{f&1fnUa9OD@061g@ClC5rQb4%^9dh!=9*6O8dwu zcC05^zc!>og-Vi8DVat!6ve3$-lk&<2Mvb`Aj~Hm+d(vOO63gYEbjh><~Ie>Sq?Pt_QqtG^=x$!=N=$>#-X&EI;EO-B_^Y1BS@HL0*&QqHt4H4M z8eE$+ZB$OT#O>Ebi7q*QY7f#>6!t?8*-kuF(L;m`>piSCRaG!HNn? zn68UG5ltKdEW3NAPlAXSLd36>ueB^WXBv)vN$&0#7;g9X8AJufL`!MfLg9TawtQ9A zo4Y-;_>su~C`O0>4)Tw;^q_dSmm$d5yJ@hiy0MA$shtD@s+Oc*uZ`=;bN#J9Xl(#E z?}F6+do74B_0P3|lOlPzoBQe+jy7v3dh^IF2GMLq4%zqCfYJuI!(GTQ(9yOKH;LK! zkc51*7LhU0DOZ&YvX?c`(2?2IV~;U3wZI z#?gw22Ir>w7SQ!1FHQSfwJg+va-deG#}l4d!I=h2X=wpqe!bZ!P=5NDsqRinr`HA` zR_`qP^&D4XB;CIP(UVg1EppM0iIe>prtfUbM)XoP;NXCBElt}U@E?|-_=N#5^7aTU z1x87zqT%H|mMi%6yxmpQFc^Ga*Nd+TfQ@RQK%2lrgktV;0x#bZ_ws$GYWs}5=9{R6 z<#!C^`{z}t-K~ix`QW+;*Cw8b)rE(ro62~N1c;A;!!7xjV(<6_<&TJnm`2(+fKDrOuY$0}T>7HtVov^#3v5rM&T|qTaDid~^ zUd#@Zp$5agr6mpM-*%Xhu7^16a?9nPJX&uc%F9@Q*u?(06g0xx&8@~HJ-Hnp9jW=* z_8R<0OOD~&pcIsUvj$$u?1@@hP~7{tgd?5z@h87=P*fR10eF%{WkBLtAnUU{#u8-Q z4K}wmy5gNGzq%C-;@ehlTS4<@@FDNQ+-pAnn!v5gxoemb{gWaF3DuCo80Q04Vp1Ym zZ0;TgKw%$~IKRLTTzxvp?j2DvUMrkz&P&it1xUJDF)Dt*bmUdk?`5?x8{Hdpeq(&rgZTx&e$B z0>OlqX_{ngd{~b4U@%_C*h*JV0MzIZDaSx>P#N{FXg9;dv(B4>A4~DOh|k366!9s~0pvk$uTcG?Fd5r%3`MfU02x=$ac){2HeO z>ZY>MtC-a%l%GgrPr+^7~>C|*;B%f)^pnav5sW%Bi6CMti+37e>As`=-s15;p zj2+y(7<0AkSF&5Tb1ymMVku+ePH|skOuxu0to?3?;Oxv72D3C*JS(pzEj1Oi2@0-z%#JNtn)Isbf)4J&3j2#Zk8}}bX<9MBdNPgT)+H~%|T_` zHe>T9%h7m~T^v)`agonB1*9SnVqWyOZ8WT_KZwcYS{}11}73apru;!NaqiivNK^Fxg6}{9KrEJ*mT$NVWM@*wfPmW$K~vdhEnbfzF)a@VeH5&24J z-}Ly#`>I&Hx@BG$zlt<95%t6nsjY#ZCVQ@XW{)9 z?RB(D*Jb1Q=zjFqRCG=CnK2n}) zb+=y2^qOHCXmvEINto>*fizXjXoXv^6lI? zw0)3PNRdXd+85Qxipj?1nuP0$&5dXA6nW2(a+u)oV^^oaw-Y}OPj!^?Miimu(GyaQ zJeKV|9~?W5dpbrewVOK1r&6`~53BmlqM9=5_R=}w$)CQY?Xz{`r*Vif!x%%?Y@BU8 z7U;kX6y_X|x&^kuZsD0`INtx$bq#Aa!;UbZ%u>kI~Tp&LANxVkgf3fAU zX>aW7_x~>bNYwR^0ttZUEc@KHAf~z?5fXce8KQ;IvnT|kNjx{&LD6t4AmgSsdHXCr zxEMf1VT_{dzLhs3doSIqLOR%BQ9r27Zbyj0MYT7&9LAMz)mMwdl#dT4w}?49$O1L0 zXr%$Z1-w) zMR#e0s1DCd^a(y8uH7XHYb9+zrx-CX>ytyv0~{xJN7RzQw#Po)W4B z+oAl{U|i1Vcl}_|nc|(Dal>LdI!8k6wdjCaSCf=By!}#orPK9R@+yPYYeZCZ`-9sZ?C~!`P5fuCvp4!+{q--FM6voO|Ww2#9w>oIUNWM15OcnJ1pFy zn5x{l%@?G~QiZza;Lbu%1uE~sF5F~@0Nh}=kA&tftv6~}rsQ$RibCL2ayi>a;o{LK z*OScD2C2On_I~Q^q-UKxAs5IR)cF`)<9FUXKYk^$K>In%hayn=9X$Z7jm?G}e%YnA zgk1MZYR{sb4;mOgA3#+ufA0UN5=>Gvr6Gu)V9dmddn5JLiq#!H_B2Fq}6Ysu4U8u;?!gG^9b)6F}ZFR_r zJw0Qlv{EG<10z8Yguk2=_e#nPuIcK6`1~WWz4%K`eAe0BE+G3H?gA8Yg8B}BI;r<{ zy7)Pm*Qc-e(H@~PH-Q#cu1N1O042h3h1H<`pnfC>xBL~J-_f%Vh#d_k!j&Z!mGx~3 z5oR(e{!lrP3L6Et$5T^ObSBG(N(}9M&DsYpLM{+ZDOKQ}l6g$O5@sH5ARV3$$#x6z zG`J+rr$z)3H3^64lQGgUGhNuc=2R5&4uSD%u)Y>jGD$-`9eb7?#2Vy|x-!ZWa)>BR z%sH}3_O2_}Fe>#3UW!3Yk$;OxV?aTarj?T)j7Dijk^QhIjWpehxBldd?B~(F{_Iyv z&+|E2NXLEO4F$v0k0EoKyIWX%rR_A*4X#THtND+UYPHT7zWk2%WNxflNR-PE_(U=M zYq|uK#N`&Evo_T7?%Ro5XP)tvYbNnDPW?LiPPwouU#jnj#(mrp_lay7QYpSgLGSJ^ z=wuWm$8;LWE#)}cQY7ojkRujMRLtz>8AuK6K_8~Ko*n~ZK+_F>rB}}$UH!R1t|ZE^ zCdQgZac^$TMmey6*myX}R*?48?|lYIbMm`-_6egAOm~syilCFPrrF(sxoV|VMYa8S zcrNu)4`!%eI8Jh217pT3Kqj|n3_jz;vBfd-zU{u`q2>!=wGJ@gv&^$$5@D2i_Jtst zt1OQ)u5A|*;*Fe{Zbmrn#AA@KSYAHyl|^ua8EmQ~;ox2QZj<5`Fo;6^r70FuwZ1Hj zJos}Z2iTVjhAZ}Bq}r~KTY5&x#|rjX_zo>>hK|`Uqo*+f*W7PwraG_|o4y-!f9!FN zjddsiUK5S9Qu`L7rf&N!hD16f!BjR3`#OO!t{m0d_Ufa=W%CAhN!%uc!lHnTd<@IP z-pz=Wtr_dw9yEeW?D8=%j{BdR)gPKq7INEB(=j1&L$xO7*i>z^j{wLWK`{9*c#Z!D zg5T66waA#@-1x&An*bzj6TDITrE8jZ_D|GFnparG^+Zhoy(OU}%C@GW6{I6pu2xJ` zjuKGvOb04@5jI2U4_!=uWnI_c8j6cdA`{+-IQOs}=)kip2 ziSX+fn4t5|E%Fbsag8YQ^E)&MP;iN1nk+9u5sv&va7nzp*aHS6l<9eNqQ5qHN%u(Pvt;}w z%u~WwT6~3f&0dr#GS$VL&sZng&n}vdhuHreGio3}NHk59>Zly$*9YX25g})i>yHEilFv-m<4~M zmGE)5%z5Y)PKW*@^wz0b#+J13An{P}S$@{iHdAX%S~Gh#lhd7A8Id5)0&4OFJ(=T8 zWmf$jCYM)a{-kU8N$COtGBM*5#(?PBI->Bs?wrx>(LZt#B`kK z)-g#?dT=tM$5npVJ`)&6&xv1-tds2{nP&M3_+FXIXjfE3(V&a}6 z{mBY9T&8axy6A4+7VG*YoIELo9rx5Ps!V|#|B>GFwO>r-L^*;{uz zC*&13yvMi68cN7pE9r3G^PQthH9F+cSJcJ5@r|m`KAY7k5eQ(pJH6OAbWco6*KR1e zO?1WS7@Swb4#Up>LS}#e{c27r2!OD4wf|*~a{RrCLYt>lf}g5_C%t+qVL?XIBXmOn z(?gHSp)mRpD^n~-vv~^ABw`b|&C91uaM72aX^t$U&m!0(LFtsLVWoucb_;VpDCK6< zrVPtPC;EI7`V>GSq4Z5WxKxK}3n!@bo-+g1ne1k!N!ub{94|+5@S%;vb|5b&Ky+m} z$B+=SvM?m~`zcN@W67xY_SHQTCcRJ)1`<13zHWZb*aj@SnKA_AxLZ&62mXy^F@`Kd z@J6O-LT%wymhaiRB$#djlPdtFlgZf`0Z1#08b8HFmh!bkJBpgmDeW6SKJr>;)NBbd zP|KU*+^SJa4I`$OpBx5o2y$i0M3oK(AunSSqrzR`Avk=4lG*_m{4Tbc)_9@qee?d- zablM9Chsj8vx(VijIXr*6R&X1K3T*;fb=n$-U!=na>AbAgKZnlkNNRWO(W`wnNn#r z0J=6s;=0YVfeVr@T?;HYe9=s0y4x|8B>F^tw}L75bdqr7y2f*4;c&Zc~ z9_M>8eBhxA>#11%k-Yis*Oy>6j;vq$T(;1AXB$ZqM)k$>`d^|aZTRNWGR|=G;=kdz zViPyad=$3t7*GF&+|{=qk-=R)PR8}*QX#ju_R>0@1md~pAF*149yPZJAa}O=rN$$W zPu89(O@Gl(mp7!9N*zyTvRW|1#1~?lslhBZq(LAieEE*+^I0owR2mB1z z!;a|$yL`^EI%4tpX|0oL2fe+4M!>JJ08Y(C$SkxVMu!6B+b*J@Sp4GPYi8`g6)*Ar zYYe%ObjpzsE6Rad0*y~UMz=Pqs`5l^f#iEIM9Uw;BPbZe)7ExLorab_J&+j~t(A%g zbFF%SX(;N1q#f?(%{JnB#IklOZO$L+F@A~XEQZ%-w?t-UW;hLbyS$?ddLJB{B1~Bl z(b~;e#dezaqN?S_Dsj!+;y=1n4c+N=PGkEOiLQ`_hw6%G6V2+JMu}dB%)cLhl>u8B zF4?I|_3-R0d@raz^`wTcRH_~x<@q>}P$b0h#-ho8i(7t`TGGPiV@yD71^euiC>WKh z#`U=O+ECgxqooTOGiAsI*)nebn0%Mk*BgW3CaqNGzMDachN%X4R^1SMWQ6H1)Qx87 zzJ4z_1bhz!mq~H#Rva7ijeE#9UG}ny0AVhA>vESbqYf0ChoG##o2QxC!B!hXv+RS+ zuA!-sis_GnuO>m-$w!I;G@9t_`z!vjfX1DYy?dKg(&&EPbm04bJVX zLyFffFP@IU>bGC8*Dz6!fqCTrbYnE(4LbDAHCWa7V&l#2c^krrH5Xifm`XTS&^j5A zZ^QxYyp@6qYLSU(jH}t?x3QbK5}R#VKwJ~)bL@=o)lcw8AbMC(K)XEFm}1QvI><kBBQPsvo{Hu26y4nmW(nv!N8mgL=9B#WXT9#T?*)q z*G>RH)E*pd`M&@_{_`4}Q7loKv?jSrzgB$5p1;HwLz;^g12~1qbd~Jiyk>S|qNE2c zzn*M8js)M|%Hfdur?=+<6k=173e?nPW0Mo%WD{vDlZU<@ei`@<7Zv_kMsR(^##h0E zjsZeAddI3aw;uISJ~JMa&`T%PQNHD;*#!2#)v+2qFvl zYh_q6&#+0ky=cI!V*<$@l)5Vg&V^p~y&jAGLYH3v1glS0d&*vb<2UDr0#o3wdZP!_Nrqn5WE~ZLn_x1oKp)y*_ zGSZ7E+J$odNPOs>7Oo9n6G+GvHYla)k4KM+!io&lZI3#GwU=ZoYeD z4`-6RnmxH~q?3ku@B&xRTzW=zrPOOg>nJcNd4qi$S-JrD~5HMv*m4(WD7nra0j!QdR@Jb;wch16T-h zkevFwZkURs=bV*jPon`ZQBm}=)Q@Zb1FQgyn%aeziWENg3#u09F@YE?$NlJ@{mXGa z&1+BJ_@)9OQ=G++Eailvn!Mh8!RH*#^PtCOwFV3KNzntd_p;jTLfPZ85yXp9G zZXU!9EN|R}Nk8kG+l8)?YTQKkj$pk#K~Jv#HQc=WWJnWR3eI0o4}&sSk!TNNCzm1? zqX0un9hWM9pf4^mGE!kQucBh(gIT_`dXiGKGVLQ-3`L5ZaZot#o*s!{4}@GH3#JkX zLYyUN?O`lqQ=BjO7xRs`povTri1tRu+W$8!(wo=dgR-z(7Fk_xEg2G7OhR-FEJihy zDEO&&;13WBfQh6>w;c?i<1`)bse~iH}|2OF<>S^5Cjm2L4Y3v%Sr#MRnZH+ z-?G~Sp_oe#VvIGSH*@!=hz1Ig6wiQu%zwt_Yrr*NBr{snCg19U*QR3YnG&;cd(p#l zlFOGUv6wpqWJA!$di-ry-bWE9r!9pTkkss>5uJNB=p@4*lj8tl^WX>%fDyN#?iHxY ztYFilW3ac?TRk+ARF~v~I>Mx>>oEuf*hRsJ9|J4I|NgWnI<>onqu^^-q>e4j_0iap znaANI1VHRN*swF8zv_SeiFsV7NAp_uCb`~ZT8HTe)u$h^c0fPzngyArspU6jLUGw* zn+e%{K?(k2W))Da*71}`q7n|x81tvQk(d3tHy|rFYK$L6Av$$7y= zD*pYW05>}1Mhumyte!~YG9^_tyVVET?~D2Tjairl#eyV6cCNPUkj97K6mWiO`3bU_ zQ=P;vcO$qbCgl^7|HM{VAY$;#wT>Kyjb_67@-*TifJaB9TiKHx2%I0!q@ot~`FMfQ zl&JC+cDlP18?D>k($dlpg{-#)f6{JqMeY&{mCAr)cL8*Rja*KYui;fd+KwvBTZS$0 zTTOV;XJ`uc4pK1OLU^=ZlP{8M_NM(nZ{8-cQSt8E?(4SiS0)$e8y5l1A-DXlBb3$n zt}A2cx&!SAZ2uLNb zx$Du$X<*H<+Hn{92yC0OAi%`uX0n^`-+&4Gu&$B7>@-L|E8QsG!4otJmBYJ+3laHf}YVHt`&~x0PC{@thJ`r8pqg{A`YW zp;Qwlyy!{#iqQ{prDn5daW-*+V7%^kZTB&+* zQ|!P#S!l^8+jr;I-zsl=X+I1!J&^WQT(8K^fnX1chMgS&*E~zb#W>?F`n${6=b<(a zF2lX+WX&Y>h!OM~sDzM^TD!XJd`q8?-ozIJ41*rMQRKX-BN9m!my`=eq|dDhjltXNQCr>0|?rX9|*WtSw!2!A_5}w&EVRwBj&H7B%sWi-)$%Ef^q*m`ib9> z9lVHKk$;u;s=6)!LOo044W5>fwNDon^uM$ux|hWI z>O6w{`xJ}EwpZJqFLT6Fm*VRysR#m2Mqqg`QD=8GxxBohX(wi!k}4BM^{X}7CKEzg zyZ1Ck=5<}>W*6;WO`#WS5`wAY)v(UuidRH^K)HV9O=ZWrgj zW;h(0`2g^zRXTnJv%C>oIN@VsY2u8{qal+qa_1lndk{)`vHDFu)U8h1a?7__$BVf^ zw{oY4$@C}OK?q=$H5Cw1_vAQAG*`b{CfubsQRTQ}w3(^XiaH9p3-74)&{)eNF38D* zEWZQwo7vJN6v~)Xn%-2J^8<=EEnvv{h}}F=eie)@=-e2!b>m*=QeKfH8k%bm-&RQU z79%ar_#8#N&BL;NzMxGt{4mND@)UlF+F?}@9~uENX6wKrh^g#}CB##!Q5pv3LbkH# zYmJ-C-mFrgam=r@$LY>PPJk^Ke+yESc|bb^ml}=(Ay8p#;M-IbqC%g815wmjH*8qbA zGMu9I|FoP0!^FltJ=CFo(4DIrou;7H_;9qQAI)S3L%INlBN3ucfUWI@#08 z(Y*3o+J_X^9WaeLCCLE=6mTh^0aGCT^M^4e7zV>4DsJ3LQhQPzz;ea*3q7Jn9qTMj zB?=l)o&z_!2NsUiD`Lkdlc7MdtqGBPhUj2=}Ca z&5=#&piH^t;dCpgvLy32AGKL*M8!v!?*d1x@869LV!&$YzU|!SGIszG z)z5%&=>ODQ8t9NfSIzN(AH~dcMg?3mF9$Oki5bz>meWCq>pQ?+b>}oQ)K`+4E#m9_ zld;ic>|6H5S{4>?fUGCfG-zA5zrS+y)V#;42a5v1Wv8e8US3k?cJBuY8$bacJn9)R z9)!>RBiiLIX9C z&HhdOFx$;|8q%l0_`O>xW-D~=cPbNerf4zmyi=^u*Lx2k@rF}UvFTU?(}(rc!L2aM z!&F53LZ6Yi1JcLRxs1AZrw!Cb)Jq4_MyFJ9Qrv#;Jt*rl;9wI#Lm=G@YN0253r&=M zj7?H~GjnqPx+>^Yk%`e(QD*=<-rKaQ- z;p|X2AGX|6t0);t<~U|uUNG3a40j6TiQ z$6OS5dJZq)JU-vHCk+=I=DHf>s*Rt}!_wa%X7iMDkO#u?P45>qQ?titScY2x8wP}? z3KX$@Jj=Yg@FOvoPmKoy(gjP9bA-grXlXUfkcFWOQ=kOwMwUM{GsoSEq6l?X@O{tT z?A9S|?_nxx83heL^3~niNde8xE>--#KW=!v8OsXUXC(&n#!Ke5XZ_7`(3?+Q%Dcfc zxLi1Ye8)b9ojT5>iV8j|e)v>=M!+45a6Kr~QayIiH>JkzI>SQb7da{U=r+6(w;Lgk zXAkuz9C~^=XPmB*RO?E@3$*8MG${wi?tDh!dIS9dHl1f-^qP20k0h>fkKT_FQSrueKwK_jsk_gOb~5@^zI z^zh}qS09y=mdY_0RxH7~1X;1`Rnq8b+ThVuaa6uezRq)1~-?6n?ND^nDNvgTf8AjepGG_eti+KrKi0~J5Y^8h9|5;!_ByY86*FdjBFT^5My$mFQxrxo6YFla@=80mIIOZ=v@X3AcbAW=LF)9{DUN* z?$@6_4z%2-<;_9oRPEaBt?lThEeQ7Z>}W|YbQz;x9NVqZ=*yYQ%e|5>t5%i~X3@z^ z=$E*2;T8sPn_e&%=kL*dU$*UeeA^+(U(SFa&*Wc9qg3p_0f*Ra3TOZwUl8Cj-ccTF9YyX@v$28&B=AE0^-!QuqMM-Ze1{x{Bi zk$Ccb!WUfQd_ofUl7$hlyubD3e>!tXI631HFuDMQLi!hnRP+Per4||eY zA5#g@-~h={u%;)#QR@HHk}*^?3E0F;!YrZE&h{Lvh#%A zK9teJ?Yt7}XuL1Sx-f0xzdsKW`_NsZPm8kjJb%>}_m8d3Y(TN!teR6#TW)eryRz+< zb=VX*;&m@$iYhLUO#bnC{;df)&~NUC<5#C)N{{pV#u@t*OH|#(VnL20*cW7n9dHoR z{|{)@A8*7T{r}CqWK3aKfD+Sbpdy?VG9Gc~UaNs|S}E_aRJ5c zFq4p0gG+S|Ir}gs_-q6&<_F~gbvy{fJHY5rP(zm1QMYub9#@gn@YF^ore*U91Nv`J z0NHzJt`pz{sEq%w4J+-GI7;TQc;6bLlzrLuBH!2s(5`{y@$iK^;NGCVVgI~?|LMXJ zcSbiueTM~XjRU0uZ7z&PyJzPuy0ODgfS^bBzvlQ1%ol_Ke9mfDGwbDv9%jp-&(VNw zft_wnc4_G+6D|&JZW+cFer%3?7Iyg9Ri^NT9uRng3_Jl&di?twjZCdExp!}J7qiBz z9h>#lmOBi*Y=Fu#_=GKBbU4u;7n0%B^Az5?!1DKXh=oJlo&cvn_y14(O$9l6W>!|^ zWf`)qqVLM>uszS7v#tVBqFoMzUsC`XM~v_w<0xof7rc5+Z(6tYhVh2+n~EJAm`e50 z=U`gwoHR$QyYpPqR&n3=OW*qv$gYkqFU8?hc;Aq9>y;r!obA)ik=61Bis?`vcmrUJ z>jZZMQr^R?y;~E$5nH-43gi7+EsqangtYV^7i4t)^$uc2CrI^v1Rec={RF{&;g;Et z?)}t7-rzw{1_B7_Pa)r2$qkQ*QK|1-+47W^_n0zp| z@0zYd12%b zt2x_2@R9A#J3R#qY{$v+RVEVl67BU6K3y}KhozM)Pvd#ledJJn(tS74kN?qt`ocW^ zJeFkLmFdxE66#o5>U(wZwX>zE9D)j315xHiVFu@oltjVAJ4*WVfS#rIrCr;fQq9j_ zKiw<#bBubfGFNwm8175ms%aWo)UPSE@6vRCfoVogyr1BGq1p5arCX=xy2Q*N9;rJ4 z&VwMye+hD5XzwpL`SoAgu1+{EM@_VEI8)T&0ny8_#mA6Qc_36KNUUi8cd>FdN~!Tj zT)i|kF*BwlQ>iRb5x0~{HCkSpii1T4QQ-9wtZH?us{p8z3uBAiVQi zd8IPEC>jd^q4kz`p%4`bU7~jI0U|rl)F;3NlfT)EK9}%$_Z+re65)};VKfTWkp45R zwgynx4=_UgD*WRf1mnd18)i8<$p{*d4Gvpi z8G8u;MLTm}L|l5cEC=GopPO!%0L*@nWhcO8km!9Leu%Z{k^djK?SMvb0j;C|_c|j@ z3eW09cC`#+t5Y$;n>5CO8 zF4+!(E3gOF0|)smklv{gE+I^z8`lQaQic$IH!&gom!}0I{N}b174uVnx-yjx@!-0h zgC|$JKHI^%Y?-#TGFi=H!sA88^TJzwCL@l>0<2YTuc|77YVM(64B6D8glyUap;pZW z_hUe~&kCdcDZ|jp`rav~!Z8%zg;26j8~dbZvaXU6oBn9*l2#6sWCZtM#+NKXNMR}_ zncAPoA3adD9iRJLn3Ls^CgYoC=-Nu?&Wd=9X^!57)rE_YcW{98_L|ISc;IqP4t+p;zsbUlcZki7584QNC|iluGj44bKQVX zN!2Ckwl#C#VCLNvohndP$KvJV$>GL_mJ{j^NQZq-b?Q)b1SFWywE8COR@j0l0+)wT z05AI~TB>p}Q@7Y!#Le;pDX7XS!@WUm`t}JrYysjn=4V`PmPWs~XI>IcyyrVcbc6wx z=c;3cBIWLim#L9Nr0Y@I<_Fg12h3;HAE|S%*xZd+x#LHZVR_0|HuOo=ZatHd?!p27 zkj82eOA@zvq_xU@qIjx~j_f_A2^dU0^gx5DQZ_^o(aj~%z0Q9dxN8~km5fW~Q zyb^T&z9$Ebm)ox<`Bw}P z_!#Uh4I;6$_>#*edtGv>mvmJtSo-=cU3z_~#Mw!vf!npUpKH%pD25cuR9f%T3@YF8 zoREs;0fN`>jmHU*8RH8@_zU;NT?EDRkUXf4-maDHiM;j+O;xgvb~rzWQ)q^84GHCu z!1poO>&XqX3R$vg^i_b{A?IH*OA7~nQuxMAwI}5>cJxw+_2qkd2gNsnD)j8^t2FLm z3otJU)I)GxbnJCB`zhx`rBEHxKB<;)Dl#AY38>T+DCH>}x}JG3eB@fnWVC@_z$GhY z%oy-VGeQ`ZpG$Z}80a_ZAK$?Z#*od~qlVnaMYIKFc#0?*bMS;WS(xWv9~z^ilGaeA zeQvV}w#W-kg|P00Cxz|HZJdmzrd&?|UU(gQAZu>WP&oUGz#VOH#*9`bqQy*n4*X0d z&%aY9eZyml5)r-JG~k{mhuQ$Xa3>uoUsjA(_s$t(&a)1=PUpSXlGdj?l)nC98#D14 zuC7hQmhq?+V8GHGWCwn>&EbtRp>05LpbEo#MDk3fkkzouGhxDeSnGg32`c;&5x0{J zn@XexMS)OMcv&@CcDZs#X1HDX?=a#vT>g+`b}{{pSv_0PQTX7@xxlGkn)*dEQF%fQ z#2$oL_8%}QK4#uv^$)1)I$UwuLWCLx+J;Pv=J6gD;06&36HK8B_3cmv?_lblY5~)z zzN2IM<1fDxsIHk@_m6iHXiFV9v#8Z`*)Pj3KN|OKoc?4i8%W>pPs)(*q-6+gZvI>Y z@nv@l4F3ZuB2x%(2J{_rr!aPkmBcLB*f(|Ny{=1oSiM_@_6!mnU#Rp4{asH!hxJwa z4G`M-v&C%I`UZs0usrfzf(wS_MYc&ubxpcBsw~{htGZ;nv?P-Xt3|GM62%|yA{^I- zO&o1Kz<8w16WPD%)|W5_c((REY3+4|wjJJ#9vcUzU+nKUcP~GlFXlcv@!7UXE&tjf z(@Zk*0*Zniz?=a0L1yb;!r!08j${GaaLl4DYvP*bGE+yVtK1jRsfPfH+wFt$zJIMd zL%f`|llEH+T~}4czqeT#Brd1n2ac*Ef#$G+Dr5c;K=Vhhnw#~B`o_~!haVe~$iuCa zK+c#Koh%G$a|Ns~0J&rSf68@Gjl*xb-p^@)gj4sas`XRjr&MBTS@dqOg8b-yKVrz3 z8fD6>je7*DA0q_>pAZp^9t`)#Q?u#m50x!U(0EH7tDCHn)GQc;o-%uoi5v64sU(+0 z?&?9^lX>LLtqV?(aV+l5a-N|q!(kbn10uo9ak&uBshZXkabZj9fl!{5>atUJRAqK! z?eYN{yrFocruMtd*SJd}B?=0x*omz~wtT3xjc&Wltz|{fS6W&2a0>Okc#0xF&28y4 z`^E0<;s9kmpUgEotw>b}z8CXmjeU)})}Q;@dYpw5y87F^UP$0_rYatNBOwMHqV2bB7s^N7;g_#NNV0lsrpMx$E7f#?xj z>^I+iB{$Tar>9FReC56Cw&REd6@J{#?rTzGe6!criyCum^?(m8rCIX)WM-kDjS0O+ zMcsKI#xFM#eq04L7%$+KU{%3|ky?6K(K9tNoH~C?EYy}t_%`UJde2_lsec~Iv>fuL z6=h8pNHZPAjq0hjgMJb3Ypf={JaW5h7HR|%>Y@Gp{gkB!CK{Vy@L09-d$X`*kp-k0 z$6>~IOH~Ar@?e}_e`>q8y`tNV&?6rN3+R%O>1Lbf&u3=_{s8`gJ>%6 zx+W~0Tp!GvO za|>1SE;Dmp-$%%iIIzuGD}rDoX3fn(AIH&?Q!hAx*IZ0SkWh;ae&a4J2K>RUof8|3 zx`AIL$2~_}z*q<}jqG-f5;;7>DyhGh-HAnieS=21KGwC#8>c2HG1&h6W-FoZ7(atB z{bQRm)QDwz&p_W*f${5%8ewiGvx{6t7-<%b>X&;0PiVM3v_Yxs;fQ>8S-ctiU7~Oj zL$uz2C zB+G#&LmGHG9;ZTa?Vbu+b$(2-YMtOQqmzrVG4%RK!~3J|1zO{GF3ZAgE*X zc^ktTgh zbSsYE;X@r6>9@`L1w8Lpp}k4v^s;ezpg~OkC z`jEB$M1}OuLO)Q4y~Z7p_Jkba&X2dZ`%{=u=00`r_JJvrt`~TlUu1)E5D2L2Mt${J zpF|H96M%vOj(P&T(D}F2OjLf7;bm>d`LS9MHBe#nI=n)64ha}DKxjGx7J@1_|79|V z4TThHJetIBr*Y%3O0mNTYe+8@H0tOI-~+nU;fuGxDjl5DxQT1N==;(p>i=DQS79qI zQetVSC2lIKrfW-$2^ckmTRj0@{$qc>`2GzJ9_8`+o!w~bjvF>ga^m%OfCfBxP><;% z(EdOnK--@|KF-h)iVaNE3&#KgKARuM_-r3{jd7V68QED`35`tb>GXB!E%X6Jd$3l9 zE|~9{zf-bSp{mS&YoMDRytN`#aDv&gD_rd%fj{Y`e+m-UK^eHu>rPzr43uaHN{ zWWU>~3e#lR?iDJA*qxbAG5#P#x8c-DU56^lSsml~vjj1!=Wr6f(dojh{gwFa-Iu3(@FOKhrnt+x|)BLt259e{!8R6BXYp`BL>OsCz|-Zi3}z8puMh~HQP<4#bnlk z2)swVT-eJEmqBR>fv#c`9{k7+m;G^5;ns|!buz^CnN`*+C&n`aDew7Dm$+z1`ovVC zhVOE_p$q1A(rpjsaGctR^aWKaiQj{fgfd6Wxa>ZpWxOTs-X+ZPkyXW6py|G7d`eNu-=TdQR%<5iI`Y;(|SmdawUSijDbZ8 zDjD8qy*H^yIm&falHp2X%5KV)r-JreV|{*oQ#WrpwP#*Oi8EPTei~Ar8Cmw7DMawF z3esxNd5#!~iHj4Ies!UdAp4-g*>~;TOgs_WmPfu`ufi^G0QIL z=LB^@<;CF`SeF zA259H&k@)&X^=ptF#U0H>&+QLhpMnE^((xe>+S)tPkrJaExpRY2ZfJSVD?!)Q{g4F zK_}qHpVkNRVC7Mk_;OD1-@hy6BX~~UyN9&ZY2Ma4YTJ}I{;GCOxkuZ!*aE;Ml-+d( z;{_C4>wJI1h%p$NO5#G(yBIdJD#bO#qC+C|QU9!^^Gc9l=5Gev_PIdI0%ni|jT$O)q07|8(1%+6NjS+anA9;g{da^bLpGE2I-9m? za+N2g67=$>Wrh^t7k~hRQnPu(es!*01t1xH!_Cn-2h3OmA}# z@Dm#pKpL-0F%c{a@?RuJxOElaD?CN3QAI+F++W;y?qq_&a$2uieD%scxUQ z1qnu$cYnfKb;PjLJI4^Q{NAnG9s&Ls@^@rR4Uqq@-F(phtFB4l;ZVN@tTZ7}|GdEz zh&vD8u=7vXsQgn=*%|9F{Z>=y3RuPzBpG5RqF+g_(khT$+L%mZ-vNn>@=0dSfySVH zeow;w<5aikGqWWZ$NZ;_^j51F&E*xT9q@T0zZauUAhUpy3f~$3{k`AuYi0aECI3Lw zw_@6j*RUP>rK<-3=zxU}ItPB|`%kiVyA$4}y_yG`avSmPeA6k0$5N5M$s)-84$Xh} zh6XMFjbnZUJ_4im(4!+r?#2`qUpX)L2iw1<3#3vr#ZBBGI)LWk{GML^4}N(EZYK?Q zva@5e+Br1749PdvsFnUE4BmpIwFy20a_-y)9V0Dz%z=Yxxc+k?eW2p{IbHvm?YZH- zux?r|Sn>SW=Hxl@2|nIO+T2S+7IHWdK-(q?2!#FJ2k$?*5=2xPKRrr3+`?L3X_U7^ zngui{jv63p|6VHg?|aE?oZ#-1-uXB=uD9iNj3Kn#%k}OZpkD)i#==MG&+p%}7|cEs z3yGBvBy)xc1QGBB;V%AiFCpKo-ZCklsH!h6WJ~o5H54Frsd0gG-UxepKwr@L|9C+? z`5+3kzaKOj-7Wv zqE`8Qxgj(mR&%;$I2}r6CdPNg8#9CVLT%kEjVo%Z4xvp?LdjehpqU6Il{>)ao1VZtN=?tmk29Qxzj(~d8mvcM3u#mOb+a< z>_Vs23>;2LZDFUlb6Ri6x1!@Cjoamc@~IaRtk8f}GoF3@0ReuSAmA^vMO`0^Shi?e zt&%s|ALE%Y3i$#ant66U+yCrz?(>DF)OyWHxgs|)p9NyYumf&^uxV=((LH)Nc|~@c8>5d!O2w%Op+C7Uelp7_xw^MYAJ3CMO6l-uDR)uK zy^H&fCbLF-7-1Yla}>eh4~bFCt6SEka#&E~uwF!Y1q!Ocd+vW4%c$1LKAoPZs3YxC z(UN+R%QWGQUr!uN?fY6^|3ij?=CY57gu^31b-=Nj>fGu^`eneUxh4b$Ttj$$(k++QkaTWRF^h3q|f{UH=T;yO&Nkr^w!i_pm z*aoPr764`CsmlAQDJF)|@V8iZMxE`*nu)VjOQvdPUsRYzH9bHU{V)pqWR6w*4!8PViX>gLpYRTBkxsfa7iP6ujJ`CW;r z1OITKF(y323-p6c)dYR>TaxoAjc26>Q7e>WVx*{o;;@t7HVQH5?;Zxq+WsX(3RlXd zHa^R^A1%z{UQgTijB75ihXO}_A!?lg!$BJ1U#c$_W-yJ}#clQkKCR5E#F582x2s07 z;oEjyF`x_!p45C)`L}~-E8*M=J}`bNRk;Kt8HTt4Z50k0Ed1A23xvbzG~2TyPSEWe zPH#odEz&B@#DKO*_)GJM-{8SNl5`QI&#{Y7Q;le=%RXXk*pU z-J%Dy$-!Tk1%o8NI(40hwJ-JHt_$u@0M;wSZ|NKf>cst*7+306iR>50M2LK|px52> z>Uq2hbD;zjAHlQk0)s)S2lRU->mGxJneDN*oAAZgC5p)%V`zXnE==}sN(O&Zie{*x z&}|T{otU!~gPo&R@AQ&5r)2@PD1i6c1@i_Cbp?_FR{pebqHl4cnP}1Z>vqB#VOdx! zMas{lbI$9mh2Fh_q&-d@@&Jf-)ISVBbIbC#pO=+_pAT?lzN&ASe5gA=eh;YZL4e!^ zi~enA{NHF#m7siy053wd<>yn)nd*m4rKeK{(FT+tsvd%c68&*7$!~%kp9~C5r9%XD z@sTkx6ZZ?G)AT0P)Y6g@J1$!YosvCVaP z*zhLI!?-FE!!|Gmq}2X+B|b~PUkQT4C;fgyfCwG*PZ09**C$Zcbhs_nrN=gUdoj$V zd$j>o6rm|Uo#ECF$~;Py#pa$LQ2rSn|Myx@Kbt?aV>5U&cvKp)`E=1;74sBr#Zd4mJzv)so{1= zd%Q0-bdcZYKGJToPgEn782lAjQ&Ak`}w6|v+>oh4U>KZnr z9Z#f^P)}A5>BE}4c^$*hs&B}DIGo7wa0sEf4sI+UQo+C2t%YUVogm{oM~MYY=i4)` z^<}3ee&F<(jpZ^JcZGM$*$XOV2LUOFQqZLcOr0)KXndqNQ;@lBT5K9DHN#k>D>fdP zZotT`MQfcb;N(I=wyn6IRgn<0*-{x(mX>6-6w-1$7uZ$3r&5*&S)Xp>H0TO%e>AsD zM8wLZ+36pAI-K04sv9k-K3#imV5`8iuE|vIf)Y{+!UPj3Dx?-3-%f6B+*u&ATUqv# z(bS;z?!4Q^qJDo{E62<8e$(CU>v`v^`Fd;p8T(|m57{mv z@}Q@5ex6h$dY7dq)31jkXwCzrqN@?aNa#-cOW+K8B)+!xIH`?={opsZ#5)~##)c9x zo-sQ;Qdv1hCV!L;!;W$ft3lss`vDWIo(EwA^iwY~7CE)b?>L)QQg}~BH40zAI>1aW z-wHeBlOHU5L~`><$H>nkuB0=14R>f{w(}w+nW*0Kya);!*v$fe8Z(i6##-~Dunx4a z5ZfH=#1qAh`?bHX3LQ!S!SC#iXFUC`Te?Zsm^|>8JWt(sf0pfEhdHJaQnQBgH5I_H z3bm5b~f4Rw{%8RM6m1-QaQmybGtTgeGmsJmRfZbHC@;_mbbH zp4Q{z+bP9rR-|5Tjh{;%b*F!#rw*=}sq-e8ATN9Me_?Z_$SH#158jl)eQRWqD-xV4 zu7^M!TP8utp&-={iFj5Np=F(KFKOLTJn+1(f@xFWqU@0-i@t9~6lPD=p8)Z>>0vV~|a5 z;$gOmd-nB7gTBQp)$GlC6=lgyIbzjNQ4+7uxii;o5niSBf92;pk^!fO(T-AoJLJMR zT7`_aS;leLa7zgk%aQf|=qG+C#tiMRM{i|J6Qse>Q7*bzT4#zdpSux1l7nrOtqBSn zV9Bg(iuaZDFS8T0O%ad5QH`hS!>STm9!12wYrKY0H1z$L!)+lcRCJ{6n7Eg$h9QBD zm*x2`Fzzfh%PeI1=&^ZEf|Kv4`lh(84$068B}(+5Ph6oUe{it$uNz5CmMi!I5B}Z(?3If3aMJpMQqM? zg06MFm>0?`Cz2yjBAAfnlGfx7AVF~whwJbRlZ=+t`EJ2oWESN)JvjF{80hc<yL17D?%BVU4knS zC172?3zE8@MwsZ7_Ty&w?4@Iea)1T_D+v) zAlLtj!Fw~NPUsqSDU3e*ZuOoS2nOG&RIe`YCQDpxhK+gWYcf#0@TmDKza zvP2Iv_9t|_@v0d!^1z{b^fJ}}{O1@j+-c%((kPHo zj~sFbpC7Oav)mB1A$DBClti!FBnj3Y)(1u0bvM>|cQmw$jg3)jhQ{13Sv&Bm@PvNnj@q2hK3#>ej0=YVj>xX4dkdAps3d1HQ26i zDD4Rj00}Zi-LJQ=n3dsRJX!#)qdOU)*&As@@?OLAu5;{2I7@%N*DmdbfL(Pqx2;n?3&f;m91T!ip=>i{>w*gM( zFnz$S0W=Sp5w~#;_+)$q38mYo0aw@o^gq=+zHti)`ko`?QzN~$i1R^nU2gKLu^LHz zv)XkZR2%EPD-~K!44X1yV=Sc}mIg+7#`(v5D{7ZM$aZLnLiwYi0Y@&Ti8(sFZgoAm!8?lYaxTX`KNW)d_f+GzC zyH6T%+EX%UkeV17LWd^N({OqQlw$1j1YgcBSwp&}(udA?xG-vGc#_+dMD2*HC9jw3 zZ6{?fGjQ@2?rd~2mZcr(B|Cn2vT5gpmp5nSa;MPrxr(lV+p@XuNe0?_B~ULrs|iHN z%#aFR8Bxfzp59>`u1rE3>a~gTUiI0$Gze0|G{Cleg#2nvo}sdUJP}UHLqJU=tGjCN zv`cRldzrhJ(vi!1W6L?o=x`T%PVRcv1ykw6D$ZH%aWX4#FeqPUD@v=C$mM#&5*l%X z`GQgQd7XV)V{Kjk;Etr8E=!+R-z#Li&x5Lp9H}aQ>gMd_$*%uDqyk+ zWz1}4h}Oo&MnauzU{hQtZAg$Dso>Uwh2@~##C~O-pRQSKi;n5E3TkK&*{?*ay-01Ie{ zn&xqfpwb-fUdI3nAE?}JkuL^@09<15h;uNJf6-7KpX%xw>-#Lgz*|eo!pqP}8Q(o1 zb)EdY*vhZKOMZ;4+?kTy(69e0Qa>C9@U204GK&uZ)kSfyjyQJ&+t|I!?IZ!W zVq~!EzyT%1aRYMF9!YVXu}CEt&hNM3STDjkZ<-okdY(*{PNcur0( zw^k^~lf42)#sfObjdr*0YQ8M^?43Br$*o)D9cxGhUhQ9N#fNJ%rF+K`tC=mk)(&vK)Z^!d4W6c#5)zBNaA zwd4V}kkiUE=(Z#_Rp@@|SJm&RngyiwXy_O4U1UtODv(o)QT9Y=n~A4ckM>{gR^}_~ z_Jnyj^S$x}qK_UKj+z>f_y?R24P?<(??!npt?xZC1b6r+4d2R;)n4jE%sph)cvqY` z%+fUNuwPDR&pXr8J<`}{aLgX8cmPHb-rMTWVR&QD4I1QyUht}SywDkYrHShqRkD2y68VaeO7_td~#_NiQv zB-S^+%qfeuhcDX@&6W%SsS7Qpqq1mHW>LZBr=LhblDoTKJ8Lsig#Se9LgkfO3BcmJ z#>f%=y0SIB$iaP?!GpETBY`~u!FgnvR!#8D8!w|nIwfFo!-6myUCf5kVbUZH4dz{S ziZ|oMQ*Hre?yOe7+Z1Kpc84%*<$Q#xY>t_jzWUgAZ+c##Q!rGdA`MD2@=FB8iTkZ> z<6ZlS5+L*|t9ki~Sglm~5>C(U5=-P^%roW(2$>vIge3?=6d3AL{r(KWA76_}xmNGN zUQgv18sNDuBJmj!TnM9*-a45Z*OD6Tw+|v7fQJSOUvWoGkZ#6Y>?vn@5Iu4Z95OQFq?Q13SoIt1xeg-p!DtnOo$4IhA1-}5=tDILnS)HlkmODo-c;kKR^YB+Js;fhGyFPkom&BN;y5T%aOsqsxAwlPSx?Iw5n z=Gx~gD@Kt8=LlyOiM%W@RxnXKHJGHY0iWC|Prs)B!ql-!!4p4=_vH2X1%`-(Nt*{M zGyQYK(*IiI%kJ$Sp8ouRUY3~J)0NiPnldA@=oq8+p7R_<%7<8Ix=1lup7 z606^n-l!fy15IE@=|4VSR4gBiZ@%paopgxaOW+R(j#G+BO-M`0fM%0VOzJh=|LS}g zV6c*LeYG|7c-%?vz0%WG?wT`5Jlxmc_eN*dc(rDrGd}-SsmmbAdC%#`{XP$)R4_h1 z?|tI;xGKvF+1DG_@?G!4_W42O+Y9JHf)_*^WHHFzym`C1TpsjHTO2&8mgn8}y1*Z+ z_<(WzK)^OgiGosd+`S7!Tmrt+-*WaRf+Kx7m>wCy0DL-79{-q&^#8Zp+%!v3iggm( zTQDmuH(@rxTRd}ce}o0dq^XSM{=1>}KTcKj^2}+{Zq^%Wk?)O$KjBvFKqL|~i<~nu zJpE&ZjZ%ey!{3|J%I5iO4KAX5nGBo5>as*r2HiJOK=IL;tMv)8l{szfVYxGNcmd zB>&~L|8JaRYpYnuNk)b@9S!?y=T>%Jm(^{cCehdb-H~JOq|;oFrs8AZvXj%G4II)*?xCak9*nG{qHT+fwbXbtF>XE9HxcJs3p!Y#@aItY=*x z+w_m|iiPgZm)ou9eV>aBnlHEgKcdSwP7jD(%H!-Xzq~y-w`&pHx?c}H?jO9&kISiE zs*d*?9kn~Y9F^HJh1eN!$aG@WZ;@3AW<4WVO0M#jX#8Sn_n=9)*&Z7mxE(oOTM3V_ zNSQSoEcbj^=i6^Ak9iw=^t}I&EX;w~)U0ktth~KCg#5N)TCc%&L)#f#-O6`_5MsjW9iuVe&K4Z_3`bo z_?m0e>R=&z#Z6OOZ@*U}B`>3VZ_T%4yFT~SedjSIGwDVDfX~N-+or;u#sjZk=EhLI zqAp)-xTv(s&5K&ER1tM?VlvZWD%CywLZm_O{XD24#7T`AR2D zeNWO!I4aN3`LLq$)JCn!?D+V9B&LU0-}>I9H+WmdIh}wygwF7sesOCEnQrKvVdqyb zc&tuX##fqfIDT*%wAy%ce%V1{_OdUW!Ch*Kv5AegEeTU91*g+TYPl6q{#RTo8s&*ca^`ba)c2f39Ws{qi|>)$(B@=eNk|2#ydWEya5 zQ4A&>90@hSc%XnR z8d==PO>g_B85fld1_;)LMWu%xvXk5 z$ERs<=prr!S!b;v`7g8uj>UYlBfD5KpIZFrhKVxBWtch>T+h4RY`z44L-{5ICfR~a zy3wovbVo#G-a}Z6=C%w@A_$4~46>NqGK)V;lItjeyjq|U!py9LEH`2v&M)VtIFmPa zV7e!9VZAHLZ_^ZnrPUfrKhN{YWF+mfT46+VKspG%M9D*7nBpWM=!5LiJTgrT=2pav z;Tl};LS`FZW&H}S3k79jr-bI3D)^b5%JGyWDl*1(X!#qcDWjrWHe7IFUY8+k z1J_?-Q2lx^qVWMyq0RVxqC*Ak@?*Bp6bPFB)Hp06CpZAB(t8bYOTPx8jMBUQ1*S$D zH^%^1!0ivZjtK=y4FJ3|@i#pE`77RuWVEhDGknnWe3M5SEh49 z;kOl6YbVHa!NcKKi9*WazC+N9c>(8%R}E&R~x4V_FV3o1IY8&igH z(1*|7;)GBU%vDU?ZRQp945q)G3021;gRcLnlsRSCdf*ll00^t;z5l;xd&d}A!!=s4 zZDY5++qP}nwr$(CZFldsZQHhOO`mfo_x_kWnaLzmzbkJlsjBaN)_N8yvh(}wVI7C2 zHJlPE037xeh-_wAB@M@pp5#NV9s>(qP9n1a6L+kV2g*{o!?PKZ!)(5>aV zRj!CTA~03DZhU zeB_xxmy!>5cZ}6^B!ZD@FdY|c>gN^1IQ1JyzcijxKu8XgX7$~ih>Q21boGqM^y}O^ z{G;|_V_k0pM~bu(qY0ZOxk0xkXbdcPdVjg1+v>Q^rTFVRrJ@Hi$vBF5pze4hc83*E zMp!9;P2o<`&9VmluA!z>zqhU#2ljBpYvu2mu zqIa1dq_@i@)0xKe1-%Q56;axAa8bf6`{N$yRn9SS?X7UXQ)V@0X4BasG@#ZwOV=1* z>g2vUn#PPiHFuDDRrm6GjJoa`(+fI;wi$&=IMX@gl;9BBV(kLZ<3CW%k@_45Yd?`< zvPuD;%z z3xJ4%#9kdRe#NG``Lq+BTyZ#TScESg(y(9(AuQ)!wBbBl2WZj#R9t$N4amA;1(@G`{U*1|LV)gl}> zhEWij#Boi7%_?zc*RG}$MeB$$H;3+X@#wFRrKVGW*zwSa|4q*i9= z>}5s)?L%=e;v5`6d&W712Uz_oBSZ>P%Sqb#68oCzH^+=a2+r+c`*aSGEzR~7$|Cc# zV5FR4uW3D1NoPKz#3z9zBuY#*v-l0`QKeYZQmYJ#oyh4q%IY$e051E0^r%ct5?gu> zrs`+dk4jXk+3G4>Yja)w=!fMd0rvIC4 zKm}jeKLED+Nyz263G;7Ir+PMsDp>d5J+kI5F2L1M?B#ZQW-K^2E7>vG$4rb02EM&= z0{~ZPso3VbaS~W~T7up|j7e3p-TQE(#9-p+taPp^jRkgl*j$nVnt* zU|O5Qbp9Z&t@c?;$&J}%YDyV*&Ge#z)RRMYLlg;|g%z1>k}X0Ce}Vz4(qw4SqpWah zKYoEwqbk660drS3KxjQ*PC$)z)=8*d{Vb+$j-l|-ih;&X+4>^CaNL?r;oK+ze&G(# z?6b9D%bvBDIY|Ma6TGzsG=w!HL&ucSBa8^_0w6{U(ZR`fB|-lY^`b}#=jqU{EKC7I zvA^~ABq+$-KYr@QnKZ&|CCJ~Z^cq)$gT=_V8?O_howuaGTM6DUsmLv)8)sLt$yOq5 z2$CHg4Ma}n>k3vAMF`*Leh;>3&iN!TPZ@GTk$7jRlLJ=+$CwvikhF#X&|J=FifgYK z?atyC6@Ao{TG!U^mDr-RigT_dkGr*mUBta?=lbLxZ_XAM+lh90d+e`!oMi9BS)Oyp zjpYM^xLzF_P0J|rb6RnS*+Vd9B@qT7z=8t-GSU-@jY5RE-%l)&@soGord54o4ULsq z0K$<}(y1JZ`~ia2KHA;`Nptu`*jBGAb^=A|wk8fD1{N^^it+{$G8V-F(jwyG{PoG* zJ{~6GBIXG?4n8$LG(yt$NJ7#o@ms^QT#x|Vb?8?OuD@JklBVqfA42fX7bVyeV4Q_$ z89oBMSSKI97Dd^hpi()OXO`7J)~lNA5ZxK|+JmA-VWkKZT@#mSFGnuY$2U^%qk>8*@)Vj<;B>rDZ`&L_dwt@}h>U zww^`T(jqjiHChb3@q(nSGzW{45MH%hS#H2 z{D!rjFV>FAFzT#E6DhmMmv%Ye(g0LH~U3rnEkuSePldR9M#_-9CQg`8nle;(Nd45{Z%ZS)HArZidElYwN zlpL1^H=VQ#P+VF&hQI&COG-kt3^*E|P~luiC?feL3#Wx}ba{T<)h#UgD+Apmjow|@ zbnrhDhMm=;Pdlx5CJ7GHqh7sN%;sg=BK2c=Y@m1#&IYM-hj&j*SlI$ZIHr7cp#W&l zHM=}D&Why0pip(a9PgZ=6o25KG{6Nla4_+sALX`-7iUXapPMk-JRK77;u(i^VBj`C zNMfo>z=$6PKCn)JRxPG2QdZA3Ll^cbzoLZ5n$ln<*a8L;YMY{KCeV?wXR}I1fbKYn z;VqmYckrl+=wP~^-foF1umLa+-#hZi4G$~-qML4Ipsrat$x)$xZ8dZGq%o!^T#ep& zfu^}vcNGmQx-xME3Kt)DclsD=>?vx5NI$qp0}V%8a@0Ns3Haswe?ICko~|DLnGA~_ zYH~w&qTIsRImJ#OTOBN=w_v!ce++9KHtigs_>bc|9KA-NRJIHtD(@%=Qdt`W&Fn|k ze{wko(R|q-5zn-BHw{xnvEvvcz=yxX0^!t$@UB7%hpT^;#{XAd@c)0N#Qj71?QO7a z+h<|G{Yl1bte&=mYS{Asi5C=;o*rGHmZ7GQq@MrnB7bEi*6x{;xQUV1k{Dzv0-%#M`^0Ol4u3_%O_WlfM+#(x8T$u_4a88kq+WE^wNl(^8_0u8v z?RCl8+d#4KQ;;cOqk@o%+Orvm)fTtKafZJ>s-R{2e&0;41s=p30O-en?e=02rV<;) zy1M<{g;;k-AB8PQTQU_x=W5KhSXbASp!c1V%92j^yiuykL?MoOZ0uU}chXgExHtn6 zo!|H*8Wj>Vv>QYdrMmwDALBLb+G3g-FNsOMKqSxL2^M|=t6CPo>Be`3^XGWriyjV&D~LVg6nfJ@QVP5RUE?MwJp-tH?^JuK83B5Wp!(fow!(@j5JBzMkN&0$+Pa?L`^YzU@^)Aw-L3s^4gLQ2_*EAnmMcP}+Dqz3h z#hnccw4$%G!%EN|H?~$$h@2ED2=*>=xrB5V6?YN$*GDHH-&l=cdcJg21DQXp?qz4i>yTd>wFXkLW>ts|SM;JwRq@gjS^L zk&D2S8TjKKj!{f^fT34yNf5P#uO3Dl{Vly8)@u; zoX{Tsiz$=rT2Ctt5?|n*2T;Ft&Iqykc0rC|ooasXPL&JEPrxrmk2bXUi(EhyFTXy{ zXo5v-s7a@gpLro8Cw?~|ciQoPG1nLRKfOBh^<<2X_V2!Lw6M;R%N(!Aoz}i_8hRxM zkz5=V(dgAC&DouMfPa7OrDh!lOqwr$xT5lFISh#yQDWT(ET-ba!d>!No*oTFa#^Sj z=Qrs35}FLE)WGUru0cL26ep_{TS5o8i{|Z2fuLs+_>lWJwpO?AB*ZcY*=j9tV7@4@ z>*a$KZ~lo{U+jw1#`h5(oI5wNvqYCy>&Ma>mOMCo(R{q63@Zt?I4iQstFsg z{NEp9Z;a;9i_{5XMLA<5q7-J-0nQ@FG_BfPkiayydca_Kn&xz!6~z%_F$FQnG`ALO z?#$pXiWFW0iBMvubha5d6|`3)4#VpPm9&{spX_=N6yql7P2 zkI|pAdRim`xr!{Bg?P^~4b1c%ZR+zSp6})}kihOPde7YnG1T`}6-ir8xRFwZhK$1_ zOCI7FP>Y7BVJt(Apu)pk?+dJJ@#eps%mCH_Up+v_l+qY(j|&@?CX3$Ec-NrGU6A|L ziC7Ndh9c1iYnAw5v1G!QHCG%zKX~AY#FY#x zYqGn`3U|@YLaOT{!U&(zt&WWY9f0RYygrl;P`aopAlEbK)SqQXLsw9(>L+jhtvo!~B+e`yZ-PmuwMeOPMpj~Hc4~#q2{x!^P#lZB(d{wb zV|0xgrJZWqeQkXyl&&eyKBg>nt$GTHs#^v_)}*o zha2MG(&T|7DK&mUT0l_OywX?Hg}cDP7{B6yY1d5KK%xgDwBv-Smh|-WB9uHnUETb@ zg=9Ti1hh?BeNAO#J!TKw%Q7MWR<7`@Om10{;?!hd03d$=tLqDY^NxyDByBfY5V~(_ z)5;*I@;fw2uLzto1b2bDK+FNKMhR~H^F=gzeR>bRnx)}dHsrAI+`>n*W4Y+$f zOhx&)H{)b&`6zfqzJoQE+a<&P-c6N7Gdk5Oto;FXQ?Q+2k-A{U^t|+4s@V?TMQVUa zfyl7OYi+`Nh#-w6=1Dfa6Sy9hHa#Z%)%`N36f9(ubzqHZe{bm_J2L z04b`5X5Sg}C>0v{MFIrtTuuyZFM-j1J`aW_K3GjGd5_6AJy+*$N=r)_Gs;^8UB_xH92*RB#wTvebFCS}Jm;4rK|VCQ!qjR-)wUOMLe~ZO zOF!MHHXmP4MV3uUR}Lk`8R=7(kqiHbc>_pTuf?&L1( z)pfHVbEr|Lb_J(uH*XWFLznw0%_Ht8vQy5Rc3;Q++^HUn@wcWiuX3HqzcV}$ywGoUJeRi z^0X|CiJY2C-&&~a5|1s|3m%@v3wOKfJ>8%4fW^ZoudV&Xf`5yIT~!7lzKZit6PrQv z)1OTA8k@<4cLe8gTuR2jJPBaJ_#2+3j?<0@)hOeJvXMQ~gks?zNzStI&d(&Jt;4Lz z#ZIKSbmoRBS*w|d*Tc`Nf%x(cmulvo^h+x<5Em{nV=k)R;{UHGM>(#`@CGp8*D>{9 zS=&DFK5*PH%JPG~Ux(AUFwpW5=(3Cs|3;asVI2$Hqta z^ut_DpAIVUD|Q~d(52l&5ccxqC5=W~!yzTM6YiKN{{wA!ZZ$;V*5)v#v=839`@0K{s5Teitk!?C z`wjJcc0{%E*9`T)LE|~{JVb}*Thw?>Pb$N|%t_~=t7pr9M3H}q|CDB=pPHaDrs0vn zdz=0(;uiO;IiXKPm3M^Saknu8lTXr>o1FD+TBFQ2)1K%zOvf`F_25R?B-w^amYpUW zpOIdYrXri2nvx}-5?`7cla&&uHc&&h%)S#g5rz&NZ(Ocx3g@~YJbC4N0>CNFOeo4! znatDLdfZw)oD5?9*Y`GgiYWRwY^mxA6 z?!}~pS58gLFfudB&s0fD%N&oJxcAxDrz8Nhu57E>xK>Mk;pT#AVEPTDY-uebW2RR{ z+cyE*5I9-VTJnbnUdyenZLH;XZ6N-jEZL7*%nDd6FaRsIJ|Q_Omvu+RvFeHTKA%_D zT26GXFQXwRpOv1L6_+-7r60RPJJ|;ZOr5Stj%7T#e=>bljxHyFFH7+!^0QU9cp#O} z-E68jal|?oqQTpYE^ox|5Mm`|q)paemMLeR&+uAdk3MAmgzMpbs2)zrj3c8STcM^F zZ_rzPZ5b4n{#;L?VkuqmfUYs3k(fmIt$N3p+uj2W5dHl-$OF{;WP)UZ#QmW7gR}gx zAnF8v_5MuOLsX|rrbEq5L3-257N0l{DF0WO(ES)v@Avo=0Q3KGyb21bUX>8V&Xoo0cVd;5VTkBo zUJ;&ni)8*xRCuzrp+&aenP!~tQxK11Oi+oQh3@x-Z*6Wv?darStZz+iXy#yRZ47YE z^v5`d-p{8I-F$sYF_cOYp6gR{2 z`?PSC7=NsFz)pfNL49>gCcXg@`h;55B{i<>h+kr_cApYmC8{)t6 zu%!uU{o9Osr{!*(n@?{d31X?_H%_lDQ);^ZNM^Do|AIvZrQ80&bCgrl#Ixd=;j6Zs zCU#U63_}DBA6pAQEB8Lbr;!5Pg2>hEg z5qB6R0%zXfq;gVmW6hGj=lCvCXs0^w&mf*;4$KVNi~gE$?Ca70PDt%vV%45(&Mg4? zpWl`k1LNE;-L|SE@5CaqVBep(^khlZq;BescH#;I&>0H@R9E?{`i)kxOkHO|_=4#% zkeN2G?+6ODCx@MQ{%g(}TOy4ouIu?6NM~3jtQJG{AlC8IMYINXV7zwJOP?ZA$mwcQ za~PzKZAN2gXO}2etcdn)&7z?m5oa+3yoJe{8I7ulU!-LODV6v1IW%$O+v@f7KDB|j z^Y!@fq3iQ?^#YIg^ZHQR^P|6@7qZ8-&k9{1WqdDQ%%NG$x-rw$&3fB|>%;i|TxF?! z&5{H61%E%Ja^P6Jx}2{H-FH2%4h?uHk#0f#Y6i2WtSNuy_vx71b_0t3aA^S_$06DvDjRO)OJBzVDtpF$7Sym`<)2wo70AG@fn)vCMiA@3pRR+ znnrc|#d6&@)O zvl9Z;4D_4gky|}-Ti)$W7+Jn zXB~@}V%~AVhM2}qtO9yJQqEzz#%xn%do+ZrwUcDqLUFrGao~V)D37={DXMJ_h`7Ps zh}j=w2v943{m;2opcOJKHNQsiUo}e^7(_>{*)<_ir9UA>#6{N3h-9r*@*gPAjc8Eu z4@nb)GPrcLf*mOmGb*^u_iHwze=;#}mqfY>iX*Gy7BDYj?5|ber4wb5d4?OfI%mrM z3Ue1fNjB$A2%E%=e1_$tN5^S+B9GU=DQI8{9a|`XsevHRHqZK+e5d#y*;!6LTH92N zMqaK7ml$6&))AmatBN}={bNpVyss}8Xhy&Ba|iFuDjePPuH>?9W0V)FQ9@L0D&a(31)!dQOc8clbD3#tfdNsyxwqfdW$2@ z7f>{L&ul$xMn1TJAcUt#7#1qJ9pKzFmBqWx8N#@BI*AO(3M=U|odc>tE4zaX&2Zz_ z0PPmsrm(R(501LR?+8x>4ZK->UjBwg7fe)Jh+$k+tM);aIT9t)AccPcC54nULAb(q z?O;}Kyh`nhb6v?&vka3nG;fshYa@q23v2FGSF@0oiud3Ao9bNsE65*QW+^PySph8=<8nEL5 z0z+}|RRH}nCZ1Guky|6r9AmGCwbH&yJgEgv&AJ7Mfa8}W;;8PY@2o1;nhN?n99L?O zji52laxn_r=@3A-hr7eCX{s+_Qd!i^y!tf7-=ytd$#!mZn(Ps=QHTWo9XP+A;oc;r z)!cF!xt*^+e-S+wLxN=cRUpwt;?o_qf~9jEeO4gdb_d=p9MB~nURP*58VBa&7`*b{ zbHR6aTW5DqxaAsfP7+sZH(H=2sdC!W)FDTWh9 zYT}!HhRlMwOM>^7>`S8Tah$23?c0Y!HGLRaIOd4zib3CGbELE4gD`Wmn2XPtTMsUH zH9e|tVc|=mucl_~SMmS4$H*wACjQ6fNR8_J_G1sYY3Rt`U!)`j5x#=`CIbNAwhQ*P z?ia~KEA;(mEZ}a@-OEXcpa2eX(Ni+Z9E9(+UMIMiXO3eg5|1Zo^c@jjcSc6qpM7U< z&dtr9ZMUQ(b%tgNyn1t<0nSuo^E0W0AxHn`0dh?i;Z zz&Bj0e4)Jl)xp=lI%Lo`eyc~Q~%B%R~3L&>&n9*LC*714I z2`wxP_IyGOt(43=|BqRUPo%ms;@ekW9BrXZ*@t>+25ViXagZAXpgxm(y6%_e)RyCv z8KgtG+#%0NB8*8=)12q?ACy2*k_=UeV0DKCn}B?Fba}zl3W-T5w1c~>LPSa+_8exs zVFbNj1i`HV5b25&HkQ{ciPtK$mL+wjLrG_+vmi;;i*Cq#pGBmQQhB^=#3AO}Xr{H0 z?{@Ss;nPa$Agh_1)0~YFO8-bkHR>aPx!ajXv>l*}Lq2*LIXT*8#9-XBcPJT=$~GUa zeL+B?v7~aO7dql*PpOY(Agm`;sX15Dy>HYsMN!u&mIsUgTB=&W(XBjk9VtEKWV}*i z-!`=~{qPQ+lHNx1TcWJ?H%68jpm-!(k4|!MT({Yvpm^^YyzCi;VrnP4fZW~tM)U!I z{uAEYsq-J?zG1UZhu}SacU-M^&Nr-f2t2DZ}8O!ciZXT zi$~Nse;zd9vOil=8uyjrr!sY0?y2D-AqU9Uka!Eh$u9d8S0+ELH+A@2P||Y*&5hY8 zj5suJ#!0-8JoNEHIoAcoJW1r5h@Ka7HB}SLdyN@GSXOTYfKND((Wup>Q;VsOL zfw#OAR;cfxs|-uScW)S~x)kdG!_dRbi=5BYZOZDbVx;zR3CFRVWU7IU4Kg+tos!s^ zz~(bY<>2FS#w}o6$9CUcq%4kWjsbciMuK#q?zKvZBHGe^au<$Qlk1eO~~xjiQn6Ul?qxDEV8D zg0OXh0_>@eRcAhA14POf*(eR<6feD?Z8g})mXI!1G#-o0Dh59{;k05LJMWmpy95LU z0c84mJT;lQH-X3}JB#UgGRx>-AYFeN-Q^f6;Yi-eON7B5qZ7iR+DU&V;wZ1eMqV}A z1r1eh5eEt}W|y}YNDZYlII3BQ?Qps#8edkzMQ7J{o6dE58hyB~-O0AV4r6hkpM%i3 zmw$cE+>6Sh;7GL8ja+Xlz(~yMztC1yk#OS0;rvs*6{oel;8odb!sUA?AW1KMg^c$` zJ4AGyTV&8()G@d$aX6hhnPXN7Vk7>c#ayhH>LvOw`jUYqsER+OdOmD z50OBIGZf)9Y1xSF_2EJFQ!i4PxDQg7UaW?j<@O`AX&X06e|8>Fu38>rUtx}-YIRmV zc9^G6{|U(l<@`zb@q-TwSN0lvf8FIq>vns$I)A(>!Jc^40wmG3+!@d8lnCreA#KMC zeu+-YG$`)!?cIah0m3Ct_OnzMZ$7MRPoy*IBHqMhiqfj(^kL~^B9l^~0iyM!>cN7x zy*4RSH8DlNw!FD1G-tA5A?weB6-y?nZA1gr#-!|7R!(;P!G2Qx(AcF>{n*36{wA8l z@)i|&lK^!kP6$x*Fw=S$RdDe{<+BjeQy_^#@>ODn%=*G#C2^^@YS%}PM>O<1bI|tR z7EA9~?%yjMW#lDm-@3V&Y&E;Rjt-w57@02ZI9Np5+K{(}zbti^!72(n*ztB#NlqDP z;@{`f&#Sc+NWYLB9Ad5`o;=h)z~Bl13w&QsM|NHxt7(sw{m~ocIq~`@`{Z7dUi#gD zI#gz-HR`e#ne`;PgaB2S4LhY90UCAJe)OpUvv2AsmWA(p^$mRAMIvbSbO$E{D=D`l zu^8q_luL=8v93J}mpDb`Hd#3<3eXCJj#mlY4 z$;GK9Up^{5>`=|tRmtL4kDoLWDtmM;yV2SHy>n1tukItQ>EO=S$R4@XOn$eoD@TMZ z0n`%P>-==L8^G%SWHt|ehPexLifuJ=<3(Y+oGOiMkk&IaQpsxFzi$lhdx-#SJ;6a9 z!Tj2jf8Xlo9#9-s;MJE%{gaD({9ZOXTf2qf>uv7+CA7n(i42S{Cq_l4cYByZE;jDN zno51T^qJN@C@Ro4`Gl~Rv>0FzBH6OAeVt3KYBwWIabhx`7|M*aa!>jVb2}zIIUyxU zP4mkr{F?jBzAQDH30j``J-!ph!evOVYX6W?u`tomG1ANb$MF0=q&mRm#&+KNXAAA7 zE-(X!idLcSgwoYPEj*cA(Q^VuiJr?lbvW7mtVmPSna+(bykf84PypmTO8dXPZokg# z|8|`10`CI<+N~QkN_VuVAn9}|hUWdJ>2sI}p$p=rQ&Ciejn@6kFQ3Z1)v_xwZH8!T zn?~Ya7g2UZ?q$tzl*tJCoGJn9Y!R$9_is%kPgtqT z`PS`WAbgPSMJUxfS_4A8Apq1%{a%|29Wev=2vrBQb@R4b#oe+y?ucFuP-5}stU^_K`dvH`>o`-?H? zFglP07wBj;6wH>s1nnh4&o%B3v^fCg6Q=osc4P#oUr?Nb}DbFy z&$61TmiP2KqtB244thK&2f%*6#@hdu8zlfH0LC$++%<`@eCFtS#gGYI-!Xed%x2iW z#)~tfSQAyldHqse3|BBq_}|N3E8w%H+7xIv|1CuO)wqP)3uKSRu0`5jWCT&6wbGLx zukh#ld0vAr09M+JD$&9gy|PNo7vPo}HFX0(Yvm9}dzrFJ zx<9hwl(+PefHppTSyu0fK60#X@hM-o0kV{X7DYLcI{o0hac315M3sVU;Y?*C2oaVT zfro5PErm!x_JY?FIVzPMNyWuH3(R&H^HC@i!(P*^h3W&XD~IcGlAfl>tt)-Y2~IEN zHd^U0M;5=8M{;!Qw;xGD04=Ar&}v-x&7-XEjwKj9K8pE^u~Z6IYKJ+fB^9Q9lTmLn zn?ZFvQ-R1%`axvuKcb#Q>+5Qe;p=hDj9Z~w5@C%`^@ zu}AIy!V#lV(=!XqO#fynML{zl>8s;9@33vC@aK0O?*V?G?qHXx)hsw=&Em|BAU<52w73ATTp zn$PIspULjgb@pw5MOgWfkuG3zAo@`W@fLY|Mh&ydC7WdTVunaHpZ5ckOBbk zE37EU3uP1dzB(-nd*L_Fgd7BXs&4-Ww0pFpvZ$CI!xp$#V{i@%P`CWK;r|&_We}EV zwq21CVP;7tCiE)Cb4SSr0D!}%%s<`h`?lIoJEQmQI@+#2^w=~Su>;s-un$qpQE!4= zL5D?_QynB-y@pxV8(Slp#UwfXy2C^q0#%P-V)d}O_w+tM+fbf4m!lGXJ?4+>uTld~ zT3VpxKOY08jCKJr?1SbFh zK_CbK_4%Lv3(*&}{}p7z`E;A@%mLkq7ViUM`Vj%7>ALb&G0Tt`b1KKjj5o_nn3d=C zf5$W^c*E9;#WD+IqQ3G$FM2@7HZ+g$P{wan8jW$EZ6O}f9g()|Ww-^0(XH6l6;^@&J2OY*(l{yO z=!R+*awt+O6F>*pIjRp*+Hy<1G;%-4g6+rR1SU@PdJn+Hj?id@coGCRf9CeZdmk4U z{F0dihBVx~4)!3?yfovuA6;V5 zw(rXyRjIpUU_k{M!Zz<{yt?R6>3e64HLLzsM4g2|!7dddXAm*Bs1w%DcU1CT90l>z z>$Jw0Rg|ipy-weM;YfeHHo?X-Oryn1JuMmRxoTVmJCv8=vDsxu>d>Rkxn0iEm zVyHnqWa~+6)(G1F0;j1QHAqwg)>N}mD8{^D$~&+6Q^99Dx(moe6``NcxsVMHZC#%V zCWO{46uT@%vHsaEqP?%Z1NIjkQ(NtMtl*5*E#Gq+aorgFy=wniacu~(bOfd4t=tJI zP!GBb`P`~9``lZHB(0ftQ&eO)$&ELV8)vf~5oM8h=*v0wZpdF;INP^*RDFxDhFxrc zq$WWvMf<`F6`cZMuFMM>F7@kdnRvhTR$5@zUCVjuykH|nj7pxYHT+|<>*aPOB}cR3 z55$0R=Vfpn8S;7`+LV%<`LIDU&7&MuPPY8W{!c?x?UFQsA)u2t2z?KGqWwXujBD5JF7vr%X4Ics-Mz-ZPzl`h#UU`Ny3I6dPCf}kC)AjJN5IqosiT9D7*S~t z)puYBQHuxx(}bT7Y3$zi`Y{}Duo$wkyd}Gv#+;)s{Yq0RRX}%2ovYXE8`GhceK6?E zq!O*jj^uaHEd=F31QTmnIDpmEMjJWMO1EE(c?+OBq{^D%Exsuti?zBVlfi19==3l@ zY5UQ+VrA0m?nfg{2MJJEvTp0PvO%*LRWN1@alo$~{w&#PMar6!`q_lCA-iRqSy7T2 z7g)^~%)7%=CQ*V-rBVEDJ4jimpHCR=p$XsGck|9Tc7b>9P(-tnZ3Oi(i5Q|>GlU!v zD9XbQ-PWR#abw)XYZKC^x|&i9fwUj~@&F>)Y9ymwta)+Fa2Ijzb_H==6kjx_(KB%S z<(MOCx$rHP(`O`k(gTf&%Q$c_DvwWFm!iB4?>iAPVBE1I3@R2R>v?-83SC@!45bSi zBg3GZw-;N&i}hWA!XJ&JB5~VYEAw?jr19PS{^DZ9P3f@9q{#n%zdM!N&?}!;AG5?wRs5l>AP^Pe1AU$%X3Dns!04Kc`WDCqD1e zJo2c?o3t}qGg%=n((Hz&nj+~Tv8>|$CdRcZ#H%AcZj*bbwd+n+fG7z=ENX-%+mu|A z_&`d$=6Uhwmhu%j2?{(4rG#aUarkr|fIi#BOVR z@!v{N1EH^q!XWL!0=2nhhbD`^MlWkIf1@vMq$?0`B2l6|+Xsl}jTqlW6E=KOyqJsQ zqWF>RD@}3Cp#*!Nn9Q`LW@G;L!G=w$qn4eP%xO8RsmnLrl*qVwakiKqH3vf0X`Te zKvUGXDAq}Nhbd*ZYl;?Ds}{}MK4v(HtmSzCqsdNV;%xqGiB?Q+7`oeLAuRy!!mZ{g zUiVIftES9YrsZ##!amAkjZSP38N zAVSYyc6%~=cr|3~MUZ-ZaGA;06GBg3}=k% zj=BDv<)HvFr$XF5Z*Fit?}#0$0cLNGcche2&4~N-2xbOp zMNfnYULm}E=~iKV8jCK4f5RsahG4XcffAk5BI@sZm&2Zyfc13koc>yNTZY7*hz98|Z}b{t4uJ@tjTe!bl5)L%oMPyK-3S>` z>I3=g)e2ewYJ}eFxW6kuH2S$~XyzaVNDoB*qMQZ`Oa>3_Y_BNF0+7lL9fTW~bz3x> ziEi}nMV|7tiG^&1A-Ob6U8iii87nlvfJrrq!VNM)G6KW7`%^MG{`+J-E{J1#H9cai z4+`wm4UFue7(Xk`JV5C}NxbS-4b475CY6UAIFdx*1lr)Tp|o-KXWn3N4BS#wZWZ^2zq(*!_5$wt_R#} zic~I@Gu-)fQt=SZThxK2UAmy{iU|dmAw}X4A{yVY%l|UB9JkXS_l%jRax#hqWk7JE>NYvu6bp5@b z4rSS^{S*kI`OQ%=+<>wF3seqM-PK{g_8q93N%!%*x0~QqTMW?0?ror@bOgpBDda^j3Nnj}=X7~gx0kadc}nZ<@~kb^yZ6wj z5hWk)u#Ar-oHRse>z4#(JQ3>Shx<4dn$yPTtOUHP{IAs&@BoAnrHN{!vt=Jc4yLP^ z4VDF-uN%~B+)jlq%!xHGA}ko_y9}c5d@Lzh!AuJegaA!!FXDc^OdwxRjb_L)L_YI~ zL8f1^vi4hg`BirXR%W2ZaE)D}H1`P^g|zd1wQbr>Ozs+su;A{RIqgN5&a}w1rHTd} zRk4(emtEsNyLjsuQ@ndz!mNLG^faZ-BbsCZP`X|6)}lQojFuXrEz;t;^GgIS=N0nD zZ)!B`^W4dvC2(2wu>4{}izKCF!h)P(4-8SutHQqPlW*}e@}-;yHzzLK1fKGefmm(s z`hL1~>nA0fgY7BZ(aQl5J&I|aSLFLoYlLDDEoCd$ie}1vXX20xOHXPzk&l-Fi>lI7 z$b&2Y7O+}+^hv*m(bL)U%s`m+Xs+k9(+h7*Iip1-xcUX3I?bOZ!an(-o$e8veQxVY zlX@m*ab4Md^Hc$^>0sqAH)`It#`G<9m6^RXU38Vd+`}lJ0TIJG%ZyE-tb~G_Q7}W> zDKN&R@9RNh^yDMhlj>7!Ea_mcIiO6OuMVe^Xm%SELJ2DW2LNC|pTCAHXY6h6NpX)# z%1BQEluLjd7c00Hc%(Qq)+66XQCSOp0(WcyJT}<63Vc5A#bI42y$d12ro;}*NeI}w zn~}=?lcmzU`1b+{r&qhrf$9!5wfCwWt#GDd-3J}C7P#H6dXvx314<xI!o8%Dy+-u8yhIMW~n;t9-b-LSMg?AYw?#aG9`n9{l9e;+n z!-aom)6H;;YJ0ApLD#Y?0#azBxdiFa&mvstf0oW#>GRqQ=L{5`=4ygjEGbhk$c7l^ zZ6bfx4>)apDsT>`VLA0}QZa&#Bsa~L-q^k8viR}>&0P5##~-|Gm{dGt0rz1};TGq= zTKMzP z$AiSup(E?k#WEB(t19UyfK2slL@r`eNQ!G9i`Z^-)BtJ8rh8D}NQxy_HCTpE)XNf!4~@j~p+{yeX3WJ4D_W6d_-A;6 zL(^`(Eo3E6k~AO@`?NifEcHVy>rh@b8;x5FrKM!Rd1q5a$ofb{f=7}SHCX{EPpf@i z@iSA?Pai_QCKM~@>i74aGY1u91GDB*igGP%b8Y|Fcse`PRa=`sTCwMY@Wp3+Sjlu> z&EWGOPj#^>hcU63IBv=CB=b_8{LsCouoW@l;t6b&KhdT1Ya4ys+3;Pgcl?i7c}0LE zTE#)G6w9~0cJwr)&q03bwzw=Qdviy74;ljnQf1i%lK|L)rjxp{>d}H7`6|O zac+-lUp=;UQ+!2fC@MVmH!yl=vhm`+ruHrA{1suUufKWK&XTQ?2Gyb>l1rKV@!f#< z8lK@sMLYsG1;Fc>@WT~v4M^e;{PJ&wAZWb~JArW)Kcgh+T#dKq_D1huEroNvu`YEz z#;8d*23L*d$?u`uBJ7kx%qc-#BY)@rLsi$4KMi0Fi>U!sCbn!_Hyp;^Q0Bbjva*1j zhPV#Rgcfj^*$8xqZY6(%&`6ZaQZoD z;jw4Ot!2_OY{6?WiP5Y<59)yT7@Aavt%?|$YnO=QHKG6rphJP zd0!AZtW9V<3jxUZ?r{KM$MKPFGG21)xMb3lucKNi40fRAwTFC@zH0l9pY^>sMW5S& zr`nFbM$JDdyX<7!h9@=iFCQWw3QfeI_!RV!itgVpuX6aUe|%uh;tN2t4C)5+q+s?U zVUXM6D-L`gMH_TFS!&-+XxW zi;|i-&-3gnzil+$e+*!}pN*d4?n~@$k0sYs0GX0{t;X8d1ED<_*^Yk>w7DsVKIALl z|L16B7&hNXY`d$j=-`^s>}@D*`LPz8CIvIO6beQmM?$sBJ-fdc^pF&guZN;SgQao;mX#$0Eo8s$^McDhhNu=Ex5c~A>385LHCtZMInobM_5A44Pc z?eq3#rRQ174F~M1=9nSijY$??NFB9Rs3fkSt46fkk>sfe+eBhOs{nkkZ*=>~SZT8c z<1Drf3tzDzUkO2Bom+GMSwH&wCbo4qJ=xK(*~o2m4Cxr>kt4>$FXgo5AKsz=W^e`# zFo!TZL>st7>_oHJ{dGjC!<5Y+F)}vh{eWc}i)Tr9Bs~+}ews-uta||^5{HRdBbp;V z%1&GYX?f>FptiISKHhqIRQ-ksOg0&dTZ@8JFy#oFXe23F;Z1zA@B(dTo;RuMe`YA1 zYrRF|EVWUm21clmI0gdr5*bnkWQ|%5+q#CDg_ubLB7KuAr`cFK_z+4NXSK5V+%rs! zM{>8dWzzk-ibMt%IV6abTHYqE@~0OW*Emoaiet=rpkxxn&t?nxF|gf|@YdsQxEU@= zc*E)^gjd4d@74Axz%+`?P`E!r@yr7?>j#)JH++v$4A=ub6whn2$-?g{5c zdlh$^S*YNMwTM@20txrbjw!gSQT>uCj74_`oUCAb_!|4FT}@yxYH!4P*f!!*w*9NW zcNe64uwy(9TgR!F9lh7VbDe^uZziVv;EY zWJ{`qBpNvBPUY<5KC5p7U74_vs1e%HadbVzTcn0o{jS|xA%Tp_1lID5f$Ga~;J{~%*ec!M15gVrt z<~NPgAL!$WJqh_n@QJvs-7}c`>E;}}WSnFd+vDo>yyc1}FAaWDAk^K(U9r!DfzUh= zZ_;QQ3eqPZY{FZ`B5A82vgQeOrpg0MjTsk<(zz&yu0 zul+D|h@(f1cNqJ|J{si88iui_r&$ZQ>m=*GnIey1b6*M?i@R6CuxCV*o2ht2xFGyK zXm`nP=J&x~sF$x$g@$L*aCKX&6o4;cthi)Z8INni<75p%SU0_ol$fLr$ln9me5X&I zrj+-1$4#$)4I=3)<8`ER#Y7`3AS(iK#)P(8uxthU?s_*zRzZH!Z9FuQFhj|(pS>uu z;cPP`Wcfs1cO;o3rNitoQk&bXatZn)KE_P)hGEQ{7oV(l#B2PZ_Z-}_^m;mrt=s&rZPbX?chG4QcGhMVm^BM6?wnLtFBtz|*;oCC!f;sW zZ$>R zoZ9i~ql=6B9(@9h0NLTPiwJl=d9I|PVRNrv}0!Y{1f(75ezdsT>XWybQMc zl@+_0?o{vbCTi)W_|ZMP&BxXfq;y%zTP0kSVVc16ui+zpGSzQ}$=8|Wg_o~ILE&{h z*pQmTiHUeMNxP`>0$rrmNnJ;F7QOjx)-V~N@r$8o+!j5JGQO$?IZE?4C%Znf-+&)_ z`V2UUpudp>Ce#1@r?9Ynfr>t>n={f_yXg5189fgpm~haslo6r&x1;N%LLxp|;f)=O zj12NaSp>f1ujs@2p*DwpIJXY3g(;KIEy6~tOOH&vtw?$L*l;yn9IXM?EQ~4NK%!5M zn!1A$w8qk-N(Ap}jK@K*Gx zU(S@`&l#1-d?KQ6y$^Y@**iH`vx@2k$B_z>NjYV?s2FwK8TZl9W(N-%s=@;JRP};{ z7dKLoe`ujBT4f_M43ui`6;}z}deU)1=M3+xIR;%s%c0hEW1bIU2s%Al`ng&iy5aHP z?bEPFr&l25lsF@%Cbws|@W#8X)bza)!%+5`(1+6a`I`84aEzLTB6BfTT9Yi{FTrT- zz9l_vBSVW5megK}ly}fowx!3MLg*vqkssEF0r1jmW}*ogdXO6`GTf^G>#o zmwsYrKI~sS-!}U`o^1J>``Iz*Q7a*U$zdg5i|Q@}zH#5Q6<|1=D;c9!P6U@=l%>Nc zO1B>T!|em$3*EG!_`UsF1q9f+X2VAwXw*u2_dcIS5gcYrtZ@7KTl@gsc%rxkCN=jP zUj~FX)OP+kM@E;lS>FPGHbiC(o2a)Q#)<+Ux%PccLIx{4IAx@6@zFDn$9AD&xTYu} zcPA;Ur4hVFGxfM>9n&cmR81EklhB>UIMR_NgpX_QSX&$uY8O zTB7haa=!?>w&j=M2cmU_DW(l2qnF>u&5=P)xwPO9>RV8+$RHZ=U)5QyzpG){nV53O zlX+<%xf#752su%Rve*uwG&?w?`Fx;hGVw>CE5bVIr3@4N1HU;P3SzWfUtmgIP9`Yg zxP|`mfu|@!teI{vCtR*Hbbr52*uxtm7nE%C2)DMG?L`gTBX|v)LuAG`KIB$Xnj>#1 zHz%W}^KyozI!V_aehN$82s->0!AbJZF2Kq~MLsFl0RvP;8+f4UX!s{1nZBxD>e@0^ zGq+PRoW`|l09uR0!3R|svpfmYWa2jJ2agVin{-)SA>GjpBOGOOjXkD+@Pc4K*LsqD`zZ*9WO0R7iE_b|SMP)B zF2@(@wPhJgP#a?yjpqGhcVP}qUOP;6|E(waAOGHrjXTLhUg>iiYWT>FkMj4`E%Jz0 zpr#8e#18|XT;Mt#mQd&`Je?ad-J6r<>Bfn1PkD=qG)kFk$H9Jq&{Ra6HVL5NUg_(- zHZQTfF1bRgtrTR8UAn>OU|#C{RS}p>?gY z#D(F^g-f2CgyUU)Q_p%SW(RO^)P8*ETVIFgs`DlauGH5DRbFAhx$O%+_LXMauXgku z#N=yg2YftIcQ6}9{yvETVNm_+Cv)QD>-yB-adgY?%g?_K4J7nJ7h2eQivtrISa=Zu zdlZxaDwF@)&J!%5o3MD$Qhn?F@Q8HYHSJUYXd-<>ubBdsp#ga_$=UhTx9ug=`;a|7 zcX+VWD(-(#(j5)7wkMkIUAEN5%G}v`Zfd;?QS9%#MEg^SvK$4ac%86Vd&0?feYDct zX!p3k=^Lb$)@(+<2Q8Q7byWUr0YyL~n$*pt2Z7k0v98W%+wf`Ps9Elt6a59Z8Ve8% z$HCFUSiAppoDe?|;QCR)MJj8%>*;&0pYZ&GD(f$rnZI~q8D{$xBp)zqeUDsBv8}P% za$bujPl^dhy2gzD?+fj9hEMccNp|iy2y&Q3m?^E{q$oEp0JOq!JS;h+)Te+uH#z;$;E?!kr z6>5F-YzH@U0N8|EsI&RS_hkW-NlBl60X&*V$JDdO+F`kkge20`KYa3rzf;M|%pRUK z>nf*ySBBgx9^2lJxnZN+7SqYTXX

`ken`zFitWa8bfqW1`&cp_ichy2JTG^~kJE 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%0A&I5^t9*-<7QtKis|dYYhB`JP{c}erHv`WN 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

ycU~NWocrhq`gAXRlvsJKX#0Z3+|%Q@UTn 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

El>?Thc6h=QY>&S>A*@TBBQPGJ^9r9`+B^#IW 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 { + const blobs = ['blob 4\0test', 'commit 7\0testing']; + + const result = []; + for await (const entry of unpack(pack(prepare(blobs), blobs.length))) { + result.push(decode(entry.body)); + } + expect(result).toEqual(['commit 7\0testing', 'blob 4\0test']); +}); + +async function* prepare(blobs: string[]) { + for (const blob of blobs) { + yield ['00', encode(blob)] as const; + } +} diff --git a/packages/packfile/src/pack.ts b/packages/packfile/src/pack.ts index 0f862c9..767556e 100644 --- a/packages/packfile/src/pack.ts +++ b/packages/packfile/src/pack.ts @@ -4,7 +4,7 @@ import composePackfile from './compose-packfile'; import {Type, NormalEntry, RawObject} from './types'; import pipe from './pipe'; -export type HashBlob = [string, Uint8Array]; +export type HashBlob = readonly [string, Uint8Array]; export default async function* pack( objects: AsyncIterableIterator, diff --git a/packages/packfile/src/unpack.test.ts b/packages/packfile/src/unpack.test.ts new file mode 100644 index 0000000..94fedda --- /dev/null +++ b/packages/packfile/src/unpack.test.ts @@ -0,0 +1,27 @@ +import {createHash} from 'crypto'; +import {readFileSync} from 'fs'; + +import unpack from './unpack'; + +async function* input() { + const pack = readFileSync(__dirname + '/../samples/sample1.pack'); + yield pack; +} +test('unpack sample', async () => { + const entries = []; + for await (const entry of unpack(input())) { + entries.push(entry); + } + + expect({ + hash: entries[2120].hash, + type: entries[2120].type, + }).toEqual({ + hash: 'def0c2614b88c6df95ac49c1e0f5e13494301142', + type: 'blob', + }); + expect(createHash('sha1').update(entries[2120].body).digest('hex')).toBe( + entries[2120].hash, + ); + expect(entries.length).toBe(2651); +}); From c358739d09dd2383397e73a54604783c6fa922b9 Mon Sep 17 00:00:00 2001 From: Forbes Lindesay Date: Fri, 20 Aug 2021 15:08:17 +0100 Subject: [PATCH 05/10] feat: add packfile-parser-stream based on node.js streams --- .../src/packfile-parser-stream.test.ts | 62 +++ .../packfile/src/packfile-parser-stream.ts | 433 ++++++++++++++++++ 2 files changed, 495 insertions(+) create mode 100644 packages/packfile/src/packfile-parser-stream.test.ts create mode 100644 packages/packfile/src/packfile-parser-stream.ts diff --git a/packages/packfile/src/packfile-parser-stream.test.ts b/packages/packfile/src/packfile-parser-stream.test.ts new file mode 100644 index 0000000..64d2dad --- /dev/null +++ b/packages/packfile/src/packfile-parser-stream.test.ts @@ -0,0 +1,62 @@ +import {createHash} from 'crypto'; +import {createReadStream, readFileSync} from 'fs'; +import {PackfileParserStream} from './packfile-parser-stream'; +import parsePackfile from './parse-packfile'; + +async function* input() { + const pack = readFileSync(__dirname + '/../samples/sample1.pack'); + yield pack; +} +const expectedEntries: any[] = []; +test('unpack sample', async () => { + for await (const entry of parsePackfile(input())) { + expectedEntries.push(entry); + } + + expect(expectedEntries.length).toBe(2651); +}); + +test('unpack sample', async () => { + const entries: any[] = []; + await new Promise((resolve, reject) => { + const input = createReadStream(__dirname + '/../samples/sample1.pack'); + const parser = new PackfileParserStream(); + + input.pipe(parser); + + input.on(`error`, (err) => reject(err)); + parser.on(`error`, (err) => reject(err)); + let index = 0; + parser.on(`data`, (entry) => { + // console.log(`type =`, entry.type); + const expectedEntry = expectedEntries[index++]; + expect({ + type: entry.type, + offset: entry.offset, + body: createHash('sha1').update(entry.body).digest('hex'), + }).toEqual({ + type: expectedEntry.type, + offset: expectedEntry.offset, + body: createHash('sha1').update(expectedEntry.body).digest('hex'), + }); + entries.push(entry); + }); + parser.on(`end`, () => resolve()); + }); + // const entries = []; + // for await (const entry of unpack(input())) { + // entries.push(entry); + // } + + // expect({ + // hash: entries[2120].hash, + // type: entries[2120].type, + // }).toEqual({ + // hash: 'def0c2614b88c6df95ac49c1e0f5e13494301142', + // type: 'blob', + // }); + // expect(createHash('sha1').update(entries[2120].body).digest('hex')).toBe( + // entries[2120].hash, + // ); + expect(entries.length).toBe(2651); +}); diff --git a/packages/packfile/src/packfile-parser-stream.ts b/packages/packfile/src/packfile-parser-stream.ts new file mode 100644 index 0000000..d1590c9 --- /dev/null +++ b/packages/packfile/src/packfile-parser-stream.ts @@ -0,0 +1,433 @@ +import {createHash, Hash} from 'crypto'; +import {Transform} from 'stream'; +import {createInflate} from 'zlib'; +import {Type, Entry} from './types'; + +// interface BaseState { +// /** +// * +// */ +// readonly buffer: Buffer; +// /** +// * Byte offset from start of stream +// */ +// readonly offset: number; +// /** +// * Git protocol version +// */ +// readonly version: 2 | 3; + +// readonly entriesCount: number; +// readonly entryIndex: number; +// } +// interface StateStart extends Pick { +// readonly type: 'start'; +// } +// interface StateParsingVersion extends Pick { +// readonly type: 'parsing-version'; +// } +// interface StateParsingEntriesCount +// extends Pick { +// readonly type: 'parsing-entries-count'; +// } +// interface StateParsingHeader +// extends Pick< +// BaseState, +// 'buffer' | 'offset' | 'version' | 'entriesCount' | 'entryIndex' +// > { +// readonly type: 'parsing-header'; +// } + +// type State = +// | StateStart +// | StateParsingVersion +// | StateParsingEntriesCount +// | StateParsingHeader; + +type State = (chunk: Buffer | null) => Promise; + +interface BaseContext { + digest: Hash; + onEntry: (entry: Entry) => void; +} +interface HeaderContext extends BaseContext { + version: 2 | 3; + entriesCount: number; + entryIndex: number; + offset: number; +} + +interface BodyContext extends HeaderContext { + entryOffset: number; + size: number; +} + +export class PackfileParserStream extends Transform { + constructor() { + let state: Promise | undefined; + super({ + readableObjectMode: true, + transform(chunk, _, callback) { + state = state + ? state.then((s) => s(chunk)) + : parseStart(chunk, { + digest: createHash('sha1'), + onEntry: (entry) => { + this.push(entry); + }, + }); + state.then( + () => { + callback(null); + }, + (err) => { + callback(err); + }, + ); + }, + flush(callback) { + if (state) { + state + .then((s) => s(null)) + .then( + () => callback(null), + (err) => callback(err), + ); + } else { + callback(new Error(`Unexpected end of stream`)); + } + }, + }); + } +} +// The first four bytes in a packfile are the bytes 'PACK' + +// The version is stored as an unsigned 32 integer in network byte order. +// It must be version 2 or 3. + +// The number of objects in this packfile is also stored as an unsigned 32 bit int. + +const HEADER_LENGTH = 4 * 3; +async function parseStart(chunk: Buffer, ctx: BaseContext): Promise { + if (chunk.length < HEADER_LENGTH) { + return await waitForMore( + chunk, + async (chunk) => await parseStart(chunk, ctx), + ); + } + + const packfileHeader = chunk.readUInt32BE(0); + if (packfileHeader !== 0x5041434b) { + throw new Error('Invalid packfile header'); + } + + const version = chunk.readUInt32BE(4); + if (version !== 2 && version !== 3) { + throw new Error('Invalid version number ' + version); + } + + const entriesCount = chunk.readUInt32BE(8); + + ctx.digest.update(chunk.slice(0, HEADER_LENGTH)); + return await parseHeader(chunk.slice(HEADER_LENGTH), { + ...ctx, + version, + entriesCount, + entryIndex: 0, + offset: HEADER_LENGTH, + }); +} + +// n-byte type and length (3-bit type, (n-1)*7+4-bit length) +// CTTTSSSS +// C is continue bit, TTT is type, S+ is length +// Second state in the same header parsing. +// CSSSSSSS* +async function parseHeader(chunk: Buffer, ctx: HeaderContext): Promise { + if (ctx.entryIndex >= ctx.entriesCount) { + return await parseChecksum(chunk, ctx); + } + if (!chunk.length) { + return await waitForMore( + chunk, + async (chunk) => await parseHeader(chunk, ctx), + ); + } + + let offset = ctx.offset; + const entryOffset = ctx.offset; + let byte = chunk[0]; + const type = (byte >> 4) & 0x7; + let size = byte & 0xf; + let left = 4; + + offset++; + ctx.digest.update(chunk.slice(0, 1)); + return parseChunk(chunk.slice(1)); + async function parseChunk(chunk: Buffer | null): Promise { + if (!chunk) { + throw new Error(`Unexpected end of stream`); + } + let i = 0; + while (byte & 0x80) { + if (i >= chunk.length) { + ctx.digest.update(chunk); + return parseChunk; + } + offset++; + byte = chunk[i++]; + size |= (byte & 0x7f) << left; + left += 7; + } + ctx.digest.update(chunk.slice(0, i)); + return await end(chunk.slice(i)); + } + async function end(remaining: Buffer): Promise { + switch (type) { + case 6: + return await ofsDelta(remaining, { + ...ctx, + entryOffset, + offset, + size, + }); + case 7: + return await refDelta(remaining, { + ...ctx, + entryOffset, + offset, + size, + }); + default: + return await parseBody( + remaining, + { + ...ctx, + entryOffset, + offset, + size, + }, + (body) => { + ctx.onEntry({type, body, offset: entryOffset}); + }, + ); + } + } +} + +// Big-endian modified base 128 number encoded ref offset +async function ofsDelta(chunk: Buffer, ctx: BodyContext): Promise { + if (!chunk.length) + return await waitForMore( + chunk, + async (buffer) => await ofsDelta(buffer, ctx), + ); + + let offset = ctx.offset; + let byte = chunk[0]; + let ref = byte & 0x7f; + + offset++; + ctx.digest.update(chunk.slice(0, 1)); + return parseChunk(chunk.slice(1)); + async function parseChunk(chunk: Buffer | null): Promise { + if (!chunk) { + throw new Error(`Unexpected end of stream`); + } + let i = 0; + while (byte & 0x80) { + if (i >= chunk.length) { + ctx.digest.update(chunk); + return parseChunk; + } + offset++; + byte = chunk[i++]; + ref = ((ref + 1) << 7) | (byte & 0x7f); + } + ctx.digest.update(chunk.slice(0, i)); + return await end(chunk.slice(i)); + } + async function end(remaining: Buffer): Promise { + return parseBody( + remaining, + { + ...ctx, + offset, + }, + (body) => { + ctx.onEntry({ + type: Type.ofsDelta, + ref, + body, + offset: ctx.entryOffset, + }); + }, + ); + } +} + +// 20 byte raw sha1 hash for ref +async function refDelta(chunk: Buffer, ctx: BodyContext): Promise { + if (chunk.length < 20) { + return await waitForMore( + chunk, + async (chunk) => await refDelta(chunk, ctx), + ); + } + const ref = chunk.slice(0, 20).toString('hex'); + const remaining = chunk.slice(20); + return await parseBody( + remaining, + { + ...ctx, + offset: ctx.offset + 20, + }, + (body) => { + ctx.onEntry({ + type: Type.refDelta, + ref, + body, + offset: ctx.entryOffset, + }); + }, + ); +} + +// Feed the deflated code to the inflate engine +async function parseBody( + chunk: Buffer, + ctx: BodyContext, + onBody: (body: Buffer) => void, +): Promise { + let inflateEnded = false; + const inflate = createInflate(); + const inputBuffers: Buffer[] = []; + const outputBuffers: Buffer[] = []; + const nextParser = new Promise((resolve, reject) => { + inflate.on(`data`, (buffer) => { + outputBuffers.push(buffer); + }); + inflate.on('error', (err) => { + inflateEnded = true; + reject(err); + }); + inflate.on('end', () => { + inflateEnded = true; + const outputBuffer = Buffer.concat(outputBuffers); + if (outputBuffer.length !== ctx.size) { + throw new Error( + `Length mismatch, expected ${ctx.size} got ${outputBuffer.length}`, + ); + } + onBody(outputBuffer); + + const inputBuffer = Buffer.concat(inputBuffers); + ctx.digest.update(inputBuffer.slice(0, inflate.bytesWritten)); + const remaining = inputBuffer.slice(inflate.bytesWritten); + resolve( + parseHeader(remaining, { + ...ctx, + entryIndex: ctx.entryIndex + 1, + offset: ctx.offset + inflate.bytesWritten, + }), + ); + }); + }); + return writeChunk(chunk); + async function writeChunk(chunk: Buffer | null): Promise { + if (!chunk || inflateEnded) { + if (!inflateEnded) { + inflate.end(); + } + return await (await nextParser)(chunk); + } + inputBuffers.push(chunk); + inflate.write(chunk); + // if (!inflate.write(chunk)) { + // await new Promise((resolve, reject) => { + // function onResume() { + // inflate.off(`resume`, onResume); + // inflate.off(`error`, onError); + // resolve(); + // } + // function onError(err: Error) { + // inflate.off(`resume`, onResume); + // inflate.off(`error`, onError); + // reject(err); + // } + // inflate.on(`resume`, onResume); + // inflate.on(`error`, onError); + // }); + // } + return writeChunk; + } + + // const inf = new pako.Inflate(); + // do { + // inf.push(await state.buffer.chunk()); + // } while (inf.err === 0 && inf.result === undefined); + // state.buffer.rewind((inf as any).strm.avail_in); + // if (inf.err != 0) throw new Error(`Inflate error ${inf.err} ${inf.msg}`); + // const data = inf.result as Uint8Array; + // if (data.length !== state.size) + // throw new Error( + // `Length mismatch, expected ${state.size} got ${data.length}`, + // ); + + // return { + // ...state, + // state: 'entry', + // entry: entry(state, data), + // entryIndex: state.entryIndex + 1, + // }; +} + +// 20 byte checksum +async function parseChecksum( + chunk: Buffer, + ctx: HeaderContext, +): Promise { + if (chunk.length < 20) { + return waitForMore(chunk, (chunk) => parseChecksum(chunk, ctx)); + } + const actual = ctx.digest.digest('hex'); + const checksum = chunk.slice(0, 20).toString('hex'); + if (checksum !== actual) { + throw new Error( + `Checksum mismatch: actual ${actual} != expected ${checksum}`, + ); + } + return done; + async function done(_chunk: Buffer | null): Promise { + return done; + } +} + +// async function consume( +// chunk: Buffer | null, +// bytes: number, +// handler: (buffer: Buffer, rest: Buffer) => Promise, +// ): Promise { +// if (!chunk) { +// throw new Error(`Unexpected end of input stream`); +// } +// if (chunk.length < bytes) { +// return await waitForMore( +// chunk, +// async (chunk) => await consume(chunk, bytes, handler), +// ); +// } +// return await handler(chunk.slice(0, bytes), chunk.slice(bytes)); +// } + +function waitForMore( + buffer: Buffer, + handler: (buffer: Buffer) => Promise, +): State { + return async (chunk: Buffer | null) => { + if (!chunk) { + throw new Error(`Unexpected end of input stream`); + } + return await handler(Buffer.concat([buffer, chunk])); + }; +} From 72f6670db744a551d5fed1ab434643db92ccfbfb Mon Sep 17 00:00:00 2001 From: Forbes Lindesay Date: Fri, 3 Sep 2021 12:44:02 +0100 Subject: [PATCH 06/10] refactor: node streams only --- .../packfile/src/DigestableAsyncBuffer.ts | 59 ---- .../packfile/src/PackfileGeneratorStream.ts | 67 ++++ .../packfile/src/PackfileParserStream.test.ts | 32 ++ ...rser-stream.ts => PackfileParserStream.ts} | 211 +++++------- packages/packfile/src/compose-packfile.ts | 82 ----- packages/packfile/src/index.test.ts | 18 -- packages/packfile/src/index.ts | 9 +- packages/packfile/src/normalize-entries.ts | 73 ----- packages/packfile/src/pack.ts | 76 ----- .../src/packfile-parser-stream.test.ts | 62 ---- packages/packfile/src/parse-packfile.ts | 304 ------------------ packages/packfile/src/pipe.ts | 110 ------- packages/packfile/src/types.ts | 38 +-- packages/packfile/src/unpack.test.ts | 27 -- packages/packfile/src/unpack.ts | 16 - 15 files changed, 203 insertions(+), 981 deletions(-) delete mode 100644 packages/packfile/src/DigestableAsyncBuffer.ts create mode 100644 packages/packfile/src/PackfileGeneratorStream.ts create mode 100644 packages/packfile/src/PackfileParserStream.test.ts rename packages/packfile/src/{packfile-parser-stream.ts => PackfileParserStream.ts} (67%) delete mode 100644 packages/packfile/src/compose-packfile.ts delete mode 100644 packages/packfile/src/index.test.ts delete mode 100644 packages/packfile/src/normalize-entries.ts delete mode 100644 packages/packfile/src/pack.ts delete mode 100644 packages/packfile/src/packfile-parser-stream.test.ts delete mode 100644 packages/packfile/src/parse-packfile.ts delete mode 100644 packages/packfile/src/pipe.ts delete mode 100644 packages/packfile/src/unpack.test.ts delete mode 100644 packages/packfile/src/unpack.ts diff --git a/packages/packfile/src/DigestableAsyncBuffer.ts b/packages/packfile/src/DigestableAsyncBuffer.ts deleted file mode 100644 index d8ff097..0000000 --- a/packages/packfile/src/DigestableAsyncBuffer.ts +++ /dev/null @@ -1,59 +0,0 @@ -import {AsyncBuffer} from '@rollingversions/git-core'; -import {createHash, Hash} from 'crypto'; - -export default class DigestableAsyncBuffer extends AsyncBuffer { - private sha: Hash; - private temp: Uint8Array; - private tempChunk: Uint8Array | undefined; - constructor(chunks: AsyncIterableIterator) { - super(chunks); - this.sha = createHash('sha1'); // sha1(); - this.temp = new Uint8Array(1); - } - - next(): Promise; - next(length: number): Promise; - async next(length?: number) { - if (length === undefined) { - const result = await super.next(); - this.temp[0] = result; - this.sha.update(this.temp); - return result; - } else { - const result = await super.next(length); - this.sha.update(result); - return result; - } - } - - async nextInt32(): Promise { - const buffer = await super.next(4); - this.sha.update(buffer); - let result = 0; - for (let i = 0; i < 4; i++) { - result = (result << 8) | buffer[i]; - } - return result; - } - - async chunk() { - if (this.tempChunk) this.sha.update(this.tempChunk); - this.tempChunk = await super.chunk(); - return this.tempChunk; - } - - rewind(length: number) { - if (this.tempChunk) - this.sha.update( - this.tempChunk.subarray(0, this.tempChunk.length - length), - ); - this.tempChunk = undefined; - super.rewind(length); - } - - digest() { - const result = this.sha.digest('hex'); - this.sha = createHash('sha1'); - return result; - } -} diff --git a/packages/packfile/src/PackfileGeneratorStream.ts b/packages/packfile/src/PackfileGeneratorStream.ts new file mode 100644 index 0000000..44c7787 --- /dev/null +++ b/packages/packfile/src/PackfileGeneratorStream.ts @@ -0,0 +1,67 @@ +import {createHash} from 'crypto'; +import {Transform} from 'stream'; +import {createDeflate} from 'zlib'; +import {GitRawObject, GitObjectTypeID} from './types'; + +export default class PackfileGeneratorStream extends Transform { + constructor({length}: {length: number}) { + const hash = createHash('sha1'); + let writtenHead = false; + const writeHead = () => { + if (writtenHead) return; + const head = Buffer.from([ + 0x50, + 0x41, + 0x43, + 0x4b, // PACK + 0, + 0, + 0, + 2, // version 2 + length >> 24, // Num of objects + (length >> 16) & 0xff, + (length >> 8) & 0xff, + length & 0xff, + ]); + hash.update(head); + this.push(head); + }; + super({ + writableObjectMode: true, + transform(chunk: GitRawObject, _, callback) { + writeHead(); + const type = GitObjectTypeID[chunk.type]; + // TODO: support packing deltas + this.push(packFrameHeader(type, chunk.body.length)); + const deflateStream = createDeflate(); + deflateStream + .on('data', (chunk) => { + this.push(chunk); + }) + .on('error', (err) => callback(err)) + .on('end', () => { + callback(); + }) + .end(chunk.body); + }, + flush(callback) { + writeHead(); + this.push(hash.digest()); + callback(); + }, + }); + } +} + +// write TYPE_AND_BASE128_SIZE +function packFrameHeader(type: GitObjectTypeID, length: number) { + const head = [(type << 4) | (length & 0xf)]; + let i = 0; + length >>= 4; + while (length) { + head[i++] |= 0x80; + head[i] = length & 0x7f; + length >>= 7; + } + return Buffer.from(head); +} diff --git a/packages/packfile/src/PackfileParserStream.test.ts b/packages/packfile/src/PackfileParserStream.test.ts new file mode 100644 index 0000000..abc7619 --- /dev/null +++ b/packages/packfile/src/PackfileParserStream.test.ts @@ -0,0 +1,32 @@ +import {createReadStream} from 'fs'; +import PackfileParserStream from './PackfileParserStream'; + +test('unpack sample', async () => { + const entries: any[] = []; + await new Promise((resolve, reject) => { + const input = createReadStream(__dirname + '/../samples/sample1.pack'); + const parser = new PackfileParserStream(); + + input.pipe(parser); + + input.on(`error`, (err) => reject(err)); + parser.on(`error`, (err) => reject(err)); + // let index = 0; + parser.on(`data`, (entry) => { + // console.log(`type =`, entry.type); + // const expectedEntry = expectedEntries[index++]; + // expect({ + // type: entry.type, + // offset: entry.offset, + // body: createHash('sha1').update(entry.body).digest('hex'), + // }).toEqual({ + // type: expectedEntry.type, + // offset: expectedEntry.offset, + // body: createHash('sha1').update(expectedEntry.body).digest('hex'), + // }); + entries.push(entry); + }); + parser.on(`end`, () => resolve()); + }); + expect(entries.length).toBe(2651); +}); diff --git a/packages/packfile/src/packfile-parser-stream.ts b/packages/packfile/src/PackfileParserStream.ts similarity index 67% rename from packages/packfile/src/packfile-parser-stream.ts rename to packages/packfile/src/PackfileParserStream.ts index d1590c9..ee179b8 100644 --- a/packages/packfile/src/packfile-parser-stream.ts +++ b/packages/packfile/src/PackfileParserStream.ts @@ -1,69 +1,43 @@ +import {concat, encode} from '@rollingversions/git-core'; import {createHash, Hash} from 'crypto'; import {Transform} from 'stream'; import {createInflate} from 'zlib'; -import {Type, Entry} from './types'; - -// interface BaseState { -// /** -// * -// */ -// readonly buffer: Buffer; -// /** -// * Byte offset from start of stream -// */ -// readonly offset: number; -// /** -// * Git protocol version -// */ -// readonly version: 2 | 3; - -// readonly entriesCount: number; -// readonly entryIndex: number; -// } -// interface StateStart extends Pick { -// readonly type: 'start'; -// } -// interface StateParsingVersion extends Pick { -// readonly type: 'parsing-version'; -// } -// interface StateParsingEntriesCount -// extends Pick { -// readonly type: 'parsing-entries-count'; -// } -// interface StateParsingHeader -// extends Pick< -// BaseState, -// 'buffer' | 'offset' | 'version' | 'entriesCount' | 'entryIndex' -// > { -// readonly type: 'parsing-header'; -// } - -// type State = -// | StateStart -// | StateParsingVersion -// | StateParsingEntriesCount -// | StateParsingHeader; +import applyDelta from './apply-delta'; +import {PackfileEntry, GitObjectTypeID} from './types'; type State = (chunk: Buffer | null) => Promise; interface BaseContext { - digest: Hash; - onEntry: (entry: Entry) => void; + readonly digest: Hash; + readonly references: Store; + readonly offsets: Store; + readonly onEntry: (entry: PackfileEntry) => void; } interface HeaderContext extends BaseContext { - version: 2 | 3; - entriesCount: number; - entryIndex: number; - offset: number; + readonly version: 2 | 3; + readonly entriesCount: number; + readonly entryIndex: number; + readonly offset: number; } interface BodyContext extends HeaderContext { - entryOffset: number; - size: number; + readonly entryOffset: number; + readonly size: number; +} + +export interface Store { + get(key: TKey): TValue | undefined | Promise; + set(key: TKey, value: TValue): unknown; +} +export interface Stores { + // Ideally you would provide a store that supports thinpack lookup + // in addition to refs added via `.set` + readonly references?: Store; + readonly offsets?: Store; } -export class PackfileParserStream extends Transform { - constructor() { +export default class PackfileParserStream extends Transform { + constructor({references = new Map(), offsets = new Map()}: Stores = {}) { let state: Promise | undefined; super({ readableObjectMode: true, @@ -71,9 +45,22 @@ export class PackfileParserStream extends Transform { state = state ? state.then((s) => s(chunk)) : parseStart(chunk, { + references, + offsets, digest: createHash('sha1'), onEntry: (entry) => { - this.push(entry); + const type = GitObjectTypeID[entry.type]; + const body = encodeRaw(type, entry.body); + const hash = createHash('sha1').update(body).digest('hex'); + + references.set(hash, entry); + offsets.set(entry.offset, entry); + + this.push({ + hash, + type, + body, + }); }, }); state.then( @@ -100,13 +87,13 @@ export class PackfileParserStream extends Transform { }); } } + // The first four bytes in a packfile are the bytes 'PACK' // The version is stored as an unsigned 32 integer in network byte order. // It must be version 2 or 3. // The number of objects in this packfile is also stored as an unsigned 32 bit int. - const HEADER_LENGTH = 4 * 3; async function parseStart(chunk: Buffer, ctx: BaseContext): Promise { if (chunk.length < HEADER_LENGTH) { @@ -118,12 +105,14 @@ async function parseStart(chunk: Buffer, ctx: BaseContext): Promise { const packfileHeader = chunk.readUInt32BE(0); if (packfileHeader !== 0x5041434b) { - throw new Error('Invalid packfile header'); + throw new Error( + 'Invalid packfile header, packfiles should start with "PACK"', + ); } const version = chunk.readUInt32BE(4); if (version !== 2 && version !== 3) { - throw new Error('Invalid version number ' + version); + throw new Error('Invalid version number ' + version + ', expected 2 or 3'); } const entriesCount = chunk.readUInt32BE(8); @@ -207,7 +196,7 @@ async function parseHeader(chunk: Buffer, ctx: HeaderContext): Promise { offset, size, }, - (body) => { + async (body) => { ctx.onEntry({type, body, offset: entryOffset}); }, ); @@ -254,10 +243,16 @@ async function ofsDelta(chunk: Buffer, ctx: BodyContext): Promise { ...ctx, offset, }, - (body) => { + async (deltaBody) => { + const base = await ctx.offsets.get(ctx.entryOffset - ref); + if (!base) { + throw new Error( + `Cannot find base of ofs-delta ${ctx.entryOffset} - ${ref}`, + ); + } + const body = applyDelta(deltaBody, base.body); ctx.onEntry({ - type: Type.ofsDelta, - ref, + type: base.type, body, offset: ctx.entryOffset, }); @@ -282,10 +277,16 @@ async function refDelta(chunk: Buffer, ctx: BodyContext): Promise { ...ctx, offset: ctx.offset + 20, }, - (body) => { + async (deltaBody) => { + const base = await ctx.references.get(ref); + if (!base) { + throw new Error( + `Cannot find base of ref-delta ${ctx.entryOffset}: ${ref}`, + ); + } + const body = applyDelta(deltaBody, base.body); ctx.onEntry({ - type: Type.refDelta, - ref, + type: base.type, body, offset: ctx.entryOffset, }); @@ -297,7 +298,7 @@ async function refDelta(chunk: Buffer, ctx: BodyContext): Promise { async function parseBody( chunk: Buffer, ctx: BodyContext, - onBody: (body: Buffer) => void, + onBody: (body: Buffer, compressedBody: Buffer) => Promise, ): Promise { let inflateEnded = false; const inflate = createInflate(); @@ -319,17 +320,23 @@ async function parseBody( `Length mismatch, expected ${ctx.size} got ${outputBuffer.length}`, ); } - onBody(outputBuffer); - const inputBuffer = Buffer.concat(inputBuffers); - ctx.digest.update(inputBuffer.slice(0, inflate.bytesWritten)); - const remaining = inputBuffer.slice(inflate.bytesWritten); - resolve( - parseHeader(remaining, { - ...ctx, - entryIndex: ctx.entryIndex + 1, - offset: ctx.offset + inflate.bytesWritten, - }), + + onBody(outputBuffer, inputBuffer).then( + () => { + ctx.digest.update(inputBuffer.slice(0, inflate.bytesWritten)); + const remaining = inputBuffer.slice(inflate.bytesWritten); + resolve( + parseHeader(remaining, { + ...ctx, + entryIndex: ctx.entryIndex + 1, + offset: ctx.offset + inflate.bytesWritten, + }), + ); + }, + (err) => { + reject(err); + }, ); }); }); @@ -343,43 +350,8 @@ async function parseBody( } inputBuffers.push(chunk); inflate.write(chunk); - // if (!inflate.write(chunk)) { - // await new Promise((resolve, reject) => { - // function onResume() { - // inflate.off(`resume`, onResume); - // inflate.off(`error`, onError); - // resolve(); - // } - // function onError(err: Error) { - // inflate.off(`resume`, onResume); - // inflate.off(`error`, onError); - // reject(err); - // } - // inflate.on(`resume`, onResume); - // inflate.on(`error`, onError); - // }); - // } return writeChunk; } - - // const inf = new pako.Inflate(); - // do { - // inf.push(await state.buffer.chunk()); - // } while (inf.err === 0 && inf.result === undefined); - // state.buffer.rewind((inf as any).strm.avail_in); - // if (inf.err != 0) throw new Error(`Inflate error ${inf.err} ${inf.msg}`); - // const data = inf.result as Uint8Array; - // if (data.length !== state.size) - // throw new Error( - // `Length mismatch, expected ${state.size} got ${data.length}`, - // ); - - // return { - // ...state, - // state: 'entry', - // entry: entry(state, data), - // entryIndex: state.entryIndex + 1, - // }; } // 20 byte checksum @@ -403,23 +375,6 @@ async function parseChecksum( } } -// async function consume( -// chunk: Buffer | null, -// bytes: number, -// handler: (buffer: Buffer, rest: Buffer) => Promise, -// ): Promise { -// if (!chunk) { -// throw new Error(`Unexpected end of input stream`); -// } -// if (chunk.length < bytes) { -// return await waitForMore( -// chunk, -// async (chunk) => await consume(chunk, bytes, handler), -// ); -// } -// return await handler(chunk.slice(0, bytes), chunk.slice(bytes)); -// } - function waitForMore( buffer: Buffer, handler: (buffer: Buffer) => Promise, @@ -431,3 +386,7 @@ function waitForMore( return await handler(Buffer.concat([buffer, chunk])); }; } + +function encodeRaw(type: string, bytes: Uint8Array) { + return concat(encode(`${type} ${bytes.length}\0`), bytes); +} diff --git a/packages/packfile/src/compose-packfile.ts b/packages/packfile/src/compose-packfile.ts deleted file mode 100644 index fdda5e1..0000000 --- a/packages/packfile/src/compose-packfile.ts +++ /dev/null @@ -1,82 +0,0 @@ -import {createHash} from 'crypto'; - -import * as pako from 'pako'; - -import {Type, Entry} from './types'; - -export default async function* composePackfile( - items: AsyncIterableIterator, - count: number, -) { - const hash = createHash('sha1'); - - const head = packHeader(count); - hash.update(head); - yield head; - - for await (const item of items) { - for (const chunk of packFrame(item)) { - hash.update(chunk); - yield chunk; - } - } - - yield hash.digest(); -} - -function packHeader(length: number) { - return Uint8Array.from([ - 0x50, - 0x41, - 0x43, - 0x4b, // PACK - 0, - 0, - 0, - 2, // version 2 - length >> 24, // Num of objects - (length >> 16) & 0xff, - (length >> 8) & 0xff, - length & 0xff, - ]); -} - -function* packFrame(item: Entry) { - yield packFrameHeader(item.type, item.body.length); - - if (item.type === Type.ofsDelta) { - yield packOfsDelta(item.ref); - } else if (item.type === Type.refDelta) { - yield Buffer.from(item.ref, 'hex'); - } - - yield pako.deflate(item.body); -} - -// write TYPE_AND_BASE128_SIZE -function packFrameHeader(type: number, length: number) { - const head = [(type << 4) | (length & 0xf)]; - let i = 0; - length >>= 4; - while (length) { - head[i++] |= 0x80; - head[i] = length & 0x7f; - length >>= 7; - } - return new Uint8Array(head); -} - -// write BIG_ENDIAN_MODIFIED_BASE_128_NUMBER -function packOfsDelta(ref: number) { - let offset = ref; - // Calculate how many digits we need in base 128 - let i = Math.floor(Math.log(offset) / Math.log(0x80)); - const head = new Uint8Array(i + 1); - // Write the last digit - head[i] = offset & 0x7f; - // Then write the rest - while ((offset >>= 7)) { - head[--i] = 0x80 | (--offset & 0x7f); - } - return head; -} diff --git a/packages/packfile/src/index.test.ts b/packages/packfile/src/index.test.ts deleted file mode 100644 index bfe50cd..0000000 --- a/packages/packfile/src/index.test.ts +++ /dev/null @@ -1,18 +0,0 @@ -import {decode, encode} from '@rollingversions/git-core'; -import {pack, unpack} from './index'; - -test('pack-unpack', async () => { - const blobs = ['blob 4\0test', 'commit 7\0testing']; - - const result = []; - for await (const entry of unpack(pack(prepare(blobs), blobs.length))) { - result.push(decode(entry.body)); - } - expect(result).toEqual(['commit 7\0testing', 'blob 4\0test']); -}); - -async function* prepare(blobs: string[]) { - for (const blob of blobs) { - yield ['00', encode(blob)] as const; - } -} diff --git a/packages/packfile/src/index.ts b/packages/packfile/src/index.ts index 35302a1..7e0fb63 100644 --- a/packages/packfile/src/index.ts +++ b/packages/packfile/src/index.ts @@ -1,5 +1,6 @@ -export {RawObject, Progress} from './types'; +export type {GitRawObject, PackfileEntry} from './types'; +export {GitObjectType} from './types'; -export {default as unpack} from './unpack'; - -export {default as pack, HashBlob} from './pack'; +export {default as PackfileGeneratorStream} from './PackfileGeneratorStream'; +export {default as PackfileParserStream} from './PackfileParserStream'; +export type { Store, Stores} from './PackfileParserStream'; diff --git a/packages/packfile/src/normalize-entries.ts b/packages/packfile/src/normalize-entries.ts deleted file mode 100644 index 2ea6bb3..0000000 --- a/packages/packfile/src/normalize-entries.ts +++ /dev/null @@ -1,73 +0,0 @@ -import {concat, encode} from '@rollingversions/git-core'; - -import { - Type, - Entry, - NormalEntry, - OfsDeltaEntry, - RefDeltaEntry, - RawObject, - Progress, -} from './types'; -import applyDelta from './apply-delta'; -import {createHash} from 'crypto'; - -export default async function* normalizeEntries( - entries: AsyncIterableIterator, - progress?: Progress, -): AsyncIterableIterator { - const references = new Map(); - const offsets = new Map(); - let deltas = 0; - - for await (let entry of entries) { - if (entry.type === Type.ofsDelta || entry.type === Type.refDelta) { - const base = getBase(entry); - const body = applyDelta(entry.body, base.body); - deltas++; - entry = { - type: base.type, - body, - offset: entry.offset, - }; - } - - const type = Type[entry.type]; - const body = encodeRaw(type, entry.body); - const hash = createHash('sha1').update(body).digest('hex'); - - references.set(hash, entry); - offsets.set(entry.offset, entry); - yield { - type, - body, - hash, - }; - } - - if (progress) - progress(`Resolving deltas: 100% (${deltas}/${deltas}), done.\n`); - - function getBase(entry: OfsDeltaEntry | RefDeltaEntry) { - if (entry.type === Type.ofsDelta) { - const base = offsets.get(entry.offset - entry.ref); - if (!base) - throw new Error( - `Cannot find base of ofs-delta ${entry.offset} - ${entry.ref}`, - ); - return base; - } else { - const base = references.get(entry.ref); - if (!base) - throw new Error( - `Cannot find base of ref-delta ${entry.offset}: ${entry.ref}`, - ); - //ToDo: thinpack lookup - return base; - } - } -} - -export function encodeRaw(type: string, bytes: Uint8Array) { - return concat(encode(`${type} ${bytes.length}\0`), bytes); -} diff --git a/packages/packfile/src/pack.ts b/packages/packfile/src/pack.ts deleted file mode 100644 index 767556e..0000000 --- a/packages/packfile/src/pack.ts +++ /dev/null @@ -1,76 +0,0 @@ -import {decode} from '@rollingversions/git-core'; - -import composePackfile from './compose-packfile'; -import {Type, NormalEntry, RawObject} from './types'; -import pipe from './pipe'; - -export type HashBlob = readonly [string, Uint8Array]; - -export default async function* pack( - objects: AsyncIterableIterator, - count: number, -): AsyncIterableIterator { - yield* pipe(objects) - .pipe(toRawObject) - .pipe(toEntry) - .pipe(sortByType) - .pipe((x) => composePackfile(x, count)); -} - -async function* toRawObject( - objects: AsyncIterableIterator, -): AsyncIterableIterator { - for await (const [hash, body] of objects) { - const space = body.indexOf(0x20); - const nil = body.indexOf(0x00, space); - yield { - body: body.subarray(nil + 1), - type: decode(body, 0, space), - hash: hash, - }; - } -} - -async function* toEntry( - objects: AsyncIterableIterator, -): AsyncIterableIterator { - for await (const object of objects) { - yield { - body: object.body, - type: - object.type === 'commit' - ? Type.commit - : object.type === 'tree' - ? Type.tree - : Type.blob, - offset: 0, - }; - } -} - -async function* sortByType(entries: AsyncIterableIterator) { - const commits = []; - const trees = []; - const blobs = []; - const others = []; - for await (const entry of entries) { - switch (entry.type) { - case Type.commit: - commits.push(entry); - break; - case Type.tree: - trees.push(entry); - break; - case Type.blob: - blobs.push(entry); - break; - default: - others.push(entry); - break; - } - } - yield* commits; - yield* trees; - yield* blobs; - yield* others; -} diff --git a/packages/packfile/src/packfile-parser-stream.test.ts b/packages/packfile/src/packfile-parser-stream.test.ts deleted file mode 100644 index 64d2dad..0000000 --- a/packages/packfile/src/packfile-parser-stream.test.ts +++ /dev/null @@ -1,62 +0,0 @@ -import {createHash} from 'crypto'; -import {createReadStream, readFileSync} from 'fs'; -import {PackfileParserStream} from './packfile-parser-stream'; -import parsePackfile from './parse-packfile'; - -async function* input() { - const pack = readFileSync(__dirname + '/../samples/sample1.pack'); - yield pack; -} -const expectedEntries: any[] = []; -test('unpack sample', async () => { - for await (const entry of parsePackfile(input())) { - expectedEntries.push(entry); - } - - expect(expectedEntries.length).toBe(2651); -}); - -test('unpack sample', async () => { - const entries: any[] = []; - await new Promise((resolve, reject) => { - const input = createReadStream(__dirname + '/../samples/sample1.pack'); - const parser = new PackfileParserStream(); - - input.pipe(parser); - - input.on(`error`, (err) => reject(err)); - parser.on(`error`, (err) => reject(err)); - let index = 0; - parser.on(`data`, (entry) => { - // console.log(`type =`, entry.type); - const expectedEntry = expectedEntries[index++]; - expect({ - type: entry.type, - offset: entry.offset, - body: createHash('sha1').update(entry.body).digest('hex'), - }).toEqual({ - type: expectedEntry.type, - offset: expectedEntry.offset, - body: createHash('sha1').update(expectedEntry.body).digest('hex'), - }); - entries.push(entry); - }); - parser.on(`end`, () => resolve()); - }); - // const entries = []; - // for await (const entry of unpack(input())) { - // entries.push(entry); - // } - - // expect({ - // hash: entries[2120].hash, - // type: entries[2120].type, - // }).toEqual({ - // hash: 'def0c2614b88c6df95ac49c1e0f5e13494301142', - // type: 'blob', - // }); - // expect(createHash('sha1').update(entries[2120].body).digest('hex')).toBe( - // entries[2120].hash, - // ); - expect(entries.length).toBe(2651); -}); diff --git a/packages/packfile/src/parse-packfile.ts b/packages/packfile/src/parse-packfile.ts deleted file mode 100644 index 2cfbd01..0000000 --- a/packages/packfile/src/parse-packfile.ts +++ /dev/null @@ -1,304 +0,0 @@ -import * as pako from 'pako'; -import {AsyncBuffer} from '@rollingversions/git-core'; -import DigestableAsyncBuffer from './DigestableAsyncBuffer'; - -import {Type, Entry, Progress} from './types'; - -type $State = T & { - readonly state: S; -}; - -interface StartState { - readonly buffer: DigestableAsyncBuffer; -} - -interface PackState extends StartState {} - -interface VersionState extends PackState { - readonly version: number; -} - -interface EntriesState extends VersionState { - readonly entryCount: number; - readonly entryIndex: number; -} - -interface HeaderState extends EntriesState { - readonly type: Type.blob | Type.commit | Type.tag | Type.tree; - readonly offset: number; - readonly size: number; -} - -interface DeltaHeaderState extends EntriesState { - readonly offset: number; - readonly size: number; -} - -interface OfsDeltaState extends DeltaHeaderState { - readonly type: Type.ofsDelta; - readonly ref: number; -} - -interface RefDeltaState extends DeltaHeaderState { - readonly type: Type.refDelta; - readonly ref: string; -} - -interface ChecksumState extends EntriesState { - readonly checksum: string; -} - -interface EntryState extends EntriesState { - readonly entry: Entry; -} - -type State = - | $State<'start', StartState> - | $State<'pack', PackState> - | $State<'version', VersionState> - | $State<'entries', EntriesState> - | $State<'header', HeaderState> - | $State<'ofs-header', DeltaHeaderState> - | $State<'ref-header', DeltaHeaderState> - | $State<'ofs-delta', OfsDeltaState> - | $State<'ref-delta', RefDeltaState> - | $State<'entry', EntryState> - | $State<'done', ChecksumState>; - -export default async function* parsePackfile( - chunks: AsyncIterableIterator, - progress?: Progress, -): AsyncIterableIterator { - let state: State = { - state: 'start', - buffer: new DigestableAsyncBuffer(chunks), - }; - - do { - state = await $step(state, progress); - if (state.state === 'entry') { - yield state.entry; - } - } while (state.state !== 'done'); - state.buffer.complete(); -} - -async function $step(state: State, progress?: Progress) { - switch (state.state) { - case 'start': - return $pack(state); - case 'pack': - return $version(state); - case 'version': - return $entries(state); - case 'entries': - return $header(state); - case 'ofs-header': - return $ofsDelta(state); - case 'ref-header': - return $refDelta(state); - case 'header': - case 'ofs-delta': - case 'ref-delta': - return $body(state); - case 'entry': - if (progress) progress(report(state)); - if (state.entryCount > state.entryIndex) { - return $header(state); - } else { - return $checksum(state); - } - default: - throw new Error(`Unknown state ${state}`); - } -} - -// The first four bytes in a packfile are the bytes 'PACK' -async function $pack(state: StartState): Promise { - if ((await state.buffer.nextInt32()) === 0x5041434b) - return { - ...state, - state: 'pack', - }; - else throw new Error('Invalid packfile header'); -} - -// The version is stored as an unsigned 32 integer in network byte order. -// It must be version 2 or 3. -async function $version(state: PackState): Promise { - const version = await state.buffer.nextInt32(); - if (version === 2 || version === 3) - return { - ...state, - state: 'version', - version, - }; - else throw new Error('Invalid version number ' + version); -} - -// The number of objects in this packfile is also stored as an unsigned 32 bit int. -async function $entries(state: VersionState): Promise { - const entryCount = await state.buffer.nextInt32(); - return { - ...state, - state: 'entries', - entryCount, - entryIndex: 0, - }; -} - -// n-byte type and length (3-bit type, (n-1)*7+4-bit length) -// CTTTSSSS -// C is continue bit, TTT is type, S+ is length -// Second state in the same header parsing. -// CSSSSSSS* -async function $header(state: EntriesState): Promise { - const offset = state.buffer.pos; - let byte = await state.buffer.next(); - const type = (byte >> 4) & 0x7; - let size = byte & 0xf; - let left = 4; - while (byte & 0x80) { - byte = await state.buffer.next(); - size |= (byte & 0x7f) << left; - left += 7; - } - if (type === 6) { - return { - ...state, - state: 'ofs-header', - offset, - size, - }; - } else if (type === 7) { - return { - ...state, - state: 'ref-header', - offset, - size, - }; - } else { - return { - ...state, - state: 'header', - type, - offset, - size, - }; - } -} - -// Big-endian modified base 128 number encoded ref offset -async function $ofsDelta(state: DeltaHeaderState): Promise { - return { - ...state, - state: 'ofs-delta', - type: Type.ofsDelta, - ref: await varLen(state.buffer), - }; -} - -// 20 byte raw sha1 hash for ref -async function $refDelta(state: DeltaHeaderState): Promise { - return { - ...state, - state: 'ref-delta', - type: Type.refDelta, - ref: Buffer.from(await state.buffer.next(20)).toString('hex'), - }; -} - -// Feed the deflated code to the inflate engine -async function $body( - state: HeaderState | OfsDeltaState | RefDeltaState, -): Promise { - const inf = new pako.Inflate(); - do { - inf.push(await state.buffer.chunk()); - } while (inf.err === 0 && inf.result === undefined); - state.buffer.rewind((inf as any).strm.avail_in); - if (inf.err != 0) throw new Error(`Inflate error ${inf.err} ${inf.msg}`); - const data = inf.result as Uint8Array; - if (data.length !== state.size) - throw new Error( - `Length mismatch, expected ${state.size} got ${data.length}`, - ); - - return { - ...state, - state: 'entry', - entry: entry(state, data), - entryIndex: state.entryIndex + 1, - }; -} - -// 20 byte checksum -async function $checksum(state: EntriesState): Promise { - const actual = state.buffer.digest(); - const checksum = Buffer.from(await state.buffer.next(20)).toString('hex'); - if (checksum !== actual) - throw new Error( - `Checksum mismatch: actual ${actual} != expected ${checksum}`, - ); - return { - ...state, - state: 'done', - checksum, - }; -} - -function entry( - state: HeaderState | RefDeltaState | OfsDeltaState, - body: Uint8Array, -): Entry { - if (state.type == Type.ofsDelta) { - return { - type: Type.ofsDelta, - ref: state.ref, - body, - offset: state.offset, - }; - } else if (state.type == Type.refDelta) { - return { - type: Type.refDelta, - ref: state.ref, - body, - offset: state.offset, - }; - } else { - return { - type: state.type, - body, - offset: state.offset, - }; - } -} - -async function varLen(buffer: AsyncBuffer) { - let byte = await buffer.next(); - let ref = byte & 0x7f; - while (byte & 0x80) { - byte = await buffer.next(); - ref = ((ref + 1) << 7) | (byte & 0x7f); - } - return ref; -} - -const suffixes = ['Bytes', 'KiB', 'MiB', 'GiB']; -function report({entryCount: total, entryIndex: pos, buffer}: EntryState) { - const percent = ((pos / total) * 100) | 0; - let size = buffer.pos; - let suf = 0; - for (; size > 1024; suf++) { - size /= 1024; - } - if (pos === total) { - return `Receiving objects: ${percent}% (${pos}/${total}), ${size.toFixed( - 2, - )} ${suffixes[suf]}, done.\n`; - } else { - return `Receiving objects: ${percent}% (${pos}/${total}), ${size.toFixed( - 2, - )} ${suffixes[suf]}\r`; - } -} diff --git a/packages/packfile/src/pipe.ts b/packages/packfile/src/pipe.ts deleted file mode 100644 index ca9bb41..0000000 --- a/packages/packfile/src/pipe.ts +++ /dev/null @@ -1,110 +0,0 @@ -export default function pipe( - input: AsyncIterableIterator | PipableAsyncIterableIterator, -): PipableAsyncIterableIterator; -export default function pipe( - input: Iterable | IterableIterator | PipableIterableIterator, -): PipableIterableIterator; -export default function pipe( - input: - | Iterable - | IterableIterator - | PipableIterableIterator - | AsyncIterableIterator - | PipableAsyncIterableIterator, -): PipableIterableIterator | PipableAsyncIterableIterator { - if (isPipable(input)) { - return input; - } - - if (isAsync(input)) { - return { - [Symbol.asyncIterator]() { - return input[Symbol.asyncIterator](); - }, - next(value?: any) { - return input.next(value); - }, - return: input.return - ? (value?: any) => (input.return as any)(value) - : undefined, - throw: input.throw ? (e?: any) => (input.throw as any)(e) : undefined, - pipe( - next: ( - iterable: AsyncIterableIterator, - ) => AsyncIterableIterator, - ) { - return pipe(next(input)); - }, - then(func: (iterable: AsyncIterableIterator) => TOut): TOut { - return func(input); - }, - }; - } - - if (isIterator(input)) { - return { - [Symbol.iterator]() { - return input[Symbol.iterator](); - }, - next(value?: any) { - return input.next(value); - }, - return: input.return - ? (value?: any) => (input.return as any)(value) - : undefined, - throw: input.throw ? (e?: any) => (input.throw as any)(e) : undefined, - pipe( - next: (iterable: IterableIterator) => IterableIterator, - ) { - return pipe(next(input)); - }, - map(func: (iterable: IterableIterator) => TOut) { - return func(input); - }, - }; - } - - return pipe(toIterableIterator(input)); -} - -function* toIterableIterator(items: Iterable): IterableIterator { - yield* items; -} - -export interface PipableIterableIterator extends IterableIterator { - pipe( - next: (iterable: IterableIterator) => IterableIterator, - ): PipableIterableIterator; - map(func: (iterable: IterableIterator) => TOut): TOut; -} - -export interface PipableAsyncIterableIterator - extends AsyncIterableIterator { - pipe( - next: (iterable: AsyncIterableIterator) => AsyncIterableIterator, - ): PipableAsyncIterableIterator; - then(func: (iterable: AsyncIterableIterator) => TOut): TOut; -} - -function isPipable( - input: - | Iterable - | IterableIterator - | PipableIterableIterator - | AsyncIterableIterator - | PipableAsyncIterableIterator, -): input is PipableIterableIterator | PipableAsyncIterableIterator { - return 'pipe' in input; -} - -function isAsync( - input: Iterable | IterableIterator | AsyncIterableIterator, -): input is AsyncIterableIterator { - return Symbol.asyncIterator in input; -} - -function isIterator( - input: IterableIterator | Iterable, -): input is IterableIterator { - return 'next' in input; -} diff --git a/packages/packfile/src/types.ts b/packages/packfile/src/types.ts index 35ab9d7..fffdd1f 100644 --- a/packages/packfile/src/types.ts +++ b/packages/packfile/src/types.ts @@ -1,36 +1,26 @@ -export enum Type { +export enum GitObjectTypeID { commit = 1, tree = 2, blob = 3, tag = 4, - ofsDelta = 6, - refDelta = 7, + // ofsDelta = 6, + // refDelta = 7, +} +export enum GitObjectType { + commit = 'commit', + tree = 'tree', + blob = 'blob', + tag = 'tag', } -export interface AbstractEntry { +export interface PackfileEntry { + readonly type: GitObjectTypeID; readonly offset: number; readonly body: Uint8Array; } -export interface NormalEntry extends AbstractEntry { - readonly type: Type.blob | Type.commit | Type.tag | Type.tree; -} -export interface RefDeltaEntry extends AbstractEntry { - readonly type: Type.refDelta; - readonly ref: string; -} - -export interface OfsDeltaEntry extends AbstractEntry { - readonly type: Type.ofsDelta; - readonly ref: number; -} - -export type Entry = NormalEntry | RefDeltaEntry | OfsDeltaEntry; - -export interface RawObject { - readonly type: string; +export interface GitRawObject { + readonly type: GitObjectType; readonly hash: string; - readonly body: Uint8Array; + readonly body: Buffer; } - -export type Progress = (message: string) => void; diff --git a/packages/packfile/src/unpack.test.ts b/packages/packfile/src/unpack.test.ts deleted file mode 100644 index 94fedda..0000000 --- a/packages/packfile/src/unpack.test.ts +++ /dev/null @@ -1,27 +0,0 @@ -import {createHash} from 'crypto'; -import {readFileSync} from 'fs'; - -import unpack from './unpack'; - -async function* input() { - const pack = readFileSync(__dirname + '/../samples/sample1.pack'); - yield pack; -} -test('unpack sample', async () => { - const entries = []; - for await (const entry of unpack(input())) { - entries.push(entry); - } - - expect({ - hash: entries[2120].hash, - type: entries[2120].type, - }).toEqual({ - hash: 'def0c2614b88c6df95ac49c1e0f5e13494301142', - type: 'blob', - }); - expect(createHash('sha1').update(entries[2120].body).digest('hex')).toBe( - entries[2120].hash, - ); - expect(entries.length).toBe(2651); -}); diff --git a/packages/packfile/src/unpack.ts b/packages/packfile/src/unpack.ts deleted file mode 100644 index 68a7f2b..0000000 --- a/packages/packfile/src/unpack.ts +++ /dev/null @@ -1,16 +0,0 @@ -import {RawObject, Progress} from './types'; - -import parsePackfile from './parse-packfile'; -import normalizeEntries from './normalize-entries'; -import pipe from './pipe'; - -export {RawObject}; - -export default async function* unpack( - chunks: AsyncIterableIterator, - progress?: Progress, -): AsyncIterableIterator { - yield* pipe(chunks) - .pipe((c) => parsePackfile(c, progress)) - .pipe((c) => normalizeEntries(c, progress)); -} From f1eb30c8c5baa9d905859c4f1c9dc3f6d58e56a9 Mon Sep 17 00:00:00 2001 From: Forbes Lindesay Date: Fri, 3 Sep 2021 12:53:02 +0100 Subject: [PATCH 07/10] test: add test fixture for packfile unpacking --- packages/packfile/README.md | 2 +- packages/packfile/samples/sample1.json | 10606 ++++++++++++++++ .../packfile/src/PackfileParserStream.test.ts | 30 +- packages/packfile/src/index.ts | 2 +- 4 files changed, 10625 insertions(+), 15 deletions(-) create mode 100644 packages/packfile/samples/sample1.json diff --git a/packages/packfile/README.md b/packages/packfile/README.md index a4c6249..2db8094 100644 --- a/packages/packfile/README.md +++ b/packages/packfile/README.md @@ -1,3 +1,3 @@ # @rollingversions/git-packfile -Forked from https://github.com/mariusGundersen/es-git +Forked from https://github.com/mariusGundersen/es-git and adapted to use node.js streams. diff --git a/packages/packfile/samples/sample1.json b/packages/packfile/samples/sample1.json new file mode 100644 index 0000000..0461acb --- /dev/null +++ b/packages/packfile/samples/sample1.json @@ -0,0 +1,10606 @@ +[ + { + "type": "commit", + "hash": "d78da0138969a368da74d0dfb9e3c5d88114b152" + }, + { + "type": "commit", + "hash": "fe884753706da90de8288d1f89b017acfb09bb22" + }, + { + "type": "commit", + "hash": "4ca86be0bf3a5e57f53c44491838955d3201a8ff" + }, + { + "type": "commit", + "hash": "9d27d918508d3438177ff0e5813e73654b2b6ca5" + }, + { + "type": "commit", + "hash": "87a8189d16de046e1137fd82d0643e0c51bce41b" + }, + { + "type": "commit", + "hash": "4380bf9b9ade4908753d1f7616d4f6ea54a1eb5d" + }, + { + "type": "commit", + "hash": "aa550bf499ffef816e770c2c9bf708458a6d4b95" + }, + { + "type": "commit", + "hash": "221ca1b2a3059b28f036db9166d2457da2baff49" + }, + { + "type": "commit", + "hash": "c91b8ae5d26d82c0f01a5bd122941e769f8e2961" + }, + { + "type": "commit", + "hash": "126fb88be921a80ee84ff39e98217b4981b017db" + }, + { + "type": "commit", + "hash": "897a6b553da15e306c5c03f5725f4c8d3d40cfa1" + }, + { + "type": "commit", + "hash": "0c92c7823b04d5c951d465c93a83dc35bb26cd95" + }, + { + "type": "commit", + "hash": "85e6629458a2e7f58ed58d842684a6d7d3f4d7cd" + }, + { + "type": "commit", + "hash": "5f97b51d8a6ddc68901a1b4881b70c02b7235b04" + }, + { + "type": "commit", + "hash": "01abd3194eaacb6ea57abee94d169d01e5960a9a" + }, + { + "type": "commit", + "hash": "f9997bf2068e68c2eeaba5e0a933d99b0ade2d23" + }, + { + "type": "commit", + "hash": "d4a1d6db1c059eb4f8f951e3c2835a84ad68427d" + }, + { + "type": "commit", + "hash": "369b41e084ebc900c11f14786b16ec11516e8e40" + }, + { + "type": "commit", + "hash": "9136d27220f83f75ecf324c4b26e4020fc964eb6" + }, + { + "type": "commit", + "hash": "a2a42f32e325011f8828122707821ade28d41cec" + }, + { + "type": "commit", + "hash": "f1740f50eda2d161524f80399f8e1f2a946f005a" + }, + { + "type": "commit", + "hash": "8ccf6713ee65215a17d5d65a7559fd78faf980d4" + }, + { + "type": "commit", + "hash": "016cb40c4328f56adf1af846713132b231ea54c7" + }, + { + "type": "commit", + "hash": "dad064db6c8599baa7a3aa343c6cd98a409811ff" + }, + { + "type": "commit", + "hash": "dabe3683d59f0f92ec77afd0e63a02910c53dfaa" + }, + { + "type": "commit", + "hash": "4a7d5bc52061cb9ceabf13f8a18e369c9c7e7fba" + }, + { + "type": "commit", + "hash": "ab50767ab50c83d2af65be8e6f72baff6ce68d9f" + }, + { + "type": "commit", + "hash": "11ee61b4690037be7fcf8736bafaff147d06db7e" + }, + { + "type": "commit", + "hash": "0127846b3825133b0280d4f246ac88a8c2327a73" + }, + { + "type": "commit", + "hash": "4dcd0c53952a42fddfea73281fbf85b963ddb278" + }, + { + "type": "commit", + "hash": "9c696ae2d1ffdbed22f8bf64745d3d2483f40b3c" + }, + { + "type": "commit", + "hash": "edd0da74722d7b6c019f4e89247cc1623a1fd0af" + }, + { + "type": "commit", + "hash": "4bd600b275e75e81f03c2f432b717104e4a8edfd" + }, + { + "type": "commit", + "hash": "7bab6ab1b4d0c64d5919cbabfc6143e20a74148f" + }, + { + "type": "commit", + "hash": "36120f3911cd99f1f9232dea25957e4befde0a76" + }, + { + "type": "commit", + "hash": "b02c799ba9854dee9d81c63105c1e7ffc4415f43" + }, + { + "type": "commit", + "hash": "1369459488a5b0a565f10be19b7a6fd07d4436b5" + }, + { + "type": "commit", + "hash": "a328333476b05ac9249e897606ad37e6ea914371" + }, + { + "type": "commit", + "hash": "6dd92da330671e0b4209c9fcab6660902d0061f7" + }, + { + "type": "commit", + "hash": "74fa4f76acd8a32a50a8c0092575043dc8f0a8eb" + }, + { + "type": "commit", + "hash": "ad4289c331fae44928279f06bbfaa9e6e87c71a4" + }, + { + "type": "commit", + "hash": "14b5f0de001649b05df4cb93c009cc66afdce3ac" + }, + { + "type": "commit", + "hash": "d824f9dc21f1693768867f2f6e95cdef1b529959" + }, + { + "type": "commit", + "hash": "d6e7ac4177f631fd58df724e61f9a013a23cd156" + }, + { + "type": "commit", + "hash": "bf09a370ae6093da154ac4d8f52999df01d11e3a" + }, + { + "type": "commit", + "hash": "ccca651a65da82a6ac0a8b01e9e2cecb0c76cd91" + }, + { + "type": "commit", + "hash": "a804fd33763bfe115dd6440b5fc2c5396325f4fb" + }, + { + "type": "commit", + "hash": "ce4634873c52dcd1e67b98e6a4f316f67e9b2719" + }, + { + "type": "commit", + "hash": "e1609e1e78fb0dd7bfdd81dbb3af4dee8c98568c" + }, + { + "type": "commit", + "hash": "b5897ce2f71374b5e16ef58a5d12e4ad0ea68e39" + }, + { + "type": "commit", + "hash": "7e6022791f1227f1d5c6317c0e7b24974d855d99" + }, + { + "type": "commit", + "hash": "f8f30def8115dfb8066d12a1ccd8db1297c78a98" + }, + { + "type": "commit", + "hash": "96909a556176abf005b4d7deef992db6326194aa" + }, + { + "type": "commit", + "hash": "3bbaefa6a88e3014c328390456f029e96d207867" + }, + { + "type": "commit", + "hash": "03ea444e55f468d7270e77196701da5350a67c50" + }, + { + "type": "commit", + "hash": "9fea589da0a807cfe1f4238c9ab0a42f4446cf45" + }, + { + "type": "commit", + "hash": "a5879695181270c8493b9be289bdd386e7749061" + }, + { + "type": "commit", + "hash": "55a5929e6fdf93ca89c4941ca0063d331fbab14b" + }, + { + "type": "commit", + "hash": "46b730d3aa20153149cf251f63cb481d4190b9a8" + }, + { + "type": "commit", + "hash": "5b10e38407ee88b340d60cd901f5ca07952b1830" + }, + { + "type": "commit", + "hash": "d6f3a56b04412ea0640b7ee3b084b5f4179bacff" + }, + { + "type": "commit", + "hash": "6d4f1276a28b1917ff74ab626e9732b8c2a615e2" + }, + { + "type": "commit", + "hash": "54a00f000df0f41fffc57072f2fead5e07178744" + }, + { + "type": "commit", + "hash": "a6c737c662d9e1d9804a423e7b01fe74e1572a05" + }, + { + "type": "commit", + "hash": "f04dbe2e537998fc5f47ef67c595c1c9f36b1736" + }, + { + "type": "commit", + "hash": "9e20d3b682b903fc7226d4a7941e4e1e0835bacd" + }, + { + "type": "commit", + "hash": "3fbd45bb0c54cd36ce08f5fde52f6baa61ca369d" + }, + { + "type": "commit", + "hash": "d23679952eba5b2661b4ed34237fa9b033c58801" + }, + { + "type": "commit", + "hash": "4c172fbb1154c7aee3bf3e3edab0188c24a6bf68" + }, + { + "type": "commit", + "hash": "2bc6be3f87656a2cd88708137682b6f30a513f19" + }, + { + "type": "commit", + "hash": "4438ad9750374bfe249ee3548fbe15aab15dd308" + }, + { + "type": "commit", + "hash": "9ae2ecec6e99c7b31218a83065efc6ac3603231e" + }, + { + "type": "commit", + "hash": "aaabdd172197cab81ee81912a744471e896f03ad" + }, + { + "type": "commit", + "hash": "6f322a0a34890b8491309544561ce067cadbb77e" + }, + { + "type": "commit", + "hash": "a55e17d3b8c5b41b9b0e2e30557ee77a7f862c1b" + }, + { + "type": "commit", + "hash": "ff690e8d8c2ab3f3ce9c1cde34503c61bf1986cc" + }, + { + "type": "commit", + "hash": "79e8a5e32576369f322187c03933ecb363b0324e" + }, + { + "type": "commit", + "hash": "081839e189c37fdccf4cb7c7c368577dcf2ba7b4" + }, + { + "type": "commit", + "hash": "b49e1d24dee89c85c23fa09bea6e110279bf48e4" + }, + { + "type": "commit", + "hash": "2eba680bf5e7c9f829c2ec1682a7d9c7b042e021" + }, + { + "type": "commit", + "hash": "af5087ea3c610b4efe1e4bc14aca1555f6c6d4dd" + }, + { + "type": "commit", + "hash": "2904518b6709b6d8b7e68112ac04babb9681ccca" + }, + { + "type": "commit", + "hash": "52e7e9f13811416ade1d5e83a66cf8c8588923cf" + }, + { + "type": "commit", + "hash": "4b7fa6d4f384017f64d47f0aaf68a02fb29fe58c" + }, + { + "type": "commit", + "hash": "5f7bcc742c5c3113112af3ddd9631b1efc9faa39" + }, + { + "type": "commit", + "hash": "56b8f1823562f48b3d492f3ad48b17c7f79bb230" + }, + { + "type": "commit", + "hash": "d3977c324e350dce40956e2eac3fbcbe7725f393" + }, + { + "type": "commit", + "hash": "1703d173d576a220f4bff13e53d7a60dd67dd026" + }, + { + "type": "commit", + "hash": "fecb23dce5ed0ccab18cb95d141e2694dc8b2763" + }, + { + "type": "commit", + "hash": "271c1e0d8a7da9b2ed260fdd91af22b017152779" + }, + { + "type": "commit", + "hash": "362f9f0f22197e4cb26124259655629f27e8ddef" + }, + { + "type": "commit", + "hash": "223c9097d9bb42361973a8fc9b0c4fcfb67a15aa" + }, + { + "type": "commit", + "hash": "26576774e14198cce6ddbc1f13c866b18d3c2f00" + }, + { + "type": "commit", + "hash": "5078b25d994194d82e4b0b39fd2207b843edb7b2" + }, + { + "type": "commit", + "hash": "b39a6b2789b4520d57c931740dcad110958e218f" + }, + { + "type": "commit", + "hash": "95f9ec767b0400265bddcb5f5b3998ddf2fe5582" + }, + { + "type": "commit", + "hash": "baf42162715e2483fa5576a57f803dc805ed5600" + }, + { + "type": "commit", + "hash": "b202d073257fd94eb4f0ed61fc49e3b5f2ea5b95" + }, + { + "type": "commit", + "hash": "df39d1953dbe7b20c708ace3bb53a10c38529147" + }, + { + "type": "commit", + "hash": "edd88959bd487cf00134a52e046667d4a9065ec7" + }, + { + "type": "commit", + "hash": "ff8c15a825b93759a321bc8273b3f97d58ea14d2" + }, + { + "type": "commit", + "hash": "51e0fe1ab7bf2fcc82385e14e5e2eb892190f72a" + }, + { + "type": "commit", + "hash": "fdb5affe795dc380fa0b2ee1ae7c573c34bccb57" + }, + { + "type": "commit", + "hash": "e1e6ce8a1be1008143ab6d0d32f21a74c1609913" + }, + { + "type": "commit", + "hash": "2033762fd471f5e3cd79ffeb6dfa8f0d8978e44d" + }, + { + "type": "commit", + "hash": "4aed01094829e924cd527f2975acc1262617926c" + }, + { + "type": "commit", + "hash": "afa1cbbbbdc2028186d9db7d0993b715df5e7240" + }, + { + "type": "commit", + "hash": "d039dbb764b259d14e58d4683fb00e3bcdb59c35" + }, + { + "type": "commit", + "hash": "23c5ff0e9f315e19831cd22601d9df0a3c1016a1" + }, + { + "type": "commit", + "hash": "d53133d98a7e731a73db039e055f8f3ab1620cdb" + }, + { + "type": "commit", + "hash": "a535d1debc905d9b64f82d44bac84324e8a68395" + }, + { + "type": "commit", + "hash": "f389673b678fba75d607a371d9049a199edf4b09" + }, + { + "type": "commit", + "hash": "a7aa6143125ba03bb81062bd8aa9d722021716b1" + }, + { + "type": "commit", + "hash": "cc73fb28c82a11cc37c2e409403a1e8321398bde" + }, + { + "type": "commit", + "hash": "3b5c9740e536e867bacda2674f7058202a1f7858" + }, + { + "type": "commit", + "hash": "9f609ee75a4998d53325fd367ef0cd809f04900b" + }, + { + "type": "commit", + "hash": "7054f1756e440e9c84adff269138ece2af6d1b83" + }, + { + "type": "commit", + "hash": "8b3ab90add47814fc884ff4e685b50ff67dfbe2a" + }, + { + "type": "commit", + "hash": "3035d3d019083e0eef6b898cd7cb05484b63ff8a" + }, + { + "type": "commit", + "hash": "cf99fa58f66d7b5d3448d7ff13cbc5b77e34d475" + }, + { + "type": "commit", + "hash": "4529d6127120dd75559a2d5987aa29b53a43b2de" + }, + { + "type": "commit", + "hash": "831f8b41d658a6f7d781101f27bf494c74ec36d5" + }, + { + "type": "commit", + "hash": "8d879a826c451780e61cced91c75864e8ba4b57b" + }, + { + "type": "commit", + "hash": "77f1a82466c23dced0d0a68ccb97213a7edf4092" + }, + { + "type": "commit", + "hash": "7bf8da57b8e56d51ea7fd21faf986f0111bbc1b9" + }, + { + "type": "commit", + "hash": "73a6c740616c6779fe4d1f7db69129b08fc17738" + }, + { + "type": "commit", + "hash": "1ca7d165f6fa8d3e3e6b127b3de10d732cab1625" + }, + { + "type": "commit", + "hash": "7202028db7817e84eac47496b54423e4b2b4f18c" + }, + { + "type": "commit", + "hash": "e0b7c837d5eadb9bcb17847d6faf203215ac8650" + }, + { + "type": "commit", + "hash": "e7ccaf07cbf6182b6d70d61e41e22a8a151e5a7a" + }, + { + "type": "commit", + "hash": "1a39b597faffdf0f74903908e918f4688079024f" + }, + { + "type": "commit", + "hash": "d7adaad4e6f48f14bcd409a725959c512a9be85d" + }, + { + "type": "commit", + "hash": "2e1bf388e7c1dd9037c57a6f74a2b2e1ab5e8004" + }, + { + "type": "commit", + "hash": "f43c2292e67c0a2192383ffb3778b1cdefcd35f2" + }, + { + "type": "commit", + "hash": "b36daa23a6a5e956aabc5b28a180acc329bbb301" + }, + { + "type": "commit", + "hash": "bccd2f9cfa057afba5140366b6e59bf9f4be21a2" + }, + { + "type": "commit", + "hash": "c53aae36700766d300f3c941626e845e8e211700" + }, + { + "type": "commit", + "hash": "432ea67ceffe0a0e798eef4d76e6891778307a43" + }, + { + "type": "commit", + "hash": "c851c3ce127a43d92bdaf66f729100396011534b" + }, + { + "type": "commit", + "hash": "1c5e7d75fe2279e1d8e93b93b0e81b35454677f0" + }, + { + "type": "commit", + "hash": "1623a373cf2dc0111e7bcd43abe40f5cb80b7d17" + }, + { + "type": "commit", + "hash": "7ff50f2c75b5cb183937ae609f900808470e12b7" + }, + { + "type": "commit", + "hash": "455011c8ab7dd7857baea026624042af9400c551" + }, + { + "type": "commit", + "hash": "2a2e109d9c3b3abd5fe77b14d5abf994c547dcf8" + }, + { + "type": "commit", + "hash": "393259678b2a1be4ef1c6960bf1b6f4de13b1f8b" + }, + { + "type": "commit", + "hash": "43f85c04e0491251ae48af9a09565e68c008d1a5" + }, + { + "type": "commit", + "hash": "d4432f7f0bc70fa182c6cfc866a854026a8f5eb4" + }, + { + "type": "commit", + "hash": "ed2a24005b39c46895a90e23e8e70a8a7644b71b" + }, + { + "type": "commit", + "hash": "7d234279bf21c36a5ef33b3511edfe8f67988f54" + }, + { + "type": "commit", + "hash": "7b5157f5b40584c29a98ac80bd0e30333ae1b1c7" + }, + { + "type": "commit", + "hash": "a598117bbf0ca9dbc48b8f8f4a43dfb75497d2dd" + }, + { + "type": "commit", + "hash": "186ffc434d411483e12b0c04c4437f6343c52ca4" + }, + { + "type": "commit", + "hash": "a933ab132101b2a6bba7e171105bfba25063f6b8" + }, + { + "type": "commit", + "hash": "4adae5aab54afac31e161e7a790d443597ab02c6" + }, + { + "type": "commit", + "hash": "c09dd9817e146a8167d9e15b0339425ebe7d5cab" + }, + { + "type": "commit", + "hash": "afe2bc3c8fa9a9dfc987a6d4f6ce7f2b73fff069" + }, + { + "type": "commit", + "hash": "8e1ccc4837b81f8758de01082e53752c26ba2a7a" + }, + { + "type": "commit", + "hash": "112104987aa22f6b374a953ceddae21ad5a6a708" + }, + { + "type": "commit", + "hash": "558ccb05520dbf699995a667d91c37bcad2899b0" + }, + { + "type": "commit", + "hash": "e12c2b676012d748beb671a2864084f89b908ed3" + }, + { + "type": "commit", + "hash": "d0eca8e3a09f74e35e401f2e036b2068caaedc0b" + }, + { + "type": "commit", + "hash": "a9fcb98615c161945862121a97058ecb022c7484" + }, + { + "type": "commit", + "hash": "5ca7e010c4002030d82fe8504ee2082dc8b38fb5" + }, + { + "type": "commit", + "hash": "8e639bf01a069af1a09deef1a29955dca9ed6102" + }, + { + "type": "commit", + "hash": "65965fd0e46ab5e7cff1a36becc5a06a1822f359" + }, + { + "type": "commit", + "hash": "c3a3cdb488089ef187e17c70ae77e6678ef01ce6" + }, + { + "type": "commit", + "hash": "1777dd9701ff094f7079102ad6f9e52e97e239d6" + }, + { + "type": "commit", + "hash": "41cfc1f97bd56c4e26a8abf7d3e182eaeb65d26f" + }, + { + "type": "commit", + "hash": "fa8e98be3aeb99466e62dcdf315a74e44d4a1e83" + }, + { + "type": "commit", + "hash": "fcf5107fde6c597606330eb719b4e31465910f62" + }, + { + "type": "commit", + "hash": "e0566a174ed2ef1075ad2ada55eb6922c6a675de" + }, + { + "type": "commit", + "hash": "51f3bd62c71fee75fbd536a47edd20c2b7e6e28d" + }, + { + "type": "commit", + "hash": "53d9f786568eb306fee6b063f083fffbf73c5dcc" + }, + { + "type": "commit", + "hash": "27c2c2f8d258f9e33e5e9dffe3a55b2acebe974d" + }, + { + "type": "commit", + "hash": "3679561e661a9a943b54e6e89f687b3c2e2365ca" + }, + { + "type": "commit", + "hash": "a040674486a5d41f282aee5b272c34224d239f90" + }, + { + "type": "commit", + "hash": "7bdc95dcc25642979485d248db5b9c9ba929940a" + }, + { + "type": "commit", + "hash": "2df2ba72f94915d6f273faa29c47f78602beafed" + }, + { + "type": "commit", + "hash": "ddb80c2679a8285286be505a95dc46a1e01adb5b" + }, + { + "type": "commit", + "hash": "0f8d48854e628f791936e973f4d9f80f1f1a7669" + }, + { + "type": "commit", + "hash": "3f14ff00628b535a2568bebd4775132fd6a7d1af" + }, + { + "type": "commit", + "hash": "57466ff66d2f842f9c6791bf218da61908407d02" + }, + { + "type": "commit", + "hash": "69b5d7a2ab1904c66415692cfe41913ed9b95021" + }, + { + "type": "commit", + "hash": "2fe9360dc5930bd772751c42ab74f856243cba59" + }, + { + "type": "commit", + "hash": "191acfbc83574a9b26e2250a60c402a7682e66e9" + }, + { + "type": "commit", + "hash": "2b386f4d9340c01e43ab931d77c6dcb41c73d14a" + }, + { + "type": "commit", + "hash": "87cf936b6a106d668eff0568da5c70bce0ae854d" + }, + { + "type": "commit", + "hash": "4709775dfd4d350d0fc2c1f1a606310367f94ae8" + }, + { + "type": "commit", + "hash": "e0947d61f70bd4cf354e74edb027ae783c5891fb" + }, + { + "type": "commit", + "hash": "43503204e246c52fe8fab686386e0e67f94f10e8" + }, + { + "type": "commit", + "hash": "ae5b8f244fb5245fc3670a65ebb542130de5d9af" + }, + { + "type": "commit", + "hash": "06a1500a9f2b917e7e553cd66d2b37448946d410" + }, + { + "type": "commit", + "hash": "5e87db001a45b8db45eba2f9c83d5a47882f1940" + }, + { + "type": "commit", + "hash": "322577cc35c6040576e7ccf1819a4cc2eadb16d2" + }, + { + "type": "commit", + "hash": "30a3468c1c4710ff65038a16efafcd76ee909ecd" + }, + { + "type": "commit", + "hash": "70f65fe216ff845b30226a88e660b0da530ebb39" + }, + { + "type": "commit", + "hash": "31e314371aae333034dd11e50886ff4aea202438" + }, + { + "type": "commit", + "hash": "a34f7c9a36db37c76ef824ef248b8d8bb29ed4ca" + }, + { + "type": "commit", + "hash": "4f06a7e31f2ebc6fb4abfc6255290c6883916fe0" + }, + { + "type": "commit", + "hash": "ff93dbe00d4dfeed5b601a16b81f0ce3a8d00715" + }, + { + "type": "commit", + "hash": "16be80836b41d3e191a861033056a9c06d4b9d24" + }, + { + "type": "commit", + "hash": "dbbedd59d1d026ad84cc0d068279e14a31ef15b0" + }, + { + "type": "commit", + "hash": "a23195a805ffa79fca66739d0f6495ecfd07f46e" + }, + { + "type": "commit", + "hash": "e7536012fd314530c204d0cd7b2393ec8b8072f3" + }, + { + "type": "commit", + "hash": "55f1ce631a32a83ac936934273716033dbc7240f" + }, + { + "type": "commit", + "hash": "e6207a8d9569c8e4669689b2f6d8066233e0e60b" + }, + { + "type": "commit", + "hash": "84b8d9e88907519701f179c4bfa5ed7b4b9fe6ee" + }, + { + "type": "commit", + "hash": "c1fc85696748fe5da18fc428356cffe6db2b3459" + }, + { + "type": "commit", + "hash": "167e15d6fdf3d85ded1b655dcc5cc6e265cd2111" + }, + { + "type": "commit", + "hash": "553a79d8e02514edea88fda77497216b3d89722d" + }, + { + "type": "commit", + "hash": "8afa18bc42836883e50343ff2b1b008f3e27999b" + }, + { + "type": "commit", + "hash": "2933d37f6fedc05e78d7f0a6f0bd24dbbe3fb635" + }, + { + "type": "commit", + "hash": "da4e60620392220557a5922e4608ee70c4f72645" + }, + { + "type": "commit", + "hash": "509ba5f5a99bb478393fb9c9058fc270a53b107b" + }, + { + "type": "commit", + "hash": "843c9839c7693d0d805e902111583a08a71be95c" + }, + { + "type": "commit", + "hash": "c10d628443a5f3d37fcd47d30b03d77a38a2ea8c" + }, + { + "type": "commit", + "hash": "bfb2575225701d7d32d30b3243bee942a49a1370" + }, + { + "type": "commit", + "hash": "df273f9107df5b64b2ea86f87f3bd0e5737800bd" + }, + { + "type": "commit", + "hash": "58d87b978e9a2463c9c27fb0ca4280ff56077ccd" + }, + { + "type": "commit", + "hash": "0467cf213820f4d916fc1f30acdc3da7a03a5c46" + }, + { + "type": "commit", + "hash": "dc7bba72b89f9f54fe27404a698b6c51545e755c" + }, + { + "type": "commit", + "hash": "e32bfa58d9c905fb5b73d3d32c8bd3b8c894dc46" + }, + { + "type": "commit", + "hash": "e4bcb2b188befbd14f470ce719bf26ef4aff87e2" + }, + { + "type": "commit", + "hash": "379508704a7c4bd9b8e8178003b1b7e30ba1c5b5" + }, + { + "type": "commit", + "hash": "4234eb45eefcb149d0037f66d728f3e10829a44b" + }, + { + "type": "commit", + "hash": "ba6f5a7a963cd24dd685b0306a7c7e2bccaea898" + }, + { + "type": "commit", + "hash": "fbf4502912c684ea78397a5af48814a28f9792f7" + }, + { + "type": "commit", + "hash": "39c6b08c60374747ed52bf42927180fa7c3b0bbc" + }, + { + "type": "commit", + "hash": "97d5d0b5d444f39d043b5d2ffbd363aeb5d7da69" + }, + { + "type": "commit", + "hash": "079204f5dfb6a562341ae026853811c8440b539a" + }, + { + "type": "commit", + "hash": "24294a7f8d650bd8b2fd300df80961fd7e198ebd" + }, + { + "type": "commit", + "hash": "bb18d064bf79320c5719a648fd0f749b82d9ee9f" + }, + { + "type": "commit", + "hash": "e189598631ac995adb4a4e6be5cafa0e8520e5b6" + }, + { + "type": "commit", + "hash": "4852e2fe58be221c1bbf361b7159ed3257955f77" + }, + { + "type": "commit", + "hash": "437c2b6d58fb0b502bdc5d7dd1aeaf164dfcfa87" + }, + { + "type": "commit", + "hash": "d8d21a191fd9f52e516f8c969e78430729057c5b" + }, + { + "type": "commit", + "hash": "38dc5d2477dd66c78bf6b1854291cdc7aed78cb9" + }, + { + "type": "commit", + "hash": "c367dee7abfd655208ad495877acfb05f83bebbe" + }, + { + "type": "commit", + "hash": "2fec9f5eb69b0d17cdb400110767979067d7b95d" + }, + { + "type": "commit", + "hash": "a20ab9878d054044b46f657538e9ab674f9bf9dc" + }, + { + "type": "commit", + "hash": "1cba31efb0c21b1b63ecbf72efc95b17b26abe46" + }, + { + "type": "commit", + "hash": "b65c7a38f18b695e5470d6da9bf8f89bb6c6da95" + }, + { + "type": "commit", + "hash": "22d221629c4980ac58f39eaf0dd8f66f6715e99b" + }, + { + "type": "commit", + "hash": "44f9deff485f83b9042dd02239a3665415a9d6e2" + }, + { + "type": "commit", + "hash": "15dcb3e7ab014ccd2525d3d8aaaa660cb381f13a" + }, + { + "type": "commit", + "hash": "f5486d2d162a06eaaff9dba8f2b4d9d9f2400092" + }, + { + "type": "commit", + "hash": "d32d42fd38f8dc01333d512a0a73d2ddd9c23ae0" + }, + { + "type": "commit", + "hash": "e09db6fd0327ed1115cc5f79446dd7d154dba665" + }, + { + "type": "commit", + "hash": "7857e79c9f011a6f302e4ff23d3103f376fd4fe9" + }, + { + "type": "commit", + "hash": "659438e9fd166caeed6172b64b20342165521508" + }, + { + "type": "commit", + "hash": "82cb322667fef07c7947010b372cc8dc243a673f" + }, + { + "type": "commit", + "hash": "8c5ad9fb00b78daa54c7b2c50fdb3f56bd1114b2" + }, + { + "type": "commit", + "hash": "bca95dfb4f446d42c336251bfeaa8f8df58888df" + }, + { + "type": "commit", + "hash": "e084c8844d76b44ce1e070a9200ad7e4b8fa68e0" + }, + { + "type": "commit", + "hash": "da41db061f334c1492ffb5b79f4e2f7e0270c333" + }, + { + "type": "commit", + "hash": "3b63f68eaf3a5e63e2c99f30bc2e2842d00bfbb2" + }, + { + "type": "commit", + "hash": "c1ef9cdf801fcbc47133b2aa73a1da1aed4231dc" + }, + { + "type": "commit", + "hash": "3727be7cf963f93e9eca784c6e33bde3822b7489" + }, + { + "type": "commit", + "hash": "e4b2a4cf13abea3742b087e35d2e9fc93e3dd8c8" + }, + { + "type": "commit", + "hash": "f338f29781d216279d9816bc1974a6ecf8e8cf55" + }, + { + "type": "commit", + "hash": "9d44902c03beecbb05bfb83fe9451d6c0a69d13c" + }, + { + "type": "commit", + "hash": "db477a765427f13e16b4185dd66750126f2a0dcd" + }, + { + "type": "commit", + "hash": "47c3ba68cafa73a4f7dc9f4342053029e22338a5" + }, + { + "type": "commit", + "hash": "a2f8e53bce772ef84783017f4a8756b001be5592" + }, + { + "type": "commit", + "hash": "dafd1c97d898689e73cd5894d791dc4a13ae4fc5" + }, + { + "type": "commit", + "hash": "aa48477120d904f840db8932d34be64a0b356b1a" + }, + { + "type": "commit", + "hash": "3df0854d1c792bf2ee4a239991538ea0cbe45a10" + }, + { + "type": "commit", + "hash": "7d531389b62f76e6971a9bf246407a7f60c80580" + }, + { + "type": "commit", + "hash": "baa71b2b756ebe5232e651fd3578854e6a346cf9" + }, + { + "type": "commit", + "hash": "b5fd73120a22159b86fd31e755658f04cbe9b26c" + }, + { + "type": "commit", + "hash": "2ccef3dc88d1d1105a4b53268208076ed16fb9f1" + }, + { + "type": "commit", + "hash": "1fa5c3824d92a5f9e51f71a90a00c7245e077d8b" + }, + { + "type": "commit", + "hash": "db3b01666224d3d5b303275ff4e1c7c3099e2d9d" + }, + { + "type": "commit", + "hash": "5f87423a50623f5f7d1a81916e4414d607c270d3" + }, + { + "type": "commit", + "hash": "7ebc1ffc8dbf7d3e85f5eb3e4e3f82acd13760c6" + }, + { + "type": "commit", + "hash": "0e76e6214dbba347a4f24497261a1bd71aac8347" + }, + { + "type": "commit", + "hash": "a161221838ab74e16f2af1059ae820d12525fdf7" + }, + { + "type": "commit", + "hash": "97eac097da4183f756ff5152e362358830904e27" + }, + { + "type": "commit", + "hash": "0d0a51d733f51385c0632f52705377f95ff2d542" + }, + { + "type": "commit", + "hash": "34f7b8654c9f095bfaa1534f2b81f2ab48100d7a" + }, + { + "type": "commit", + "hash": "5de0701019381445bd33c8ab8ed0a952f7935816" + }, + { + "type": "commit", + "hash": "b606b2ec3d152a5fecb002eca9c5646ab72da360" + }, + { + "type": "commit", + "hash": "8ec72a3152eec7bca8e3546a05710483b67163f1" + }, + { + "type": "commit", + "hash": "bf8e27a90045e37cbb88063fee6c4dca70ad87d5" + }, + { + "type": "commit", + "hash": "712d8acac54aacef42c776a3058ec5ad7e888bab" + }, + { + "type": "commit", + "hash": "2552222c169f78bd96dd27f3086ea118c09f1438" + }, + { + "type": "commit", + "hash": "9d5936213bbc1cd3bf17abc2041a200b1e33f76e" + }, + { + "type": "commit", + "hash": "2860d0ad4f9db629e6196c7c0674192d2989cbe9" + }, + { + "type": "commit", + "hash": "6dc405e35cf7b64bc153bb5ee315fb351b627d6f" + }, + { + "type": "commit", + "hash": "27491ee84fc7bc58893e628b758df97e7917d296" + }, + { + "type": "commit", + "hash": "ebd0ddd4bc27b9ccc42759358487945ac0c9a90e" + }, + { + "type": "commit", + "hash": "0c04a552745e449f4ea53830b6eea87d0d14f804" + }, + { + "type": "commit", + "hash": "0e71422d75434ff96a858b4d37164417db45acdd" + }, + { + "type": "commit", + "hash": "b2e9ba6aef77837ec6defea8ee754437c1002a97" + }, + { + "type": "commit", + "hash": "90386c451e1231779152623e20550f78eefd5636" + }, + { + "type": "commit", + "hash": "b19cc215ea096bfaeb07f3d6fdfe8fd9114d13b3" + }, + { + "type": "commit", + "hash": "87d88cc49b7b4a0c573c0acb261b61f50b7c7094" + }, + { + "type": "commit", + "hash": "14bc1ea3a7aed1bac09c5af9ce254018cbdcfafa" + }, + { + "type": "commit", + "hash": "368bceea7a8cd96cbde483e104adcaa45a74314b" + }, + { + "type": "commit", + "hash": "de16e76c5e7e05a430e669d8085e43285d221b9d" + }, + { + "type": "commit", + "hash": "e004c5c641f60db5e87e5eb88e8d9780fc4f53dd" + }, + { + "type": "commit", + "hash": "8149d392877ea0bb5a48546a5564d590b590d520" + }, + { + "type": "commit", + "hash": "56355963e2bddaf39dde855c42396c66b211a513" + }, + { + "type": "commit", + "hash": "8e4113f664493cc87fa3c3eda57e0b7e0b8c92eb" + }, + { + "type": "commit", + "hash": "9f80da18bebf44e1b829966d9040f1414faf8e9d" + }, + { + "type": "commit", + "hash": "ad896805440b85e88c3f23a965066264938808ed" + }, + { + "type": "commit", + "hash": "8520fd72e5bef30052a327d29466996d29a9d701" + }, + { + "type": "commit", + "hash": "da81d1156ead189cb5f10e655988bd40a0f7bdf4" + }, + { + "type": "commit", + "hash": "dcad8fff8160a93717edcdf56019c62ddc48fc2c" + }, + { + "type": "commit", + "hash": "b78907c0b72e5e501ce89017911b1879464cd4ae" + }, + { + "type": "commit", + "hash": "c3fe5b62c226f726cbb8a2345a69c7d78faaeb37" + }, + { + "type": "commit", + "hash": "d9c04323272568da750c3bf548dff99fb4218717" + }, + { + "type": "commit", + "hash": "64a8e842075a398f9a9e57ccae6b2c2ff57220dd" + }, + { + "type": "commit", + "hash": "60478cc8107510f56a30c69ea09190ad715d1d66" + }, + { + "type": "commit", + "hash": "e0ef5e31e2cfce7f9e59bb5ba3234b9d7132a7c4" + }, + { + "type": "commit", + "hash": "7c9b204411219099d27844cbfa0706d4e685cc4f" + }, + { + "type": "commit", + "hash": "2fe0094efa30ae31be999b5d44079af012e7c8df" + }, + { + "type": "commit", + "hash": "a3025aa5db0d2167da946d9565a610b10f196620" + }, + { + "type": "commit", + "hash": "528ce0d714f9eddb16e23eafb93fd16820de288e" + }, + { + "type": "commit", + "hash": "e6e08587d666fa04f08d82c971fc722b2c8280f5" + }, + { + "type": "commit", + "hash": "18632ad55dd884a188ad00cd745ed5f188bbd367" + }, + { + "type": "commit", + "hash": "87ca13a77fb40de9f595ee98d6573a3cfb306de5" + }, + { + "type": "commit", + "hash": "0575f17e7462df5ad0d24580182c1e4e950c7b36" + }, + { + "type": "commit", + "hash": "1872da0d5a64c64e7be0b6fddacf0cbb80e76d94" + }, + { + "type": "commit", + "hash": "9918ac4e094321dd70e17c8ecc2d2c9ffe6c55d2" + }, + { + "type": "commit", + "hash": "4a17676f102352452b4e84fdcc737b342fced169" + }, + { + "type": "commit", + "hash": "47e8a733c46e54ab6c6bf7b8b0280d4fcf57e7c7" + }, + { + "type": "commit", + "hash": "54881edcd9fb1a4df42376c488c79a44c7323916" + }, + { + "type": "commit", + "hash": "00b446dbeb854ecec46295cbbc92994ff7e87305" + }, + { + "type": "commit", + "hash": "14b258abfc2ac2988002afa60d44d6c60546bd99" + }, + { + "type": "commit", + "hash": "b5456edd2ba4ff522fe5efa5fa4863d758dc0dbb" + }, + { + "type": "commit", + "hash": "a61ad52468e9efcc335502e5a3bb0446ec43016f" + }, + { + "type": "commit", + "hash": "f3cd08d17ef7e068d3ce6b852955bdcc9b25e410" + }, + { + "type": "commit", + "hash": "bbe4beeb6f34b477ef5ffd6e3af7963093251fa0" + }, + { + "type": "commit", + "hash": "5d45a54d2f2b0bc6fecc1c771b55913e65021c33" + }, + { + "type": "commit", + "hash": "8f8de83036c5e9f0931460357286fd0abc2c9644" + }, + { + "type": "commit", + "hash": "e01229a1bd654109fc055a8be751c46c2d3930cb" + }, + { + "type": "commit", + "hash": "5343cf471a47f8a0bdfa312ea47cb4ee0959d49d" + }, + { + "type": "commit", + "hash": "2baa4f9f821ac2a2af4e3e9c82fc3f30e08b0aea" + }, + { + "type": "commit", + "hash": "6428985d29563ce61bf65f290080f713e149f26d" + }, + { + "type": "commit", + "hash": "4dbeb69883264c2b87ba84adb67fa048397b3600" + }, + { + "type": "commit", + "hash": "3c4e5f2da0870692227febbc6ca1473d9a42c98d" + }, + { + "type": "commit", + "hash": "dd63c427173810677705a1c1abca3e39bd4338e9" + }, + { + "type": "commit", + "hash": "516eb968017fef44e0129479c6041b6658254dfc" + }, + { + "type": "commit", + "hash": "0c35e645a49f8e5e3f0cc6b5b65875d6d9d3f2e4" + }, + { + "type": "commit", + "hash": "7f610289d27bc5af598aea01001b7943d273ee4e" + }, + { + "type": "commit", + "hash": "1d147cee654deb3238d7bbd6336ac22189e415a8" + }, + { + "type": "commit", + "hash": "068f9e101eba4cb0a3e037c871fca4eccc67697f" + }, + { + "type": "commit", + "hash": "4ac8e01f2266b033dd1e4a483fdcff4e894891b1" + }, + { + "type": "commit", + "hash": "5c096430be0ef0649e9259ec9ce5ac490b5f92b3" + }, + { + "type": "commit", + "hash": "4a38a59cd826b8b094ad48df74d0677d1f5f1ff4" + }, + { + "type": "commit", + "hash": "30430638dbf9ce41d61c68e95a781744a3bb80e8" + }, + { + "type": "commit", + "hash": "ea7a9c14864975aa1620622e5d4f24945496e055" + }, + { + "type": "commit", + "hash": "f7ac64a9707c68d32791073409dde8a867cb0df6" + }, + { + "type": "commit", + "hash": "11934b86a475fc54a60c9a1cec47f9052bca8013" + }, + { + "type": "commit", + "hash": "8382c7aeff7fedc05d01c21b04f35c2066b41f77" + }, + { + "type": "commit", + "hash": "d60097a45887058933226685f565fc48c5c16ea5" + }, + { + "type": "commit", + "hash": "e89a9658e9922dd377cef779d5f48967bf2fa794" + }, + { + "type": "commit", + "hash": "556b62996681b7c6ce817c2ab5cc4542a99ff2f0" + }, + { + "type": "commit", + "hash": "b5fd3c9da0e9d0da11adf151547cb0d3296cad35" + }, + { + "type": "commit", + "hash": "48f9cf93deb6f6629ab026d205376045dec0db5b" + }, + { + "type": "commit", + "hash": "60a62f26ffa72a6a0393c80ce5822c7958a38589" + }, + { + "type": "commit", + "hash": "011cec287beb08685e5b2d9f5528daa67b49e412" + }, + { + "type": "commit", + "hash": "04fd7da1675d92e3cdb677d673d82db87de7f786" + }, + { + "type": "commit", + "hash": "7ff8cc3d7cfa8e308648d1524113005e291a1653" + }, + { + "type": "commit", + "hash": "0386c1ba93e9ad57fd4eed7ad187b055f74d3843" + }, + { + "type": "commit", + "hash": "6423411c9ff42fd914f264fea4d4578fa3e8573a" + }, + { + "type": "commit", + "hash": "6d7d5cb487a08b2dcffa9cdacf642fdd8afca574" + }, + { + "type": "commit", + "hash": "a21e812e12c58f128220b84f9c079c069d96c40d" + }, + { + "type": "commit", + "hash": "8ed0c4538bb3da8279da2752a49813a4f64b7ad8" + }, + { + "type": "commit", + "hash": "e996983bd7316cea3473cdd01c80fc39d9531536" + }, + { + "type": "commit", + "hash": "d5b7824a9c6d20ddabf2d0be0eb66e15a3a2a6bb" + }, + { + "type": "commit", + "hash": "b875c8b53a51b8880877d89f1bfbde1c383279aa" + }, + { + "type": "commit", + "hash": "acad295664b4ca8a85ca6778528686da5974bfa5" + }, + { + "type": "commit", + "hash": "55f026ff21f29adf226004d509362322256911f4" + }, + { + "type": "commit", + "hash": "f04b8e0902bd271e2f2f4bdc525f6fdce1a400ba" + }, + { + "type": "commit", + "hash": "3145bfad6d13ee3fd9599bee753b6331362fda92" + }, + { + "type": "commit", + "hash": "88c7c19cfa81fb8aec796f049dd44e5be8e13294" + }, + { + "type": "commit", + "hash": "9408c38d2cb1129e2a916517a8c9d13c56d314ef" + }, + { + "type": "commit", + "hash": "d3e5ea8d2615fea04d7b753a1d3ab57044e1fd73" + }, + { + "type": "commit", + "hash": "d580014d05a657e424affe311eed20d429ee7de3" + }, + { + "type": "commit", + "hash": "9cae8da5d0ca90e3f9598fc697fd0e6267152f1d" + }, + { + "type": "commit", + "hash": "f15a92ba0bdd3464edf86d1f17d9a31d33f37f78" + }, + { + "type": "commit", + "hash": "ad22d7af4062e6c109a1e2edbad9faf17abf1d0e" + }, + { + "type": "commit", + "hash": "a61c691ac4036ec698b1894b7c3ad54a665e79ee" + }, + { + "type": "commit", + "hash": "1050fc80e82e0116ba2c67aaf997f6de48dd38ab" + }, + { + "type": "commit", + "hash": "780c38e9a53f1f7bdf76c1dd1f2c4ba1f9d851cd" + }, + { + "type": "commit", + "hash": "cc7dafd92aa958904b0020ca49809b637597e67a" + }, + { + "type": "commit", + "hash": "aacb8d882cd78d9f496d07ca3db91fab53154201" + }, + { + "type": "commit", + "hash": "fd2f9bfb5966a7c9946ee8e0a53fa49b03cdbcf8" + }, + { + "type": "commit", + "hash": "700cdf43060da3e8d237d593b8de2840dd0b73ed" + }, + { + "type": "commit", + "hash": "ff750adb35a13c6b58b50f524121e80d1e20149a" + }, + { + "type": "commit", + "hash": "a2f01a9d6472d8dcf831229861c15e3d72398367" + }, + { + "type": "commit", + "hash": "578a041993264d8a6074557a8621ad1ca8a438bb" + }, + { + "type": "commit", + "hash": "90f8133af6d04d67d6c646ad73c7c98277100070" + }, + { + "type": "commit", + "hash": "8186eb8bd10319949a9d626620c6b99b60e3e0ec" + }, + { + "type": "commit", + "hash": "4d71f30364611c66c84b556ffcd6216ee4cf3328" + }, + { + "type": "commit", + "hash": "fcd6879bec53f79ab43c67df5d6d7e94e1e346e0" + }, + { + "type": "commit", + "hash": "ca7843cf56c91d495c66623dd05338c7d06f62cb" + }, + { + "type": "commit", + "hash": "925cd7daa7f73217db4127bf0a2c7e352b6b8ff2" + }, + { + "type": "commit", + "hash": "d1fc8d75d685025261b0b5ef9faf966f19912625" + }, + { + "type": "commit", + "hash": "1de264e7334ec5cf870185d9b3fd27abe65dfee2" + }, + { + "type": "commit", + "hash": "05c190c0be4a64e9650bfd211642c3fac3f2f545" + }, + { + "type": "commit", + "hash": "9552fe62c3aacd7c5d40d55c32e01965179d0588" + }, + { + "type": "commit", + "hash": "98ae95c46b7c3bb70eb4c0f859466576bf42ea64" + }, + { + "type": "commit", + "hash": "caa5f102c7cc5f9177b51ccb395e9afc88d0ad64" + }, + { + "type": "commit", + "hash": "21012d2ba7877d10f759a0afdd136e269a8497bf" + }, + { + "type": "commit", + "hash": "7feb04b428c119fb5dfe0c5b2e3f073cdea1c3d9" + }, + { + "type": "commit", + "hash": "ad7364e05ac0156f37c4c02c3a219b5c07c68c1a" + }, + { + "type": "commit", + "hash": "346a7cbd42b0818c30ae01bf9fb5b51cc9ddd34d" + }, + { + "type": "commit", + "hash": "de4970301e3934ca1df07083cd82ac401e1929a5" + }, + { + "type": "commit", + "hash": "3db99394cfca3a03f6fc4e36be97be1ea05a6cc6" + }, + { + "type": "commit", + "hash": "c26f988f39faa7517d30264b95c33d3ded54939e" + }, + { + "type": "commit", + "hash": "a62cdb747900b48ea8f9d5650cf2c794eaccbf68" + }, + { + "type": "commit", + "hash": "2e2fda87a1c8062c56ae6a76f45d69388e45e32a" + }, + { + "type": "commit", + "hash": "95df3b8d82ac5df01df168c875c6f42784e04332" + }, + { + "type": "commit", + "hash": "1bc51db511e44f34bc9ef8ea49cfcac06605a7e0" + }, + { + "type": "commit", + "hash": "f49d1b0e596cdc2b20286767d3c04feec5cf6712" + }, + { + "type": "commit", + "hash": "308ea5b8cb243eb381c468aa710f101ad4bc7e5f" + }, + { + "type": "commit", + "hash": "63b677253b45375050c06c72428b34aef179c716" + }, + { + "type": "commit", + "hash": "5ac35adf66fbbfd10d8016ddd8135852f6e46645" + }, + { + "type": "commit", + "hash": "6e15f023c31335cf06ac4bdee3e2fa5f58b28dd9" + }, + { + "type": "commit", + "hash": "4c70b3ee1ac2e0c61f7ea81ad890b90402dc99a1" + }, + { + "type": "commit", + "hash": "0f37b506099530aab750cfa92294a425a1695d03" + }, + { + "type": "commit", + "hash": "b653d79d98e1d1cf8809a93e04f6fc09f289214d" + }, + { + "type": "commit", + "hash": "eb742de62df99b1011bb430373ee26f2708d1c40" + }, + { + "type": "commit", + "hash": "cd07cfbf99d5d3b7d3768dffccaebd9f7c6e72ac" + }, + { + "type": "commit", + "hash": "f0d1e3eacd5491ebcc236ef93dcb34ce8c634ccc" + }, + { + "type": "commit", + "hash": "c02c22fd76a0a916fac6181c47f56b34bbf8d9a7" + }, + { + "type": "commit", + "hash": "90efe85b7a09896442874f9f7fe1cf4ec54f1a24" + }, + { + "type": "commit", + "hash": "5b6685cca7cde16ee4591aa29da8b1a1d7d2a6f3" + }, + { + "type": "commit", + "hash": "8350796027b55b573405b20a4bf76936c916e1e4" + }, + { + "type": "commit", + "hash": "898eec9b9c5b721640827ff65b15377a0802190c" + }, + { + "type": "commit", + "hash": "7f49c8105925f0c046d0b54bc50ebb6d2a2685a6" + }, + { + "type": "commit", + "hash": "d42cdb0440cd33582272d4a46f23bfa31f410610" + }, + { + "type": "commit", + "hash": "f189d1ecf0c13525e754d70b572d4f256abb2120" + }, + { + "type": "commit", + "hash": "34fcf308924f4fc6ef781c4335ef17f22d985921" + }, + { + "type": "commit", + "hash": "ec28a19d3882ea8584d0309018386b7fab7e3885" + }, + { + "type": "commit", + "hash": "28147dc19a426f2bc299b296995c902d238c43a9" + }, + { + "type": "commit", + "hash": "903d28f96b73dac8f797c0969fa59cd69bbc1dc0" + }, + { + "type": "commit", + "hash": "0bfed2bdab1ba931aaca7d23b0d08a180a1c05a3" + }, + { + "type": "commit", + "hash": "00888e24af242c695dd36c348a423ba68720dc09" + }, + { + "type": "commit", + "hash": "82de17c00edab57e9e12b1d5d3c76c0b87de9fed" + }, + { + "type": "commit", + "hash": "8c4faaa1db64ba9e545d46a8619e95edb028580a" + }, + { + "type": "commit", + "hash": "0e8ca6c80d7b7008c946b13f18ba4533401dc062" + }, + { + "type": "commit", + "hash": "9e2114da79a01ff3f0c35f823fcebf6d633b5622" + }, + { + "type": "commit", + "hash": "0570c1bb0bb66ddddb3f858d4ae83dea918eb1bd" + }, + { + "type": "commit", + "hash": "387286c6d938db5a579a1340dcbb079ad9db6297" + }, + { + "type": "commit", + "hash": "5434e813b36382d575df68f83dbdac1bb1efa91f" + }, + { + "type": "commit", + "hash": "2547a6042f074465770fde65d6242cfb9bdedc16" + }, + { + "type": "commit", + "hash": "6d3ac0be7beddf1b6c3d69116e00242db6f75d6b" + }, + { + "type": "commit", + "hash": "d4c49251cceb26024dfc39480c8430485b60b432" + }, + { + "type": "commit", + "hash": "1db913a70af4b7498ee1212935094dcd02c55344" + }, + { + "type": "commit", + "hash": "564853cb85827533914c05d745a3ec906a87b919" + }, + { + "type": "commit", + "hash": "faacf89b89abd6488944dd339905c92f721ac701" + }, + { + "type": "commit", + "hash": "50c5997325689056d54aad6107dcad88fb22441a" + }, + { + "type": "commit", + "hash": "8cca12c59f1ce4fd3d467ae91a70899cb312616c" + }, + { + "type": "commit", + "hash": "2a112727acb49bc2cba0cb47efa114133d2c8f38" + }, + { + "type": "commit", + "hash": "67fd18cfab2ed09ef1f985a23f70b61989b878c1" + }, + { + "type": "commit", + "hash": "d104b3fc6726e52d1bc462ec49db830b4b6bf649" + }, + { + "type": "commit", + "hash": "edbfc6c94463c1c9815d4e24e06fb325669a770c" + }, + { + "type": "commit", + "hash": "131eedfd29d8a771ccc1973356d656102019096e" + }, + { + "type": "commit", + "hash": "8a2d0faccfc5175f4733c33dcb7d26e50e32b6d3" + }, + { + "type": "commit", + "hash": "d8d92b24b79f46f7def5ce17a62f050bab5f8187" + }, + { + "type": "commit", + "hash": "9c80e8e6552e7d01c7a3bf2c7f49413b6ebb74d7" + }, + { + "type": "commit", + "hash": "afe1a27db133013d453d49b604b2e739b72d3455" + }, + { + "type": "commit", + "hash": "8193b61ea7bf25459ff8b179bc261b7a920dd3f4" + }, + { + "type": "commit", + "hash": "586c8cf27bd7a64ff9a2b504f14408aca8f80bcd" + }, + { + "type": "commit", + "hash": "b641c7ae7e866a2feb85a507c050e0df46121903" + }, + { + "type": "commit", + "hash": "f6147a157492a0344ebafcac843fbc1fd1906092" + }, + { + "type": "commit", + "hash": "bf98c479814d7cce2926e7a8eadff2e60fb6e3fe" + }, + { + "type": "commit", + "hash": "525af9de1e1a98b6723ce109ae13bc1455af2883" + }, + { + "type": "commit", + "hash": "63c28ada22b814baae23585d12df86bead848b77" + }, + { + "type": "commit", + "hash": "40e61f6d90a0d9b7b28df60f757261fd772f4ca3" + }, + { + "type": "commit", + "hash": "7c3d919cbf707966ce7bef773c03a4953a021dfb" + }, + { + "type": "commit", + "hash": "6abdb4d1c1a4240bad63f846de28b787aa3d1999" + }, + { + "type": "commit", + "hash": "18e207c1153dd4df2b07bb0263b2dac5dec8e341" + }, + { + "type": "commit", + "hash": "c8ea3c512c57bb61edd99313eed33f07b1593f0c" + }, + { + "type": "commit", + "hash": "30e830e79fbf3a2c90888d598cee09f94aa82621" + }, + { + "type": "commit", + "hash": "4dd00e21332b306f4954822442a248a356346d0b" + }, + { + "type": "commit", + "hash": "5c7bed3d7dc3f37e89c2a23a6d2a7b5badd0ae91" + }, + { + "type": "commit", + "hash": "fc25877c4c0217c13efeece2d02eda61eec3e4c8" + }, + { + "type": "commit", + "hash": "77521ef0158d0052a7289a93a8f665038169fe07" + }, + { + "type": "commit", + "hash": "acc55521662538c447bc186802601693f29cd7d6" + }, + { + "type": "commit", + "hash": "2508596cc65d14860f88c374509d8839a044493d" + }, + { + "type": "commit", + "hash": "d9f8a2a31caa9fb0bab6a05dd16c3855978056e0" + }, + { + "type": "commit", + "hash": "8465a303723809a5f2cff099b4a0917394463214" + }, + { + "type": "commit", + "hash": "53ee96e01546cdbabb2a21f5e24fd3efb6858a19" + }, + { + "type": "commit", + "hash": "66d3bf43c7968a848ebeb38b5d22374fa7e1951d" + }, + { + "type": "commit", + "hash": "bf7e398733e8a5ded4b119691b3e6fedfde6b3a2" + }, + { + "type": "commit", + "hash": "50ac1bec57ce516495e04b732497e4560842fc7f" + }, + { + "type": "commit", + "hash": "2422b19f210bf7ebb68e3608c43ec22cd0455577" + }, + { + "type": "commit", + "hash": "aa26cf421a78119d1fe279bf3f25b87364a0f3b3" + }, + { + "type": "commit", + "hash": "55447edf84e9fd1edea7ce944936244e84500d56" + }, + { + "type": "commit", + "hash": "86a4aa65fe6a51b98af8d8097914381c946772ef" + }, + { + "type": "commit", + "hash": "d4b8ef3797f673879e6c0cc2302f4f1ab59e12fb" + }, + { + "type": "commit", + "hash": "7bd309e7877de5e5ebd4220f2d7954d204b318cc" + }, + { + "type": "commit", + "hash": "88acd305a0e172bece0e0d990a871a2ad7b015e6" + }, + { + "type": "commit", + "hash": "ac1ba804279977414914995083219fa8dffee0e7" + }, + { + "type": "commit", + "hash": "e5a269ed8940903a84fb59a6a7ec0a9c6213b86b" + }, + { + "type": "commit", + "hash": "bc45cae4f5ae01e6644c9cc9f884cb4d19d261e8" + }, + { + "type": "commit", + "hash": "f5881f1b12170b5b3ac421ade39ce2c49a32dcd5" + }, + { + "type": "commit", + "hash": "bf84dc1d08773e71284e0d5072a30f2809615b65" + }, + { + "type": "commit", + "hash": "c4e4addec494f1ec978c7cb0c5aac3642d08c411" + }, + { + "type": "commit", + "hash": "1ac3ae35274d4fe57934031af8856ccd989c1e84" + }, + { + "type": "commit", + "hash": "7050089d21bf30771bcc532b3c1ab2b22b6d1285" + }, + { + "type": "commit", + "hash": "52bc15b3e685afe74f8331bade5ed992b8aeedee" + }, + { + "type": "commit", + "hash": "d82af6d554d036df131f8ead819cd1cf7467fb02" + }, + { + "type": "commit", + "hash": "ba1e16ceb081cf4756f58b6c3addd1a775aa5b13" + }, + { + "type": "commit", + "hash": "7c470e4bc8cdc6bd2f3af0052e1a3cd5a094e8fa" + }, + { + "type": "commit", + "hash": "c4b387e59dd3aa51d34c0b0e7185f78f5f6c0dc7" + }, + { + "type": "commit", + "hash": "abcc57cdea99411cc685640439780638862d250b" + }, + { + "type": "commit", + "hash": "eb7fa987eff03d9b4f4065416ebfcd53936bd71e" + }, + { + "type": "commit", + "hash": "ed804807f78a676eda3bf00cd6983670b0691c0f" + }, + { + "type": "commit", + "hash": "2d4d01de4dfbccabc929ac91c3bda00373558795" + }, + { + "type": "commit", + "hash": "d9a566955b7f688ff529ded5b841e47b36bce777" + }, + { + "type": "commit", + "hash": "682614ba7a59ac3ec77e1f7c2702f544426a2414" + }, + { + "type": "commit", + "hash": "6dc47a835547320b0ef05e95fc271eebd309e382" + }, + { + "type": "commit", + "hash": "72912e1e3346e6a5cfdba65778732b6b04ea94ef" + }, + { + "type": "commit", + "hash": "368e942ebceb7552870330a9f307e85347e2f310" + }, + { + "type": "commit", + "hash": "1ed58733a028dc1493356d75461d807b2b7fe8dc" + }, + { + "type": "commit", + "hash": "4eb08f371a0765006f06c64d190ec30817833ee7" + }, + { + "type": "commit", + "hash": "5df9752dfd79d8a8b1ec9933f0be811675008b83" + }, + { + "type": "commit", + "hash": "0f939570d8a42b8ce61a1c631eee33c65e69ee90" + }, + { + "type": "commit", + "hash": "2acfee3214b36f6cccb96e804c24792e4b7fbedb" + }, + { + "type": "commit", + "hash": "f2248ce199e59055f887e2d67b4271e19e474426" + }, + { + "type": "commit", + "hash": "e18beddaf853a92ff037021ce458623cc2230af9" + }, + { + "type": "commit", + "hash": "87d4956761ce1df41946d10dc13b19830a01a726" + }, + { + "type": "commit", + "hash": "2ecafca525dfb6005c7f978584571b2fd6a4810d" + }, + { + "type": "commit", + "hash": "1cd2df731cf8f0a9f80658485627cf56c83dce0d" + }, + { + "type": "commit", + "hash": "c01823389bbf64eb3cc456f789965b3d9827369e" + }, + { + "type": "commit", + "hash": "0f912439301168548c4f2edb435d968b6ba5842f" + }, + { + "type": "commit", + "hash": "66e40f0aee0fc2a53a0b328f342e07842bed9f24" + }, + { + "type": "commit", + "hash": "c45b2945d78a1b8c0b408da85be7f46d89784e5a" + }, + { + "type": "commit", + "hash": "6e859fb86f1ecb3057e9b0287bea68b654de6481" + }, + { + "type": "commit", + "hash": "92dc69f23879e6f3ff58d7aa092de125cfb7db50" + }, + { + "type": "commit", + "hash": "aad03cea6b5f13879c59046bd84ffd6fc6ba24a6" + }, + { + "type": "commit", + "hash": "e5b1f47e22c9620fd1d1d1d51f8f06d6a1a31b8a" + }, + { + "type": "commit", + "hash": "1a0c89cc387e3d5b245a468717874f133cb2b4bb" + }, + { + "type": "commit", + "hash": "998500b3a62c91435d676b8ceecd2eeab56e76ba" + }, + { + "type": "commit", + "hash": "4646a962f864aeb07966d8a458fa778f0d72f60f" + }, + { + "type": "commit", + "hash": "edf8c78d5e67b40c20dcab3d2541c2c294d2513a" + }, + { + "type": "commit", + "hash": "7bb4695c99eca55d54a45fbdb810982731861094" + }, + { + "type": "commit", + "hash": "3b092558e94d6518a98cb8772340cf28cfce1852" + }, + { + "type": "commit", + "hash": "fcb6b0561e4930842a12a54ede1ae9560e8dc977" + }, + { + "type": "commit", + "hash": "9b87e1f121ad6229ad57222270dec72df12a503e" + }, + { + "type": "commit", + "hash": "62478fda59cda0aa39a28a1aa6d503e1c25ade35" + }, + { + "type": "commit", + "hash": "db6cf449f142e3bebeb4024287a4897b84d54bc8" + }, + { + "type": "commit", + "hash": "699166b6681eee730afebdae82fd7ad8cbb5ddb8" + }, + { + "type": "commit", + "hash": "fa5d2280d32085742010344efda20ec1ccea93f2" + }, + { + "type": "commit", + "hash": "73fd77a3c9d98ee041f031912e48fededfba3123" + }, + { + "type": "commit", + "hash": "8d7c1c3547911c92b2d0e68027f8db9356f1c3e4" + }, + { + "type": "commit", + "hash": "1d92be37da7121d7759df4294a4407fbc15abb78" + }, + { + "type": "commit", + "hash": "ed78067a84922936119fbbb88bcaddf640e9131d" + }, + { + "type": "commit", + "hash": "5d7ed155a1df90e72acc59e85be2db2d85283219" + }, + { + "type": "blob", + "hash": "18d523ef2da5a78d5b4f954bd4a3ab4df6e0a94e" + }, + { + "type": "blob", + "hash": "a8fdbae66e623da1561166dc8d66a03c8510e7c5" + }, + { + "type": "blob", + "hash": "036ea387bbbba0c6aaba195e9ea3aabae42153c6" + }, + { + "type": "blob", + "hash": "f84931b2447ff4818a07a52ab508655a25ceb3f8" + }, + { + "type": "blob", + "hash": "c968f8832ec88fa7369df9cd14b9a220a9555e35" + }, + { + "type": "blob", + "hash": "bfa2ab56bb404dd4fdbd1869938aa169dcefa032" + }, + { + "type": "blob", + "hash": "1c235365036e72f2f61e4712416948006d99b9ad" + }, + { + "type": "tree", + "hash": "6807ad0df127fcd1723fff785c173519dbcba8e0" + }, + { + "type": "blob", + "hash": "259ad003983a03b5fb2721361e3c8f8df9b5d871" + }, + { + "type": "tree", + "hash": "d4942cb94921da81688cbb7cbb3350cc5dc3e550" + }, + { + "type": "blob", + "hash": "4a95217bc6ff8bd01f44866601582342a05f7991" + }, + { + "type": "blob", + "hash": "984b11e903778142d04a54a6ef42878d6690d155" + }, + { + "type": "blob", + "hash": "b81df8733a6518e92a0a817b9a43dbded7d390ab" + }, + { + "type": "blob", + "hash": "4faa15f8095e43234d5221a247fc04bf0f00bdbf" + }, + { + "type": "blob", + "hash": "d96d36fb37ea24244bdd494ca7b7e985fb3fceb8" + }, + { + "type": "blob", + "hash": "b08a1f98a8fc3ed144740abecd7ab04f5572803e" + }, + { + "type": "tree", + "hash": "5d4b58851008f8ca9b41b9adf893f46256ee869a" + }, + { + "type": "blob", + "hash": "f6375b90acd9aabf91c57f0fcbbc3f957634beb6" + }, + { + "type": "blob", + "hash": "c178435f97ed96060b9bf42440279d141170fa50" + }, + { + "type": "blob", + "hash": "6b41aba69cbdec639c48dfcc662b37502b5b1846" + }, + { + "type": "blob", + "hash": "09d074fd308ec3aa56520742275dfcec6663a9d0" + }, + { + "type": "blob", + "hash": "5357ac3c0541d6c95a63da4abf488cbd22d8da80" + }, + { + "type": "blob", + "hash": "2aa195839013337320cb8a1fde517f22058386f9" + }, + { + "type": "blob", + "hash": "e69264cb2bdb3ca8b75824e249e8c8d11e4ad07d" + }, + { + "type": "blob", + "hash": "be50543949ba4f8a7710c00a24b36daee9bc8259" + }, + { + "type": "blob", + "hash": "038f8a4878534e3bc4e0dcca241c7109044f6a10" + }, + { + "type": "blob", + "hash": "512bcc537159c538d18e1d51c11eeb33f10bda4a" + }, + { + "type": "blob", + "hash": "245a5e2cd48bf8029a262811f90f5560f5269243" + }, + { + "type": "blob", + "hash": "1a2ba048da9d0aefc95a80fb59fda50ad1320377" + }, + { + "type": "blob", + "hash": "c8d34d3754283c04a633dbed7530f15872f5208d" + }, + { + "type": "blob", + "hash": "ce8d318c5bdafa63bd703d06065955e9f75e034b" + }, + { + "type": "blob", + "hash": "8dad19a32afcd8599797a045f744f7f5c9fb41d1" + }, + { + "type": "blob", + "hash": "93ac7c1ace197dfd3a67bec561032cc2dcc254de" + }, + { + "type": "blob", + "hash": "9992875063054dd42b9c272ad25930b5ffadf558" + }, + { + "type": "blob", + "hash": "09cc5502964b45d3113ae47055a20b460bf562bc" + }, + { + "type": "blob", + "hash": "f41a2f73f232f5988cc17b62561109efd09f9162" + }, + { + "type": "blob", + "hash": "413446298f4d5a2f0a3f4d8928da5545d2d3d4a0" + }, + { + "type": "blob", + "hash": "9a1c050e18370c2bac01c145cf0af9c981a8c8b9" + }, + { + "type": "blob", + "hash": "985d00546caf6fa51e5b7e5b4b7306a7f60c9e29" + }, + { + "type": "blob", + "hash": "6d942856af497435801da5579595dd2187754799" + }, + { + "type": "blob", + "hash": "63afc903b1209248f5ef87c1f5446cbf5cdaabac" + }, + { + "type": "blob", + "hash": "82912247fdb07ec3dffabdfe83ce04f0f2be0df0" + }, + { + "type": "blob", + "hash": "3953499d85134f313082943b04ede6981306911e" + }, + { + "type": "blob", + "hash": "a1060b27bc5db157fc47a24dcb72b01f9918a5ce" + }, + { + "type": "blob", + "hash": "0434481d5d39a1bbf752acfc062f5682234ad035" + }, + { + "type": "blob", + "hash": "574a28ac13176e51a9db8e75bfb6057dbe9c02c0" + }, + { + "type": "blob", + "hash": "3615b7a162032052f393472fca1b70d35d7e2e43" + }, + { + "type": "blob", + "hash": "a3d1936b658c11316d20b00e4e09ccfbf93ebbe1" + }, + { + "type": "blob", + "hash": "39f128db66507ae389bef319b539879888366b46" + }, + { + "type": "blob", + "hash": "d0fa687cd107e6c4efd30ee88e50ecf9042cddf4" + }, + { + "type": "blob", + "hash": "6222c115487372c420cafcfd63666b321f95e5d9" + }, + { + "type": "blob", + "hash": "d95cdbdc223a8a6d0c3f7998154453d493b5469f" + }, + { + "type": "blob", + "hash": "59a54752c3365e41dfd728507e7900586a5aa073" + }, + { + "type": "blob", + "hash": "6a2574487292ad4fc083445a564320a757401fb6" + }, + { + "type": "tree", + "hash": "650bf92fa44dca3683fb9c961ae6d00aa14195ed" + }, + { + "type": "tree", + "hash": "08e3a96ec6dbef6972229aaa200630b0f14f1786" + }, + { + "type": "blob", + "hash": "173cdddd8ea210e18f6e53912d6362bced76f7ac" + }, + { + "type": "blob", + "hash": "5bf906480494333c0920a65fef2b7834d9e0c404" + }, + { + "type": "blob", + "hash": "2a14aa693cced6e2954a799d47083e7b7cefed8c" + }, + { + "type": "blob", + "hash": "49c23e9f50906fd266760d03f4dda3fa897973d5" + }, + { + "type": "blob", + "hash": "c7f39671f5fa869249e0fce1be3c9cfe2bb3bcf9" + }, + { + "type": "blob", + "hash": "37a5ff709541e4ca1c9310eac684d09f11bce2b7" + }, + { + "type": "blob", + "hash": "fd3b0c389967b096b5cf0ecac363457d87ae5560" + }, + { + "type": "blob", + "hash": "d32728ee522b7db1cd2a3689b71a13597f829b47" + }, + { + "type": "blob", + "hash": "e0655bfe7cb365d2778718439c8758ea88fbed74" + }, + { + "type": "blob", + "hash": "d90a99c22ba0ec15a1096edececc856625ab34ae" + }, + { + "type": "blob", + "hash": "9f93e6a053ec8b51ee116af4a0239c04cc29c02f" + }, + { + "type": "blob", + "hash": "22640ba50a8b03fd58efe3552e4e9b8097bc78cf" + }, + { + "type": "blob", + "hash": "4f6c1d28da852b318605a53cc54901a1c6943c36" + }, + { + "type": "blob", + "hash": "b0c406857ea662a27de3bf30f66141944f3751e6" + }, + { + "type": "blob", + "hash": "001d9582be86c595e15b5e9286a6f9bb2e10ec9f" + }, + { + "type": "blob", + "hash": "2833ffd3cbec134c563a99175f7003a960c14b84" + }, + { + "type": "blob", + "hash": "78f8090494efac896004e7cb75a19dfe66afd1f0" + }, + { + "type": "blob", + "hash": "d1987731d82fb9f4ec0aca22539702054d2ce9a5" + }, + { + "type": "blob", + "hash": "7ca3e7c08b7337622cb3a13131c37791d20e66e6" + }, + { + "type": "blob", + "hash": "70dbfda3d4a03a425c7cdc8b33b9a2ea479e771e" + }, + { + "type": "blob", + "hash": "ebf5d5e1e17f9255263c43870e73d4b580d7e475" + }, + { + "type": "tree", + "hash": "86bf5ebe6c64357f16441a61df2badebc7990009" + }, + { + "type": "tree", + "hash": "2836f1c38fcac8ac0fe8065e16ebeda0007d722a" + }, + { + "type": "blob", + "hash": "0351e6daeef68fa35d30d32f9fcd5903afa9d312" + }, + { + "type": "blob", + "hash": "a1609c3fe7b8003a4341677ead6ba8f67bd133c2" + }, + { + "type": "blob", + "hash": "ef3157f513ea512938b94918b722a9400d326194" + }, + { + "type": "blob", + "hash": "fd9a33d63e04244f0919d38333b6fa72af4b7df2" + }, + { + "type": "blob", + "hash": "81d38b31b7a10fd5b36c56890a2d434f27ddd185" + }, + { + "type": "blob", + "hash": "dece5aced40393d2679c32e92c2806fa9fcdbf37" + }, + { + "type": "blob", + "hash": "b57f2332440f85483777a6af369c763c9b80493e" + }, + { + "type": "blob", + "hash": "f7db59c631b0b4ecbef384d0dd2cd507dac9a79c" + }, + { + "type": "blob", + "hash": "823f310e0dd37bde4f70260fcc111c5466e62a67" + }, + { + "type": "blob", + "hash": "5137dae232d8ee17639430290577ff89526b1e5f" + }, + { + "type": "blob", + "hash": "59c14f11c44fa2f0052e8563c406fdfeffb6a946" + }, + { + "type": "blob", + "hash": "ed8ba0385ddf3885d5b94bee06c119f7f02d3c83" + }, + { + "type": "blob", + "hash": "bec26a08224bbc19e2671fd89cfd1e670e210eac" + }, + { + "type": "blob", + "hash": "9f70c0d7316f730c4e8a2453a585a3926e7cd0fb" + }, + { + "type": "tree", + "hash": "980cdf948a1382ca91218e97fc63caebe996e7dd" + }, + { + "type": "tree", + "hash": "63b17818a5a8a2c00609772ead729d89e72fcd3f" + }, + { + "type": "blob", + "hash": "44ab90e020a29d078a7ab1b76a27c0854a1100f0" + }, + { + "type": "blob", + "hash": "88ac21f519737a04763a66b8e42fbc5af041e54b" + }, + { + "type": "tree", + "hash": "53a98e05107d87e33c00127151d5cc2dbf987238" + }, + { + "type": "tree", + "hash": "3837441b75e1e17c235c45aaca4594cbde3e3fa5" + }, + { + "type": "tree", + "hash": "eb6c2fb43f8c34e565157f014381f8bde2817d51" + }, + { + "type": "blob", + "hash": "982938796181b00ce0ed43c84f3ce0eae45477e8" + }, + { + "type": "blob", + "hash": "19b43a5cb49fc78c59d76cd4d6d804bd36b4fad2" + }, + { + "type": "blob", + "hash": "5983003402843f15ede668fa3aa27ee129e549a8" + }, + { + "type": "blob", + "hash": "fa12bfd0df49297b692fbdc5baaef252979fdb4d" + }, + { + "type": "tree", + "hash": "016b4797a2173524cbaf241d808d616d0a3bc0a9" + }, + { + "type": "tree", + "hash": "7e3627f3bf106779581769e905c7423da0e8f2f1" + }, + { + "type": "blob", + "hash": "6c8c538c4ea5dc6b9c504691635f40caf746b3a0" + }, + { + "type": "blob", + "hash": "69c8cbb6ddfd12f46c9f06dd3f81dd8e3457220c" + }, + { + "type": "blob", + "hash": "2288516d2d05bd9e25cafab2b79a887b3563256d" + }, + { + "type": "blob", + "hash": "79128e416ce7abe80d289c31086cb51bbc942cc7" + }, + { + "type": "blob", + "hash": "537a65bfa0ba65ac1d660b01131ff0eba99fd45b" + }, + { + "type": "blob", + "hash": "18a36503e2941f38206c89d224379d1ad865f30f" + }, + { + "type": "blob", + "hash": "182e27a2320b44ea19c6d8401b677dc48370d7a9" + }, + { + "type": "blob", + "hash": "5dcc021cc5b9ac816b2effd7e209fb456472581a" + }, + { + "type": "blob", + "hash": "5693cb0184d903e0d7c7055ce1e40b085769b6b5" + }, + { + "type": "blob", + "hash": "5822aab6b1b2b9ab1b08c78d42eedf1ca6028076" + }, + { + "type": "blob", + "hash": "baaefc281d78ce75e46edd3077e85b3f032cb642" + }, + { + "type": "blob", + "hash": "3cc419c29f81515af0029d0eab2ace79449a7306" + }, + { + "type": "blob", + "hash": "5429c25fe3e01088ebf396dc62786fc63ae4be7c" + }, + { + "type": "blob", + "hash": "22b99a2228ef27167115b9f3254a431f70324938" + }, + { + "type": "blob", + "hash": "39826fea185088c92380f0ddad993445e43a819f" + }, + { + "type": "blob", + "hash": "eeae487d5464b5dd80266b9dae94386f262eab40" + }, + { + "type": "blob", + "hash": "f9a133055577a31e6a97ea9fa7419fd5f69fe589" + }, + { + "type": "blob", + "hash": "523b850a246900f3092ec369a2fbccde3bd843a6" + }, + { + "type": "blob", + "hash": "254dc1f2ad231f6589480f5c63ec200ec32d9ac0" + }, + { + "type": "tree", + "hash": "adc8cf8cc7312a981b8303a73cff2832ec97f2fe" + }, + { + "type": "tree", + "hash": "f63cc7980c1338108f5cc048746e39f1c156c26e" + }, + { + "type": "tree", + "hash": "bf38c2b9a5491ec77d1366b827bbbfe13eb19cb9" + }, + { + "type": "tree", + "hash": "dc2ffe78bc4f166db2eb5c9b41cf6d1f37d32f4b" + }, + { + "type": "tree", + "hash": "261ff5bd0454cb9bdadf970a3e24b8985fac3d90" + }, + { + "type": "tree", + "hash": "b724c93f94f8931c04d50312928a1d1435633c7e" + }, + { + "type": "tree", + "hash": "427817ecc00b4a49443f3f6c175e11bd36ae095c" + }, + { + "type": "tree", + "hash": "07b089b8295ca30c6ff5d48a2c98aeb5adf8e847" + }, + { + "type": "tree", + "hash": "f44c461bb827a8c84bc4ec2af11105a3b989d917" + }, + { + "type": "blob", + "hash": "5a4d700e604f269b1d441683358e4bd3b326dd8a" + }, + { + "type": "blob", + "hash": "4bbd0c6e13d70c6df57e1c5ad42e3e0b0075b8bd" + }, + { + "type": "blob", + "hash": "6161444cf2a157082c71ab0fc1cbaeaca091a4b4" + }, + { + "type": "blob", + "hash": "a09432adf7970d0c245ee004dc84e3e72999460c" + }, + { + "type": "blob", + "hash": "953ae25c15f369c3a955071519a1a3ec54f54170" + }, + { + "type": "blob", + "hash": "284ba529a6636c23b740a1f8925c6b16bbd4b043" + }, + { + "type": "blob", + "hash": "3d4cb3e1bb42f35648e382b759f3e01b35f0dd79" + }, + { + "type": "blob", + "hash": "3215ae7069b88893e9b56a2cf2e5fe983bebec0c" + }, + { + "type": "tree", + "hash": "0b9c73eaa474109785364a3ac5d9fd1de0301d7b" + }, + { + "type": "tree", + "hash": "47a0a27fa3c566b142c4c8c591f4b4a8b8f8f73d" + }, + { + "type": "blob", + "hash": "0d3511c3cd4c4738ab150ca8d40a891d58c5f017" + }, + { + "type": "blob", + "hash": "1402d3e2f8ebd46c3ff4633592518ecdc365d029" + }, + { + "type": "blob", + "hash": "1f3ad00ccb166538b2a1f9501886a3d4abbe4313" + }, + { + "type": "blob", + "hash": "5469a3294774e037d243ef7e08eee94068a80a5c" + }, + { + "type": "blob", + "hash": "885a6921b91043f9188a085b1217a9ec5f91cc0d" + }, + { + "type": "blob", + "hash": "29d821d24dd5ef443ddbe246489805505321b760" + }, + { + "type": "blob", + "hash": "912818591c4182643498a3aca557ebafbdecab77" + }, + { + "type": "blob", + "hash": "f249dc5649f92c93588b50db4362dfbfb64c31a4" + }, + { + "type": "blob", + "hash": "c3c9d0046ac46424733bfc5be5fd7df2fd93a50f" + }, + { + "type": "blob", + "hash": "2e536ad146f9af1b63fa94d0bdf3bffa3641616a" + }, + { + "type": "blob", + "hash": "16677bfc00be575bdaff61ae9e34b1bfb5b9252e" + }, + { + "type": "blob", + "hash": "c8d61e55ee988b77ee2b29be69052561b42eec4a" + }, + { + "type": "blob", + "hash": "1ab7de48485415988fc1ce8b44649504c7c3d864" + }, + { + "type": "blob", + "hash": "fcf82b2874fd4083b1ed7660843e5f09a939f5fd" + }, + { + "type": "blob", + "hash": "2eb508282955709a05f4553808d2d3f10935130d" + }, + { + "type": "blob", + "hash": "95d065d74f0972f25dcffee2b9695748c2d130c6" + }, + { + "type": "blob", + "hash": "0eca92de513a6d49e81264e9b715655bc90b7ea0" + }, + { + "type": "blob", + "hash": "76f7f58b07173a11bb288e0ef0f6a068b2515b36" + }, + { + "type": "blob", + "hash": "63f41036748e066bcafabd1c5e77f2585c395a89" + }, + { + "type": "blob", + "hash": "ba03b7d511fca8d4994d6e8eca4dca5de8e560c2" + }, + { + "type": "blob", + "hash": "dc48018da096529dd836e0eb830848dda6534513" + }, + { + "type": "tree", + "hash": "783b1c2e2b46c98f74c310a98ef08054c854efe4" + }, + { + "type": "tree", + "hash": "2932ccf35e3473e446c2a1bfb7fbebe9285ccab0" + }, + { + "type": "blob", + "hash": "565482dc91da426c78185538a244f785941c20b6" + }, + { + "type": "blob", + "hash": "ad4fc72b99f49efe6db91b26c3910b282d3745a5" + }, + { + "type": "blob", + "hash": "20a7f005c7884546ea02d097b15fa8a12b522e6f" + }, + { + "type": "blob", + "hash": "c1808db4cfc1bdf91c7b4fb73ca19ab4261529e3" + }, + { + "type": "blob", + "hash": "9713e609452a7cf42e4505fa5d83b7b879f7023f" + }, + { + "type": "blob", + "hash": "1ea962dba3b73be2d788b02fed48f576d6c3d443" + }, + { + "type": "blob", + "hash": "a7b797a5ab583f6bc92e2a6fbdb3f5497a853cf4" + }, + { + "type": "blob", + "hash": "30d02e6aeb698343567588d7dc7f4a44c6fa0f75" + }, + { + "type": "blob", + "hash": "0a1c903de76e9c37adea974fcb91b275a3ef39df" + }, + { + "type": "blob", + "hash": "94a3db3490a989f2916c8784feb98e57876d5174" + }, + { + "type": "blob", + "hash": "1462efcd443e3a07561893bc50cb107679446b90" + }, + { + "type": "blob", + "hash": "3717b838c08e5656d1c3139832dc0bed84390d73" + }, + { + "type": "blob", + "hash": "18c61a53e28c7ba6fc348f86c1745710730c6e8c" + }, + { + "type": "blob", + "hash": "481b48c166fd6f12a360bff24d52d13b36a07422" + }, + { + "type": "blob", + "hash": "48dc5288bd24912d86bbb6a08bf95190d7036f2c" + }, + { + "type": "blob", + "hash": "6e46845a203a08a929e1a70513b789d23fb43ba1" + }, + { + "type": "blob", + "hash": "78f5eb5d5b255952e6e87655c718063597e578ba" + }, + { + "type": "blob", + "hash": "d67d8d9615894473d1a9a9e6a51bcddb57453fc0" + }, + { + "type": "blob", + "hash": "e87151d0e1e416184889ab540bd3293abbf2242b" + }, + { + "type": "blob", + "hash": "a2a02af4b922f1a76548b52cd3996265a9b15752" + }, + { + "type": "blob", + "hash": "bc3189d8c268ea1b73fec4c332101072a6c1318d" + }, + { + "type": "blob", + "hash": "390b97a5db80af27d1d4eddcda9e73ab44f9ef26" + }, + { + "type": "blob", + "hash": "5de9f76ac69d4f022d843b24aac3e0e25e7523a4" + }, + { + "type": "blob", + "hash": "1438d5c1d0340aee00d57cca2a4ebada849f90a6" + }, + { + "type": "blob", + "hash": "a5d30209bd0bbcda89926b9e56d6502c319727c4" + }, + { + "type": "blob", + "hash": "65da059aa64e9e18b2a54e7f3a6791183a3c6b87" + }, + { + "type": "blob", + "hash": "677b9dc7aea4dee8de4ad7ceb3e35756f54d3fe5" + }, + { + "type": "blob", + "hash": "d104d7e9d823b0257db76a4f726bc5143874ea09" + }, + { + "type": "blob", + "hash": "0910bd67ba2e87890b9556b1001464b49162138c" + }, + { + "type": "blob", + "hash": "53b6524dfaad8c13f5c175dda8a2f67dbfdb3ce0" + }, + { + "type": "blob", + "hash": "cfb184b303ecb633d257f5681ba6490cae43a713" + }, + { + "type": "blob", + "hash": "f816cc48b115c259bc598e71453cd661da8088c7" + }, + { + "type": "blob", + "hash": "e2c545fcf8f68c67a038898b1b2c84fb3cdb6192" + }, + { + "type": "blob", + "hash": "cfc2770f0d575c9aff1b24668624a63f8043fb64" + }, + { + "type": "blob", + "hash": "e49b1c370148461e814bfb0ba2e16945bf1c7f10" + }, + { + "type": "blob", + "hash": "950fcb8ca4afef075e1d45669bb7dee577351474" + }, + { + "type": "blob", + "hash": "2b3c4e572a7f6db74bfc2218c723cb50f141514e" + }, + { + "type": "blob", + "hash": "288fbabb5730fa7dbc62811e8350dfe74f658fd5" + }, + { + "type": "blob", + "hash": "5373043dd2fc1ca50d19bad5854a37015b601ca4" + }, + { + "type": "blob", + "hash": "303ce9116e5c463e43e32cbfe5c81b7e8f265a07" + }, + { + "type": "tree", + "hash": "73b7d1a0c2dbf9b8df620a9e62b5640ca6fc449a" + }, + { + "type": "blob", + "hash": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "type": "tree", + "hash": "7f617fd1e2f110a2e72c3c1226614e9c2ab5eb82" + }, + { + "type": "tree", + "hash": "6d62558c01f590dfc8536335827ba0e4ba370bee" + }, + { + "type": "tree", + "hash": "7e5d7b54c4b37412c85491a5c2ea139f2ba41d4d" + }, + { + "type": "blob", + "hash": "83b7660148616264f95023fb0d956a7871189ca2" + }, + { + "type": "tree", + "hash": "db1e6003134394c80092dea01bf91bc6bac1bb37" + }, + { + "type": "tree", + "hash": "3de92e394a72f15711802cf83b842b7abeb5fd27" + }, + { + "type": "tree", + "hash": "17b0e4ff7dfd8ee175eb0eb9f32cd062cfd38609" + }, + { + "type": "tree", + "hash": "ff120c5e7d45d2a0eeed8a51cb9b4aa90f98bc77" + }, + { + "type": "tree", + "hash": "35d21f59f5194f000d73bb6d24848dd1b68d2519" + }, + { + "type": "tree", + "hash": "7bb1b49ce56edd3675ef9f2e5b82568dabce5043" + }, + { + "type": "tree", + "hash": "08baf80e3011eb4c59413c5543db140b611b7f09" + }, + { + "type": "tree", + "hash": "6dc118157af83076812f87d5348cbf5903a9a1fe" + }, + { + "type": "blob", + "hash": "4678daefb0c1b50868fd9c0034ae8b56ac278b5d" + }, + { + "type": "tree", + "hash": "d57698c1db467dd7d4e7676533f2b16673bc847b" + }, + { + "type": "tree", + "hash": "c02f6b7bbb114bb94bc018d2243babaa0b71d3d0" + }, + { + "type": "blob", + "hash": "a3da7b6d7c8041e32673cf01fe013357ff10f294" + }, + { + "type": "tree", + "hash": "216f388830f23cfd546ba947d624d520263d5cab" + }, + { + "type": "blob", + "hash": "0f23e0a0fe02cd87b770479585119d974a4eddf8" + }, + { + "type": "tree", + "hash": "07a7a6aba3f0e9525b8a0f891a723421b622efb3" + }, + { + "type": "tree", + "hash": "0d222d7adfbbbfdd435b6f8dcd27e5033044b430" + }, + { + "type": "tree", + "hash": "19660ae0cf99c878ff07c7d2425d740f1d3156f0" + }, + { + "type": "tree", + "hash": "6341e5363ec8f0b92de40da56db0c3bb46bae7e7" + }, + { + "type": "blob", + "hash": "349834e55272c4b8d25392fae53c0d7551a464b6" + }, + { + "type": "blob", + "hash": "b6bfc40cc7eca3ee640823d1688d175c11c795c6" + }, + { + "type": "blob", + "hash": "b4f3c23df2886b2f14adc4ccff791199c98befc7" + }, + { + "type": "tree", + "hash": "54b2f942f8ca8912be82eb8fdb1325a06d18a700" + }, + { + "type": "tree", + "hash": "94c08df5292dfd80ed5ace795f5b37afe5269a8c" + }, + { + "type": "blob", + "hash": "886ddd40ef70bc6dc7dd78bebe9b95024e7fccc1" + }, + { + "type": "blob", + "hash": "ab00f231bd22d5890a317ae1602f406d9791e0e7" + }, + { + "type": "blob", + "hash": "de66c5e5466094c43b4ffd095f6495186b05c535" + }, + { + "type": "blob", + "hash": "449d1bab059f9c505faa1323a23f8d268ab829f1" + }, + { + "type": "blob", + "hash": "4bd247d87f3ab51862f04237602155ae4fbb729b" + }, + { + "type": "blob", + "hash": "48ef390f099339dd66181c0293017c32c055138e" + }, + { + "type": "blob", + "hash": "65b88321cef2a9229d4c64ca52d61c9d67fe629b" + }, + { + "type": "blob", + "hash": "6965fea09146851270b37b0eb1c563b29be28b6c" + }, + { + "type": "blob", + "hash": "82a8ab6b8a1857e22e79a0d67f59af22b6b72d67" + }, + { + "type": "blob", + "hash": "ef0288927215136f713e208f85b6effc79aed295" + }, + { + "type": "blob", + "hash": "a932fbc0feb7cb360903e19d6b30d21c81b228bd" + }, + { + "type": "blob", + "hash": "c207e0957b01499afe5d9bd467419408eab87909" + }, + { + "type": "tree", + "hash": "03cf0f1b02528de2cf366c320ecd13d8c0384783" + }, + { + "type": "tree", + "hash": "2764d4996ff164f2ec05047e2af747e10e4f4f46" + }, + { + "type": "tree", + "hash": "c648b67b4a241d15aa82ac43efe17f47d894ff8c" + }, + { + "type": "blob", + "hash": "28812f8070ed3c5c25ca8fe01eb024fa2b659481" + }, + { + "type": "blob", + "hash": "e0a912bfb8666f36ed9276c615f8fcc53700f83a" + }, + { + "type": "tree", + "hash": "75a6904a90afed2d46205089e66d4c06c2c857af" + }, + { + "type": "tree", + "hash": "de369c29be754ed6ff21fc67e24b1010d8e50d62" + }, + { + "type": "blob", + "hash": "f9de195c5e971e74c2f7d9406a1320007704d0ff" + }, + { + "type": "tree", + "hash": "46b534f0db4afc22c7974dffd7f5b43e3335e175" + }, + { + "type": "tree", + "hash": "82a6e53fc1e3c944a411ffa48569e0ee4bdcd798" + }, + { + "type": "blob", + "hash": "5c83e62b7e11e6f64152660e642e261258166420" + }, + { + "type": "blob", + "hash": "35a83c9be51bf82d82664c46c92b99c21270446f" + }, + { + "type": "blob", + "hash": "af8cdde955e03efc2868ac20ef0f6fad17fe9793" + }, + { + "type": "blob", + "hash": "c22cc3d34724bb2236906642f3fc39d683a25f2c" + }, + { + "type": "blob", + "hash": "279167f90b54f4f018dc7da10c67e780a499d215" + }, + { + "type": "blob", + "hash": "f2e1bd7e1ff60adf645ab27cd3f28c5f780bb247" + }, + { + "type": "tree", + "hash": "92f7a4c5e94f6eadb3b32d7b00e2e3bd9f36f839" + }, + { + "type": "tree", + "hash": "dc0c25c933041f53629cabc82f8c0e30f03029c3" + }, + { + "type": "tree", + "hash": "4a8117ccaed167605d22183c5aacac4ac8a5693f" + }, + { + "type": "blob", + "hash": "b9e6895eaf1d78facd442721213d7ac95a2d62d5" + }, + { + "type": "blob", + "hash": "b031e784f96d0693699d2b6773776099eb403f0e" + }, + { + "type": "tree", + "hash": "0e610c1e3e5c791ec2a553f2d842471d9a45b8d5" + }, + { + "type": "blob", + "hash": "3adddf296e69aed864835e7f47afe7c421909e90" + }, + { + "type": "blob", + "hash": "a63dd48f9912ad6731f46774ca7c796c1b8b107e" + }, + { + "type": "blob", + "hash": "2803f4b47ca58c99ced192e98d80381f7a855998" + }, + { + "type": "blob", + "hash": "578511eb8fb3251290ca22c3d58da470ebeee9c1" + }, + { + "type": "blob", + "hash": "ced7e10a95bc57779ec9380d4def0b116ab1bd37" + }, + { + "type": "blob", + "hash": "be7d5487aac9b1c6b1326faa4ed27252a5c295ec" + }, + { + "type": "tree", + "hash": "04e036c42754f896c8c88df0791bf961e8a79370" + }, + { + "type": "blob", + "hash": "01259c1d122de120aaa54df5616deda64f2e2894" + }, + { + "type": "blob", + "hash": "eed5608cf58cab5218da721e1fbefac9a4d1af1f" + }, + { + "type": "blob", + "hash": "d53424ff74b342b1b8a24cb4a792f949438ed37f" + }, + { + "type": "blob", + "hash": "196b8b31d2994fac14a5ed0caa3abda55e25c2fe" + }, + { + "type": "blob", + "hash": "8d4a279087b506062f7bf4207372e94594319405" + }, + { + "type": "blob", + "hash": "1b817a75a0026152218e524880c6f136ff9150c3" + }, + { + "type": "blob", + "hash": "6e34ed3fec46993200b645b5b044e5a710efff6a" + }, + { + "type": "tree", + "hash": "221a22332873f20b956e03b54ab2fcc999752150" + }, + { + "type": "tree", + "hash": "4a3a04fd70b960fadc23fc4e08413333181b7044" + }, + { + "type": "blob", + "hash": "420b92b879101cd352fff3d8439089655f38db0a" + }, + { + "type": "blob", + "hash": "a78c4198e349a3ca819882b2612190b8fa43e664" + }, + { + "type": "blob", + "hash": "1813173c3cbdd3478e7c354fa3cfc03a957fe66a" + }, + { + "type": "blob", + "hash": "b29f43c6d0f40ad878cdbdba9fde013c8f72c95e" + }, + { + "type": "tree", + "hash": "20a6d0434c0daabe4b0047f8f085bee2de74e15d" + }, + { + "type": "blob", + "hash": "1a6a56a79e07e1b5c7e02dd172cbcb5159bf4e3e" + }, + { + "type": "blob", + "hash": "fa4101d90fc51f7a5dbb57387e1026300abb5781" + }, + { + "type": "blob", + "hash": "359a5b7b0115aa054298a4ee034f460f6501cc9f" + }, + { + "type": "blob", + "hash": "d5f0de6652bdfff516e97509be40574170667325" + }, + { + "type": "blob", + "hash": "05b04c25f2ebad19c05bbd7bc7aa8c0f535fc1f7" + }, + { + "type": "tree", + "hash": "92ab9c275a4821e50b32c162dde4ef1b48369d8c" + }, + { + "type": "blob", + "hash": "cf90deec4df95861a719214ad63dbba7c671c2f4" + }, + { + "type": "tree", + "hash": "0dfee48971c0ce3a0f4714094846d2662fe5b609" + }, + { + "type": "tree", + "hash": "92894a150d36ba87612c959fdc2410f9a5243431" + }, + { + "type": "blob", + "hash": "3c3629e647f5ddf82548912e337bea9826b434af" + }, + { + "type": "blob", + "hash": "1ea5f9ae5585c3fff6afb334665ddf6496b1870a" + }, + { + "type": "tree", + "hash": "65709249ca99861bee38a9a1f358014c8b1ab1cd" + }, + { + "type": "tree", + "hash": "76aed561d938c7b0a97ca7e4a4e1278191c069a7" + }, + { + "type": "tree", + "hash": "805ce3520b58be2769e23b168a486a94ae0ba1d5" + }, + { + "type": "tree", + "hash": "a0e2bfcab3d62d11d60d5edc47f4dd62cff7ce6f" + }, + { + "type": "blob", + "hash": "d19b4f2ebf21feb394a6224a116f9c1ca442505f" + }, + { + "type": "blob", + "hash": "27764b590a2800d5db3b91173b480ff94ffc8440" + }, + { + "type": "blob", + "hash": "751834b232ebe9aa05f4137ad6eac04a866c2775" + }, + { + "type": "blob", + "hash": "20b9ce62e234769489d7d4822d53b1c71bd29290" + }, + { + "type": "blob", + "hash": "4be842856eb8a5304b3b266e4ce741d9a21ac85c" + }, + { + "type": "blob", + "hash": "11250fdb73fd82ee88008b7fe0b3f2a1592c25e1" + }, + { + "type": "blob", + "hash": "e69d63d9368ed3536dd0b61d45776593e691ebd0" + }, + { + "type": "blob", + "hash": "9945620af6bc5fc001859d226d9003baf2346277" + }, + { + "type": "blob", + "hash": "33415a98b9440bfdb60641ff596ee3f3bd20ff72" + }, + { + "type": "tree", + "hash": "4a34f15550923ecb92c798bc97ea4bef0ced4f82" + }, + { + "type": "blob", + "hash": "8949a58fd305d412eb173121b31a0cc149cba5cc" + }, + { + "type": "blob", + "hash": "ac46495950f11541eb0947c22438c8eadaff356a" + }, + { + "type": "blob", + "hash": "ecbe1d4688070634579071089f806561a687d1cf" + }, + { + "type": "blob", + "hash": "10de131d5fe0b349a77affb1ab89b993dba369b4" + }, + { + "type": "blob", + "hash": "061599af811dc2b918a89b60c90da9ed97f5aa76" + }, + { + "type": "blob", + "hash": "37f3e6e558c5f70b9cd0226b143ca6e0cb39d447" + }, + { + "type": "blob", + "hash": "b8689c97cf2ec287597916b64c7301cec9f0e1f5" + }, + { + "type": "blob", + "hash": "a59e1820822db3910f0e3126a6ba773c1aab429f" + }, + { + "type": "blob", + "hash": "f5a186e5d0f50f432c41144d573d3aae0a8b9e9c" + }, + { + "type": "blob", + "hash": "67c48820546eaf808fbe74880784b466881296c7" + }, + { + "type": "blob", + "hash": "030524113d172829c935ee4218aa16b6a33a3535" + }, + { + "type": "blob", + "hash": "ddea4d0cb3ee9a70d39d9e2c603b4bcb6980460b" + }, + { + "type": "blob", + "hash": "c20ac9d2021853ab4f0246127119d291ddee539d" + }, + { + "type": "blob", + "hash": "91f997c91e53a87fe59025cb100ca890aa5873ae" + }, + { + "type": "blob", + "hash": "3d9f32acba5de7bb5f9e86f76245e542f07601fe" + }, + { + "type": "blob", + "hash": "1b32b0723494d5d9c45bb6fca77acb0949f3bb71" + }, + { + "type": "blob", + "hash": "474f7e77eb21e82db9823cce82153271044d3a04" + }, + { + "type": "tree", + "hash": "67e5d973277dec6a35bf1b69878bc5570e82433b" + }, + { + "type": "tree", + "hash": "9a632b195940d786aa2cf4881efe5a4793c46873" + }, + { + "type": "blob", + "hash": "c88e7ec37a2c56576b7a33e9cd4e649614f57330" + }, + { + "type": "blob", + "hash": "d3cd7cc8bc37dbdbd20f8d773abeeac55bc56554" + }, + { + "type": "blob", + "hash": "efedf5eba1e2c562f1e949ba9e7176c457f33c20" + }, + { + "type": "blob", + "hash": "16c0cede290e8c05f0f634c0abf51a5f0ebbf86a" + }, + { + "type": "blob", + "hash": "96dbef6631755ca2ed43d01a47011f26a223530f" + }, + { + "type": "blob", + "hash": "8b898a9f858ee1aca2a5babf37f35af17c515378" + }, + { + "type": "tree", + "hash": "0922901cd31f755d4c87434d65dfe20312219d5a" + }, + { + "type": "tree", + "hash": "0c1e0b03e74449a5fc342625cc8325c10d6d6b2a" + }, + { + "type": "tree", + "hash": "490a42c251697b5d67349f151c25c38d1fb1a8b5" + }, + { + "type": "tree", + "hash": "aff58c04b582cd45557aebd14f6e210bac31c666" + }, + { + "type": "tree", + "hash": "c42fd797b71ff06cd6b1aa6921bcbd0610d8437b" + }, + { + "type": "tree", + "hash": "ef7955b0653af74d1ae1d22ab0c9490b51a94c0a" + }, + { + "type": "blob", + "hash": "4f3d51e89d59c7275124cc83018b960e07e2d5c5" + }, + { + "type": "blob", + "hash": "e1828620ac37f28934b917a3656db8f0b8505706" + }, + { + "type": "blob", + "hash": "9d5c656f7610f295af5fc618f5172b67ffdbd55a" + }, + { + "type": "blob", + "hash": "cb3f69c6a6c6017c103c65c47ce372028af8bf43" + }, + { + "type": "blob", + "hash": "e2b13f1cf39810ced8e20303c4075098a827972d" + }, + { + "type": "blob", + "hash": "63269f2eb004bb5e96470330128210d254d19955" + }, + { + "type": "blob", + "hash": "9345469fb0fd5e8716f8773c6a690477f350794d" + }, + { + "type": "blob", + "hash": "ac57df991033325927086755bd5a4e5aa51d4809" + }, + { + "type": "blob", + "hash": "46ea4f0acfba1a5112e866a8c40ac149f720f176" + }, + { + "type": "blob", + "hash": "fb19f651b23df411217034f21b28a8255c06a8d1" + }, + { + "type": "blob", + "hash": "a7f81cee2f8b61a2df14b135cb262cbb8612c122" + }, + { + "type": "blob", + "hash": "8b9407d2bf094c76f3fcdd4845277a9a38bcb437" + }, + { + "type": "blob", + "hash": "82e62bf6d0de134c6be6466d7e0905a1e14ee2b5" + }, + { + "type": "blob", + "hash": "1087c491c510554913f5121059e0bfb1406cba98" + }, + { + "type": "blob", + "hash": "5e704ee92c3d7a60d98fd4ed68a32b5eeae7d870" + }, + { + "type": "blob", + "hash": "199f5d846e85f2206335cb6aad112a7c94879abd" + }, + { + "type": "blob", + "hash": "77c27aba113e1d1a60e5316a15505b7f6b5fe155" + }, + { + "type": "blob", + "hash": "5c4b76b65dec713b9582a09222e40a5f753384db" + }, + { + "type": "blob", + "hash": "5f48184fb544d58667fdcce05b3480537e09ebd8" + }, + { + "type": "tree", + "hash": "06646b1e72b274a573d613257e2973e46f91765d" + }, + { + "type": "tree", + "hash": "28641628883036cf7d69339d3f081f6e5b51b048" + }, + { + "type": "tree", + "hash": "94cb41d8f43e0ec3aa09c800df242efb24d807d5" + }, + { + "type": "tree", + "hash": "cbc3918ce6e4443c4159c28cbfcf034be25465a8" + }, + { + "type": "blob", + "hash": "bdbb60020259c281caf5ae52b6c40d7cf3b83e4d" + }, + { + "type": "blob", + "hash": "09cdb72c488b110dbeeb583edbf1b79802087e63" + }, + { + "type": "blob", + "hash": "63fb543ffeeb935dc1e509492744a6b2b2b810d4" + }, + { + "type": "blob", + "hash": "0f739644d3b7113fdd4bc96ab8bf40ce27d4de0f" + }, + { + "type": "blob", + "hash": "7d8bc1be3c39a9a517c2fd022c28c2ca104f4b88" + }, + { + "type": "blob", + "hash": "a664228bc9b9150818e636d3654a30e8fd271ab4" + }, + { + "type": "blob", + "hash": "73fee0d6e86ee5cb1365af0ca5cd3b84e1bb6257" + }, + { + "type": "blob", + "hash": "3d4c6bd953d10287ec462aa2426d009ec0a30c97" + }, + { + "type": "blob", + "hash": "df101f274adf19f18540ce4f56e9a4f15a5b27b2" + }, + { + "type": "blob", + "hash": "a9e9afae306e193a9b0893d18e7c5ee427d4debc" + }, + { + "type": "blob", + "hash": "26c2d5be6075d0c78d4fa3416f25d289979877e1" + }, + { + "type": "blob", + "hash": "08df3813c52cbe851ac35fcee1f8ab92000e6445" + }, + { + "type": "blob", + "hash": "ecb42836ec3f9f9065592c969714aae603a4eae9" + }, + { + "type": "tree", + "hash": "395092457a22df7f6d8467142a01688d605ec682" + }, + { + "type": "tree", + "hash": "857d3947f86aa7c7850592348878ad21b941f579" + }, + { + "type": "blob", + "hash": "642f1a4b5ba5e97dabfa1dfb888ba5703d9c3135" + }, + { + "type": "blob", + "hash": "875c96cba96ad8a57f6aab57698325653a667082" + }, + { + "type": "blob", + "hash": "d63a2c52f73fafce4e2732587f95819155cbd220" + }, + { + "type": "blob", + "hash": "539970e1ad515752e5be06ccb635eb2af382b05b" + }, + { + "type": "blob", + "hash": "671f35690092fd08dd3814889f85549e7e8955d6" + }, + { + "type": "blob", + "hash": "25e96043b673d650a21aa620a8946c834f391691" + }, + { + "type": "blob", + "hash": "f11cd48d6d650be07f08f0ef161483fce2743c83" + }, + { + "type": "blob", + "hash": "ecd3b827b5b0ee6c11043b037e5e2b84edcca2a6" + }, + { + "type": "tree", + "hash": "13b496c034b12fdb92009798783f84465271600c" + }, + { + "type": "tree", + "hash": "1ac17efd501668bd10d561ff8995f0e23a81eefc" + }, + { + "type": "tree", + "hash": "b0919b2cca172852148bb1f0b932f32f2b2b8358" + }, + { + "type": "blob", + "hash": "2e83d5f95776687ce57fd25305a9e361482d6b42" + }, + { + "type": "blob", + "hash": "3a4787bc6e2dea235020fde3aa37c9d14a7d61c9" + }, + { + "type": "blob", + "hash": "fae160b12fcc9b5c2b1a000393755905da8e5e4a" + }, + { + "type": "blob", + "hash": "f84df95749238d8d390adb75ba21148072b8166b" + }, + { + "type": "blob", + "hash": "659fc19cc52a6ad1368d50b69ebb6cd85d1457d3" + }, + { + "type": "blob", + "hash": "045303fc8533512923dfbb8dc53d723241a7c2be" + }, + { + "type": "blob", + "hash": "f81d4b967a8995715f0a1dc34bd8a855880eb805" + }, + { + "type": "tree", + "hash": "d425919dfa0a123a2d93946727fe94b1a8cae6cd" + }, + { + "type": "blob", + "hash": "16c31c360e27d2865ae0752f91bb758182ffab4e" + }, + { + "type": "tree", + "hash": "1bcfbb76924188f3962fdfa0d4c4b3e79e756870" + }, + { + "type": "tree", + "hash": "2744a5286dbb6407e74eff5453a060f00d93bbf8" + }, + { + "type": "blob", + "hash": "f48371e1bb804d1051396b1ae3d5a7604bbd23cd" + }, + { + "type": "blob", + "hash": "a35db9b050c36cea146f7180f9a15663b246b5e6" + }, + { + "type": "blob", + "hash": "5964b76b5d6bf1a327a2108a7dad14260bac10c4" + }, + { + "type": "blob", + "hash": "dc973fc51554857c8be947b46d85ccf187d1ca53" + }, + { + "type": "blob", + "hash": "c80a2833d5641ef364156578a1d11fe17bf21a57" + }, + { + "type": "tree", + "hash": "336c8bbcd8a65461b41322ecdd807e50740b2091" + }, + { + "type": "tree", + "hash": "66b0caceeaf08bd46eebea46078407429621061d" + }, + { + "type": "blob", + "hash": "984b10550e226af03e166a4dbc4544ccc8eb0d62" + }, + { + "type": "blob", + "hash": "ad4e17ea72c43aceaabc49e05655defb115acfb7" + }, + { + "type": "blob", + "hash": "e0b7eb87341d1238b89c94ea71b53817060cceb2" + }, + { + "type": "tree", + "hash": "60b1e74e2ebe8a4af0ac6e95505a0bfca7da0e46" + }, + { + "type": "tree", + "hash": "8cfdac2ed535dd7775d9fc84272c680ffc080055" + }, + { + "type": "blob", + "hash": "52dbb03cce280ccc671e12028b70300fe08c9a52" + }, + { + "type": "blob", + "hash": "84a9eed80dac9feac98cc38e0fed472e5de958ae" + }, + { + "type": "blob", + "hash": "30b371354d6459bda096c8409828ac9a7ca7384d" + }, + { + "type": "tree", + "hash": "8b25fb5bef2d067f6b85c0d755d8693aa0f6141c" + }, + { + "type": "blob", + "hash": "4dcf3e680f3b642f5f34f22c92e461b95de92c7c" + }, + { + "type": "blob", + "hash": "5fe4f0f0e1d3fbf7ff344d9143cd13eb44a4e483" + }, + { + "type": "blob", + "hash": "62bd76d3b6e8686e22bc7e89530bb98c5ddc2712" + }, + { + "type": "blob", + "hash": "d3665b9fd5ee208de6dbda5202fdce4dcad54876" + }, + { + "type": "blob", + "hash": "bdbea4903f88b8a9e2d16847e8635c77f1e74166" + }, + { + "type": "tree", + "hash": "03412db2602e86ae42d970806c8f5c5348c75e62" + }, + { + "type": "blob", + "hash": "d4db3b8237b80785f1d4e725a271ff3b3550ec74" + }, + { + "type": "blob", + "hash": "b5a7fbf3614925de707f0dee64cfff18abc13fcf" + }, + { + "type": "blob", + "hash": "080a723566461091e7201d3d53d184e6e4f333e7" + }, + { + "type": "tree", + "hash": "e5a4e9dbf1026e0cec3f11efda03eb581c576168" + }, + { + "type": "blob", + "hash": "075240dae0c7789b5fb3e2e1e291b8e10436bda1" + }, + { + "type": "blob", + "hash": "91e143ddd781e156bcee573769bea9f8fb997a2f" + }, + { + "type": "blob", + "hash": "f9d3906c5f0c22b802a45e30f49bfd7fc0945317" + }, + { + "type": "blob", + "hash": "33723c17340b9e60e585f117259e7a571823d84c" + }, + { + "type": "blob", + "hash": "006cb85e1bd615cf51d616028c1696ccf600f0a6" + }, + { + "type": "tree", + "hash": "9646dc6ecb8cadc2164c458a19d99bf8b2030a53" + }, + { + "type": "tree", + "hash": "b8a02c1ee71d92245589d84a514b47716df93f0e" + }, + { + "type": "tree", + "hash": "9e7ea6aafa8fb9ca9ba5da3b3d958e05853202f2" + }, + { + "type": "blob", + "hash": "10eb800f331ed1f4c2cce9c3197d39584f4083c3" + }, + { + "type": "blob", + "hash": "3ad510d0369f2437565a5ff1f9d290b1a2457cc9" + }, + { + "type": "blob", + "hash": "9d8754ccf8ac41402805b81c29a5f36a14bfdd92" + }, + { + "type": "tree", + "hash": "266fb91416c96157420d3ca1067d185920537ac3" + }, + { + "type": "tree", + "hash": "2d8a9560b5de6e53a6b1af27498deb53a5ce2aa0" + }, + { + "type": "tree", + "hash": "e763a039cd2c7665b0fe2489e5caed85fdbc5375" + }, + { + "type": "blob", + "hash": "eedf7f189ad6adbb5ecfeac13663b02599161552" + }, + { + "type": "blob", + "hash": "6138cefb2a8bc236153a8a09e9f77449043f310b" + }, + { + "type": "blob", + "hash": "0cb9b555b36ec3fabcfa75f90964d2c9c88f0ac8" + }, + { + "type": "blob", + "hash": "af60638ed52b8d94d7fa157a63cff5a19018b17e" + }, + { + "type": "blob", + "hash": "46843c27e4ebe65207526676bbb16931f44d0c71" + }, + { + "type": "blob", + "hash": "206e319221fc643db22c9950229eeb4a5bbdbe0c" + }, + { + "type": "blob", + "hash": "43c44ed3aeba36f4a421770da646cc92ca6aaa64" + }, + { + "type": "tree", + "hash": "43f60c49ceef2fb4f024a8a9fdb6a70e9a7d370c" + }, + { + "type": "blob", + "hash": "c1d90961ec3e6289ad8644f28cc676e78c011e22" + }, + { + "type": "tree", + "hash": "22ff247804f9d881fb1f60f4471bd86aee4807b0" + }, + { + "type": "blob", + "hash": "7eb7e36ab9d93609615953620ecdad5929c4876c" + }, + { + "type": "blob", + "hash": "266af48548bba58244d790165271210b9f45a59f" + }, + { + "type": "blob", + "hash": "9fef932ea1836d8238b43c775b630e0e3c24d7ae" + }, + { + "type": "blob", + "hash": "c5d3d764eeb8a79afd9e87aadcbfde834dbd7a92" + }, + { + "type": "tree", + "hash": "14e0bf8f72cde4eb402f31a6899c2abf4963a7b4" + }, + { + "type": "blob", + "hash": "a4d6133ddf21abfad0e2da0e4e16bc9057d8a830" + }, + { + "type": "blob", + "hash": "ae0b668e1331a85ec26ed681f79b6dbd5573958f" + }, + { + "type": "tree", + "hash": "7fc7a12b77bcf56b5d4428ff03424e7c51b9e7a3" + }, + { + "type": "tree", + "hash": "adeb0b98f20643ce966402024b703d344ef1a8e6" + }, + { + "type": "tree", + "hash": "ae3a619a897a80e770ed8907926b9e028ca51cff" + }, + { + "type": "blob", + "hash": "84b010513de4f3a6b917986a1e5014fa0a2aeb13" + }, + { + "type": "tree", + "hash": "947ef32d770ad73bb31d05cb379dfcd49dc8fb01" + }, + { + "type": "blob", + "hash": "7cc6223f5a158570596c86d42a9770438470e323" + }, + { + "type": "tree", + "hash": "08af5dbe3f452cdabcf63ece2f475bb7217a586b" + }, + { + "type": "tree", + "hash": "3908e9102039763702d8236ca57337f08d01dd21" + }, + { + "type": "blob", + "hash": "6ee542b66bd31624f2132ff9eee3448fd9a0974a" + }, + { + "type": "tree", + "hash": "6cd31fcedec9a37168559635f8ec592b675cb577" + }, + { + "type": "tree", + "hash": "92703c3312f9ca3f9d89c6d392904b9852bfb9ea" + }, + { + "type": "tree", + "hash": "b26643c31d7d51653eef532126a70300e0ce8b2f" + }, + { + "type": "tree", + "hash": "b361910c3509c91ac14ff4c084e912f0bb39d96d" + }, + { + "type": "tree", + "hash": "d9401120c01f6de0e54d81449b11dc500d44596c" + }, + { + "type": "tree", + "hash": "fa0d0c99b69218f4129a1e582b7805cce991a154" + }, + { + "type": "tree", + "hash": "00ea240f48e075ef0f1078ebff8c44d694b9b021" + }, + { + "type": "tree", + "hash": "758575a62675e2860b482d8e53e97b9914ac1a30" + }, + { + "type": "blob", + "hash": "dfe8683fc4b5a858a483d7d03acf9e1daa631e3b" + }, + { + "type": "blob", + "hash": "0c188e66f802f292e6a458b2433341f58e691df9" + }, + { + "type": "blob", + "hash": "ae8c07ea8641420b38534f3cf3c8a823cdacc2f7" + }, + { + "type": "blob", + "hash": "7d81353f94beeafab215b2d3d088bd9ebbc4a12e" + }, + { + "type": "tree", + "hash": "2c2dc02159409933cfdcb73e987f7b314601ecff" + }, + { + "type": "blob", + "hash": "d98972767ddbf3bdf0c6bf38022f54478d6f0238" + }, + { + "type": "blob", + "hash": "923125d83488ef62070a0c540e0cc6544d2d4d63" + }, + { + "type": "tree", + "hash": "0b502646516805a579b26833adc632c380044559" + }, + { + "type": "tree", + "hash": "358d393b551fd0ab06e56d5a1b62dfd6e7bdfa70" + }, + { + "type": "tree", + "hash": "1b15e66d05c0be7fffe0cf21218816bdf8bac139" + }, + { + "type": "blob", + "hash": "da94966138017316d70ffd631388cf55bb4e9678" + }, + { + "type": "blob", + "hash": "9910f41203d50e1b778a03f5f8c4a1eaff3cfe7c" + }, + { + "type": "blob", + "hash": "0920bd779c0d1072942a92d5c64412d87f3c1b3a" + }, + { + "type": "tree", + "hash": "5506ad99195834528051ee653fad5cf0d683460f" + }, + { + "type": "tree", + "hash": "840522f31ede75c6d7cf5886ad04d7a1280ae221" + }, + { + "type": "tree", + "hash": "8e59435c44a3bf452acb163d31988e101a5b31ef" + }, + { + "type": "tree", + "hash": "a604eda90e9041ef02086025ef94225ebaf1296a" + }, + { + "type": "tree", + "hash": "b4e600126475230c8eeeb519d969f12757a4e4e2" + }, + { + "type": "blob", + "hash": "1508c8ba7a1964ca7d8bafc6735b129b2e85afba" + }, + { + "type": "blob", + "hash": "663fe19ce12dba5750b85b716c9b652aba342317" + }, + { + "type": "blob", + "hash": "1f427d58ec117d3e6eefcd249fe21427bcfa009a" + }, + { + "type": "blob", + "hash": "27cece3996b4769887b389243ee48e00464c0f51" + }, + { + "type": "tree", + "hash": "cb4e275ff7135b7df3e829963d58af8384a5affb" + }, + { + "type": "tree", + "hash": "fa21efd6fe4193713f0fa8804ad4684dd573ca84" + }, + { + "type": "blob", + "hash": "7242010b26fc662c8dce88aac81eb63952174d55" + }, + { + "type": "blob", + "hash": "379dd108b1645de8bff38d924f669f294c51ddb9" + }, + { + "type": "blob", + "hash": "f67336cafdc9c78fcf405c9bf4f1192f513d2dd3" + }, + { + "type": "tree", + "hash": "15233c85a345ebd7dedc0d8fe5dd12c67cedb074" + }, + { + "type": "tree", + "hash": "18c7a2fe51640ac9a11140cc5d513c5564e8ff0b" + }, + { + "type": "tree", + "hash": "3287e32b3d116a8c0bf5bed74828334c2dfd8508" + }, + { + "type": "tree", + "hash": "7fd8951e60ec93ac4d4b427198bb44dd16811091" + }, + { + "type": "blob", + "hash": "16ec3a48c88363383fbb98a5a5fcdaf0ff1f0da5" + }, + { + "type": "blob", + "hash": "01b94df7a5e6ec4b589b9bcbc7f405bfb73d1435" + }, + { + "type": "tree", + "hash": "3c47532379e95a611b54053a73ea00b076125699" + }, + { + "type": "blob", + "hash": "b97af551fa459dbbacfe0018eaa6ae0b57abde62" + }, + { + "type": "tree", + "hash": "9f59c9c10d66403e851ab7cba0f9805588f5aac6" + }, + { + "type": "blob", + "hash": "5859b2bce31e8975cc9d30e869aa35103bd41a6c" + }, + { + "type": "blob", + "hash": "bf14ada067386250e33f18a4e2d90f9522f71fc4" + }, + { + "type": "blob", + "hash": "10d752f7407b9f73a73263f54eaeaf031ab812b6" + }, + { + "type": "blob", + "hash": "b4d24c6dc3e7e1aad3afe1f4d23b10f54850eeda" + }, + { + "type": "blob", + "hash": "d417c0bd612927246c498e92b82a7bbb2d618a6f" + }, + { + "type": "tree", + "hash": "f8173c3b403731b45c8b3aa0d89cfbbf61d09547" + }, + { + "type": "blob", + "hash": "26dfd47ed8515da9c87a5e2c4dc065959215bea5" + }, + { + "type": "tree", + "hash": "abc70aba65ac23f75e5187c5d38feb6df90de335" + }, + { + "type": "tree", + "hash": "a1a7db8951b0a7bfc49705c5732b8c9769785e42" + }, + { + "type": "tree", + "hash": "94f5d484c6051c6a2284a0f69c28becad33d93a0" + }, + { + "type": "tree", + "hash": "04dbc5a3e0954080337afb9dcef397e6fb1ee3c2" + }, + { + "type": "blob", + "hash": "ecf2d03d4be13422294293045b4b7d7b4d0c6ad6" + }, + { + "type": "blob", + "hash": "e5f68a8fd7ee255c028d72079af38b9f912c6523" + }, + { + "type": "blob", + "hash": "8f03590f3545484915d68329f390a305688364ca" + }, + { + "type": "blob", + "hash": "c7eff68310835d8e842f99b5eb7dee33eae1caef" + }, + { + "type": "blob", + "hash": "2a771b511f4fa38d220865082d1fe51e961bab63" + }, + { + "type": "blob", + "hash": "f0910a6c69e393ed97e5476d999998d46f6ee493" + }, + { + "type": "tree", + "hash": "86b8599b333b8384c0281f95f36b84ad2fa3d9f6" + }, + { + "type": "blob", + "hash": "eefeeb4a0b31a89bfb033294d9fe68ce509f9aa3" + }, + { + "type": "blob", + "hash": "f159c9705746b73ed2112c6bd27caf69f85ae6e1" + }, + { + "type": "blob", + "hash": "95168790ff1a438a8a6e70a59e395e0ab00da239" + }, + { + "type": "blob", + "hash": "6c84af0301df6bd5fdfc07dfdff5bf92ac023ba1" + }, + { + "type": "tree", + "hash": "3e2342f8e5a6224eccf7925abcf6cceef6647cae" + }, + { + "type": "tree", + "hash": "745819a08c4f10e5179c73cef123369e101a751f" + }, + { + "type": "tree", + "hash": "7f833ad2e35823732a3c9be27b3787cd7b2e4ffb" + }, + { + "type": "tree", + "hash": "13cde31f23862624a3bccccb1826eaa0397b5cb0" + }, + { + "type": "tree", + "hash": "f59b9b1ad79ab51082f8db2311c855696f3eb7d9" + }, + { + "type": "tree", + "hash": "8595636c003e239748ded99d0f0e96c792f8be8b" + }, + { + "type": "tree", + "hash": "57ec8455997a2da038b49654932f11c7387487a5" + }, + { + "type": "blob", + "hash": "df1f6dae0155edb592b5fac73e3c2a7da947aa5e" + }, + { + "type": "blob", + "hash": "b00898f759c7643bf50efd9fbca7acbf08cdce85" + }, + { + "type": "blob", + "hash": "608c79f3bc42f6624efd6a2a9a252047d38a1761" + }, + { + "type": "blob", + "hash": "6a68ec24a6fcfb5ec1e42eb9a8c0903dacbf170e" + }, + { + "type": "blob", + "hash": "1caf4b3e4bb9ec5c565cda05064f3117b7699d1e" + }, + { + "type": "tree", + "hash": "20caf5787906a36932dbefe8a88209e3e96e410c" + }, + { + "type": "tree", + "hash": "621073d66930b51aed661a6cd696d6dd80887106" + }, + { + "type": "tree", + "hash": "ec85f018cdf98db5fdd939bfaf8bd87936b8c088" + }, + { + "type": "tree", + "hash": "881dc1e40fffbb66e9ba0ee8728535af6c8cc1d5" + }, + { + "type": "tree", + "hash": "eacef5cd2bb35498062f32c209f1a286d5bb2cf0" + }, + { + "type": "tree", + "hash": "58c7f57173913412f860cf4ad79554970f37114c" + }, + { + "type": "tree", + "hash": "0ead863563eca137088d83c6b7d4363c9ca14bd1" + }, + { + "type": "tree", + "hash": "f9eadc989486b5fe0041454ff1049b87c63d7e5f" + }, + { + "type": "tree", + "hash": "6af87153f43e7e76c77b4c908b4d508bbfdc8258" + }, + { + "type": "blob", + "hash": "efab67c1dd9121b2ae80effa1759064aee9d6bed" + }, + { + "type": "tree", + "hash": "0d8b53ab0f26ed973ca8e865f71d1ce1c1eb16b6" + }, + { + "type": "blob", + "hash": "6092a9cc93ca303d2e4ad3b58588d3b30ca45efa" + }, + { + "type": "blob", + "hash": "000656ffd313f1f95d3eba18d8c5e8f16ba8ee94" + }, + { + "type": "blob", + "hash": "f95ed2330d40d49917ed4d2ba447b3df4277ef89" + }, + { + "type": "blob", + "hash": "7f8c38cbe5efedabb56c8a2e5f253bb23638155c" + }, + { + "type": "tree", + "hash": "00d88ae9c517c77c70a728b0c62db2ca01326784" + }, + { + "type": "tree", + "hash": "e498075b251e0565493711cc39fcf2d1acdbc5c8" + }, + { + "type": "tree", + "hash": "e172658034e7c1fd14ead344a414662cf92da3ef" + }, + { + "type": "tree", + "hash": "e0ba0265cb4250f18315b3c37ccc0ae21bde5b93" + }, + { + "type": "blob", + "hash": "f187fffa9096db905b8795b70ffab89f004705d9" + }, + { + "type": "blob", + "hash": "e92305b4ffa044d4bb7c3c3cd06cd26aa099923f" + }, + { + "type": "tree", + "hash": "50689ef30375c5eb44997124d627b3725c0c75b5" + }, + { + "type": "blob", + "hash": "a6e84316c0c18837d7bccb7c6f05e96216f3e7dd" + }, + { + "type": "blob", + "hash": "ebf3fdc445ad21af870e9dc0ef9c2b4d0df67d94" + }, + { + "type": "tree", + "hash": "69e52a4035f3f53959563887b848380334b12ab0" + }, + { + "type": "blob", + "hash": "46700342829d55bc235cf0f424e3f95059851f80" + }, + { + "type": "blob", + "hash": "40df004718bb38f0eaabd0ca2b7dc0fda1dcc108" + }, + { + "type": "blob", + "hash": "2a900d23cecbb64115a9072d52cb3861c0a2f0a5" + }, + { + "type": "blob", + "hash": "064a7ecb2fe23d607a876b11c756ea0418bf6abe" + }, + { + "type": "blob", + "hash": "a5c9d24b80de31292f826768da77cbd768857d4f" + }, + { + "type": "blob", + "hash": "03247b2a0970e61b82bd4d348da6ce6e862149ed" + }, + { + "type": "tree", + "hash": "f12bdf632d89b4e602dd30816eb086483e0deda5" + }, + { + "type": "blob", + "hash": "bee0472cb063a08f112f8e94394bace6ea49af44" + }, + { + "type": "blob", + "hash": "a7941a47905f977f636870755c0ed1230d3361d6" + }, + { + "type": "blob", + "hash": "6dd35cb2a32b42377924380c156435e05ded970a" + }, + { + "type": "blob", + "hash": "3fa55ed737934af7c4b45af2b2c46a1582afda75" + }, + { + "type": "blob", + "hash": "e867513eaec9774e77ce7a0d0a3a100da39fd4c4" + }, + { + "type": "blob", + "hash": "246d0ee33dac88f9e19d22f13adf9b6a9d7d3b61" + }, + { + "type": "tree", + "hash": "479cc48fe2e0a4381bd58efbd396a492df657089" + }, + { + "type": "tree", + "hash": "f0063e321c5df53b98fb94d8052e77a6ca164823" + }, + { + "type": "tree", + "hash": "65273ed7c89eca41abf0c77cedb3067ba5f13c49" + }, + { + "type": "tree", + "hash": "aa804fa3b39d47733e2433ab7f937a9d38d68f65" + }, + { + "type": "tree", + "hash": "c49e1c28294e1839238626af3d00e0b95e3f6118" + }, + { + "type": "blob", + "hash": "a8c2423de8d73a4fb6791980ccb1541cb6c0f528" + }, + { + "type": "tree", + "hash": "cf3eadd177fc90100f6bf7368eb56f826ae56f04" + }, + { + "type": "tree", + "hash": "0807acbcb175957cb4864f9128ab612e01f51159" + }, + { + "type": "tree", + "hash": "25e07c5274647ee6b992ce6f01e68a5fd0e4d1df" + }, + { + "type": "tree", + "hash": "f82d6658733b3090f341a0506503e81ca7919931" + }, + { + "type": "tree", + "hash": "acc40391b082640a17835d5bfdd3d3267ce44982" + }, + { + "type": "tree", + "hash": "0752680163c876de28013a8f94cc8b0a32da6cc8" + }, + { + "type": "tree", + "hash": "84bb216287e508927daf6fcb7e6c31e42818925b" + }, + { + "type": "blob", + "hash": "a9e91c1e09ee76e3c1779e471bec411cc68b8053" + }, + { + "type": "tree", + "hash": "d43da7ab22f4e5d47112b7fd0b5a8fe3b43e3006" + }, + { + "type": "tree", + "hash": "10fef892e0b5a71bb224de001a5f686e3874d48c" + }, + { + "type": "blob", + "hash": "11f1954943b7614cde6ddc31fd0069ab87139b0a" + }, + { + "type": "blob", + "hash": "b7c0c336a2e1857321cf375d7dc9e973c3040a38" + }, + { + "type": "tree", + "hash": "d9cce5ef008bae78da22c85f55c82d0531b2d00a" + }, + { + "type": "tree", + "hash": "8d86e1615d5a9479e00316729ff172d38a77ddba" + }, + { + "type": "tree", + "hash": "386d3a9542a05348531cc81a5b634780fae99b13" + }, + { + "type": "tree", + "hash": "fa259ad0b8109d48cfc58df90121cbf7941c0a35" + }, + { + "type": "tree", + "hash": "297e8085809cb7c7fb582fd1823f040d5ec5c5d8" + }, + { + "type": "blob", + "hash": "d15b8297ff250dc348b77079d57c141044800112" + }, + { + "type": "tree", + "hash": "ba53820c1fdb6f65568a53747620acf420d77075" + }, + { + "type": "tree", + "hash": "81023a0a50b1165269a3a811158afad30b8e6c56" + }, + { + "type": "tree", + "hash": "9ec4e207902965f9cd3def7f9ce2554dfb82713e" + }, + { + "type": "tree", + "hash": "3c9292398e066cc4092f6dde22c0d46381977e38" + }, + { + "type": "tree", + "hash": "931a4d9c525366fb9379a7c6312aad9ded5d5bda" + }, + { + "type": "blob", + "hash": "1016c625d6cf5b8c6d8a804118e5f8008d57443a" + }, + { + "type": "tree", + "hash": "caf4c9f82ba2b206cbb0488749c963e3d762d080" + }, + { + "type": "blob", + "hash": "1778ba680ed58d1a69e66805466a585163f057e8" + }, + { + "type": "tree", + "hash": "cc2f91e62ee4165a20b4fab331896c6d17766e2e" + }, + { + "type": "tree", + "hash": "8cbfda2571baf920cda105be7adf1e43e484a887" + }, + { + "type": "tree", + "hash": "ad7ca21282bc7f92f91d02b83ed45d932c7929f6" + }, + { + "type": "tree", + "hash": "e68b2c9a74a04566f45e84dd4549f45215c8eb7f" + }, + { + "type": "tree", + "hash": "2e544c3e862d603fa57e3c99e517edf2b57a6049" + }, + { + "type": "tree", + "hash": "d5bb14cd9e9e032a03d4940050b844894af2b900" + }, + { + "type": "blob", + "hash": "e9774e7ad2d0ae2bae389198d85c39eeca9d089e" + }, + { + "type": "blob", + "hash": "77062f022102c5a1ee1617946ba4896b51ded9da" + }, + { + "type": "tree", + "hash": "57a02f6944d40a9271a1f6ac6d815aae91d2f5d8" + }, + { + "type": "tree", + "hash": "d8b269d3f32298c3763663dba3f07003a315f360" + }, + { + "type": "tree", + "hash": "018af920d7170bf00c05bb5c1a04edc9240aff4a" + }, + { + "type": "tree", + "hash": "e9e5dec9fb662c7712d149a535622d17120b56cc" + }, + { + "type": "tree", + "hash": "cf6b7f7375a93e06b888c891997e040febd75e91" + }, + { + "type": "tree", + "hash": "087695aeb2895d67817a654e68985499d618a8b8" + }, + { + "type": "blob", + "hash": "72d0b5c38cec5264272e6c1eca6c4a1a609bdf7a" + }, + { + "type": "tree", + "hash": "10b40eb05713832a2af9d70a67fee7e6be25063c" + }, + { + "type": "tree", + "hash": "a380783ee02bf5f91e0216c1a49a19e0508f1748" + }, + { + "type": "tree", + "hash": "d5552a9ad1fa6c6dd951845b765d028d3b495848" + }, + { + "type": "tree", + "hash": "aaceeee7a55a61a0b303edbd753872a353339636" + }, + { + "type": "blob", + "hash": "80f6276ab34f456d092de0a511b17d16c03be7bd" + }, + { + "type": "tree", + "hash": "b9ef790fd39bdd7f40bdb307268344c987f33184" + }, + { + "type": "tree", + "hash": "08869b9fc7bd47ff290fd8f562d030e5872d7147" + }, + { + "type": "blob", + "hash": "895c4b0c8c2505a7541aa9b72ac84215a81ebc43" + }, + { + "type": "tree", + "hash": "bc554961aa93d9a0696108df5e2bb4a9b47eda2d" + }, + { + "type": "tree", + "hash": "3c6a1b376507b0d0008d2508ceae1f2f40fbee33" + }, + { + "type": "tree", + "hash": "96e82fe3412fb54b9af69c0dd1f00dba053c3c75" + }, + { + "type": "blob", + "hash": "1434efa0379a8ee896602280909a3d82e27d7955" + }, + { + "type": "blob", + "hash": "9752a88b9a8007fea0405b2adc6d0ed1e3ba80ea" + }, + { + "type": "tree", + "hash": "ac6e6031183d8e8f462568d1c0838ace51a83050" + }, + { + "type": "tree", + "hash": "777b07498ba0c638247c80ddd222224fb3d87c50" + }, + { + "type": "blob", + "hash": "92ab2abd5c842625c67d78f25489dfbf3861f0c7" + }, + { + "type": "tree", + "hash": "e557e02d34e0b7efb7b9613e949816d84ae4efe0" + }, + { + "type": "tree", + "hash": "2676a80dbd2e10f4848a07d36f6c151beba9a1b0" + }, + { + "type": "tree", + "hash": "39b6d07916610440a205fb919d03f5bc6e306139" + }, + { + "type": "blob", + "hash": "b85f2d311d68c191dd9cfbe7de89cfeae9a587d1" + }, + { + "type": "blob", + "hash": "52e2f0998280e205dca20d68822adba011e5425e" + }, + { + "type": "tree", + "hash": "7b8e8caf553b04017ae7e913a09fac7f9a8cf8d5" + }, + { + "type": "blob", + "hash": "f40f188fdb8f7443818a042c1758c82eaa5cbd69" + }, + { + "type": "tree", + "hash": "29893a8e7ae3d6f6bf65e9824229c91e77ee6a64" + }, + { + "type": "blob", + "hash": "0e4764b0437cc7e1300541a930d07ea7921fd393" + }, + { + "type": "tree", + "hash": "2e8209638ee3cb370cb180ebebd516cfa04ed919" + }, + { + "type": "blob", + "hash": "13cced1be708f32c4320cfe7afe69e9a81439f4e" + }, + { + "type": "tree", + "hash": "9f053b4cef3e9495a4e9c608242bbe8775867bfd" + }, + { + "type": "tree", + "hash": "91610c967f8c22d6c8d9eba906b04e645510e813" + }, + { + "type": "tree", + "hash": "7ec04d9940a4c71496489475f4539cbfde4c9259" + }, + { + "type": "tree", + "hash": "f25c5957f9f396697948fb9846ce4c9e803bc92e" + }, + { + "type": "blob", + "hash": "a1ddff3259a6d95d263d6a75d359537c9f26f23d" + }, + { + "type": "tree", + "hash": "33ae57aa9c0cc1e6b13e64101404084deb50094b" + }, + { + "type": "tree", + "hash": "6fe872a216a7d2696875fd92f97bc9aa336440b1" + }, + { + "type": "blob", + "hash": "03ceb44da8dd8536a8f25e5c2c5b3d9496d5aee8" + }, + { + "type": "tree", + "hash": "77f528bb793930fa87f586ad6a8d302c561a99a1" + }, + { + "type": "tree", + "hash": "3a47f4a3f704c77128c4677f243d524be31d9559" + }, + { + "type": "tree", + "hash": "80edbd89214f477a3135834dd1263722b390eacc" + }, + { + "type": "blob", + "hash": "e001073330b718c512ee8535bd0a04bd921c63a2" + }, + { + "type": "tree", + "hash": "08458c529810381582a9e66a2b9e08da11feabd3" + }, + { + "type": "tree", + "hash": "9c9e3310d45305d20a35708cca1d34a8af791512" + }, + { + "type": "tree", + "hash": "9ac7f132cda5801ab808cf693b9fa093112424e7" + }, + { + "type": "tree", + "hash": "2f7cd1f5d6669823f6199506e46aec8041af029d" + }, + { + "type": "tree", + "hash": "7eb684b68a4b2391b89bd94ec0c0b7e8639102aa" + }, + { + "type": "tree", + "hash": "7aef0cf00ccc98416384c7965c662472676dd9c5" + }, + { + "type": "tree", + "hash": "45505b6e22cce63336b7ab980b474744100541d3" + }, + { + "type": "blob", + "hash": "efc8c55d9b579aa5fcdd3612fb9cf305956fca56" + }, + { + "type": "blob", + "hash": "207767b31da36cf1599e4ab0302492fcaa200943" + }, + { + "type": "blob", + "hash": "5cb964654ab9698e2796d9c591c7618e921589c8" + }, + { + "type": "tree", + "hash": "c5d16e4ae8d1b2b8a594ad0409afc703d8f49f16" + }, + { + "type": "tree", + "hash": "2074981db65b6ac21f20f336922bb77f3a1de77f" + }, + { + "type": "blob", + "hash": "807a398697955bbead9e8301220fab278f18e9a2" + }, + { + "type": "blob", + "hash": "ad7cbbf96cb7d103a8fc9beefe2fb50ba0b64fb0" + }, + { + "type": "tree", + "hash": "7f340a3e0c0f3eb1f055cb7d2c6f012f564aeae5" + }, + { + "type": "tree", + "hash": "96a913cd6c51cd7cfde81fb9032da0219ab3936b" + }, + { + "type": "tree", + "hash": "e045804f29f49f3f224368b8cd9fcb41d706f47f" + }, + { + "type": "tree", + "hash": "d2eae772ab4d2f34f620d69d133701304a6f7a34" + }, + { + "type": "blob", + "hash": "4dd4ffc08d42f8de14db9a33c4288c99d9e681e0" + }, + { + "type": "tree", + "hash": "1915da063e5a7748e3068a001272d2db2e1fe1a2" + }, + { + "type": "tree", + "hash": "f6f555b3a0e1c3c4144a7295ccc46f389af165af" + }, + { + "type": "blob", + "hash": "b3404c3873757b94f5e4005f4a31dda3e5f0d605" + }, + { + "type": "tree", + "hash": "c2938234727637a3a56023a5c2cf3099b4557d16" + }, + { + "type": "tree", + "hash": "4e99b6a5192c24fd4b336d63d17aaee7f289abd7" + }, + { + "type": "blob", + "hash": "8bde4352c84c1c734862b8cc00e9c50eddaf989f" + }, + { + "type": "tree", + "hash": "150909e6c47ba06ca9c6f904c84815ea446b5f09" + }, + { + "type": "tree", + "hash": "e6d2d86777a63fb90ecf8ba8c4389bb7fa428851" + }, + { + "type": "tree", + "hash": "9e99bdd1c595ec3e80039caa525969ca945a7c4e" + }, + { + "type": "tree", + "hash": "1c7003e6b4e6dec078ae12d97c918171684b1a3b" + }, + { + "type": "tree", + "hash": "da20143e18114dde965317f47cd7d37028777131" + }, + { + "type": "tree", + "hash": "37a9bb6f756a1b6788da318d48bc5392aca93691" + }, + { + "type": "blob", + "hash": "0dc1ce45b89a5a411321d77e57320ef5ebbb37e4" + }, + { + "type": "tree", + "hash": "25b521cf7999dd84f43b4ef63a601103b299412b" + }, + { + "type": "tree", + "hash": "faa56b5c14618ae7a28f0670deeba17339063d6b" + }, + { + "type": "tree", + "hash": "2f3a53b649e8c159e29a1a2aecb462fa6bfa45cb" + }, + { + "type": "blob", + "hash": "8cb3d548f33cc6ae17841723faedf4685d6fc476" + }, + { + "type": "tree", + "hash": "dae03e49ef4f942583835f6633c950893e6405bf" + }, + { + "type": "tree", + "hash": "e1533349260283123e8f72a3a5be0acb719bb91d" + }, + { + "type": "tree", + "hash": "78df54e8fc29fdf9de80dde6675a1287d7af31aa" + }, + { + "type": "tree", + "hash": "dd0190dd5e4e42b94bec75c609e88d1799aa042f" + }, + { + "type": "blob", + "hash": "7bbfba2fcce8dbc2f452de4e36b10b650df08545" + }, + { + "type": "tree", + "hash": "2462b42c3a2d808dccff9220387b46096efda49f" + }, + { + "type": "tree", + "hash": "1b74f4fcb948243c76d329dd796a6b2affbeaa4d" + }, + { + "type": "tree", + "hash": "bfc9c7503bd50ff2ff6183e11fc84fb3aa6e352c" + }, + { + "type": "tree", + "hash": "50a048f27ec951930f406b3526cbced152273055" + }, + { + "type": "tree", + "hash": "b7709c403c0bc64764dbe1e5bdcc81a395e1bc71" + }, + { + "type": "tree", + "hash": "df100a2f0e517b5865133d45a477db09490a1a63" + }, + { + "type": "blob", + "hash": "7bb107395ac7f5493ffbffdca01d91c6da7907d5" + }, + { + "type": "tree", + "hash": "00062b221f769c212699d3805dc82afb5d1f367e" + }, + { + "type": "tree", + "hash": "02bd6e113d23aa24603fe6e9e0c3e4122b948571" + }, + { + "type": "blob", + "hash": "5d9bac6110481e086199fa01037bbbeddc8b0231" + }, + { + "type": "tree", + "hash": "c76655f0ccbf0a143a92d5487f6cb57f2088a3cd" + }, + { + "type": "tree", + "hash": "15ee88d19c70e36c502f61460c6834129f73c924" + }, + { + "type": "tree", + "hash": "f8e34d439748bdd0e2d8e60e3cee9d8f8d80806c" + }, + { + "type": "tree", + "hash": "2e71a99a5c720ec5994ba02f01985c56abe494f8" + }, + { + "type": "blob", + "hash": "3d9738e14e767d520be35dafa55e1a8b554a2dde" + }, + { + "type": "tree", + "hash": "07a6a6e2f93cd2b2c99c72a8ca0ced4a67b7551f" + }, + { + "type": "tree", + "hash": "8f9723925d158e78c3871030b6b0e500300d7eef" + }, + { + "type": "blob", + "hash": "3746449ad54fb7a13b739da8ba81cd3755e7bba7" + }, + { + "type": "tree", + "hash": "41b46707a9cd1e77882c8832cf7bbae53c0280b4" + }, + { + "type": "tree", + "hash": "18a9d1cae8dcd2799ab9b972870c922a785cc8b7" + }, + { + "type": "blob", + "hash": "731d3928caad21077cc7fe4ddf5f66819d9a4b07" + }, + { + "type": "tree", + "hash": "428107a3ff4ec58ebbc89798455809cf124dd1fa" + }, + { + "type": "tree", + "hash": "67da0a5df309a8c6a9ff8ec0b1d56562a37c694f" + }, + { + "type": "tree", + "hash": "865559b02b6db33f1e4a48e47b713dce20b4034c" + }, + { + "type": "blob", + "hash": "61f70fdad87f6aa4f3167465a75b25d398e1fd86" + }, + { + "type": "blob", + "hash": "14081e89308021b5473fc68a7173678ebecfd794" + }, + { + "type": "tree", + "hash": "4165278c25ea1500d3c9ffde94e57f0655dfda07" + }, + { + "type": "tree", + "hash": "8c8a548af2ae6c8df2f8bd65a5597f938e8073f3" + }, + { + "type": "tree", + "hash": "2acb215240e445d1f75b2558e52c48c7ce2fcd5c" + }, + { + "type": "blob", + "hash": "59bef34ef6a459edc4c3e4110ba34c598fdffc14" + }, + { + "type": "tree", + "hash": "1d7912c7e2d56ec307a4ba54c7199271070603c7" + }, + { + "type": "tree", + "hash": "7c4de3bc814484feff1d61a4579465a6ad37cfec" + }, + { + "type": "blob", + "hash": "47a7d06f8df77377de9edc39501c67c3d5f3ecd8" + }, + { + "type": "tree", + "hash": "29cb26e91fedf134a7f681e93977b4d1a82bd988" + }, + { + "type": "tree", + "hash": "0785196a2e5bff9edbfd724dc339f4433257200d" + }, + { + "type": "blob", + "hash": "c52221e9fd47a85e4610741f1d5bdede4f2c6e6f" + }, + { + "type": "tree", + "hash": "5c476220e14bd9cb9d717ad6c57ccff383a45598" + }, + { + "type": "blob", + "hash": "143a5c2ad46a7e62951a619110e84a0538d7eaa1" + }, + { + "type": "tree", + "hash": "9f2e218fcb2546b9cddd53a5925386943aca8926" + }, + { + "type": "blob", + "hash": "6fb0381aeee93ce44946144b7993e05ac303d30f" + }, + { + "type": "tree", + "hash": "437c4e38435477886afab4255e8f53edee8c4e88" + }, + { + "type": "blob", + "hash": "1512a9c208614459b1c38ec5d354d42ba73d0ae4" + }, + { + "type": "tree", + "hash": "0536fe4eb51da7651c1d685edac6ec7f2426ff73" + }, + { + "type": "blob", + "hash": "2190bdac558147240950f9d9d67342f2b1e78f83" + }, + { + "type": "tree", + "hash": "a860a6471673e8da04880de5b2515a8654b19bce" + }, + { + "type": "blob", + "hash": "a02fefa80244361ffab72a47d3549f731f328c8a" + }, + { + "type": "tree", + "hash": "5a7256a8627b0d78cde03829a302edddb39b6b22" + }, + { + "type": "blob", + "hash": "75538d5fa5e86821bfb219152689cdca452a7902" + }, + { + "type": "tree", + "hash": "c59f7b3181dd847f9908afcdf8b7e678504fa08e" + }, + { + "type": "blob", + "hash": "ec47b509f112f19d2e527f0e07f5f33a1645206d" + }, + { + "type": "tree", + "hash": "22f21d2aabd46086bf2a20e84ba7929412860ba4" + }, + { + "type": "blob", + "hash": "ba196148070c639c47cca95953d445a4a46ef0cc" + }, + { + "type": "tree", + "hash": "4030340d1224b027ebf5be8f677396988e1931fe" + }, + { + "type": "tree", + "hash": "50276ffe3395a6251c639150266c07634f40a703" + }, + { + "type": "blob", + "hash": "9e2c790004a925a0db344bf0c1068541d56e659e" + }, + { + "type": "tree", + "hash": "1506c4d84a4860acc21dbaf763cac6125357235a" + }, + { + "type": "blob", + "hash": "72da9df52c883dabba7d0cb36c45a32104a35f1b" + }, + { + "type": "tree", + "hash": "e033ae782ce18f712f21ec27a71a779b727b4969" + }, + { + "type": "tree", + "hash": "f54906dbc3894827dfc057a73a75d17a6b01f52b" + }, + { + "type": "tree", + "hash": "db9eafd21c90d337d8893ee4fd1f60ec53e51fce" + }, + { + "type": "tree", + "hash": "8ea6fe82ab92c90035fff4481043089fa0b447be" + }, + { + "type": "tree", + "hash": "559c58781f70eff4746b9d986e45cfc601cafa51" + }, + { + "type": "blob", + "hash": "2b9594a33486c0d996833c24a41774d0f4061fcc" + }, + { + "type": "blob", + "hash": "31cc1027ca61db7ced2ef502e6ca0a1577992449" + }, + { + "type": "tree", + "hash": "445eee899ead06b24fc7485a9dae9c6cf782a2d1" + }, + { + "type": "tree", + "hash": "a592da7331690bbfec6ce025a166613e9df4d5a0" + }, + { + "type": "tree", + "hash": "a268eb4057bccbfdda66c9abd71eb7112a0a1b20" + }, + { + "type": "blob", + "hash": "34639451769c06e546d40970876f5218a6c9165c" + }, + { + "type": "tree", + "hash": "9a7866b9c87e5f537a6d06b583414e7cca992ea2" + }, + { + "type": "blob", + "hash": "5c9ed349fa1644579c4a858fc6ec845a6cd5fcc8" + }, + { + "type": "blob", + "hash": "f1e7667233733867376b51b76180511629a9f7e4" + }, + { + "type": "tree", + "hash": "2a6b309526602b3a8ee59e825d5c8dd0b03eac2e" + }, + { + "type": "tree", + "hash": "dde8100105a5ee139be057195a5b09740dd2bd2d" + }, + { + "type": "tree", + "hash": "252c1f52b0379f9a9e2afa4a826167d7727a97f3" + }, + { + "type": "blob", + "hash": "de2e81649d8bba788a3a8edb9b6c9d9b884326ef" + }, + { + "type": "tree", + "hash": "1775b55d99eabf1e2002e67d7ee922f9007ad29e" + }, + { + "type": "tree", + "hash": "ec874767cfba3c635a970210a2d68722984c156c" + }, + { + "type": "blob", + "hash": "5ac33767cfab28b6499f051ec12f1742e9d93019" + }, + { + "type": "tree", + "hash": "29e1a8b386339b1bfd227d4a32de82d0065785b1" + }, + { + "type": "tree", + "hash": "3c0d7df6d6b167537da73f4a3e68685ed6314fbc" + }, + { + "type": "blob", + "hash": "6570dba4f6e7dbdc30c40592a0a2081d17bf7c8d" + }, + { + "type": "tree", + "hash": "58ea9aab465d9ebc4f65a706ac74e36f5d6d16b1" + }, + { + "type": "tree", + "hash": "d1bf672f3120307631b1a70315e28b22faaccf7d" + }, + { + "type": "tree", + "hash": "be9d24bac82b23e9bf93197610d67ed520b770d4" + }, + { + "type": "tree", + "hash": "811195d856c8da23df04aa0f1a92ef49348c6c72" + }, + { + "type": "blob", + "hash": "9b516f8e459c02fdf5b1581d8ee342a10598276f" + }, + { + "type": "tree", + "hash": "ee2b440e72648df85c0400f35d76a01912326dc7" + }, + { + "type": "tree", + "hash": "8c7f888ab36b75b8225c02ee73a2a213c524c5b4" + }, + { + "type": "blob", + "hash": "54a032caec1092685ca86be2802703db778772ed" + }, + { + "type": "blob", + "hash": "72d333e127d5adc4e1cf989553b0132b82c760ee" + }, + { + "type": "blob", + "hash": "072a130735aedbc9ca20edb64da89ce72fe8515b" + }, + { + "type": "blob", + "hash": "7856e90d8a206ba75ccf1f6e78be6c9be4726844" + }, + { + "type": "blob", + "hash": "b69f10da56376cfa6a278e2d49fb76b4bff28cfc" + }, + { + "type": "blob", + "hash": "2cf28262648a8399e1ae20ed62c4ec4ee52808d7" + }, + { + "type": "tree", + "hash": "767d79de9243649e928a87b053a6246550c20572" + }, + { + "type": "blob", + "hash": "5ecd157f3e10403119a4fe03dcc728d3e79c9802" + }, + { + "type": "blob", + "hash": "f7e2525d6c16d832b3ac6ea634c7b2e0970967c2" + }, + { + "type": "blob", + "hash": "354e843c7a569571c135ef1ae4953412a48feaf0" + }, + { + "type": "blob", + "hash": "85169123b2c1c59988f8a9ce270c4257de0b56fe" + }, + { + "type": "blob", + "hash": "3df094d79799c068d6afe857415b60750bd93457" + }, + { + "type": "tree", + "hash": "64292c5c960ef0b007aab7c45358fa2e004477f4" + }, + { + "type": "tree", + "hash": "0c7fb29b51433f2357602e10ec00b2de1c85768e" + }, + { + "type": "tree", + "hash": "ae888b238359b8330ab26dc6798fa51df4953b6e" + }, + { + "type": "blob", + "hash": "740a56eea124df762ade91726e9c0edad800ebbb" + }, + { + "type": "tree", + "hash": "84dd0ec29456a7a9f6f713ddff24a91c6e5c970b" + }, + { + "type": "tree", + "hash": "36d6f8473656999d087de63c5d21d45b338850f2" + }, + { + "type": "blob", + "hash": "70eaf31e253994c568f714cf29c83ba9ac43e6cd" + }, + { + "type": "tree", + "hash": "d949955e05f2178558ee751660712f7dc2e79a25" + }, + { + "type": "blob", + "hash": "73b1409b609c5bc1bf3b60f43ee43f44079c1c92" + }, + { + "type": "tree", + "hash": "d457695729c44893265fca02fb5747c6c80c62f5" + }, + { + "type": "tree", + "hash": "539efe0a05dab25b2868e3ad3c8afde138bfcb73" + }, + { + "type": "blob", + "hash": "900dddae57030ca6b17557421afca0d8415d0672" + }, + { + "type": "tree", + "hash": "135262bb8ae2e998fce976b9731f604e4683f9e4" + }, + { + "type": "tree", + "hash": "ec512bbd7ed8f0e4584681ce87c29db719a8482b" + }, + { + "type": "blob", + "hash": "a049e4ea8e7365160cf24b7a8a7c50743a33af4e" + }, + { + "type": "tree", + "hash": "bd5b22fda1f99dc9e70c9ea7018c7eb8f18ef902" + }, + { + "type": "blob", + "hash": "40c719a4c5da9f4888963ca8b7cf19a9a8073990" + }, + { + "type": "tree", + "hash": "5c28431cefea96abfdcb4682b97785a781889ffb" + }, + { + "type": "tree", + "hash": "1195da08e145ef533c18903557f99f3052bd6d09" + }, + { + "type": "tree", + "hash": "57217240bdd2ff143253c003de2576052db5665d" + }, + { + "type": "tree", + "hash": "933ff537540398ce9cbb41321bc15d6d1dd1c9ff" + }, + { + "type": "tree", + "hash": "95c6cbbccfb0c351a9dd7e94c40c851efedd24a2" + }, + { + "type": "blob", + "hash": "8588d353cd52f2b873b6a93ef490b267b53d3514" + }, + { + "type": "tree", + "hash": "09e4ed48b0298b2cbd130879bb2d47ed097b0b36" + }, + { + "type": "tree", + "hash": "91a1b85d5a366069b4a7a6d99cb0ad38508f20f8" + }, + { + "type": "blob", + "hash": "433947fe8f5fbc675e239532934da57baf75efb4" + }, + { + "type": "blob", + "hash": "30c7efd3ce0f5d0d9969daafd458d7aec0ccf95c" + }, + { + "type": "blob", + "hash": "553de3728e58ca87337e8dff817567783cdaf606" + }, + { + "type": "blob", + "hash": "eada26d820733b9ce34408c8bc0afad02d90821f" + }, + { + "type": "tree", + "hash": "dce7cb4221ad288b649e66ae3b90405097a5d513" + }, + { + "type": "tree", + "hash": "40bc17965b6e1da5033531045278181b7d35d0b4" + }, + { + "type": "tree", + "hash": "20453e50acc517ed310d5195c1b60c0c10494d2a" + }, + { + "type": "tree", + "hash": "9899236ade35e4727cba21352e23f95080e29a8d" + }, + { + "type": "tree", + "hash": "6229c8325f421cbb54905065c0c29b554f6b652c" + }, + { + "type": "tree", + "hash": "d6eb13b2037a75615c2e87dd37872a8476ba83cb" + }, + { + "type": "blob", + "hash": "b9ee4373d0342d1704f815dc92578e56a96877bf" + }, + { + "type": "blob", + "hash": "5698ecb24667fe4fe800bce37b49bceca408e60b" + }, + { + "type": "tree", + "hash": "c9bb5819fbf74efaa1428b8685507b7e5b36d57a" + }, + { + "type": "tree", + "hash": "3b5629406474cd71789eab010abf9a6d7dc05698" + }, + { + "type": "blob", + "hash": "27e7bcf6016d2b8af2d860ea86b62b734efcf9ed" + }, + { + "type": "blob", + "hash": "f5974be3144853e27ea87e8e43849623eaa5a756" + }, + { + "type": "tree", + "hash": "7b69e31f17b8d4fb86fc92eb0bd322ec62c407f5" + }, + { + "type": "tree", + "hash": "d71247d6caa9d8d0ab1deaf34228875f8f00a1d3" + }, + { + "type": "tree", + "hash": "cd06a8433ceff9be0e277bf1eb9aefca491637bc" + }, + { + "type": "tree", + "hash": "b8f005632bccdf84b739862d01ee6647c04d16fb" + }, + { + "type": "tree", + "hash": "a50b5a7ee60ae7af2497326629539b83325352d7" + }, + { + "type": "tree", + "hash": "f45d2e813f1a94a19065ce098d03a180f61e5711" + }, + { + "type": "blob", + "hash": "2e863ba0c92842b5859306dadfe4e4a4adbb25b6" + }, + { + "type": "tree", + "hash": "0b7ca72b29ea836495882914761a1aa9575e4cc3" + }, + { + "type": "tree", + "hash": "bbd653c5a25219c20cee7d26120cad3ee4ecd15f" + }, + { + "type": "blob", + "hash": "20ec8c09c053e4ecd724d97c5d4e597ee8ffb276" + }, + { + "type": "tree", + "hash": "9d4f8ed811d1fabc3489207f459a15ed3de67ab0" + }, + { + "type": "tree", + "hash": "6789fac7b026f187e68813d2cc51b247a66783bd" + }, + { + "type": "tree", + "hash": "a382d2cd511b09bcce989398f4244065721afc9d" + }, + { + "type": "blob", + "hash": "d0d2131e829baf059a898732a1e6018ff0d049e7" + }, + { + "type": "tree", + "hash": "f55af913628b0eb710543ecb3f30d3b7ca11a9ae" + }, + { + "type": "tree", + "hash": "dd2bd3bd5df394bb7ea2fed25b1437144464e944" + }, + { + "type": "tree", + "hash": "246ee26e8181e13cf35886359d71629568006be3" + }, + { + "type": "tree", + "hash": "c83d4e8a3311af0a902c46e1af68a011a4e9c8b2" + }, + { + "type": "tree", + "hash": "af809d6e9401acf3cdf4351443549e310ad9b386" + }, + { + "type": "tree", + "hash": "9ae1215019d6434db6dca3f1f9b640e25ae50900" + }, + { + "type": "tree", + "hash": "3891b7c5c73b132375dad1eaca923bfa8ab9d124" + }, + { + "type": "blob", + "hash": "36e663bb2ebb8708efcaed0ae21a9ce7dc950c6e" + }, + { + "type": "tree", + "hash": "f5f86b812fd6e2a1a316b8ee9bcc2856b60c9c61" + }, + { + "type": "blob", + "hash": "d7ce3e9391044a556a69002fe0714d17f9d6adcc" + }, + { + "type": "tree", + "hash": "d1abbcff1ef6388f57ca7117b211c6c67b549f66" + }, + { + "type": "tree", + "hash": "473ddae751640d5247eacb008a2762a40c07863b" + }, + { + "type": "tree", + "hash": "9e1f90b9dabf0a940094d88d988c95ada9906a8b" + }, + { + "type": "tree", + "hash": "165405c2b96e4e7e8039575d1c6aea407e33dfa3" + }, + { + "type": "blob", + "hash": "950252e840390e807a5e4e4d1817fb7df1fb3b23" + }, + { + "type": "tree", + "hash": "f2ccf4f19ab633a850b63c530c6185f6af50bd5e" + }, + { + "type": "blob", + "hash": "181e00bc90889da7e3d6b0f2c3e874bfd3326999" + }, + { + "type": "tree", + "hash": "014d76ef844da35cfe79ab0b212e69b9b9a4a410" + }, + { + "type": "tree", + "hash": "3d8cdd280fe7f07d94f18c0b5f757a78dc8078f1" + }, + { + "type": "tree", + "hash": "50fbaf44eca394efb5afb509ac6fa56fc79c7fcf" + }, + { + "type": "tree", + "hash": "3b86a08c7f8098c80628b0f82d93cc038bb124ce" + }, + { + "type": "tree", + "hash": "30421e752a16de876d53315e85a62c75e834a589" + }, + { + "type": "tree", + "hash": "d8b356b9af81e811b85f1cc2b2940c58fdb5211d" + }, + { + "type": "blob", + "hash": "0ea12b7110e21870e19b28c97e8f4dca2d3c9cb2" + }, + { + "type": "tree", + "hash": "0c6322d78495f01fe6855c24720cff34d945e59c" + }, + { + "type": "tree", + "hash": "65d26ea7b631b8b222200eba1dc9a6a0a84e519f" + }, + { + "type": "tree", + "hash": "eb388a721f4d7951fee1c4949a983d1f2b904d47" + }, + { + "type": "tree", + "hash": "803ce802cd7d677a2a88e631ab3e98029112ef05" + }, + { + "type": "tree", + "hash": "1d2463f438191d4068cac20d38d512a92d183f75" + }, + { + "type": "tree", + "hash": "fe6164a97e0a2a15f23ab8a0c1ceab7c0c572029" + }, + { + "type": "blob", + "hash": "c06fac79c4be4de82362c2f2ea0b8f1c9a70b8f5" + }, + { + "type": "tree", + "hash": "198ccc42645fa4255905856e52cba63e55b6975a" + }, + { + "type": "tree", + "hash": "482bb6a1de2c6b41d03b94a14181d31a30958221" + }, + { + "type": "tree", + "hash": "afb37ad9e72d171ee22264ce06f42ab0f1e2a672" + }, + { + "type": "tree", + "hash": "8623cb4a590eb6606febf6f1d80d13de9e5224cf" + }, + { + "type": "tree", + "hash": "b1cd80bd2ece88b36837a83bfef3a8500249418b" + }, + { + "type": "tree", + "hash": "b7608861d2e0de622e2ce1f9402252594fb422fc" + }, + { + "type": "blob", + "hash": "efa6c5bd0292d8d222ca97d0e459ef4203f9bfbb" + }, + { + "type": "tree", + "hash": "d0e23dd1894f81399a9e400a825163b0a62cc1f9" + }, + { + "type": "tree", + "hash": "a0fe42eab37f305df32251d4da08ab1da84d0e65" + }, + { + "type": "tree", + "hash": "39f4d4e05967845e9a74470a92d9c9a86491998d" + }, + { + "type": "tree", + "hash": "df6540536e67f514497b1478b3521fecabacf35e" + }, + { + "type": "tree", + "hash": "6ac318cb3dcd63f475196ed05ada2c3287968903" + }, + { + "type": "blob", + "hash": "f3284ae2e8ba6d634d44e186078c163a679cd2f3" + }, + { + "type": "blob", + "hash": "c11409b20fe453d78903a6c6ba4340e922358718" + }, + { + "type": "blob", + "hash": "ef700c44e0126458f8c78ab431f55aa049189cf0" + }, + { + "type": "blob", + "hash": "5c7fe2c0c6775f92483e9990ce5860702d139ee8" + }, + { + "type": "blob", + "hash": "f01b5dc7bc7415d06cb49f8d6c0625bd6c4e1ea7" + }, + { + "type": "blob", + "hash": "166e0fc82a192953c8dd1b21bb6d9703169a3e47" + }, + { + "type": "tree", + "hash": "f07c489ba2609c447b90e4010beba2d5a74aa16e" + }, + { + "type": "blob", + "hash": "791d3df41ebb0ec5cd77e1c3c321f080821d76b2" + }, + { + "type": "tree", + "hash": "98867d63ace9d2e600e7dce0dd41c1f7b2cd9aa5" + }, + { + "type": "tree", + "hash": "66311bd7762d0b963db503a28dffe4cff4538131" + }, + { + "type": "blob", + "hash": "e58d54b11d63fe8b08d88ec886cd22fa98b67695" + }, + { + "type": "blob", + "hash": "56c31a21e1c3ff1ccc81eda9f532caa587a496d8" + }, + { + "type": "blob", + "hash": "45d936c7a6fa76a3e8d4429182602cf9c3883ccb" + }, + { + "type": "tree", + "hash": "e268825b79d2cf3686502131c3d94f97a9a26160" + }, + { + "type": "blob", + "hash": "b13b4acdc3bdb1df166e5f5c94ace5a169be28eb" + }, + { + "type": "blob", + "hash": "49b98d0e0acb1f5e6e7317a89a23fdb611b2c749" + }, + { + "type": "blob", + "hash": "3d1d9ce7145e25f27ef919f96fc53c8f0c1bb372" + }, + { + "type": "tree", + "hash": "266133ae3029dcf198b576a33af7f502e54637bb" + }, + { + "type": "tree", + "hash": "b21a8cce59b2ef41dce47329fb040721c3ca5cae" + }, + { + "type": "tree", + "hash": "f80d969fcf77bad21f4bdb1c2854bfbc4dc5ecad" + }, + { + "type": "tree", + "hash": "e78410827766330ebda329f71bb0c11a00621cf1" + }, + { + "type": "tree", + "hash": "dc77ea0c4e33d277d6346b0832c063dd492e6e6d" + }, + { + "type": "tree", + "hash": "e86fca16a93f54f7193bb4350dd9c2da79085baf" + }, + { + "type": "tree", + "hash": "77028562e0a0f3fa60a0da2fac945011c4089e37" + }, + { + "type": "blob", + "hash": "ab418d413168a3969779ab7989fef96c77cdd0c5" + }, + { + "type": "tree", + "hash": "f79889f9043be04fb8b54a7b2922c310e5cd9a12" + }, + { + "type": "tree", + "hash": "da988ea954efe2897f49e5c9a678939550912e25" + }, + { + "type": "blob", + "hash": "b24a3dd761d6abba63da77dee65136fd39f16c45" + }, + { + "type": "tree", + "hash": "0c69420e8c7faae0fa8869d97ae5b138b87ecbb0" + }, + { + "type": "tree", + "hash": "0914d323e8a1412f8ef739d452e0c702edc0840c" + }, + { + "type": "tree", + "hash": "9da1b78b32451ad98ad44bf03a3fb799a40e6ea2" + }, + { + "type": "blob", + "hash": "8cd1c5c8a248b5b15cd36b332cd57c30a5bbe10e" + }, + { + "type": "blob", + "hash": "9e8cb734fd0b6cb4519adfc98360d82b9553d8ec" + }, + { + "type": "blob", + "hash": "cd560a42bf52b384b53ef82ac8687cd2ea0fd595" + }, + { + "type": "tree", + "hash": "78d117abceab4107ae8103d6ada3f28cada4ed2c" + }, + { + "type": "tree", + "hash": "ba386ebf7abee963015dec47974eaf9b66c19d2f" + }, + { + "type": "tree", + "hash": "440ca21661343192d547f1c32d1e88950cde19d9" + }, + { + "type": "blob", + "hash": "00d5fd2fc95b062a3fa1aec370381216f35cfdc0" + }, + { + "type": "blob", + "hash": "3da63f85c4d82b20910e901e6bf135c2c2d7c09d" + }, + { + "type": "tree", + "hash": "9aebc22de92306ae736a97090a6bebb6e8fe0552" + }, + { + "type": "tree", + "hash": "3bf5b235709765170f0368e8027d1fdca9854294" + }, + { + "type": "tree", + "hash": "232d5a3219300e4dcfe63c01a08981842f6dfe9e" + }, + { + "type": "tree", + "hash": "7253a9f29108730bc806e32f0ddde079d588f7b9" + }, + { + "type": "tree", + "hash": "d168d315342b4112e6a11b5f83537ef1b89f9523" + }, + { + "type": "tree", + "hash": "08ffda5bbdf44b898463817f3366fb8437a9d68c" + }, + { + "type": "tree", + "hash": "bccc733b9ba01487dd0c7378b5cd67629ce841be" + }, + { + "type": "tree", + "hash": "c47f198cb5b21e51dcca50f24898c0072b6c61d2" + }, + { + "type": "tree", + "hash": "21bf99eab19bc88b6b501a2008a9f1dd2456a363" + }, + { + "type": "tree", + "hash": "82b2ac71e595967402920fdfafd46b72d667f3db" + }, + { + "type": "blob", + "hash": "62dd713950baa5fc3660c75811471123fc160093" + }, + { + "type": "blob", + "hash": "b9af33c3343fd99ca58004ce7aacf7f750fd07c7" + }, + { + "type": "tree", + "hash": "acb853c3ed8ef53d0ed146f8405d5d601924cb0e" + }, + { + "type": "tree", + "hash": "15fce881d072ae57029c54b4ece9deb7184de06c" + }, + { + "type": "tree", + "hash": "9188da85eaef6f241ca9aa3e756d28f8de5a6944" + }, + { + "type": "blob", + "hash": "09e678397a6813ea85554c2c426b7141f41b4cbe" + }, + { + "type": "blob", + "hash": "3f49bd4fd6f201766cde3c726bcdc03de71a0962" + }, + { + "type": "blob", + "hash": "642869ee86e5e99cf13a282af9e7618f5bf54954" + }, + { + "type": "tree", + "hash": "987c0fc9fd3b308ce258c3208048299f72a1c679" + }, + { + "type": "tree", + "hash": "e41758f6a91245aa8430bc3f70b9c97758b41fe1" + }, + { + "type": "tree", + "hash": "27f90b1cb6e36dd7bb4dcbda9cebb20fe9e89491" + }, + { + "type": "tree", + "hash": "fe2e88e8cf66c58d49a3caf3412db20ab7bebd1a" + }, + { + "type": "tree", + "hash": "45c6c83f3fae582ac6c2ab05c11eee2eb972a2ef" + }, + { + "type": "blob", + "hash": "830e35c63454b9bf42323fd54d7c47520099287e" + }, + { + "type": "tree", + "hash": "b428da4ae1dff75dab8f4dfb83ecbdda91adf740" + }, + { + "type": "tree", + "hash": "98b2053d3a95f53806d53843323dc4dae26d4b2d" + }, + { + "type": "blob", + "hash": "27b4186e58454563dd135afd9d583336f2122e3d" + }, + { + "type": "tree", + "hash": "539354a8a070b01b45f4940d81b428f995397a53" + }, + { + "type": "blob", + "hash": "cee72bfb3e213bb04b8d9a32616144a826dba6b5" + }, + { + "type": "tree", + "hash": "09210b582c0f4fc6b677f4d7faee14a289d418ce" + }, + { + "type": "tree", + "hash": "6c7d103b1a45f8f95d0c92e8f8de738f41354ae4" + }, + { + "type": "blob", + "hash": "a18fa6d365248c300a99b1725fe3058ed322228e" + }, + { + "type": "blob", + "hash": "dc81f64e2d67d21a3237ca3a765c522fcf9bb394" + }, + { + "type": "blob", + "hash": "df1f05cf8208bae8c5ddcf00c6f31ba3cc78e2dc" + }, + { + "type": "blob", + "hash": "a80dfec60f69042e01f269efe388f17cb02c37d9" + }, + { + "type": "tree", + "hash": "97a6dc7957ebeafa5ec7ce0485a41bd406de9812" + }, + { + "type": "tree", + "hash": "3329deef1c7f73f6478d8bd820cc355a1a6ac5e4" + }, + { + "type": "blob", + "hash": "21bb1486dfa675ebc816636926b9a98636731874" + }, + { + "type": "tree", + "hash": "d3557550380ab20c88b334b99aa01eb24c238c39" + }, + { + "type": "blob", + "hash": "0b9ad1583344a829e856b43b974ae6963381d771" + }, + { + "type": "blob", + "hash": "6a05316409c47d430d111272727823af3889507f" + }, + { + "type": "blob", + "hash": "576da4c4625864155462a6d771c83fe10eefb8e1" + }, + { + "type": "blob", + "hash": "73b497b5cf8bfdd195c570b8f58ccbe133da5d52" + }, + { + "type": "tree", + "hash": "a544bcdffe93195c0d50e11093ef1901a0085348" + }, + { + "type": "tree", + "hash": "b69c6bfc4f89dab0a0774384d90de6217217a235" + }, + { + "type": "tree", + "hash": "2fff58c71072fcc5edc0cca496d36cc6a2da24b1" + }, + { + "type": "tree", + "hash": "3bbad2dee0637a88db1363e09fb73b91fb30de60" + }, + { + "type": "blob", + "hash": "216193206d13e5d2102d8dba90a20cac3ddbf298" + }, + { + "type": "blob", + "hash": "97a59e9afe1d2c5708deb66062254769aedf60d4" + }, + { + "type": "tree", + "hash": "7365b34242983b792698937b12d0d67ffdfadac9" + }, + { + "type": "tree", + "hash": "8f2bc3604d15b472282228053fb75529e752498f" + }, + { + "type": "blob", + "hash": "e7fcb0e3d6d28f4c38d3caa0d5e15026072a7fbb" + }, + { + "type": "tree", + "hash": "7c000632a0b8793a4e207b927293a92c14655d39" + }, + { + "type": "tree", + "hash": "bf494dc4c63fb5d2a0cc7d1ba5da3a599c6b7c0c" + }, + { + "type": "tree", + "hash": "0e4c37792e920f0017d0e360829e39bf7f1257c9" + }, + { + "type": "tree", + "hash": "ec8c8fadb936617aa8bb4d5faf0cac959fbf3d89" + }, + { + "type": "tree", + "hash": "36960a644e696b1f72850e3eb3ea1dae0e2dac92" + }, + { + "type": "tree", + "hash": "c9775f21f99542710cef9044790b512c96938558" + }, + { + "type": "blob", + "hash": "95a11aa9dbd770f25ce488e82e0c1eaf9e7ea73d" + }, + { + "type": "tree", + "hash": "03a420e4688ca66d3c61bc8c52d0e2c16a021926" + }, + { + "type": "blob", + "hash": "f5d2446639b6d6aced0117d4728ece4e4a41c99d" + }, + { + "type": "blob", + "hash": "2524062e1cde99d9f11c6f9f3092679471c17ef0" + }, + { + "type": "tree", + "hash": "c797af45c91ac5042b987918f7b86a57cb301ef7" + }, + { + "type": "tree", + "hash": "df371ca3397cd0f7c6b3a6e98683cdb2800f47b4" + }, + { + "type": "blob", + "hash": "8f7010313892a58029b286c7357dd8dd4f1923fb" + }, + { + "type": "blob", + "hash": "aec8975e42a858ebf0c5f9a9e1c353afabab29b2" + }, + { + "type": "blob", + "hash": "41a9ac681a9040be13b5a2529b95f10bf5f772f6" + }, + { + "type": "blob", + "hash": "595ec5aa62ffd368a4464a0a7414bf118a13623c" + }, + { + "type": "blob", + "hash": "b1eb8567ce9debc002fb5f51e38192df621c35f2" + }, + { + "type": "blob", + "hash": "1328951e1990ac985418a198f89aecea96967421" + }, + { + "type": "blob", + "hash": "c9be4bed4511c52b06c20ca22d00d009a42b7b9d" + }, + { + "type": "tree", + "hash": "241d3d9ef647b165cb69230782638493558779e9" + }, + { + "type": "blob", + "hash": "0604513ecd2b9450da1b701f1378d118edc1e390" + }, + { + "type": "tree", + "hash": "ca3968e664e6e2d3ee895095811eb738a945ba18" + }, + { + "type": "tree", + "hash": "82ac5cd33136b3a64d6e6818cefacda12b01f38e" + }, + { + "type": "tree", + "hash": "1225212fee1b9ca6be67d7aba4beab4de6174d29" + }, + { + "type": "tree", + "hash": "39d61e80de39dd687634ae6082d67ec43cc65d2a" + }, + { + "type": "blob", + "hash": "4fd9487af6c4c93205aff420f45b67c05374443a" + }, + { + "type": "blob", + "hash": "b27052ef09c921534167b60fb6ed645930559878" + }, + { + "type": "blob", + "hash": "dff5f07b4fda980a20499adc35e833859d4d4660" + }, + { + "type": "tree", + "hash": "8303b81746532923c01b080c5a19e7555c044c85" + }, + { + "type": "tree", + "hash": "797cd32289fdfe29f782fd1dd85c3a7130eb82c0" + }, + { + "type": "blob", + "hash": "e328574d1dfb321cfab75acf62a1aaadf9a79310" + }, + { + "type": "tree", + "hash": "237ce1ebee75ff671e06a7f3f441c9efef17979c" + }, + { + "type": "tree", + "hash": "66e6fdac847e249ebbb4d2cdae85746f13384862" + }, + { + "type": "tree", + "hash": "594cec420d02dff76b618a0346c8a7bd29254849" + }, + { + "type": "tree", + "hash": "5ffa4644c7991fe92f8d07d293bf82c4584ba328" + }, + { + "type": "tree", + "hash": "f5a6b1bb5ded9bb7add71063ca2c75322bd3d9b2" + }, + { + "type": "tree", + "hash": "c2eaf379c87bb594b1cc2f520f10b0134ac6a674" + }, + { + "type": "tree", + "hash": "dcd2295ab365c7d40dc749143b1e9e700ec2ec02" + }, + { + "type": "tree", + "hash": "9eb1455c68c5f90fc596a120e20503720742ecde" + }, + { + "type": "blob", + "hash": "9964d6fb6ebe0493a507b89603a018521caeb461" + }, + { + "type": "tree", + "hash": "ad7ee9bab8a8897fbbbeeaca198ba083c8856c01" + }, + { + "type": "tree", + "hash": "0cc2bda78a93a363ad7bc6ed3c4b36517e06293d" + }, + { + "type": "tree", + "hash": "d3779327c903cdf6217f9ca6f7308184cd33d937" + }, + { + "type": "tree", + "hash": "05b02b9949b083784895ad444e50aadcb69ec2dd" + }, + { + "type": "tree", + "hash": "ed57d92ea2a73e75559bfa56f0c359863b097328" + }, + { + "type": "tree", + "hash": "f9e68a7e7c97e999f7ec05c54ddd5f968d58e7e1" + }, + { + "type": "tree", + "hash": "062cf2ee7e3ee3fe94b78c4046edbe1a0b8fc886" + }, + { + "type": "tree", + "hash": "cc4bebc3cc8a9613b9ab2babb8150267f8c3b2e4" + }, + { + "type": "tree", + "hash": "d34e4fd6114a5c7bcdfb034c616f9a8ebd13e2f5" + }, + { + "type": "tree", + "hash": "dc44d2c0e8a3f676b4d181a4fd58c7c948be0b68" + }, + { + "type": "tree", + "hash": "574b8b8dd8d90465575096e4185d350c3c578833" + }, + { + "type": "blob", + "hash": "7a527168d6ce27d34c738cee75aafc49924ed555" + }, + { + "type": "tree", + "hash": "49a3344fef59bd8253b906a008c4071acdeca5e2" + }, + { + "type": "blob", + "hash": "10d166eeac25f6a25d38feb9c22e47aa7894e756" + }, + { + "type": "tree", + "hash": "5eb20068467e86b60af5abcce57185531d26ac97" + }, + { + "type": "tree", + "hash": "401205ac03f3797b9b0ed5ae9ddb606e8db24cd8" + }, + { + "type": "blob", + "hash": "0ecb7805c76587a42edf3bdbb38b3f07909638df" + }, + { + "type": "tree", + "hash": "72d97d1868ff6ab84adbf83bdbd91718228250ec" + }, + { + "type": "tree", + "hash": "3c386be8197b3c5fcd509cb2854d06d61390377b" + }, + { + "type": "tree", + "hash": "598e0bf857be01f51fda3e2398ecc98d21e7e5c1" + }, + { + "type": "blob", + "hash": "1f33a03ceced8e3aa2218fe0f531078cc09c49ee" + }, + { + "type": "tree", + "hash": "dec0fa8dab9e9a955858ff0303f84f2aec4a24b3" + }, + { + "type": "tree", + "hash": "b568b269bfd28615c4f82a380dec8061327b0415" + }, + { + "type": "tree", + "hash": "85549837e30cea597df4f47f2b7a92f36a8e9d84" + }, + { + "type": "tree", + "hash": "30b19e3689e5f80fe3fe243b389a261130b55170" + }, + { + "type": "tree", + "hash": "b8a195f8d7d4db9d99e5296238e64bdd892dee1b" + }, + { + "type": "tree", + "hash": "c19daf0ec56014fe0e7cfe241ed5c263a7fc43c6" + }, + { + "type": "blob", + "hash": "3f36cdf1e7ebd3e1c594b7e245ca880933daa80f" + }, + { + "type": "tree", + "hash": "a0c487a985fe1cc06e02113d109b333b88d301b1" + }, + { + "type": "tree", + "hash": "da23fad08a17e304fad7f743ed8eeb41100263c0" + }, + { + "type": "blob", + "hash": "0d28f44d507ecc7e1f30c06a99d58f17b409a67f" + }, + { + "type": "blob", + "hash": "77b0bdaa401d56413816cfb59e5117fde1d8addb" + }, + { + "type": "tree", + "hash": "63a3e7110f0297e0720ebd9a82a63abd28be02d8" + }, + { + "type": "tree", + "hash": "3c65fc92871607c7a286867be462134f39e020ad" + }, + { + "type": "blob", + "hash": "e1feea94791360da76f58712a05126f3591931c6" + }, + { + "type": "blob", + "hash": "1f6dfb183de7f3c571610b1d5497ccec141fd306" + }, + { + "type": "tree", + "hash": "8bea89fb30647c98a1d2a5d5aa94a84792e27dfd" + }, + { + "type": "blob", + "hash": "c077986561dd91dc2327095e9768405791252fff" + }, + { + "type": "blob", + "hash": "7db7fa6ccddffc670c5af37051476c835337377d" + }, + { + "type": "tree", + "hash": "ddae2bd6749a9435cb82d69f33b5b45581ecc030" + }, + { + "type": "tree", + "hash": "0bb5ab8f69a826ae40699831a4f59385cb8e2e12" + }, + { + "type": "tree", + "hash": "d3d0496336ed3fe1f8a50dacf6d6736c4d795d88" + }, + { + "type": "blob", + "hash": "dfca298cb7e9117b29a8b63c1890d2e37adf20c3" + }, + { + "type": "tree", + "hash": "680f66a630a901dad03a96d05d1343dea2498aea" + }, + { + "type": "blob", + "hash": "bcb00e456bd4db70e3d839e4dfe3379e51ce0f03" + }, + { + "type": "tree", + "hash": "66e6b03c7585ec516e2988932befcf82739ea979" + }, + { + "type": "blob", + "hash": "8a746a943b6e161ce20659d651987b37735930c3" + }, + { + "type": "tree", + "hash": "b339b0ddf5c2c5dca593e394e5f2a308910f9a4d" + }, + { + "type": "tree", + "hash": "d8c90385de373f34bb6605d4e8d319e030771f35" + }, + { + "type": "blob", + "hash": "ce719c89006827269316bcd1afd2c760388397e5" + }, + { + "type": "tree", + "hash": "e0593a0b4c6dc9bf0cdd9a543d2fe38793922460" + }, + { + "type": "tree", + "hash": "fca3e11220a8839808c2854102a0001aae499ee6" + }, + { + "type": "tree", + "hash": "67b470626bfd7e7660f264523d8fedc8df465b4f" + }, + { + "type": "tree", + "hash": "14e2cf9013a833927eedcbc25bc4a65d3ea77a15" + }, + { + "type": "blob", + "hash": "68654f54fe104bdf475d2aef09a5eb594e8d9441" + }, + { + "type": "tree", + "hash": "691f2180dc1d06683dab332c2e27874d9b89857f" + }, + { + "type": "tree", + "hash": "a741c04939617653bb9bf81d2e5a6952be1dbe16" + }, + { + "type": "blob", + "hash": "7beef459dfba45fdb3900f7b88a1ca9c6a8d6025" + }, + { + "type": "blob", + "hash": "8ca5b4fae2a598ecde531cd8a1190923a05587d7" + }, + { + "type": "blob", + "hash": "c0ad1f874ac7a7d0d303fee0f3f6cd7513e99902" + }, + { + "type": "tree", + "hash": "ef9ec0cb7e140aac052e7079deb1e2bbfe26ae09" + }, + { + "type": "tree", + "hash": "a3750e423880c78cf7a0c5342381f1a28f05298f" + }, + { + "type": "blob", + "hash": "70a2ff12f60aefaba05dce3c722a615d8f339dfc" + }, + { + "type": "tree", + "hash": "f5075d5fc26d83bd1de08be855296876d3ac1213" + }, + { + "type": "blob", + "hash": "0565fbad559c652514fa669fc7c5127c2595f2f4" + }, + { + "type": "tree", + "hash": "4272cf2cd4a1dc3d541a463f2d65ccaf8f332cc4" + }, + { + "type": "tree", + "hash": "fa89c719d2287152ccac120ba57169a403724041" + }, + { + "type": "blob", + "hash": "36a3973b3dd7c38728dbac20acbbbf94d342ffe9" + }, + { + "type": "blob", + "hash": "6420129a9b09d212ad74faf97dd8ee83b271909e" + }, + { + "type": "blob", + "hash": "22dba0bce842dc45f01963a4aaae28dfa122e651" + }, + { + "type": "tree", + "hash": "2b5e94f21ccbdfa8453f76afc3378d01f2200a84" + }, + { + "type": "tree", + "hash": "7ff7bea64f4f247e6d6974ad3cfcebd9d4f25d18" + }, + { + "type": "blob", + "hash": "d1b44b68ad65dafcfdc8de34b73eec0cfe41aa7b" + }, + { + "type": "tree", + "hash": "c8747ed88a77a6a1040ba686e52055100e3d5187" + }, + { + "type": "tree", + "hash": "925056a8de6a200fdf0af6bc1a05bf8eb29298d8" + }, + { + "type": "tree", + "hash": "4a2a79c71291f7f6a8f38c8cc33dd86e83d7333f" + }, + { + "type": "tree", + "hash": "6f045ecc0041b5897672f1f9eec608b26ceaf4dc" + }, + { + "type": "tree", + "hash": "9e4a3810ed930b7cdd7f343e11aed721ddc21273" + }, + { + "type": "blob", + "hash": "1dd6a2619a0b8fd9d5c68af32b27c9840f3bc8e2" + }, + { + "type": "blob", + "hash": "153c648c4da67471a85713e42b3c1367e266428a" + }, + { + "type": "tree", + "hash": "18563211c5909e0e21e8fffd96bbecdb9b82c79e" + }, + { + "type": "tree", + "hash": "6cc0cda6c429a1c512b8d290441204d16bbea2b3" + }, + { + "type": "tree", + "hash": "ad963fb6eb2d20f8422dcb1767f5e79c0f58a0f3" + }, + { + "type": "blob", + "hash": "bcc3000047351612d925c77d8957822170884781" + }, + { + "type": "tree", + "hash": "eb486be94aa3f8cec889bb9c4ed5a16a3cc82d58" + }, + { + "type": "tree", + "hash": "9592fdbd6aa0aed222ecb8a5e8715523d7cf2b65" + }, + { + "type": "blob", + "hash": "0980bde7329b0fed06d2981d47ef5d54fd104440" + }, + { + "type": "tree", + "hash": "6b6a44f7ee3b6d39fe28d73481d355bf7f4a55eb" + }, + { + "type": "tree", + "hash": "7334185e752eb355b5dcd25589c7829e709e12cd" + }, + { + "type": "blob", + "hash": "a77087fae219fb5a7bacfd1caa9160b8a9b4dd67" + }, + { + "type": "blob", + "hash": "81c4004b2105d9fc87476b8201b76750b84e2314" + }, + { + "type": "blob", + "hash": "8a8a695834c3c25c6467db62e71dc7ed7ad15979" + }, + { + "type": "tree", + "hash": "23763a7f1d444f25e5022b03d13e1ba088118ccc" + }, + { + "type": "tree", + "hash": "1a86112be742aa98c85d8f34bb6aada75d498431" + }, + { + "type": "blob", + "hash": "02ee1125ed538e7c5c12b56b090186e3c585b2ec" + }, + { + "type": "tree", + "hash": "fdb343900163d66b6c922958a9daa918ba2500b9" + }, + { + "type": "blob", + "hash": "6db65ed220e8c59da78615d5a33c1abd5a7ba169" + }, + { + "type": "blob", + "hash": "d8457157c26433b38bfb6ec529b5570363e6db12" + }, + { + "type": "tree", + "hash": "98b36ddd0c46d50678b231a16f8fb3bb0dfe4607" + }, + { + "type": "tree", + "hash": "990bcd80ef09dde71b4b7ac0e68f4d5aa4194ce3" + }, + { + "type": "blob", + "hash": "2d76281642f9cd80899adc35c32af34873e5bc35" + }, + { + "type": "tree", + "hash": "6d6e11d9444fb578786c4c68afbec7c9e921aa17" + }, + { + "type": "tree", + "hash": "481b1b43f809e3d87ee51e30d17e0c6ba2789e60" + }, + { + "type": "tree", + "hash": "40c38c05163f066306153586730669dd18e18aa4" + }, + { + "type": "blob", + "hash": "ecd4e9f3acdf3cb035829ae5fc1319b276a93de3" + }, + { + "type": "tree", + "hash": "3811731f5b6075aa2c7b042c5de990b7b2606a32" + }, + { + "type": "blob", + "hash": "54b974dffe5c5b2ff05ed83be9ccbdbc1a8ca717" + }, + { + "type": "tree", + "hash": "d86a179d0a4728a06c6cc8e6aa6feef062295df3" + }, + { + "type": "tree", + "hash": "9bc3302cf9fe4535974568d1bb8f2d6824080fe9" + }, + { + "type": "blob", + "hash": "f5de19d62ea5bc9b63f110538705ff8570531c08" + }, + { + "type": "blob", + "hash": "a9f1528b5af0b889472529219fc17fe7ffa8f36f" + }, + { + "type": "tree", + "hash": "50b1f2da5d512b93f4aae2665fcfef650041e609" + }, + { + "type": "tree", + "hash": "6644bb0a1849d9bcf0ec70d47dbce65ade4a0ece" + }, + { + "type": "tree", + "hash": "7f38cd82a803221df18282fd15dce5009d359479" + }, + { + "type": "tree", + "hash": "0cffbbb877b5336841f5ce38f68de7c99bbf1788" + }, + { + "type": "tree", + "hash": "68bb6e6a075d40bf2722ebaa162fe36d208c5b9c" + }, + { + "type": "tree", + "hash": "3fe83c434efce24c2663651c83e85089143c15e7" + }, + { + "type": "blob", + "hash": "e44ea24da7425e03e172b08bb2c48f346cedd4a1" + }, + { + "type": "tree", + "hash": "cc7fbc78a4fdef4fa93d4e9c1ef4487bd0fca016" + }, + { + "type": "tree", + "hash": "42ce0e767826e91ab85e61afc741571c8b800591" + }, + { + "type": "tree", + "hash": "10d4a5a348b9d99749750cf298837cf57a73f835" + }, + { + "type": "tree", + "hash": "241fc64d07b912f1ea3b4290bb6e88bdbc9fa35e" + }, + { + "type": "blob", + "hash": "6ceadc54af69caf93ca4f417b385e7d20fa8f7af" + }, + { + "type": "blob", + "hash": "f2a76d44af6aceda0b8a3ceff6a5ce151acdeba2" + }, + { + "type": "tree", + "hash": "549974006c253842ca197731f9fdb9f3e7173e4c" + }, + { + "type": "blob", + "hash": "0afe09aaf2d09c840c3277b988a07b14bf03246b" + }, + { + "type": "blob", + "hash": "ca8730b0fa7879ec3efd8bc7185716e437b644c9" + }, + { + "type": "tree", + "hash": "df15a5fde20d87b1333d18f70c5e0ef49c274cc6" + }, + { + "type": "tree", + "hash": "1c9e69eda6c3197517ebb406254583507a0861f4" + }, + { + "type": "blob", + "hash": "d100048ec9a15c27bf5f1f1cfeb91b89fc1def44" + }, + { + "type": "tree", + "hash": "e514f7fd492ab48722403ee2b546371e23983095" + }, + { + "type": "blob", + "hash": "7d686e88975fd3168c32dd087c9fff4c7c3ec957" + }, + { + "type": "blob", + "hash": "56f0dfa1b5012dd0eba9fd0bf373a9c9edbb6fbf" + }, + { + "type": "tree", + "hash": "8bfeda8a32e4aa597ce78bc0b92abdc01b2d1a01" + }, + { + "type": "tree", + "hash": "2f696efeeacdd1133547452d8a63e112bbe3c9ae" + }, + { + "type": "blob", + "hash": "30979e69cec529edaa29959f273e2ffd9cbb1124" + }, + { + "type": "tree", + "hash": "8fd02e5c52bb8aa885e67df718090f93ce5a1e90" + }, + { + "type": "tree", + "hash": "566999daec6bb9cc4984cdd174d722a0a9390f95" + }, + { + "type": "tree", + "hash": "28c0b3c8ae96bfa31f37388c4fde6d7fd5db5f34" + }, + { + "type": "tree", + "hash": "88388012d70a6b02b68aab7011d3098fddbbd5a6" + }, + { + "type": "blob", + "hash": "1065061d7b98da9c1be6bd9681a4b08dc0dde84e" + }, + { + "type": "tree", + "hash": "b898440d5d2008a7c1e6d67c0fc3f2efe2926943" + }, + { + "type": "blob", + "hash": "6e16f44e1d7035c0241e3b311e1f520a1e20d3b5" + }, + { + "type": "tree", + "hash": "64edfa41dc7327d599eb5422ced0f18308f2c780" + }, + { + "type": "blob", + "hash": "7f9567609c47cefc4b164f89fd8f2cc021500403" + }, + { + "type": "tree", + "hash": "ff03aceb94df9934b7f5cb80ec824d2054334d27" + }, + { + "type": "tree", + "hash": "857fa017e33950b9418bb0f1c7d96ff4da7166b6" + }, + { + "type": "tree", + "hash": "896693b1730cf1383495df11262ae6dc62962d92" + }, + { + "type": "tree", + "hash": "2cf00a9c55b92fa7e9047e352b8e0361ae6e7716" + }, + { + "type": "tree", + "hash": "9f414ab8827c66431c52ffd6b5cab96c168a0f8c" + }, + { + "type": "blob", + "hash": "6dd439f6c2393b5742fa0daa8fa7f0c59a981fb6" + }, + { + "type": "tree", + "hash": "537425b00522be39e5a34c8c7d42974fcf7affad" + }, + { + "type": "blob", + "hash": "13219a620d93b1a0010006ded08b365e818e294a" + }, + { + "type": "blob", + "hash": "07780d1407917d51ee14f786971146f1ac3aaaf8" + }, + { + "type": "blob", + "hash": "9eee3bb66e33194addb8988590f625f389b8d50a" + }, + { + "type": "blob", + "hash": "f5d8e39a6a932301c6899e44f1ff664bbcedce25" + }, + { + "type": "blob", + "hash": "44488ecb214161ef9f5c94d9ad408b268f9d886e" + }, + { + "type": "blob", + "hash": "50478196cba12d28e1334386a64ecf246673104c" + }, + { + "type": "tree", + "hash": "756e64e8e7416dd1e6d67b22e33a2a6365af845b" + }, + { + "type": "blob", + "hash": "f21221562341149adf6c9b60dca8b0d9a3c765d8" + }, + { + "type": "blob", + "hash": "2dc43ae60018045f01a9453282911b09c8b5125d" + }, + { + "type": "tree", + "hash": "67afcd3323049e5f71342ce0632787b119fded27" + }, + { + "type": "tree", + "hash": "2c8e444ee49340bd935336a50db26480dcd8c702" + }, + { + "type": "blob", + "hash": "8b2df34693da8779fe95649db489990f030a4bd8" + }, + { + "type": "tree", + "hash": "4f77e263619ed03f521c805cb34a7c2eb97a411f" + }, + { + "type": "blob", + "hash": "dc93f9cbcd306a5670f211f67e102075612415a4" + }, + { + "type": "blob", + "hash": "e71c9f288e57b1d1a779f7b7c0b0f5cb97c9074d" + }, + { + "type": "tree", + "hash": "1d52bc231da5982783596e7f78f824e490bf23e6" + }, + { + "type": "tree", + "hash": "c3f66279970a35075bd97f4fc61a658b87996580" + }, + { + "type": "blob", + "hash": "6145de0219f3a3a5ce84c96761799e26ea942488" + }, + { + "type": "blob", + "hash": "4614e9954f4fef63fb0fcb39c8d7ad90b1f4df3f" + }, + { + "type": "tree", + "hash": "262f5a5021bba824656907cb352aafd47eabf8c5" + }, + { + "type": "tree", + "hash": "324bd43c40c577bec3983fdcd42d28a31fd6f95b" + }, + { + "type": "tree", + "hash": "8d0a95aa754f7c4f98afbfe99693a31e1849a9ae" + }, + { + "type": "tree", + "hash": "e618be4524e3c9982506d350ed0410ad968334dd" + }, + { + "type": "blob", + "hash": "e727b6b3d6411d47eec761052148b0be629b9c7a" + }, + { + "type": "blob", + "hash": "1097f298d9dcad280367390572245b0fe2b1c395" + }, + { + "type": "blob", + "hash": "c375d1a12d6182caf8cde0e10e89cfe2ddc790b8" + }, + { + "type": "tree", + "hash": "92c9a9ca7126cc8581c9acc38492be0e39b5ec85" + }, + { + "type": "tree", + "hash": "fb7a01110a7320e9699bb44a9fa206a25993cb0b" + }, + { + "type": "blob", + "hash": "a25f7538a4f334fcc158fe46e035c22bb7c3765b" + }, + { + "type": "tree", + "hash": "16810ec0c5edcadc66ce9aea58d807fafe522304" + }, + { + "type": "blob", + "hash": "8f04f72976c1bb4c14eaa2d62ed7c9c3d0d17271" + }, + { + "type": "blob", + "hash": "083f7f280b37df4aeedf0f85d05e74d5d2f67f85" + }, + { + "type": "blob", + "hash": "81992959112a84600497b913427f7cde0b204972" + }, + { + "type": "tree", + "hash": "286aa0674210d2da4f8958203ba0fa96ddf5ae8a" + }, + { + "type": "tree", + "hash": "db7aa823c9c422f49a11126b51af4685b6c8948a" + }, + { + "type": "blob", + "hash": "19189dbe6e096e4bd25701ca07cb2c644297a263" + }, + { + "type": "tree", + "hash": "65858deb9ea200f4351a23211d30c3e98e1cff8f" + }, + { + "type": "blob", + "hash": "c40761ee62678f3cc5c8683604837340c4585ab5" + }, + { + "type": "tree", + "hash": "fc63051dc9341439f37e560a2e76c66b842db97f" + }, + { + "type": "tree", + "hash": "0067fddbb167f845b359dd0735456ca909a13724" + }, + { + "type": "blob", + "hash": "4dbae485314715c0cadd86de8bb4cdae386f2f4e" + }, + { + "type": "tree", + "hash": "6a42fcc1852da63005a524f474eaad3e0bdd3cd9" + }, + { + "type": "tree", + "hash": "f0eb82176738793ad41f2171f7f331ed01ca8855" + }, + { + "type": "blob", + "hash": "2d5c2013d3f1d60e5e6173bc326f0d3bf8df2d82" + }, + { + "type": "tree", + "hash": "04bded85f34ba86af51af31bd08dcd33df66c99b" + }, + { + "type": "blob", + "hash": "06ff3bb5891000a98a4bf2419659de5c7264142b" + }, + { + "type": "tree", + "hash": "9ce6b3b31939f569f9b25aa4ce80339461b4826b" + }, + { + "type": "blob", + "hash": "e849fca400582b895789fc1ff8d0bdf9a2efe6ff" + }, + { + "type": "tree", + "hash": "c883a6574e58f464a089402d61db3d237b00eb1b" + }, + { + "type": "tree", + "hash": "5750791320decaf6da786570e146d0a0447478af" + }, + { + "type": "blob", + "hash": "cddbc30a97368f14969dbb92d28253514e42e130" + }, + { + "type": "blob", + "hash": "1e57607d761db63076e9c8c592d6cf8cdca69438" + }, + { + "type": "tree", + "hash": "198c2a58264f15694116f0e95cea39e3531f4550" + }, + { + "type": "tree", + "hash": "4f8792d50e6a311ef0d3492e7298fdd323962618" + }, + { + "type": "tree", + "hash": "7d019be594dcae3672163f1fec6da37083b85969" + }, + { + "type": "tree", + "hash": "b396009b1709baacfb3b2495c8a982438978cf2b" + }, + { + "type": "blob", + "hash": "3d4485148d683074aede46e9c020e1d74e49b2e6" + }, + { + "type": "blob", + "hash": "3ee8bde8ad6726943cd39d004acc54d9ff96c775" + }, + { + "type": "blob", + "hash": "590a7e993885bc5640023ff8c1ef3fe933aa1b41" + }, + { + "type": "tree", + "hash": "3169c17d2186dd563a0937b697a0f97f0efaa9b7" + }, + { + "type": "tree", + "hash": "af78106bf4f3708b90c37ae3864f821ee13dec01" + }, + { + "type": "blob", + "hash": "d3d3d3523942ee2129b2da8a3cbeeea06b03b2d3" + }, + { + "type": "tree", + "hash": "9be332b988a78a6baad4003e8ff6e3ded6e02cf1" + }, + { + "type": "tree", + "hash": "2ab6c57a9a13fc35a436808d1c3ed3d15d2d1716" + }, + { + "type": "blob", + "hash": "8b92ce6487c7581683ec214740f7381370a3f158" + }, + { + "type": "blob", + "hash": "919659075376b9c161c6da76cfd82a1a91ad4d04" + }, + { + "type": "tree", + "hash": "2636223c9efc928211c7769a5a7a7e33b8355331" + }, + { + "type": "tree", + "hash": "a7c6a5aa3603b03ea3d3e632e91390722e348032" + }, + { + "type": "blob", + "hash": "faba2c1b8dab94c9ff52615f600fb45d373eb0b4" + }, + { + "type": "blob", + "hash": "2ca78552e2d2720778f13419adb56ef94d3e0825" + }, + { + "type": "blob", + "hash": "475ebebddb715726026d32ccc07294008b9e1dd3" + }, + { + "type": "tree", + "hash": "495a780811382caaed22c7fd439a896a2fdfc385" + }, + { + "type": "blob", + "hash": "a9ab834b439f20480f2b9b1e030dd6f4315840d2" + }, + { + "type": "tree", + "hash": "65754ae19a15f7317a4022e063790432e8d33115" + }, + { + "type": "tree", + "hash": "21b4323d1f647f21b4ef98e83346df7a7481f97f" + }, + { + "type": "blob", + "hash": "1bbca745cec08df14c380035eb684a650a14112b" + }, + { + "type": "tree", + "hash": "178785ebdb7cba67961cc9b7c4ff920d2b8b84f2" + }, + { + "type": "blob", + "hash": "a8ada5c8ccd25e38d70d71755adf9deb0693bf92" + }, + { + "type": "blob", + "hash": "329221664b1596e1b953af335ff8d5175e5a019c" + }, + { + "type": "tree", + "hash": "8e7c7f7d558bc0964aaf4f6b2ddd7922d9a872b2" + }, + { + "type": "tree", + "hash": "1b77e80eb0f0f9a6d089ce69accce22a3b8fadf7" + }, + { + "type": "tree", + "hash": "b6bcec3886b8188f3b94799f58d397f27b8a8a42" + }, + { + "type": "blob", + "hash": "cb089cd89a7d7686d284d8761201649346b5aa1c" + }, + { + "type": "tree", + "hash": "f124d06b0a5cd1e01aed618a47f8e20873c5cdc5" + }, + { + "type": "tree", + "hash": "ef22c2b354bda00bd8c9a9a193d6b535696d805f" + }, + { + "type": "blob", + "hash": "3adbc6b28571170f672794721b1c05971da185a7" + }, + { + "type": "tree", + "hash": "565d9492e8287a15c7cd4e9ccb8ede5622d435eb" + }, + { + "type": "blob", + "hash": "cb293854ddb0820248b13e4c2912b66bc319e776" + }, + { + "type": "tree", + "hash": "2b7c833e3e152d9f62d32966a8e82e2fc968c39d" + }, + { + "type": "blob", + "hash": "4f2bd9e6f8904e8157590bcfcbdcb377a55d6cdf" + }, + { + "type": "tree", + "hash": "71dae2dae7cc0a00bde76a3a90e761c58d2b6454" + }, + { + "type": "tree", + "hash": "b4a10435edd0a1be8ec32dc7c2042e9bd3143fa2" + }, + { + "type": "tree", + "hash": "6dfbaaa3586496e591fff4a9285bb3d77e2d5b7c" + }, + { + "type": "tree", + "hash": "cd85d74bdce6d66ec5b4dbfb0a2510b8ebb4391d" + }, + { + "type": "tree", + "hash": "ef5e8f7de94c4519f9a7fbe9cd0050beafda8322" + }, + { + "type": "tree", + "hash": "425953a452055ab745c0ee9ceccf76a4813b8f08" + }, + { + "type": "tree", + "hash": "4b35c99353ef9a68f3b287751e500b7db3d05abe" + }, + { + "type": "blob", + "hash": "fc379ccf5b74cfb9a892b111f7323ed37877b78b" + }, + { + "type": "tree", + "hash": "5b439e57ed7fc1b8425d9b4d0e2443b516b72b7f" + }, + { + "type": "tree", + "hash": "ce9700e35df7b502894128a9501150b6706a5bcd" + }, + { + "type": "blob", + "hash": "b90f49457d912c927d16ae0e65df50d260d13adb" + }, + { + "type": "tree", + "hash": "61725e0c29ccdfb8cef1eed220c3d2fa02369df7" + }, + { + "type": "blob", + "hash": "66f7ce696716074624b3df15521141b1bf06c4c5" + }, + { + "type": "tree", + "hash": "26aec55c13ad778ddcce61cd910b138e36d3d9ff" + }, + { + "type": "tree", + "hash": "30e1908340bd1f6389d4f73f9d547d0a165d663d" + }, + { + "type": "tree", + "hash": "dcf178369a3ce8f71189ac13dc3014c587ac7e54" + }, + { + "type": "blob", + "hash": "d6bae81bac62e57828d2d5e2812b268b39febe36" + }, + { + "type": "tree", + "hash": "ed14beb4d6ee4bd4c3f3a214be59c59ee8a834f5" + }, + { + "type": "tree", + "hash": "ecb9ca19bfe6c351c8987bf9f44ff4249d5905d6" + }, + { + "type": "tree", + "hash": "f8523c60c0bd9cd121d5057f87d00ab697d5b55d" + }, + { + "type": "tree", + "hash": "fe48c95b02229545e15aece1b25c58a03c62a024" + }, + { + "type": "tree", + "hash": "8042f9871513b6146e3347a61c4d20d4d4bcd4b2" + }, + { + "type": "tree", + "hash": "75b994d67ec18158e5df09639557d37e72f45456" + }, + { + "type": "blob", + "hash": "bceb3504a7ea0d31611e6061f7a7a3303e3b131a" + }, + { + "type": "tree", + "hash": "98eb88bb4b6a055a0f94fd89c6fce7b40195dd99" + }, + { + "type": "tree", + "hash": "f4c8767bf379e13b1159b01fc668db6d0a9cc0af" + }, + { + "type": "blob", + "hash": "50a788737421116d3ced8e0d5fc66f9c8a4f96bb" + }, + { + "type": "tree", + "hash": "e16d5b8c965ec833c4c41a99219c455c2ef55343" + }, + { + "type": "tree", + "hash": "5fe727f2b3f5c72a27286e36bcd7b77d2a052022" + }, + { + "type": "tree", + "hash": "c17996393a0d00f2fb76560d525f1a728563ab6c" + }, + { + "type": "tree", + "hash": "2a38ea8aaeaf11ecc5a1a78b139f99df7726bb3e" + }, + { + "type": "tree", + "hash": "9d56dc48f289b7ea50ee42c28674dc6e730407dd" + }, + { + "type": "blob", + "hash": "6f0429b68a854e816e19b9acd349e5a020e7e3f8" + }, + { + "type": "tree", + "hash": "e3ab0c8b05dbd31827fa4f3c1de181ecd8e1da3a" + }, + { + "type": "tree", + "hash": "381e7f68f4e74fc1ca0d1bf6280dcf370e477737" + }, + { + "type": "tree", + "hash": "c1dee2ffb7a7a116a0b2ecfe7509bfbb193785bf" + }, + { + "type": "tree", + "hash": "e7ae67a61e7cafa66e64e4b9c43661d88ec54137" + }, + { + "type": "blob", + "hash": "86a6a5b6525250b3bc1dc44361f52807c70e04eb" + }, + { + "type": "tree", + "hash": "b3b2b2c6465f071cb99a8222fb741947ad91002a" + }, + { + "type": "blob", + "hash": "501e49bd958d703b8256757f82f48144c0006533" + }, + { + "type": "tree", + "hash": "17a9faacf32bb85885e70fad9b9ab838f9ec6823" + }, + { + "type": "tree", + "hash": "3949e8662daeb8602fe7e9b50da3287bc736c67f" + }, + { + "type": "tree", + "hash": "623f702e385011cfb461acab4f8669e9ce5e9fc6" + }, + { + "type": "tree", + "hash": "af376cd1c218de5e5b6b825683a8eacc6a8a6f54" + }, + { + "type": "tree", + "hash": "d2631f94e564c4a60f7a77350a80cbf4ba150afd" + }, + { + "type": "tree", + "hash": "89c33e728aca5623a25dc389d98bf72221c02ad4" + }, + { + "type": "blob", + "hash": "4d76dd332ccf64e1509592bc828a3ed0095655cb" + }, + { + "type": "blob", + "hash": "3b1a9284cf208d282ff1fa48839648d21f7a14b5" + }, + { + "type": "blob", + "hash": "7deb80a9f44730d16f41b598c6930275c55ec511" + }, + { + "type": "blob", + "hash": "afcdd82789b65eda3bdb5b66f7b9926ebd8781e2" + }, + { + "type": "tree", + "hash": "e9a0279e04c6f8496a4d0eeb0f773581dc531e29" + }, + { + "type": "tree", + "hash": "fc1868d7ac342cf036233fb89a9dd6dd81635358" + }, + { + "type": "tree", + "hash": "dc9f4f712e1fd955a21ef4f6460811b88cb3c312" + }, + { + "type": "blob", + "hash": "1673d9666e15d52124f74ecb0ab8f7b9bb7549f0" + }, + { + "type": "tree", + "hash": "29b605e7019679ca45846c07d531d4acd432d26f" + }, + { + "type": "tree", + "hash": "6775d7ca574dd0f3ebc58c4d93bb9fee88fed0e3" + }, + { + "type": "blob", + "hash": "bfd0efc52c87f7da4f4e74119b2a982962573189" + }, + { + "type": "tree", + "hash": "1f05790ba8034c2a4711239433793a82105f92e8" + }, + { + "type": "tree", + "hash": "ec3d4c0231e95e622c96894ba4026c72f2127dad" + }, + { + "type": "tree", + "hash": "46cceccc1a701756b1a5c3585ddfd9d6357e52fa" + }, + { + "type": "tree", + "hash": "def4b193e1bd33e3132333ac6e8789ad6792d59b" + }, + { + "type": "blob", + "hash": "a1f2907694640363d0fc4fa9c4eec83841c1b919" + }, + { + "type": "blob", + "hash": "4d40afdedfb120491093f49824c11544874cabdf" + }, + { + "type": "tree", + "hash": "74c1b018abe1a232762a5e866da69141dd7ae7d8" + }, + { + "type": "tree", + "hash": "e0e136ea12c24de0ccf50ba36be9a2fb7cc709c9" + }, + { + "type": "blob", + "hash": "af37eeba0b8efd408820ab85ec915ae647808971" + }, + { + "type": "tree", + "hash": "cc4cc80b4d053eb193cb5757e9c7e2441fa08e60" + }, + { + "type": "blob", + "hash": "57ffb7e49b61acd9e25963db0d2d7e8b550b3527" + }, + { + "type": "blob", + "hash": "b82ef4c9249849462726ea83e8f1299067964124" + }, + { + "type": "blob", + "hash": "2e6bf8451667ec09cb51dbc81cac008849b85d03" + }, + { + "type": "blob", + "hash": "133c85ffb3937cb0292947f4ae8faad48ca4b44e" + }, + { + "type": "tree", + "hash": "b44fa18ebeb7cb7729e244d978a27f4dbab557e1" + }, + { + "type": "tree", + "hash": "3a0b7f969ea3dff5765809e4c4a9ce833daff91c" + }, + { + "type": "tree", + "hash": "5668a572b438352dac7e1d3489522913bf86f3b3" + }, + { + "type": "blob", + "hash": "5c049703e8a76df6fd04a9504e4a4da1cd922ae0" + }, + { + "type": "blob", + "hash": "8eec3f7b1e3078df40e35ca042237c747c39f2f2" + }, + { + "type": "blob", + "hash": "ef18ef0ff89c8322b3de9b6e6f4736b5e19d7153" + }, + { + "type": "tree", + "hash": "f46e11f0734b604a5adcc3e48cc507ea5605b2f5" + }, + { + "type": "tree", + "hash": "61369f0e9dadc65d5cfbf7eedac0507665c65e80" + }, + { + "type": "tree", + "hash": "7cd266f17813663a9d5add3ef8dfbeba4c7c10e7" + }, + { + "type": "blob", + "hash": "93f92556c3e67b7fd0700893acfdb9baf9eab2a6" + }, + { + "type": "tree", + "hash": "6a9fdf95f833956f8dfcf571c954b6669306624c" + }, + { + "type": "tree", + "hash": "40eabcd225af526c2afee74c2b1e7fc9a1ba9203" + }, + { + "type": "blob", + "hash": "ea343aed4b36212e721ab244ed04115dd71bddd9" + }, + { + "type": "tree", + "hash": "cb482d14856b1d8d47325fe33356c0a46cd373ba" + }, + { + "type": "blob", + "hash": "52211d6e2614bb9d03140c36df9f724bc34a28c5" + }, + { + "type": "tree", + "hash": "a38fa276d7903d086bacea9084752a4f9096c8c0" + }, + { + "type": "blob", + "hash": "af1f8a1338ff144ffd42464658abd345f8423238" + }, + { + "type": "tree", + "hash": "98b8ee308a86f734e0f93b94305601e13ee27331" + }, + { + "type": "blob", + "hash": "7124d61e3ed09c4df956d897c8de41b946849733" + }, + { + "type": "blob", + "hash": "2c58eb1821689e7d739cf40e970041814f5b837b" + }, + { + "type": "tree", + "hash": "429149586f5dbde53fed4450bed127df1b3f2b1e" + }, + { + "type": "blob", + "hash": "e4ed69cf587324c220d088d9cb1da9585b17b163" + }, + { + "type": "blob", + "hash": "e1eb319d6775d0dbe9d3d501ac4c575a5ba0c37f" + }, + { + "type": "tree", + "hash": "b53fa3742ed63d1d6e557109d758c73a9448bc82" + }, + { + "type": "tree", + "hash": "c180e8af07cc1d6f631f49a9d6230c7152291eeb" + }, + { + "type": "tree", + "hash": "c7a3125313417fd36078427aefb6ee326eb1c558" + }, + { + "type": "tree", + "hash": "6f01a3bfbb2c5d80e10c5e9caf3936b4a67099f0" + }, + { + "type": "tree", + "hash": "d256d71f4684181ec648d1bd14736a7d96dfb84e" + }, + { + "type": "tree", + "hash": "4e1b8e69cd64af86ed76506dabdbe8cc1bc067c9" + }, + { + "type": "blob", + "hash": "dbf748f9553ba69e950cf091ddeebfc1a88b9bc8" + }, + { + "type": "tree", + "hash": "0b354c555510c4d52602f73b1ca95ae9ec2fd03d" + }, + { + "type": "blob", + "hash": "232a311053f759658a9f344c7aae40056c5e5053" + }, + { + "type": "blob", + "hash": "a5c6565851ac9d0ba9e2b510ecce39e25a45ced8" + }, + { + "type": "tree", + "hash": "f66d031d9c442349194f83ca8a30bf79bd2f9785" + }, + { + "type": "tree", + "hash": "396ca29d4ef7dd55ceb02cd390610ef126a22340" + }, + { + "type": "blob", + "hash": "81bd49d90d86104239685980aa56b1457502d101" + }, + { + "type": "blob", + "hash": "eaa7815778cc595612c97335e2cda0174a26f4c5" + }, + { + "type": "blob", + "hash": "4398d99e07d61bbe76de7403e52247787cc30d1c" + }, + { + "type": "blob", + "hash": "e837144d48ec2c23fb50b1ee67662bc4b67784db" + }, + { + "type": "tree", + "hash": "d32b9cf88901e2cf649b1bcd783025768a542c7c" + }, + { + "type": "blob", + "hash": "dc0f07c453048491d62394f6355f708c7648ce46" + }, + { + "type": "tree", + "hash": "adc3a61ae9d7186ce8b363162914552c246e8ccf" + }, + { + "type": "blob", + "hash": "753a842c0fc6ee9fae7306471268bc23adab43c6" + }, + { + "type": "tree", + "hash": "1fa97ca1be2c385728431d62be61b2bbebfa4c4d" + }, + { + "type": "tree", + "hash": "a5c5c3e70fa7e3b79dd41642f2dc9b2fdafb5c4c" + }, + { + "type": "tree", + "hash": "dac3189f13defef2826d11672eac4de0726f2568" + }, + { + "type": "tree", + "hash": "219a16404bd7ecb6c077fc5f147bd6888aa1d7d7" + }, + { + "type": "tree", + "hash": "23537c8ba36c2f6f1bbd821e13d3b271f742fb9f" + }, + { + "type": "tree", + "hash": "a22c9d2e590a1cd14056907827822408580f15ee" + }, + { + "type": "blob", + "hash": "a27ccb5ea633b2520b750d2d55d861085410d2eb" + }, + { + "type": "tree", + "hash": "425ca5c9f068355616e3f550528c1d2a0312b745" + }, + { + "type": "tree", + "hash": "a6011f47fa5a5239da8f540f48b44f8fbdb3bcb6" + }, + { + "type": "blob", + "hash": "0b18a108e739d3488cbd24a28bcc967cb0814690" + }, + { + "type": "blob", + "hash": "82d1cee06dd4ea5fe7f171592a13516c1de8e125" + }, + { + "type": "blob", + "hash": "f59bdcc3271e1f147657c416408f4262ddf5cb9b" + }, + { + "type": "blob", + "hash": "0e82967c6ec224daeb42b5661c6688d6de88f4f5" + }, + { + "type": "blob", + "hash": "b9dc30fd28853ac896782c5634aee4a2bfb8e05d" + }, + { + "type": "blob", + "hash": "9455ea85852649a1c1fe02f47fbf8a129511c2ab" + }, + { + "type": "blob", + "hash": "9176e1e7f7b66c5bb868f54fa32d76de22b62c69" + }, + { + "type": "tree", + "hash": "4bed3a8b73f4ec676e2d9f51eb3ce143e67133b9" + }, + { + "type": "tree", + "hash": "4fe4024d62563025b107370b0bd1be0c279ee16a" + }, + { + "type": "tree", + "hash": "5713bd2b45e9412ebe05296dae52869c94df619c" + }, + { + "type": "tree", + "hash": "12723384e8fb03e71d5c7cffe08fb77b4735a603" + }, + { + "type": "tree", + "hash": "1f0f647d3b06dd2a1036f6eb316dc79162c382f6" + }, + { + "type": "blob", + "hash": "960179f6b240560df8b74fe4d1b85e95e6c4997c" + }, + { + "type": "tree", + "hash": "612b67c3bd749e1ce43b8fb825551f43cc01da16" + }, + { + "type": "tree", + "hash": "dd9493e5cfbd2d58d65bcb5748f208d1ab733af8" + }, + { + "type": "blob", + "hash": "e210847bd0f7692217e0003069a01cce9e63b1f4" + }, + { + "type": "blob", + "hash": "2614fe3ea2cfb786b7afc77d32dec5d1a600394e" + }, + { + "type": "blob", + "hash": "783c480be1a3f65dbf9f9bd2906124fbec0d6e6d" + }, + { + "type": "blob", + "hash": "0f7aee8be62f49bf2098b95f06adae1e214fee3c" + }, + { + "type": "blob", + "hash": "1a0cf24a0c66c65b43e23954e9ddda5834c5bcbe" + }, + { + "type": "blob", + "hash": "9b2a1068bac9ba5a878b2e9f8c00f1d9593471dc" + }, + { + "type": "blob", + "hash": "168a92504a4224bbf23590082f6f41c6ceffc759" + }, + { + "type": "blob", + "hash": "e7a26aa529e5e9027af56e56d51c70e3ca44184c" + }, + { + "type": "tree", + "hash": "98196099db046bb45d24c0218b42b3b97f567f91" + }, + { + "type": "tree", + "hash": "ee48b8f5545acedca4b01b8805b85f95feaf84b4" + }, + { + "type": "blob", + "hash": "2fd59e43d39c320b3f13daac4f2f70664e07668a" + }, + { + "type": "tree", + "hash": "2dbb2dfeb10dbb47cc85703db36327f7107235ce" + }, + { + "type": "blob", + "hash": "e9de24e0f037fac5084c3f5926cacf5d0a17c9f8" + }, + { + "type": "blob", + "hash": "0488c8e8d1c69a42af13169647aefd1ee01ee5d0" + }, + { + "type": "blob", + "hash": "2d5366d32dbbd7b6655256308cf0f8d061810363" + }, + { + "type": "tree", + "hash": "577580de650851b6db5e5cb50f47ff77e935cd27" + }, + { + "type": "tree", + "hash": "4163e8aa2cc2afcbeb230acdd6f83c560033105f" + }, + { + "type": "blob", + "hash": "42a9e2f9f9ebcdb6aab36b7e8951e50c125d9067" + }, + { + "type": "blob", + "hash": "00f02724243be4561052cd766049d8382900a384" + }, + { + "type": "tree", + "hash": "f7e26b4c909d17df63f2ae2d1f7ed986aa70bba6" + }, + { + "type": "tree", + "hash": "b0c75d0fb830f1ea64ec7048f8baa98ed8aab3a2" + }, + { + "type": "blob", + "hash": "348bc6e0269b0ed5715eda6eb1429d84434649c4" + }, + { + "type": "blob", + "hash": "19f166a94e4f6d580f36d20cbeb238b596515759" + }, + { + "type": "blob", + "hash": "acca00dea51a411d192759d15986cc9b51080219" + }, + { + "type": "tree", + "hash": "ca017ab33696b28799eb9bc939aa3eefa1797c71" + }, + { + "type": "tree", + "hash": "1d8d4173089e6a0e8652563adff7c7494dc075ab" + }, + { + "type": "blob", + "hash": "94c466848ccb5c61a6c34110b680eca26f17747b" + }, + { + "type": "tree", + "hash": "cb875af375a0dbbaac1574813ecefa3e8a50b5e5" + }, + { + "type": "blob", + "hash": "65e615f4123db2e9588039cb1c3d64a5f8fcef23" + }, + { + "type": "blob", + "hash": "2476fba26b5676150f5167fe697aff0edb8b3f5d" + }, + { + "type": "tree", + "hash": "4d1a2bb293f4985631e5091604302202bde7acd0" + }, + { + "type": "blob", + "hash": "7fb5779769a907051bc7e6d3263f7d1d0c168be1" + }, + { + "type": "blob", + "hash": "057b5702768c43652fffdb2041b5f3a8a980abf4" + }, + { + "type": "blob", + "hash": "70d6feb80d8bfe3afebb0bee4401982d98e2eaa9" + }, + { + "type": "blob", + "hash": "82264b3995123fe397256fa4c4a3c507f75c93f1" + }, + { + "type": "tree", + "hash": "75efaccbf0b0f0ff440d74f7dd46208494bd8893" + }, + { + "type": "tree", + "hash": "de3407543b188f1bfd184c3a51cd2e835ba26907" + }, + { + "type": "blob", + "hash": "f15576ded7963f67c7ec23c2fc6b2fe0354b7bcc" + }, + { + "type": "blob", + "hash": "eae248179f2511b8b29248b1766441dd0b8341c4" + }, + { + "type": "tree", + "hash": "8458fd3d02bbe6fbd171ad348840d53a8495e213" + }, + { + "type": "tree", + "hash": "be6d8408e2591bc74dac048cbdd15f9243a92426" + }, + { + "type": "tree", + "hash": "4bf814bd07da6e1d490f81ea7347cb5d4edc565a" + }, + { + "type": "tree", + "hash": "500449276cd07e0747701809c58650fffeb294bd" + }, + { + "type": "tree", + "hash": "ebd6a565eabbe4fa419df367aad35736056adc35" + }, + { + "type": "tree", + "hash": "c85b683817a7bb5d82ba20f4933f205d7ee4024a" + }, + { + "type": "tree", + "hash": "18e56c7ff9e185430b123e513956bc5363850b56" + }, + { + "type": "blob", + "hash": "48b2c67c6fb812c098f8c841191aa8f6d7018d20" + }, + { + "type": "tree", + "hash": "e5ef5ee0b531ed033e6f43e0393a88dde545ca44" + }, + { + "type": "tree", + "hash": "27b992144caa5e330b9efd22a1d92ba15ee305eb" + }, + { + "type": "blob", + "hash": "2a657fc25d314c898f0d56acf34ccfc6b6a30919" + }, + { + "type": "blob", + "hash": "85d7b9f5ec5b01f28566a16b20ae9c662e25ad12" + }, + { + "type": "blob", + "hash": "64e84a7a67ff715beb15e435bb06ace69f8e705c" + }, + { + "type": "blob", + "hash": "f665e333d92c2f671995c30bd7bee6e240567e95" + }, + { + "type": "tree", + "hash": "f55b38821583c0dd342fba626f505239d879a28d" + }, + { + "type": "tree", + "hash": "eb1297306dfa988dd36789abd6b6943981556fd2" + }, + { + "type": "blob", + "hash": "ca38c6e5a1300476d22431cd10a4d268ab72c518" + }, + { + "type": "blob", + "hash": "a445a50eee5f784af8934042bf15ed69f966839d" + }, + { + "type": "tree", + "hash": "c358dc25b157fb0b3662c890af94c6a51fbc1642" + }, + { + "type": "tree", + "hash": "cfbb3aaef049e6d96784623f058a959fab00ed73" + }, + { + "type": "blob", + "hash": "7ae2221237c76fab3f5689e594949fb62b53717c" + }, + { + "type": "tree", + "hash": "11165d6aef4b65ca28003867e75b27ad17fa93a2" + }, + { + "type": "blob", + "hash": "fd00351c2fa76f7abd482585bc396dfa7fb3cda2" + }, + { + "type": "tree", + "hash": "fca4eaaa13e4362ec8d8bbc1c0003872510ab2f3" + }, + { + "type": "blob", + "hash": "06e8ae8ad0c158359c107ff541ced5c35b20cbcb" + }, + { + "type": "tree", + "hash": "c48ec8245edf34f7b52172460dbc5713b4086827" + }, + { + "type": "blob", + "hash": "f1ab92fa84fe9c8d1d0785cf077a73df5cd40727" + }, + { + "type": "blob", + "hash": "cb4a4c39499022b0cec46509f28e4da45b9fdbbc" + }, + { + "type": "blob", + "hash": "594b84370e0953d4d67d465ca9de656433de7e84" + }, + { + "type": "blob", + "hash": "5e95b1dd304f701a503d7f05ecb26079b9f0f116" + }, + { + "type": "tree", + "hash": "110e88bbfee0487f487119576feb81870c46b62a" + }, + { + "type": "blob", + "hash": "d9f60ddcba58cf01d5d4a39cc373662859c55ddb" + }, + { + "type": "blob", + "hash": "94f52cba2e8bd3b287182e0227292d84c2473ac6" + }, + { + "type": "tree", + "hash": "60024e44a018fd8884de9a1bbb58d8a80bde7824" + }, + { + "type": "tree", + "hash": "ca6ffef98d61742b3ef8acb944298b5b016ad2d0" + }, + { + "type": "tree", + "hash": "1747daa7cfbb674c38d1898b5e2118ae67169720" + }, + { + "type": "tree", + "hash": "117346395358cd48ec9717fb74afe3d898bceed5" + }, + { + "type": "tree", + "hash": "1d15a140a0369456896d20f1731b09e9506d1a25" + }, + { + "type": "tree", + "hash": "4ad976cf53eb65d9d59dfc410fd729633f2f703b" + }, + { + "type": "tree", + "hash": "50c5ffb335a37e49faf6b8a157ac18060e628d57" + }, + { + "type": "tree", + "hash": "6c2e2536a2ca37add02b2767f86e278b132686ab" + }, + { + "type": "blob", + "hash": "77681ae7d626b2d0386ffcb13d6741c637995f10" + }, + { + "type": "blob", + "hash": "ba78ccb3f9be7e779678ed59d6f23ea86bdeef05" + }, + { + "type": "blob", + "hash": "8f888693920c9b5a1d6e63e3099a6d946ede9e1b" + }, + { + "type": "tree", + "hash": "8c159b093b2cbb61491b5a24d606ef8665094528" + }, + { + "type": "tree", + "hash": "f4d9a7f2cafc03f85df976590367450f71f57f51" + }, + { + "type": "blob", + "hash": "d60a05e9abc05dc6c124f3bdefb1ddec0b3d319c" + }, + { + "type": "tree", + "hash": "2ef767463bc201fd103d3cafed0e5adbc77eca5a" + }, + { + "type": "tree", + "hash": "34bd993ebb057046c96d063bb856ea9159bcd184" + }, + { + "type": "blob", + "hash": "856aed7af246b69f9d0e47e30197c4c1488afc5c" + }, + { + "type": "blob", + "hash": "1fbc93951bf3e0c4f99f5ea232350ada8b3cd4be" + }, + { + "type": "tree", + "hash": "5e35f1b9aaa4e46f8e85097f0cf1f6e67c44239b" + }, + { + "type": "tree", + "hash": "b69f2267e6c7f8ceaef2ff44a8e186c81a2d58cc" + }, + { + "type": "tree", + "hash": "c0c3c16eecb59b377cc4a59c23cc6239d2e7ffda" + }, + { + "type": "tree", + "hash": "a9d95419beb13ba18a3067027a2f4c229bfeadac" + }, + { + "type": "blob", + "hash": "87135dbccab03704006840fec2544224ce9e43b3" + }, + { + "type": "tree", + "hash": "2b2730c43671b48e642836585862188facba35fe" + }, + { + "type": "blob", + "hash": "53fcacd1adf58336ea37fbbf2fa24dc3cb660636" + }, + { + "type": "blob", + "hash": "f022b976daec4dad4641219bdcdce28062566305" + }, + { + "type": "tree", + "hash": "ea46cb4ba0ba2ce3a6744cde59a0de1bf2cc6462" + }, + { + "type": "blob", + "hash": "d78478c26172a8ca4f29a9afcfae9e6a2e2d5028" + }, + { + "type": "tree", + "hash": "1af19d3b0ebd0a45ad576d00c0900051245493f6" + }, + { + "type": "tree", + "hash": "788897873fe0f4278f211cbba2d652dd88e3035f" + }, + { + "type": "blob", + "hash": "29d3c55d842dfa30624bc2d171edaa331d62e9dc" + }, + { + "type": "blob", + "hash": "d6904a154a45eb3ba85caba27dd0295009ae015b" + }, + { + "type": "tree", + "hash": "22a09c38576cb376117357a483cc1ba7973ce93a" + }, + { + "type": "blob", + "hash": "e21f9eca654cfa96f9410264fd4e0d0944da5d78" + }, + { + "type": "blob", + "hash": "466e6f3d4b66ea964f02a4c3d3ed939a7951b429" + }, + { + "type": "tree", + "hash": "778cc0e421c01770a5d1d10cf3cb080cd7a5b0df" + }, + { + "type": "blob", + "hash": "3a921b2f30f03f06139a95b09948c0d0750727d3" + }, + { + "type": "tree", + "hash": "18555c196400301950267dab3f28fb361a78d744" + }, + { + "type": "tree", + "hash": "383b678879dc151b0c872d27edca33d1cd52ed32" + }, + { + "type": "tree", + "hash": "5b24b46d3294438c50c7ffe620bd53b57eac9f24" + }, + { + "type": "tree", + "hash": "a4fe775137bac3f39c7087bb30d7a92e00240c69" + }, + { + "type": "blob", + "hash": "7410ac7b09ba1dac2d6005268e450737bd65780f" + }, + { + "type": "blob", + "hash": "cfd358d4b2a979a4af09a968cfe8348e52e93c95" + }, + { + "type": "tree", + "hash": "d9db0f969a519c870f901594889f2f4bffc84dc7" + }, + { + "type": "tree", + "hash": "48b533888bf609ca8e918e43bb7dd2b1f81d175c" + }, + { + "type": "tree", + "hash": "808316893855501705b0d818376534f8d51cc80b" + }, + { + "type": "blob", + "hash": "47f0fb235e17b4ec64e23107417aef899fb3ca51" + }, + { + "type": "blob", + "hash": "b323c35381aa7ff7b403700c3b6f9cd81fbceffb" + }, + { + "type": "tree", + "hash": "127927be81c843e4af75f9714c876e7f82760962" + }, + { + "type": "tree", + "hash": "4ce69c42c7b6602cdb0ccafde106f20ddd9f033d" + }, + { + "type": "blob", + "hash": "48b2ef0d72a276c81d215f7a46ca0f486befb8e6" + }, + { + "type": "tree", + "hash": "cd0de879e5fc9ddf2e32ce1ef20aa7c5cf8773f1" + }, + { + "type": "blob", + "hash": "0e5fca742c33a02fc01bdd01ca00143e693a0b48" + }, + { + "type": "tree", + "hash": "1b53fdadb14161e5e42070ab4df4b34d00896dd1" + }, + { + "type": "tree", + "hash": "8441c329626f90dfbf509990c824ea57ce7d8b14" + }, + { + "type": "blob", + "hash": "ee99d3dc26707ba3fa2ee1fa95d1a1e1d916369b" + }, + { + "type": "tree", + "hash": "f57ea66fb29097f4a6cfba5120fdef67259cd688" + }, + { + "type": "tree", + "hash": "677b6ecb68c1fe64ee6a302135b14d598b383d63" + }, + { + "type": "tree", + "hash": "6788da57b8fcf5867671c25091c263b39230e27d" + }, + { + "type": "tree", + "hash": "90ddeb417f494adead1bfb9288b941a3a78745d1" + }, + { + "type": "blob", + "hash": "49d94011dc1f29ec6bfab2ff12a5f3dbe7f7aa32" + }, + { + "type": "blob", + "hash": "9bc8a274f0ef17f0e7eeb0289754b693f29fc32d" + }, + { + "type": "tree", + "hash": "b26a3b31b34e1b83d16ac31722c77a9263589cfe" + }, + { + "type": "blob", + "hash": "8691a43c6d765ce496c5987866aa572d28ac7f34" + }, + { + "type": "tree", + "hash": "970cb1a0a56f291219664ccfda09aae65f2d90c0" + }, + { + "type": "blob", + "hash": "e885cedbc88748cbf29a255838609e4412e501c6" + }, + { + "type": "tree", + "hash": "a7ee969d1cfcc6f148ed58406c0a0dbcacef127d" + }, + { + "type": "tree", + "hash": "9b045247357087a9c9004bd6f988c08eeef5e722" + }, + { + "type": "blob", + "hash": "def0c2614b88c6df95ac49c1e0f5e13494301142" + }, + { + "type": "tree", + "hash": "e7778fa19a5ee86db24f231c3d35e0067166ef84" + }, + { + "type": "tree", + "hash": "c47aba1ec4e29dd8ea3bb88ce2f1b4c021f78c69" + }, + { + "type": "blob", + "hash": "50ee8ff3345798b1f65ea5d968280c601681b612" + }, + { + "type": "blob", + "hash": "184a12f4aec994258cc21f30b83ae28186d6345c" + }, + { + "type": "tree", + "hash": "118296c5fb1b67cdacc434d1d11abbbedc2abc53" + }, + { + "type": "tree", + "hash": "e2820514dc4726e74dfa3e9d1459698de01f6798" + }, + { + "type": "tree", + "hash": "fcf11563511e80dd2100ad6bfd2e758e0dad5114" + }, + { + "type": "tree", + "hash": "7df7469c0390d3949b46cd165ed81c3dcf405145" + }, + { + "type": "tree", + "hash": "f264f3281c927e6ea6666db882419112d38b5fb4" + }, + { + "type": "tree", + "hash": "18542c3ca12ea39acba5328ca29fb7ccd4e85df0" + }, + { + "type": "tree", + "hash": "d4fbf0365ec36e11a32ae2b9b84c716d887d4cac" + }, + { + "type": "blob", + "hash": "13eb3117fbbbdb18e66c72ec38126eef39b72eee" + }, + { + "type": "tree", + "hash": "b942b9bcdce3894dd88102a982456200399724f2" + }, + { + "type": "tree", + "hash": "9107976cf1b0e563b426229a5160df9cf18bef4d" + }, + { + "type": "tree", + "hash": "ce2b8f8ae1aa28d17847f0ed7aa6ef9caec5238b" + }, + { + "type": "blob", + "hash": "6da0eff1c0a5742b981364037b818ba6ec80e0f6" + }, + { + "type": "blob", + "hash": "535792e1928b03af394fc1ffc7236a3a099e5ec2" + }, + { + "type": "tree", + "hash": "0d6aae99f4cf6151e95d96572ce66d9b8b1fa5f2" + }, + { + "type": "tree", + "hash": "aec6e63ccba6cc258262c09ca89773ffe9d742bc" + }, + { + "type": "blob", + "hash": "bc44e535126e04824d4c3ddc2f82f798df5317ce" + }, + { + "type": "blob", + "hash": "2fea769e7cbb075d7b68706b0d74c626a1204de2" + }, + { + "type": "blob", + "hash": "d7365c57022db12e4f2c3ed992fa594dd8acf9df" + }, + { + "type": "blob", + "hash": "f35e81d966bceed9b258ffb341e33b1cf29647ec" + }, + { + "type": "tree", + "hash": "0cdcf7cb31c8658a3c8dd2863b8d1104b5a05386" + }, + { + "type": "blob", + "hash": "e8d0134146dcc971b57b9cb395600166954da27c" + }, + { + "type": "blob", + "hash": "c3e951f8b21cfe4a1f6dd6c4fd649da6f26d8664" + }, + { + "type": "blob", + "hash": "e0dfa4cf1ee2dd2756bb54e3002b58e37ddd211b" + }, + { + "type": "blob", + "hash": "2246ed3586981aded2e2f8d818cbe97bed3db3e8" + }, + { + "type": "blob", + "hash": "394a216647ccae9741a027c6bea198df8c93cd21" + }, + { + "type": "tree", + "hash": "6dc7dacacb294c621247470f388b455bcaeffb03" + }, + { + "type": "blob", + "hash": "565299de6aff84cce8a950b41c4fa968d537cd90" + }, + { + "type": "blob", + "hash": "1f5e0e478cc7236db484cb9dc5e99ee454158688" + }, + { + "type": "tree", + "hash": "a03286706c491c33e91cd1b053d155d2c410ffc6" + }, + { + "type": "blob", + "hash": "d2b3a9e865f7c6f429cd3da181158ec7b5c42773" + }, + { + "type": "blob", + "hash": "e3138361cf032a841e47279ee014723604b1b406" + }, + { + "type": "blob", + "hash": "cffc4953a5cd8bdd1bdbf97693f808c37751e387" + }, + { + "type": "tree", + "hash": "5768afb1d21c7a4750b750fc5786f111b90690b4" + }, + { + "type": "tree", + "hash": "02f1e9084d7a1afb9d5d95ac91be3f39c1e04e21" + }, + { + "type": "blob", + "hash": "2301942efc7aeb305d03c0182fea388486966464" + }, + { + "type": "blob", + "hash": "55b3328ffe46265563876fddc070282c21c641bf" + }, + { + "type": "tree", + "hash": "89373377713c1e44f9ca4223e73d9ab7afaa5d33" + }, + { + "type": "tree", + "hash": "3ceede138c5d255c2763dbf45f80aa6ed1cd215f" + }, + { + "type": "blob", + "hash": "26ef256fd19fc2b07d2078db4bdea2d5fbd66b99" + }, + { + "type": "tree", + "hash": "52e50b0f15b1c9748dde0c99c43c07ed1b2b1169" + }, + { + "type": "tree", + "hash": "0c9fd189d49dbf1284ffc1ba1bb5a9fdb90036a9" + }, + { + "type": "tree", + "hash": "554541610a8f24a96dafc3d94f848d067698da9a" + }, + { + "type": "blob", + "hash": "92a2d86875ca474d988cb599e692c6f760bde217" + }, + { + "type": "tree", + "hash": "3a5de0ff4ae26a4a040ab0a6b34cad314fc78fd1" + }, + { + "type": "blob", + "hash": "988424031e554346e050ef7c06c0f8b624b41302" + }, + { + "type": "tree", + "hash": "cac06c345ec5f78304968ee2cfdedfe190837b2a" + }, + { + "type": "blob", + "hash": "850963a76da98c04532338e5f95ae4ace8994a90" + }, + { + "type": "tree", + "hash": "039be289c17d0a6bafbb2bd8e176375d253ff150" + }, + { + "type": "tree", + "hash": "fa519b71917b850cb41ca47b43d419d53962e1f9" + }, + { + "type": "blob", + "hash": "b562e9ce587cb20152a71b10fd465fe84e5ac128" + }, + { + "type": "tree", + "hash": "7f700af6583f83ccb02d39d0a1ed28764726c969" + }, + { + "type": "tree", + "hash": "da5f003df417b53f995f5508b0969f70c1349679" + }, + { + "type": "tree", + "hash": "b9e1d53f1b08aedf0d219ced9cc51cbbd645bea3" + }, + { + "type": "blob", + "hash": "ffd6a8e1470eaa304d775de0ea741d56f164c6bf" + }, + { + "type": "tree", + "hash": "9ccd1a468a65720935d6f2a8a3669d3b3d907d35" + }, + { + "type": "blob", + "hash": "7cbe54c216eaaab2a3218d5dee6da52595c00c7c" + }, + { + "type": "tree", + "hash": "75813aa93ac2757f0ee1c0334f4a6afe36084ddd" + }, + { + "type": "blob", + "hash": "76acb4dc6de55f120de77864a2950c8e13c31145" + }, + { + "type": "blob", + "hash": "e55696ab4f6a70cc06a86215cb68acb39eaca190" + }, + { + "type": "tree", + "hash": "36e7770b47fa74b968cb2e4c384479b295c0d811" + }, + { + "type": "tree", + "hash": "b8a3635d786eb9a774a26242a2675b4f9cdf0e99" + }, + { + "type": "tree", + "hash": "e22368dd205d9e3a7e9f1d06da07a10bdd4a2108" + }, + { + "type": "blob", + "hash": "62d347b9e160a72fa65d17a3bc14f0970e43a494" + }, + { + "type": "tree", + "hash": "d18630c0c336984cec25b1088fbf5ed766e05729" + }, + { + "type": "tree", + "hash": "c2de8aef875e356cdd7d41e4ccb3940cde8526cc" + }, + { + "type": "blob", + "hash": "7151188f893d40676618e2b3cf722088efdc39a1" + }, + { + "type": "blob", + "hash": "04d8f111bf8d591226fd1315cec81e70ebcd762b" + }, + { + "type": "blob", + "hash": "43db1230ea8b0f5e99ce8a8a1babfe53daf73064" + }, + { + "type": "blob", + "hash": "e377cb929572ae10508447dc76876ba4a41d5838" + }, + { + "type": "tree", + "hash": "2a4d9e69c1ffb703952dbe53ae7635ef70399b7b" + }, + { + "type": "tree", + "hash": "8e35fcc9186677c9288c25643ce145b3a483f17e" + }, + { + "type": "tree", + "hash": "7a7361a5cf46465e210a6a775a96b010d5a6553e" + }, + { + "type": "tree", + "hash": "8cbafb2b26d601afc8fb2fe0796fa7ead4d4c8b0" + }, + { + "type": "tree", + "hash": "290659cff27e396fb7c69b410a2cb5cb97665098" + }, + { + "type": "tree", + "hash": "4ad4cf40e7ae91847e67fc52f0c7441510135d58" + }, + { + "type": "tree", + "hash": "b0e31d4230cb3bcd5779536658ab31c696a82605" + }, + { + "type": "tree", + "hash": "460a27478cb25339997f3c879074cb8f6580cfff" + }, + { + "type": "tree", + "hash": "b5193a40b909b3f33182c81f0b624bf0f9b3a554" + }, + { + "type": "tree", + "hash": "8f21bdfad70c8c2d9dbca40a4bf28c1893db5451" + }, + { + "type": "tree", + "hash": "021f5a0eeefe9d014e4436e363af8fe7a20e5894" + }, + { + "type": "tree", + "hash": "c3d214c76a5a5baf16990a50e02a7446cb4189f2" + }, + { + "type": "tree", + "hash": "653454b520b547a1f3b768a3976484a5b2c0b57b" + }, + { + "type": "tree", + "hash": "e2f230ba95eb993c7a7a18468da05fad6eab2266" + }, + { + "type": "blob", + "hash": "c1765e9dc88ef560515085615c6aebc5ffbeff81" + }, + { + "type": "blob", + "hash": "d9f9199d87988e3ce0c2a75985701a412c1c0d66" + }, + { + "type": "tree", + "hash": "e7580e9ab6ac8529cf4a06c3e89bcaec6c6cde66" + }, + { + "type": "blob", + "hash": "7cbf2f3d001db4ef8598ba9454a80d6b8702d2c2" + }, + { + "type": "blob", + "hash": "2823549c3ba38b3e7c02ce3ba9444cbc085f7a7f" + }, + { + "type": "blob", + "hash": "71fecc9e0a3aff76b90ee88723fc9494bcf8c0dc" + }, + { + "type": "tree", + "hash": "fa7a97a5327508ccf24b04941ed3513a323348a0" + }, + { + "type": "tree", + "hash": "58c919e5eb0951c0327f83f1723a8aeedd50111b" + }, + { + "type": "tree", + "hash": "c8460e0f3338fe826d8e9f9233b02182d2fb02be" + }, + { + "type": "blob", + "hash": "12c922b857ce45e78909da11032816d63465927d" + }, + { + "type": "tree", + "hash": "027e63fd50e41bf7d9c1700b682db9392e8c08b8" + }, + { + "type": "tree", + "hash": "7f40a0cfa24206312488e9f508ef0945ffd07ad1" + }, + { + "type": "tree", + "hash": "e94bc22480559ab528a31b2e433f7870d389ee9b" + }, + { + "type": "tree", + "hash": "0a08ed16988b6a006be3199ad7b470c46c0313be" + }, + { + "type": "tree", + "hash": "3f8f11816291bc9039112a2bd0851ff3cb72b124" + }, + { + "type": "tree", + "hash": "66a79a6291334a3f12e960915807575c336a99fc" + }, + { + "type": "blob", + "hash": "7c263064ab0aae22c227bb75616d50d6e51d50e4" + }, + { + "type": "tree", + "hash": "2ad33e63b0618f0a3b6becf6153e702425db3b32" + }, + { + "type": "tree", + "hash": "f94efd2a52781400aad46721fe8263a58f4ff398" + }, + { + "type": "blob", + "hash": "66309453d09d47b8371fcc3b94f9862216aa34f0" + }, + { + "type": "tree", + "hash": "b154f38f432a42b5637513ff9e2cb47dd773a053" + }, + { + "type": "tree", + "hash": "fc0bb367417d47ac932cfa1ac617f12a312db7a7" + }, + { + "type": "blob", + "hash": "26c6f15ba30ebbff5467c60115c42d63ef481404" + }, + { + "type": "tree", + "hash": "dff52be0f07c61e1214bfc395e0b34d52274a334" + }, + { + "type": "blob", + "hash": "410d2511682702849f9eb040735a5aa0c43b2c46" + }, + { + "type": "tree", + "hash": "ead0aab2e6875020b622d751febee68f708cedfa" + }, + { + "type": "tree", + "hash": "00d11ebdc627f5c2af76510817ff796aa1053f3e" + }, + { + "type": "tree", + "hash": "0168825a38affb6bf79d614973bc7ed37979b9d8" + }, + { + "type": "tree", + "hash": "7cc7e8b91153fbc9509e45f99596dda5677af77c" + }, + { + "type": "blob", + "hash": "02cba740f0562648037e2b9ed012894ea49f74e3" + }, + { + "type": "tree", + "hash": "951704e74101b94356e9fc222a0bc5724f73cd92" + }, + { + "type": "tree", + "hash": "7845a4b30890841437436e2494f6318d05da9091" + }, + { + "type": "tree", + "hash": "35dda229f594e1a44de1bda1011d6a50ef199f5d" + }, + { + "type": "tree", + "hash": "ee6cf15ff29bab6718f05ecc7bcfebc07809ff61" + }, + { + "type": "tree", + "hash": "14a429892ba29963076c7063bfeea8961c05ca3c" + }, + { + "type": "tree", + "hash": "25502cfc1b19025b8da123d904b0b60ea7816821" + }, + { + "type": "tree", + "hash": "ad24121de1504802cf80d02f67980a7a5ed9c750" + }, + { + "type": "blob", + "hash": "9d54186827239e4869475023f29cae1079bc316a" + }, + { + "type": "blob", + "hash": "73e4ce81abc35de7e052df957c3ed19a66ea4c8f" + }, + { + "type": "blob", + "hash": "d2d3aaf0ea3fecb72e6fdc15b9adae9bbe0ca4ca" + }, + { + "type": "tree", + "hash": "12f5aa2a94362d07bce8458d18b8be8930049345" + }, + { + "type": "tree", + "hash": "648af7e274e6bdf40cace893695e92e1a4e7d124" + }, + { + "type": "tree", + "hash": "3ec9c577b1a2a473105d7eefcc2da877495476ae" + }, + { + "type": "blob", + "hash": "287462c827a915cc309a4f29b0b2e999a04ed63d" + }, + { + "type": "tree", + "hash": "81ca083aa2f9bb7006bd210550b891ce45fb24e6" + }, + { + "type": "tree", + "hash": "763d07eb27219f8dc3ea0f17b3026d2c89ea4306" + }, + { + "type": "blob", + "hash": "a53eedead660f76aa4822860e99ee8b2ed1c18e4" + }, + { + "type": "tree", + "hash": "52a7ed5b44e87834103ec0ebddcb33cc959a9905" + }, + { + "type": "blob", + "hash": "62a8216506234239d4183b48130a1db949e3a5b5" + }, + { + "type": "tree", + "hash": "a206a46437911d01d3a3dbfda43b5b8b78d74e82" + }, + { + "type": "tree", + "hash": "4e9833c8f7ff33f626082ff651ddfbf092dbf1c4" + }, + { + "type": "tree", + "hash": "7b7c169512ed5c85040dbc751358cc619c13e05f" + }, + { + "type": "tree", + "hash": "3ec613fab0cd7e17ea25b772451f45ba098f4469" + }, + { + "type": "blob", + "hash": "0308745587410345c680cc1f7cfe20c5073831b9" + }, + { + "type": "tree", + "hash": "b06d1d5ffb06cf0e710d7af1ee0ad45efda094cb" + }, + { + "type": "tree", + "hash": "28b4bcbda6f226872a269f92fd5b90ccdb9216a4" + }, + { + "type": "tree", + "hash": "083461fbcb85c735514388551e17eca21439360d" + }, + { + "type": "tree", + "hash": "49cbdaf687ca70f709ccc7150a5e62fee3f7a332" + }, + { + "type": "blob", + "hash": "05017a5dcdc6d9a9322d67a63ad2fce7d25c979e" + }, + { + "type": "tree", + "hash": "0289ac6b18ed80746eefef55d7e0540baa691710" + }, + { + "type": "tree", + "hash": "55ab8e0b8e9825e20febe2d4c9164f21e17c4217" + }, + { + "type": "blob", + "hash": "d7faf117a8fc8efe89a0386c4ee5f2faef98086d" + }, + { + "type": "tree", + "hash": "070586176422fbccbf0e1b35a59d52b30c638000" + }, + { + "type": "tree", + "hash": "76928874375e1be068226a94441e87f261b0bd69" + }, + { + "type": "tree", + "hash": "cf1e0e0637c17803aee24c8184085a73fb10de84" + }, + { + "type": "tree", + "hash": "9527e17721c6b53ed4846dfea35382552755af90" + }, + { + "type": "blob", + "hash": "4f67ff37e2bb4e14da9fdadac34bfcdc6f6e8e6b" + }, + { + "type": "tree", + "hash": "4c2ebc8b7d97f6ea5f7217b40415e73cb17ded87" + }, + { + "type": "tree", + "hash": "11f8ae440d7bfbeec4a58257a251bf8ccc6e9a16" + }, + { + "type": "blob", + "hash": "f097eb80ce83035cefce4b1cf1333000dae6e14d" + }, + { + "type": "tree", + "hash": "fa072f29879cebc7a40058f737483c03510cb132" + }, + { + "type": "tree", + "hash": "30e05182b11b2b344a6f7fb20f1e2bd14cc56d73" + }, + { + "type": "tree", + "hash": "581091d2d35158fcda05bcaec4f27be8bda47439" + }, + { + "type": "tree", + "hash": "92292b9619f3e1a9daa89f7746ca20e14aaff950" + }, + { + "type": "blob", + "hash": "f4f7c995dcd108abeaa5c4cd30c455aa597c4893" + }, + { + "type": "tree", + "hash": "8195cb57665d5037d57dd0b572652176c70112dd" + }, + { + "type": "tree", + "hash": "e34a50cb37fc21762894d46c61af3ea1239e2bd1" + }, + { + "type": "blob", + "hash": "68bed003c0dc5e7c008cc20a570791a053d5e394" + }, + { + "type": "tree", + "hash": "8c875121e192a876070d69730e19efc9c63f56d0" + }, + { + "type": "tree", + "hash": "ed5cba635abdfa204e2881b7a0eb332d81fa2e26" + }, + { + "type": "tree", + "hash": "f59cab81247c32e3f6a10d280564fc2fd601c89f" + }, + { + "type": "blob", + "hash": "0f36c8f6b782ba574ed53fb04d7c38bbb9350148" + }, + { + "type": "tree", + "hash": "fa302728e03d93b2a3c355a6011312eef9739010" + }, + { + "type": "blob", + "hash": "0ee3cbe08b83c9417268874c8771f067cbc1d3d5" + }, + { + "type": "tree", + "hash": "b8caa65577971475280bb7d8b819550767c57a76" + }, + { + "type": "blob", + "hash": "6c2ad16ee039d17a35e6acbe71a6761dc1da1747" + }, + { + "type": "tree", + "hash": "45f2a5bf08b93dab55d1661b9fea5740f27f1dc2" + }, + { + "type": "blob", + "hash": "d5fcd8666532993ef26af77b74bdee2ae63ecfe2" + }, + { + "type": "blob", + "hash": "25ef96c3c411cbe8e2a4aa70911d4dea6208bc49" + }, + { + "type": "tree", + "hash": "7483d2d0e2aeb18d79930ca8a4ad0bd5be32e3dd" + }, + { + "type": "tree", + "hash": "f7221160be325e7ac6f29e9cb4b006b987099a6a" + }, + { + "type": "tree", + "hash": "cda77d677396badb85550aa6765dae1750ffb5a4" + }, + { + "type": "blob", + "hash": "73eb016e530b3d18c5300b1b43d28f0950b01cac" + }, + { + "type": "tree", + "hash": "a2b57f7faf7ea75c3d207e8d67390252c4265108" + }, + { + "type": "tree", + "hash": "5cfad76642d29809d2608ece454556d748237dd1" + }, + { + "type": "tree", + "hash": "a1996d58af51689d81d0270cfa61fe317150dac1" + }, + { + "type": "tree", + "hash": "e68ac8fa07758139c880121879b3cd9d464b0016" + }, + { + "type": "blob", + "hash": "d016da0209b7ab4051d219a3b1fc892b8e7bf780" + }, + { + "type": "tree", + "hash": "fe744a736fce65a6d76d2d67dc9ebb9f2233d4d1" + }, + { + "type": "tree", + "hash": "1c4f98abc6f339c3465d20337b30ee6243b35e17" + }, + { + "type": "tree", + "hash": "8b8817cb9cc856de5bb97e775ef1b6f1722ad4f9" + }, + { + "type": "blob", + "hash": "2279e6c395e655084a605715df2d53cfc48b53f2" + }, + { + "type": "blob", + "hash": "b0d4d38290603cc2b41e938a973c3b56962630a4" + }, + { + "type": "tree", + "hash": "855222aadf0a714a0959a86aeb2c5e5ff046bad2" + }, + { + "type": "tree", + "hash": "e9d48fcae135dd5983862066072e3bf24b466ee8" + }, + { + "type": "blob", + "hash": "a8e50a6f66791709b9802834b01258d360b62eb0" + }, + { + "type": "tree", + "hash": "73a93cfbbade5a3b31e2907f6420b8f6c778f7f8" + }, + { + "type": "tree", + "hash": "8e24a3f7b0e7256d3e090c1843d2f5525c585f42" + }, + { + "type": "blob", + "hash": "8bca27df1712f076861f3e71d9ea1e3538e4681c" + }, + { + "type": "tree", + "hash": "9d5226c9d7fbdb05cc7c0cd0ac320d29dbe8a531" + }, + { + "type": "tree", + "hash": "232f02e804ca38d64b4a8b24b6ed7afaf8aab99f" + }, + { + "type": "blob", + "hash": "5bf300dbb80f2aedf4174194ef8ddf73859d5caf" + }, + { + "type": "tree", + "hash": "aa34ecf57db8202d12e905fc06852b63db16cbc5" + }, + { + "type": "tree", + "hash": "05115d48a362d131c5fd8372000fe409e9cc3755" + }, + { + "type": "tree", + "hash": "118f7cf53f600e6b8567c5ce586367a6fd1745d7" + }, + { + "type": "tree", + "hash": "19e8e93196203834be3cc280261b340f618af080" + }, + { + "type": "tree", + "hash": "3c1766dccefcb1403daf003f4898b6717d40163f" + }, + { + "type": "tree", + "hash": "420e58cdece997e8e118dadbb753730fd300b655" + }, + { + "type": "tree", + "hash": "6a4e612a85c3ae856ce81c144966a049b6a80c89" + }, + { + "type": "tree", + "hash": "0c46f9fe749d40c9369ae9c8e6b2d80bff22c940" + }, + { + "type": "tree", + "hash": "90f8e9ccb4561558120d85380b56a8f43c50a150" + }, + { + "type": "tree", + "hash": "12d4c443db02385820d8d1ef8203dcf9691858e5" + }, + { + "type": "tree", + "hash": "918e23f6cc5555fd39f1e6c7bd509d419b2a3194" + }, + { + "type": "blob", + "hash": "3dc6f5cf66e3a1a193a0bd375c4dc853b7b25aab" + }, + { + "type": "tree", + "hash": "5c463a5465c26b7d1fd3070560fdde3e9d720134" + }, + { + "type": "tree", + "hash": "689306522322aa70de29f4a74da1d0fdd30ff8dd" + }, + { + "type": "tree", + "hash": "f9dacf43eb6608cf0b0c384fcaea0066e17e1818" + }, + { + "type": "tree", + "hash": "d5026a5ef48f5f3155afbb80705fe7c2fb537990" + }, + { + "type": "tree", + "hash": "a04fecffc872f918a1c3c53ac6ca4424101e7841" + }, + { + "type": "tree", + "hash": "dbf6d414d51385a747165cc2da1eb0c03ccf157f" + }, + { + "type": "tree", + "hash": "eaae73bd99e420258f2f2481788b405d22729a5c" + }, + { + "type": "tree", + "hash": "96d053dc1afbb11887a355927f476383024840f0" + }, + { + "type": "tree", + "hash": "70c1773c164d2a5092a6cb1637f358a2041be0b8" + }, + { + "type": "blob", + "hash": "384ab228277f110e426bc81d6ae161c56f7fdcfe" + }, + { + "type": "tree", + "hash": "c7586a21309fb2cf17a080996f6c34a99bb54a01" + }, + { + "type": "tree", + "hash": "e5b73a35ec5b91e9468c835cf13590d9ba3b3ca3" + }, + { + "type": "blob", + "hash": "089c761f3f35d7000905ec7ab8e0ec2004ba1d70" + }, + { + "type": "tree", + "hash": "b6a371232510db917d3557969387185ad5a18472" + }, + { + "type": "tree", + "hash": "855219b9a85f6677bb52efbecfc517672c567721" + }, + { + "type": "tree", + "hash": "702d7dd3fc97e37d243f9f25575e7af0e54b0fc2" + }, + { + "type": "blob", + "hash": "ee981560716f919c41431caa36969a3a0742b13d" + }, + { + "type": "tree", + "hash": "bfe56acaa3ace4611c3d046dd0ee3d684d09b697" + }, + { + "type": "tree", + "hash": "0c320bd11d1a70fe8340d798df9815139b37e2be" + }, + { + "type": "blob", + "hash": "d442e31e869e60a81435042eb3156185b0e77560" + }, + { + "type": "tree", + "hash": "e34f24aed8963ec183881ae3ef6ab5ef2c3c1d75" + }, + { + "type": "blob", + "hash": "3fb4e38cb70a3334af46adee4ea2efb4704309fd" + }, + { + "type": "tree", + "hash": "b2ac6cf0c374844a1841aa0b80d8c4d2c9232def" + }, + { + "type": "tree", + "hash": "f41dc85cb75b05992a4062512a76afbf948d9a36" + }, + { + "type": "tree", + "hash": "56120ab031ee07a928ffedcf0fae4090b7c1c2d1" + }, + { + "type": "tree", + "hash": "6b0b2a8fb75fea54159cc76026af893552bed5b4" + }, + { + "type": "blob", + "hash": "d0aa114d8e03a812723f3e59a2d0c50a9b2e2d57" + }, + { + "type": "tree", + "hash": "83aa814c4cdb75bced90b736fa35d80178fa8813" + }, + { + "type": "tree", + "hash": "4fd0af9ec0cd6b2ca3864a6871f3ad8cc9e008f8" + }, + { + "type": "tree", + "hash": "5d82f3ff8f7fe0f613127cc7fb76fc30ac64c14e" + }, + { + "type": "tree", + "hash": "8d452cbf453ca57731d4ec49c322bddc9f41e88b" + }, + { + "type": "blob", + "hash": "cb18fefcf1c457a3d6f92651372e83591d7c33a9" + }, + { + "type": "tree", + "hash": "e252719c7f0bd60048d2b6650605020865065a3d" + }, + { + "type": "blob", + "hash": "65454aee4b291d5bd3737fcc76b86037d2d5ebe0" + }, + { + "type": "tree", + "hash": "e73d7dfc62d3fbd9b3dea1da9cf5cb814c49349b" + }, + { + "type": "blob", + "hash": "2a182e8e40556186fd5606763da63c8910988f48" + }, + { + "type": "blob", + "hash": "43a1247b2b2909899c4e88d81aabe73c1c34e706" + }, + { + "type": "tree", + "hash": "0ab3c2443a8cbb6cbdff4d25c83a50fb09364021" + }, + { + "type": "tree", + "hash": "3a275a7a4eb4377f7754bb60c51c9638f3563892" + }, + { + "type": "tree", + "hash": "a359a3d9b05db9f3c655e11517f8b4b723200851" + }, + { + "type": "blob", + "hash": "8f4f27933b8e075c612260b90e40f2bd903eb403" + }, + { + "type": "blob", + "hash": "6ed887bbeea613337556140355425476e0c6915a" + }, + { + "type": "tree", + "hash": "2ca93f4f934be37629daaafd82c65d8610cece8f" + }, + { + "type": "tree", + "hash": "b57bec700f11bc4fb4f0b5c929c63c695be9ea65" + }, + { + "type": "blob", + "hash": "c78a2c5465c82031e2bfbab86c859b6d37f8152f" + }, + { + "type": "tree", + "hash": "f5a58f09d92f60985a80a3035e3d2346e9cc5582" + }, + { + "type": "blob", + "hash": "deffff17b1f4edc94afa4685e9f8ee40a7c6f5a8" + }, + { + "type": "tree", + "hash": "2518a94156ca4a7163a20a370052ada87a0ec97e" + }, + { + "type": "tree", + "hash": "fb5d54fb83b6cb956f75f491c76eb45a3f291f6a" + }, + { + "type": "blob", + "hash": "79fdf362af4580e8b6755190e19ee92ad05c1909" + }, + { + "type": "tree", + "hash": "836793b1d9d4f066fd4ff7637f996edb8fe74f12" + }, + { + "type": "blob", + "hash": "7e96bcf03240b82c7b5f3f62050084a761a4ebf6" + }, + { + "type": "blob", + "hash": "e1cac2ddcb95cb6c59507fb0e11910fb27e18a54" + }, + { + "type": "blob", + "hash": "536195d2c2d474d0556909c11cb8cd5b042d3255" + }, + { + "type": "tree", + "hash": "8404acbb0df65a5c43309fdf271f3ca323622159" + }, + { + "type": "blob", + "hash": "edf623e7919d4b4e97570d2ec82a1e07a6d3160d" + }, + { + "type": "blob", + "hash": "fe94672f76461266ccf93432a38a6418f05ac21f" + }, + { + "type": "blob", + "hash": "9ff17ce88bdae3110c9b4514a36204e53284393e" + }, + { + "type": "blob", + "hash": "0fcaa2036458ecc7e6ae4d8db39c631bd9434224" + }, + { + "type": "blob", + "hash": "7c9b37c8b76a58f243f6f0c495babaad37d96343" + }, + { + "type": "blob", + "hash": "1aa628036302e0274d52788fa78f33d1fdba0440" + }, + { + "type": "blob", + "hash": "df46f24f681d552821c174ab01b06fe04f41d3a2" + }, + { + "type": "blob", + "hash": "5b8cbbff2964e57937c35bdbc82346f24174aba5" + }, + { + "type": "tree", + "hash": "6aa5968e214590058519d1196f8dbfe935c0edc3" + }, + { + "type": "tree", + "hash": "a41b3594925a48c161ce2b5fd2fa1866dfac8a41" + }, + { + "type": "blob", + "hash": "d623a4af3d2494c8ca00445156779578906ca1a3" + }, + { + "type": "tree", + "hash": "2bc99f2d16bbb79ba75ced8db976e3fe7a8ac9e1" + }, + { + "type": "tree", + "hash": "564564da81a9ecf5a87d589dab1a6ec52fafb5c7" + }, + { + "type": "tree", + "hash": "6b49aeb41a4adf0df4a4a9a60b0489950f576258" + }, + { + "type": "blob", + "hash": "7b98779854d5ddb4f12b2ea95c029341d24edbbb" + }, + { + "type": "tree", + "hash": "37c07755ee32122b922b9d49c634a85a9dc3dce7" + }, + { + "type": "blob", + "hash": "4a98a59abeb8ee4f4d58751835230f884d479aa0" + }, + { + "type": "tree", + "hash": "386099eca3c64020ad7f53379e30268a9cd23745" + }, + { + "type": "blob", + "hash": "b27872cd5c294190e4ab7fac392b059af7170f42" + }, + { + "type": "blob", + "hash": "3bebc454d8326bb8575277e8d534755519b27352" + }, + { + "type": "tree", + "hash": "b16df09a9a8640af018070ae75ddf1521e51eab6" + }, + { + "type": "blob", + "hash": "a31540fbe1e026a377515132353958e07b09dd34" + }, + { + "type": "tree", + "hash": "b1fd74442617d6b46a0642eb2ea0d469a2616813" + }, + { + "type": "blob", + "hash": "712b23cc131692fbeb73d627ec7d84d0aba347ed" + }, + { + "type": "blob", + "hash": "bc07665baa80ae0ec94b38e60a2eebbe4fbadbbb" + }, + { + "type": "blob", + "hash": "945e97ced62b6ba7cbde48414138477bd440d5a4" + }, + { + "type": "blob", + "hash": "ae7a5bffd0a48a02ceaa4e8483e78086e8845ee1" + }, + { + "type": "tree", + "hash": "86850118dde016ab33c045ed1540daee6be54037" + }, + { + "type": "tree", + "hash": "264ab87f34f4dce5d41e81c853ae5b22e323dad6" + }, + { + "type": "tree", + "hash": "910018fbb33040d91cb4f4fc3121382bf5925e11" + }, + { + "type": "tree", + "hash": "a04146bd63800729c24377c1a30c4cbc53ba3182" + }, + { + "type": "blob", + "hash": "40db5952d821f63e9d55fed062e41cf22e11ad21" + }, + { + "type": "blob", + "hash": "b45aa7df5c2c09305f2ac5d281ce319e34220ba2" + }, + { + "type": "tree", + "hash": "0437a805b40686f011184c7ce870760a1a22f56e" + }, + { + "type": "tree", + "hash": "39e291dc0bf1769e564fda99b95e30a7345123e9" + }, + { + "type": "tree", + "hash": "490b1c70626bee9d0652ea9f5c8e61e2126d037f" + }, + { + "type": "blob", + "hash": "bd85b3d08e7622b8f57bae803717a9765fb7f1b5" + }, + { + "type": "tree", + "hash": "f1b54836fc9e5f7c8e2844eef1357c8ad09a6ff8" + }, + { + "type": "blob", + "hash": "e604a52fe902a2b25c63130905b8d8c6b1c52a81" + }, + { + "type": "blob", + "hash": "9feea48ddfa779809fa315786b73284f2f3f475f" + }, + { + "type": "blob", + "hash": "d3ce7f9f1e86816e9f9638131e34a271ebb98568" + }, + { + "type": "blob", + "hash": "6f5b96e7ebc7168abf56af1060aaf986f8633415" + }, + { + "type": "blob", + "hash": "39e6f3d4c4089298ed5bd41a26574fdecf3f7f98" + }, + { + "type": "blob", + "hash": "f89ba3db2d3454a710d8925cfac11250de47c167" + }, + { + "type": "blob", + "hash": "85fd3d76b06d85e0676fa49361423487eaa020a3" + }, + { + "type": "blob", + "hash": "45e8394c85bc9b5c0093ca06c30c59353a13b5e6" + }, + { + "type": "tree", + "hash": "fa05c7045765bf3e4941900e54511b9a24ac5008" + }, + { + "type": "blob", + "hash": "b2476afd56b88913d86136cf3688878fe060f7ea" + }, + { + "type": "tree", + "hash": "30307f9d2efc279a0d8d2a103aff547e7c453007" + }, + { + "type": "blob", + "hash": "211f70e4b4ffe5c30af121008f2b895fd7a57f7f" + }, + { + "type": "tree", + "hash": "cf5e42574be407f9a9122bb7a77202cd03746db5" + }, + { + "type": "tree", + "hash": "8cb3fc431e951509ef79d4d9021008f8bd002100" + }, + { + "type": "tree", + "hash": "d2db66edbf9b1e70de461a6cd962e4e17c18d66f" + }, + { + "type": "tree", + "hash": "d79c21a288fc77cf8c7a585f7e66c8e0878a2b19" + }, + { + "type": "tree", + "hash": "49ac3e64737699cf6a8be1e848b99fcd57c3b554" + }, + { + "type": "tree", + "hash": "0887c4fdb775e488d4584ee84cce1ccb26f370ca" + }, + { + "type": "tree", + "hash": "4247988c3d399cdde3dac619e83af17bc3d193e2" + }, + { + "type": "tree", + "hash": "44fc7230bec5a695b4894b81da1d17ce46b342c1" + }, + { + "type": "tree", + "hash": "eb535eb096c37649d9291762a8885bc863b6e891" + }, + { + "type": "tree", + "hash": "db7b752585b9265d291488090e6957017e608e6f" + }, + { + "type": "tree", + "hash": "4b08bd9642ebd6f7af56a331c5e9cee30a521cd9" + }, + { + "type": "blob", + "hash": "75dd966eba1586196000ae0477913198e6bac6d3" + }, + { + "type": "blob", + "hash": "6d23ad0e7c23d90632ed0cd520fed67cd707d067" + }, + { + "type": "tree", + "hash": "7583c097bbabfd7cfe67d33df289e2f1360125f1" + }, + { + "type": "tree", + "hash": "08abc6f8a162e4e219d12905ce793b9b21c7dc3b" + }, + { + "type": "tree", + "hash": "0a01fc850d3046114f2aca1679e4b85ca83367e0" + }, + { + "type": "tree", + "hash": "bddb9a1623487830affe6b783fedf8f3cdfca338" + }, + { + "type": "tree", + "hash": "ca95d1a0b57d8f078b119d1d376b93258a63990b" + }, + { + "type": "tree", + "hash": "5b3b2f4918695a9a55a3f189e37e9616af7c5e88" + }, + { + "type": "tree", + "hash": "ec6aa632f7a33321f2066b20005dcad9bed893f3" + }, + { + "type": "tree", + "hash": "b9209e26fd0ffffbaee2d6b8f8955b536660ba81" + }, + { + "type": "tree", + "hash": "31ffea6bde2b2e8f83d63aa038f5ec41f168cc81" + }, + { + "type": "blob", + "hash": "b9f270a1826b7afb5472d84b73dd272defe77903" + }, + { + "type": "tree", + "hash": "8e7cb703934cc76589bf2630540a1e1b5692e3da" + }, + { + "type": "tree", + "hash": "4fffcc9b6aa3232090313d724a2ea72b7ab93e16" + }, + { + "type": "tree", + "hash": "da7d734216b6930c01475266b8066f7121352808" + }, + { + "type": "tree", + "hash": "a131f6b72b6e2bbdb512cf81bb32f5e39d9e7264" + }, + { + "type": "blob", + "hash": "2632b328826a104a6d3212618be2e17b056080a5" + }, + { + "type": "tree", + "hash": "2e4fb9c4ffe0cecdfa4c88847dbb5cb5e58d2246" + }, + { + "type": "blob", + "hash": "9ca0eca9c13c9f9fae424327a7a04a235e8f9fed" + }, + { + "type": "tree", + "hash": "fd274060db61204345bb951760cb24f607ba9d0a" + }, + { + "type": "tree", + "hash": "bb032bb7f6614dc88ba8309848f365ddc1d28e71" + }, + { + "type": "blob", + "hash": "32165c8b7ae75743ddaacf46d5b8c09f53b28469" + }, + { + "type": "tree", + "hash": "89520d2ca715cf3e85f7fa1091b91205af85efc3" + }, + { + "type": "tree", + "hash": "cc579a50215efc1818cb0f7e618f350e19af7203" + }, + { + "type": "tree", + "hash": "f0ec23d16fecaf2d6813662821d70be09fba4dd0" + }, + { + "type": "blob", + "hash": "ba0e870df4b533dbddae3a0173948ca6d666b685" + }, + { + "type": "tree", + "hash": "e4cdd30f81e9393b357ce74e5d1483b386e177fc" + }, + { + "type": "tree", + "hash": "fa429708aca7050695115d91286a0d8092f7c308" + }, + { + "type": "tree", + "hash": "ad07f42916ab39989764608d3c941ab7a4954b82" + }, + { + "type": "tree", + "hash": "3b440c04348718a4db477ed5fe409312df91eeff" + }, + { + "type": "blob", + "hash": "4a2b2f6828b2bf0df0384189d8e87290042d0580" + }, + { + "type": "blob", + "hash": "2699c56cb08804c6ac06306fda4425600d239baf" + }, + { + "type": "tree", + "hash": "4be20c91eab700b39a9ffdb058c2e85641a9128c" + }, + { + "type": "tree", + "hash": "dfc66626db0743cd93287784d697cce90754f028" + }, + { + "type": "blob", + "hash": "5b84be548720f30b9d541fff3ca6bbf7f76587dc" + }, + { + "type": "tree", + "hash": "3af1251ef57a86d05c88235f94996225a0290f43" + }, + { + "type": "tree", + "hash": "73061b9cf09569cf0626b6f59d635a23f190bd12" + }, + { + "type": "tree", + "hash": "74f3861dab6fbe4e8884671d98cae7ae84a16e49" + }, + { + "type": "blob", + "hash": "44376bb9f77fe513dc0213eb2114382812d14bc3" + }, + { + "type": "tree", + "hash": "1a843ab71cde7b8c5e8d2c511ccbbafe69f29d09" + }, + { + "type": "tree", + "hash": "6e1cd13a9642459c9751f1090a80c7e4c5393285" + }, + { + "type": "tree", + "hash": "1bc8964c2cfaa91938ac32782cff88b9db46aa19" + }, + { + "type": "blob", + "hash": "c7fceeb0d0cad28f30a15dfc87480a55ac29a07e" + }, + { + "type": "tree", + "hash": "7e47f5e1cfadd1c3dc1b549902618894a1fe24d8" + }, + { + "type": "tree", + "hash": "2a9b44054de8015f738d01d3a6af45a816cb6e3b" + }, + { + "type": "tree", + "hash": "0be0d4c6c82b6ffc82daf079434cb5078fb90626" + }, + { + "type": "blob", + "hash": "af932f0dbc9b7b66595746d57741152b476db325" + }, + { + "type": "blob", + "hash": "81254fced1dba7a2038b4f66ae7d34f16f323de4" + }, + { + "type": "tree", + "hash": "d9c6e97a946d00f97052117ecc7ea867864a7540" + }, + { + "type": "tree", + "hash": "8522f2fc6e69e0606372d70cc67699074df3e563" + }, + { + "type": "blob", + "hash": "e2783dcced821289747631f428dfdf72693c2f09" + }, + { + "type": "blob", + "hash": "55d7aa9b98ecde19e94b3873a445e4d064d9af07" + }, + { + "type": "tree", + "hash": "be1573bc46554fa99becf686f6300ea658c009c5" + }, + { + "type": "tree", + "hash": "a275f750b58efdd9a3eacf7ecb0a4364faadc42a" + }, + { + "type": "tree", + "hash": "53597f2b77ffc4595bfc71fcad97f87674e43530" + }, + { + "type": "blob", + "hash": "346106b30d70c6e9a20ce8a9af52e06533994547" + }, + { + "type": "tree", + "hash": "7615ae621f73d3703c984a15053868a779ff68c5" + }, + { + "type": "blob", + "hash": "a57dcdf204048b41fd77da06978e353b8325ed7e" + }, + { + "type": "blob", + "hash": "ddd06bb3f1f76e5cec3973861c614f7fc3cb1df1" + }, + { + "type": "blob", + "hash": "ba66323084e830fac932b6f2afd4585b77fae913" + }, + { + "type": "tree", + "hash": "32c5c9e6614ff39b46fc10b5a5b5377d4660c18c" + }, + { + "type": "tree", + "hash": "f5548c657b8ba66e4587064e26e808548b9dfc11" + }, + { + "type": "tree", + "hash": "9a03249ed745a2a1f6fe4088231f837dad8ae125" + }, + { + "type": "tree", + "hash": "1e5f47f1c483eeb924c96da621bb4ddac088cdc3" + }, + { + "type": "tree", + "hash": "bdc4e32bed097cbd29eaf4a083a2791319115fd9" + }, + { + "type": "blob", + "hash": "4ddee6c15f53cb57cf37f27e136f085b8d5a1de6" + }, + { + "type": "blob", + "hash": "d42645f3f0bbf1d2286d7a5b257a44bfcad1c81a" + }, + { + "type": "tree", + "hash": "775a40ce3da78e7a92d2c542b9f28cbef31f71ee" + }, + { + "type": "blob", + "hash": "33c1559ff1022eac6259de4a422c634652b8aa8d" + }, + { + "type": "blob", + "hash": "02e646db1e00d54c8cd0d44a896ac1e2c552dd2b" + }, + { + "type": "tree", + "hash": "244d94ba7f25329a28658060f697005b03042878" + }, + { + "type": "blob", + "hash": "ce0def0632f11df5371a04edf2f3286189619b01" + }, + { + "type": "blob", + "hash": "79ad4db0f1c4c8c22b4090d04ce9dbfaf8679017" + }, + { + "type": "blob", + "hash": "17d25b1a492f769daca259f05c9b38a25441ee98" + }, + { + "type": "blob", + "hash": "dcf1314631fa9676331c8672b7fcf4b509531e89" + }, + { + "type": "tree", + "hash": "08234aeb2d6bf563944c4ee27c68c3d7543dd713" + }, + { + "type": "tree", + "hash": "0fb18c539bc22c4dc4664dfd7a594c9c5df4bd45" + }, + { + "type": "tree", + "hash": "741acf3e4d1dfc3707fec8bd1301bdafd685cf9f" + }, + { + "type": "tree", + "hash": "13912b594610753e99e4bd96bd692e7fa509e6e9" + }, + { + "type": "tree", + "hash": "58414277a593323754ea2fc3d9f2c30b0d55f101" + }, + { + "type": "tree", + "hash": "5266af1fef38653ec27d3333a8831a62ac40876e" + }, + { + "type": "tree", + "hash": "20598edd2df4a8598c673ed73f20d6880a8d2ee4" + }, + { + "type": "blob", + "hash": "d41dce722b6b3c2e0a1d96b9caea43da6c3b0feb" + }, + { + "type": "tree", + "hash": "69d5e02c6d20c2a7d62ebfb4dddebd38ddcc2d50" + }, + { + "type": "tree", + "hash": "91335433b0ead045ff7b427a57050a4c3b1fb818" + }, + { + "type": "tree", + "hash": "37abd8144bb811f2e1680a91e059e8d7274d5734" + }, + { + "type": "blob", + "hash": "f88fd7fb89fdc5786abe3d4dc7aa9c63a43915b8" + }, + { + "type": "tree", + "hash": "18a59017c23ddcc94988b203510f68251a271efe" + }, + { + "type": "tree", + "hash": "55ac9410266e19015aaf7a06a3ed2704fb8c6019" + }, + { + "type": "blob", + "hash": "7b3a2050d89f958e590bb7834f91cf6a7c6d67ac" + }, + { + "type": "tree", + "hash": "5289aa390a0db243050f24e305a9152040eb8814" + }, + { + "type": "blob", + "hash": "72dca39fa69c3431920c99c48d32bc33adea5e35" + }, + { + "type": "tree", + "hash": "8b3171e5574506e51b41c26221b0a3436d9d7f55" + }, + { + "type": "tree", + "hash": "5c5324d24452d981cc658fd0b54e4791a4ef2c1c" + }, + { + "type": "tree", + "hash": "e8eda42f2b0db27dbc95900cc0a8b0c5d01b59a4" + }, + { + "type": "tree", + "hash": "e8efc7545226fe1092683437c53d125c19ac1480" + }, + { + "type": "blob", + "hash": "c4c271f1b14be9822d90fce3d99742c2f47916e8" + }, + { + "type": "tree", + "hash": "1c5a2d1c564fe3bc4bb870313d28956c8ef8b553" + }, + { + "type": "blob", + "hash": "bd0498b808f8ed2ada1966c215e368aa889ebf13" + }, + { + "type": "tree", + "hash": "acc307af17552c999b1d2fa021754ee4dc99361f" + }, + { + "type": "blob", + "hash": "c8049230b3aac21b51c171e4a9c037071c81b1ef" + }, + { + "type": "blob", + "hash": "3b94339df2767a1bb41a270fb49ed9320a2d16ed" + }, + { + "type": "tree", + "hash": "49f4238442bf554ab507eadc18d7ac3a0e5596af" + }, + { + "type": "tree", + "hash": "44ec2e03632cd58cb54d195e47c368ba24ec31dc" + }, + { + "type": "tree", + "hash": "4697fb653a4c11f5709ec016d856ecae9ded67fc" + }, + { + "type": "blob", + "hash": "87b982538118573c41fede43ca91a4a25c4f9f20" + }, + { + "type": "tree", + "hash": "2b5189f1a77a044192678315033cc63ffd68841d" + }, + { + "type": "blob", + "hash": "60b1c8be5db6f5bae6e16c4ba89763aa5dfdb2f7" + }, + { + "type": "tree", + "hash": "dd22fae4e4b4b2af658eeb495cd4385a279fa2a8" + }, + { + "type": "tree", + "hash": "6e9c119f1239584c641f683db6293be5a8cc2a53" + }, + { + "type": "blob", + "hash": "67897a5120d29d7633840097eeb7b53f57931c3f" + }, + { + "type": "tree", + "hash": "eea377b07f1ad29cfb6c79a493fa887f25c8e3bc" + }, + { + "type": "tree", + "hash": "f18928b60bc83ab63b52a162b9834c7efe04db86" + }, + { + "type": "tree", + "hash": "fd446fc2dcbc5df767332214a5b8820696a5f741" + }, + { + "type": "tree", + "hash": "c14a04ccad34c9a1fee28384bb39f0104557ba75" + }, + { + "type": "tree", + "hash": "a10b00f67f041e7b3ef3c4d2d2c8e0ea29a5e254" + }, + { + "type": "blob", + "hash": "a469d20031aef7bd6a3f4c219e689a534f15a550" + }, + { + "type": "tree", + "hash": "09a671c4f589e82feea962ec43815a9be4e94f9d" + }, + { + "type": "blob", + "hash": "d1608c7d849953ccfcec3dacebd835ab5b1dfe0a" + }, + { + "type": "tree", + "hash": "4504f5215e96d261c820f1d69bc3d5e8723a5049" + }, + { + "type": "tree", + "hash": "0abe0b2445713611d4692ca14b31f9e4ba3aaa1c" + }, + { + "type": "blob", + "hash": "2c5fb5df77a0211429cc2e1fa1f07a49c57f7975" + }, + { + "type": "tree", + "hash": "6d709692141a60258bd79ddf019e152c035be2fa" + }, + { + "type": "tree", + "hash": "69f081dc7a8d20f4474ec7c29763d3f2f62356d2" + }, + { + "type": "blob", + "hash": "fc0c34289ccefd9d2a0931eb2eb01d1a5aa5454e" + }, + { + "type": "tree", + "hash": "65545036760e7e7f450adc27a5938d922fd1b6c9" + }, + { + "type": "tree", + "hash": "ead192cd73c867b3948ac6d8419e4a1bc401d1c2" + }, + { + "type": "tree", + "hash": "5dc1b0c69d0364e8899910bc2f57ae40b4d33584" + }, + { + "type": "blob", + "hash": "05f3b78437cb20dbba2790bc8867538db65a8a26" + }, + { + "type": "tree", + "hash": "88ae29dec6c71814f9921aa9c4aa61c1962a2294" + }, + { + "type": "blob", + "hash": "2540c1595ae2164dc94a43be4615375d25c35024" + }, + { + "type": "tree", + "hash": "4b28290278c5ab1ff439c7f810dfc17f55e6bc88" + }, + { + "type": "tree", + "hash": "f173a07ce219c6ef3d9e5b1c5509e928f11fdf09" + }, + { + "type": "tree", + "hash": "7c42465cc943c31f4e1c760975e679a18e2dfad8" + }, + { + "type": "blob", + "hash": "f4a2c5fe0bde743e500ac32f69cd55e9cb9490e1" + }, + { + "type": "tree", + "hash": "99e67a1860052f368d3b562e5dd898e0e713baa1" + }, + { + "type": "tree", + "hash": "166b3487de1048c9d1bc116adb3142d5d9b2e273" + }, + { + "type": "blob", + "hash": "20b0f6b6ff03715a5a774711694097b634b7d3b2" + }, + { + "type": "tree", + "hash": "2a40237689320450c7cf8cea95a609debf42db6d" + }, + { + "type": "tree", + "hash": "a67a9fe16b199620a1ceeeb226a7360e87916aba" + }, + { + "type": "tree", + "hash": "51ff6806a74fdbd3915303c3c21302a2d1ad9177" + }, + { + "type": "blob", + "hash": "512b0a48097f82a66255d7f3aa08c369be183531" + }, + { + "type": "tree", + "hash": "1052ef18f062d383cf970f406766d532f6012316" + }, + { + "type": "tree", + "hash": "ec250dd2c68f14d186cdc6ef3d4b49bbb3c37c29" + }, + { + "type": "blob", + "hash": "04305752760b233334dc71e035a5ce67e81b3250" + }, + { + "type": "tree", + "hash": "6a671ed9f8907234d3007c9c55570927cafb0a86" + }, + { + "type": "blob", + "hash": "fe62a97312f5fd49b1f1dea15c30c396788e1491" + }, + { + "type": "tree", + "hash": "4defb26c9aadee32ff0dd3c211838ea3bd1da304" + }, + { + "type": "tree", + "hash": "3237ff66b5cc3ada0882b0baab9cda02c932b005" + }, + { + "type": "tree", + "hash": "ad6aaa6458ac520d3ba460f6a2e75ac715ac76b6" + }, + { + "type": "blob", + "hash": "5ea1a4764f8dd023fde1dfb78b547f27d6277b21" + }, + { + "type": "blob", + "hash": "52cfc99ff19c2673f13d94e68dd79823a8950197" + }, + { + "type": "blob", + "hash": "a0fef85e60a05cee810b44f3f0f05ace82ea306b" + }, + { + "type": "blob", + "hash": "ffd2ddddeed9cb66ead6a6f88bb26eac5ce52322" + }, + { + "type": "tree", + "hash": "b8c4a98a5c7f15c8fcd43899c2c415076d4db50a" + }, + { + "type": "tree", + "hash": "ac6cf3c99d645e2de415e0d3bf8bbcd5d1faf48a" + }, + { + "type": "tree", + "hash": "3f536dbd7c79439ab385f5c12b53c64c7a8e0958" + }, + { + "type": "blob", + "hash": "7ca487896f68a2a8ec45eb9b52d2b00287f6a8bb" + }, + { + "type": "tree", + "hash": "79fe96b44996233a5d11537dcd037e20b2091a96" + }, + { + "type": "tree", + "hash": "3fd02b014d35d237ad19d80c4eb334b68eda4051" + }, + { + "type": "blob", + "hash": "736b90ee80aaa3e28e2a7d450e20dac8d30a9da7" + }, + { + "type": "tree", + "hash": "59f5b7bf4c4d1aae51513d987ca6aad108c27b16" + }, + { + "type": "tree", + "hash": "d1cb87c498e1c1746eea6b92ec89ca1c5095d1e0" + }, + { + "type": "tree", + "hash": "62593654f79354ed27278df5729228d423b0491e" + }, + { + "type": "blob", + "hash": "06b33577867e87c72923cc4d25a55bf7c8241f6a" + }, + { + "type": "tree", + "hash": "cd9cfe76b80267f33f4e4888b2661b6e71636f37" + }, + { + "type": "tree", + "hash": "509d7b42aee2682527c71eb131062e9791bca55b" + }, + { + "type": "blob", + "hash": "7fb881208bd3648236ba5f44cb917ad92e70efda" + }, + { + "type": "tree", + "hash": "b80965839b285d9652be814959ed58efc5a5bd7b" + }, + { + "type": "tree", + "hash": "7b024849c73241fedd2142269b3681b76311cb43" + }, + { + "type": "blob", + "hash": "566aff8ae19bced1cab27fc0100b5083e26fe3c7" + }, + { + "type": "tree", + "hash": "63580a37545c86c8b7657df51cab03d310c9e731" + }, + { + "type": "blob", + "hash": "9e00fa96062bb7a7d1db26970912f0cddb8242e2" + }, + { + "type": "tree", + "hash": "7b2d5cc7174a79ebe2873de8158630720633e5db" + }, + { + "type": "tree", + "hash": "8a852681670a76206daca033c2b485358af3a7a8" + }, + { + "type": "blob", + "hash": "9f382510a17d96392faabdda7c769e2943e9979a" + }, + { + "type": "tree", + "hash": "8baf473c75794801335837fad841ef445719ff63" + }, + { + "type": "tree", + "hash": "74e6f9a32356147c26da6637808547ec85c749ef" + }, + { + "type": "tree", + "hash": "fe6805a34f3e2ea80a8343e833fb70e84c6fab8f" + }, + { + "type": "tree", + "hash": "4a5d7c2feca4fb0bc3843df5bf351b6fe14cb37c" + }, + { + "type": "blob", + "hash": "d55e05498a8ece521915191112f70f33e032e685" + }, + { + "type": "tree", + "hash": "87c081520fe774e28b2e6c3dc52c1898e942497f" + }, + { + "type": "tree", + "hash": "1e4646ec0f79ac62d32d8358038bc49ff6a035fd" + }, + { + "type": "tree", + "hash": "06d74c99ef044c988523f6c924af99e240f469bc" + }, + { + "type": "tree", + "hash": "9599680b3670a44af1dc0ee90b94065acee4c4f3" + }, + { + "type": "blob", + "hash": "71c50152bb63a18143917bd58e98dd4a58ff197a" + }, + { + "type": "tree", + "hash": "ba1a96208b02d362a96d9479d63007996a6a4bb8" + }, + { + "type": "blob", + "hash": "3db14a5b42c8a200300a09c12e90750183888b85" + }, + { + "type": "blob", + "hash": "b15357fe569a0f1c717543172f074aba55369f3b" + }, + { + "type": "tree", + "hash": "0f0a6c019eadb1112a9c563555f22b8c2e0832c1" + }, + { + "type": "blob", + "hash": "de74a328ddd70a714d8f26ac8798657cabad1436" + }, + { + "type": "blob", + "hash": "12e1cb0d634e6e03fbb932ae25ec2aef3eb0486a" + }, + { + "type": "blob", + "hash": "4e7530369eb8c89b19e473ce3f982ff1360115fe" + }, + { + "type": "blob", + "hash": "49fb75edc245a5a269e9468c65b0b1bf6513c7e5" + }, + { + "type": "blob", + "hash": "9162c629aefdafe6661c586baaadc61a468e2b81" + }, + { + "type": "tree", + "hash": "f843f0c5e4da190f4c0747d208c9a4af1d6d3bf8" + }, + { + "type": "blob", + "hash": "3029e5a38c5459c939e15616e5bb4c0ce408e5cd" + }, + { + "type": "blob", + "hash": "5298634ce41f040eb700ffd6835c5f85beff49d9" + }, + { + "type": "blob", + "hash": "81b6a7de701af04f5d5bee88f8b5228e6ae6b8a4" + }, + { + "type": "blob", + "hash": "adeb7396aa3720815990715b6fc022e5a262a26c" + }, + { + "type": "tree", + "hash": "68c46a63532043735249a94c8c39521e0f888b10" + }, + { + "type": "tree", + "hash": "11a3fe10c28f68d73312d1b12bce3968ef564e9c" + }, + { + "type": "blob", + "hash": "7c30561e847d32374d88e5daba63dc321dce3d73" + } +] diff --git a/packages/packfile/src/PackfileParserStream.test.ts b/packages/packfile/src/PackfileParserStream.test.ts index abc7619..aeb00db 100644 --- a/packages/packfile/src/PackfileParserStream.test.ts +++ b/packages/packfile/src/PackfileParserStream.test.ts @@ -1,6 +1,11 @@ -import {createReadStream} from 'fs'; +import {createHash} from 'crypto'; +import {readFileSync, createReadStream} from 'fs'; import PackfileParserStream from './PackfileParserStream'; +const expectedEntries = JSON.parse( + readFileSync(__dirname + '/../samples/sample1.json', 'utf8'), +); + test('unpack sample', async () => { const entries: any[] = []; await new Promise((resolve, reject) => { @@ -11,19 +16,18 @@ test('unpack sample', async () => { input.on(`error`, (err) => reject(err)); parser.on(`error`, (err) => reject(err)); - // let index = 0; + let index = 0; parser.on(`data`, (entry) => { - // console.log(`type =`, entry.type); - // const expectedEntry = expectedEntries[index++]; - // expect({ - // type: entry.type, - // offset: entry.offset, - // body: createHash('sha1').update(entry.body).digest('hex'), - // }).toEqual({ - // type: expectedEntry.type, - // offset: expectedEntry.offset, - // body: createHash('sha1').update(expectedEntry.body).digest('hex'), - // }); + const expectedEntry = expectedEntries[index++]; + expect({ + type: entry.type, + hash: entry.hash, + body: createHash('sha1').update(entry.body).digest('hex'), + }).toEqual({ + type: expectedEntry.type, + hash: expectedEntry.hash, + body: expectedEntry.hash, + }); entries.push(entry); }); parser.on(`end`, () => resolve()); diff --git a/packages/packfile/src/index.ts b/packages/packfile/src/index.ts index 7e0fb63..bda071b 100644 --- a/packages/packfile/src/index.ts +++ b/packages/packfile/src/index.ts @@ -3,4 +3,4 @@ export {GitObjectType} from './types'; export {default as PackfileGeneratorStream} from './PackfileGeneratorStream'; export {default as PackfileParserStream} from './PackfileParserStream'; -export type { Store, Stores} from './PackfileParserStream'; +export type {Store, Stores} from './PackfileParserStream'; From fbe515cfd718b668f11bffb08b605416f09bf18c Mon Sep 17 00:00:00 2001 From: Forbes Lindesay Date: Fri, 3 Sep 2021 13:05:45 +0100 Subject: [PATCH 08/10] test: packfile generator stream --- .gitignore | 3 +- .../src/PackfileGeneratorStream.test.ts | 55 +++++++++++++++++++ .../packfile/src/PackfileGeneratorStream.ts | 26 ++++++--- 3 files changed, 76 insertions(+), 8 deletions(-) create mode 100644 packages/packfile/src/PackfileGeneratorStream.test.ts diff --git a/.gitignore b/.gitignore index 0f2c77e..382b752 100644 --- a/.gitignore +++ b/.gitignore @@ -95,4 +95,5 @@ app/tailwind.css.br bundle-cache package-entry-points.json -secrets/ \ No newline at end of file +secrets/ +packages/packfile/samples/output.pack \ No newline at end of file diff --git a/packages/packfile/src/PackfileGeneratorStream.test.ts b/packages/packfile/src/PackfileGeneratorStream.test.ts new file mode 100644 index 0000000..2be7371 --- /dev/null +++ b/packages/packfile/src/PackfileGeneratorStream.test.ts @@ -0,0 +1,55 @@ +import {createHash} from 'crypto'; +import {readFileSync, createReadStream, createWriteStream} from 'fs'; +import PackfileGeneratorStream from './PackfileGeneratorStream'; +import PackfileParserStream from './PackfileParserStream'; + +const expectedEntries = JSON.parse( + readFileSync(__dirname + '/../samples/sample1.json', 'utf8'), +); + +test('unpack sample, pack it again, and write to file', async () => { + await new Promise((resolve, reject) => { + createReadStream(__dirname + '/../samples/sample1.pack') + .on(`error`, (err) => reject(err)) + .pipe(new PackfileParserStream()) + .on(`error`, (err) => reject(err)) + .pipe(new PackfileGeneratorStream({entryCount: 2651})) + .on(`error`, (err) => reject(err)) + .pipe(createWriteStream(__dirname + '/../samples/output.pack')) + .on(`error`, (err) => reject(err)) + .on(`close`, () => resolve()) + }); +}); + +test('unpack sample, pack it again, then unpack it again', async () => { + const entries: any[] = []; + await new Promise((resolve, reject) => { + const parser = new PackfileParserStream(); + + createReadStream(__dirname + '/../samples/sample1.pack') + .on(`error`, (err) => reject(err)) + .pipe(new PackfileParserStream()) + .on(`error`, (err) => reject(err)) + .pipe(new PackfileGeneratorStream({entryCount: 2651})) + .on(`error`, (err) => reject(err)) + .pipe(parser); + + parser.on(`error`, (err) => reject(err)); + let index = 0; + parser.on(`data`, (entry) => { + const expectedEntry = expectedEntries[index++]; + expect({ + type: entry.type, + hash: entry.hash, + body: createHash('sha1').update(entry.body).digest('hex'), + }).toEqual({ + type: expectedEntry.type, + hash: expectedEntry.hash, + body: expectedEntry.hash, + }); + entries.push(entry); + }); + parser.on(`end`, () => resolve()); + }); + expect(entries.length).toBe(2651); +}); diff --git a/packages/packfile/src/PackfileGeneratorStream.ts b/packages/packfile/src/PackfileGeneratorStream.ts index 44c7787..742ee7f 100644 --- a/packages/packfile/src/PackfileGeneratorStream.ts +++ b/packages/packfile/src/PackfileGeneratorStream.ts @@ -4,11 +4,12 @@ import {createDeflate} from 'zlib'; import {GitRawObject, GitObjectTypeID} from './types'; export default class PackfileGeneratorStream extends Transform { - constructor({length}: {length: number}) { + constructor({entryCount}: {entryCount: number}) { const hash = createHash('sha1'); let writtenHead = false; const writeHead = () => { if (writtenHead) return; + writtenHead = true const head = Buffer.from([ 0x50, 0x41, @@ -18,10 +19,10 @@ export default class PackfileGeneratorStream extends Transform { 0, 0, 2, // version 2 - length >> 24, // Num of objects - (length >> 16) & 0xff, - (length >> 8) & 0xff, - length & 0xff, + entryCount >> 24, // Num of objects + (entryCount >> 16) & 0xff, + (entryCount >> 8) & 0xff, + entryCount & 0xff, ]); hash.update(head); this.push(head); @@ -32,17 +33,28 @@ export default class PackfileGeneratorStream extends Transform { writeHead(); const type = GitObjectTypeID[chunk.type]; // TODO: support packing deltas - this.push(packFrameHeader(type, chunk.body.length)); + + const space = chunk.body.indexOf(0x20); + if (space < 0) throw new Error('Invalid git object buffer'); + const nil = chunk.body.indexOf(0x00, space); + if (nil < 0) throw new Error('Invalid git object buffer'); + const body = chunk.body.subarray(nil + 1); + + const frameHeader = packFrameHeader(type, body.length) + hash.update(frameHeader) + this.push(frameHeader); + const deflateStream = createDeflate(); deflateStream .on('data', (chunk) => { + hash.update(chunk) this.push(chunk); }) .on('error', (err) => callback(err)) .on('end', () => { callback(); }) - .end(chunk.body); + .end(body); }, flush(callback) { writeHead(); From 5974381503bbfbee79bca41828ff9f8e1fd959e3 Mon Sep 17 00:00:00 2001 From: Forbes Lindesay Date: Mon, 13 Sep 2021 17:58:34 +0100 Subject: [PATCH 09/10] convert everything to streams --- package.json | 1 + packages/core/src/AsyncBuffer.ts | 123 ------- packages/core/src/index.ts | 1 - packages/http/package.json | 2 +- packages/http/src/HttpInterface.ts | 11 +- packages/http/src/createHttpHandler.ts | 85 ++--- packages/http/src/fetchObjects.integration.ts | 60 ++-- packages/http/src/fetchObjects.ts | 56 +-- packages/http/src/index.ts | 14 +- packages/http/src/initialRequest.ts | 21 +- packages/http/src/lsRefs.integration.ts | 41 +-- packages/http/src/lsRefs.ts | 41 ++- packages/packfile/src/PackfileParserStream.ts | 7 +- packages/protocol/package.json | 7 +- packages/protocol/src/CapabilityList.ts | 10 +- packages/protocol/src/FetchCommand.ts | 331 +++++++++--------- packages/protocol/src/InitialRequest.ts | 84 ++--- packages/protocol/src/LsRefsCommand.ts | 136 ++++--- packages/protocol/src/PktLines.test.ts | 83 +++-- packages/protocol/src/PktLines.ts | 158 +++++---- packages/protocol/src/index.ts | 16 +- packages/protocol/tsconfig.json | 1 - scripts/test-pull.js | 50 +-- yarn.lock | 85 ++++- 24 files changed, 732 insertions(+), 692 deletions(-) delete mode 100644 packages/core/src/AsyncBuffer.ts diff --git a/package.json b/package.json index 4403c7f..70efe2d 100644 --- a/package.json +++ b/package.json @@ -36,6 +36,7 @@ "scripts": { "http": "yarn workspace @rollingversions/git-http", "objects": "yarn workspace @rollingversions/git-objects", + "packfile": "yarn workspace @rollingversions/git-packfile", "protocol": "yarn workspace @rollingversions/git-protocol", "streams": "yarn workspace @rollingversions/git-streams", "build": "yarn build:links && yarn build:ts && yarn build:rollup", diff --git a/packages/core/src/AsyncBuffer.ts b/packages/core/src/AsyncBuffer.ts deleted file mode 100644 index e3acd26..0000000 --- a/packages/core/src/AsyncBuffer.ts +++ /dev/null @@ -1,123 +0,0 @@ -import {concat} from './utils'; - -export default class AsyncBuffer { - private data: Uint8Array; - private readonly source: AsyncIterableIterator; - private pointer = 0; - private consumed = 0; - constructor(source: AsyncIterableIterator) { - this.source = source; - this.data = new Uint8Array(0); - } - - get pos() { - return this.consumed + this.pointer; - } - - private async nextData(length: number) { - while (this.pointer + length > this.data.length) { - const {value, done} = await this.source.next(); - if (done) { - throw new Error( - 'done ' + this.pointer + ' ' + length + ' ' + this.data.length, - ); - } - if (this.data.length > 0) { - this.consumed += this.pointer; - this.data = concat(this.data.subarray(this.pointer), value); - this.pointer = 0; - } else { - this.data = value; - } - } - } - - next(): Promise; - next(length: number): Promise; - async next(length?: number) { - if (length !== undefined) { - await this.nextData(length); - return this.data.subarray(this.pointer, (this.pointer += length)); - } else { - await this.nextData(1); - return this.data[this.pointer++]; - } - } - - async nextInt32(): Promise { - await this.nextData(4); - let result = 0; - for (let i = 0; i < 4; i++) { - result = (result << 8) | this.data[this.pointer + i]; - } - return result; - } - - peek(): Promise; - peek(length: number): Promise; - async peek(length?: number) { - if (length !== undefined) { - await this.nextData(length); - return this.data.subarray(this.pointer, this.pointer + length); - } else { - await this.nextData(1); - return this.data[this.pointer]; - } - } - - async peekInt32(): Promise { - await this.nextData(4); - let result = 0; - for (let i = 0; i < 4; i++) { - result = (result << 8) | this.data[this.pointer + i]; - } - return result; - } - - rest(): AsyncIterableIterator; - rest(length: number): AsyncIterableIterator; - async *rest(length?: number): AsyncIterableIterator { - if (length !== undefined) { - while (length > this.data.length - this.pointer) { - const chunkSize = this.data.length - this.pointer; - if (chunkSize == 0) { - await this.nextData(1); - } else { - yield await this.next(chunkSize); - length -= chunkSize; - } - } - yield await this.next(length); - } else { - yield await this.next(this.data.length - this.pointer); - for await (const chunk of this.source) { - yield await chunk; - } - } - } - - async chunk() { - if (this.pointer === this.data.length) { - await this.nextData(1); - } - const pointer = this.pointer; - this.pointer = this.data.length; - return this.data.subarray(pointer); - } - - rewind(length: number) { - this.pointer -= length; - } - - async isDone() { - return this.nextData(1).then( - () => false, - () => true, - ); - } - - async complete() { - for await (const _ of this.rest()) { - } - } -} diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts index 6565674..77b090b 100644 --- a/packages/core/src/index.ts +++ b/packages/core/src/index.ts @@ -1,4 +1,3 @@ -export {default as AsyncBuffer} from './AsyncBuffer'; export {default as Buffer} from './Buffer'; export { decode, diff --git a/packages/http/package.json b/packages/http/package.json index e974474..f533d97 100644 --- a/packages/http/package.json +++ b/packages/http/package.json @@ -20,8 +20,8 @@ }, "dependencies": { "@rollingversions/git-protocol": "^0.0.0", - "@rollingversions/git-streams": "^0.0.0", "cross-fetch": "^3.0.6", + "http-basic": "^8.1.3", "https-proxy-agent": "^5.0.0" }, "devDependencies": {}, diff --git a/packages/http/src/HttpInterface.ts b/packages/http/src/HttpInterface.ts index d77e0b9..294310c 100644 --- a/packages/http/src/HttpInterface.ts +++ b/packages/http/src/HttpInterface.ts @@ -1,11 +1,16 @@ +export interface HttpResponse { + url: URL; + statusCode: number; + body: NodeJS.ReadableStream; +} export default interface HttpInterface< THeaders extends {set(name: string, value: string): unknown} > { createHeaders(url: URL): THeaders; - get(url: URL, headers: THeaders): AsyncIterableIterator; + get(url: URL, headers: THeaders): Promise; post( url: URL, headers: THeaders, - body: AsyncIterableIterator, - ): AsyncIterableIterator; + body: NodeJS.ReadableStream, + ): Promise; } diff --git a/packages/http/src/createHttpHandler.ts b/packages/http/src/createHttpHandler.ts index a8868b9..ea0c6cd 100644 --- a/packages/http/src/createHttpHandler.ts +++ b/packages/http/src/createHttpHandler.ts @@ -1,56 +1,47 @@ -import fetch, {Headers} from 'cross-fetch'; -import { - asyncIteratorToStream, - streamToAsyncIterator, -} from '@rollingversions/git-streams'; -import HttpInterface from './HttpInterface'; +import request from 'http-basic'; +import HttpInterface, {HttpResponse} from './HttpInterface'; const createHttpHandler = (options: { [key: string]: any; -}): HttpInterface => ({ - createHeaders: () => new Headers(), - get: async function* (url, headers) { - const response = await fetch(url.href, {...options, headers}); - if (!response.ok) { - throw new Error( - `Server responded to ${url.href} with status code ${ - response.status - }: ${await response.text()}`, +}): HttpInterface> => ({ + createHeaders: () => new Map(), + get: async (url, headers) => { + return await new Promise((resolve, reject) => { + request( + `GET`, + url.href, + {...options, headers: Object.fromEntries(headers.entries())}, + (err, res) => { + if (err) reject(err); + else + resolve({ + statusCode: res!.statusCode, + url: new URL(res!.url), + body: res!.body, + }); + }, ); - } - if (response.body) { - for await (const chunk of streamToAsyncIterator(response.body)) { - yield chunk; - } - } else { - yield new Uint8Array(await response.arrayBuffer()); - } - }, - post: async function* (url, headers, body) { - const response = await fetch(url.href, { - ...options, - method: 'POST', - headers, - // @ts-expect-error - on NodeJS this is a NodeJS stream, in the browser it is a browser stream - body: await asyncIteratorToStream(body), }); - if (!response.ok) { - console.error( - `Server responded to ${url.href} with status code ${response.status}`, - ); - throw new Error( - `Server responded to ${url.href} with status code ${ - response.status - }: ${await response.text()}`, + }, + post: async (url, headers, body) => { + return await new Promise((resolve, reject) => { + body.pipe( + request( + `POST`, + url.href, + {...options, headers: Object.fromEntries(headers.entries())}, + (err, res) => { + if (err) reject(err); + else + resolve({ + statusCode: res!.statusCode, + url: new URL(res!.url), + body: res!.body, + }); + }, + ) as NodeJS.WritableStream, ); - } - if (response.body) { - for await (const chunk of streamToAsyncIterator(response.body)) { - yield chunk; - } - } else { - yield new Uint8Array(await response.arrayBuffer()); - } + }); }, }); diff --git a/packages/http/src/fetchObjects.integration.ts b/packages/http/src/fetchObjects.integration.ts index 0ff7084..3332531 100644 --- a/packages/http/src/fetchObjects.integration.ts +++ b/packages/http/src/fetchObjects.integration.ts @@ -1,41 +1,37 @@ import {treeDepth} from '@rollingversions/git-protocol'; -import {asyncIteratorToArray} from '@rollingversions/git-streams'; -import fetchObjects, {FetchResponseEntryKind} from './fetchObjects'; +import fetchObjects from './fetchObjects'; import HttpProxy from './HttpProxy'; test('fetchObjects', async () => { - const results = await asyncIteratorToArray( - fetchObjects( - new URL( - 'https://github.com/RollingVersions/test-single-npm-package-github-actions.git', - ), - { - want: ['03ca392fee460157e6fef84f0dcd6679f66af891'], - have: ['cb73a4316c9d09477a54c564bffafec4fc54f7e0'], - filter: [treeDepth(0)], - }, - { - http: HttpProxy, - agent: 'rollingversions.com', - serverCapabilities: new Map([ - ['agent', 'git/github-gb13cc0c1a7bd'], - ['ls-refs', true], - ['fetch', 'shallow filter'], - ['server-option', true], - ['object-format', 'sha1'], - ]), - }, + const results: any[] = []; + const response = await fetchObjects( + new URL( + 'https://github.com/RollingVersions/test-single-npm-package-github-actions.git', ), + { + want: ['03ca392fee460157e6fef84f0dcd6679f66af891'], + have: ['cb73a4316c9d09477a54c564bffafec4fc54f7e0'], + filter: [treeDepth(0)], + }, + { + http: HttpProxy, + agent: 'rollingversions.com', + serverCapabilities: new Map([ + ['agent', 'git/github-gb13cc0c1a7bd'], + ['ls-refs', true], + ['fetch', 'shallow filter'], + ['server-option', true], + ['object-format', 'sha1'], + ]), + }, ); - expect( - results - .flatMap((e) => - e.kind === FetchResponseEntryKind.Object - ? [`${e.type}(${e.hash})`] - : [], - ) - .sort(), - ).toEqual([ + await new Promise((resolve, reject) => { + response + .on(`data`, (obj) => results.push(obj)) + .on(`error`, reject) + .on(`end`, () => resolve()); + }); + expect(results.map((e) => `${e.type}(${e.hash})`).sort()).toEqual([ 'commit(03ca392fee460157e6fef84f0dcd6679f66af891)', 'commit(a0762d4f1ef04a03c5a603f786ce598397b1610d)', ]); diff --git a/packages/http/src/fetchObjects.ts b/packages/http/src/fetchObjects.ts index 27c3204..4a4f5c9 100644 --- a/packages/http/src/fetchObjects.ts +++ b/packages/http/src/fetchObjects.ts @@ -2,30 +2,16 @@ import { composeFetchCommand, parseFetchResponse, FetchCommand, - FetchResponseEntryError, - FetchResponseEntry, - FetchResponseEntryHeader, - FetchResponseEntryKind, FetchResponseEntryObject, - FetchResponseEntryProgress, } from '@rollingversions/git-protocol'; import {ContextWithServerCapabilities} from './Context'; const defaultCapabilities: [string, string | boolean][] = [ ['object-format', 'sha1'], ]; -export type { - FetchCommand, - FetchResponseEntryError, - FetchResponseEntryHeader, - FetchResponseEntryProgress, - FetchResponseEntryObject, - FetchResponseEntry, -}; +export type {FetchCommand, FetchResponseEntryObject}; -export {FetchResponseEntryKind}; - -export default async function* fetchObjects< +export default async function fetchObjects< THeaders extends {set(name: string, value: string): unknown} >( repoURL: URL, @@ -42,19 +28,33 @@ export default async function* fetchObjects< headers.set('content-type', 'application/x-git-upload-pack-request'); headers.set('git-protocol', 'version=2'); headers.set('user-agent', ctx.agent); - yield* parseFetchResponse( - ctx.http.post( - url, - headers, - composeFetchCommand( - command, - new Map( - [ - ['agent', ctx.agent] as const, - ...defaultCapabilities, - ].filter(([key]) => ctx.serverCapabilities.has(key)), - ), + + const response = await ctx.http.post( + url, + headers, + composeFetchCommand( + command, + new Map( + [ + ['agent', ctx.agent] as const, + ...defaultCapabilities, + ].filter(([key]) => ctx.serverCapabilities.has(key)), ), ), ); + if (response.statusCode !== 200) { + const body = await new Promise((resolve, reject) => { + const body: Buffer[] = []; + response.body + .on(`data`, (chunk) => body.push(chunk)) + .on(`error`, reject) + .on(`end`, () => resolve(Buffer.concat(body))); + }); + throw new Error( + `Git server responded with status ${response.statusCode}: ${body.toString( + `utf8`, + )}`, + ); + } + return parseFetchResponse(response.body); } diff --git a/packages/http/src/index.ts b/packages/http/src/index.ts index b1dddb2..f73302c 100644 --- a/packages/http/src/index.ts +++ b/packages/http/src/index.ts @@ -1,4 +1,3 @@ -import {asyncIteratorToArray} from '@rollingversions/git-streams'; import HttpDefault from './createHttpHandler'; import initialRequest from './initialRequest'; import lsRefs from './lsRefs'; @@ -15,22 +14,11 @@ export const DEFAULT_HTTP_HANDLER = HttpDefault({}); export type { FetchCommand, - FetchResponseEntry, - FetchResponseEntryHeader, - FetchResponseEntryProgress, - FetchResponseEntryError, FetchResponseEntryObject, } from '@rollingversions/git-protocol'; -export { - blobNone, - blobLimit, - treeDepth, - FetchResponseEntryKind, -} from '@rollingversions/git-protocol'; +export {blobNone, blobLimit, treeDepth} from '@rollingversions/git-protocol'; export {initialRequest}; export {lsRefs}; export {fetchObjects}; - -export {asyncIteratorToArray}; diff --git a/packages/http/src/initialRequest.ts b/packages/http/src/initialRequest.ts index 26c4d46..a0180f3 100644 --- a/packages/http/src/initialRequest.ts +++ b/packages/http/src/initialRequest.ts @@ -18,6 +18,25 @@ export default async function initialRequest< const headers = ctx.http.createHeaders(url); headers.set('git-protocol', 'version=2'); headers.set('user-agent', ctx.agent); - const capabilities = await parseInitialResponse(ctx.http.get(url, headers)); + + const response = await ctx.http.get(url, headers); + + if (response.statusCode !== 200) { + const body = await new Promise((resolve, reject) => { + const body: Buffer[] = []; + response.body + .on(`data`, (chunk) => body.push(chunk)) + .on(`error`, reject) + .on(`end`, () => resolve(Buffer.concat(body))); + }); + throw new Error( + `Git server responded with status ${response.statusCode}: ${body.toString( + `utf8`, + )}`, + ); + } + console.log('response.url =', response.url.href); + + const capabilities = await parseInitialResponse(response.body); return {capabilities}; } diff --git a/packages/http/src/lsRefs.integration.ts b/packages/http/src/lsRefs.integration.ts index 4fa1309..05d6e51 100644 --- a/packages/http/src/lsRefs.integration.ts +++ b/packages/http/src/lsRefs.integration.ts @@ -1,30 +1,27 @@ -import {asyncIteratorToArray} from '@rollingversions/git-streams'; import lsRefs from './lsRefs'; import HttpProxy from './HttpProxy'; test('lsRefs', async () => { - const refs = await asyncIteratorToArray( - lsRefs( - new URL( - 'https://github.com/RollingVersions/test-single-npm-package-github-actions.git', - ), - { - symrefs: true, - peel: true, - refPrefix: ['refs/heads/', 'refs/tags/', 'HEAD'], - }, - { - http: HttpProxy, - agent: 'rollingversions.com', - serverCapabilities: new Map([ - ['agent', 'git/github-gb13cc0c1a7bd'], - ['ls-refs', true], - ['fetch', 'shallow filter'], - ['server-option', true], - ['object-format', 'sha1'], - ]), - }, + const refs = await lsRefs( + new URL( + 'https://github.com/RollingVersions/test-single-npm-package-github-actions.git', ), + { + symrefs: true, + peel: true, + refPrefix: ['refs/heads/', 'refs/tags/', 'HEAD'], + }, + { + http: HttpProxy, + agent: 'rollingversions.com', + serverCapabilities: new Map([ + ['agent', 'git/github-gb13cc0c1a7bd'], + ['ls-refs', true], + ['fetch', 'shallow filter'], + ['server-option', true], + ['object-format', 'sha1'], + ]), + }, ); expect(refs.find((r) => r.refName === 'HEAD')).toEqual({ objectID: expect.any(String), diff --git a/packages/http/src/lsRefs.ts b/packages/http/src/lsRefs.ts index 0c40ea5..2cad329 100644 --- a/packages/http/src/lsRefs.ts +++ b/packages/http/src/lsRefs.ts @@ -10,13 +10,13 @@ const defaultCapabilities: [string, string | boolean][] = [ ['object-format', 'sha1'], ]; export type {LsRefsCommand, LsRefsResponseEntry}; -export default async function* lsRefs< +export default async function lsRefs< THeaders extends {set(name: string, value: string): unknown} >( repoURL: URL, command: LsRefsCommand, ctx: ContextWithServerCapabilities, -): AsyncIterableIterator { +): Promise { const url = new URL( `${ repoURL.href.endsWith('.git') ? repoURL.href : `${repoURL.href}.git` @@ -27,19 +27,32 @@ export default async function* lsRefs< headers.set('content-type', 'application/x-git-upload-pack-request'); headers.set('git-protocol', 'version=2'); headers.set('user-agent', ctx.agent); - yield* parseLsRefsResponse( - ctx.http.post( - url, - headers, - composeLsRefsCommand( - command, - new Map( - [ - ['agent', ctx.agent] as const, - ...defaultCapabilities, - ].filter(([key]) => ctx.serverCapabilities.has(key)), - ), + const response = await ctx.http.post( + url, + headers, + composeLsRefsCommand( + command, + new Map( + [ + ['agent', ctx.agent] as const, + ...defaultCapabilities, + ].filter(([key]) => ctx.serverCapabilities.has(key)), ), ), ); + if (response.statusCode !== 200) { + const body = await new Promise((resolve, reject) => { + const body: Buffer[] = []; + response.body + .on(`data`, (chunk) => body.push(chunk)) + .on(`error`, reject) + .on(`end`, () => resolve(Buffer.concat(body))); + }); + throw new Error( + `Git server responded with status ${response.statusCode}: ${body.toString( + `utf8`, + )}`, + ); + } + return await parseLsRefsResponse(response.body); } diff --git a/packages/packfile/src/PackfileParserStream.ts b/packages/packfile/src/PackfileParserStream.ts index ee179b8..3983b25 100644 --- a/packages/packfile/src/PackfileParserStream.ts +++ b/packages/packfile/src/PackfileParserStream.ts @@ -49,7 +49,7 @@ export default class PackfileParserStream extends Transform { offsets, digest: createHash('sha1'), onEntry: (entry) => { - const type = GitObjectTypeID[entry.type]; + const type = GitObjectTypeID[entry.type] ?? `unknown`; const body = encodeRaw(type, entry.body); const hash = createHash('sha1').update(body).digest('hex'); @@ -270,6 +270,7 @@ async function refDelta(chunk: Buffer, ctx: BodyContext): Promise { ); } const ref = chunk.slice(0, 20).toString('hex'); + ctx.digest.update(chunk.slice(0, 20)); const remaining = chunk.slice(20); return await parseBody( remaining, @@ -321,11 +322,11 @@ async function parseBody( ); } const inputBuffer = Buffer.concat(inputBuffers); + ctx.digest.update(inputBuffer.slice(0, inflate.bytesWritten)); + const remaining = inputBuffer.slice(inflate.bytesWritten); onBody(outputBuffer, inputBuffer).then( () => { - ctx.digest.update(inputBuffer.slice(0, inflate.bytesWritten)); - const remaining = inputBuffer.slice(inflate.bytesWritten); resolve( parseHeader(remaining, { ...ctx, diff --git a/packages/protocol/package.json b/packages/protocol/package.json index c447ff0..b701664 100644 --- a/packages/protocol/package.json +++ b/packages/protocol/package.json @@ -20,10 +20,11 @@ }, "dependencies": { "@rollingversions/git-core": "^0.0.0", - "@rollingversions/git-packfile": "^0.0.0", - "@rollingversions/git-streams": "^0.0.0" + "@rollingversions/git-packfile": "^0.0.0" + }, + "devDependencies": { + "@types/node": "*" }, - "devDependencies": {}, "peerDependencies": {}, "engines": { "node": ">=14.0.0" diff --git a/packages/protocol/src/CapabilityList.ts b/packages/protocol/src/CapabilityList.ts index 7e44545..a2b9301 100644 --- a/packages/protocol/src/CapabilityList.ts +++ b/packages/protocol/src/CapabilityList.ts @@ -8,9 +8,10 @@ type Capabilities = Pick< >; export default Capabilities; -export function* composeCapabilityList( +export function composeCapabilityList( capabilities: Capabilities, -): Generator { +): PacketLine[] { + const result: PacketLine[] = []; for (const [key, value] of capabilities.entries()) { if (!/^[a-z0-9\-\_]+$/i.test(key)) { throw new Error(`Invalid capability key: "${key}"`); @@ -19,7 +20,7 @@ export function* composeCapabilityList( continue; } if (value === true) { - yield `${key}\n`; + result.push(`${key}\n`); } else { if ( !/^[a-z0-9\ \-\_\.\,\?\\\/\{\}\[\]\(\)\<\>\!\@\#\$\%\^\&\*\+\=\:\;]+$/i.test( @@ -28,7 +29,8 @@ export function* composeCapabilityList( ) { throw new Error(`Invalid capability value for "${key}": "${value}"`); } - yield `${key}=${value}\n`; + result.push(`${key}=${value}\n`); } } + return result; } diff --git a/packages/protocol/src/FetchCommand.ts b/packages/protocol/src/FetchCommand.ts index a868d92..6a718d5 100644 --- a/packages/protocol/src/FetchCommand.ts +++ b/packages/protocol/src/FetchCommand.ts @@ -1,17 +1,14 @@ -import {AsyncBuffer, decode, Type} from '@rollingversions/git-core'; -import {unpack} from '@rollingversions/git-packfile'; -import { - mergeAsyncIterator, - splitAsyncIterator, -} from '@rollingversions/git-streams'; +import {decode, Type} from '@rollingversions/git-core'; +import {PackfileParserStream} from '@rollingversions/git-packfile'; import { isSpecialPacket, - packetLineParser, - packetLinePrinter, + PacketLineGenerator, + PacketLineParser, SpecialPacketLine, } from './PktLines'; import ObjectFilter, {objectFiltersToString} from './ObjectFilter'; import Capabilities, {composeCapabilityList} from './CapabilityList'; +import {PassThrough, Transform} from 'stream'; // Sample Request: // 0016object-format=sha1 @@ -164,184 +161,184 @@ export default interface FetchCommand { packfileUriProtocols?: readonly string[]; } -export const composeFetchCommand = packetLinePrinter( - async function* composeLsRefsCommand( - command: FetchCommand, - capabilities: Capabilities, - ) { - yield `command=fetch\n`; - yield* composeCapabilityList(capabilities); - yield SpecialPacketLine.DelimiterPacket; - if (command.thinPack) { - yield `thin-pack\n`; - } - if (command.noProgress) { - yield `no-progress\n`; - } - if (command.includeTag) { - yield `include-tag\n`; - } - for (const want of command.want) { - yield `want ${want}\n`; - } - for (const have of command.have ?? []) { - yield `have ${have}\n`; - } - for (const shallow of command.shallow ?? []) { - yield `shallow ${shallow}\n`; - } - if (command.deepen !== undefined) { - yield `deepen ${command.deepen}\n`; - } - if (command.deepenRelative) { - yield `deepen-relative\n`; - } - if (command.deepenSince !== undefined) { - yield `deepen-since ${command.deepenSince}\n`; - } - for (const deepenNot of command.deepenNot ?? []) { - yield `deepen-not ${deepenNot}\n`; - } - if (command.filter?.length) { - yield `filter ${objectFiltersToString(...command.filter)}`; - } - for (const wantRefs of command.wantRefs ?? []) { - yield `want-ref ${wantRefs}\n`; - } - if (command.sidebandAll) { - yield `sideband-all\n`; - } - if (command.packfileUriProtocols?.length) { - yield `packfile-uris ${command.packfileUriProtocols.join(',')}\n`; - } - yield `done`; - yield SpecialPacketLine.FlushPacket; - }, -); - -export enum FetchResponseEntryKind { - Header, - Progress, - Error, - Object, - RawPackfileChunk, -} -export interface FetchResponseEntryHeader { - kind: FetchResponseEntryKind.Header; - text: string; -} -export interface FetchResponseEntryProgress { - kind: FetchResponseEntryKind.Progress; - text: string; -} -export interface FetchResponseEntryError { - kind: FetchResponseEntryKind.Error; - text: string; -} -interface FetchResponseEntryRawPackfileChunk { - kind: FetchResponseEntryKind.RawPackfileChunk; - chunks: AsyncBuffer; +export function composeFetchCommand( + command: FetchCommand, + capabilities: Capabilities, +): NodeJS.ReadableStream { + const packetLines = new PacketLineGenerator(); + packetLines.write(`command=fetch\n`); + for (const capability of composeCapabilityList(capabilities)) { + packetLines.write(capability); + } + packetLines.write(SpecialPacketLine.DelimiterPacket); + if (command.thinPack) { + packetLines.write(`thin-pack\n`); + } + if (command.noProgress) { + packetLines.write(`no-progress\n`); + } + if (command.includeTag) { + packetLines.write(`include-tag\n`); + } + for (const want of command.want) { + packetLines.write(`want ${want}\n`); + } + for (const have of command.have ?? []) { + packetLines.write(`have ${have}\n`); + } + for (const shallow of command.shallow ?? []) { + packetLines.write(`shallow ${shallow}\n`); + } + if (command.deepen !== undefined) { + packetLines.write(`deepen ${command.deepen}\n`); + } + if (command.deepenRelative) { + packetLines.write(`deepen-relative\n`); + } + if (command.deepenSince !== undefined) { + packetLines.write(`deepen-since ${command.deepenSince}\n`); + } + for (const deepenNot of command.deepenNot ?? []) { + packetLines.write(`deepen-not ${deepenNot}\n`); + } + if (command.filter?.length) { + packetLines.write(`filter ${objectFiltersToString(...command.filter)}`); + } + for (const wantRefs of command.wantRefs ?? []) { + packetLines.write(`want-ref ${wantRefs}\n`); + } + if (command.sidebandAll) { + packetLines.write(`sideband-all\n`); + } + if (command.packfileUriProtocols?.length) { + packetLines.write( + `packfile-uris ${command.packfileUriProtocols.join(',')}\n`, + ); + } + packetLines.write(`done`); + packetLines.write(SpecialPacketLine.FlushPacket); + packetLines.end(); + return packetLines; } -type RawFetchResponseEntry = - | FetchResponseEntryHeader - | FetchResponseEntryProgress - | FetchResponseEntryError - | FetchResponseEntryRawPackfileChunk; - export interface FetchResponseEntryObject { - kind: FetchResponseEntryKind.Object; type: Type; hash: string; body: Uint8Array; } -export type FetchResponseEntry = - | FetchResponseEntryHeader - | FetchResponseEntryProgress - | FetchResponseEntryError - | FetchResponseEntryObject; -// use split iterator to produce 4 "channels": -// 1. headers -// 2. packfile chunks -// 3. progress -// 4. errors -// parse the packfile chunks, then merge everything back together -// using mergeAsyncIterator -export const parseFetchResponse = packetLineParser(function parseLsRefsResponse( - response, -) { - async function* parseResponseLines(): AsyncGenerator { - let inPackfile = false; - for await (const pkt of response) { - if (isSpecialPacket(pkt)) { - continue; - } - if (inPackfile) { - const channel = await pkt.peek(); +export class FetchResponseMetadataParser extends Transform { + constructor() { + super({ + writableObjectMode: true, + readableObjectMode: false, + transform(pkt: SpecialPacketLine | Buffer, _encoding, cb) { + if (isSpecialPacket(pkt)) { + this.emit(`special`, pkt); + return cb(); + } + + const channel = pkt[0]; switch (channel) { case 1: - yield { - kind: FetchResponseEntryKind.RawPackfileChunk, - chunks: pkt.stream(), - }; + this.push(pkt.slice(1)); break; case 2: { - const text = decode(await pkt.toBuffer(), 1).trim(); - yield {kind: FetchResponseEntryKind.Progress, text}; + this.emit(`progress`, decode(pkt.slice(1)).trim()); break; } case 3: { - const text = decode(await pkt.toBuffer(), 1).trim(); - yield {kind: FetchResponseEntryKind.Error, text}; + this.emit(`error`, new Error(decode(pkt.slice(1)).trim())); break; } default: - await pkt.stream().complete(); - } - } else { - const text = await pkt.toString(); - if (text === 'packfile') { - inPackfile = true; - } else { - yield {kind: FetchResponseEntryKind.Header, text}; + break; } - } - } + cb(); + }, + }); } - const [metadata, packetChunks] = splitAsyncIterator( - parseResponseLines(), - (c) => (c.kind !== FetchResponseEntryKind.RawPackfileChunk ? c : undefined), - (c) => (c.kind === FetchResponseEntryKind.RawPackfileChunk ? c : undefined), - ); - async function* getRawChunks() { - for await (const {chunks} of packetChunks) { - // consume the channel identifier - chunks.next(); - yield* chunks.rest(); - } - } - async function* unpackRawChunks(): AsyncIterableIterator { - for await (const obj of unpack(getRawChunks())) { - yield { - kind: FetchResponseEntryKind.Object, - type: asType(obj.type), - hash: obj.hash, - body: obj.body, - }; - } - } - return mergeAsyncIterator(unpackRawChunks(), metadata); -}); +} -function asType(type: string): Type { - switch (type) { - case Type.blob: - case Type.commit: - case Type.tag: - case Type.tree: - return type; - default: - return Type.unknown; - } +// use split iterator to produce 4 "channels": +// 1. headers +// 2. packfile chunks +// 3. progress +// 4. errors +// parse the packfile chunks, then merge everything back together +// using mergeAsyncIterator +export function parseFetchResponse(response: NodeJS.ReadableStream) { + const output = new PassThrough({objectMode: true}); + response + .on('error', (err) => output.emit(`error`, err)) + .pipe(new PacketLineParser()) + .on('error', (err) => output.emit(`error`, err)) + .pipe(new FetchResponseMetadataParser()) + .on('error', (err) => output.emit(`error`, err)) + .on('progress', (progress) => output.emit(`progress`, progress)) + .pipe(new PackfileParserStream()) + .on('error', (err) => output.emit(`error`, err)) + .pipe(output); + return output; + // async function* parseResponseLines(): AsyncGenerator { + // let inPackfile = false; + // for await (const pkt of response) { + // if (isSpecialPacket(pkt)) { + // continue; + // } + // if (inPackfile) { + // const channel = await pkt.peek(); + // switch (channel) { + // case 1: + // yield { + // kind: FetchResponseEntryKind.RawPackfileChunk, + // chunks: pkt.stream(), + // }; + // break; + // case 2: { + // const text = decode(await pkt.toBuffer(), 1).trim(); + // yield {kind: FetchResponseEntryKind.Progress, text}; + // break; + // } + // case 3: { + // const text = decode(await pkt.toBuffer(), 1).trim(); + // yield {kind: FetchResponseEntryKind.Error, text}; + // break; + // } + // default: + // await pkt.stream().complete(); + // } + // } else { + // const text = await pkt.toString(); + // if (text === 'packfile') { + // inPackfile = true; + // } else { + // yield {kind: FetchResponseEntryKind.Header, text}; + // } + // } + // } + // } + // const [metadata, packetChunks] = splitAsyncIterator( + // parseResponseLines(), + // (c) => (c.kind !== FetchResponseEntryKind.RawPackfileChunk ? c : undefined), + // (c) => (c.kind === FetchResponseEntryKind.RawPackfileChunk ? c : undefined), + // ); + // async function* getRawChunks() { + // for await (const {chunks} of packetChunks) { + // // consume the channel identifier + // chunks.next(); + // yield* chunks.rest(); + // } + // } + // async function* unpackRawChunks(): AsyncIterableIterator { + // for await (const obj of unpack(getRawChunks())) { + // yield { + // kind: FetchResponseEntryKind.Object, + // type: asType(obj.type), + // hash: obj.hash, + // body: obj.body, + // }; + // } + // } + // return mergeAsyncIterator(unpackRawChunks(), metadata); } diff --git a/packages/protocol/src/InitialRequest.ts b/packages/protocol/src/InitialRequest.ts index 0aa8d29..23a7f8e 100644 --- a/packages/protocol/src/InitialRequest.ts +++ b/packages/protocol/src/InitialRequest.ts @@ -1,43 +1,49 @@ import Capabilities from './CapabilityList'; -import {isSpecialPacket, packetLineParser, SpecialPacketLine} from './PktLines'; +import {isSpecialPacket, PacketLineParser, SpecialPacketLine} from './PktLines'; -export const parseInitialResponse = packetLineParser( - async (packets): Promise => { - const capabilities = new Map(); - let isStart = true; - let gotVersion = false; - let gotVersionAtLeastOnce = false; - for await (const packet of packets) { - console.log('packet =', packet); - if (packet === SpecialPacketLine.FlushPacket) { - isStart = true; - gotVersion = false; - } - if (isSpecialPacket(packet)) { - continue; - } - const line = await packet.toString(); - if (gotVersion) { - const [key, ...value] = line.split('='); - if (value.length) { - capabilities.set(key, value.join('=')); - } else { - capabilities.set(key, true); +export async function parseInitialResponse( + response: NodeJS.ReadableStream, +): Promise { + const capabilities = new Map(); + let isStart = true; + let gotVersion = false; + let gotVersionAtLeastOnce = false; + await new Promise((resolve, reject) => { + response + .on(`error`, reject) + .pipe(new PacketLineParser()) + .on(`error`, reject) + .on(`data`, (packet: Buffer | SpecialPacketLine) => { + if (packet === SpecialPacketLine.FlushPacket) { + isStart = true; + gotVersion = false; } - } else if (isStart) { - if (line === 'version 2') { - gotVersion = true; - gotVersionAtLeastOnce = true; - } else { - isStart = false; + if (isSpecialPacket(packet)) { + return; } - } - } - if (!gotVersionAtLeastOnce) { - throw new Error( - `The server did not respond with "version 2" as the protocol`, - ); - } - return capabilities; - }, -); + const line = packet.toString(`utf8`).replace(/\n$/, ``); + if (gotVersion) { + const [key, ...value] = line.split('='); + if (value.length) { + capabilities.set(key, value.join('=')); + } else { + capabilities.set(key, true); + } + } else if (isStart) { + if (line === 'version 2') { + gotVersion = true; + gotVersionAtLeastOnce = true; + } else { + isStart = false; + } + } + }) + .on(`end`, () => resolve()); + }); + if (!gotVersionAtLeastOnce) { + throw new Error( + `The server did not respond with "version 2" as the protocol`, + ); + } + return capabilities; +} diff --git a/packages/protocol/src/LsRefsCommand.ts b/packages/protocol/src/LsRefsCommand.ts index f4ebd56..241f48b 100644 --- a/packages/protocol/src/LsRefsCommand.ts +++ b/packages/protocol/src/LsRefsCommand.ts @@ -1,8 +1,9 @@ +import {Transform} from 'stream'; import Capabilities, {composeCapabilityList} from './CapabilityList'; import { isSpecialPacket, - packetLineParser, - packetLinePrinter, + PacketLineGenerator, + PacketLineParser, SpecialPacketLine, } from './PktLines'; @@ -51,58 +52,81 @@ export interface LsRefsResponseEntry { peeled: string[]; } -export const composeLsRefsCommand = packetLinePrinter( - async function* composeLsRefsCommand( - command: LsRefsCommand, - capabilities: Capabilities, - ) { - yield `command=ls-refs\n`; - yield* composeCapabilityList(capabilities); - yield SpecialPacketLine.DelimiterPacket; - if (command.symrefs) { - yield `symrefs\n`; - } - if (command.peel) { - yield `peel\n`; - } - for (const prefix of command.refPrefix ?? []) { - yield `ref-prefix ${prefix}\n`; - } - yield SpecialPacketLine.FlushPacket; - }, -); +export function composeLsRefsCommand( + command: LsRefsCommand, + capabilities: Capabilities, +): NodeJS.ReadableStream { + const output = new PacketLineGenerator(); + output.write(`command=ls-refs\n`); + for (const line of composeCapabilityList(capabilities)) { + output.write(line); + } + output.write(SpecialPacketLine.DelimiterPacket); + if (command.symrefs) { + output.write(`symrefs\n`); + } + if (command.peel) { + output.write(`peel\n`); + } + for (const prefix of command.refPrefix ?? []) { + output.write(`ref-prefix ${prefix}\n`); + } + output.write(SpecialPacketLine.FlushPacket); + output.end(); + return output; +} + +export class LsRefsResponseParser extends Transform { + constructor() { + super({ + writableObjectMode: true, + readableObjectMode: true, + transform(pkt: SpecialPacketLine | Buffer, _encoding, cb) { + if (pkt === SpecialPacketLine.FlushPacket) { + return cb(); + } + if (isSpecialPacket(pkt)) { + return cb(new Error(`Unexpected packet: "${pkt}"`)); + } + const lineStr = pkt.toString(`utf8`).replace(/\n$/, ``); + const line = lineStr.split(' '); + if (line.length < 2) { + return cb(new Error(`Invalid line: "${line.join(` `)}"`)); + } + const [objectID, refName, ...refAttributes] = line; + const symrefTarget = + refAttributes + .filter((a) => a.startsWith('symref-target:')) + .map((a) => a.substr('symref-target:'.length)) + .find(() => true) ?? null; + const peeled = refAttributes + .filter((a) => a.startsWith('peeled:')) + .map((a) => a.substr('peeled:'.length)); + const entry: LsRefsResponseEntry = { + objectID, + refName, + symrefTarget, + peeled, + }; + this.push(entry); + cb(); + }, + }); + } +} -export const parseLsRefsResponse = packetLineParser( - async function* parseLsRefsResponse( - response, - ): AsyncIterableIterator { - for await (const pkt of response) { - if (pkt === SpecialPacketLine.FlushPacket) { - break; - } - if (isSpecialPacket(pkt)) { - throw new Error(`Unexpected packet: "${pkt}"`); - } - const lineStr = await pkt.toString(); - const line = lineStr.split(' '); - if (line.length < 2) { - throw new Error(`Invalid line: "${line.join(` `)}"`); - } - const [objectID, refName, ...refAttributes] = line; - const symrefTarget = - refAttributes - .filter((a) => a.startsWith('symref-target:')) - .map((a) => a.substr('symref-target:'.length)) - .find(() => true) ?? null; - const peeled = refAttributes - .filter((a) => a.startsWith('peeled:')) - .map((a) => a.substr('peeled:'.length)); - yield { - objectID, - refName, - symrefTarget, - peeled, - }; - } - }, -); +export async function parseLsRefsResponse( + response: NodeJS.ReadableStream, +): Promise { + return await new Promise((resolve, reject) => { + const result: LsRefsResponseEntry[] = []; + response + .on(`error`, reject) + .pipe(new PacketLineParser()) + .on(`error`, reject) + .pipe(new LsRefsResponseParser()) + .on(`error`, reject) + .on(`data`, (entry: LsRefsResponseEntry) => result.push(entry)) + .on(`end`, () => resolve(result)); + }); +} diff --git a/packages/protocol/src/PktLines.test.ts b/packages/protocol/src/PktLines.test.ts index 330f8ca..44935fb 100644 --- a/packages/protocol/src/PktLines.test.ts +++ b/packages/protocol/src/PktLines.test.ts @@ -1,9 +1,9 @@ import {decode, encode} from '@rollingversions/git-core'; import { printPktLine, - parsePktLines, isSpecialPacket, SpecialPacketLine, + PacketLineParser, } from './PktLines'; test('printPktLine', () => { @@ -16,28 +16,71 @@ test('printPktLine', () => { expect(decode(printPktLine(encode('hi\n')))).toBe('0007hi\n'); }); -test('parsePktLines', async () => { - const results: any[] = []; - for await (const line of parsePktLines( - (async function* () { - yield encode('0007hi\n'); - yield encode('0000'); - yield encode('0001'); - yield encode('0002'); - yield encode('0009hello'); - })(), - )) { - if (isSpecialPacket(line)) { - results.push(line); - } else { - results.push(await line.toString()); - } - } - expect(results).toEqual([ +test('PacketLineParser', async () => { + const input = Buffer.from( + [ + '0007hi\n', + '0000', + '0001', + '0002', + '0009hello', + '0009hello', + '0009hello', + '0009hello', + '0009hello', + ].join(``), + ); + const expectedOutput = [ 'hi', SpecialPacketLine.FlushPacket, SpecialPacketLine.DelimiterPacket, SpecialPacketLine.MessagePacket, 'hello', - ]); + 'hello', + 'hello', + 'hello', + 'hello', + ]; + for (let chunkSize = 1; chunkSize < input.length + 1; chunkSize++) { + const results = await new Promise((resolve, reject) => { + const lines: any[] = []; + const parser = new PacketLineParser(); + parser + .on(`data`, (line) => { + if (isSpecialPacket(line)) { + lines.push(line); + } else { + lines.push(line.toString(`utf8`).replace(/\n$/, ``)); + } + }) + .on(`error`, reject) + .on(`end`, () => resolve(lines)); + for (let i = 0; i < input.length; i += chunkSize) { + parser.write(input.slice(i, i + chunkSize)); + } + parser.end(); + }); + expect(results).toEqual(expectedOutput); + } }); +// test('PacketLineParser - Stream', async () => { +// const input = Buffer.from( +// ['0007hi\n', '0000', '0001', '0002', '0009hello'].join(``), +// ); +// const expectedOutput = `hi\nhello`; +// for (let chunkSize = 1; chunkSize < input.length + 1; chunkSize++) { +// const result = await new Promise((resolve, reject) => { +// const chunks: Buffer[] = []; +// const parser = new PacketLineParser({mode: 'stream'}); +// parser +// .on(`data`, (chunk) => chunks.push(chunk)) +// .on(`error`, reject) +// .on(`end`, () => resolve(Buffer.concat(chunks))); +// for (let i = 0; i < input.length; i += chunkSize) { +// parser.write(input.slice(i, i + chunkSize)); +// } +// parser.end(); +// }); +// expect(result.toString(`utf8`)).toEqual(expectedOutput); +// } +// }); diff --git a/packages/protocol/src/PktLines.ts b/packages/protocol/src/PktLines.ts index 6177af3..1982363 100644 --- a/packages/protocol/src/PktLines.ts +++ b/packages/protocol/src/PktLines.ts @@ -1,12 +1,6 @@ // https://git-scm.com/docs/protocol-common -import { - AsyncBuffer, - fromHex, - toHexChar, - concat, - encode, - decode, -} from '@rollingversions/git-core'; +import {fromHex, toHexChar, encode} from '@rollingversions/git-core'; +import {Transform} from 'stream'; export enum SpecialPacketLine { /** @@ -24,19 +18,14 @@ export enum SpecialPacketLine { } const SpecialPacketLineEncoded = { - [SpecialPacketLine.FlushPacket]: encode('0000'), - [SpecialPacketLine.DelimiterPacket]: encode('0001'), - [SpecialPacketLine.MessagePacket]: encode('0002'), + [SpecialPacketLine.FlushPacket]: Buffer.from('0000'), + [SpecialPacketLine.DelimiterPacket]: Buffer.from('0001'), + [SpecialPacketLine.MessagePacket]: Buffer.from('0002'), }; export type PacketLine = string | Uint8Array | SpecialPacketLine; -export interface NormalParsedPacketLine { - readonly peek: () => Promise; - readonly toString: () => Promise; - readonly toBuffer: () => Promise; - readonly stream: () => AsyncBuffer; -} +export type NormalParsedPacketLine = Buffer; export type ParsedPacketLine = NormalParsedPacketLine | SpecialPacketLine; export function isSpecialPacket(pkt: unknown): pkt is SpecialPacketLine { @@ -52,7 +41,7 @@ export function isSpecialPacket(pkt: unknown): pkt is SpecialPacketLine { // whether or not they contain the trailing LF (stripping the LF if present, and not // complaining when it is missing). -export function printPktLine(line: PacketLine): Uint8Array { +export function printPktLine(line: PacketLine): Buffer { if (isSpecialPacket(line)) { return SpecialPacketLineEncoded[line]; } @@ -63,7 +52,7 @@ export function printPktLine(line: PacketLine): Uint8Array { // The first four bytes of the line, the pkt-len, indicates the total length // of the line, in hexadecimal. The pkt-len includes the 4 bytes used to contain // the length’s hexadecimal representation. - const buffer = new Uint8Array(4 + line.length); + const buffer = Buffer.alloc(4 + line.length); buffer[0] = toHexChar(buffer.length >>> 12); buffer[1] = toHexChar((buffer.length >>> 8) & 0xf); buffer[2] = toHexChar((buffer.length >>> 4) & 0xf); @@ -73,65 +62,88 @@ export function printPktLine(line: PacketLine): Uint8Array { return buffer; } -export function packetLinePrinter( - fn: (...args: TArgs) => AsyncIterableIterator, -): (...args: TArgs) => AsyncIterableIterator { - return async function* (...args) { - for await (const line of fn(...args)) { - yield printPktLine(line); - } - }; -} -export function packetLineParser( - fn: ( - response: AsyncIterableIterator, - ...args: TArgs - ) => TResult, -): (response: AsyncIterableIterator, ...args: TArgs) => TResult { - return (response, ...args) => fn(parsePktLines(response), ...args); -} -export async function* parsePktLines( - response: AsyncIterableIterator, -) { - const buffer = new AsyncBuffer(response); - - while (!(await buffer.isDone())) { - yield await unpktLine(buffer); - } -} +/** + * In "stream" mode, the output is a binary stream containing all the data + * in the normal packet lines concatenated into a single stream. Events are + * emitted for: + * - flush_packet + * - delimiter_packet + * - message_packet + * + * In "line" mode, the output consists of a mix of values from the + * SpecialPacketLine enum, and `Buffer` objects representing a single + * normal packet line. + */ +export class PacketLineParser extends Transform { + constructor() { + let remainingOnLine = 0; + let buffer: Buffer[] = []; + const transform = (chunk: Buffer) => { + if (remainingOnLine !== 0) { + // Buffering a line + if (remainingOnLine > chunk.length) { + remainingOnLine -= chunk.length; + buffer.push(chunk); + return; + } -async function unpktLine(line: AsyncBuffer): Promise { - const size = fromHex(await line.next(4)); - if (size === 0) { - return SpecialPacketLine.FlushPacket; - } - if (size === 1) { - return SpecialPacketLine.DelimiterPacket; - } - if (size === 2) { - return SpecialPacketLine.MessagePacket; - } - const stream = new AsyncBuffer(line.rest(size - 4)); - return { - peek: () => stream.peek(), - toString: async () => { - const str = decode(await consume(stream.rest())); - if (str.endsWith('\n')) { - return str.substr(0, str.length - 1); + buffer.push(chunk.slice(0, remainingOnLine)); + this.push(Buffer.concat(buffer)); + const rest = chunk.slice(remainingOnLine); + buffer = []; + remainingOnLine = 0; + transform(rest); } else { - return str; + // parsing header (4 bytes) + buffer.push(chunk); + const buf = Buffer.concat(buffer); + if (buf.length < 4) { + return; + } + buffer = []; + const size = fromHex(buf.slice(0, 4)); + if (size === 0) { + this.push(SpecialPacketLine.FlushPacket); + transform(buf.slice(4)); + return; + } + if (size === 1) { + this.push(SpecialPacketLine.DelimiterPacket); + transform(buf.slice(4)); + return; + } + if (size === 2) { + this.push(SpecialPacketLine.MessagePacket); + transform(buf.slice(4)); + return; + } else { + remainingOnLine = Math.max(0, size - 4); + transform(buf.slice(4)); + return; + } } - }, - toBuffer: () => consume(stream.rest()), - stream: () => stream, - }; + }; + super({ + writableObjectMode: false, + readableObjectMode: true, + transform(chunk: Buffer, _encoding, cb) { + transform(chunk); + cb(); + }, + }); + } } -async function consume(stream: AsyncIterableIterator) { - const result: Uint8Array[] = []; - for await (const chunk of stream) { - result.push(chunk); +export class PacketLineGenerator extends Transform { + constructor() { + super({ + writableObjectMode: true, + readableObjectMode: false, + transform(line, _encoding, cb) { + this.push(printPktLine(line)); + cb(); + }, + }); } - return concat(...result); } diff --git a/packages/protocol/src/index.ts b/packages/protocol/src/index.ts index 1d1f667..910758e 100644 --- a/packages/protocol/src/index.ts +++ b/packages/protocol/src/index.ts @@ -2,12 +2,7 @@ import Capabilities from './CapabilityList'; import FetchCommand, { composeFetchCommand, parseFetchResponse, - FetchResponseEntryKind, - FetchResponseEntryError, - FetchResponseEntryHeader, - FetchResponseEntryProgress, FetchResponseEntryObject, - FetchResponseEntry, } from './FetchCommand'; import {parseInitialResponse} from './InitialRequest'; import LsRefsCommand, { @@ -24,18 +19,11 @@ import ObjectFilter, { export type {Capabilities}; export type {LsRefsCommand, LsRefsResponseEntry}; -export type { - FetchCommand, - FetchResponseEntryError, - FetchResponseEntryHeader, - FetchResponseEntryProgress, - FetchResponseEntryObject, - FetchResponseEntry, -}; +export type {FetchCommand, FetchResponseEntryObject}; export {parseInitialResponse}; export {composeLsRefsCommand, parseLsRefsResponse}; -export {composeFetchCommand, parseFetchResponse, FetchResponseEntryKind}; +export {composeFetchCommand, parseFetchResponse}; export type {ObjectFilter}; export {blobNone, blobLimit, sparse, treeDepth}; diff --git a/packages/protocol/tsconfig.json b/packages/protocol/tsconfig.json index 8d178d2..874c1b6 100644 --- a/packages/protocol/tsconfig.json +++ b/packages/protocol/tsconfig.json @@ -13,6 +13,5 @@ "references": [ {"path": "../core"}, {"path": "../packfile"}, - {"path": "../streams"}, ], } diff --git a/scripts/test-pull.js b/scripts/test-pull.js index eee02ef..068d544 100644 --- a/scripts/test-pull.js +++ b/scripts/test-pull.js @@ -75,27 +75,25 @@ async function pullRepo() { }); console.warn(`git_lsrefs`, `Git ls refs request ${repoURL.href}`); - const remoteRefs = await git.asyncIteratorToArray( - git.lsRefs( - repoURL, - { - // TODO: what do we need here? - // symrefs: true, - refPrefix: ['refs/heads/', 'refs/tags/', 'refs/pull/'], - }, - { - http, - agent: 'rollingversions.com', - serverCapabilities, - }, - ), + const remoteRefs = await git.lsRefs( + repoURL, + { + // TODO: what do we need here? + // symrefs: true, + refPrefix: ['refs/heads/', 'refs/tags/', 'refs/pull/'], + }, + { + http, + agent: 'rollingversions.com', + serverCapabilities, + }, ); for (const ref of remoteRefs) { console.warn(`ref:`, ref); } console.warn(`git_fetch_objects`, `Git fetch request ${repoURL.href}`); - for await (const entry of git.fetchObjects( + const fetchResponse = await git.fetchObjects( repoURL, { want: [...new Set(remoteRefs.map((ref) => ref.objectID))], @@ -107,17 +105,23 @@ async function pullRepo() { agent: 'rollingversions.com', serverCapabilities, }, - )) { - if (entry.kind === git.FetchResponseEntryKind.Object) { - if (gitObj.objectIsCommit(entry.body)) { - const commit = gitObj.decodeObject(entry.body); - console.warn(`${entry.hash} ${commit.body.message}`); - } - } - } + ); + await new Promise((resolve, reject) => { + fetchResponse + .on(`data`, (entry) => { + if (gitObj.objectIsCommit(entry.body)) { + const commit = gitObj.decodeObject(entry.body); + console.warn(`${entry.hash} ${commit.body.message}`); + } + }) + .on(`error`, reject) + .on(`end`, () => resolve()); + }); + console.log(`!done!`); } pullRepo().catch((ex) => { + console.error(`Request failed`); console.error(ex.stack); process.exit(1); }); diff --git a/yarn.lock b/yarn.lock index 711289f..d816da9 100644 --- a/yarn.lock +++ b/yarn.lock @@ -875,6 +875,11 @@ resolved "https://registry.yarnpkg.com/@types/node/-/node-16.6.2.tgz#331b7b9f8621c638284787c5559423822fdffc50" integrity sha512-LSw8TZt12ZudbpHc6EkIyDM3nHVWKYrAvGy6EAJfNfjusbwnThqjqxUKKRwuV3iWYeW/LYMzNgaq3MaLffQ2xA== +"@types/node@^10.0.3": + version "10.17.60" + resolved "https://registry.yarnpkg.com/@types/node/-/node-10.17.60.tgz#35f3d6213daed95da7f0f73e75bcc6980e90597b" + integrity sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw== + "@types/normalize-package-data@^2.4.0": version "2.4.0" resolved "https://registry.yarnpkg.com/@types/normalize-package-data/-/normalize-package-data-2.4.0.tgz#e486d0d97396d79beedd0a6e33f4534ff6b4973e" @@ -1328,7 +1333,7 @@ capture-exit@^2.0.0: dependencies: rsvp "^4.8.4" -caseless@~0.12.0: +caseless@^0.12.0, caseless@~0.12.0: version "0.12.0" resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc" integrity sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw= @@ -1515,6 +1520,16 @@ concat-map@0.0.1: resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s= +concat-stream@^1.6.2: + version "1.6.2" + resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-1.6.2.tgz#904bdf194cd3122fc675c77fc4ac3d4ff0fd1a34" + integrity sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw== + dependencies: + buffer-from "^1.0.0" + inherits "^2.0.3" + readable-stream "^2.2.2" + typedarray "^0.0.6" + convert-source-map@^1.4.0, convert-source-map@^1.6.0, convert-source-map@^1.7.0: version "1.7.0" resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.7.0.tgz#17a2cb882d7f77d3490585e2ce6c524424a3a442" @@ -1537,6 +1552,11 @@ core-util-is@1.0.2: resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7" integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac= +core-util-is@~1.0.0: + version "1.0.3" + resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.3.tgz#a6042d3634c2b27e9328f837b965fac83808db85" + integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ== + cosmiconfig@^7.0.0: version "7.0.0" resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-7.0.0.tgz#ef9b44d773959cae63ddecd122de23853b60f8d3" @@ -2222,6 +2242,23 @@ html-escaper@^2.0.0: resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453" integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg== +http-basic@^8.1.3: + version "8.1.3" + resolved "https://registry.yarnpkg.com/http-basic/-/http-basic-8.1.3.tgz#a7cabee7526869b9b710136970805b1004261bbf" + integrity sha512-/EcDMwJZh3mABI2NhGfHOGOeOZITqfkEO4p/xK+l3NpyncIHUQBoMvCSF/b5GqvKtySC2srL/GGG3+EtlqlmCw== + dependencies: + caseless "^0.12.0" + concat-stream "^1.6.2" + http-response-object "^3.0.1" + parse-cache-control "^1.0.1" + +http-response-object@^3.0.1: + version "3.0.2" + resolved "https://registry.yarnpkg.com/http-response-object/-/http-response-object-3.0.2.tgz#7f435bb210454e4360d074ef1f989d5ea8aa9810" + integrity sha512-bqX0XTF6fnXSQcEJ2Iuyr75yVakyjIDCqroJQ/aHfSdlM743Cwqoi2nDYMzLGWUcuTWGWy8AAvOKXTfiv6q9RA== + dependencies: + "@types/node" "^10.0.3" + http-signature@~1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/http-signature/-/http-signature-1.2.0.tgz#9aecd925114772f3d95b65a60abb8f7c18fbace1" @@ -2301,7 +2338,7 @@ inflight@^1.0.4: once "^1.3.0" wrappy "1" -inherits@2: +inherits@2, inherits@^2.0.3, inherits@~2.0.3: version "2.0.4" resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== @@ -2525,7 +2562,7 @@ is-wsl@^2.2.0: dependencies: is-docker "^2.0.0" -isarray@1.0.0: +isarray@1.0.0, isarray@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11" integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE= @@ -3683,6 +3720,11 @@ parent-module@^1.0.0: dependencies: callsites "^3.0.0" +parse-cache-control@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/parse-cache-control/-/parse-cache-control-1.0.1.tgz#8eeab3e54fa56920fe16ba38f77fa21aacc2d74e" + integrity sha1-juqz5U+laSD+Fro493+iGqzC104= + parse-json@^5.0.0: version "5.1.0" resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.1.0.tgz#f96088cdf24a8faa9aea9a009f2d9d942c999646" @@ -3804,6 +3846,11 @@ pretty-format@^26.6.2: ansi-styles "^4.0.0" react-is "^17.0.1" +process-nextick-args@~2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2" + integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag== + prompts@^2.0.1: version "2.4.0" resolved "https://registry.yarnpkg.com/prompts/-/prompts-2.4.0.tgz#4aa5de0723a231d1ee9121c40fdf663df73f61d7" @@ -3881,6 +3928,19 @@ read-pkg@^5.2.0: parse-json "^5.0.0" type-fest "^0.6.0" +readable-stream@^2.2.2: + version "2.3.7" + resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.7.tgz#1eca1cf711aef814c04f62252a36a62f6cb23b57" + integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw== + dependencies: + core-util-is "~1.0.0" + inherits "~2.0.3" + isarray "~1.0.0" + process-nextick-args "~2.0.0" + safe-buffer "~5.1.1" + string_decoder "~1.1.1" + util-deprecate "~1.0.1" + regenerator-runtime@^0.13.4: version "0.13.7" resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.7.tgz#cac2dacc8a1ea675feaabaeb8ae833898ae46f55" @@ -4059,7 +4119,7 @@ safe-buffer@^5.0.1, safe-buffer@^5.1.2: resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6" integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== -safe-buffer@~5.1.1: +safe-buffer@~5.1.0, safe-buffer@~5.1.1: version "5.1.2" resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d" integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g== @@ -4395,6 +4455,13 @@ string-width@^4.1.0, string-width@^4.2.0: is-fullwidth-code-point "^3.0.0" strip-ansi "^6.0.0" +string_decoder@~1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8" + integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg== + dependencies: + safe-buffer "~5.1.0" + stringify-object@^3.3.0: version "3.3.0" resolved "https://registry.yarnpkg.com/stringify-object/-/stringify-object-3.3.0.tgz#703065aefca19300d3ce88af4f5b3956d7556629" @@ -4683,6 +4750,11 @@ typedarray-to-buffer@^3.1.5: dependencies: is-typedarray "^1.0.0" +typedarray@^0.0.6: + version "0.0.6" + resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777" + integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c= + typescript@^3.8.3: version "3.9.7" resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.9.7.tgz#98d600a5ebdc38f40cb277522f12dc800e9e25fa" @@ -4743,6 +4815,11 @@ use@^3.1.0: resolved "https://registry.yarnpkg.com/use/-/use-3.1.1.tgz#d50c8cac79a19fbc20f2911f56eb973f4e10070f" integrity sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ== +util-deprecate@~1.0.1: + version "1.0.2" + resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf" + integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8= + uuid@^3.3.2: version "3.4.0" resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.4.0.tgz#b23e4358afa8a202fe7a100af1f5f883f02007ee" From 46e315b1db9196f8c042751cef213dc6f3d51abb Mon Sep 17 00:00:00 2001 From: Forbes Lindesay Date: Mon, 13 Sep 2021 18:29:51 +0100 Subject: [PATCH 10/10] chore: remove custom `Buffer` --- packages/core/src/Buffer.ts | 82 ------------------- packages/core/src/index.ts | 13 --- .../http/src/initialRequest.integration.ts | 5 +- packages/http/src/initialRequest.ts | 6 +- packages/packfile/src/apply-delta.ts | 51 ++++++------ packages/packfile/src/types.ts | 2 +- 6 files changed, 37 insertions(+), 122 deletions(-) delete mode 100644 packages/core/src/Buffer.ts diff --git a/packages/core/src/Buffer.ts b/packages/core/src/Buffer.ts deleted file mode 100644 index 968e408..0000000 --- a/packages/core/src/Buffer.ts +++ /dev/null @@ -1,82 +0,0 @@ -export default class Buffer { - readonly data: Uint8Array; - private pointer = 0; - constructor(data: Uint8Array) { - this.data = data; - } - - get pos() { - return this.pointer; - } - - next(): number; - next(length: number): Uint8Array; - next(length?: number) { - if (length !== undefined) { - length = Math.min(length, this.data.length - this.pointer); - const result = this.data.subarray(this.pointer, this.pointer + length); - this.pointer += length; - return result; - } else { - return this.data[this.pointer++]; - } - } - - nextInt32(): number { - let result = 0; - for (let i = 0; i < 4; i++) { - result = (result << 8) | this.next(); - } - return result; - } - - peek(): number; - peek(length: number): Uint8Array; - peek(length?: number) { - if (length !== undefined) { - length = Math.min(length, this.data.length - this.pointer); - const result = this.data.subarray(this.pointer, this.pointer + length); - return result; - } else { - return this.data[this.pointer]; - } - } - - peekInt32(): number { - let result = 0; - for (let i = 0; i < 4; i++) { - result = (result << 8) | this.data[this.pointer + i]; - } - return result; - } - - write(byte: number): void; - write(bytes: Uint8Array): void; - write(bytes: Uint8Array, offset: number, length: number): void; - write(value: number | Uint8Array, offset?: number, length?: number) { - if (typeof value === 'number') { - this.data[this.pointer++] = value; - } else { - if (offset !== undefined) { - length = length === undefined ? value.length - offset : length; - this.data.set(value.subarray(offset, offset + length), this.pointer); - this.pointer += length; - } else { - this.data.set(value, this.pointer); - this.pointer += value.length; - } - } - } - - rest() { - return this.next(this.data.length - this.pointer); - } - - soFar() { - return this.data.subarray(0, this.pointer); - } - - get isDone() { - return this.pointer >= this.data.length; - } -} diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts index 77b090b..07167b1 100644 --- a/packages/core/src/index.ts +++ b/packages/core/src/index.ts @@ -1,4 +1,3 @@ -export {default as Buffer} from './Buffer'; export { decode, encode, @@ -50,16 +49,4 @@ export function toType(mode: number) { return Type.unknown; } -export interface IRawRepo { - listRefs(): Promise; - getRef(ref: string): Promise; - setRef(ref: string, hash: Hash): Promise; - deleteRef(ref: string): Promise; - saveRaw(hash: Hash, object: Uint8Array): Promise; - loadRaw(hash: Hash): Promise; - hasObject(hash: Hash): Promise; - saveMetadata(name: string, value: Uint8Array): Promise; - loadMetadata(name: string): Promise; -} - export type Hash = string; diff --git a/packages/http/src/initialRequest.integration.ts b/packages/http/src/initialRequest.integration.ts index c5410e6..38e6419 100644 --- a/packages/http/src/initialRequest.integration.ts +++ b/packages/http/src/initialRequest.integration.ts @@ -2,12 +2,15 @@ import initialRequest from './initialRequest'; import HttpProxy from './HttpProxy'; test('initialRequest', async () => { - const {capabilities} = await initialRequest( + const {url, capabilities} = await initialRequest( new URL( 'https://github.com/RollingVersions/test-single-npm-package-github-actions.git', ), {http: HttpProxy, agent: 'rollingversions.com'}, ); + expect(url.href).toBe( + `https://github.com/RollingVersions/test-single-npm-package-github-actions.git`, + ); expect(typeof capabilities.get('agent')).toBe('string'); expect(capabilities.get('ls-refs')).toBe(true); expect(capabilities.get('fetch')).toBe('shallow filter'); diff --git a/packages/http/src/initialRequest.ts b/packages/http/src/initialRequest.ts index a0180f3..e02ed1b 100644 --- a/packages/http/src/initialRequest.ts +++ b/packages/http/src/initialRequest.ts @@ -5,6 +5,7 @@ import { import Context from './Context'; export interface InitialResponse { + url: URL; capabilities: Capabilities; } export default async function initialRequest< @@ -38,5 +39,8 @@ export default async function initialRequest< console.log('response.url =', response.url.href); const capabilities = await parseInitialResponse(response.body); - return {capabilities}; + return { + url: new URL(response.url.href.split(`.git`)[0] + `.git`), + capabilities, + }; } diff --git a/packages/packfile/src/apply-delta.ts b/packages/packfile/src/apply-delta.ts index 43150c2..2330371 100644 --- a/packages/packfile/src/apply-delta.ts +++ b/packages/packfile/src/apply-delta.ts @@ -1,53 +1,56 @@ -import {Buffer} from '@rollingversions/git-core'; - -export default function applyDelta(delta: Uint8Array, base: Uint8Array) { - const input = new Buffer(delta); - - if (base.length !== readLength(input)) { +export default function applyDelta(delta: Buffer, base: Buffer) { + let [expectedBaseLength, index] = readLength(delta, 0); + if (base.length !== expectedBaseLength) { throw new Error('Base length mismatch'); } + let outputLength; + [outputLength, index] = readLength(delta, index); // Create a new output buffer with length from header. - const output = new Buffer(new Uint8Array(readLength(input))); + const output = Buffer.alloc(outputLength); - while (!input.isDone) { - const byte = input.next(); + let pointer = 0; + while (index < delta.length) { + const byte = delta[index++]; // Copy command. Tells us offset in base and length to copy. if (byte & 0x80) { let offset = 0; let length = 0; - if (byte & 0x01) offset |= input.next() << 0; - if (byte & 0x02) offset |= input.next() << 8; - if (byte & 0x04) offset |= input.next() << 16; - if (byte & 0x08) offset |= input.next() << 24; - if (byte & 0x10) length |= input.next() << 0; - if (byte & 0x20) length |= input.next() << 8; - if (byte & 0x40) length |= input.next() << 16; + if (byte & 0x01) offset |= delta[index++] << 0; + if (byte & 0x02) offset |= delta[index++] << 8; + if (byte & 0x04) offset |= delta[index++] << 16; + if (byte & 0x08) offset |= delta[index++] << 24; + if (byte & 0x10) length |= delta[index++] << 0; + if (byte & 0x20) length |= delta[index++] << 8; + if (byte & 0x40) length |= delta[index++] << 16; if (length === 0) length = 0x10000; // copy the data - output.write(base, offset, length); + output.set(base.slice(offset, offset + length), pointer); + pointer += length; } // Insert command, opcode byte is length itself else if (byte) { - output.write(input.next(byte)); + output.set(delta.slice(index, index + byte), pointer); + index += byte; + pointer += byte; } else throw new Error('Invalid delta opcode'); } - if (output.pos !== output.data.length) { + if (pointer !== output.length) { throw new Error('Size mismatch in check'); } - return output.data; + return output; } -function readLength(buffer: Buffer) { - let byte = buffer.next(); +function readLength(buffer: Buffer, index: number) { + let byte = buffer[index++]; let length = byte & 0x7f; let shift = 7; while (byte & 0x80) { - byte = buffer.next(); + byte = buffer[index++]; length |= (byte & 0x7f) << shift; shift += 7; } - return length; + return [length, index]; } diff --git a/packages/packfile/src/types.ts b/packages/packfile/src/types.ts index fffdd1f..ccdd8da 100644 --- a/packages/packfile/src/types.ts +++ b/packages/packfile/src/types.ts @@ -16,7 +16,7 @@ export enum GitObjectType { export interface PackfileEntry { readonly type: GitObjectTypeID; readonly offset: number; - readonly body: Uint8Array; + readonly body: Buffer; } export interface GitRawObject {